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

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);

package/gonext-repl.mjs

@@ -43,11 +43,11 @@ const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const white = (s) => `\x1b[37m${s}\x1b[0m`;
 // ANSI 90 ("bright black") — a reliable neutral grey across terminal themes, unlike
 // code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
 const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 
 // The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
 // SWALLOW them from the terminal (the local ticker below drives progress instead), and
@@ -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;
@@ -360,6 +368,19 @@ 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
+
+// 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);
+};
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -393,6 +414,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
@@ -400,7 +423,6 @@ async function runAgentTurn(history) {
   let warnedPending = false;
   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
-  let routingAnnounced = false; // one friendly line replaces the whole routing play-by-play
   // True once we've SPECIFICALLY seen "→ Chat reply" (the plain-reply/trivial-chat
   // branch), as opposed to "→ Agent mode…" (the tool-use branch). Only the plain-reply
   // path streams its answer via answer_stream with NO heartbeat/tool-summary/code lines
@@ -419,11 +441,18 @@ async function runAgentTurn(history) {
   let lastContentAt = Date.now();
   let thinking = false;
   let thinkingSince = 0;
+  let thinkWord = pickWord(); // playful word shown UNDER the in-progress line (flavor)
   let almostDone = false; // set from the worker's "…almost completed thinking…" heartbeat
+  let runningCmd = null; // the command currently executing (from a "Running → …" event)
   const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
 
+  // The status is TWO in-place lines — the in-progress action, then the playful word
+  // under it. Cursor sits at the end of line 2, so clearing = wipe line 2, move up, wipe
+  // line 1, leaving the cursor back at the status's origin for a redraw or real content.
   const clearStatus = () => {
-    if (statusShown) { process.stdout.write(CLEAR_LINE); statusShown = false; }
+    if (!statusShown) return;
+    process.stdout.write("\r\x1b[K\x1b[1A\r\x1b[K");
+    statusShown = false;
   };
 
   const tick = () => {
@@ -433,22 +462,33 @@ async function runAgentTurn(history) {
     // done — overwriting the ticker there corrupts the visible answer mid-word. Stay
     // silent once any of THIS line has already been shown (see carryFlushedLen).
     if (plainReplyFlow && carryFlushedLen > 0) return;
-    // Count from when the stream went quiet, so the seconds reflect the true wait.
-    if (!thinking) { thinking = true; thinkingSince = lastContentAt; }
+    // Count from when this phase went quiet, so the seconds reflect the current wait/run.
+    if (!thinking) { thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); }
     const secs = thinkSecs();
-    const glyph = SPINNER[secs % SPINNER.length];       // rotates → reads as "in progress"
-    const label = almostDone ? "almost done" : "working";
-    process.stdout.write(CLEAR_LINE + yellow(`${glyph} ${label}… (${secs}s)`));
+    if (secs % 12 === 0) thinkWord = pickWord(); // rotate the word on long waits
+    const glyph = SPINNER[secs % SPINNER.length]; // rotates → reads as "in progress"
+    // Line 1 = WHAT is happening now: the running command, else the phase (Thinking /
+    // Almost done). Line 2 = the playful word (flavor). Truncate so neither wraps.
+    const primary = runningCmd
+      ? `Running ${runningCmd}`
+      : almostDone ? "Almost done" : "Thinking";
+    const max = Math.max(24, (process.stdout.columns || 80) - 14);
+    const fit = (s) => (s.length > max ? s.slice(0, max - 1) + "…" : s);
+    clearStatus();
+    process.stdout.write(
+      yellow(`${glyph} ${fit(primary)}… (${secs}s)`) + "\n" + dim(`  ${thinkWord}…`)
+    );
     statusShown = true;
   };
   const ticker = setInterval(tick, 1000);
 
   // Called right before any real (bullet/edit-card/answer) content prints: drop the
-  // blinking-bullet status line so content lands cleanly on its own line. No "completed
-  // thought" stamp — each finished action prints its own solid ● bullet instead.
+  // status lines so content lands cleanly, and end the current phase (so the next phase's
+  // seconds count fresh, and any running command is considered finished).
   const onContent = () => {
     clearStatus();
-    if (thinking) { process.stdout.write(CLEAR_LINE); thinking = false; }
+    thinking = false;
+    runningCmd = null;
     lastContentAt = Date.now();
   };
 
@@ -494,17 +534,10 @@ async function runAgentTurn(history) {
       if (inStreamFence) continue;
       if (isToolStepSummary(line)) { lastContentAt = Date.now(); continue; } // swallow
       if (isRoutingLine(line)) {
-        // Replace the whole routing play-by-play with ONE friendly line, shown once
-        // per turn — the raw labels are implementation detail (visible in the daemon's
-        // own terminal if you need them).
+        // Swallow the router's play-by-play entirely — the blinking-bullet ticker (which
+        // already shows the playful word + seconds) is the single in-progress indicator,
+        // so a separate static "Booting the big brain…" line here would just duplicate it.
         if (line.trim() === "→ Chat reply") plainReplyFlow = true;
-        if (!routingAnnounced) {
-          routingAnnounced = true;
-          onContent();
-          process.stdout.write(dim(`${pickWord()}…`) + "\n");
-          lastWasBlank = false;
-        }
-        lastContentAt = Date.now();
         continue;
       }
       // Edit card (a file change made by the agent's edit tools) — rendered as a
@@ -593,6 +626,14 @@ async function runAgentTurn(history) {
         }
         continue;
       }
+      // Agent flow: a "Running → <cmd>" is the START of a command — show it as the live
+      // in-progress status (the blinking bullet names it) rather than a solid bullet; its
+      // completion ("Command passed/failed → …" / "Server up → …") prints the done bullet.
+      // So the pair collapses to: "◑ Running <cmd>…" while it runs, then "● <result>".
+      if (!plainReplyFlow) {
+        const mRun = /^Running → (.+)$/.exec(line.trim());
+        if (mRun) { runningCmd = mRun[1]; thinking = false; lastContentAt = Date.now(); continue; }
+      }
       if (alreadyFlushed === 0) onContent();
       if (plainReplyFlow) {
         // Plain-reply content IS the answer — print it in the default color and remember
@@ -600,11 +641,10 @@ async function runAgentTurn(history) {
         process.stdout.write(line.slice(alreadyFlushed) + "\n");
         answerShownLive = true;
       } else {
-        // Agent flow: with the raw Thought/code stream suppressed above, the only lines
-        // that reach here are the worker's out-of-fence ACTION events ("Running → npx…",
-        // "Searching code → import (11 hits)", "Server up → …", "Composing answer…").
-        // Render each as ONE solid bullet — the clean, summarized action list (task #41).
-        process.stdout.write(green(BULLET) + " " + line.trim() + "\n");
+        // The remaining out-of-fence ACTION events ("Command passed → …", "Searching code
+        // → …", "Server up → …", "Composing answer…") each print as ONE solid bullet —
+        // the clean, summarized action list (task #41).
+        process.stdout.write(white(BULLET) + " " + line.trim() + "\n");
       }
       lastWasBlank = false;
     }
@@ -651,9 +691,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" &&
@@ -672,6 +720,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;
   }
 }
 
@@ -711,8 +764,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
@@ -769,7 +840,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
@@ -780,8 +851,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.203",
+  "version": "1.0.205",
   "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",