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

package/gonext-local-worker.mjs

@@ -2020,6 +2020,71 @@ function normalizeBaseUrl(raw) {
   return typeof raw === "string" ? raw.trim().replace(/\/+$/, "") : "";
 }
 
+/**
+ * "Load Models" (task #44): probe the agent coding-model server's model list. Tries the
+ * OpenAI-compatible /v1/models (MLX + Ollama both serve it) and falls back to Ollama's
+ * /api/tags. The server is on the user's network, so only this worker can reach it. The
+ * job's resultText is JSON {models:[...]} the web parses into checkboxes.
+ */
+async function runListModelsJob(job) {
+  const { jobId, payload } = job;
+  const start = Date.now();
+  const runRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ jobStatus: "running" }),
+  });
+  await ensureWorkerOk(runRes, `mark running list_models jobId=${jobId}`);
+  try {
+    const base = normalizeBaseUrl(payload?.url).replace(/\/v1$/i, "");
+    if (!base) throw new Error("No coding-model URL provided.");
+    const models = new Set();
+    // 1) OpenAI-compatible /v1/models → { data: [{ id }] }
+    try {
+      const r = await fetch(`${base}/v1/models`, { method: "GET" });
+      if (r.ok) {
+        const j = await r.json().catch(() => ({}));
+        for (const m of Array.isArray(j?.data) ? j.data : []) {
+          if (typeof m?.id === "string" && m.id.trim()) models.add(m.id.trim());
+        }
+      }
+    } catch {
+      /* try the Ollama shape next */
+    }
+    // 2) Ollama /api/tags → { models: [{ name }] }
+    if (models.size === 0) {
+      const r = await fetch(`${base}/api/tags`, { method: "GET" });
+      if (r.ok) {
+        const j = await r.json().catch(() => ({}));
+        for (const m of Array.isArray(j?.models) ? j.models : []) {
+          if (typeof m?.name === "string" && m.name.trim()) models.add(m.name.trim());
+        }
+      }
+    }
+    const list = Array.from(models).sort();
+    const doneRes = await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "completed",
+        resultText: JSON.stringify({ models: list }),
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    });
+    await ensureWorkerOk(doneRes, `complete list_models jobId=${jobId}`);
+    console.log(`[gonext-worker] list_models ${jobId}: ${list.length} model(s) from ${base}`);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    await workerFetch(`/api/worker/jobs/${jobId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        jobStatus: "failed",
+        errorMessage: `Could not list models: ${message}`,
+        totalTimeSeconds: (Date.now() - start) / 1000,
+      }),
+    }).catch(() => {});
+    console.error(`[gonext-worker] failed list_models ${jobId}:`, message);
+  }
+}
+
 function normalizeOpenAiV1Root(raw) {
   const base = normalizeBaseUrl(raw);
   if (!base) return "";
@@ -2601,6 +2666,10 @@ async function pollOnce() {
       await runHttpProbeJob(job);
       return;
     }
+    if (job.jobType === "list_models") {
+      await runListModelsJob(job);
+      return;
+    }
     if (job.jobType === "agent_chat") {
       await runAgentChatJob(job);
       return;

package/gonext-repl.mjs

@@ -21,7 +21,7 @@
  * interrupted investigation actually resumes it). /reset clears it.
  *
  * Requires the worker daemon to be running (it claims the job).
- * Commands: /exit  /reset  /revert [runId]  /help      Ctrl-C stops following the current run.
+ * Commands: /exit  /model  /reset  /revert [runId]  /help   Ctrl-C stops following the current run.
  */
 import { readFile, mkdir, writeFile, unlink } from "node:fs/promises";
 import { existsSync, statSync, readFileSync } from "node:fs";
@@ -119,7 +119,7 @@ if (argv.includes("--help") || argv.includes("-h")) {
       "  -v, --verbose   show the agent's diagnostic logs ([gonext-agent] …) and python stderr\n" +
       "  -h, --help      this help\n\n" +
       "Auth comes from ~/.gonext/worker.env; models/budgets/RAG come from your web Settings.\n" +
-      "Inside the REPL: /exit · /reset · /revert [runId] · /help — Ctrl-C stops following a turn.\n" +
+      "Inside the REPL: /exit · /model · /reset · /revert [runId] · /help — Ctrl-C stops following a turn.\n" +
       "Questions are enqueued like web questions and executed by the RUNNING\n" +
       "gonext-local-worker daemon — its terminal shows the full [gonext-agent] logs.\n" +
       "Conversation history is saved per-folder in ~/.gonext/sessions and resumed next time\n" +
@@ -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;
@@ -193,6 +201,19 @@ rl.on("line", (l) => {
     _lineQueue.push(clean);
   }
 });
+// Neutralize navigation keys (↑/↓ history recall, ←/→ cursor, Home/End, etc.) during a
+// turn: echo is already muted, but readline still recalls history into the invisible
+// buffer on ↑/↓ — reset the line state after every keypress so nothing accumulates or
+// moves. Ctrl+C is unaffected (readline emits its SIGINT before this handler runs).
+if (process.stdin.isTTY) {
+  process.stdin.on("keypress", () => {
+    if (following) {
+      rl.line = "";
+      rl.cursor = 0;
+      rl.historyIndex = -1;
+    }
+  });
+}
 rl.on("close", () => {
   _stdinClosed = true;
   if (_lineWaiter) {
@@ -246,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;
   }
@@ -268,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"))
   );
 }
 
@@ -302,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"));
@@ -327,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) {
@@ -335,9 +406,57 @@ 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 ----------
+// /model command: fetch the allowed coding models (default + web-curated whitelist),
+// show a numbered picker, and set sessionCodingModel to the choice for this session.
+async function chooseModel() {
+  let probe;
+  try {
+    probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);
+  } catch (err) {
+    console.log(red(`  couldn't load models: ${err.message}\n`));
+    return;
+  }
+  const allowed = Array.isArray(probe?.codingAllowed) ? probe.codingAllowed : [];
+  const def = (probe?.codingDefault ?? "").trim();
+  if (allowed.length === 0) {
+    console.log(dim("  No coding model configured. Set one in the web app → Settings → Agent.\n"));
+    return;
+  }
+  if (allowed.length === 1) {
+    console.log(
+      dim(`  Only one coding model is available: ${allowed[0]}.\n`) +
+        dim("  Add more in the web app → Settings → Agent → Load Models (checkboxes).\n")
+    );
+    return;
+  }
+  const active = sessionCodingModel || def;
+  console.log(dim("  Choose the coding model for this session:"));
+  allowed.forEach((m, i) => {
+    const mark = m === active ? green(" ●") : "  ";
+    const tag = m === def ? dim(" (default)") : "";
+    console.log(`   ${mark} ${i + 1}. ${m}${tag}`);
+  });
+  const pick = (await ask(dim("  number (or Enter to keep current): "))).trim();
+  if (!pick) {
+    console.log("");
+    return;
+  }
+  const idx = Number.parseInt(pick, 10) - 1;
+  if (!Number.isInteger(idx) || idx < 0 || idx >= allowed.length) {
+    console.log(red("  invalid choice.\n"));
+    return;
+  }
+  const chosen = allowed[idx];
+  // Empty override means "use the account default" — so don't send an override when the
+  // user picks the default (keeps the payload clean and lets a later default change win).
+  sessionCodingModel = chosen === def ? "" : chosen;
+  console.log(green(`  ✓ coding model → ${chosen}${chosen === def ? " (default)" : ""}\n`));
+}
+
 async function fetchAgentPayload(messages) {
   const res = await fetch(`${apiBase}/api/worker/agent-payload`, {
     method: "POST",
@@ -370,6 +489,9 @@ let following = false;
 let followAborted = false;
 let currentJobId = null; // the running turn's jobId — so Ctrl+C can cancel it server-side
 let cancelRequested = false; // a cancel POST has been sent for the current turn
+// Per-session coding-model override chosen via /model (empty = use the account default).
+// Sent to /agent-ask as codingModelOverride; the API validates it against the whitelist.
+let sessionCodingModel = "";
 
 // While a turn runs, mute readline's own echo/redraws so keystrokes can't corrupt the
 // live status display and there's no way to type a new question — only Ctrl+C works.
@@ -381,6 +503,15 @@ rl._writeToOutput = (s) => {
   if (_origWriteToOutput) _origWriteToOutput(s);
   else process.stdout.write(s);
 };
+// _writeToOutput only mutes echoed TEXT; readline's line refresh writes cursor-position
+// + erase escapes (e.g. ESC[1G, ESC[0J) straight to output on every keypress, which
+// would corrupt our live status display. No-op it during a turn so a keypress produces
+// ZERO terminal output.
+const _origRefreshLine = rl._refreshLine ? rl._refreshLine.bind(rl) : null;
+rl._refreshLine = () => {
+  if (following) return;
+  if (_origRefreshLine) _origRefreshLine();
+};
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -397,8 +528,12 @@ async function runAgentTurn(history) {
     method: "POST",
     headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
     // cwd = this terminal's folder → agent puts download/unzip output here (when it's
-    // a registered workspace).
-    body: JSON.stringify({ messages: history, cwd: resolve(process.cwd()) }),
+    // a registered workspace). codingModelOverride = the /model choice for this session.
+    body: JSON.stringify({
+      messages: history,
+      cwd: resolve(process.cwd()),
+      ...(sessionCodingModel ? { codingModelOverride: sessionCodingModel } : {}),
+    }),
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
@@ -421,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
@@ -673,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") {
@@ -813,12 +982,17 @@ async function main() {
     if (line === "/help") {
       console.log(
         dim(
-          "  /exit — quit · /revert [runId] — undo the agent's file edits (latest run) · " +
+          "  /exit — quit · /model — switch the coding model for this session · " +
+            "/revert [runId] — undo the agent's file edits (latest run) · " +
             "/reset — forget this folder's saved conversation and start fresh"
         )
       );
       continue;
     }
+    if (line === "/model") {
+      await chooseModel();
+      continue;
+    }
     if (line === "/reset" || line === "/new") {
       history.length = 0;
       await clearSession(cwd);

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.205",
+  "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",