@proagentstore/cli 0.4.12 → 0.4.14

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

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { handlerFor } from "./handlers.js";
 export class HeadlessSession {
     config;
     sessionName;
@@ -28,14 +29,25 @@ export class HeadlessSession {
         // Claude is the structured engine; everything else is a raw CLI.
         this.mode = config.clientType === "claude" ? "stream-json" : "raw";
         const { bin, args } = parseCommand(config.command);
+        // When no explicit command is configured, fall back to THIS engine's default
+        // command (codex/gemini/grok/…) — not a hard-coded "claude", which would drive a
+        // non-Claude session with the wrong CLI (and mode is already "raw" for it).
+        const fallback = parseCommand(handlerFor(config.clientType).cliCommand);
         // A test/override bin wins for the binary only; the command's args are kept.
-        this.cmdBin = config.bin ?? (bin || "claude");
-        this.cmdArgs = args;
+        this.cmdBin = config.bin ?? (bin || fallback.bin || "claude");
+        // Use the configured command's args when a command was given (bin set), else the
+        // engine default's args.
+        this.cmdArgs = bin ? args : fallback.args;
         this.binName = (this.cmdBin.split("/").pop() || this.cmdBin) || "cli";
     }
-    /** True while the agent process is running. */
+    /** True while the agent process is running. NOTE: do NOT use `proc.killed` — Node sets
+     *  it true the instant a signal is DELIVERED, not when the process exits. interrupt()
+     *  SIGINTs to abort a turn while the process keeps running, so `killed` gave a false
+     *  "dead" → input() then spawned a SECOND process (orphaning the first). exitCode is
+     *  null while running and set on normal exit; signalCode is set when a signal actually
+     *  terminated it — together they're the real liveness signal. */
     get alive() {
-        return this.proc !== null && this.proc.exitCode === null && !this.proc.killed;
+        return this.proc !== null && this.proc.exitCode === null && this.proc.signalCode === null;
     }
     /** Idle = ready for the next instruction. */
     get ready() {
@@ -76,31 +88,39 @@ export class HeadlessSession {
         // (e.g. --model) without letting them clobber or orphan-value our flags. raw:
         // run exactly what the user configured and capture stdout.
         const args = this.mode === "stream-json" ? buildClaudeArgs(this.cmdArgs, this.claudeSessionId) : [...this.cmdArgs];
-        this.proc = spawn(this.cmdBin, args, {
+        const proc = spawn(this.cmdBin, args, {
             cwd: this.config.workDir,
             env: { ...process.env, ...this.config.env },
             stdio: ["pipe", "pipe", "pipe"],
         });
+        this.proc = proc;
         this.run = "idle";
         this.lastOutputAt = Date.now();
         // MUST handle 'error' — without a listener, a spawn failure (e.g. the binary
         // not on PATH) is thrown as an uncaught exception and crashes the runner.
-        this.proc.on("error", (err) => {
+        proc.on("error", (err) => {
+            if (this.proc !== proc)
+                return; // a newer process replaced this one — ignore the stale event
             this.run = "idle";
             this.push(`[cannot run \`${this.cmdBin}\`: ${err.message} — is ${this.binName} installed and on your PATH?]`);
             this.proc = null;
         });
         // Swallow EPIPE when writing to a process that just exited (one-shot turn).
-        this.proc.stdin?.on("error", () => { });
-        this.proc.stdout?.on("data", (d) => this.onStdout(d.toString("utf8")));
-        this.proc.stderr?.on("data", (d) => {
+        proc.stdin?.on("error", () => { });
+        proc.stdout?.on("data", (d) => this.onStdout(d.toString("utf8")));
+        proc.stderr?.on("data", (d) => {
             this.lastOutputAt = Date.now();
             this.sawOutputSinceInput = true;
             const text = d.toString("utf8").trim();
             if (text)
                 this.push(`[${this.binName}] ${stripAnsi(text)}`);
         });
-        this.proc.on("exit", (code) => {
+        proc.on("exit", (code) => {
+            // A stop() + re-start() on the SAME session object can leave this old process's
+            // async exit to fire AFTER the fresh start — capturing `proc` and bailing when it
+            // no longer matches stops the stale handler from resetting the new turn to idle.
+            if (this.proc !== proc)
+                return;
             this.run = "idle";
             if (code && code !== 0)
                 this.push(`[${this.binName} exited with code ${code}]`);
@@ -179,9 +199,14 @@ export class HeadlessSession {
             else
                 this.pushRaw(line); // raw engine — the line IS the terminal output
         }
-        // A TUI/raw engine may render without newlines; don't let `buf` grow unbounded
-        // (and surface the partial output so the pane isn't blank). 16KB is generous.
-        if (this.buf.length > 16 * 1024) {
+        // A TUI/raw engine may render without newlines; surface the partial output and cap
+        // growth at 16KB. Claude's stream-json, though, emits ONE JSON object per line and a
+        // single event (a large tool_result / the final `result`) can legitimately exceed
+        // 16KB — truncating mid-line there corrupts the event, and losing a `result` line
+        // wedges the turn "thinking" forever (stream-json has no idle backstop). So give the
+        // structured path a far larger ceiling; only a pathologically huge line resets it.
+        const cap = this.mode === "raw" ? 16 * 1024 : 4 * 1024 * 1024;
+        if (this.buf.length > cap) {
             if (this.mode === "raw")
                 this.pushRaw(this.buf);
             this.buf = "";
@@ -275,8 +300,12 @@ export function buildClaudeArgs(userArgs, resumeId) {
                 i++;
             continue;
         }
-        if (!args.includes(a))
-            args.push(a);
+        // Push every user token as-is. A previous `!args.includes(a)` dedup silently
+        // dropped a REPEATED flag token (e.g. the 2nd `--add-dir` in `--add-dir /a
+        // --add-dir /b`), which orphaned its value (`/b` became a stray positional).
+        // Our own structural flags are already protected via RESERVED_CLAUDE_FLAGS, so
+        // no dedup is needed here.
+        args.push(a);
     }
     if (!args.includes("--dangerously-skip-permissions"))
         args.push("--dangerously-skip-permissions");

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

@@ -54,7 +54,11 @@ export class CodingRuntime {
     snapshot(sessionId) {
         const session = this.require(sessionId);
         const alive = session.alive;
-        const pane = alive ? clip(session.snapshot()) : "";
+        // ALWAYS return the transcript — it holds the produced output AND the
+        // `[exited with code N]` / `[error]` lines recorded on exit. Blanking it when the
+        // process is dead lost exactly the output + failure reason the brain/console needs
+        // to diagnose a crash or read a one-shot CLI's final result.
+        const pane = clip(session.snapshot());
         return {
             sessionId,
             pane,

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

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 /**
  * Low-level tmux primitives for the coding runtime.
@@ -108,10 +108,18 @@ export function ensureRepo(dir, opts = {}) {
             mkdirSync(dir, { recursive: true });
         return dir;
     }
-    // A stale/empty/half-cloned dir (exists but no .git) would make `git clone`
-    // fail on a non-empty target — clear it first so the clone is clean.
-    if (existsSync(dir))
+    // The dir exists but has no `.git`. It could be a half-cloned/empty managed dir
+    // (safe to clear) OR a real user directory the caller passed as an explicit workDir
+    // (deleting it = data loss). NEVER recursively delete a non-empty non-git dir — refuse
+    // instead, so a mis-wired workDir+cloneUrl can't nuke a user's files. An empty dir is
+    // fine to remove (git clone needs an empty/absent target).
+    if (existsSync(dir)) {
+        const entries = readdirSync(dir);
+        if (entries.length > 0) {
+            throw new Error(`Refusing to clone into non-empty directory "${dir}" (no .git found) — move it aside or point at an empty path.`);
+        }
         rmSync(dir, { recursive: true, force: true });
+    }
     let url = opts.cloneUrl;
     if (opts.token && /^https:\/\//.test(url)) {
         url = url.replace(/^https:\/\//, `https://x-access-token:${opts.token}@`);

package/dist/browser-runner/runner.js

@@ -758,6 +758,28 @@ export class LocalRunner {
             return `⚠ "${name}" REJECTED: now reads "${shown}"${parsed.msg ? ` — ${parsed.msg.slice(0, 80)}` : ""}`;
         return `"${name}" now reads "${shown}"`;
     }
+    /** Read a checkbox/radio's checked state via the standard evaluate tool so `check`
+     *  can be made idempotent (a raw click would toggle). Returns true/false, or null when
+     *  the state can't be determined (then we fall back to clicking). Never throws. */
+    async isChecked(mcp, ref, label) {
+        const fn = "el => { if (el.checked !== undefined && el.checked !== null) return !!el.checked; " +
+            "const a = el.getAttribute('aria-checked'); return a === 'true' ? true : a === 'false' ? false : null; }";
+        const res = await mcp.callTool("browser_evaluate", { element: label, target: ref, function: fn }).catch(() => null);
+        if (!res || res.isError)
+            return null;
+        const txt = mcp.textOf(res);
+        const i = txt.indexOf("### Result");
+        if (i < 0)
+            return null;
+        const after = txt.slice(i + "### Result".length).trim();
+        const end = after.indexOf("\n###");
+        const block = (end >= 0 ? after.slice(0, end) : after).trim().replace(/^["']|["']$/g, "");
+        if (/^true$/i.test(block))
+            return true;
+        if (/^false$/i.test(block))
+            return false;
+        return null;
+    }
     /** The snapshot ref the brain must target the element by (standard-tool `target`). */
     refOf(action) {
         const ref = (action.ref || "").trim();
@@ -773,10 +795,19 @@ export class LocalRunner {
                 return mcp.callTool("browser_navigate", { url: a.url });
             case "type":
                 return mcp.callTool("browser_type", { element: label, target: this.refOf(a), text: a.text ?? "" });
-            // A checkbox/radio is just a click at the standard-tool level.
             case "click":
-            case "check":
                 return mcp.callTool("browser_click", { element: label, target: this.refOf(a) });
+            case "check": {
+                const ref = this.refOf(a);
+                // A checkbox/radio click is a TOGGLE at the standard-tool level — clicking an
+                // ALREADY-checked control unchecks it, silently reversing a pre-ticked consent
+                // or a default-selected radio before submit. Make `check` idempotent
+                // (ensure-checked): read the current state and only click when it isn't set.
+                if ((await this.isChecked(mcp, ref, label)) === true) {
+                    return { isError: false, content: [{ type: "text", text: `"${label}" already checked` }] };
+                }
+                return mcp.callTool("browser_click", { element: label, target: ref });
+            }
             case "upload": {
                 if (!this.applyResumePath)
                     throw new RunnerInputError("no résumé file available to upload");

package/dist/index.js

@@ -952,10 +952,14 @@ function createRunnerCommand() {
     });
     runner.stdout?.on("data", (data) => process.stdout.write(data));
     runner.stderr?.on("data", (data) => process.stderr.write(data));
+    let shuttingDown = false;
     runner.on("exit", (code) => {
-      if (code && code !== 0) writeError(`runner exited with code ${code}`);
+      if (shuttingDown) return;
+      writeError(`Local browser runtime exited unexpectedly${code ? ` (code ${code})` : ""}. Run \`pags up\` again to reconnect.`);
+      process.exit(code ?? 1);
     });
     const shutdown = () => {
+      shuttingDown = true;
       if (!runner.killed) runner.kill("SIGTERM");
     };
     process.once("SIGINT", () => {
@@ -1361,9 +1365,13 @@ var upCommand = new Command7("up").description("Start the browser runner for all
     if (key === "r") {
       if (childDead) {
         writeLine("  Restarting runner...");
-        const { execSync } = await import("child_process");
+        const { execFileSync: execFileSync2 } = await import("child_process");
+        const restartArgs = [process.argv[1], "up"];
+        if (opts.headless) restartArgs.push("--headless");
+        if (opts.force) restartArgs.push("--force");
+        if (opts.instance) restartArgs.push("--instance", opts.instance);
         try {
-          execSync(`${process.execPath} ${process.argv[1]} up${opts.headless ? " --headless" : ""}${opts.force ? " --force" : ""}`, {
+          execFileSync2(process.execPath, restartArgs, {
             stdio: "inherit",
             env: process.env
           });

package/package.json

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