@tiens.nguyen/gonext-local-worker 1.0.271 → 1.0.272

package/gonext_agent_chat.py

@@ -1487,6 +1487,74 @@ def _pdf_upload_via_api(api_base: str, worker_key: str, file_name: str,
     return get_url
 
 
+# Generic download support (task #102) — deliver ANY workspace file/folder as a download.
+_DOWNLOAD_MAX_BYTES = 100 * 1024 * 1024  # 100 MB cap on what we'll upload for download
+_DOWNLOAD_CONTENT_TYPES = {
+    "pdf": "application/pdf", "zip": "application/zip", "json": "application/json",
+    "csv": "text/csv", "txt": "text/plain", "md": "text/markdown", "html": "text/html",
+    "htm": "text/html", "xml": "application/xml", "yaml": "application/x-yaml",
+    "yml": "application/x-yaml", "svg": "image/svg+xml", "png": "image/png",
+    "jpg": "image/jpeg", "jpeg": "image/jpeg", "gif": "image/gif", "sql": "application/sql",
+    "tar": "application/x-tar", "gz": "application/gzip", "tgz": "application/gzip",
+}
+
+
+def _content_type_for(name: str) -> str:
+    """Content-type by filename extension for create_download (matches the API's map)."""
+    ext = ""
+    if "." in (name or ""):
+        ext = name.rsplit(".", 1)[-1].strip().lower()
+    return _DOWNLOAD_CONTENT_TYPES.get(ext, "application/octet-stream")
+
+
+def _artifact_upload_via_api(api_base: str, worker_key: str, file_name: str,
+                             data: bytes, content_type: str = "") -> str:
+    """Presign a GENERIC S3 upload (any file type), PUT the bytes, return the download URL.
+    Like _pdf_upload_via_api but preserves the real extension + Content-Type. The PUT
+    Content-Type MUST match what the presign signed, so we send content_type in the presign
+    request and PUT with the value the API echoes back (task #102)."""
+    import urllib.error as _ue
+    import urllib.request as _u
+
+    ctx = _ssl_context()
+    base = (api_base or "").rstrip("/")
+    if not base or not worker_key:
+        raise RuntimeError("Download is not available: worker API base/key missing.")
+    req = _u.Request(
+        f"{base}/api/worker/artifact-upload-url",
+        data=json.dumps({"fileName": file_name, "contentType": content_type}).encode("utf-8"),
+        headers={"Content-Type": "application/json", "X-Worker-Key": worker_key},
+        method="POST",
+    )
+    try:
+        with _u.urlopen(req, timeout=30, context=ctx) as resp:
+            ref = json.loads(resp.read().decode("utf-8"))
+    except _ue.HTTPError as e:  # noqa: PERF203
+        detail = e.read().decode("utf-8", "replace")[:300]
+        raise RuntimeError(f"Could not get an upload URL (HTTP {e.code}): {detail}")
+    except _ue.URLError as e:
+        raise RuntimeError(
+            f"Could not reach the API at {base} to presign the upload "
+            f"({getattr(e, 'reason', e)}). Is the worker API deployed/online?"
+        )
+    put_url = ref.get("putUrl")
+    get_url = ref.get("getUrl")
+    if not put_url or not get_url:
+        raise RuntimeError("Upload URL response was incomplete.")
+    put_ct = ref.get("contentType") or content_type or "application/octet-stream"
+    put_req = _u.Request(put_url, data=data, headers={"Content-Type": put_ct}, method="PUT")
+    try:
+        with _u.urlopen(put_req, timeout=120, context=ctx) as up:
+            if up.status not in (200, 201, 204):
+                raise RuntimeError(f"S3 upload failed (HTTP {up.status}).")
+    except _ue.HTTPError as e:  # noqa: PERF203
+        detail = e.read().decode("utf-8", "replace")[:200]
+        raise RuntimeError(f"S3 upload failed (HTTP {e.code}): {detail}")
+    except _ue.URLError as e:
+        raise RuntimeError(f"S3 upload could not connect ({getattr(e, 'reason', e)}).")
+    return get_url
+
+
 def _format_text_for_pdf(text: str, title: str, base_url: str, api_key: str,
                          model_id: str, instruction: str = "") -> str:
     """Use the model to clean/structure raw text into well-formed Markdown for the PDF.
@@ -4094,6 +4162,106 @@ def run_agent_chat(cfg):
         _last_obs["text"] = out
         return out
 
+    @tool
+    def create_download(path: str, name: str = "") -> str:
+        """Package a workspace FILE or FOLDER into a downloadable file and return a download link. A FOLDER is zipped (skipping node_modules/.git/build/dist); a single FILE is offered as-is. Use this to hand the user a ZIP of a project you scaffolded, or to let them download any file you made with create_file (csv, json, a report, …).
+
+        Args:
+            path: the file or folder to package (a workspace path).
+            name: optional download name (e.g. "my-app.zip"); defaults to the file/folder name.
+        """
+        import os
+        if not pdf_api_base or not pdf_worker_key:
+            msg = "Error: download isn't available (the worker API base/key isn't configured)."
+            _last_obs["text"] = msg
+            return msg
+        try:
+            src = _rag_read_allowed((path or "").strip())
+        except Exception as e:  # noqa: BLE001
+            msg = f"Error: can't access that path ({e})."
+            _last_obs["text"] = msg
+            return msg
+        if not os.path.exists(src):
+            msg = f"Error: nothing exists at {path}."
+            _last_obs["text"] = msg
+            return msg
+        try:
+            import tempfile
+            import zipfile
+            if os.path.isdir(src):
+                base = os.path.basename(src.rstrip("/\\")) or "archive"
+                file_name = (name or f"{base}.zip").strip()
+                if not file_name.lower().endswith(".zip"):
+                    file_name += ".zip"
+                _emit({"type": "step", "text": f"Zipping {base}…"})
+                tmp = tempfile.NamedTemporaryFile(suffix=".zip", delete=False)
+                tmp.close()
+                total = 0
+                files = 0
+                try:
+                    with zipfile.ZipFile(tmp.name, "w", zipfile.ZIP_DEFLATED) as zf:
+                        for root, dirs, filenames in os.walk(src):
+                            dirs[:] = [
+                                d for d in dirs
+                                if d not in _RAG_SKIP_DIRS and not d.startswith(".")
+                            ]
+                            for fn in filenames:
+                                fp = os.path.join(root, fn)
+                                try:
+                                    total += os.path.getsize(fp)
+                                except OSError:
+                                    continue
+                                if total > _DOWNLOAD_MAX_BYTES:
+                                    raise RuntimeError(
+                                        f"folder is too large to zip "
+                                        f"(> {_DOWNLOAD_MAX_BYTES // (1024 * 1024)} MB)"
+                                    )
+                                zf.write(fp, os.path.join(base, os.path.relpath(fp, src)))
+                                files += 1
+                    if files == 0:
+                        msg = (f"Nothing to zip in {path} "
+                               "(no files after skipping node_modules/.git/build/dist).")
+                        _last_obs["text"] = msg
+                        return msg
+                    with open(tmp.name, "rb") as fh:
+                        data = fh.read()
+                finally:
+                    try:
+                        os.unlink(tmp.name)
+                    except OSError:
+                        pass
+                content_type = "application/zip"
+                summary = f"{files} file(s)"
+            else:
+                size = os.path.getsize(src)
+                if size > _DOWNLOAD_MAX_BYTES:
+                    msg = (f"Error: {os.path.basename(src)} is too large to share "
+                           f"(> {_DOWNLOAD_MAX_BYTES // (1024 * 1024)} MB).")
+                    _last_obs["text"] = msg
+                    return msg
+                file_name = (name or os.path.basename(src)).strip() or "file"
+                with open(src, "rb") as fh:
+                    data = fh.read()
+                content_type = _content_type_for(file_name)
+                summary = f"{size} bytes"
+            _emit({"type": "step", "text": "Uploading…"})
+            url = _artifact_upload_via_api(
+                pdf_api_base, pdf_worker_key, file_name, data, content_type
+            )
+            out = (
+                f"✅ \"{file_name}\" is ready ({summary}).\n"
+                f"Download it here (link valid for a limited time):\n{url}"
+            )
+            _emit({"type": "step", "text": f"Download ready → {file_name}"})
+            _log(f"create_download ok name={file_name!r} bytes={len(data)}")
+            _last_obs["text"] = out
+            return out
+        except Exception as e:  # noqa: BLE001
+            _log(f"create_download error: {type(e).__name__}: {e!r}")
+            msg = f"Error: couldn't create the download ({str(e)[:200]})."
+            _last_obs["text"] = msg
+            return msg
+
     # Growing record of this turn's steps, persisted to disk after each one via
     # _write_turn_checkpoint (inside step_callback below) — see _load_and_clear_turn_
     # checkpoint above for how a crashed/interrupted turn gets recovered on the next run.
@@ -5845,7 +6013,7 @@ def run_agent_chat(cfg):
                 return msg
 
         agent_tools = [http_request, web_search, fetch_url, calculate,
-                       get_current_datetime, create_pdf]
+                       get_current_datetime, create_pdf, create_download]
         # Only register the PDF reader / email / RAG tools when available — the model
         # never sees a tool it can't run, since the task-hint's tool list (filled in just
         # below) is generated FROM this exact list, so it's always in sync by construction.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.271",
+  "version": "1.0.272",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",