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

package/gonext-local-worker.mjs

@@ -867,7 +867,7 @@ async function performHttpMeasurement(params) {
  * line as they arrive. Resolves when the process exits cleanly; rejects on
  * non-zero exit or timeout. stderr is collected and appended to error messages.
  */
-function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine, extraEnv) {
+function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine, extraEnv, abortSignal) {
   return new Promise((resolve, reject) => {
     const spawnOpts = { stdio: ["pipe", "pipe", "pipe"] };
     if (extraEnv && Object.keys(extraEnv).length > 0) {
@@ -877,10 +877,23 @@ function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine
     let stderr = "";
     let lineBuffer = "";
     let timedOut = false;
+    let aborted = false;
     const timer = setTimeout(() => {
       timedOut = true;
       child.kill("SIGKILL");
     }, timeoutMs);
+    // User-requested cancel (gonext Ctrl+C): kill the Python agent so it stops burning
+    // steps/tokens. On close we resolve cleanly (not reject) — the caller checks the
+    // cancel flag and leaves the job in its already-"cancelled" state.
+    const onAbort = () => {
+      if (aborted) return;
+      aborted = true;
+      child.kill("SIGKILL");
+    };
+    if (abortSignal) {
+      if (abortSignal.aborted) onAbort();
+      else abortSignal.addEventListener("abort", onAbort, { once: true });
+    }
     child.stdout.on("data", (d) => {
       lineBuffer += d.toString("utf8");
       const parts = lineBuffer.split("\n");
@@ -905,6 +918,7 @@ function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine
     });
     child.on("close", (code) => {
       clearTimeout(timer);
+      if (abortSignal) abortSignal.removeEventListener?.("abort", onAbort);
       // Drain any remaining buffered line
       const remaining = lineBuffer.trim();
       if (remaining) {
@@ -914,6 +928,10 @@ function runProcessWithStreamingStdout(cmd, cmdArgs, stdinStr, timeoutMs, onLine
           /* ignore */
         }
       }
+      if (aborted) {
+        resolve(); // cancelled by the user — a clean stop, not an error
+        return;
+      }
       if (timedOut) {
         reject(new Error(`agent chat timed out after ${timeoutMs} ms`));
         return;
@@ -1686,6 +1704,12 @@ function trackCodingModelForWarmup(codingBaseURL, codingModelId) {
 async function runAgentChatJob(job) {
   const { jobId, payload } = job;
   const start = Date.now();
+  // User-requested cancel (gonext Ctrl+C): the REPL marks the job "cancelled" via the
+  // API; a poll below (and the job-chunk 409 path) trips this controller, which kills
+  // the Python agent. `cancelled` is checked at the finish so we DON'T overwrite the
+  // "cancelled" status with completed/failed.
+  const cancelAc = new AbortController();
+  let cancelled = false;
   // Remember this job's Ollama coding model and keep it resident via a background
   // interval. Only warms now if the model is new/changed — repeat questions rely on
   // the interval, so we don't re-warm (or re-log) on every question.
@@ -1713,8 +1737,12 @@ async function runAgentChatJob(job) {
     });
     if (!res.ok && res.status !== 204) {
       const snippet = (await res.text().catch(() => "")).trim().slice(0, 400);
+      const cancelledNow =
+        res.status === 409 && snippet.includes('"jobStatus":"cancelled"');
+      if (cancelledNow) cancelAc.abort(); // REPL cancelled mid-run → stop the Python agent
       const benign409 =
-        res.status === 409 && snippet.includes('"jobStatus":"completed"');
+        res.status === 409 &&
+        (snippet.includes('"jobStatus":"completed"') || cancelledNow);
       if (!benign409) {
         console.error(
           `[gonext-worker] agent_chat job-chunk POST failed status=${res.status} jobId=${jobId}` +
@@ -1848,6 +1876,28 @@ async function runAgentChatJob(job) {
       pdfEnv = { DYLD_FALLBACK_LIBRARY_PATH: merged };
     }
 
+    // Poll our own job status during the run so a REPL Ctrl+C (which marks the job
+    // "cancelled" via the API) actually stops the Python agent within ~1.5s, instead of
+    // only being noticed on the next chunk flush (which can be 45s apart during a long
+    // model call). The job-chunk 409 path (flushChunks) is the backup signal.
+    const cancelPoll = setInterval(async () => {
+      if (cancelAc.signal.aborted) return;
+      try {
+        const r = await workerFetch(`/api/worker/jobs/${jobId}`);
+        if (r.ok) {
+          const j = await r.json().catch(() => ({}));
+          if (j?.jobStatus === "cancelled") {
+            cancelled = true;
+            cancelAc.abort();
+          }
+        }
+      } catch {
+        /* transient poll error — try again next tick */
+      }
+    }, 1500);
+    cancelAc.signal.addEventListener("abort", () => { cancelled = true; }, { once: true });
+
+    try {
     await runProcessWithStreamingStdout(python, [scriptPath], input, timeoutMs, (event) => {
       if (event.type === "log" && typeof event.text === "string") {
         console.log(`[gonext-agent] ${event.text}`);
@@ -1901,7 +1951,19 @@ async function runAgentChatJob(job) {
           enqueueText(event.text);
         }
       }
-    }, pdfEnv);
+    }, pdfEnv, cancelAc.signal);
+    } finally {
+      clearInterval(cancelPoll);
+    }
+
+    // User cancelled mid-run: the Python child was SIGKILLed and the job is already
+    // "cancelled" in the store. Leave it there — do NOT PATCH completed/failed (which
+    // would resurrect a finished status) and skip the final chunk flush (it'd 409).
+    if (cancelled || cancelAc.signal.aborted) {
+      if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+      console.log(`[gonext-worker] agent_chat ${jobId} cancelled by user`);
+      return;
+    }
 
     closeStreamFence();
     if (inThink) {
@@ -1926,6 +1988,12 @@ async function runAgentChatJob(job) {
     console.log(`[gonext-worker] completed agent_chat ${jobId} (${totalTimeSeconds.toFixed(1)}s)`);
   } catch (e) {
     if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    // A cancel that raced into the catch (e.g. the kill surfaced as an error before the
+    // aborted-close path): the job is already "cancelled" — don't overwrite with failed.
+    if (cancelled || cancelAc.signal.aborted) {
+      console.log(`[gonext-worker] agent_chat ${jobId} cancelled by user`);
+      return;
+    }
     await flushTail;
     await flushChunks().catch(() => {});
     const message = e instanceof Error ? e.message : String(e);
@@ -1952,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 "";
@@ -2533,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" +
@@ -176,6 +176,14 @@ const _lineQueue = [];
 let _lineWaiter = null;
 let _stdinClosed = false;
 rl.on("line", (l) => {
+  // While a turn is running, IGNORE typed input entirely — no type-ahead, no queued
+  // next question. Only Ctrl+C (handled via SIGINT) does anything mid-turn. Clear the
+  // line buffer so nothing the user typed leaks into the next prompt.
+  if (following) {
+    rl.line = "";
+    rl.cursor = 0;
+    return;
+  }
   const clean = stripAnsiEscapes(l);
   if (_lineWaiter) {
     const w = _lineWaiter;
@@ -185,6 +193,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) {
@@ -330,6 +351,53 @@ async function clearSession(cwd) {
 }
 
 // ---------- 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",
@@ -360,6 +428,31 @@ async function fetchAgentPayload(messages) {
 // [gonext-agent] logs. We poll the job here and stream the persisted chunks live.
 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.
+// Same _writeToOutput override password prompts use; our UI (prompt, status, bullets)
+// writes to stdout directly, so it's unaffected — only readline's echo is swallowed.
+const _origWriteToOutput = rl._writeToOutput ? rl._writeToOutput.bind(rl) : null;
+rl._writeToOutput = (s) => {
+  if (following) return;
+  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));
 
@@ -376,8 +469,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) {
@@ -393,6 +490,8 @@ async function runAgentTurn(history) {
 
   following = true;
   followAborted = false;
+  currentJobId = jobId;
+  cancelRequested = false;
   const startedAt = Date.now();
   let shownChars = 0;
   let carry = ""; // trailing partial content line held until its newline arrives
@@ -668,9 +767,17 @@ async function runAgentTurn(history) {
         consume(text.slice(shownChars));
         shownChars = text.length;
       }
-      if (job.jobStatus === "failed" || job.jobStatus === "cancelled") {
+      if (job.jobStatus === "cancelled") {
+        // User-requested stop (Ctrl+C) — a clean outcome, not an error. The worker has
+        // killed the Python agent. Print a quiet note and return an empty, non-persisted
+        // turn (main() drops it from history).
+        clearStatus();
+        process.stdout.write(dim("\n(cancelled — the agent was stopped)\n"));
+        return { text: "", shown: false, cancelled: true };
+      }
+      if (job.jobStatus === "failed") {
         clearStatus();
-        throw new Error(job.errorMessage || `job ${job.jobStatus}`);
+        throw new Error(job.errorMessage || "job failed");
       }
       if (
         job.jobStatus === "pending" &&
@@ -689,6 +796,11 @@ async function runAgentTurn(history) {
     clearInterval(ticker);
     clearStatus();
     following = false;
+    currentJobId = null;
+    // Drop anything typed (but not submitted) during the turn — echo was muted, so it's
+    // invisible; without this it would surface on the next prompt.
+    rl.line = "";
+    rl.cursor = 0;
   }
 }
 
@@ -728,8 +840,26 @@ async function main() {
   // only one can ever fire for a given mode, so there's no double-handling.
   const onInterrupt = () => {
     if (following) {
-      followAborted = true;
-      process.stdout.write(red("\n^C "));
+      if (!cancelRequested && currentJobId) {
+        // First Ctrl+C: actually CANCEL the running turn server-side (stop the model),
+        // not just detach. The worker sees the "cancelled" status and kills the Python
+        // agent; the poll loop then returns cleanly with the "(cancelled)" note.
+        cancelRequested = true;
+        const jobId = currentJobId;
+        process.stdout.write(red("\n^C ") + dim("stopping the agent…\n"));
+        fetch(`${apiBase}/api/worker/jobs/cancel`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+          body: JSON.stringify({ jobId }),
+        }).catch(() => {
+          /* best-effort — the worker also self-detects via the chunk 409 path */
+        });
+      } else {
+        // Second Ctrl+C (or no jobId yet): give up waiting locally. The worker keeps
+        // trying to stop, but we stop following.
+        followAborted = true;
+        process.stdout.write(red("\n^C "));
+      }
     } else {
       process.stdout.write(dim("\n(/exit to quit)\n"));
       // Discard anything half-typed (Ctrl-C at a prompt means "never mind") and
@@ -759,12 +889,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);
@@ -786,7 +921,7 @@ async function main() {
     }
     history.push({ role: "user", content: line });
     try {
-      const { text: answer, shown } = await runAgentTurn(history);
+      const { text: answer, shown, cancelled } = await runAgentTurn(history);
       if (answer) {
         history.push({ role: "assistant", content: answer });
         // Persist after every successful turn (not just on clean exit) — an ungraceful
@@ -797,8 +932,12 @@ async function main() {
         // again here would just duplicate it; a blank line is enough for spacing.
         console.log(shown ? "" : `\n\n${answer}\n`);
       } else {
-        history.pop(); // aborted/failed turn — don't poison the next request's history
-        console.log(red("\n(no answer — run aborted or failed)\n"));
+        history.pop(); // aborted/failed/cancelled turn — don't poison the next request
+        // Ctrl+C cancel already printed its own "(cancelled)" note in runAgentTurn — a
+        // second "(no answer)" line here would be redundant/misleading.
+        if (!cancelled) {
+          console.log(red("\n(no answer — run aborted or failed)\n"));
+        }
       }
     } catch (err) {
       history.pop();

package/package.json

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