@tiens.nguyen/gonext-local-worker 1.0.206 → 1.0.207

package/gonext-repl.mjs

@@ -172,6 +172,14 @@ rl.setPrompt(PROMPT);
 // final-byte) from every submitted line so stray arrow-key presses can't corrupt task
 // text sent to the model.
 const stripAnsiEscapes = (s) => String(s ?? "").replace(/\x1b\[[0-9;]*[A-Za-z~]/g, "");
+// A fetch() failure (DNS, connection reset, timeout) throws rather than returning a
+// response — recognize it so the poll loop can treat it as a transient blip, not a hard
+// stop. Node's fetch throws a TypeError ("fetch failed") wrapping the socket error.
+const isNetworkError = (e) =>
+  e instanceof TypeError ||
+  /fetch failed|network|ECONN|ETIMEDOUT|EAI_AGAIN|socket hang up|und_err|terminated/i.test(
+    String(e?.message ?? e)
+  );
 const _lineQueue = [];
 let _lineWaiter = null;
 let _stdinClosed = false;
@@ -259,8 +267,20 @@ async function ensureWorkspace() {
   const list = await readWorkspaces();
   const hit = list.find((w) => cwd === w.path || cwd.startsWith(w.path + "/"));
   if (hit) {
+    // Registered before cloud sync existed → ask once and persist. Otherwise honor the
+    // stored choice. (undefined = old record that never opted in → ask.)
+    if (hit.allowSync === undefined) {
+      hit.allowSync = await askYesNo(
+        "Allow syncing this workspace's chat history to the cloud?", true
+      );
+      await writeFile(WS_FILE, JSON.stringify({ workspaces: list }, null, 2) + "\n");
+    }
+    wsSync = { enabled: hit.allowSync !== false, name: hit.name, path: hit.path };
     console.log(
-      dim(`workspace: ${hit.name} → ${hit.path} (run ${hit.allowRun ? "enabled" : "disabled"})`)
+      dim(
+        `workspace: ${hit.name} → ${hit.path} (run ${hit.allowRun ? "enabled" : "disabled"}` +
+          `${hit.allowSync !== false ? ", cloud sync on" : ""})`
+      )
     );
     return;
   }
@@ -281,18 +301,26 @@ async function ensureWorkspace() {
             still allowlisted (npm/mvn/pytest/…) and run with a scrubbed env. Type n to
             keep a workspace read/edit-only. */
   );
+  const allowSync = await askYesNo(
+    "Allow syncing this workspace's chat history to the cloud?\n" +
+      "(your conversation is saved to your account so you can see it on the web app)",
+    true /* default Yes — RAG is NOT synced (it stays on your S3); only chat history. */
+  );
   const next = list.filter((w) => w.path !== cwd);
   next.push({
     name: basename(cwd),
     path: cwd,
     allowRun,
+    allowSync,
     addedAt: new Date().toISOString(),
   });
   await mkdir(dirname(WS_FILE), { recursive: true });
   await writeFile(WS_FILE, JSON.stringify({ workspaces: next }, null, 2) + "\n");
+  wsSync = { enabled: allowSync, name: basename(cwd), path: cwd };
   console.log(
     green(`✓ workspace registered: ${basename(cwd)}`) +
-      (allowRun ? green(" (run-commands enabled)") : dim(" (run-commands disabled)"))
+      (allowRun ? green(" (run-commands enabled)") : dim(" (run-commands disabled)")) +
+      (allowSync ? green(" · cloud sync on") : dim(" · cloud sync off"))
   );
 }
 
@@ -315,6 +343,34 @@ function sessionFilePath(cwd) {
 // for a long-lived folder with no benefit.
 const MAX_PERSISTED_MESSAGES = 40;
 
+// Cloud sync (task #47), opt-in per workspace. Set by ensureWorkspace() for the current
+// folder; when enabled, saveSession/clearSession also mirror the chat history to Mongo
+// via the worker-authed /api/worker/workspace-sync. RAG is NOT synced (stays on S3).
+let wsSync = { enabled: false, name: "", path: "" };
+const workspaceKeyFor = (cwd) =>
+  createHash("sha256").update(cwd).digest("hex").slice(0, 32);
+
+async function pushWorkspaceSync(cwd, history, { del = false } = {}) {
+  if (!wsSync.enabled) return;
+  const body = del
+    ? { workspaceKey: workspaceKeyFor(cwd), delete: true }
+    : {
+        workspaceKey: workspaceKeyFor(cwd),
+        name: wsSync.name || basename(cwd),
+        path: cwd,
+        history: history.slice(-MAX_PERSISTED_MESSAGES),
+      };
+  try {
+    await fetch(`${apiBase}/api/worker/workspace-sync`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+      body: JSON.stringify(body),
+    });
+  } catch {
+    // Best-effort — a cloud-sync blip must never block the REPL (local save already done).
+  }
+}
+
 async function loadSession(cwd) {
   try {
     const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
@@ -340,6 +396,8 @@ async function saveSession(cwd, history) {
     // Non-fatal — losing session persistence should never crash or block the REPL.
     console.error(dim(`(session save failed: ${err.message})`));
   }
+  // Mirror to the cloud AFTER the local write (fire-and-forget; opt-in via wsSync).
+  void pushWorkspaceSync(cwd, history);
 }
 
 async function clearSession(cwd) {
@@ -348,6 +406,7 @@ async function clearSession(cwd) {
   } catch {
     // Nothing on disk to clear — fine.
   }
+  void pushWorkspaceSync(cwd, [], { del: true }); // /reset removes the cloud copy too
 }
 
 // ---------- fetch the ready-to-run agent payload from user settings ----------
@@ -497,6 +556,11 @@ async function runAgentTurn(history) {
   let carry = ""; // trailing partial content line held until its newline arrives
   let statusShown = false; // a transient status line is currently on screen
   let warnedPending = false;
+  // Transient poll failures (a network blip or a 5xx like the API's momentary "Worker
+  // key lookup failed." — a cold Mongo connection, NOT a bad key) must NOT kill a
+  // long-running turn. Tolerate a run of them; only give up after too many in a row.
+  let pollFailures = 0;
+  const MAX_POLL_FAILURES = 6; // ~6 tries with backoff before conceding the follow
   let jobRunning = false; // only tick "thinking…" once the worker has claimed the job
   let answerShownLive = false; // plain-reply content already printed — don't re-print it
   // True once we've SPECIFICALLY seen "→ Chat reply" (the plain-reply/trivial-chat
@@ -749,11 +813,40 @@ async function runAgentTurn(history) {
         );
         return { text: "", shown: false };
       }
-      const jr = await fetch(`${apiBase}/api/worker/jobs/${jobId}`, {
-        headers: { "X-Worker-Key": workerKey },
-      });
-      const job = await jr.json().catch(() => ({}));
-      if (!jr.ok) throw new Error(job?.error || `job poll failed (HTTP ${jr.status})`);
+      let job;
+      try {
+        const jr = await fetch(`${apiBase}/api/worker/jobs/${jobId}`, {
+          headers: { "X-Worker-Key": workerKey },
+        });
+        const parsed = await jr.json().catch(() => ({}));
+        if (jr.ok) {
+          job = parsed;
+          pollFailures = 0; // a clean poll resets the tolerance window
+        } else if (jr.status >= 400 && jr.status < 500) {
+          // Client error (bad/expired key, job genuinely gone) — NOT transient, fail fast.
+          throw new Error(parsed?.error || `job poll failed (HTTP ${jr.status})`);
+        } else {
+          // 5xx — a momentary server/DB blip (e.g. "Worker key lookup failed."). Transient.
+          throw Object.assign(
+            new Error(parsed?.error || `job poll failed (HTTP ${jr.status})`),
+            { transient: true }
+          );
+        }
+      } catch (err) {
+        // A fetch/network exception has no HTTP status — treat it as transient too.
+        const transient = err?.transient === true || isNetworkError(err);
+        if (!transient) throw err;
+        pollFailures += 1;
+        if (pollFailures >= MAX_POLL_FAILURES) {
+          clearStatus();
+          throw new Error(
+            `lost contact with the API after ${pollFailures} tries (${String(err.message).slice(0, 80)}). ` +
+              "The turn may still be running on the worker — try 'continue'."
+          );
+        }
+        await sleep(Math.min(700 * pollFailures, 3000)); // linear backoff, capped at 3s
+        continue;
+      }
       jobRunning = job.jobStatus === "running";
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {

package/gonext_agent_chat.py

@@ -1891,6 +1891,19 @@ def _ws_for_path(path: str):
     return None
 
 
+def _default_ws_root() -> str:
+    """The folder a tool defaults to when the model passes NO path/workdir: the terminal's
+    ACTIVE folder (where `gonext` was launched), NOT the first-registered workspace.
+    Registered workspaces accumulate across sessions, so falling back to _WS_ROOTS[0]
+    made a no-workdir command land in an OLD workspace (bug #46: launched in t9, created
+    the project in t1). Falls back to the first workspace only when there is no active
+    folder at all."""
+    import os
+    if _WS_ACTIVE and os.path.isdir(_WS_ACTIVE):
+        return _WS_ACTIVE
+    return _WS_ROOTS[0]["path"] if _WS_ROOTS else "."
+
+
 def _workspace_overview(roots, max_entries: int = 40) -> str:
     """Cheap, LOCAL top-level listing of each registered workspace root — a plain
     os.listdir(), no recursion, no network call, no model call. Used two ways: (1)
@@ -2744,14 +2757,33 @@ def run_agent_chat(cfg):
         "If the user adds information, rag_add(source_url=url, text=...).\n"
     ) if _RAG_AVAILABLE else ""
     _ws_names = ", ".join(f"{w['name']} = {w['path']}" for w in _WS_ROOTS)
+    # The folder the terminal is OPEN in (where `gonext` was launched). This is where the
+    # user means "here"/"this workspace" and where a no-path/no-workdir tool call defaults
+    # (see _default_ws_root). Registered workspaces accumulate over time, so WITHOUT this
+    # the model would pick an arbitrary/old one (bug #46: opened in t9, built in t1).
+    _active_ws = _ws_for_path(_WS_ACTIVE) if _WS_ACTIVE else None
+    _active_label = (
+        f"{_active_ws['name']} = {_WS_ACTIVE}" if _active_ws else (_WS_ACTIVE or "")
+    )
+    _ws_current_line = (
+        f"  CURRENT folder — the terminal is open HERE; default ALL create/edit/run/"
+        f"download operations to THIS folder unless the user EXPLICITLY names another "
+        f"workspace: {_active_label}\n"
+        if _active_label else ""
+    )
     # Upfront, ZERO-COST (no tool call, no model round-trip) top-level listing — so the
     # agent already knows the workspace is non-empty and roughly what's in it before its
     # first step, instead of having to spend (and risk losing to a timeout) a whole
-    # round-trip just calling list_dir to discover that.
-    _ws_overview = _workspace_overview(_WS_ROOTS) if _WS_AVAILABLE else ""
+    # round-trip just calling list_dir to discover that. Only the CURRENT folder (not every
+    # accumulated workspace) — to keep the model anchored on where it should act.
+    _overview_roots = (
+        [_active_ws] if _active_ws else _WS_ROOTS
+    ) if _WS_AVAILABLE else []
+    _ws_overview = _workspace_overview(_overview_roots) if _overview_roots else ""
     _ws_tool_block = (
-        f"  WORKSPACES (local code folders you may READ and EDIT): {_ws_names}\n"
-        f"  Current contents:\n"
+        _ws_current_line
+        + f"  Other registered workspaces (use only if the user names them): {_ws_names}\n"
+        f"  Current folder contents:\n"
         + "\n".join(f"    {line}" for line in _ws_overview.splitlines()) + "\n"
         "    - list_dir(path) / read_text_file(path) — browse and read files.\n"
         "    - grep_repo(pattern, path='', glob='') — search code, returns file:line hits. "
@@ -4085,7 +4117,7 @@ def run_agent_chat(cfg):
             try:
                 import fnmatch
                 import os
-                root = _rag_read_allowed((path or "").strip() or (_WS_ROOTS[0]["path"] if _WS_ROOTS else "."))
+                root = _rag_read_allowed((path or "").strip() or _default_ws_root())
                 try:
                     rx = re.compile(pattern)
                 except re.error:
@@ -4330,7 +4362,7 @@ def run_agent_chat(cfg):
                 import signal
                 import subprocess
                 import time as _t
-                wd = _rag_read_allowed((workdir or "").strip() or (_WS_ROOTS[0]["path"] if _WS_ROOTS else "."))
+                wd = _rag_read_allowed((workdir or "").strip() or _default_ws_root())
                 w = _ws_for_path(wd)
                 if w is None or not w.get("allowRun"):
                     msg = ("Error: running commands is not enabled for this workspace. "

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.206",
+  "version": "1.0.207",
   "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",