@proagentstore/cli 0.4.129 → 0.4.130

package/dist/browser-runner/crash-reports.js

@@ -0,0 +1,287 @@
+/**
+ * Durable crash reports for the local runner and the CLI that supervises it (#1087).
+ *
+ * Kept BYTE-IDENTICAL at
+ *
+ *   packages/browser-runner/src/crash-reports.ts
+ *   packages/cli/src/crash-reports.ts
+ *
+ * (`packages/cli/src/crash-reports.test.ts` fails the moment they differ) and imports only Node
+ * built-ins, so the CLI — which bundles the runner but cannot import its source — carries a copy.
+ *
+ * ── What it is for
+ *
+ * A runner crash used to be a line on stderr and nothing else: the runtime's `uncaughtException`
+ * handler printed and moved on, a request that threw answered 500 and was forgotten, and a runtime
+ * killed by a signal made `runner connect` exit with no record of the signal. This keeps a BOUNDED,
+ * SANITIZED record of each on disk — so it survives the process, an offline stretch and a restart —
+ * until the CLI, which holds the account token, has delivered it to the platform (`deliver.ts`
+ * there; `POST /v1/runner/crash-reports`, idempotent by `id`). There it is an `error_log` row that
+ * MCP `list_errors(source: "runner-crash")` reads.
+ *
+ * ── One writer per file
+ *
+ * The runtime writes `<dataDir>/crash-reports.json`; the CLI writes its own file. Nobody else writes
+ * either: the CLI records what it has DELIVERED in its own ledger rather than editing the runtime's
+ * file, so two processes never race on one file. A report delivered twice is harmless — the
+ * platform keeps one row per id.
+ *
+ * ── Atomic writes, and what they do not cover
+ *
+ * Every write goes to a temp file in the same directory, is fsync'd, then renamed over the target.
+ * A rename within one filesystem is atomic, so a reader sees the old file or the new one, never half
+ * of either; an interrupted write leaves a stray `*.tmp`, which is removed the next time the file is
+ * opened. LIMITS, stated rather than hidden:
+ *   - a hard kill or power loss BEFORE the rename loses that one write (the file keeps its previous
+ *     contents) — a crash that kills the process before `record` returns is not recorded;
+ *   - the directory entry is not fsync'd, so a power loss just after the rename can still roll the
+ *     file back to its previous version on some filesystems;
+ *   - SIGKILL and an OOM kill run no handler in the dying process at all — only its PARENT can see
+ *     the signal, which is why the CLI records `runner_exit` itself.
+ *
+ * ── Corruption is evidence, not an empty file
+ *
+ * A file that cannot be parsed is MOVED to `<file>.corrupt-<timestamp>` and reported, never read as
+ * empty and overwritten. Quarantined copies are bounded too ({@link MAX_QUARANTINED}).
+ *
+ * ── Bounds
+ *
+ * At most {@link MAX_REPORTS} reports per file (oldest dropped first, and COUNTED in `dropped`);
+ * a message is clipped to 1000 characters and a stack to 4000, marked as cut; credential-shaped
+ * text is masked. Metadata only (ADR 0004): no request or response bodies, no environment.
+ */
+import { closeSync, copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, unlinkSync, writeSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+export const MAX_REPORTS = 100;
+export const MAX_QUARANTINED = 5;
+const MAX_MESSAGE = 1000;
+const MAX_STACK = 4000;
+/** Mask credential-shaped text: bearer tokens, API keys, JWTs, `token=…` pairs. */
+export function maskSecrets(text) {
+    return text
+        .replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, "$1 [redacted]")
+        .replace(/\b(sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{8,}|gho_[A-Za-z0-9]{8,}|github_pat_[A-Za-z0-9_]{8,}|xox[abp]-[A-Za-z0-9-]{8,}|pags_runner_[A-Za-z0-9-]{8,})/g, "[redacted]")
+        .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, "[redacted-jwt]")
+        .replace(/\b((?:api[_-]?key|token|secret|password|authorization)\s*[=:]\s*)("?)[^\s"&]{4,}\2/gi, "$1[redacted]");
+}
+/** A stable, non-identifying key for an account — the same as the runner lock's (`runner-lock.ts`). */
+export function crashAccountKey(login) {
+    return createHash("sha256").update(login.trim().toLowerCase()).digest("hex").substring(0, 12);
+}
+/** Clip VISIBLY: a cut value says it was cut and by how much. */
+function clip(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.substring(0, max)}\n[cut: showing the first ${max} of ${text.length} characters]`;
+}
+const clean = (value, max) => clip(maskSecrets(String(value ?? "")), max);
+const shortId = (value) => (typeof value === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value) ? value : undefined);
+/** The error's message, stack and cause, sanitized and bounded. */
+export function describeError(error) {
+    if (error instanceof Error) {
+        const cause = error.cause;
+        return {
+            message: clean(`${error.name}: ${error.message}`, MAX_MESSAGE),
+            stack: error.stack ? clean(error.stack, MAX_STACK) : undefined,
+            cause: cause === undefined ? undefined : clean(cause instanceof Error ? `${cause.name}: ${cause.message}` : cause, MAX_MESSAGE),
+        };
+    }
+    return { message: clean(error, MAX_MESSAGE) };
+}
+/**
+ * The runtime's own identity for its reports: the build and account `runner connect` passes it in
+ * `PAGS_RUNNER_BUILD` / `PAGS_RUNNER_ACCOUNT`. Absent for a bare `pags runner start`.
+ */
+export function runtimeCrashIdentity(env = process.env) {
+    return { source: "runtime", build: env.PAGS_RUNNER_BUILD || undefined, account: env.PAGS_RUNNER_ACCOUNT || undefined };
+}
+/** Build a report from what is known — every field bounded, ids id-shaped or dropped. */
+export function crashReport(input) {
+    return {
+        id: shortId(input.id) ?? `crash_${randomUUID()}`,
+        at: input.at ?? new Date().toISOString(),
+        source: input.source,
+        kind: input.kind,
+        message: clean(input.message, MAX_MESSAGE),
+        ...(input.stack ? { stack: clean(input.stack, MAX_STACK) } : {}),
+        ...(input.cause ? { cause: clean(input.cause, MAX_MESSAGE) } : {}),
+        ...(input.exitCode !== undefined ? { exitCode: input.exitCode } : {}),
+        ...(input.signal !== undefined ? { signal: input.signal } : {}),
+        ...(shortId(input.build) ? { build: input.build } : {}),
+        ...(shortId(input.account) ? { account: input.account } : {}),
+        ...(shortId(input.instanceId) ? { instanceId: input.instanceId } : {}),
+        ...(shortId(input.sessionId) ? { sessionId: input.sessionId } : {}),
+        ...(shortId(input.taskId) ? { taskId: input.taskId } : {}),
+        ...(input.route ? { route: clean(input.route, 200) } : {}),
+        ...(input.tail?.length ? { tail: input.tail.slice(-20).map((line) => clean(line, 300)) } : {}),
+    };
+}
+/**
+ * Write `data` as JSON atomically: temp file in the same directory, fsync, rename. Throws on
+ * failure — the caller decides whether that may surface.
+ */
+export function writeJsonAtomic(path, data, mode = 0o600) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    const fd = openSync(tmp, "w", mode);
+    try {
+        writeSync(fd, `${JSON.stringify(data, null, 2)}\n`);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    try {
+        renameSync(tmp, path);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch {
+            // The temp file is already gone; the rename's own error is the one that matters.
+        }
+        throw error;
+    }
+}
+/** Remove temp files an interrupted {@link writeJsonAtomic} left beside `path`. */
+export function removeStaleTemps(path) {
+    const dir = dirname(path);
+    const prefix = `${basename(path)}.`;
+    if (!existsSync(dir))
+        return;
+    for (const name of readdirSync(dir)) {
+        if (!name.startsWith(prefix) || !name.endsWith(".tmp"))
+            continue;
+        try {
+            unlinkSync(join(dir, name));
+        }
+        catch {
+            // Another process may own it; a temp file is never read, so leaving it is safe.
+        }
+    }
+}
+/**
+ * Read a JSON file. A file that does not parse is MOVED aside to `<path>.corrupt-<timestamp>` —
+ * kept as evidence, and out of the way so the next write cannot overwrite it — and reported as
+ * `quarantined`. At most {@link MAX_QUARANTINED} quarantined copies are kept per file.
+ */
+export function readJsonOrQuarantine(path) {
+    removeStaleTemps(path);
+    if (!existsSync(path))
+        return { status: "missing" };
+    try {
+        return { status: "ok", value: JSON.parse(readFileSync(path, "utf-8")) };
+    }
+    catch (error) {
+        const quarantinedTo = `${path}.corrupt-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+        try {
+            renameSync(path, quarantinedTo);
+        }
+        catch {
+            // Could not move it: keep a COPY instead, so the caller's next write cannot destroy the
+            // only evidence. If even that fails the report says so.
+            try {
+                copyFileSync(path, quarantinedTo);
+            }
+            catch (copyError) {
+                return { status: "quarantined", quarantinedTo: "(not preserved)", error: `${describeError(error).message}; preserving it failed: ${describeError(copyError).message}` };
+            }
+        }
+        pruneQuarantine(path);
+        return { status: "quarantined", quarantinedTo, error: describeError(error).message };
+    }
+}
+function pruneQuarantine(path) {
+    const dir = dirname(path);
+    const prefix = `${basename(path)}.corrupt-`;
+    const copies = readdirSync(dir).filter((name) => name.startsWith(prefix)).sort();
+    const excess = copies.length - MAX_QUARANTINED;
+    for (const name of excess > 0 ? copies.slice(0, excess) : []) {
+        try {
+            unlinkSync(join(dir, name));
+        }
+        catch {
+            // Best-effort pruning; an extra copy is a bounded cost.
+        }
+    }
+}
+/**
+ * One process's crash-report file. Synchronous throughout: it is called from `uncaughtException`
+ * and from an `exit` listener, where nothing asynchronous is guaranteed to run.
+ */
+export class CrashLog {
+    path;
+    base;
+    /** `base` stamps the reports this log writes about ITSELF (a quarantined file). */
+    constructor(path, base = { source: "runtime" }) {
+        this.path = path;
+        this.base = base;
+    }
+    /** Everything still on disk, oldest first. A corrupt file is quarantined and reported, then read as a fresh file. */
+    read() {
+        const got = readJsonOrQuarantine(this.path);
+        if (got.status === "ok") {
+            const reports = Array.isArray(got.value.reports) ? got.value.reports.filter((r) => !!r && typeof r.id === "string") : [];
+            return { reports, dropped: Number(got.value.dropped) || 0 };
+        }
+        if (got.status === "missing")
+            return { reports: [], dropped: 0 };
+        // The quarantine itself is a report in the fresh file, so the evidence is pointed at, not lost.
+        const file = {
+            reports: [crashReport({ ...this.base, kind: "store_corrupt", message: `crash-report file was unreadable and was moved to ${basename(got.quarantinedTo)}: ${got.error}` })],
+            dropped: 0,
+        };
+        this.write(file);
+        return file;
+    }
+    /** Append a report (bounded). Never throws: a crash path must not crash on its own record. */
+    record(report) {
+        try {
+            const file = this.read();
+            if (file.reports.some((r) => r.id === report.id))
+                return true;
+            file.reports.push(report);
+            const over = file.reports.length - MAX_REPORTS;
+            if (over > 0) {
+                file.reports = file.reports.slice(over);
+                file.dropped += over;
+            }
+            this.write(file);
+            return true;
+        }
+        catch (error) {
+            process.stderr.write(`[crash-reports] could not record ${report.kind}: ${describeError(error).message}\n`);
+            return false;
+        }
+    }
+    /** Drop reports by id — only by this file's own writer. */
+    remove(ids) {
+        if (!ids.length)
+            return;
+        const file = this.read();
+        const gone = new Set(ids);
+        file.reports = file.reports.filter((r) => !gone.has(r.id));
+        this.write(file);
+    }
+    write(file) {
+        writeJsonAtomic(this.path, file);
+    }
+}
+/**
+ * Record process-level crashes in `log`. The process keeps running afterwards (a runner that died on
+ * every stray error would drop its relay), so `onCrash` is where a caller adds its own line.
+ */
+export function installCrashHandlers(log, base, onCrash) {
+    process.on("uncaughtException", (error) => {
+        const report = crashReport({ ...base, kind: "uncaught_exception", ...describeError(error) });
+        log.record(report);
+        onCrash?.(report);
+    });
+    process.on("unhandledRejection", (reason) => {
+        const report = crashReport({ ...base, kind: "unhandled_rejection", ...describeError(reason) });
+        log.record(report);
+        onCrash?.(report);
+    });
+}

package/dist/browser-runner/index.js

@@ -1,19 +1,10 @@
 #!/usr/bin/env node
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { CrashLog, crashReport, describeError, installCrashHandlers, runtimeCrashIdentity } from "./crash-reports.js";
 import { startRunnerServer } from "./server.js";
 import { reapOnStartup } from "./reaper.js";
 import { randomUUID } from "node:crypto";
-// Resilience: a stray error in any runtime must NOT take the whole runner down —
-// that drops the tunnel and forces the user to restart `pags up` (and lose their
-// session). Log it and keep serving. Per-component handlers catch most things;
-// this is the last-resort backstop.
-process.on("uncaughtException", (err) => {
-    process.stderr.write(`[runner] uncaught: ${err?.stack || String(err)}\n`);
-});
-process.on("unhandledRejection", (reason) => {
-    process.stderr.write(`[runner] unhandled rejection: ${String(reason)}\n`);
-});
 function arg(name, fallback) {
     const index = process.argv.indexOf(name);
     if (index === -1)
@@ -67,6 +58,18 @@ Endpoints:
     process.exit(0);
 }
 const config = configFromArgs();
+// Resilience: a stray error in any runtime must NOT take the whole runner down —
+// that drops the tunnel and forces the user to restart `pags up` (and lose their
+// session). Keep serving. Per-component handlers catch most things; this is the
+// last-resort backstop — and since #1087 it leaves a DURABLE record, which the CLI
+// delivers to the platform (MCP `list_errors`), instead of a stderr line only.
+// Build and account come from `runner connect` (`runtimeCrashIdentity`); the CLI delivers a report
+// only under the account that wrote it.
+const IDENTITY = runtimeCrashIdentity();
+const crashLog = new CrashLog(join(config.dataDir, "crash-reports.json"), IDENTITY);
+installCrashHandlers(crashLog, IDENTITY, (report) => {
+    process.stderr.write(`[runner] ${report.kind === "uncaught_exception" ? "uncaught" : "unhandled rejection"}: ${report.stack || report.message}\n`);
+});
 // SECURITY: the runner's endpoints spawn CLIs and drive a browser as the user.
 // Without a token, `authorize()` allows every request, so a tokenless runner must
 // never be reachable off the local machine. Refuse to start if bound to a
@@ -83,8 +86,27 @@ if (!config.token && !LOOPBACK.has(config.host)) {
 // machine to load 253. Nothing in-process can clean those up, so we do it here,
 // before we start competing for the same CPU. Narrow by construction: see the
 // SAFETY block in reaper.ts for why the user's real Chrome can never match.
-reapOnStartup((line) => process.stderr.write(`${line}\n`));
-const started = await startRunnerServer(config);
+/** A failure before the runtime serves anything: recorded, said, and the process exits non-zero. */
+function startupFailed(stage, error) {
+    const report = crashReport({ ...IDENTITY, kind: "startup_failure", instanceId: config.instanceId, ...describeError(error), route: stage });
+    crashLog.record(report);
+    process.stderr.write(`[runner] could not start (${stage}): ${report.message}\n`);
+    process.exit(1);
+}
+try {
+    reapOnStartup((line) => process.stderr.write(`${line}\n`));
+}
+catch (error) {
+    // The reaper is housekeeping: its failure is recorded, and the runtime still starts.
+    crashLog.record(crashReport({ ...IDENTITY, kind: "startup_failure", ...describeError(error), route: "reap" }));
+}
+let started;
+try {
+    started = await startRunnerServer(config);
+}
+catch (error) {
+    startupFailed("listen", error);
+}
 process.stdout.write(`ProAgentStore browser runtime listening at ${started.url}\n`);
 process.stdout.write(`Data dir: ${config.dataDir}\n`);
 process.stdout.write("Control plane: PAGS; runtime plane: PAGS; brain placement: PAGS; runner role: tool-executor\n");

package/dist/browser-runner/request-failure.js

@@ -0,0 +1,19 @@
+import { crashReport, describeError, runtimeCrashIdentity } from "./crash-reports.js";
+/**
+ * A request that failed on the runtime's side (5xx), as a crash report (#1087): method, path and the
+ * correlation ids the URL and headers carry — the instance header, a `/tasks/:id`, a `/sessions/:id`.
+ * Never the body. Called from the server's one request boundary.
+ */
+export function recordRequestFailure(log, req, error) {
+    const path = (req.url || "").split("?")[0];
+    const instance = req.headers["x-pags-instance-id"];
+    log.record(crashReport({
+        ...runtimeCrashIdentity(),
+        kind: "request_failure",
+        ...describeError(error),
+        route: `${req.method ?? "?"} ${path}`,
+        instanceId: typeof instance === "string" ? instance : undefined,
+        taskId: /\/tasks\/([^/]+)/.exec(path)?.[1],
+        sessionId: /\/sessions\/([^/]+)/.exec(path)?.[1],
+    }));
+}

package/dist/browser-runner/runner.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { CrashLog, runtimeCrashIdentity } from "./crash-reports.js";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
@@ -81,6 +82,8 @@ export class LocalRunner {
     /** The profile dir Chrome was actually launched into (holds DevToolsActivePort). */
     launchedProfileDir = null;
     store;
+    /** This runtime's crash reports (#1087) — delivered to the platform by the CLI that runs it. */
+    crashLog;
     /** Local tmux coding sessions (the second runtime — AgentCoder port). */
     coding;
     /** Local CLI browser research (#944): a signed-in Codex / Claude Code CLI researching through the policy bridge. */
@@ -99,6 +102,7 @@ export class LocalRunner {
         this.config = config;
         mkdirSync(config.dataDir, { recursive: true });
         this.store = new RunnerStore(config.dataDir);
+        this.crashLog = new CrashLog(join(config.dataDir, "crash-reports.json"), runtimeCrashIdentity());
         this.coding = new CodingRuntime(join(config.dataDir, "repos"));
         const { browserFor, applyBrowserFor } = createRunnerBrowserFactories({ headless: config.headless, defaultTools: () => this.getMcp(), sharedPage: () => this.activePage });
         this.localBrowser = new LocalBrowserRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, browserFor });

package/dist/browser-runner/server.js

@@ -1,5 +1,6 @@
 import { createServer, } from "node:http";
 import { URL } from "node:url";
+import { recordRequestFailure } from "./request-failure.js";
 import { LocalRunner, RunnerInputError } from "./runner.js";
 import { probeGitSshIdentity } from "./coding/repo.js";
 import { checkEngine } from "./coding/engine-check.js";
@@ -30,6 +31,11 @@ export function createRunnerServer(runner) {
         }
         catch (error) {
             const status = error instanceof RunnerInputError ? error.status : 500;
+            // A request that failed on the runner's side is a crash report (#1087), not just a 500 to
+            // the caller: method, path and correlation ids from the URL and headers — never the body.
+            // A caller's bad input (`RunnerInputError`) is answered, not recorded.
+            if (status >= 500)
+                recordRequestFailure(runner.crashLog, req, error);
             json(res, status, {
                 error: error instanceof Error ? error.message : String(error),
             });
@@ -39,8 +45,15 @@ export function createRunnerServer(runner) {
 export async function startRunnerServer(config) {
     const runner = new LocalRunner(config);
     const server = createRunnerServer(runner);
-    await new Promise((resolve) => {
-        server.listen(config.port, config.host, resolve);
+    // A bind failure (EADDRINUSE, EACCES) REJECTS (#1087). It used to be an `error` event with no
+    // listener — an uncaught exception that the crash handler swallows, leaving a runtime that never
+    // started and never exited. Now the entrypoint records a `startup_failure` and exits non-zero.
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(config.port, config.host, () => {
+            server.off("error", reject);
+            resolve();
+        });
     });
     const address = server.address();
     const actualPort = address.port;

package/dist/browser-runner/store.js

@@ -1,6 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
+import { CrashLog, crashReport, readJsonOrQuarantine, runtimeCrashIdentity, writeJsonAtomic } from "./crash-reports.js";
 import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
+/** Events kept in the local store. Older ones are dropped — and counted in `droppedEvents`. */
+export const MAX_EVENTS = 500;
 function emptyStore() {
     return {
         sessions: [],
@@ -8,10 +10,26 @@ function emptyStore() {
         events: [],
     };
 }
+/**
+ * The runner's local sessions / tasks / events file.
+ *
+ * Crash-safe since #1087: every write is atomic (temp file + fsync + rename, `crash-reports.ts`), so
+ * a crash mid-write leaves the previous file intact rather than a truncated one; and a file that
+ * does not parse is QUARANTINED (moved to `runner-store.json.corrupt-<time>`) and reported in the
+ * crash log for delivery to the platform — it used to read as an empty store, and the next write
+ * then overwrote the evidence. Limits are those of `writeJsonAtomic`: the write in flight at a hard
+ * kill or power loss is lost, never half-applied.
+ */
 export class RunnerStore {
     filePath;
+    crashLog;
     constructor(dataDir) {
         this.filePath = join(dataDir, "runner-store.json");
+        this.crashLog = new CrashLog(join(dataDir, "crash-reports.json"), runtimeCrashIdentity());
+    }
+    /** How many events the buffer has dropped, ever. */
+    droppedEventCount() {
+        return this.read().droppedEvents ?? 0;
     }
     listSessions() {
         return this.read().sessions;
@@ -84,7 +102,10 @@ export class RunnerStore {
             createdAt: new Date().toISOString(),
         };
         data.events.unshift(row);
-        data.events = data.events.slice(0, 500);
+        if (data.events.length > MAX_EVENTS) {
+            data.droppedEvents = (data.droppedEvents ?? 0) + (data.events.length - MAX_EVENTS);
+            data.events.length = MAX_EVENTS;
+        }
         this.write(data);
         return row;
     }
@@ -92,24 +113,26 @@ export class RunnerStore {
         return this.read().events.slice(0, limit);
     }
     read() {
-        if (!existsSync(this.filePath))
+        const got = readJsonOrQuarantine(this.filePath);
+        if (got.status === "missing")
             return emptyStore();
-        try {
-            const parsed = JSON.parse(readFileSync(this.filePath, "utf-8"));
-            return {
-                sessions: Array.isArray(parsed.sessions) ? parsed.sessions : [],
-                tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
-                events: Array.isArray(parsed.events) ? parsed.events : [],
-            };
-        }
-        catch {
+        if (got.status === "quarantined") {
+            // Evidence, not an empty store: the file is moved aside, the move is reported, and only
+            // then does the runner continue on a fresh store.
+            const message = `runner store was unreadable and was moved to ${got.quarantinedTo}: ${got.error}`;
+            process.stderr.write(`[store] ${message}\n`);
+            this.crashLog.record(crashReport({ ...runtimeCrashIdentity(), kind: "store_corrupt", message }));
             return emptyStore();
         }
+        const parsed = got.value;
+        return {
+            sessions: Array.isArray(parsed.sessions) ? parsed.sessions : [],
+            tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
+            events: Array.isArray(parsed.events) ? parsed.events : [],
+            droppedEvents: Number(parsed.droppedEvents) || 0,
+        };
     }
     write(data) {
-        mkdirSync(dirname(this.filePath), { recursive: true });
-        writeFileSync(this.filePath, `${JSON.stringify(data, null, 2)}\n`, {
-            mode: 0o600,
-        });
+        writeJsonAtomic(this.filePath, data);
     }
 }

package/dist/index.js

@@ -1174,7 +1174,7 @@ var publishCommand = new Command7("publish").description("Publish an agent to Pr
 
 // src/commands/runner/command.ts
 import { spawn as spawn4 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { Command as Command8 } from "commander";
 
 // src/commands/runner/process.ts
@@ -2905,6 +2905,274 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
   };
 }
 
+// src/crash-reports.ts
+import { closeSync as closeSync2, copyFileSync, existsSync as existsSync8, fsyncSync, mkdirSync as mkdirSync7, openSync as openSync2, readdirSync, readFileSync as readFileSync8, renameSync as renameSync3, unlinkSync as unlinkSync3, writeSync as writeSync2 } from "fs";
+import { basename, dirname as dirname4, join as join9 } from "path";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+var MAX_REPORTS = 100;
+var MAX_QUARANTINED = 5;
+var MAX_MESSAGE = 1e3;
+var MAX_STACK = 4e3;
+function maskSecrets(text) {
+  return text.replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, "$1 [redacted]").replace(/\b(sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9]{8,}|gho_[A-Za-z0-9]{8,}|github_pat_[A-Za-z0-9_]{8,}|xox[abp]-[A-Za-z0-9-]{8,}|pags_runner_[A-Za-z0-9-]{8,})/g, "[redacted]").replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, "[redacted-jwt]").replace(/\b((?:api[_-]?key|token|secret|password|authorization)\s*[=:]\s*)("?)[^\s"&]{4,}\2/gi, "$1[redacted]");
+}
+function crashAccountKey(login) {
+  return createHash2("sha256").update(login.trim().toLowerCase()).digest("hex").substring(0, 12);
+}
+function clip(text, max) {
+  if (text.length <= max) return text;
+  return `${text.substring(0, max)}
+[cut: showing the first ${max} of ${text.length} characters]`;
+}
+var clean2 = (value, max) => clip(maskSecrets(String(value ?? "")), max);
+var shortId = (value) => typeof value === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value) ? value : void 0;
+function describeError(error) {
+  if (error instanceof Error) {
+    const cause = error.cause;
+    return {
+      message: clean2(`${error.name}: ${error.message}`, MAX_MESSAGE),
+      stack: error.stack ? clean2(error.stack, MAX_STACK) : void 0,
+      cause: cause === void 0 ? void 0 : clean2(cause instanceof Error ? `${cause.name}: ${cause.message}` : cause, MAX_MESSAGE)
+    };
+  }
+  return { message: clean2(error, MAX_MESSAGE) };
+}
+function crashReport(input) {
+  return {
+    id: shortId(input.id) ?? `crash_${randomUUID3()}`,
+    at: input.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    source: input.source,
+    kind: input.kind,
+    message: clean2(input.message, MAX_MESSAGE),
+    ...input.stack ? { stack: clean2(input.stack, MAX_STACK) } : {},
+    ...input.cause ? { cause: clean2(input.cause, MAX_MESSAGE) } : {},
+    ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
+    ...input.signal !== void 0 ? { signal: input.signal } : {},
+    ...shortId(input.build) ? { build: input.build } : {},
+    ...shortId(input.account) ? { account: input.account } : {},
+    ...shortId(input.instanceId) ? { instanceId: input.instanceId } : {},
+    ...shortId(input.sessionId) ? { sessionId: input.sessionId } : {},
+    ...shortId(input.taskId) ? { taskId: input.taskId } : {},
+    ...input.route ? { route: clean2(input.route, 200) } : {},
+    ...input.tail?.length ? { tail: input.tail.slice(-20).map((line) => clean2(line, 300)) } : {}
+  };
+}
+function writeJsonAtomic(path, data, mode = 384) {
+  mkdirSync7(dirname4(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${randomUUID3()}.tmp`;
+  const fd = openSync2(tmp, "w", mode);
+  try {
+    writeSync2(fd, `${JSON.stringify(data, null, 2)}
+`);
+    fsyncSync(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  try {
+    renameSync3(tmp, path);
+  } catch (error) {
+    try {
+      unlinkSync3(tmp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function removeStaleTemps(path) {
+  const dir = dirname4(path);
+  const prefix = `${basename(path)}.`;
+  if (!existsSync8(dir)) return;
+  for (const name of readdirSync(dir)) {
+    if (!name.startsWith(prefix) || !name.endsWith(".tmp")) continue;
+    try {
+      unlinkSync3(join9(dir, name));
+    } catch {
+    }
+  }
+}
+function readJsonOrQuarantine(path) {
+  removeStaleTemps(path);
+  if (!existsSync8(path)) return { status: "missing" };
+  try {
+    return { status: "ok", value: JSON.parse(readFileSync8(path, "utf-8")) };
+  } catch (error) {
+    const quarantinedTo = `${path}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+    try {
+      renameSync3(path, quarantinedTo);
+    } catch {
+      try {
+        copyFileSync(path, quarantinedTo);
+      } catch (copyError) {
+        return { status: "quarantined", quarantinedTo: "(not preserved)", error: `${describeError(error).message}; preserving it failed: ${describeError(copyError).message}` };
+      }
+    }
+    pruneQuarantine(path);
+    return { status: "quarantined", quarantinedTo, error: describeError(error).message };
+  }
+}
+function pruneQuarantine(path) {
+  const dir = dirname4(path);
+  const prefix = `${basename(path)}.corrupt-`;
+  const copies = readdirSync(dir).filter((name) => name.startsWith(prefix)).sort();
+  const excess = copies.length - MAX_QUARANTINED;
+  for (const name of excess > 0 ? copies.slice(0, excess) : []) {
+    try {
+      unlinkSync3(join9(dir, name));
+    } catch {
+    }
+  }
+}
+var CrashLog = class {
+  /** `base` stamps the reports this log writes about ITSELF (a quarantined file). */
+  constructor(path, base = { source: "runtime" }) {
+    this.path = path;
+    this.base = base;
+  }
+  path;
+  base;
+  /** Everything still on disk, oldest first. A corrupt file is quarantined and reported, then read as a fresh file. */
+  read() {
+    const got = readJsonOrQuarantine(this.path);
+    if (got.status === "ok") {
+      const reports = Array.isArray(got.value.reports) ? got.value.reports.filter((r) => !!r && typeof r.id === "string") : [];
+      return { reports, dropped: Number(got.value.dropped) || 0 };
+    }
+    if (got.status === "missing") return { reports: [], dropped: 0 };
+    const file = {
+      reports: [crashReport({ ...this.base, kind: "store_corrupt", message: `crash-report file was unreadable and was moved to ${basename(got.quarantinedTo)}: ${got.error}` })],
+      dropped: 0
+    };
+    this.write(file);
+    return file;
+  }
+  /** Append a report (bounded). Never throws: a crash path must not crash on its own record. */
+  record(report) {
+    try {
+      const file = this.read();
+      if (file.reports.some((r) => r.id === report.id)) return true;
+      file.reports.push(report);
+      const over = file.reports.length - MAX_REPORTS;
+      if (over > 0) {
+        file.reports = file.reports.slice(over);
+        file.dropped += over;
+      }
+      this.write(file);
+      return true;
+    } catch (error) {
+      process.stderr.write(`[crash-reports] could not record ${report.kind}: ${describeError(error).message}
+`);
+      return false;
+    }
+  }
+  /** Drop reports by id — only by this file's own writer. */
+  remove(ids) {
+    if (!ids.length) return;
+    const file = this.read();
+    const gone = new Set(ids);
+    file.reports = file.reports.filter((r) => !gone.has(r.id));
+    this.write(file);
+  }
+  write(file) {
+    writeJsonAtomic(this.path, file);
+  }
+};
+
+// src/crash-delivery.ts
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join10 } from "path";
+var BATCH = 50;
+var LEDGER_MAX = 1e3;
+var TIMEOUT_MS = 1e4;
+function runnerDataDir(dataDir, env = process.env) {
+  return dataDir || env.PAGS_RUNNER_DATA_DIR || join10(homedir4(), ".config", "proagentstore", "browser-runner");
+}
+function crashPaths(configDir2, account, dataDir) {
+  const key = crashAccountKey(account);
+  return {
+    runtimeFile: join10(runnerDataDir(dataDir), "crash-reports.json"),
+    cliFile: join10(configDir2, `runner-crashes-${key}.json`),
+    ledgerFile: join10(configDir2, `crash-delivered-${key}.json`)
+  };
+}
+function readRuntimeReports(path) {
+  if (!existsSync9(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
+    return Array.isArray(parsed.reports) ? parsed.reports.filter((r) => r && typeof r.id === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function readLedger(path) {
+  const got = readJsonOrQuarantine(path);
+  return got.status === "ok" && Array.isArray(got.value.ids) ? got.value.ids.filter((id) => typeof id === "string") : [];
+}
+async function deliverCrashReports(opts) {
+  const key = crashAccountKey(opts.account);
+  const cliLog = new CrashLog(opts.paths.cliFile, { source: "cli", account: key });
+  const acked = new Set(readLedger(opts.paths.ledgerFile));
+  const mine = (r) => r.account === key && !acked.has(r.id);
+  const pending = [...readRuntimeReports(opts.paths.runtimeFile).filter(mine), ...cliLog.read().reports.filter(mine)];
+  if (!pending.length) return { delivered: 0, pending: 0 };
+  const doFetch = opts.fetchImpl ?? fetch;
+  const accepted = [];
+  let error;
+  for (let i = 0; i < pending.length; i += BATCH) {
+    const batch = pending.slice(i, i + BATCH);
+    try {
+      const res = await doFetch(`${opts.apiBase.replace(/\/$/, "")}/v1/errors/runner-crashes`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${opts.token}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ reports: batch }),
+        signal: AbortSignal.timeout(TIMEOUT_MS)
+      });
+      if (!res.ok) {
+        error = `the platform answered ${res.status}`;
+        break;
+      }
+      const body = await res.json().catch(() => ({}));
+      if (Array.isArray(body.accepted)) accepted.push(...body.accepted.filter((id) => typeof id === "string"));
+    } catch (e) {
+      error = e instanceof Error ? e.message : String(e);
+      break;
+    }
+  }
+  if (accepted.length) {
+    const ledger = [...acked, ...accepted];
+    writeJsonAtomic(opts.paths.ledgerFile, { ids: ledger.slice(Math.max(0, ledger.length - LEDGER_MAX)) });
+    cliLog.remove(accepted);
+  }
+  return { delivered: accepted.length, pending: pending.length - accepted.length, ...error ? { error } : {} };
+}
+var OutputTail = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  buffer = [];
+  partial = "";
+  push(chunk) {
+    const parts = (this.partial + chunk.toString()).split("\n");
+    this.partial = parts.pop() ?? "";
+    for (const line of parts) {
+      if (!line.trim()) continue;
+      this.buffer.push(line);
+      if (this.buffer.length > this.max) this.buffer.shift();
+    }
+  }
+  lines() {
+    return this.partial.trim() ? [...this.buffer, this.partial].slice(-this.max) : [...this.buffer];
+  }
+};
+function recordChildExit(o) {
+  const account = crashAccountKey(o.account);
+  const how = o.signal ? `was killed by ${o.signal}` : `exited unexpectedly${o.code !== null ? ` (code ${o.code})` : ""}`;
+  const report = crashReport({ source: "cli", account, build: o.build, kind: o.kind, message: `${o.what} ${how}`, exitCode: o.code, signal: o.signal, tail: o.tail });
+  new CrashLog(o.paths.cliFile, { source: "cli", account }).record(report);
+  return report;
+}
+
 // src/commands/runner/command.ts
 import { hostname as hostname5 } from "os";
 function collectCapability(value, previous = []) {
@@ -2918,7 +3186,7 @@ function createRunnerCommand() {
     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").option("--watch-instances", "Attach newly eligible agents while running, without a restart").action(async (instanceIds, opts) => {
-    const runnerToken = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN) || `pags_runner_${randomUUID3()}`;
+    const runnerToken = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN) || `pags_runner_${randomUUID4()}`;
     const host = clean(opts.host) || "127.0.0.1";
     const port = clean(opts.port) || String(await findFreePort2(49171));
     const lockAccount = clean(process.env.PAGS_LOCK_ACCOUNT) || "";
@@ -2939,6 +3207,8 @@ function createRunnerCommand() {
     const primary = instanceIds[0];
     const runnerOpts = { ...opts, host, port, token: runnerToken };
     const spec = runnerSpawnSpec(runnerOpts);
+    const crashAccount = lockAccount || loadSession()?.user.login || "";
+    const crashes = crashAccount ? crashPaths(configDir(), crashAccount, opts.dataDir) : null;
     const runner = spawn4(spec.command, spec.args, {
       cwd: spec.cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -2948,16 +3218,36 @@ function createRunnerCommand() {
       // replace is an authorisation rather than a signal aimed at a name pattern.
       env: {
         ...process.env,
+        PAGS_RUNNER_BUILD: CLI_VERSION,
+        ...crashAccount ? { PAGS_RUNNER_ACCOUNT: crashAccountKey(crashAccount) } : {},
         ...lockHeld ? { PAGS_RUNNER_RSID: lockHeld.rsid, PAGS_RUNNER_CONTROL_NONCE: lockHeld.nonce, PAGS_RUNNER_LAUNCH: lockHeld.launch } : {}
       }
     });
+    const tail = new OutputTail(20);
     runner.stdout?.on("data", (data) => process.stdout.write(data));
-    runner.stderr?.on("data", (data) => process.stderr.write(data));
+    runner.stderr?.on("data", (data) => {
+      process.stderr.write(data);
+      tail.push(data);
+    });
+    const deliver = async () => {
+      if (!crashes) return;
+      const token = clean(opts.pagsToken) || clean(process.env.PAGS_TOKEN) || clean(loadSession()?.token);
+      if (!token) return;
+      const result = await deliverCrashReports({ apiBase: pagsApiBase(opts.apiBase), token, account: crashAccount, paths: crashes });
+      if (result.delivered) writeLine(`Delivered ${result.delivered} crash report(s) to ProAgentStore.`);
+    };
     let shuttingDown = false;
-    runner.on("exit", (code) => {
+    runner.on("exit", (code, signal) => {
       if (shuttingDown) return;
-      writeError(`Local browser runtime exited unexpectedly${code ? ` (code ${code})` : ""}. Run \`pags up\` again to reconnect.`);
-      process.exit(code ?? 1);
+      const how = signal ? `was killed by ${signal}` : `exited unexpectedly${code !== null ? ` (code ${code})` : ""}`;
+      writeError(`Local browser runtime ${how}. Run \`pags up\` again to reconnect.`);
+      if (crashes) recordChildExit({ paths: crashes, account: crashAccount, build: CLI_VERSION, kind: "runner_exit", what: "the local runtime", code, signal, tail: tail.lines() });
+      const finish = () => process.exit(code ?? 1);
+      const deadline = setTimeout(finish, 5e3);
+      void deliver().catch(() => void 0).finally(() => {
+        clearTimeout(deadline);
+        finish();
+      });
     });
     const shutdown = () => {
       shuttingDown = true;
@@ -2977,6 +3267,8 @@ function createRunnerCommand() {
       await waitForLocalRunner({ url: localUrl, token: runnerToken, instanceId: primary });
       writeLine(`Local browser runtime healthy at ${localUrl}`);
       await connectViaRelay(instanceIds, localUrl, runnerToken, opts, Boolean(opts.force), Boolean(opts.watchInstances));
+      void deliver().catch(() => void 0);
+      setInterval(() => void deliver().catch(() => void 0), 5 * 6e4).unref();
       await new Promise((resolvePromise) => {
         runner.on("exit", () => resolvePromise());
       });
@@ -3098,27 +3390,27 @@ function createRunnerCommand() {
 var runnerCommand = createRunnerCommand();
 
 // src/commands/status.ts
-import { readFileSync as readFileSync9, statSync as statSync2, watchFile } from "fs";
+import { readFileSync as readFileSync11, statSync as statSync2, watchFile } from "fs";
 import { Command as Command9 } from "commander";
 
 // src/background.ts
 import { spawn as nodeSpawn } from "child_process";
-import { closeSync as closeSync2, existsSync as existsSync8, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync8, renameSync as renameSync3, statSync, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname4, join as join9 } from "path";
+import { closeSync as closeSync3, existsSync as existsSync10, mkdirSync as mkdirSync8, openSync as openSync3, readFileSync as readFileSync10, renameSync as renameSync4, statSync, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, join as join11 } from "path";
 var BACKGROUND_ENV = "PAGS_BACKGROUND";
 var BACKGROUND_LOG_ENV = "PAGS_BACKGROUND_LOG";
 var BACKGROUND_RESTART_ENV = "PAGS_BACKGROUND_RESTART";
 var LOG_ROTATE_BYTES = 5 * 1024 * 1024;
-var backgroundLogPath = (account, env = process.env) => join9(configDir(env), "logs", `runner-${accountKey(account)}.log`);
-var backgroundStatePath = (account, env = process.env) => join9(configDir(env), `background-${accountKey(account)}.json`);
+var backgroundLogPath = (account, env = process.env) => join11(configDir(env), "logs", `runner-${accountKey(account)}.log`);
+var backgroundStatePath = (account, env = process.env) => join11(configDir(env), `background-${accountKey(account)}.json`);
 function writeBackgroundState(path, state) {
-  mkdirSync7(dirname4(path), { recursive: true });
+  mkdirSync8(dirname5(path), { recursive: true });
   writeFileSync6(path, `${JSON.stringify(state)}
 `, { mode: 384 });
 }
 function readBackgroundState(path) {
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync10(path, "utf-8"));
     return parsed?.v === 1 && Number.isInteger(parsed.pid) ? parsed : null;
   } catch {
     return null;
@@ -3130,7 +3422,7 @@ function rotateLog(path, maxBytes = LOG_ROTATE_BYTES) {
   } catch {
     return false;
   }
-  renameSync3(path, `${path}.1`);
+  renameSync4(path, `${path}.1`);
   return true;
 }
 function shellQuote(arg, platform = process.platform) {
@@ -3142,16 +3434,16 @@ function backgroundRestartCommand(execPath, script, upArgs, platform = process.p
   return platform === "win32" ? `set ${BACKGROUND_RESTART_ENV}=1&& ${argv}` : `${BACKGROUND_RESTART_ENV}=1 ${argv}`;
 }
 function spawnDetached(command, args, env, logPath, spawn5 = nodeSpawn) {
-  mkdirSync7(dirname4(logPath), { recursive: true });
+  mkdirSync8(dirname5(logPath), { recursive: true });
   rotateLog(logPath);
-  const fd = openSync2(logPath, "a", 384);
+  const fd = openSync3(logPath, "a", 384);
   try {
     const child = spawn5(command, args, { detached: true, stdio: ["ignore", fd, fd], env, windowsHide: true });
     child.unref();
     if (!child.pid) throw new Error("the runner process did not start");
     return child.pid;
   } finally {
-    closeSync2(fd);
+    closeSync3(fd);
   }
 }
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -3175,8 +3467,8 @@ async function waitUntilTakeable(read, opts = {}) {
   }
 }
 function tailLines(path, n) {
-  if (!existsSync8(path)) return null;
-  const lines = readFileSync8(path, "utf-8").split("\n");
+  if (!existsSync10(path)) return null;
+  const lines = readFileSync10(path, "utf-8").split("\n");
   if (lines.at(-1) === "") lines.pop();
   return lines.slice(Math.max(0, lines.length - n));
 }
@@ -3231,7 +3523,7 @@ var logsCommand = new Command9("logs").description("Show the background runner's
   watchFile(path, { interval: 1e3 }, (cur) => {
     if (cur.size < offset) offset = 0;
     if (cur.size === offset) return;
-    process.stdout.write(readFileSync9(path).subarray(offset, cur.size));
+    process.stdout.write(readFileSync11(path).subarray(offset, cur.size));
     offset = cur.size;
   });
 });
@@ -3735,14 +4027,21 @@ var upCommand = new Command10("up").description("Start the browser runner for al
     }
   };
   let childDead = false;
+  let stopping = false;
   child.stdout?.on("data", handleOutput);
   child.stderr?.on("data", handleOutput);
-  child.on("exit", (code) => {
+  const crashes = crashPaths(configDir(), session.user.login);
+  const recordConnectExit = (code, signal, tail) => {
+    recordChildExit({ paths: crashes, account: session.user.login, build: CLI_VERSION2, kind: "connect_exit", what: "runner connect", code, signal, tail });
+    void deliverCrashReports({ apiBase: API_BASE3, token: session.token, account: session.user.login, paths: crashes }).catch(() => void 0);
+  };
+  child.on("exit", (code, signal) => {
     if (code === RUNNER_RESTART_EXIT_CODE) {
       restartUp("Runner updated remotely \u2014 restarting pags up on the new version\u2026", { PAGS_NO_PROMPT: "1" });
       return;
     }
     childDead = true;
+    if (code !== 0 && !stopping) recordConnectExit(code, signal ?? null, logs.slice(-20));
     if (code === null) {
       state.runner = "error";
       state.lastEvent = "Runner stopped by another process (signal) \u2014 it is not connected any more";
@@ -3765,6 +4064,7 @@ var upCommand = new Command10("up").description("Start the browser runner for al
     process.exit(1);
   }
   const shutdown = () => {
+    stopping = true;
     child.kill();
     clearScreen();
     writeLine("  Runner stopped.");

package/package.json

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