@proagentstore/cli 0.4.149 → 0.4.150

package/dist/bootstrap.js

@@ -2,13 +2,21 @@
 import {
   BOOTSTRAP_ENV,
   NO_SELF_UPDATE_ENV,
+  TRIAL_MS,
+  badVersions,
+  beginTrial,
   cachedPayloads,
   installPayload,
   latestPublishedVersion,
+  logUpdateStep,
+  markBad,
   newestPayload,
+  noteTrialStart,
   olderThan,
-  payloadAt
-} from "./chunk-NNA7VZ6W.js";
+  payloadAt,
+  payloadRoot,
+  readTrial
+} from "./chunk-PKMXQJEJ.js";
 
 // src/bootstrap.ts
 import { existsSync } from "fs";
@@ -17,20 +25,41 @@ import { fileURLToPath } from "url";
 
 // src/bootstrap/stub.ts
 import { pathToFileURL } from "url";
+var STUB_RESTART_EXIT_CODE = 75;
+var RESTARTED_BY = ["PAGS_UP_SUPERVISED", "PAGS_UP_LAUNCHER", "PAGS_SERVICE"];
+function trialApplies(args) {
+  const command = args.find((a) => !a.startsWith("-"));
+  return command === "up" || command === "runner";
+}
 function checksForUpdate(args) {
   return args.find((a) => !a.startsWith("-")) === "up";
 }
 async function runStub(deps) {
-  const log = deps.log ?? ((line) => process.stderr.write(`${line}
-`));
-  const local = () => newestPayload([...deps.bundled ? [deps.bundled] : [], ...(deps.cached ?? cachedPayloads)()]);
+  const log = deps.log ?? ((line) => {
+    process.stderr.write(`${line}
+`);
+    logUpdateStep(`stub: ${line}`);
+  });
+  const root = deps.root ?? payloadRoot();
+  const now = deps.now ?? Date.now;
+  const env = deps.env ?? process.env;
+  const all = () => [...deps.bundled ? [deps.bundled] : [], ...(deps.cached ?? cachedPayloads)()];
+  const local = (without = []) => {
+    const skip = /* @__PURE__ */ new Set([...Object.keys(badVersions(root)), ...without]);
+    return newestPayload(all().filter((p) => !skip.has(p.version))) ?? (without.length ? null : newestPayload(all()));
+  };
   let chosen = local();
-  if (checksForUpdate(deps.args) && !deps.fromSource && process.env[NO_SELF_UPDATE_ENV] !== "1") {
+  if (checksForUpdate(deps.args) && !deps.fromSource && env[NO_SELF_UPDATE_ENV] !== "1") {
     const latest = await (deps.latest ?? (() => latestPublishedVersion(15e3)))();
-    if (latest && (!chosen || olderThan(chosen.version, latest))) {
+    const bad = latest ? badVersions(root)[latest] : void 0;
+    if (latest && bad) {
+      log(`pags: ${latest} is published, but this machine rolled back from it (${bad}) \u2014 staying on ${chosen?.version ?? "nothing"}`);
+    } else if (latest && (!chosen || olderThan(chosen.version, latest))) {
       log(`pags: updating ${chosen?.version ?? "(none)"} \u2192 ${latest}\u2026`);
       try {
+        const previous = chosen?.version ?? null;
         chosen = await (deps.install ?? ((v) => installPayload(v)))(latest);
+        beginTrial(root, chosen.version, previous, now());
         log(`pags: now on ${chosen.version}`);
       } catch (e) {
         log(`pags: could not fetch ${latest} (${e instanceof Error ? e.message : String(e)}) \u2014 starting ${chosen?.version ?? "nothing"} instead`);
@@ -38,10 +67,46 @@ async function runStub(deps) {
     }
   }
   if (!chosen) throw new Error("pags: no CLI to run \u2014 reinstall with `npm i -g @proagentstore/cli`");
-  process.env[BOOTSTRAP_ENV] = deps.self;
-  await (deps.load ?? ((entry) => import(pathToFileURL(entry).href)))(chosen.entry);
+  if (trialApplies(deps.args)) {
+    const verdict = noteTrialStart(root, chosen.version, now());
+    if (verdict.kind === "give-up") {
+      const fallback = local([chosen.version]);
+      markBad(root, chosen.version, verdict.reason, fallback?.version ?? null, now());
+      log(`pags: giving up on ${chosen.version} \u2014 ${verdict.reason}; rolling back to ${fallback?.version ?? "nothing"}`);
+      if (fallback) chosen = fallback;
+    } else if (verdict.kind === "trial") {
+      watchTrial(root, chosen.version, deps, log, now, env);
+    }
+  }
+  if (trialApplies(deps.args)) logUpdateStep(`stub: running ${chosen.version} for pags ${deps.args.find((a) => !a.startsWith("-"))}`);
+  env[BOOTSTRAP_ENV] = deps.self;
+  const load = deps.load ?? ((entry) => import(pathToFileURL(entry).href));
+  try {
+    await load(chosen.entry);
+  } catch (e) {
+    const fallback = readTrial(root)?.version === chosen.version ? local([chosen.version]) : null;
+    if (!fallback) throw e;
+    const why = `it crashed on start: ${e instanceof Error ? e.message : String(e)}`;
+    markBad(root, chosen.version, why, fallback.version, now());
+    log(`pags: giving up on ${chosen.version} \u2014 ${why}; rolling back to ${fallback.version}`);
+    chosen = fallback;
+    await load(chosen.entry);
+  }
   return chosen;
 }
+function watchTrial(root, version, deps, log, now, env) {
+  const startedAt = readTrial(root)?.startedAt ?? now();
+  const timer = (deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms)))(() => {
+    const given = badVersions(root)[version];
+    if (readTrial(root)?.version !== version && !given) return;
+    const reason = `it did not register with the platform within ${TRIAL_MS / 6e4} minutes of first starting`;
+    if (!given) markBad(root, version, reason, readTrial(root)?.previous ?? null, now());
+    const supervised = RESTARTED_BY.some((k) => !!env[k]);
+    log(`pags: giving up on ${version} \u2014 ${given ?? reason}.${supervised ? " Restarting on the previous version." : ' The next "pags up" runs the previous version.'}`);
+    if (supervised) (deps.exit ?? ((code) => process.exit(code)))(STUB_RESTART_EXIT_CODE);
+  }, Math.max(0, startedAt + TRIAL_MS - now()));
+  timer.unref?.();
+}
 
 // src/bootstrap.ts
 var self = fileURLToPath(import.meta.url);

package/dist/chunk-PKMXQJEJ.js

@@ -0,0 +1,281 @@
+// src/bootstrap/payload.ts
+import { execFile } from "child_process";
+import { existsSync, mkdirSync as mkdirSync2, mkdtempSync, readdirSync, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2, win32 } from "path";
+import { promisify } from "util";
+
+// src/bootstrap/trial.ts
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+var TRIAL_MS = 5 * 6e4;
+var MAX_TRIAL_STARTS = 6;
+var trialPath = (root) => join(root, ".trial.json");
+var badPath = (root) => join(root, ".bad.json");
+var noticePath = (root) => join(root, ".rollback.json");
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJson(root, path, value) {
+  mkdirSync(root, { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, JSON.stringify(value));
+  renameSync(temp, path);
+}
+function readTrial(root) {
+  const t = readJson(trialPath(root));
+  if (!t || typeof t.version !== "string" || typeof t.installedAt !== "number") return null;
+  return {
+    version: t.version,
+    previous: typeof t.previous === "string" ? t.previous : null,
+    installedAt: t.installedAt,
+    ...typeof t.startedAt === "number" ? { startedAt: t.startedAt } : {},
+    starts: typeof t.starts === "number" && t.starts >= 0 ? t.starts : 0
+  };
+}
+function beginTrial(root, version, previous, now = Date.now()) {
+  if (version === previous) return;
+  try {
+    writeJson(root, trialPath(root), { version, previous, installedAt: now, starts: 0 });
+  } catch {
+  }
+}
+function badVersions(root) {
+  const raw = readJson(badPath(root));
+  const out = {};
+  for (const [v, why] of Object.entries(raw?.versions ?? {})) if (typeof why === "string") out[v] = why;
+  return out;
+}
+function markBad(root, version, reason, to, now = Date.now()) {
+  try {
+    writeJson(root, badPath(root), { versions: { ...badVersions(root), [version]: reason.slice(0, 300) } });
+    writeJson(root, noticePath(root), { from: version, to, reason: reason.slice(0, 300), at: now });
+    if (readTrial(root)?.version === version) rmSync(trialPath(root), { force: true });
+  } catch {
+  }
+}
+function markPayloadHealthy(root, version) {
+  const trial = readTrial(root);
+  if (trial?.version !== version) return false;
+  rmSync(trialPath(root), { force: true });
+  return true;
+}
+function takeRollbackNotice(root) {
+  const n = readJson(noticePath(root));
+  rmSync(noticePath(root), { force: true });
+  if (!n || typeof n.from !== "string" || typeof n.reason !== "string") return null;
+  return { from: n.from, to: typeof n.to === "string" ? n.to : null, reason: n.reason, at: typeof n.at === "number" ? n.at : 0 };
+}
+function noteTrialStart(root, version, now = Date.now()) {
+  const trial = readTrial(root);
+  if (!trial || trial.version !== version) return { kind: "none" };
+  if (trial.startedAt !== void 0 && now - trial.startedAt >= TRIAL_MS) {
+    return { kind: "give-up", reason: `it did not register with the platform within ${TRIAL_MS / 6e4} minutes of first starting` };
+  }
+  if (trial.starts >= MAX_TRIAL_STARTS) {
+    return { kind: "give-up", reason: `it was started ${trial.starts} times without registering with the platform` };
+  }
+  const next = { ...trial, startedAt: trial.startedAt ?? now, starts: trial.starts + 1 };
+  try {
+    writeJson(root, trialPath(root), next);
+  } catch {
+  }
+  return { kind: "trial", trial: next };
+}
+
+// src/bootstrap/payload.ts
+var run = promisify(execFile);
+var CLI_PACKAGE = "@proagentstore/cli";
+var BOOTSTRAP_ENV = "PAGS_BOOTSTRAP";
+var NO_SELF_UPDATE_ENV = "PAGS_NO_SELF_UPDATE";
+var KEEP = 2;
+function payloadRoot() {
+  return process.env.PAGS_CLI_CACHE || join2(homedir(), ".config", "proagentstore", "cli");
+}
+function isVersion(v) {
+  return typeof v === "string" && /^(\d+)\.(\d+)\.(\d+)/.test(v.trim());
+}
+function olderThan(a, b) {
+  const parse = (v) => /^(\d+)\.(\d+)\.(\d+)/.exec(v.trim())?.slice(1).map(Number);
+  const x = parse(a);
+  const y = parse(b);
+  if (!x || !y) return false;
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] < y[i];
+  return false;
+}
+function payloadAt(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync2(join2(dir, "package.json"), "utf-8"));
+    if (pkg.name !== CLI_PACKAGE || !pkg.version) return null;
+    const entry = join2(dir, pkg.pagsPayload || "dist/index.js");
+    return existsSync(entry) ? { version: pkg.version, entry } : null;
+  } catch {
+    return null;
+  }
+}
+var installedAt = (prefix) => join2(prefix, "node_modules", ...CLI_PACKAGE.split("/"));
+var packageDir = (root, version) => installedAt(join2(root, version));
+function cachedPayloads(root = payloadRoot()) {
+  let names;
+  try {
+    names = readdirSync(root);
+  } catch {
+    return [];
+  }
+  return names.flatMap((v) => v.startsWith(".") ? [] : payloadAt(packageDir(root, v)) ?? []);
+}
+function newestPayload(payloads) {
+  return payloads.reduce((best, p) => !best || olderThan(best.version, p.version) ? p : best, null);
+}
+var CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+function quoteCmdArg(arg) {
+  const quoted = `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`;
+  return quoted.replace(CMD_META, "^$1").replace(CMD_META, "^$1");
+}
+var envVar = (env, name) => env[Object.keys(env).find((k) => k.toUpperCase() === name) ?? name];
+function npmInvocation(args, deps = {}) {
+  if ((deps.platform ?? process.platform) !== "win32") return { file: "npm", args };
+  const env = deps.env ?? process.env;
+  const exists = deps.exists ?? existsSync;
+  const execPath = deps.execPath ?? process.execPath;
+  const cli = (dir) => win32.join(dir, "node_modules", "npm", "bin", "npm-cli.js");
+  const onPath = (envVar(env, "PATH") ?? "").split(";").filter((dir) => dir && exists(win32.join(dir, "npm.cmd")));
+  for (const dir of [...onPath, win32.dirname(execPath)]) {
+    if (exists(cli(dir))) return { file: execPath, args: [cli(dir), ...args] };
+  }
+  const line = ["npm", ...args.map(quoteCmdArg)].join(" ");
+  return { file: envVar(env, "COMSPEC") || "cmd.exe", args: ["/d", "/s", "/c", `"${line}"`], windowsVerbatimArguments: true };
+}
+function runNpm(args, options) {
+  const npm = npmInvocation(args);
+  return run(npm.file, npm.args, { ...options, ...npm.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {} });
+}
+async function latestPublishedRelease(timeoutMs = 3e4, signal, deps = {}) {
+  try {
+    const { stdout } = await (deps.runNpm ?? runNpm)(["view", CLI_PACKAGE, "version"], { timeout: timeoutMs, signal });
+    const version = String(stdout).trim();
+    return version ? { version } : { error: "npm printed no version" };
+  } catch (e) {
+    return { error: npmFailure(e) };
+  }
+}
+function npmFailure(e) {
+  const err = e;
+  const stderr = String(err?.stderr ?? "").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const npmErrors = stderr.filter((l) => /npm (ERR!|error)/i.test(l));
+  const why = npmErrors.slice(0, 2).join(" ") || stderr.at(-1) || (err?.killed || err?.signal ? `npm did not answer in time (${String(err.signal ?? "killed")})` : "") || (typeof err?.code === "string" ? `npm could not be started (${err.code}: ${String(err.message ?? "")})` : "") || String(err?.message ?? e);
+  return why.replace(/\s+/g, " ").trim().slice(0, 300);
+}
+async function latestPublishedVersion(timeoutMs = 3e4, signal) {
+  const r = await latestPublishedRelease(timeoutMs, signal);
+  return "version" in r ? r.version : null;
+}
+async function npmInstallInto(dir, version) {
+  try {
+    await runNpm(["install", "--prefix", dir, "--omit=dev", "--no-audit", "--no-fund", "--no-save", `${CLI_PACKAGE}@${version}`], { timeout: 5 * 6e4 });
+  } catch (e) {
+    const stderr = String(e.stderr ?? "").trim();
+    throw new Error((stderr || (e instanceof Error ? e.message : String(e))).slice(-400));
+  }
+}
+async function installPayload(version, root = payloadRoot(), install = npmInstallInto) {
+  const done = payloadAt(packageDir(root, version));
+  if (done) return done;
+  mkdirSync2(root, { recursive: true });
+  const scratch = mkdtempSync(join2(root, `.install-${version}-`));
+  try {
+    await install(scratch, version);
+    if (payloadAt(installedAt(scratch))?.version !== version) throw new Error(`npm installed no ${CLI_PACKAGE}@${version}`);
+    try {
+      renameSync2(scratch, join2(root, version));
+    } catch (e) {
+      if (!payloadAt(packageDir(root, version))) throw e;
+    }
+  } finally {
+    rmSync2(scratch, { recursive: true, force: true });
+  }
+  const payload = payloadAt(packageDir(root, version));
+  if (!payload) throw new Error(`${CLI_PACKAGE}@${version} is not usable after install`);
+  const bad = badVersions(root);
+  const others = cachedPayloads(root).filter((p) => p.version !== version).sort((a, b) => olderThan(a.version, b.version) ? 1 : -1);
+  const kept = new Set(others.filter((p) => !bad[p.version]).slice(0, KEEP - 1).map((p) => p.version));
+  for (const old of others) if (!kept.has(old.version)) rmSync2(join2(root, old.version), { recursive: true, force: true });
+  return payload;
+}
+
+// src/bootstrap/update-log.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join3 } from "path";
+var MAX_BYTES = 256 * 1024;
+var UPDATE_LOG_UPLOAD_CHARS = 4e3;
+function updateLogPath(env = process.env) {
+  return env.PAGS_UPDATE_LOG?.trim() || join3(env.PAGS_CONFIG_DIR?.trim() || join3(homedir2(), ".config", "proagentstore"), "update.log");
+}
+function logUpdateStep(step, env = process.env, now = /* @__PURE__ */ new Date()) {
+  const path = updateLogPath(env);
+  try {
+    mkdirSync3(dirname(path), { recursive: true });
+    if (existsSync2(path) && statSync(path).size > MAX_BYTES) {
+      const text = readFileSync3(path, "utf8");
+      writeFileSync2(path, text.slice(text.indexOf("\n", text.length / 2) + 1));
+    }
+    appendFileSync(path, `${now.toISOString()} [${process.pid}] ${step.replace(/\s*\n\s*/g, " | ")}
+`);
+  } catch {
+  }
+}
+function updateLogTail(env = process.env, maxChars = UPDATE_LOG_UPLOAD_CHARS) {
+  try {
+    const text = readFileSync3(updateLogPath(env), "utf8").trimEnd();
+    if (!text) return null;
+    if (text.length <= maxChars) return text;
+    const cut = text.slice(-maxChars);
+    return cut.slice(cut.indexOf("\n") + 1);
+  } catch {
+    return null;
+  }
+}
+function updateLogUpload(version, env = process.env) {
+  let pending = updateLogTail(env);
+  return {
+    /** The field for a status report while the upload is pending. */
+    body: () => pending ? { updateLog: pending } : {},
+    /** The platform answered a report of this start. */
+    answered: () => {
+      if (pending === null) return;
+      pending = null;
+      logUpdateStep(`registered: ${version} answered by the platform`, env);
+    }
+  };
+}
+
+export {
+  TRIAL_MS,
+  readTrial,
+  beginTrial,
+  badVersions,
+  markBad,
+  markPayloadHealthy,
+  takeRollbackNotice,
+  noteTrialStart,
+  CLI_PACKAGE,
+  BOOTSTRAP_ENV,
+  NO_SELF_UPDATE_ENV,
+  payloadRoot,
+  isVersion,
+  olderThan,
+  payloadAt,
+  cachedPayloads,
+  newestPayload,
+  runNpm,
+  latestPublishedRelease,
+  latestPublishedVersion,
+  installPayload,
+  logUpdateStep,
+  updateLogUpload
+};

package/dist/index.js

@@ -2,12 +2,19 @@
 import {
   BOOTSTRAP_ENV,
   CLI_PACKAGE,
+  badVersions,
+  beginTrial,
   installPayload,
   isVersion,
   latestPublishedRelease,
+  logUpdateStep,
+  markPayloadHealthy,
   olderThan,
-  runNpm
-} from "./chunk-NNA7VZ6W.js";
+  payloadRoot,
+  runNpm,
+  takeRollbackNotice,
+  updateLogUpload
+} from "./chunk-PKMXQJEJ.js";
 
 // src/index.ts
 import { createRequire as createRequire3 } from "module";
@@ -1361,6 +1368,7 @@ function deferredUpdateLeaseActive(lease, now = Date.now()) {
   return now < lease.expiresAt;
 }
 function leaveForRestart(restarter, deps = { spawn: spawn3, exit: (code) => process.exit(code) }) {
+  logUpdateStep(`restart: leaving for the ${restarter} restarter (${restarter === "command" ? "restart command started, exit 0" : `exit ${RUNNER_RESTART_EXIT_CODE}`})`);
   if (restarter === "command") {
     deps.spawn(process.env[RESTART_COMMAND_ENV], { shell: true, detached: true, stdio: "ignore", env: process.env }).unref();
     deps.exit(0);
@@ -1379,6 +1387,8 @@ function planRunnerUpdate(f) {
   if (f.fromSource) return { action: "refused", current: f.current, reason: "This runner runs from a source checkout \u2014 update it with `git pull` there, not npm." };
   if (!f.latest) return { action: "refused", current: f.current, reason: `npm could not be asked for the latest ${CLI_PACKAGE} from this machine${f.latestError ? `: ${f.latestError}` : "."}`, retryable: true };
   if (!olderThan(f.current, f.latest)) return { action: "up-to-date", current: f.current };
+  const rolledBack = f.rolledBack?.[f.latest];
+  if (rolledBack) return { action: "refused", current: f.current, reason: `${f.latest} was installed here and rolled back: ${rolledBack}. This machine stays on ${f.current} until a newer release is published.`, retryable: true };
   if (!f.restarter) {
     return {
       action: "refused",
@@ -1411,17 +1421,24 @@ function planRunnerRestart(f) {
   }
   return { action: "restart", current: f.current, restarter: f.restarter };
 }
-async function installVersion(version2) {
-  if (process.env[BOOTSTRAP_ENV]) {
-    await installPayload(version2);
-    return;
-  }
+async function installVersion(version2, current = null) {
+  const bootstrapped = !!process.env[BOOTSTRAP_ENV];
+  logUpdateStep(`install: ${current ?? "?"} \u2192 ${version2} starting (${bootstrapped ? "payload cache" : "npm i -g"})`);
   try {
-    await runNpm(["i", "-g", `${CLI_PACKAGE}@${version2}`], { timeout: 5 * 6e4 });
+    if (bootstrapped) {
+      await installPayload(version2);
+      beginTrial(payloadRoot(), version2, current);
+    } else {
+      await runNpm(["i", "-g", `${CLI_PACKAGE}@${version2}`], { timeout: 5 * 6e4 }).catch((e) => {
+        const stderr = String(e.stderr ?? "").trim();
+        throw new Error((stderr || (e instanceof Error ? e.message : String(e))).slice(-400));
+      });
+    }
   } catch (e) {
-    const stderr = String(e.stderr ?? "").trim();
-    throw new Error((stderr || (e instanceof Error ? e.message : String(e))).slice(-400));
+    logUpdateStep(`install: ${version2} FAILED \u2014 ${e instanceof Error ? e.message : String(e)}`);
+    throw e;
   }
+  logUpdateStep(`install: ${version2} installed`);
 }
 
 // src/commands/runner/membership.ts
@@ -1776,13 +1793,15 @@ function parseAutoUpdatePolicy(value) {
   const lastAttemptAt = raw.lastAttemptAt ?? raw.last_attempt_at;
   const reason = raw.reason;
   const recovery = parseRecovery(raw.recovery);
+  const fleet = raw.fleetUpdating ?? raw.fleet_updating;
   return {
     autoUpdate,
     ...status ? { status } : {},
     ...typeof latestVersion === "string" ? { latestVersion } : {},
     ...typeof lastAttemptAt === "string" ? { lastAttemptAt } : {},
     ...typeof reason === "string" ? { reason } : {},
-    ...recovery ? { recovery } : {}
+    ...recovery ? { recovery } : {},
+    ...typeof fleet === "number" && Number.isInteger(fleet) && fleet >= 0 ? { fleetUpdating: fleet } : {}
   };
 }
 function policyFromResponse(value) {
@@ -1843,7 +1862,9 @@ function acceptPolicyResponse(local, wasAuthoritative, response) {
   const { recovery: _fromService, ...remote } = parsed;
   const action = policyScheduleAction(local, remote, wasAuthoritative);
   const ownerTransition = action === "cancel" || !local.autoUpdate;
-  return { policy: ownerTransition ? { ...local, ...remote } : { ...local, autoUpdate: remote.autoUpdate }, action };
+  const { fleetUpdating: _stale, ...base } = local;
+  const fleet = remote.fleetUpdating === void 0 ? {} : { fleetUpdating: remote.fleetUpdating };
+  return { policy: ownerTransition ? { ...base, ...remote, ...fleet } : { ...base, autoUpdate: remote.autoUpdate, ...fleet }, action };
 }
 var ResponseFence = class {
   sent = 0;
@@ -2068,6 +2089,12 @@ var AutomaticUpdateController = class {
       this.defer();
       return;
     }
+    if (policy.fleetUpdating) {
+      this.blockerClass = "fleet_stagger";
+      this.deps.status("waiting-for-idle", { latestVersion: plan.latest, reason: `${policy.fleetUpdating} other machine(s) on this account are mid-update; this one updates after them.` });
+      this.defer(plan.latest);
+      return;
+    }
     const target = open && isVersion(open.target) ? open.target : plan.latest;
     const attempt = { ...plan, latest: target };
     const recovery = open ?? { target, attachments: [...this.deps.attachments?.() ?? []], at: new Date(this.now()).toISOString() };
@@ -2077,7 +2104,7 @@ var AutomaticUpdateController = class {
       this.deps.status("restarting", { latestVersion: target, reason: void 0 });
       return;
     }
-    this.blockerClass = "idle_wait";
+    this.blockerClass = this.deps.policy().value.fleetUpdating ? "fleet_stagger" : "idle_wait";
     this.defer(target);
   }
   defer(latest) {
@@ -2250,7 +2277,10 @@ function createPolicyChannel(deps) {
     if (action === "cancel") deps.onAction("cancel");
     else if (action === "start" && !deps.cell.refreshing) deps.onAction("start");
   };
-  const accept = (response, sentAs) => act(deps.cell.accept(response, sentAs));
+  const accept = (response, sentAs) => {
+    act(deps.cell.accept(response, sentAs));
+    deps.onAnswer?.();
+  };
   const register = async (id, force = deps.force, signal) => {
     const sent = deps.cell.next();
     try {
@@ -2300,7 +2330,7 @@ function createInstallBridge(deps) {
     if (automatic) {
       const fresh = await within((signal) => deps.refresh(signal));
       if (fresh === null) expired(false, "The owner policy refresh before installing");
-      if (!fresh || !deps.cell.policy.autoUpdate) {
+      if (!fresh || !deps.cell.policy.autoUpdate || deps.cell.policy.fleetUpdating) {
         release(false);
         return false;
       }
@@ -2344,6 +2374,27 @@ function createInstallBridge(deps) {
   return { run, inFlight: () => inFlight, installedPendingRestart: () => installedPendingRestart };
 }
 
+// src/commands/runner/release-trial.ts
+function releaseTrial(version2, cell, log, env = process.env, root = payloadRoot) {
+  if (!env[BOOTSTRAP_ENV]) return { rollbackReason: null, proven: () => void 0, rolledBack: () => ({}) };
+  const notice = takeRollbackNotice(root());
+  const rollbackReason = notice ? `Rolled back from ${notice.from} to ${version2}: ${notice.reason}.` : null;
+  if (rollbackReason) {
+    log(`auto-update: ${rollbackReason}`);
+    cell.record("failure", { reason: rollbackReason, recovery: void 0 });
+  }
+  let done = false;
+  return {
+    rollbackReason,
+    proven: () => {
+      if (done) return;
+      done = true;
+      if (markPayloadHealthy(root(), version2)) log(`auto-update: ${version2} registered \u2014 it is kept.`);
+    },
+    rolledBack: () => badVersions(root())
+  };
+}
+
 // src/commands/runner/relay.ts
 var MEMBERSHIP_SYNC_PATH = "/pags/membership/sync";
 var CLI_CONTROL_PATHS = /* @__PURE__ */ new Set([MEMBERSHIP_SYNC_PATH, RUNNER_UPDATE_PATH, RUNNER_RESTART_PATH]);
@@ -2355,12 +2406,15 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   const machine = loadMachineIdentity(runnerNode);
   const autoUpdateKey = machine.id ? autoUpdatePolicyKey(machine.id) : "";
   const cell = new PolicyCell(autoUpdateKey ? loadAutoUpdatePolicy(autoUpdateKey) ?? { autoUpdate: false } : { autoUpdate: false }, (p) => saveAutoUpdatePolicy(autoUpdateKey, p), !!autoUpdateKey);
+  const trial = releaseTrial(CLI_VERSION, cell, writeLine);
   let scheduleAutomaticUpdate = () => void 0;
   let autoUpdateDiagnostics = () => ({});
+  const updateLog = updateLogUpload(CLI_VERSION);
   const autoUpdateStatusBody = () => ({
     status: autoUpdateStatusWire(cell.policy.status),
     latestVersion: cell.policy.latestVersion,
     error: cell.policy.reason,
+    ...updateLog.body(),
     ...autoUpdateDiagnostics()
   });
   const capabilities = await requestRunner("GET", "/capabilities", { url: localUrl, token: runnerToken, instanceId: instanceIds[0] });
@@ -2387,7 +2441,11 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       lastRegisterError = msg;
       writeError(`register ${id.slice(0, 8)}\u2026 failed: ${msg}`);
     },
-    onAction: (action) => scheduleAutomaticUpdate(action === "start", action === "cancel")
+    onAction: (action) => scheduleAutomaticUpdate(action === "start", action === "cancel"),
+    onAnswer: () => {
+      trial.proven();
+      updateLog.answered();
+    }
   });
   const registered = channel.registered;
   const registerRuntime = (id, forceClaim = force) => channel.register(id, forceClaim);
@@ -2424,6 +2482,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       ..."error" in release ? { latestError: release.error } : {},
       fromSource: runsFromSource(),
       restarter: restarterFrom(process.env),
+      rolledBack: trial.rolledBack(),
       // A restart ends browser/application work too. Give these durable names to the same
       // planner so neither manual nor automatic update can mistake them for an idle machine.
       busy
@@ -2434,7 +2493,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     cell,
     refresh: channel.refresh,
     facts: updateFacts,
-    install: installVersion,
+    install: (version2) => installVersion(version2, CLI_VERSION),
     admission: relayMutationAdmission,
     leaseActive: deferredUpdateLeaseActive,
     detachAll: () => {
@@ -3531,7 +3590,7 @@ var logsCommand = new Command9("logs").description("Show the background runner's
 // src/commands/up.ts
 import { createRequire as createRequire2 } from "module";
 import { Command as Command10 } from "commander";
-import { hostname as hostname7 } from "os";
+import { homedir as homedir5, hostname as hostname7, userInfo } from "os";
 
 // src/tui.ts
 import chalk from "chalk";
@@ -3653,32 +3712,35 @@ async function waitForKey(keys, onInterrupt) {
 // src/commands/up-restart.ts
 import { spawn as nodeSpawn2, spawnSync as nodeSpawnSync } from "child_process";
 var UP_LAUNCHER_ENV = "PAGS_UP_LAUNCHER";
-function upRestartMode(env, platform, canExecve) {
+function upRestartMode(env) {
   if (env[SERVICE_ENV] === "1") return "service";
   if (env[RESTART_COMMAND_ENV]?.trim()) return "command";
   if (env[UP_LAUNCHER_ENV] === "1") return "launcher-child";
-  return platform !== "win32" && canExecve ? "exec" : "launcher";
+  return "launcher";
+}
+function relaunchDelayMs(failures) {
+  return Math.min(5 * 6e4, 1e4 * 2 ** Math.max(0, failures - 1));
 }
 function processRestartDeps() {
-  const execve = process.execve;
   return {
     env: process.env,
-    platform: process.platform,
     execPath: process.execPath,
     execArgv: process.execArgv,
     script: process.argv[1],
-    execve: typeof execve === "function" ? execve.bind(process) : void 0,
     spawn: nodeSpawn2,
     spawnSync: nodeSpawnSync,
     exit: (code) => process.exit(code),
     log: () => {
-    }
+    },
+    sleep: (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms),
+    step: (line) => logUpdateStep(line)
   };
 }
 function restartPagsUp(args, extraEnv, deps) {
   const env = { ...deps.env, ...extraEnv };
   const argv = [...deps.execArgv, deps.script, ...args];
-  const mode = upRestartMode(env, deps.platform, !!deps.execve);
+  const mode = upRestartMode(env);
+  deps.step(`restart: pags ${args.join(" ")} \u2014 leaving via ${mode}`);
   if (mode === "service" || mode === "command") {
     leaveForRestart(mode, { spawn: deps.spawn, exit: deps.exit });
     return;
@@ -3687,24 +3749,31 @@ function restartPagsUp(args, extraEnv, deps) {
     deps.exit(RUNNER_RESTART_EXIT_CODE);
     return;
   }
-  if (mode === "exec") {
-    try {
-      deps.execve(deps.execPath, [deps.execPath, ...argv], env);
-    } catch (e) {
-      deps.log(`Restart failed (${e instanceof Error ? e.message : String(e)}) \u2014 the runner is NOT running. Run 'pags up' again.`);
-      deps.exit(1);
-    }
-    return;
-  }
+  let failures = 0;
   for (let first = true; ; first = false) {
+    const unattended = !first || env.PAGS_NO_PROMPT === "1";
+    deps.step(`launcher: starting pags up${unattended ? " (unattended)" : ""}`);
     const r = deps.spawnSync(deps.execPath, argv, { stdio: "inherit", env: { ...env, [UP_LAUNCHER_ENV]: "1", ...first ? {} : { PAGS_NO_PROMPT: "1" } } });
-    if (r.status === RUNNER_RESTART_EXIT_CODE) continue;
-    if (r.error || r.status !== 0) {
-      deps.log(`Restart failed${typeof r.status === "number" ? ` (exit ${r.status})` : ""} \u2014 the runner is NOT running. Run 'pags up' again.`);
-      deps.exit(typeof r.status === "number" && r.status !== 0 ? r.status : 1);
+    const how = r.error ? `could not start (${r.error.message})` : r.signal ? `was killed by ${r.signal}` : `exited ${r.status}`;
+    deps.step(`launcher: pags up ${how}`);
+    if (r.status === RUNNER_RESTART_EXIT_CODE) {
+      failures = 0;
+      continue;
+    }
+    if (!r.error && r.status === 0) {
+      deps.exit(0);
       return;
     }
-    deps.exit(0);
+    if (unattended) {
+      failures++;
+      const wait = relaunchDelayMs(failures);
+      deps.log(`pags up ${how} \u2014 starting it again in ${Math.round(wait / 1e3)}s (attempt ${failures + 1}).`);
+      deps.step(`launcher: retrying in ${Math.round(wait / 1e3)}s (failure ${failures})`);
+      deps.sleep(wait);
+      continue;
+    }
+    deps.log(`Restart failed${typeof r.status === "number" ? ` (exit ${r.status})` : ""} \u2014 the runner is NOT running. Run 'pags up' again.`);
+    deps.exit(typeof r.status === "number" && r.status !== 0 ? r.status : 1);
     return;
   }
 }
@@ -3850,11 +3919,244 @@ async function startInBackground(start, deps = processDeps()) {
   return 1;
 }
 
+// src/service-install.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { mkdirSync as mkdirSync9, rmSync, writeFileSync as writeFileSync7 } from "fs";
+import { posix, win32 as win322 } from "path";
+var SERVICE_LABEL = "online.proagentstore.pags-up";
+var SYSTEMD_UNIT = "pags-up.service";
+var WINDOWS_TASK = "pags up";
+var pathFor = (ctx) => ctx.platform === "win32" ? win322 : posix;
+var supervisorPath = (ctx) => pathFor(ctx).join(ctx.configDir, "pags-up-supervisor.mjs");
+var serviceLogPath = (ctx) => pathFor(ctx).join(ctx.configDir, "pags-up.log");
+function supervisorScript(ctx) {
+  const config = JSON.stringify({ node: ctx.nodePath, script: ctx.script, log: serviceLogPath(ctx), path: ctx.pathEnv });
+  return `// Written by \`pags up --install-service\` (#1141). Keeps \`pags up\` running; see packages/cli/src/service-install.ts.
+import { spawn } from "node:child_process";
+import { appendFileSync, closeSync, openSync } from "node:fs";
+
+const config = ${config};
+const num = (name, fallback) => { const n = Number(process.env[name]); return Number.isFinite(n) && n > 0 ? n : fallback; };
+const MIN = num("PAGS_SUPERVISOR_MIN_MS", 10_000);
+const MAX = num("PAGS_SUPERVISOR_MAX_MS", 300_000);
+const RESET = num("PAGS_SUPERVISOR_RESET_MS", 600_000);
+const RESTART_CODE = 75; // \`pags up\` asking to be started again: an update, or runner_restart
+
+const say = (line) => { try { appendFileSync(config.log, \`[\${new Date().toISOString()}] supervisor: \${line}\\n\`); } catch { /* a log that cannot be written must not stop the runner */ } };
+let delay = MIN;
+let child = null;
+let stopping = false;
+
+function start() {
+	if (stopping) return;
+	const startedAt = Date.now();
+	let out = "ignore";
+	try { out = openSync(config.log, "a"); } catch { /* run without a log rather than not at all */ }
+	say("starting pags up");
+	child = spawn(config.node, [config.script, "up", "--headless"], {
+		stdio: ["ignore", out, out],
+		env: { ...process.env, PATH: config.path || process.env.PATH, PAGS_SERVICE: "1", PAGS_SERVICE_NAME: "${SERVICE_LABEL}", PAGS_NO_PROMPT: "1" },
+		windowsHide: true,
+	});
+	if (typeof out === "number") closeSync(out);
+	child.on("error", (e) => say(\`could not start pags up: \${e.message}\`));
+	child.on("exit", (code, signal) => {
+		child = null;
+		if (stopping) return;
+		if (Date.now() - startedAt >= RESET) delay = MIN;
+		const wait = code === RESTART_CODE ? 1_000 : delay;
+		say(\`pags up exited (\${signal ?? code}); starting it again in \${Math.round(wait / 1000)}s\`);
+		if (code !== RESTART_CODE) delay = Math.min(delay * 2, MAX);
+		setTimeout(start, wait);
+	});
+}
+
+for (const sig of ["SIGTERM", "SIGINT"]) {
+	process.on(sig, () => {
+		stopping = true;
+		say(\`stopping (\${sig})\`);
+		if (child) child.kill("SIGTERM");
+		setTimeout(() => process.exit(0), 5_000).unref();
+		if (!child) process.exit(0);
+		else child.once("exit", () => process.exit(0));
+	});
+}
+start();
+`;
+}
+var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var unitWord = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+var ps = (s) => `'${s.replace(/'/g, "''")}'`;
+function servicePlan(ctx) {
+  const supervisor = supervisorPath(ctx);
+  const log = serviceLogPath(ctx);
+  const files = [{ path: supervisor, content: supervisorScript(ctx) }];
+  if (ctx.platform === "darwin") {
+    const plist = posix.join(ctx.home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+    const domain = `gui/${ctx.uid ?? 501}`;
+    files.push({
+      path: plist,
+      content: `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key><string>${SERVICE_LABEL}</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>${xml(ctx.nodePath)}</string>
+		<string>${xml(supervisor)}</string>
+	</array>
+	<key>RunAtLoad</key><true/>
+	<key>KeepAlive</key><true/>
+	<key>ThrottleInterval</key><integer>30</integer>
+	<key>ProcessType</key><string>Background</string>
+	<key>StandardOutPath</key><string>${xml(log)}</string>
+	<key>StandardErrorPath</key><string>${xml(log)}</string>
+</dict>
+</plist>
+`
+    });
+    return {
+      kind: "launchd",
+      files,
+      commands: [
+        { file: "launchctl", args: ["bootout", `${domain}/${SERVICE_LABEL}`], optional: true, why: "unload an earlier copy" },
+        { file: "launchctl", args: ["bootstrap", domain, plist], why: "load the LaunchAgent" },
+        { file: "launchctl", args: ["kickstart", "-k", `${domain}/${SERVICE_LABEL}`], why: "start it now" }
+      ],
+      notes: [
+        `LaunchAgent ${plist} \u2014 runs while this user is logged in. On a machine that must survive a reboot unattended, turn on automatic login for this user.`,
+        `Remove it with: pags up --uninstall-service`
+      ]
+    };
+  }
+  if (ctx.platform === "win32") {
+    const task = win322.join(ctx.configDir, "pags-up-task.ps1");
+    const principal = `${ctx.domain ? `${ctx.domain}\\` : ""}${ctx.user ?? ""}`;
+    files.push({
+      path: task,
+      content: `# Written by \`pags up --install-service\` (#1141). Registers the "${WINDOWS_TASK}" Scheduled Task; needs an elevated PowerShell.
+$ErrorActionPreference = 'Stop'
+$action    = New-ScheduledTaskAction -Execute ${ps(ctx.nodePath)} -Argument ${ps(`"${supervisor}"`)}
+$trigger   = New-ScheduledTaskTrigger -AtStartup
+$principal = New-ScheduledTaskPrincipal -UserId ${ps(principal)} -LogonType S4U -RunLevel Limited
+$settings  = New-ScheduledTaskSettingsSet -ExecutionTimeLimit ([TimeSpan]::Zero) -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable
+Unregister-ScheduledTask -TaskName ${ps(WINDOWS_TASK)} -Confirm:$false -ErrorAction SilentlyContinue
+Register-ScheduledTask -TaskName ${ps(WINDOWS_TASK)} -Action $action -Trigger $trigger -Principal $principal -Settings $settings | Out-Null
+Start-ScheduledTask -TaskName ${ps(WINDOWS_TASK)}
+`
+    });
+    return {
+      kind: "scheduled-task",
+      files,
+      commands: [{ file: "powershell.exe", args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", task], why: "register and start the Scheduled Task" }],
+      notes: [
+        `Scheduled Task "${WINDOWS_TASK}" \u2014 starts at boot as ${principal || "this user"}, with nobody logged in. Registering it needs an elevated PowerShell: if it was refused, run ${task} from one.`,
+        `Remove it with: pags up --uninstall-service`
+      ]
+    };
+  }
+  const unit = posix.join(ctx.home, ".config", "systemd", "user", SYSTEMD_UNIT);
+  files.push({
+    path: unit,
+    content: `# Written by \`pags up --install-service\` (#1141).
+[Unit]
+Description=ProAgentStore runner (pags up)
+After=network-online.target
+Wants=network-online.target
+StartLimitIntervalSec=0
+
+[Service]
+ExecStart=${unitWord(ctx.nodePath)} ${unitWord(supervisor)}
+Environment=${unitWord(`PATH=${ctx.pathEnv}`)}
+Restart=always
+RestartSec=10
+KillMode=mixed
+
+[Install]
+WantedBy=default.target
+`
+  });
+  return {
+    kind: "systemd",
+    files,
+    commands: [
+      { file: "systemctl", args: ["--user", "daemon-reload"], why: "read the unit" },
+      { file: "systemctl", args: ["--user", "enable", "--now", SYSTEMD_UNIT], why: "enable and start it" },
+      { file: "loginctl", args: ["enable-linger", ...ctx.user ? [ctx.user] : []], optional: true, why: "keep it running with nobody logged in" }
+    ],
+    notes: [`systemd user unit ${unit}. Logs: ${log} (and journalctl --user -u ${SYSTEMD_UNIT}).`, `Remove it with: pags up --uninstall-service`]
+  };
+}
+function serviceRemovalPlan(ctx) {
+  const plan = servicePlan(ctx);
+  const files = plan.files.map((f) => f.path);
+  if (plan.kind === "launchd") return { files, commands: [{ file: "launchctl", args: ["bootout", `gui/${ctx.uid ?? 501}/${SERVICE_LABEL}`], optional: true, why: "unload the LaunchAgent" }] };
+  if (plan.kind === "systemd") return { files, commands: [{ file: "systemctl", args: ["--user", "disable", "--now", SYSTEMD_UNIT], optional: true, why: "stop and disable the unit" }] };
+  return {
+    files,
+    commands: [{ file: "powershell.exe", args: ["-NoProfile", "-Command", `Stop-ScheduledTask -TaskName ${ps(WINDOWS_TASK)} -ErrorAction SilentlyContinue; Unregister-ScheduledTask -TaskName ${ps(WINDOWS_TASK)} -Confirm:$false`], optional: true, why: "remove the Scheduled Task" }]
+  };
+}
+var defaultWrite = (path, content) => {
+  mkdirSync9(path.replace(/[\\/][^\\/]*$/, ""), { recursive: true });
+  writeFileSync7(path, content);
+};
+var defaultRun = (file, args) => void execFileSync3(file, args, { stdio: "pipe", timeout: 6e4 });
+function installService(ctx, deps = {}) {
+  const plan = servicePlan(ctx);
+  const lines = [];
+  for (const f of plan.files) {
+    (deps.write ?? defaultWrite)(f.path, f.content);
+    lines.push(`wrote ${f.path}`);
+  }
+  let ok = true;
+  for (const c2 of plan.commands) {
+    try {
+      (deps.run ?? defaultRun)(c2.file, c2.args);
+      lines.push(`${c2.why}: ok`);
+    } catch (e) {
+      const why = String(e.stderr ?? "").trim() || (e instanceof Error ? e.message : String(e));
+      lines.push(`${c2.why}: ${c2.optional ? "skipped" : "FAILED"} \u2014 ${why.split(/\r?\n/)[0].slice(0, 200)}`);
+      if (!c2.optional) ok = false;
+    }
+  }
+  return { ok, lines: [...lines, ...plan.notes] };
+}
+function uninstallService(ctx, deps = {}) {
+  const plan = serviceRemovalPlan(ctx);
+  const lines = [];
+  for (const c2 of plan.commands) {
+    try {
+      (deps.run ?? defaultRun)(c2.file, c2.args);
+      lines.push(`${c2.why}: ok`);
+    } catch (e) {
+      lines.push(`${c2.why}: skipped \u2014 ${(e instanceof Error ? e.message : String(e)).split(/\r?\n/)[0].slice(0, 200)}`);
+    }
+  }
+  for (const f of plan.files) {
+    (deps.remove ?? ((p) => rmSync(p, { force: true })))(f);
+    lines.push(`removed ${f}`);
+  }
+  return { lines };
+}
+
 // src/commands/up.ts
 var API_BASE3 = "https://api.proagentstore.online";
 var CLI_VERSION2 = createRequire2(import.meta.url)("../package.json").version;
-var upCommand = new Command10("up").description("Start the browser runner for all your agent instances").option("--headless", "Run browser in headless mode").option("--instance <id>", "Connect to a specific instance only").option("--force", "Take over from another connected machine").option("--replace", "Stop the `pags up` already running here for this account, then take over").option("--now", "With --replace: stop it even though work is running on it (that work is lost)").option("--background", "Run the runner in the background, with no terminal open (stop it with `pags down`)").action(async (opts) => {
+var upCommand = new Command10("up").description("Start the browser runner for all your agent instances").option("--headless", "Run browser in headless mode").option("--instance <id>", "Connect to a specific instance only").option("--force", "Take over from another connected machine").option("--replace", "Stop the `pags up` already running here for this account, then take over").option("--now", "With --replace: stop it even though work is running on it (that work is lost)").option("--background", "Run the runner in the background, with no terminal open (stop it with `pags down`)").option("--install-service", "Install an OS service that keeps `pags up` running (launchd, systemd or a Scheduled Task), then exit").option("--uninstall-service", "Remove the service --install-service installed, then exit").action(async (opts) => {
+  if (opts.uninstallService) {
+    for (const line of uninstallService(serviceContext()).lines) writeLine(line);
+    return;
+  }
   const session = requireSession();
+  if (opts.installService) {
+    const result = installService(serviceContext());
+    for (const line of result.lines) writeLine(line);
+    writeLine(result.ok ? "The service starts `pags up` now and whenever it exits. A `pags up` already running here keeps the lock; the service takes over once it stops." : "The service was not fully installed \u2014 see the FAILED line above.");
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
   const state = {
     user: session.user.login,
     instances: [],
@@ -3871,18 +4173,34 @@ var upCommand = new Command10("up").description("Start the browser runner for al
     // as taking a few seconds, indefinitely, because nothing counted (#497).
     startedAt: Date.now()
   };
+  const unattended = process.env.PAGS_NO_PROMPT === "1";
+  logUpdateStep(`start: pags up ${CLI_VERSION2}${unattended ? " (unattended)" : ""}`);
   clearScreen();
   printLogo(CLI_VERSION2);
   printStep("Signed in as " + session.user.login, "ok");
   printStep("Fetching instances...", "wait");
-  const res = await fetch(`${API_BASE3}/v1/instances/my/instances`, {
-    headers: { Authorization: `Bearer ${session.token}` }
-  });
-  if (!res.ok) {
-    printStep("Failed to fetch instances: " + res.status, "fail");
-    process.exit(1);
+  let data;
+  for (let failures = 1; ; failures++) {
+    let failure;
+    try {
+      const res = await fetch(`${API_BASE3}/v1/instances/my/instances`, { headers: { Authorization: `Bearer ${session.token}` } });
+      if (res.ok) {
+        data = await res.json();
+        break;
+      }
+      failure = `HTTP ${res.status}`;
+    } catch (e) {
+      failure = e instanceof Error ? e.message : String(e);
+    }
+    logUpdateStep(`start: fetching instances failed (${failure})${unattended ? "" : " \u2014 exiting"}`);
+    if (!unattended) {
+      printStep("Failed to fetch instances: " + failure, "fail");
+      process.exit(1);
+    }
+    const wait = Math.min(5 * 6e4, 5e3 * 2 ** (failures - 1));
+    printStep(`Failed to fetch instances (${failure}) \u2014 retrying in ${Math.round(wait / 1e3)}s`, "wait");
+    await new Promise((resolve5) => setTimeout(resolve5, wait));
   }
-  const data = await res.json();
   const active = (data.instances || []).filter((i) => i.status === "active");
   let instances = active;
   let elsewhere = [];
@@ -3930,9 +4248,10 @@ var upCommand = new Command10("up").description("Start the browser runner for al
   state.activeInstance = instances.length === 1 ? instances[0].name || instances[0].slug || instances[0].id.slice(0, 8) : `${instances.length} agents`;
   printStep(`Connecting ${state.activeInstance}\u2026`, "wait");
   const lockFile = lockPath(session.user.login);
-  if (opts.background && process.env[BACKGROUND_RESTART_ENV] === "1") await waitUntilTakeable(() => inspectHolder(lockFile));
+  if (unattended || opts.background && process.env[BACKGROUND_RESTART_ENV] === "1") await waitUntilTakeable(() => inspectHolder(lockFile), { timeoutMs: 6e4 });
   const held = await inspectHolder(lockFile);
   if (held.lock && !isTakeable(held.verdict)) {
+    logUpdateStep(`start: the lock is held by pid ${held.lock.pid} (${held.verdict})${opts.replace ? " \u2014 replacing it" : " \u2014 exiting"}`);
     if (!opts.replace) {
       clearScreen();
       printLogo(CLI_VERSION2);
@@ -4037,10 +4356,12 @@ var upCommand = new Command10("up").description("Start the browser runner for al
   };
   child.on("exit", (code, signal) => {
     if (code === RUNNER_RESTART_EXIT_CODE) {
+      logUpdateStep("restart: runner connect asked for a restart (exit 75)");
       restartUp("Runner updated remotely \u2014 restarting pags up on the new version\u2026", { PAGS_NO_PROMPT: "1" });
       return;
     }
     childDead = true;
+    logUpdateStep(`runner connect ${signal ? `was killed by ${signal}` : `exited ${code}`}${stopping ? " (stopping)" : ""}`);
     if (code !== 0 && !stopping) recordConnectExit(code, signal ?? null, logs.slice(-20));
     if (code === null) {
       state.runner = "error";
@@ -4125,6 +4446,26 @@ var downCommand = new Command10("down").description("Stop the browser runner and
   }
   writeLine("");
 });
+function serviceContext() {
+  const user = (() => {
+    try {
+      return userInfo().username;
+    } catch {
+      return process.env.USER || process.env.USERNAME || void 0;
+    }
+  })();
+  return {
+    platform: process.platform,
+    home: homedir5(),
+    nodePath: process.execPath,
+    script: process.argv[1],
+    configDir: configDir(),
+    pathEnv: process.env.PATH ?? "",
+    uid: process.getuid?.(),
+    user,
+    domain: process.env.USERDOMAIN
+  };
+}
 
 // src/index.ts
 var require2 = createRequire3(import.meta.url);

package/package.json

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

package/dist/chunk-NNA7VZ6W.js

@@ -1,138 +0,0 @@
-// src/bootstrap/payload.ts
-import { execFile } from "child_process";
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync } from "fs";
-import { homedir } from "os";
-import { join, win32 } from "path";
-import { promisify } from "util";
-var run = promisify(execFile);
-var CLI_PACKAGE = "@proagentstore/cli";
-var BOOTSTRAP_ENV = "PAGS_BOOTSTRAP";
-var NO_SELF_UPDATE_ENV = "PAGS_NO_SELF_UPDATE";
-var KEEP = 2;
-function payloadRoot() {
-  return process.env.PAGS_CLI_CACHE || join(homedir(), ".config", "proagentstore", "cli");
-}
-function isVersion(v) {
-  return typeof v === "string" && /^(\d+)\.(\d+)\.(\d+)/.test(v.trim());
-}
-function olderThan(a, b) {
-  const parse = (v) => /^(\d+)\.(\d+)\.(\d+)/.exec(v.trim())?.slice(1).map(Number);
-  const x = parse(a);
-  const y = parse(b);
-  if (!x || !y) return false;
-  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] < y[i];
-  return false;
-}
-function payloadAt(dir) {
-  try {
-    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
-    if (pkg.name !== CLI_PACKAGE || !pkg.version) return null;
-    const entry = join(dir, pkg.pagsPayload || "dist/index.js");
-    return existsSync(entry) ? { version: pkg.version, entry } : null;
-  } catch {
-    return null;
-  }
-}
-var installedAt = (prefix) => join(prefix, "node_modules", ...CLI_PACKAGE.split("/"));
-var packageDir = (root, version) => installedAt(join(root, version));
-function cachedPayloads(root = payloadRoot()) {
-  let names;
-  try {
-    names = readdirSync(root);
-  } catch {
-    return [];
-  }
-  return names.flatMap((v) => v.startsWith(".") ? [] : payloadAt(packageDir(root, v)) ?? []);
-}
-function newestPayload(payloads) {
-  return payloads.reduce((best, p) => !best || olderThan(best.version, p.version) ? p : best, null);
-}
-var CMD_META = /([()\][%!^"`<>&|;, *?])/g;
-function quoteCmdArg(arg) {
-  const quoted = `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`;
-  return quoted.replace(CMD_META, "^$1").replace(CMD_META, "^$1");
-}
-var envVar = (env, name) => env[Object.keys(env).find((k) => k.toUpperCase() === name) ?? name];
-function npmInvocation(args, deps = {}) {
-  if ((deps.platform ?? process.platform) !== "win32") return { file: "npm", args };
-  const env = deps.env ?? process.env;
-  const exists = deps.exists ?? existsSync;
-  const execPath = deps.execPath ?? process.execPath;
-  const cli = (dir) => win32.join(dir, "node_modules", "npm", "bin", "npm-cli.js");
-  const onPath = (envVar(env, "PATH") ?? "").split(";").filter((dir) => dir && exists(win32.join(dir, "npm.cmd")));
-  for (const dir of [...onPath, win32.dirname(execPath)]) {
-    if (exists(cli(dir))) return { file: execPath, args: [cli(dir), ...args] };
-  }
-  const line = ["npm", ...args.map(quoteCmdArg)].join(" ");
-  return { file: envVar(env, "COMSPEC") || "cmd.exe", args: ["/d", "/s", "/c", `"${line}"`], windowsVerbatimArguments: true };
-}
-function runNpm(args, options) {
-  const npm = npmInvocation(args);
-  return run(npm.file, npm.args, { ...options, ...npm.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {} });
-}
-async function latestPublishedRelease(timeoutMs = 3e4, signal, deps = {}) {
-  try {
-    const { stdout } = await (deps.runNpm ?? runNpm)(["view", CLI_PACKAGE, "version"], { timeout: timeoutMs, signal });
-    const version = String(stdout).trim();
-    return version ? { version } : { error: "npm printed no version" };
-  } catch (e) {
-    return { error: npmFailure(e) };
-  }
-}
-function npmFailure(e) {
-  const err = e;
-  const stderr = String(err?.stderr ?? "").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-  const npmErrors = stderr.filter((l) => /npm (ERR!|error)/i.test(l));
-  const why = npmErrors.slice(0, 2).join(" ") || stderr.at(-1) || (err?.killed || err?.signal ? `npm did not answer in time (${String(err.signal ?? "killed")})` : "") || (typeof err?.code === "string" ? `npm could not be started (${err.code}: ${String(err.message ?? "")})` : "") || String(err?.message ?? e);
-  return why.replace(/\s+/g, " ").trim().slice(0, 300);
-}
-async function latestPublishedVersion(timeoutMs = 3e4, signal) {
-  const r = await latestPublishedRelease(timeoutMs, signal);
-  return "version" in r ? r.version : null;
-}
-async function npmInstallInto(dir, version) {
-  try {
-    await runNpm(["install", "--prefix", dir, "--omit=dev", "--no-audit", "--no-fund", "--no-save", `${CLI_PACKAGE}@${version}`], { timeout: 5 * 6e4 });
-  } catch (e) {
-    const stderr = String(e.stderr ?? "").trim();
-    throw new Error((stderr || (e instanceof Error ? e.message : String(e))).slice(-400));
-  }
-}
-async function installPayload(version, root = payloadRoot(), install = npmInstallInto) {
-  const done = payloadAt(packageDir(root, version));
-  if (done) return done;
-  mkdirSync(root, { recursive: true });
-  const scratch = mkdtempSync(join(root, `.install-${version}-`));
-  try {
-    await install(scratch, version);
-    if (payloadAt(installedAt(scratch))?.version !== version) throw new Error(`npm installed no ${CLI_PACKAGE}@${version}`);
-    try {
-      renameSync(scratch, join(root, version));
-    } catch (e) {
-      if (!payloadAt(packageDir(root, version))) throw e;
-    }
-  } finally {
-    rmSync(scratch, { recursive: true, force: true });
-  }
-  const payload = payloadAt(packageDir(root, version));
-  if (!payload) throw new Error(`${CLI_PACKAGE}@${version} is not usable after install`);
-  for (const old of cachedPayloads(root).sort((a, b) => olderThan(a.version, b.version) ? 1 : -1).slice(KEEP)) {
-    rmSync(join(root, old.version), { recursive: true, force: true });
-  }
-  return payload;
-}
-
-export {
-  CLI_PACKAGE,
-  BOOTSTRAP_ENV,
-  NO_SELF_UPDATE_ENV,
-  isVersion,
-  olderThan,
-  payloadAt,
-  cachedPayloads,
-  newestPayload,
-  runNpm,
-  latestPublishedRelease,
-  latestPublishedVersion,
-  installPayload
-};