@proagentstore/cli 0.4.27 → 0.4.29

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) {
@@ -276,6 +286,9 @@ export class HeadlessSession {
             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()));
@@ -432,11 +445,46 @@ 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 tokenStart = i;
+        let out = "";
+        while (i < src.length) {
+            const ch = src[i];
+            // A DOUBLE quote always opens a span — that is what `--flag "two words"` means and
+            // what anyone typing this expects.
+            //
+            // A SINGLE quote opens one only at a token boundary (token start, or right after `=`),
+            // because in ordinary English it is an apostrophe. This field is a preset text box, not
+            // a shell: a real shell would pair the two apostrophes in `don't guess and don't stop`
+            // and hand the engine `dont guess and dont` plus a stray `stop`, which is exactly the
+            // mangling seen here. `--agent='my agent'` and `'my agent'` still work.
+            const opens = ch === '"' || (ch === "'" && (i === tokenStart || src[i - 1] === "="));
+            if (opens) {
+                const close = src.indexOf(ch, i + 1);
+                if (close !== -1) {
+                    out += src.slice(i + 1, close);
+                    i = close + 1;
+                    continue;
+                }
+                // Unterminated — the character is literal, not the start of a span.
+                out += ch;
+                i++;
+                continue;
+            }
+            if (isSpace(ch))
+                break;
+            out += ch;
+            i++;
+        }
+        tokens.push(out);
     }
     return { bin: tokens[0] ?? "", args: tokens.slice(1) };
 }

package/dist/browser-runner/runner.js

@@ -9,6 +9,7 @@ import { McpRuntime } from "./mcp-runtime.js";
 import { HumanHandoffError, RunnerInputError } from "./errors.js";
 import { RunnerStore } from "./store.js";
 import { CodingRuntime } from "./coding/runtime.js";
+import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
 /** True for a plain object. */
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -30,6 +31,15 @@ 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 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/dist/browser-runner/store.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
 function emptyStore() {
     return {
         sessions: [],
@@ -50,7 +51,7 @@ export class RunnerStore {
             // to "failed", which re-mirrors to the board, resurrects the Retry button, and
             // slips past the API single-flight guard → a second concurrent apply on the one
             // browser page. Mirrors the API carve-out in expireOrphanedRuntimeTasks.
-            if (task.type === "job.apply_agent")
+            if (WORKFLOW_DRIVEN_TASKS.has(task.type))
                 continue;
             if (task.status === "needs_human" || task.status === "running") {
                 task.status = "failed";

package/dist/browser-runner/task-types.js

@@ -0,0 +1,20 @@
+/**
+ * Task types steered by a remote durable Workflow rather than executed by the runner.
+ *
+ * ONE list, in its own module because THREE places need it and they drifted: task creation had
+ * `job.apply_agent || browser.task`, `resumeTakeover` had only `job.apply_agent` (so resolving a
+ * stuck browse handoff destroyed the session), and `RunnerStore.expireInFlightTasks` still
+ * hardcodes its own copy — which meant restarting `pags up` failed a live browse run locally while
+ * the cloud side preserved it, leaving the two views of one durable run disagreeing.
+ *
+ * `browser.handoff` is the synthetic task `browserHandoff` creates for a caller that has none (the
+ * engine sign-in relay mints its own id for a coding session with no runner task). It belongs here
+ * for the same reason: the console's Resume button is agent-agnostic, so without it pressing
+ * Resume would complete and END the takeover mid-sign-in — reintroducing the exact bug the browse
+ * case was fixed for.
+ */
+export const WORKFLOW_DRIVEN_TASKS = new Set([
+    "job.apply_agent",
+    "browser.task",
+    "browser.handoff",
+]);

package/dist/index.js

@@ -1,10 +1,4 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 
 // src/index.ts
 import { createRequire as createRequire3 } from "module";
@@ -371,7 +365,7 @@ jobs:
 });
 
 // src/commands/login.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { createServer } from "http";
 import { homedir } from "os";
 import { join as join3 } from "path";
@@ -472,14 +466,16 @@ var loginCommand = new Command3("login").description("Sign in with Google or Git
   }
 });
 var logoutCommand = new Command3("logout").description("Sign out and remove stored session").action(() => {
+  if (!existsSync3(TOKEN_FILE)) {
+    writeLine("Already signed out.");
+    return;
+  }
   try {
-    if (existsSync3(TOKEN_FILE)) {
-      const { unlinkSync } = __require("fs");
-      unlinkSync(TOKEN_FILE);
-    }
+    unlinkSync(TOKEN_FILE);
     writeLine("Signed out.");
-  } catch {
-    writeLine("Already signed out.");
+  } catch (err) {
+    writeError(`Could not remove ${TOKEN_FILE}: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
   }
 });
 var whoamiCommand = new Command3("whoami").description("Show current signed-in user").action(() => {
@@ -921,7 +917,9 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
     ws.onclose = (ev) => {
       if (reconnecting) return;
       reconnecting = true;
-      const reason = ev.code === 4401 || ev.code === 1008 ? " (token expired \u2014 run `pags login` then `pags up`)" : "";
+      const said = (ev.reason || "").trim();
+      const hint = ev.code === 4401 ? " \u2014 run `pags login`, then `pags up`" : ev.code === 4409 ? " \u2014 run `pags up --force` to take over" : "";
+      const reason = said ? ` (${said}${hint})` : ev.code === 1008 ? " (token expired \u2014 run `pags login` then `pags up`)" : "";
       writeLine(`Relay disconnected: ${instanceId.slice(0, 8)}\u2026${reason} \u2014 reconnecting in ${Math.round(backoffMs / 1e3)}s`);
       setTimeout(() => {
         reconnecting = false;
@@ -943,7 +941,7 @@ function createRunnerCommand() {
   const command = new Command6("runner").description(
     "Manage the local ProAgentStore browser runtime for ProAgentStore agents"
   );
-  command.command("start").description("Start the local ProAgentStore browser runtime in the foreground").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind", "49171").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Require this bearer token").option("--instance-id <id>", "Bind runner requests to a PAGS instance id").option("--headless", "Run Playwright headless").action(async (opts) => {
+  command.command("start").description("Start the local ProAgentStore browser runtime in the foreground").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind (default: first free port from 49171)").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Require this bearer token").option("--instance-id <id>", "Bind runner requests to a PAGS instance id").option("--headless", "Run Playwright headless").action(async (opts) => {
     await startRunnerForeground(opts);
   });
   command.command("connect <instanceIds...>").description("Start ONE local runtime, connect via WebSocket relay, and register it for every given PAGS instance").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind", "49171").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Runner bearer token. Defaults to PAGS_RUNNER_TOKEN or a generated token").option("--headless", "Run Playwright headless").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").option("--runner-version <version>", "Runner version").option("--force", "Take over from another connected machine").action(async (instanceIds, opts) => {
@@ -1184,7 +1182,7 @@ function printStep(label, status) {
   const icon = status === "ok" ? chalk.green("\u2713") : status === "fail" ? chalk.red("\u2717") : chalk.yellow("\u2026");
   console.log(pad + icon + " " + label);
 }
-async function waitForKey(keys) {
+async function waitForKey(keys, onInterrupt) {
   return new Promise((resolve5) => {
     readline.emitKeypressEvents(process.stdin);
     if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -1192,6 +1190,10 @@ async function waitForKey(keys) {
     const onKeypress = (str, key) => {
       if (key?.ctrl && key.name === "c") {
         cleanup();
+        if (onInterrupt) {
+          onInterrupt();
+          return;
+        }
         process.exit(0);
       }
       const val = (str || "").trim().toLowerCase();
@@ -1366,7 +1368,7 @@ var upCommand = new Command7("up").description("Start the browser runner for all
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
   while (true) {
-    const key = await waitForKey(["r", "l", "q"]);
+    const key = await waitForKey(["r", "l", "q"], shutdown);
     if (key === "q") {
       shutdown();
       break;

package/package.json

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