@tiens.nguyen/gonext-local-worker 1.0.308 → 1.0.310

package/gonext-repl.mjs

@@ -1113,6 +1113,63 @@ function pickFromList(items, initialSel = 0, opts = {}) {
   });
 }
 
+// Cancel whichever approval picker is currently showing (Yes/No or the N-row list),
+// resolving it as a DENY. Used when the job ends server-side while we're still waiting
+// for the user, so the picker promise never leaks and no late choice is sent (#110).
+function cancelActivePicker() {
+  if (approvalActive) finishApproval(false);
+  if (listPickerActive) finishList(-1);
+}
+
+// Show an approval picker, but RACE it against the job going terminal. The old code
+// awaited the picker INLINE inside the poll loop, so while the user thought, the REPL
+// stopped polling and couldn't notice that python had already given up (its own approval
+// deadline) and completed the job — the user's late "Yes" then hit a finished job and was
+// silently lost (#110). Here a background watcher polls the job; if it goes
+// completed/failed/cancelled first, we dismiss the picker and report `ended:true` so the
+// caller skips the POST and lets the normal terminal-status handling run.
+async function approvalPromptRacingJob(command) {
+  let watching = true;
+  const watcher = (async () => {
+    while (watching) {
+      await sleep(1000);
+      if (!watching) return null;
+      try {
+        const r = await fetch(`${apiBase}/api/worker/jobs/${jobIdForApprovalRace}`, {
+          headers: { "X-Worker-Key": workerKey },
+        });
+        if (!r.ok) continue;
+        const j = await r.json().catch(() => ({}));
+        if (
+          j?.jobStatus === "completed" ||
+          j?.jobStatus === "failed" ||
+          j?.jobStatus === "cancelled"
+        ) {
+          return "ended";
+        }
+      } catch {
+        /* transient poll error — keep watching */
+      }
+    }
+    return null;
+  })();
+  const picker = approvalPrompt(command).then((r) => ({ kind: "answer", ...r }));
+  const raced = await Promise.race([
+    picker,
+    watcher.then((v) => (v === "ended" ? { kind: "ended" } : new Promise(() => {}))),
+  ]);
+  watching = false;
+  if (raced.kind === "ended") {
+    cancelActivePicker(); // unblock the picker promise so it doesn't leak
+    await picker.catch(() => {}); // let it settle after the cancel
+    return { ended: true, allow: false, dontAsk: false };
+  }
+  // The user answered first — stop the watcher and return their choice.
+  return { ended: false, allow: raced.allow, dontAsk: raced.dontAsk };
+}
+// The jobId the approval race should watch — set by runAgentTurn before it can prompt.
+let jobIdForApprovalRace = "";
+
 // 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 = "";
@@ -1326,6 +1383,7 @@ async function runAgentTurn(history) {
   following = true;
   followAborted = false;
   currentJobId = jobId;
+  jobIdForApprovalRace = jobId; // so an approval picker can watch THIS job for early end (#110)
   cancelRequested = false;
   const startedAt = Date.now();
   let shownChars = 0;
@@ -1894,7 +1952,19 @@ async function runAgentTurn(history) {
       ) {
         lastApprovalId = job.pendingApproval.id;
         clearStatus();
-        const { allow, dontAsk } = await approvalPrompt(job.pendingApproval.command || "");
+        // Race the picker against the job ending server-side (#110): if python gives up
+        // (its own approval deadline) and completes the job while we're waiting, dismiss
+        // the picker and DON'T post a now-useless choice — fall through to the normal
+        // completed/failed/cancelled handling below on the next poll.
+        const { ended, allow, dontAsk } = await approvalPromptRacingJob(
+          job.pendingApproval.command || ""
+        );
+        if (ended) {
+          process.stdout.write(
+            dim("\n  (the run already ended before you chose — reply 'continue' to resume)\n")
+          );
+          continue; // re-poll; the terminal-status branches below take it from here
+        }
         // "Yes, don't ask again this session" (max-step prompt only): remember it so every
         // later turn sends alwaysExtendOnMaxStep and the agent auto-extends silently (#80).
         if (dontAsk) {

package/gonext_agent_chat.py

@@ -2835,10 +2835,16 @@ def _ws_command_risk(command, argv, denyset):
     return (None, None)
 
 
-def _ws_request_approval(api_base, worker_key, job_id, command, reason):
+def _ws_request_approval(api_base, worker_key, job_id, command, reason, deadline_s=180):
     """Pause and ask the user (via the terminal REPL's Yes/No picker) to allow a risky
     command. Registers a pending approval on the job through the API, then polls the job
     for the user's decision. Returns True (allow) or False (deny / timeout / cancelled).
+
+    deadline_s bounds the wait. 180s is right for a RISKY command (absent user → deny,
+    never auto-run). But the __MAXSTEP__ "keep going?" prompt is NOT security-sensitive and
+    the coder can be slow, so it passes a much larger deadline (#110): the REPL now
+    dismisses the picker the instant this job ends, and the worker's own job-cap kills a
+    truly-abandoned run, so a long wait here is safe and lets a real "Yes" actually land.
     Mirrors _pdf_upload_via_api's worker-key auth — no new creds on the worker."""
     import urllib.request as _u
     import uuid as _uuid
@@ -2866,7 +2872,7 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason):
         _emit({"type": "step", "text": "Awaiting your choice: compact the context?"})
     else:
         _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
-    deadline = _t.time() + 180  # 3 min; absent user → deny (never auto-run something risky)
+    deadline = _t.time() + max(30, int(deadline_s))  # per-call; risky=180s, __MAXSTEP__ long
     while _t.time() < deadline:
         _t.sleep(1.2)
         try:
@@ -6543,10 +6549,14 @@ def run_agent_chat(cfg):
                          "(don't-ask-again session flag)")
                     _do_extend = True
                 elif _interactive_approval and _job_id and pdf_api_base and pdf_worker_key:
+                    # Long deadline (#110): the "keep going?" prompt isn't risky, and the
+                    # slow coder + a thinking user shouldn't get auto-denied at 180s. The
+                    # REPL dismisses the picker if this job ends, and the worker job-cap
+                    # bounds a walked-away user, so waiting here is safe.
                     _do_extend = _ws_request_approval(
                         pdf_api_base, pdf_worker_key, _job_id,
                         f"__MAXSTEP__::Reached the step budget ({agent.max_steps}). "
-                        "Keep going?", "max-steps")
+                        "Keep going?", "max-steps", deadline_s=1500)
                 else:
                     _do_extend = False  # web / no interactive channel → current wrap-up
                 if not _do_extend:

package/package.json

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