@proagentstore/cli 0.4.26 → 0.4.28

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

@@ -44,6 +44,15 @@ export class HeadlessSession {
     turnStartedAt = 0;
     /** Set by stop() — the only thing that ends a one-shot session (see `alive`). */
     stopped = false;
+    /**
+     * The engine binary could not be spawned (ENOENT, not executable).
+     *
+     * Without this, `alive = !stopped` made a MISCONFIGURED engine indistinguishable from a
+     * healthy idle one — so `runCodingLoop`'s `if (!snap.alive)` guard, the thing that catches a
+     * bad command, became structurally unreachable for every one-shot engine and the Pilot burned
+     * all 40 BYOK decisions re-spawning a binary that isn't there.
+     */
+    spawnFailed = false;
     constructor(config) {
         this.config = config;
         this.sessionName = `pags-${config.clientType}-${config.id}`;
@@ -87,7 +96,7 @@ export class HeadlessSession {
      */
     get alive() {
         if (this.oneShot)
-            return !this.stopped;
+            return !this.stopped && !this.spawnFailed;
         return this.procAlive;
     }
     /** Is a process running THIS instant? The persistent engine's liveness, and the spawn guard. */
@@ -153,6 +162,7 @@ export class HeadlessSession {
         // Starting always un-stops: `stop()` is what ends a one-shot session, so a (re)start
         // after one has to bring it back or the session is permanently unusable.
         this.stopped = false;
+        this.spawnFailed = false; // a restart is also a retry of a command that could not run
         // A one-shot engine has nothing to start until there is a turn to run; starting it here
         // is what produced the instant "exited with code 1".
         if (this.oneShot) {
@@ -255,13 +265,30 @@ 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.
+        if (this.procAlive) {
+            try {
+                this.proc?.kill();
+            }
+            catch {
+                /* already gone */
+            }
+        }
         this.proc = proc;
         // Without an 'error' listener a spawn failure (binary not on PATH) is an uncaught
         // exception that takes the whole runner down, not just this session.
         proc.on("error", (err) => {
+            if (this.proc !== proc)
+                return; // stale: a newer turn owns the session now
             this.push(`[${this.config.clientType}] failed to start: ${err.message}`);
             this.run = "idle";
             this.proc = null;
+            // The command itself is unrunnable — report the session dead so the loop stops with a
+            // real reason instead of retrying a binary that does not exist.
+            this.spawnFailed = true;
         });
         proc.stdout?.on("data", (d) => this.onStdout(d.toString()));
         proc.stderr?.on("data", (d) => this.onStdout(d.toString()));
@@ -271,13 +298,29 @@ export class HeadlessSession {
             // looked like an idle session for a whole afternoon.
             if (code)
                 this.push(`[${this.config.clientType} exited with code ${code}]`);
+            // STALENESS GUARD, matching the persistent path's. Without it, an older turn's
+            // `close` clobbered the newer one: `run = "idle"` while process B was still working
+            // (so the brain acted on a half-done turn and could double-send), and `proc = null`
+            // so stop()/interrupt()/end() could no longer kill B — ending the session left a
+            // codex process still editing the repo, invisible to `alive`, diagnostics and
+            // kill-tmux.
+            if (this.proc !== proc)
+                return;
             this.run = "idle";
             this.proc = null;
         });
     }
-    /** No TTY in headless mode; control is via messages. Kept for interface parity. */
-    key(_keys) {
-        /* intentionally a no-op — there are no raw keystrokes without a terminal */
+    /**
+     * No TTY in headless mode; control is via messages. Kept for interface parity — the human
+     * takeover path can still route a keypress here.
+     *
+     * RECORDED rather than silently dropped. As a pure no-op it was indistinguishable from
+     * success: `act` returned an ordinary snapshot with an unchanged pane, so the caller could not
+     * tell "sent, nothing happened" from "never sent". The transcript is what the brain and the
+     * console both read, so the truth belongs there.
+     */
+    key(keys) {
+        this.push(`[ignored keypress ${keys.slice(0, 40)} — this session has no terminal attached]`);
     }
     /** Abort the current turn (SIGINT, like Ctrl-C). The process stays usable. */
     interrupt() {
@@ -402,11 +445,53 @@ function stamp() {
  * tokenize like the command line it looks like.
  */
 export function parseCommand(command) {
+    const src = command ?? "";
     const tokens = [];
-    // One token = a run of unquoted chars and/or quoted spans, glued together (`"a b"c` → `a bc`).
-    const re = /(?:[^\s"']+|"[^"]*"|'[^']*')+/g;
-    for (const raw of (command ?? "").match(re) ?? []) {
-        tokens.push(raw.replace(/"([^"]*)"|'([^']*)'/g, (_m, d, s) => d ?? s ?? ""));
+    const isSpace = (c) => c === " " || c === "\t" || c === "\n" || c === "\r";
+    let i = 0;
+    while (i < src.length) {
+        while (i < src.length && isSpace(src[i]))
+            i++;
+        if (i >= src.length)
+            break;
+        const start = i;
+        let out = "";
+        let quote = null;
+        while (i < src.length) {
+            const ch = src[i];
+            if (quote) {
+                if (ch === quote)
+                    quote = null;
+                else
+                    out += ch;
+                i++;
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                quote = ch;
+                i++;
+                continue;
+            }
+            if (isSpace(ch))
+                break;
+            out += ch;
+            i++;
+        }
+        if (quote) {
+            // UNTERMINATED quote → it was a literal character, not a quote. `don't` is ordinary
+            // English in a user-edited preset; treating the apostrophe as an opening quote made
+            // `--append-system-prompt don't guess` reach the engine as three broken arguments.
+            i = start;
+            let raw = "";
+            while (i < src.length && !isSpace(src[i])) {
+                raw += src[i];
+                i++;
+            }
+            tokens.push(raw);
+        }
+        else {
+            tokens.push(out);
+        }
     }
     return { bin: tokens[0] ?? "", args: tokens.slice(1) };
 }

package/dist/browser-runner/runner.js

@@ -30,6 +30,16 @@ const CAPABILITIES = [
 /** How many times a task may attempt an action before handing off to a human. */
 export const MAX_AUTONOMOUS_ATTEMPTS = 3;
 const APPROVAL_REQUIRED_TASKS = new Set(["browser.open"]);
+/**
+ * Tasks steered by a remote durable Workflow rather than executed by the runner.
+ *
+ * ONE list, because the two places that need it drifted: task creation already treated
+ * `browser.task` like `job.apply_agent`, but `resumeTakeover` did not — so a human resolving a
+ * stuck browse handoff destroyed the takeover session instead of handing control back, and the
+ * workflow then polled a dead session for 15 minutes before failing a run it had already
+ * completed.
+ */
+const WORKFLOW_DRIVEN_TASKS = new Set(["job.apply_agent", "browser.task"]);
 const require = createRequire(import.meta.url);
 export class LocalRunner {
     config;
@@ -101,7 +111,7 @@ export class LocalRunner {
         // steered by the remote Workflow brain via the /browser/* endpoints — the runner
         // never auto-executes them. The task exists for the console board, the activity
         // trace, and takeover keying.
-        if (normalized.type === "job.apply_agent" || normalized.type === "browser.task") {
+        if (WORKFLOW_DRIVEN_TASKS.has(normalized.type)) {
             const task = {
                 id: `task_${crypto.randomUUID()}`,
                 type: normalized.type,
@@ -374,10 +384,18 @@ export class LocalRunner {
         if (!task)
             throw new RunnerInputError("Task not found");
         const page = session.page;
-        // Agent-driven applications are steered by the remote workflow. "Resume"
-        // here just signals the human finished the stuck step (or solved a captcha);
-        // the workflow polls humanDone and continues driving. Do NOT complete/submit.
-        if (task.type === "job.apply_agent") {
+        // Agent-driven runs are steered by the remote workflow. "Resume" here just signals the
+        // human finished the stuck step (or solved a captcha); the workflow polls humanDone and
+        // continues driving. Do NOT complete/submit.
+        //
+        // `browser.task` belongs here too, and its omission made a stuck handoff UNRESOLVABLE:
+        // `humanDone` is set ONLY in this branch, so a browse task fell through to the path below,
+        // which sets `status = "completed"` and calls `endTakeover()` — destroying the session.
+        // `browserHandoffStatus` then returns `{solved:false}` forever (no session), so the
+        // workflow polled for the full 15 minutes and closed the run "failed — stuck not resolved
+        // in time", on a task it had already marked completed. The console's Resume button is
+        // agent-agnostic, so the user pressing it was what broke the run.
+        if (WORKFLOW_DRIVEN_TASKS.has(task.type)) {
             session.humanDone = true;
             this.addTaskEvent(task, "job.resumed", "Human finished the step — handing back to the agent");
             return { submitted: false, resumed: true, reason: "handed back to the agent — the agent is continuing" };
@@ -387,7 +405,7 @@ export class LocalRunner {
             this.addTaskEvent(task, "job.human_challenge_present", `Challenge not yet solved: ${challenge}`);
             return { submitted: false, reason: `The ${challenge} challenge isn't solved yet — complete it in the live view, then submit again.` };
         }
-        // Only browser.open reaches here now (job.apply_agent returns above) — it just
+        // Only browser.open reaches here now (workflow-driven tasks return above) — it just
         // needs the challenge cleared, no form submit.
         this.addTaskEvent(task, "job.resumed", "Human cleared the challenge; resuming");
         const output = {
@@ -992,8 +1010,21 @@ export class LocalRunner {
         const page = await this.getActivePage();
         this.takeovers.set(taskId, { page, reason, humanDone: false });
         const screenshotBase64 = await captureScreenshotDataUrl(page);
-        const task = this.store.getTask(taskId);
-        if (task) {
+        // The takeover is registered ABOVE, unconditionally — that is what makes the live view work.
+        // Everything below is the task's own bookkeeping, and it used to be skipped whenever no
+        // LOCAL task existed. The engine sign-in relay mints its own id (`signin-<sessionId>`) for
+        // a coding session that has no runner task at all, so the handoff registered silently and
+        // none of the status flip, the message or the screenshot ever happened: the console
+        // reported success and offered "take over the browser", while the takeover it pointed at
+        // carried no context. A task row is created for it here rather than requiring the caller
+        // to have made one, so the handoff is complete for every caller.
+        let task = this.store.getTask(taskId);
+        if (!task) {
+            const now = new Date().toISOString();
+            task = { id: taskId, type: "browser.handoff", status: "needs_human", input: {}, requiresApproval: false, createdAt: now, updatedAt: now };
+            this.store.putTask(task);
+        }
+        {
             task.status = "needs_human";
             task.updatedAt = new Date().toISOString();
             this.store.putTask(task);

package/package.json

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