@proagentstore/cli 0.4.129 → 0.4.131

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.131",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",