@proagentstore/cli 0.4.149 → 0.4.152

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
+};