@proagentstore/cli 0.4.40 → 0.4.41

package/dist/browser-runner/coding/handlers.js

@@ -1,110 +1,22 @@
 /**
- * Per-CLI behaviour for the coding runtime.
+ * Per-CLI facts the coding runtime needs before it can spawn an engine.
  *
- * Each AI coding CLI renders its TUI differently, so "is it ready for input?",
- * "is it still working?", and "where does its answer start/end in the pane?" are
- * CLI-specific. These handlers encapsulate that, ported from the AgentCoder
- * `bridge/src/agents/handlers/*`. A `generic` shell handler is included so the
- * runtime (and tests) can drive a plain shell deterministically.
+ * This file used to carry pane heuristics too — `isReady` / `isProcessing` / `extractResponse` /
+ * `completion`, ported from AgentCoder's `bridge/src/agents/handlers/*` — which answered
+ * "is it ready for input?" by matching strings a vendor prints in its TUI. They died with the
+ * tmux backend (commit c94642f): a session is a child process now, so Claude's turn boundary is a
+ * `result` event and a raw engine's is process exit. Nothing had called them since, and keeping
+ * them left a live-looking `pane.includes("ctrl+c to interrupt")` one vendor release away from
+ * being silently wrong — for anyone who wired it back up believing it worked.
+ *
+ * What remains is data: which binary this engine is, and which env var carries its key.
  */
-/** Shared "find the user's input line, return everything after it up to the next prompt". */
-function sliceAfterInput(captured, userInput, isPromptLine) {
-    const lines = captured.split("\n");
-    const needle = userInput.slice(0, 25);
-    let start = -1;
-    if (needle) {
-        for (let i = lines.length - 1; i >= 0; i--) {
-            if (lines[i].includes(needle)) {
-                start = i;
-                break;
-            }
-        }
-    }
-    if (start === -1)
-        return lines.slice(-200).join("\n").trim();
-    let end = lines.length;
-    for (let i = lines.length - 1; i > start; i--) {
-        if (isPromptLine(lines[i].trim())) {
-            end = i;
-            break;
-        }
-    }
-    return lines.slice(start + 1, end).join("\n").trim();
-}
-export class ClaudeHandler {
-    clientType = "claude";
-    cliCommand = "claude --dangerously-skip-permissions";
-    envVar = "ANTHROPIC_API_KEY";
-    isProcessing(pane) {
-        return pane.includes("ctrl+c to interrupt") || /Working|Thinking|Reading|Searching|Running|Editing|Writing/.test(pane);
-    }
-    isReady(pane) {
-        if (this.isProcessing(pane))
-            return false;
-        const tail = pane.split("\n").slice(-15).join("\n");
-        return (tail.includes("bypass permissions") ||
-            tail.includes("? for shortcuts") ||
-            /❯\s*$/.test(tail) ||
-            /❯ .*↵ send/.test(tail));
-    }
-    extractResponse(captured, userInput) {
-        return sliceAfterInput(captured, userInput, (l) => l === "❯" || l.startsWith("❯ "));
-    }
-    completion() {
-        return { minWait: 1000, stableThreshold: 0, forceCompleteAfter: 5 * 60 * 1000, pollInterval: 500 };
-    }
-}
-export class GeminiHandler {
-    clientType = "gemini";
-    cliCommand = "gemini";
-    envVar = "GEMINI_API_KEY";
-    isProcessing(pane) {
-        return /thinking|processing|generating|working|loading/i.test(pane);
-    }
-    isReady(pane) {
-        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
-        const hasPrompt = /[>$]\s*$/.test(last) || /^>/.test(last);
-        return hasPrompt && !this.isProcessing(pane);
-    }
-    extractResponse(captured, userInput) {
-        return sliceAfterInput(captured, userInput, (l) => /^[>$]\s*$/.test(l) || /^[>$]\s+\S/.test(l));
-    }
-    completion() {
-        return { stableThreshold: 1500, forceCompleteAfter: 5 * 60 * 1000, pollInterval: 500 };
-    }
-}
-/** Codex / Grok render close enough to a generic prompt; reuse the shell heuristics. */
-export class GenericHandler {
-    clientType;
-    cliCommand;
-    envVar;
-    constructor(clientType = "generic", cliCommand = "bash", envVar = "") {
-        this.clientType = clientType;
-        this.cliCommand = cliCommand;
-        this.envVar = envVar;
-    }
-    isProcessing(pane) {
-        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
-        return /\.\.\.$/.test(last);
-    }
-    isReady(pane) {
-        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
-        // A shell prompt ends in $, #, >, or %  (optionally followed by a cursor space).
-        return /[$#>%]\s*$/.test(last) && !this.isProcessing(pane);
-    }
-    extractResponse(captured, userInput) {
-        return sliceAfterInput(captured, userInput, (l) => /[$#>%]\s*$/.test(l));
-    }
-    completion() {
-        return { stableThreshold: 800, forceCompleteAfter: 60 * 1000, pollInterval: 300 };
-    }
-}
 const HANDLERS = {
-    claude: new ClaudeHandler(),
-    gemini: new GeminiHandler(),
-    codex: new GenericHandler("codex", "codex", "OPENAI_API_KEY"),
-    grok: new GenericHandler("grok", "grok", "XAI_API_KEY"),
-    generic: new GenericHandler(),
+    claude: { clientType: "claude", cliCommand: "claude --dangerously-skip-permissions", envVar: "ANTHROPIC_API_KEY" },
+    gemini: { clientType: "gemini", cliCommand: "gemini --approval-mode yolo --skip-trust --prompt", envVar: "GEMINI_API_KEY" },
+    codex: { clientType: "codex", cliCommand: "codex exec --sandbox danger-full-access", envVar: "OPENAI_API_KEY" },
+    grok: { clientType: "grok", cliCommand: "grok --permission-mode bypassPermissions -p", envVar: "XAI_API_KEY" },
+    generic: { clientType: "generic", cliCommand: "bash", envVar: "" },
 };
 export function handlerFor(clientType) {
     return HANDLERS[clientType] ?? HANDLERS.generic;

package/dist/browser-runner/coding/headless.js

@@ -44,6 +44,19 @@ const MAX_PENDING_USAGE = 200;
  * matter most, whereas the merge that started an incident is the one you cannot afford to lose.
  */
 const MAX_PENDING_ACTS = 100;
+/**
+ * Absolute ceiling on ONE one-shot turn (#391).
+ *
+ * The old idle heuristic carried a 15-minute backstop so a wedged engine could not sit "thinking"
+ * forever. Now that exit is the only thing that ends a one-shot turn, that ceiling has to be
+ * ENFORCED rather than inferred: a rule that merely relabels a still-running process as idle is
+ * the very defect #391 is about — it hands the next turn a repo another engine is still editing.
+ *
+ * So the timer ends the turn (SIGTERM) and says so in the transcript. Removing the ceiling
+ * outright would trade an early kill for a permanent hang, which is worse: nothing else on this
+ * path can unstick a process that never exits, and the console's Restart is a human noticing.
+ */
+const MAX_ONE_SHOT_TURN_MS = 15 * 60 * 1000;
 export class HeadlessSession {
     config;
     /**
@@ -67,11 +80,11 @@ export class HeadlessSession {
     cmdBin;
     cmdArgs;
     binName;
-    /** Wall-clock of the last stdout/stderr byte — drives the raw-mode idle heuristic. */
+    /** Wall-clock of the last stdout/stderr byte — drives the persistent-raw idle heuristic. */
     lastOutputAt = 0;
-    /** Raw-mode: has any output arrived since the current turn's input? */
+    /** Persistent-raw: has any output arrived since the current turn's input? */
     sawOutputSinceInput = false;
-    /** Raw-mode: when the current turn started (absolute idle backstop). */
+    /** Persistent-raw: when the current turn started (absolute idle backstop). */
     turnStartedAt = 0;
     /** Set by stop() — the only thing that ends a one-shot session (see `alive`). */
     stopped = false;
@@ -198,7 +211,27 @@ export class HeadlessSession {
     runState() {
         if (!this.alive)
             return "idle";
-        // Raw engines have no "turn over" event, so we INFER idle. Three rules, in order:
+        // A ONE-SHOT engine's turn IS a process, so its exit is an exact end-of-turn signal and no
+        // timer may pre-empt it (#391). Idle is set by the `close` handler; here the only question
+        // is whether that process is still running.
+        //
+        // This used to fall through to the timer rules below, which were written for a PERSISTENT
+        // interactive CLI — one with no other signal to read. Against a one-shot engine the 1.5s
+        // quiet rule could only ever fire EARLY: any pause inside a turn (a test suite, an install,
+        // a slow network fetch) read as "finished", the Pilot sent turn 2, and `runOneShot` killed
+        // turn 1 to keep two engines off one repo. The heuristic that existed to prevent a
+        // premature finish was causing one, and destroying the work in flight to do it.
+        //
+        // The ceiling that stops a wedged process is armed in `runOneShot` — it ENDS the turn
+        // rather than relabelling a live one as idle, which is the same mistake in slower form.
+        if (this.oneShot)
+            return this.procAlive ? "thinking" : "idle";
+        // Below: a PERSISTENT non-Claude engine — alive between turns, so exit says nothing about
+        // a turn and idle must be inferred. None ships today; every raw engine is one-shot. The
+        // gate is `!oneShot` rather than `mode === "raw"` because the latter now means the
+        // OPPOSITE of the condition these rules were written for.
+        //
+        // Three rules, in order:
         //  1. produced output, then went quiet for 1.5s → settled (the common case).
         //  2. NEVER produced output but 8s elapsed → a silent turn (just a prompt) is done.
         //  3. absolute 15-min backstop → never wedge "thinking" forever (e.g. a heartbeat
@@ -316,7 +349,7 @@ export class HeadlessSession {
         const now = Date.now();
         this.lastOutputAt = now;
         this.turnStartedAt = now;
-        this.sawOutputSinceInput = false; // arm the raw idle heuristic for THIS turn
+        this.sawOutputSinceInput = false; // arm the persistent-raw idle heuristic for THIS turn
         try {
             if (this.mode === "stream-json") {
                 const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } });
@@ -353,11 +386,17 @@ export class HeadlessSession {
             env: mergeEnv(process.env, this.config.env),
             stdio: ["ignore", "pipe", "pipe"],
         });
-        // A turn already running is aborted before its replacement starts. `input()` never killed
-        // the previous process, and the raw idle heuristic declares idle after a >1.5s output
-        // pause — so a long build could be judged idle, the brain sends turn 2, and TWO engine
-        // processes edit the same repo at once.
+        // A turn already running is aborted before its replacement starts: `input()` accepts a turn
+        // at any time — a human typing in the console, a takeover, a Loop that stopped waiting —
+        // so without this TWO engine processes edit the same repo at once. Still needed after #391
+        // made exit authoritative: that stops the Pilot from being TOLD a running turn is over, it
+        // does not stop anyone from sending anyway.
+        //
+        // It SAYS what it destroyed, for the same reason the non-zero exit code goes into the
+        // transcript below: a turn's work vanishing with no line in the record is how the Pilot
+        // ends up reasoning about a turn that never finished, with nothing to explain the gap.
         if (this.procAlive) {
+            this.push(`[${this.config.clientType} turn aborted — a new instruction arrived while the previous one was still running]`);
             try {
                 this.proc?.kill();
             }
@@ -380,7 +419,23 @@ export class HeadlessSession {
         });
         proc.stdout?.on("data", (d) => this.onStdout(d.toString()));
         proc.stderr?.on("data", (d) => this.onStdout(d.toString()));
+        // The enforced ceiling (#391). `unref` so a pending timer can never keep the runner's
+        // event loop alive past its own shutdown.
+        const maxTurnMs = this.config.maxTurnMs ?? MAX_ONE_SHOT_TURN_MS;
+        const ceiling = setTimeout(() => {
+            if (this.proc !== proc)
+                return; // a newer turn owns the session; this one is already gone
+            this.push(`[${this.config.clientType} turn ended after ${Math.round(maxTurnMs / 60000)}m — the engine never exited, so the session was unwedged]`);
+            try {
+                proc.kill();
+            }
+            catch {
+                /* already gone */
+            }
+        }, maxTurnMs);
+        ceiling.unref();
         proc.on("close", (code) => {
+            clearTimeout(ceiling); // cleared before the staleness guard: the timer belongs to THIS process
             // A non-zero exit is the engine's own failure (bad flags, not signed in) and the
             // operator needs to see it — silently going idle is how "stdin is not a terminal"
             // looked like an idle session for a whole afternoon.

package/dist/browser-runner/coding/runtime.js

@@ -11,8 +11,8 @@ export class CodingRuntime {
     /**
      * Active human handoffs keyed by session id. `resolved` flips when the human
      * finishes (console "Resume" / submits a value); the brain workflow polls
-     * {@link takeoverStatus} and continues once it does — the tmux analogue of the
-     * browser runtime's handoff-status machinery.
+     * {@link takeoverStatus} and continues once it does — the coding-session analogue of
+     * the browser runtime's handoff-status machinery.
      */
     takeovers = new Map();
     /** Base directory under which repos are cloned (one subdir per repo). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.40",
+  "version": "0.4.41",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",