@proagentstore/cli 0.4.40 → 0.4.42

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/repo.js

@@ -1,15 +1,49 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
 /**
- * Repo/workdir helpers for the coding engine.
- *
- * These lived in `coding/tmux.ts` and have nothing to do with tmux — `ensureRepo` runs `git
- * clone`. The coding engine stopped using tmux when it moved to the structured stream-json
- * interface, so anyone cleaning up that module found its two most load-bearing functions
- * inside it (#247). Split out so the tmux module is only tmux, and only the terminal-operator
- * agents depend on it.
+ * Inspect a workdir: does it exist, does it hold anything, is it a checkout. Never throws —
+ * every failure is a `false`, because this function exists to REPORT a broken path and one that
+ * threw would be reported as a broken runner instead.
  */
+export function checkWorkdir(dir) {
+    const absent = { checked: true, path: dir, exists: false, isDirectory: false, entryCount: 0, insideWorkTree: false, gitChecked: true };
+    let isDirectory = false;
+    try {
+        isDirectory = statSync(dir).isDirectory();
+    }
+    catch {
+        return { ...absent };
+    }
+    if (!isDirectory)
+        return { ...absent, exists: true };
+    let entryCount = 0;
+    try {
+        entryCount = readdirSync(dir).length;
+    }
+    catch {
+        // Unreadable (permissions) — reported as empty rather than as a crash; the cloud's
+        // message for "empty" tells the owner to look at the path either way.
+    }
+    let insideWorkTree = false;
+    let gitChecked = true;
+    try {
+        const out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+            cwd: dir,
+            encoding: "utf-8",
+            timeout: 10_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        insideWorkTree = out.trim() === "true";
+    }
+    catch (e) {
+        // Exit 128 ("not a git repository") is an ANSWER. ENOENT is git missing from PATH, which
+        // is not — and reporting it as "not a checkout" would condemn every repo on that machine.
+        if (e?.code === "ENOENT")
+            gitChecked = false;
+    }
+    return { checked: true, path: dir, exists: true, isDirectory, entryCount, insideWorkTree, gitChecked };
+}
 /**
  * A safe, collision-resistant label derived from an arbitrary string.
  *

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

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { defaultStatePath, HeadlessSession } from "./headless.js";
 import { InspectError, readGitRemoteOrigin, readRepoFile, repoTree, runRepoGit } from "./inspect.js";
-import { ensureRepo, sanitizeSessionName } from "./repo.js";
+import { checkWorkdir, ensureRepo, sanitizeSessionName } from "./repo.js";
 /** Hard cap on a pane returned to the brain/console (matches the worker MAX_PANE_CHARS). */
 const MAX_PANE = 64 * 1024;
 export class CodingRuntime {
@@ -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). */
@@ -58,6 +58,16 @@ export class CodingRuntime {
     gitRemote(input) {
         return { remote: readGitRemoteOrigin(this.resolveWorkDir(input)) };
     }
+    /**
+     * Is the configured workdir usable AT ALL — present, non-empty, a checkout (#405)?
+     *
+     * The only endpoint here that answers a question about the PATH rather than about its
+     * contents, and the one the cloud needs before it may call a repo `ready`. Reports the
+     * resolved path so a message can name the thing the owner actually typed, `~` and all.
+     */
+    checkRepo(input) {
+        return checkWorkdir(this.resolveWorkDir(input));
+    }
     static taskTypes() {
         return ["coding.session"];
     }

package/dist/browser-runner/server.js

@@ -232,6 +232,18 @@ async function route(runner, req, res) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
         }
     }
+    // Does the configured workdir exist / hold files / belong to a checkout (#405)? An older
+    // runner 404s this; the cloud reads the missing `checked:true` as "unverified" and leaves
+    // the repo's status alone rather than condemning it.
+    if (req.method === "POST" && path === "/coding/repo-check") {
+        const b = await readJson(req);
+        try {
+            return json(res, 200, runner.coding.checkRepo(b));
+        }
+        catch (e) {
+            return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
+        }
+    }
     if (req.method === "POST" && path === "/coding/tree") {
         const b = await readJson(req);
         try {

package/package.json

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