@proagentstore/cli 0.4.23 → 0.4.25

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

@@ -106,7 +106,31 @@ export class HeadlessSession {
         return this.transcript.join("\n");
     }
     /** Launch (or resume) the agent process. Idempotent if already alive. */
+    /**
+     * Raw engines run ONE-SHOT PER TURN, not as a persistent interactive process.
+     *
+     * The persistent design assumed an interactive CLI reading stdin — which is what tmux used to
+     * provide, via a PTY. Without one, `codex` (and grok, and any TUI) dies immediately with
+     * "stdin is not a terminal", so three of the four engines were simply broken.
+     *
+     * AgentCoder solved this before PAGS existed and ran fine on it: `claude -p '<instruction>'`
+     * per turn, plain exec, no PTY and no tmux. Codex's exact analogue is `codex exec`. So the
+     * process is spawned when a turn ARRIVES and exits when the turn ends, rather than being
+     * kept alive for stdin writes that a non-interactive binary will never read.
+     *
+     * Claude keeps its persistent stream-json process — it is explicitly non-interactive and
+     * multi-turn, which is why it survived the migration untouched.
+     */
+    get oneShot() {
+        return this.mode === "raw";
+    }
     start() {
+        // 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) {
+            this.run = "idle";
+            return;
+        }
         if (this.alive)
             return;
         // stream-json: we own the structural flags + --resume; merge the user's extras
@@ -173,14 +197,56 @@ export class HeadlessSession {
                 this.proc?.stdin?.write(`${msg}\n`);
             }
             else {
-                // Raw CLI: write the line to stdin as if typed.
-                this.proc?.stdin?.write(`${text}\n`);
+                // Raw CLI: spawn THIS turn. See `oneShot` — there is no persistent process to
+                // write to, because a non-interactive binary would never have read it.
+                this.runOneShot(text);
             }
         }
         catch {
             /* process may have died; the next snapshot reports not-alive */
         }
     }
+    /**
+     * Run ONE turn as its own process, the way AgentCoder did (`claude -p '<instruction>'`).
+     *
+     * Contract, deliberately general so it is not a Codex special case: **the preset command is a
+     * prefix and the turn text is appended as the final argument.** That makes every prompt-in /
+     * text-out CLI usable by configuration alone —
+     *
+     *   codex exec              → codex exec "<turn>"
+     *   claude -p               → claude -p "<turn>"
+     *   ollama run llama3       → ollama run llama3 "<turn>"
+     *   my-model --flag         → my-model --flag "<turn>"
+     *
+     * — including a local model, with no platform change and no cloud key. Whoever configures the
+     * preset decides what runs and what it costs; the platform does not need to know the engine.
+     */
+    runOneShot(text) {
+        const proc = spawn(this.cmdBin, [...this.cmdArgs, text], {
+            cwd: this.config.workDir,
+            env: mergeEnv(process.env, this.config.env),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        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) => {
+            this.push(`[${this.config.clientType}] failed to start: ${err.message}`);
+            this.run = "idle";
+            this.proc = null;
+        });
+        proc.stdout?.on("data", (d) => this.onStdout(d.toString()));
+        proc.stderr?.on("data", (d) => this.onStdout(d.toString()));
+        proc.on("close", (code) => {
+            // 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.
+            if (code)
+                this.push(`[${this.config.clientType} exited with code ${code}]`);
+            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 */
@@ -296,14 +362,23 @@ export class HeadlessSession {
 function stamp() {
     return new Date().toTimeString().slice(0, 8);
 }
-/** Split a launch command into bin + args, respecting single/double quotes. */
+/**
+ * Split a launch command into bin + args, respecting single/double quotes — the way a shell
+ * would, because that is what a user editing an engine preset is writing.
+ *
+ * Quotes are stripped wherever they appear in a token, not only when they wrap the whole thing.
+ * The earlier alternation (`"…" | '…' | \S+`) only recognised a fully-quoted token, so
+ * `-c model="o3"` reached the engine as the literal `model="o3"` and
+ * `--append-system-prompt="be terse"` split at the space. A preset is free text; it has to
+ * tokenize like the command line it looks like.
+ */
 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] ?? "");
+    // 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 ?? ""));
+    }
     return { bin: tokens[0] ?? "", args: tokens.slice(1) };
 }
 /** Structural flags PAGS owns for the Claude stream-json engine — a user command

package/package.json

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