@proagentstore/cli 0.4.24 → 0.4.26

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

@@ -42,6 +42,8 @@ export class HeadlessSession {
     sawOutputSinceInput = false;
     /** Raw-mode: 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;
     constructor(config) {
         this.config = config;
         this.sessionName = `pags-${config.clientType}-${config.id}`;
@@ -60,13 +62,36 @@ export class HeadlessSession {
         this.cmdArgs = bin ? args : fallback.args;
         this.binName = (this.cmdBin.split("/").pop() || this.cmdBin) || "cli";
     }
-    /** 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. */
+    /**
+     * Can this session take a turn? — NOT "is a process executing right now".
+     *
+     * The distinction only appeared with one-shot engines. A persistent Claude session has a
+     * process alive between turns, so the two questions had the same answer and one getter served
+     * both. A one-shot engine has NO process between turns — that is its resting state — so the
+     * process-liveness answer is `false` for every question asked while the session sits idle,
+     * which is exactly when the Pilot asks.
+     *
+     * The cost of conflating them was total: `runCodingLoop` opens with
+     * `if (!snap.alive) return failed("coding session is not running")`, so every delegated goal
+     * on codex/grok/gemini/ollama died at iteration 0 having done nothing, reporting a dead
+     * session that was in fact healthy and answering interactive turns fine.
+     *
+     * So: a one-shot session is alive until `stop()`. Whether a turn is currently executing is
+     * `runState`, which is the question the loop actually has a use for.
+     *
+     * NOTE for the persistent path: 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 signal.
+     */
     get alive() {
+        if (this.oneShot)
+            return !this.stopped;
+        return this.procAlive;
+    }
+    /** Is a process running THIS instant? The persistent engine's liveness, and the spawn guard. */
+    get procAlive() {
         return this.proc !== null && this.proc.exitCode === null && this.proc.signalCode === null;
     }
     /** Idle = ready for the next instruction. */
@@ -125,13 +150,16 @@ export class HeadlessSession {
         return this.mode === "raw";
     }
     start() {
+        // 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;
         // 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)
+        if (this.procAlive)
             return;
         // 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:
@@ -262,7 +290,7 @@ export class HeadlessSession {
         this.run = "idle";
         this.lastOutputAt = Date.now();
     }
-    /** Tear the process down. */
+    /** Tear the process down. For a one-shot engine this is the ONLY thing that ends the session. */
     stop() {
         try {
             this.proc?.kill();
@@ -272,6 +300,7 @@ export class HeadlessSession {
         }
         this.proc = null;
         this.run = "idle";
+        this.stopped = true;
     }
     // ── internals ────────────────────────────────────────────────────────────
     onStdout(chunk) {
@@ -362,14 +391,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.24",
+  "version": "0.4.26",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",