@proagentstore/cli 0.2.2 → 0.2.4

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

@@ -10,10 +10,28 @@ export class HeadlessSession {
     run = "idle";
     /** Claude Code's own session id (from the init event) — used to --resume. */
     claudeSessionId = null;
+    /** "stream-json" for Claude (structured) · "raw" for any other CLI (stdout capture). */
+    mode;
+    cmdBin;
+    cmdArgs;
+    binName;
+    /** Wall-clock of the last stdout/stderr byte — drives the raw-mode idle heuristic. */
+    lastOutputAt = 0;
+    /** Raw-mode: has any output arrived since the current turn's input? */
+    sawOutputSinceInput = false;
+    /** Raw-mode: when the current turn started (absolute idle backstop). */
+    turnStartedAt = 0;
     constructor(config) {
         this.config = config;
         this.sessionName = `pags-${config.clientType}-${config.id}`;
         this.claudeSessionId = readState(config.statePath, config.id);
+        // 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);
+        // 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.binName = (this.cmdBin.split("/").pop() || this.cmdBin) || "cli";
     }
     /** True while the agent process is running. */
     get alive() {
@@ -21,10 +39,30 @@ export class HeadlessSession {
     }
     /** Idle = ready for the next instruction. */
     get ready() {
-        return this.alive && this.run === "idle";
+        return this.alive && this.runState() === "idle";
     }
     runState() {
-        return this.alive ? (this.run === "thinking" ? "thinking" : "idle") : "idle";
+        if (!this.alive)
+            return "idle";
+        // Raw engines have no "turn over" event, so we INFER idle. 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
+        //     that keeps refreshing lastOutputAt). The user can also Restart from diagnostics.
+        // Rule 1 deliberately waits for first output so a slow first token can't flip us
+        // to idle mid-turn (which would make the brain proceed against a half-done turn).
+        if (this.mode === "raw" && this.run === "thinking") {
+            const now = Date.now();
+            const quiet = now - this.lastOutputAt;
+            const elapsed = now - this.turnStartedAt;
+            if (this.sawOutputSinceInput && quiet > 1500)
+                this.run = "idle";
+            else if (!this.sawOutputSinceInput && elapsed > 8000)
+                this.run = "idle";
+            else if (elapsed > 15 * 60 * 1000)
+                this.run = "idle";
+        }
+        return this.run === "thinking" ? "thinking" : "idle";
     }
     /** The rendered conversation the brain/console reads (Claude's real output). */
     snapshot() {
@@ -34,43 +72,38 @@ export class HeadlessSession {
     start() {
         if (this.alive)
             return;
-        const args = [
-            "-p",
-            "--input-format",
-            "stream-json",
-            "--output-format",
-            "stream-json",
-            "--verbose",
-            "--dangerously-skip-permissions",
-        ];
-        // Continue the prior conversation after a runner restart (state in ~/.claude).
-        if (this.claudeSessionId)
-            args.push("--resume", this.claudeSessionId);
-        this.proc = spawn(this.config.bin ?? "claude", args, {
+        // stream-json: we own the structural flags + --resume; merge the user's extras
+        // (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, {
             cwd: this.config.workDir,
             env: { ...process.env, ...this.config.env },
             stdio: ["pipe", "pipe", "pipe"],
         });
         this.run = "idle";
-        // MUST handle 'error' — without a listener, a spawn failure (e.g. `claude`
+        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) => {
             this.run = "idle";
-            this.push(`[cannot run \`${this.config.bin ?? "claude"}\`: ${err.message} — is Claude Code installed and on your PATH?]`);
+            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) => {
+            this.lastOutputAt = Date.now();
+            this.sawOutputSinceInput = true;
             const text = d.toString("utf8").trim();
             if (text)
-                this.push(`[claude] ${text}`);
+                this.push(`[${this.binName}] ${stripAnsi(text)}`);
         });
         this.proc.on("exit", (code) => {
             this.run = "idle";
             if (code && code !== 0)
-                this.push(`[claude exited with code ${code}]`);
+                this.push(`[${this.binName} exited with code ${code}]`);
             // A bad --resume can kill the process instantly; drop it so the next
             // start is a clean session rather than looping on a dead id.
             if (code && code !== 0 && this.claudeSessionId) {
@@ -79,15 +112,25 @@ export class HeadlessSession {
             }
         });
     }
-    /** Send a user turn to Claude (the agent acts on it). */
+    /** Send a user turn to the agent (it acts on it). */
     input(text) {
         if (!this.alive)
             this.start();
         this.push(`\n❯ [${stamp()}] ${text}`); // ❯ — your turn, timestamped
         this.run = "thinking";
-        const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } });
+        const now = Date.now();
+        this.lastOutputAt = now;
+        this.turnStartedAt = now;
+        this.sawOutputSinceInput = false; // arm the raw idle heuristic for THIS turn
         try {
-            this.proc?.stdin?.write(`${msg}\n`);
+            if (this.mode === "stream-json") {
+                const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } });
+                this.proc?.stdin?.write(`${msg}\n`);
+            }
+            else {
+                // Raw CLI: write the line to stdin as if typed.
+                this.proc?.stdin?.write(`${text}\n`);
+            }
         }
         catch {
             /* process may have died; the next snapshot reports not-alive */
@@ -120,16 +163,37 @@ export class HeadlessSession {
     }
     // ── internals ────────────────────────────────────────────────────────────
     onStdout(chunk) {
+        this.lastOutputAt = Date.now();
+        this.sawOutputSinceInput = true; // a slow first token must NOT count as idle
         this.buf += chunk;
         let nl;
         // biome-ignore lint/suspicious/noAssignInExpressions: standard line-buffer drain
         while ((nl = this.buf.indexOf("\n")) >= 0) {
             const line = this.buf.slice(0, nl).trim();
             this.buf = this.buf.slice(nl + 1);
-            if (line)
+            if (!line)
+                continue;
+            if (this.mode === "stream-json")
                 this.handle(line);
+            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) {
+            if (this.mode === "raw")
+                this.pushRaw(this.buf);
+            this.buf = "";
         }
     }
+    /** Raw-engine stdout: strip ANSI control codes and append to the transcript. */
+    pushRaw(line) {
+        const clean = stripAnsi(line);
+        if (clean.trim())
+            this.push(clean);
+        if (this.transcript.length > 4000)
+            this.transcript = this.transcript.slice(-3000);
+    }
     handle(line) {
         let ev;
         try {
@@ -181,6 +245,49 @@ export class HeadlessSession {
 function stamp() {
     return new Date().toTimeString().slice(0, 8);
 }
+/** Split a launch command into bin + args, respecting single/double quotes. */
+export function parseCommand(command) {
+    const tokens = [];
+    const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let m;
+    // biome-ignore lint/suspicious/noAssignInExpressions: tokenizer drain
+    while ((m = re.exec(command ?? "")) !== null)
+        tokens.push(m[1] ?? m[2] ?? m[3] ?? "");
+    return { bin: tokens[0] ?? "", args: tokens.slice(1) };
+}
+/** Structural flags PAGS owns for the Claude stream-json engine — a user command
+ *  must not override or duplicate these (and must not orphan their values). */
+const RESERVED_CLAUDE_FLAGS = new Set(["-p", "--print", "--input-format", "--output-format", "--verbose", "--resume"]);
+/**
+ * Build Claude's argv: our structural stream-json flags + the user's extra args
+ * (e.g. `--model`), with reserved flags (and their values) stripped so the user
+ * can't clobber the protocol or leave an orphaned positional. `--resume` is added
+ * last from our persisted session id, never from the user's command.
+ */
+export function buildClaudeArgs(userArgs, resumeId) {
+    const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"];
+    for (let i = 0; i < userArgs.length; i++) {
+        const a = userArgs[i];
+        if (RESERVED_CLAUDE_FLAGS.has(a)) {
+            // drop the flag AND its value (when the next token isn't itself a flag)
+            if (i + 1 < userArgs.length && !userArgs[i + 1].startsWith("-"))
+                i++;
+            continue;
+        }
+        if (!args.includes(a))
+            args.push(a);
+    }
+    if (!args.includes("--dangerously-skip-permissions"))
+        args.push("--dangerously-skip-permissions");
+    if (resumeId)
+        args.push("--resume", resumeId);
+    return args;
+}
+/** Strip ANSI/VT escape sequences so a raw CLI's coloured output reads as plain text. */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: stripping terminal escape codes
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b[()][AB0-2]/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "");
+}
 /** Compact a tool_use input object to a single readable line. */
 function shortInput(input) {
     if (input == null)

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

@@ -40,6 +40,7 @@ export class CodingRuntime {
                 id: input.sessionId,
                 workDir,
                 clientType: input.clientType,
+                command: input.command,
                 env: input.env,
                 statePath: defaultStatePath(this.reposBaseDir),
                 bin: input.bin,

package/package.json

@@ -1,46 +1,46 @@
 {
-	"name": "@proagentstore/cli",
-	"version": "0.2.2",
-	"description": "CLI for creating, publishing, and running ProAgentStore agents",
-	"license": "MIT",
-	"type": "module",
-	"bin": {
-		"pags": "dist/index.js"
-	},
-	"homepage": "https://github.com/ProAgentStore/platform#readme",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/ProAgentStore/platform.git",
-		"directory": "packages/cli"
-	},
-	"keywords": [
-		"proagentstore",
-		"pags",
-		"cli",
-		"agents",
-		"mcp",
-		"browser-runner"
-	],
-	"publishConfig": {
-		"access": "public"
-	},
-	"scripts": {
-		"build": "pnpm --filter @proagentstore/browser-runner build && tsup src/index.ts --format esm --dts && node scripts/copy-browser-runner.mjs",
-		"dev": "tsx src/index.ts",
-		"typecheck": "tsc --noEmit"
-	},
-	"dependencies": {
-		"chalk": "^5.6.2",
-		"commander": "^13.0.0",
-		"playwright": "^1.60.0"
-	},
-	"devDependencies": {
-		"@types/node": "^22.0.0",
-		"tsup": "^8.4.0",
-		"tsx": "^4.21.0",
-		"typescript": "^5.7.0"
-	},
-	"files": [
-		"dist"
-	]
+  "name": "@proagentstore/cli",
+  "version": "0.2.4",
+  "description": "CLI for creating, publishing, and running ProAgentStore agents",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "pags": "dist/index.js"
+  },
+  "homepage": "https://github.com/ProAgentStore/platform#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ProAgentStore/platform.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "proagentstore",
+    "pags",
+    "cli",
+    "agents",
+    "mcp",
+    "browser-runner"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm --filter @proagentstore/browser-runner build && tsup src/index.ts --format esm --dts && node scripts/copy-browser-runner.mjs",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^13.0.0",
+    "playwright": "^1.60.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0"
+  },
+  "files": [
+    "dist"
+  ]
 }