token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-CVCEVUGK.mjs

@@ -0,0 +1,315 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  copyFromSharedCache,
+  downloadPinned
+} from "./token-goat-chunk-AUNGYYQX.mjs";
+import "./token-goat-chunk-2UPZGKKY.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  atomicWriteText,
+  ensureDirSync
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  ensureDataDirPrivate
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/embed_runtime_web.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createGunzip } from "node:zlib";
+var _require = createRequire(import.meta.url);
+var ORT_WEB_TARBALL = {
+  name: "onnxruntime-web-1.30.0.tgz",
+  sha256: "d2228df7e4616bc3348bf504ee888f3bec43789a273f0a63f3e68d203ce3bf71",
+  bytes: 33106585
+};
+var ORT_WEB_GLUE = {
+  name: "ort-wasm-simd-threaded.mjs",
+  sha256: "e13f7f94fc51b4ca72b12faeb1ee95f4ace6dfbc8939bc718aabdc0a27c4299b",
+  bytes: 24381
+};
+var TARBALL_MEMBER = "package/dist/ort-wasm-simd-threaded.wasm";
+var BACKEND_START_FAILED = "no available backend found";
+var _webLoad = null;
+var _inFlightWasm = null;
+var _placeFailures = /* @__PURE__ */ new WeakSet();
+function readVerified(filePath, file) {
+  const info = fs.lstatSync(filePath, { throwIfNoEntry: false });
+  if (!info?.isFile() || info.size !== file.bytes) return null;
+  const bytes = fs.readFileSync(filePath);
+  if (bytes.length !== file.bytes) return null;
+  return createHash("sha256").update(bytes).digest("hex") === file.sha256 ? bytes : null;
+}
+function ensureWasmBinary(host) {
+  if (_inFlightWasm === null) {
+    _inFlightWasm = (async () => {
+      try {
+        return await placeWasmBinary(host);
+      } finally {
+        _inFlightWasm = null;
+      }
+    })();
+  }
+  return _inFlightWasm;
+}
+async function placeWasmBinary(host) {
+  ensureDataDirPrivate();
+  const { dir, version, wasm } = host;
+  const target = path.join(dir, wasm.name);
+  const cached = readVerified(target, wasm);
+  if (cached) return cached;
+  fs.rmSync(target, { force: true });
+  ensureDirSync(dir);
+  const shared = host.sharedDir;
+  if (shared && await copyFromSharedCache(shared, wasm, target)) {
+    const copied = readVerified(target, wasm);
+    if (copied) return copied;
+  }
+  if (loadConfig().network.offline) {
+    throw new Error(
+      `Offline mode is on (network.offline): refusing to download the WebAssembly inference runtime (onnxruntime-web ${version}). Copy ${wasm.name} from that package's dist/ into ${dir} on a connected machine to use semantic search here.`
+    );
+  }
+  console.warn(
+    `Downloading the embedding runtime, once (onnxruntime-web ${version} from registry.npmjs.org, ${Math.round(ORT_WEB_TARBALL.bytes / 1024 / 1024)} MB, keeping its ${Math.round(wasm.bytes / 1024 / 1024)} MB ${wasm.name}) into ${dir}`
+  );
+  const archive = path.join(dir, ORT_WEB_TARBALL.name);
+  try {
+    await downloadPinned(tarballUrl(), ORT_WEB_TARBALL, archive);
+    await extractTarMember(archive, TARBALL_MEMBER, wasm, target);
+  } finally {
+    fs.rmSync(archive, { force: true, maxRetries: 20, retryDelay: 25 });
+  }
+  if (shared) host.publish(shared, wasm, target);
+  const placed = readVerified(target, wasm);
+  if (!placed) throw new Error(`${target} did not verify after extraction`);
+  return placed;
+}
+function tarballUrl() {
+  return `https://registry.npmjs.org/onnxruntime-web/-/${ORT_WEB_TARBALL.name}`;
+}
+var ExactReader = class {
+  constructor(source) {
+    this.source = source;
+  }
+  source;
+  chunks = [];
+  buffered = 0;
+  ended = false;
+  async fill(n) {
+    while (this.buffered < n && !this.ended) {
+      const next = await this.source.next();
+      if (next.done === true) {
+        this.ended = true;
+        break;
+      }
+      this.chunks.push(next.value);
+      this.buffered += next.value.length;
+    }
+  }
+  /** Exactly `n` bytes, or fewer only when the input ends first. */
+  async read(n) {
+    await this.fill(n);
+    const all = this.chunks.length === 1 ? this.chunks[0] : Buffer.concat(this.chunks);
+    const out = all.subarray(0, n);
+    const rest = all.subarray(out.length);
+    this.chunks = rest.length > 0 ? [rest] : [];
+    this.buffered = rest.length;
+    return out;
+  }
+  /** Discard exactly `n` bytes without holding them, or throw if the input ends first. */
+  async skip(n) {
+    let left = n;
+    while (left > 0) {
+      if (this.buffered === 0) await this.fill(1);
+      const head = this.chunks[0];
+      if (head === void 0) throw new Error("archive ended inside an entry");
+      if (head.length <= left) {
+        this.chunks.shift();
+        this.buffered -= head.length;
+        left -= head.length;
+      } else {
+        this.chunks[0] = head.subarray(left);
+        this.buffered -= left;
+        left = 0;
+      }
+    }
+  }
+};
+function tarString(block, start, length) {
+  const field = block.subarray(start, start + length);
+  const end = field.indexOf(0);
+  return field.subarray(0, end === -1 ? field.length : end).toString("utf8");
+}
+function tarOctal(block, start, length) {
+  if ((block[start] & 128) !== 0) throw new Error("tar header uses a base-256 number, which this reader does not support");
+  const text = tarString(block, start, length).trim();
+  const value = text === "" ? 0 : Number.parseInt(text, 8);
+  if (!Number.isSafeInteger(value) || value < 0) throw new Error(`tar header holds an invalid number: ${JSON.stringify(text)}`);
+  return value;
+}
+function paxPath(data) {
+  let at = 0;
+  let found = null;
+  while (at < data.length) {
+    const space = data.indexOf(32, at);
+    if (space === -1) break;
+    const length = Number.parseInt(data.subarray(at, space).toString("latin1"), 10);
+    if (!Number.isSafeInteger(length) || length <= 0 || at + length > data.length) break;
+    const record = data.subarray(space + 1, at + length - 1).toString("utf8");
+    const eq = record.indexOf("=");
+    if (eq !== -1 && record.slice(0, eq) === "path") found = record.slice(eq + 1);
+    at += length;
+  }
+  return found;
+}
+async function extractTarMember(archive, member, file, target) {
+  const raw = fs.createReadStream(archive);
+  const gunzip = createGunzip();
+  raw.on("error", (e) => gunzip.destroy(e));
+  raw.pipe(gunzip);
+  const reader = new ExactReader(gunzip[Symbol.asyncIterator]());
+  try {
+    let nextName = null;
+    for (; ; ) {
+      const header = await reader.read(512);
+      if (header.length < 512) throw new Error(`${archive} ended before its end-of-archive marker, without ${member}`);
+      if (header.every((b) => b === 0)) throw new Error(`${archive} has no ${member}`);
+      let sum = 0;
+      for (let i = 0; i < 512; i++) sum += i >= 148 && i < 156 ? 32 : header[i];
+      if (sum !== tarOctal(header, 148, 8)) throw new Error(`${archive} has a tar header with a bad checksum`);
+      const size = tarOctal(header, 124, 12);
+      const padding = (512 - size % 512) % 512;
+      const type = header[156] === 0 ? "0" : String.fromCharCode(header[156]);
+      let name = tarString(header, 0, 100);
+      if (header.subarray(257, 263).toString("latin1") === "ustar\0") {
+        const prefix = tarString(header, 345, 155);
+        if (prefix !== "") name = `${prefix}/${name}`;
+      }
+      if (nextName !== null) {
+        name = nextName;
+        nextName = null;
+      }
+      if (type === "x" || type === "L") {
+        const data = await reader.read(size);
+        if (data.length < size) throw new Error(`${archive} ended inside an extended header`);
+        await reader.skip(padding);
+        nextName = type === "x" ? paxPath(data) : tarString(data, 0, data.length);
+        continue;
+      }
+      if ((type === "0" || type === "7") && name === member) {
+        if (size !== file.bytes) throw new Error(`${member} is ${size} bytes in ${archive}, expected the pinned ${file.bytes}`);
+        const data = await reader.read(size);
+        if (data.length !== file.bytes) throw new Error(`${archive} ended inside ${member}`);
+        const digest = createHash("sha256").update(data).digest("hex");
+        if (digest !== file.sha256) throw new Error(`${member} has sha256 ${digest}, expected the pinned ${file.sha256}`);
+        const temp = `${target}.${process.pid}.partial`;
+        try {
+          fs.writeFileSync(temp, data);
+          fs.renameSync(temp, target);
+        } catch (e) {
+          fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+          throw e;
+        }
+        return;
+      }
+      await reader.skip(size + padding);
+    }
+  } finally {
+    raw.destroy();
+    gunzip.destroy();
+  }
+}
+function verifiedGlueUrl(version) {
+  const beside = fileURLToPath(new URL(`./${ORT_WEB_GLUE.name}`, import.meta.url));
+  const file = fs.existsSync(beside) ? beside : _require.resolve(`onnxruntime-web/${ORT_WEB_GLUE.name}`);
+  if (readVerified(file, ORT_WEB_GLUE) === null) {
+    throw new Error(`${file} is not the ${ORT_WEB_GLUE.name} onnxruntime-web ${version} ships (pinned sha256 ${ORT_WEB_GLUE.sha256})`);
+  }
+  return pathToFileURL(file).href;
+}
+function loadWebRuntime(threads, host) {
+  if (_webLoad !== null) return _webLoad;
+  const pending = (async () => {
+    const ort = await import("./token-goat-chunk-EXKGNHEG.mjs");
+    if (ort.env.versions.web !== host.version) {
+      throw new Error(`the bundled onnxruntime-web is ${ort.env.versions.web ?? "unknown"}, but its binary is pinned for ${host.version}`);
+    }
+    const glue = verifiedGlueUrl(host.version);
+    const binary = await ensureWasmBinary(host).catch((e) => {
+      if (typeof e === "object" && e !== null) _placeFailures.add(e);
+      throw e;
+    });
+    ort.env.wasm.wasmBinary = binary;
+    ort.env.wasm.wasmPaths = { mjs: glue };
+    ort.env.wasm.numThreads = threads;
+    return ort;
+  })();
+  _webLoad = pending;
+  pending.catch(() => {
+    if (_webLoad === pending) _webLoad = null;
+  });
+  return pending;
+}
+async function createWebSession(modelPath, threads, host) {
+  let ort;
+  try {
+    ort = await loadWebRuntime(threads, host);
+  } catch (e) {
+    if (typeof e === "object" && e !== null && _placeFailures.has(e)) throw host.failed(e, false);
+    throw startFailed(e, host);
+  }
+  let session;
+  try {
+    session = await ort.InferenceSession.create(modelPath, { intraOpNumThreads: threads, interOpNumThreads: 1 });
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith(BACKEND_START_FAILED)) throw startFailed(e, host);
+    throw e;
+  }
+  try {
+    const recorded = JSON.parse(fs.readFileSync(host.startFailure.path, "utf8"));
+    if (recorded.key === host.startFailure.key) fs.rmSync(host.startFailure.path, { force: true });
+  } catch {
+  }
+  return { session, Tensor: ort.Tensor };
+}
+function startFailed(e, host) {
+  const message = e instanceof Error ? e.message : String(e);
+  try {
+    ensureDirSync(path.dirname(host.startFailure.path));
+    atomicWriteText(host.startFailure.path, JSON.stringify({ key: host.startFailure.key, message, at: Date.now() }));
+  } catch {
+    return host.failed(e, false);
+  }
+  return host.failed(e, true);
+}
+registerReset(() => {
+  _webLoad = null;
+  _inFlightWasm = null;
+});
+export {
+  ORT_WEB_GLUE,
+  ORT_WEB_TARBALL,
+  createWebSession,
+  ensureWasmBinary,
+  extractTarMember
+};

package/dist/token-goat-chunk-CXHOFN7R.mjs

@@ -0,0 +1,371 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  formatCommandError,
+  writeCommandFailure
+} from "./token-goat-chunk-CBIQ7WTD.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  ensureDirSync
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  fencedCommand
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  displaySafeJson
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  VERSION,
+  dataDir
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/cli_upgrade.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire(import.meta.url);
+var UPDATE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var SEMVER = /^\d+\.\d+\.\d+(?:-[\w.-]+)?$/;
+var FAILED_CHECK_TTL_MS = 60 * 60 * 1e3;
+function getCachedUpdateStatus() {
+  try {
+    const cachePath = path.join(dataDir(), "update_check.json");
+    if (!fs.existsSync(cachePath)) return null;
+    const raw = fs.readFileSync(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.checkedAt === "number") {
+      const latest = typeof parsed.latest === "string" && SEMVER.test(parsed.latest) ? parsed.latest : null;
+      return { checkedAt: parsed.checkedAt, current: VERSION, latest, updateAvailable: latest !== null && compareSemver(latest, VERSION) > 0, error: latest === null && typeof parsed.error === "string" ? parsed.error : void 0 };
+    }
+  } catch {
+  }
+  return null;
+}
+function saveCachedUpdateStatus(info) {
+  try {
+    const dir = dataDir();
+    ensureDirSync(dir);
+    const cachePath = path.join(dir, "update_check.json");
+    fs.writeFileSync(cachePath, JSON.stringify(info, null, 2), "utf8");
+  } catch {
+  }
+}
+function getRegistryUrl() {
+  const envRegistry = process.env["NPM_CONFIG_REGISTRY"] || process.env["npm_config_registry"];
+  if (envRegistry && typeof envRegistry === "string") {
+    return envRegistry.endsWith("/") ? envRegistry : `${envRegistry}/`;
+  }
+  return "https://registry.npmjs.org/";
+}
+function npmInvocation(host) {
+  const named = host.env["npm_execpath"];
+  if (typeof named === "string" && /(?:^|[\\/])npm-cli\.js$/.test(named) && host.exists(named)) return { file: host.execPath, prefix: [named] };
+  if (host.platform !== "win32") return { file: "npm", prefix: [] };
+  const bundled = path.win32.join(path.win32.dirname(host.execPath), "node_modules", "npm", "bin", "npm-cli.js");
+  return host.exists(bundled) ? { file: host.execPath, prefix: [bundled] } : null;
+}
+function hostNpm() {
+  return npmInvocation({ platform: process.platform, env: process.env, execPath: process.execPath, exists: (p) => fs.existsSync(p) });
+}
+function runningPackageRoot(moduleUrl = import.meta.url) {
+  let dir;
+  try {
+    dir = fs.realpathSync(path.dirname(fileURLToPath(moduleUrl)));
+  } catch {
+    return null;
+  }
+  for (; ; ) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+      if (pkg.name === "token-goat") return dir;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function isDevCheckout(root) {
+  return root !== null && fs.existsSync(path.join(root, ".git")) && fs.existsSync(path.join(root, "esbuild.config.mjs"));
+}
+function upgradeDecision(status, offline, devCheckout) {
+  if (offline) return "offline";
+  if (status.error || !status.latest) return "unreachable";
+  if (!status.updateAvailable) return "up-to-date";
+  if (devCheckout) return "dev-checkout";
+  return "install";
+}
+function currentUpgradeDecision(status) {
+  return upgradeDecision(status, loadConfig().network.offline, isDevCheckout(runningPackageRoot()));
+}
+var DEV_CHECKOUT_ADVICE = "git pull && npm run build && token-goat install";
+function updateAdvice(decision) {
+  if (decision === "install") return "Run `token-goat upgrade` to update.";
+  if (decision === "dev-checkout") return `This token-goat runs from a development checkout. To update it, run: ${DEV_CHECKOUT_ADVICE}`;
+  return null;
+}
+function fetchViaNpm(timeoutMs = 2500) {
+  const npm = hostNpm();
+  if (!npm) return null;
+  try {
+    const res = spawnSync(npm.file, [...npm.prefix, "view", "token-goat", "version"], {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    });
+    if (res.status === 0 && res.stdout) {
+      const trimmed = res.stdout.trim();
+      if (SEMVER.test(trimmed)) {
+        return trimmed;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fetchViaHttp(registryUrl, timeoutMs = 3500) {
+  return new Promise((resolve) => {
+    try {
+      const cleanUrl = registryUrl.endsWith("/") ? registryUrl : `${registryUrl}/`;
+      const targetUrl = new URL(`token-goat/latest`, cleanUrl);
+      const isHttps = targetUrl.protocol === "https:";
+      const getFn = isHttps ? https.get : require2("node:http").get;
+      const req = getFn(
+        targetUrl,
+        {
+          headers: { "User-Agent": `token-goat/${VERSION} (node/${process.version})` },
+          // A fresh connection, never one pooled by the global agent: after npm's blocking spawn the registry may have closed the pooled one, and reusing it fails with ECONNRESET.
+          agent: false,
+          timeout: timeoutMs
+        },
+        (res) => {
+          if (res.statusCode !== 200) {
+            res.resume();
+            resolve(null);
+            return;
+          }
+          let data = "";
+          res.setEncoding("utf8");
+          res.on("data", (chunk) => {
+            data += chunk;
+            if (data.length > 32768) {
+              req.destroy();
+              resolve(null);
+            }
+          });
+          res.on("end", () => {
+            try {
+              const parsed = JSON.parse(data);
+              const version = parsed.version || parsed["dist-tags"]?.latest;
+              if (version && typeof version === "string" && SEMVER.test(version)) {
+                resolve(version);
+              } else {
+                resolve(null);
+              }
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(null);
+      });
+      req.on("error", () => {
+        resolve(null);
+      });
+    } catch {
+      resolve(null);
+    }
+  });
+}
+async function fetchLatestVersion(timeoutMs = 3500) {
+  if (loadConfig().network.offline) {
+    return null;
+  }
+  const npmVersion = fetchViaNpm(Math.min(timeoutMs, 2500));
+  if (npmVersion) {
+    return npmVersion;
+  }
+  const registryUrl = getRegistryUrl();
+  return fetchViaHttp(registryUrl, timeoutMs);
+}
+function compareSemver(a, b) {
+  const pa = a.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  const pb = b.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na > nb) return 1;
+    if (na < nb) return -1;
+  }
+  return 0;
+}
+async function checkUpdateStatus(timeoutMs = 3500, forceFresh = false) {
+  if (!forceFresh) {
+    const cached = getCachedUpdateStatus();
+    if (cached && Date.now() - cached.checkedAt < (cached.latest ? UPDATE_CACHE_TTL_MS : FAILED_CHECK_TTL_MS)) {
+      return { current: VERSION, latest: cached.latest, updateAvailable: cached.updateAvailable, error: cached.error };
+    }
+  }
+  const latest = await fetchLatestVersion(timeoutMs);
+  if (!latest) {
+    if (loadConfig().network.offline) {
+      return { current: VERSION, latest: null, updateAvailable: false, error: "network.offline is set, so no update check was made" };
+    }
+    const result2 = {
+      current: VERSION,
+      latest: null,
+      updateAvailable: false,
+      error: "Could not reach npm or internal registry (request failed or timed out)"
+    };
+    saveCachedUpdateStatus({
+      checkedAt: Date.now(),
+      current: VERSION,
+      latest: null,
+      updateAvailable: false,
+      error: result2.error
+    });
+    return result2;
+  }
+  const updateAvailable = compareSemver(latest, VERSION) > 0;
+  const result = {
+    current: VERSION,
+    latest,
+    updateAvailable
+  };
+  saveCachedUpdateStatus({
+    checkedAt: Date.now(),
+    current: VERSION,
+    latest,
+    updateAvailable
+  });
+  return result;
+}
+async function cmdUpgrade(opts = {}, onSyncHooks) {
+  const status = await checkUpdateStatus(3500, true);
+  if (opts.check) {
+    const failure = status.error ?? (status.latest ? void 0 : "could not determine the latest version");
+    if (failure !== void 0) {
+      writeCommandFailure(opts.json === true, { ...status }, [`${failure}.`, `Current version: v${status.current}`]);
+      return;
+    }
+    if (opts.json) {
+      console.log(displaySafeJson(status, 2));
+      return;
+    }
+    if (status.updateAvailable && status.latest) {
+      console.log(`Update available: v${status.current} -> v${status.latest}`);
+      console.log(`Run \`token-goat upgrade\` to update.`);
+    } else {
+      console.log(`token-goat is up to date (v${status.current})`);
+    }
+    return;
+  }
+  const decision = currentUpgradeDecision(status);
+  switch (decision) {
+    case "offline":
+      console.error(formatCommandError("network.offline is set, so no update check was made and nothing was installed. Unset it (or TOKEN_GOAT_OFFLINE) to upgrade."));
+      process.exitCode = 1;
+      return;
+    case "unreachable":
+      console.error(formatCommandError(`${status.error ?? "could not determine the latest version"}. Nothing was installed.`));
+      process.exitCode = 1;
+      return;
+    case "up-to-date":
+      console.log(`token-goat is up to date (v${status.current})`);
+      return;
+    case "dev-checkout":
+      console.log(`Update available: v${status.current} -> v${status.latest}`);
+      console.log(`This token-goat runs from a development checkout, so it was not replaced. To update it, run:`);
+      console.log(`  ${DEV_CHECKOUT_ADVICE}`);
+      return;
+    case "install":
+      break;
+  }
+  console.log(`Upgrading token-goat v${status.current} -> v${status.latest}...`);
+  const outcome = await performUpgrade(onSyncHooks);
+  if (!outcome.ok) {
+    console.error(formatCommandError(outcome.message));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`[\u2713] token-goat successfully updated.`);
+}
+var MANUAL_INSTALL = "npm install -g token-goat@latest";
+async function performUpgrade(onSyncHooks, npm = hostNpm()) {
+  if (!npm) return { ok: false, message: `npm was not found next to this Node.js, so token-goat could not upgrade itself. Run ${fencedCommand(MANUAL_INSTALL)} yourself.` };
+  let stoppedPid = [];
+  try {
+    const { stopWorker, readPidFile } = await import("./token-goat-chunk-NSNSPPBG.mjs");
+    const { queryServers } = await import("./token-goat-hook-client.mjs");
+    await queryServers("stop");
+    const tracked = readPidFile(dataDir());
+    if (stopWorker() && tracked !== null) stoppedPid = [tracked];
+  } catch {
+  }
+  try {
+    const { retireStrayResidents, describeRetirement, UPGRADE_RESIDENT_KINDS } = await import("./token-goat-chunk-TAUZ4OFS.mjs");
+    const note = describeRetirement(await retireStrayResidents({ kinds: UPGRADE_RESIDENT_KINDS, skip: stoppedPid }));
+    if (note !== null) console.log(note);
+  } catch {
+  }
+  const install = spawnSync(npm.file, [...npm.prefix, "install", "-g", "token-goat@latest"], { stdio: "inherit", windowsHide: true });
+  if (install.status !== 0) {
+    const why = install.error ? install.error.message : `exit code ${install.status ?? "unknown"}`;
+    return { ok: false, message: `npm install failed (${why}). If npm reported EPERM or EBUSY, another program still has token-goat's files open: close running agent sessions and run ${fencedCommand(MANUAL_INSTALL)}.` };
+  }
+  console.log(`Syncing token-goat hooks and integration manifests...`);
+  const launcher = installedLauncher(npm);
+  if (launcher) {
+    const sync = spawnSync(process.execPath, [launcher, "install"], { stdio: "inherit", windowsHide: true });
+    if (sync.status !== 0) return { ok: false, message: `the new version installed, but \`token-goat install\` failed (exit code ${sync.status ?? "unknown"}). Run \`token-goat install\` to finish.` };
+    return { ok: true };
+  }
+  try {
+    if (onSyncHooks) await onSyncHooks();
+  } catch (e) {
+    return { ok: false, message: `the new version installed, but syncing hooks failed (${e instanceof Error ? e.message : String(e)}). Run \`token-goat install\` to finish.` };
+  }
+  return { ok: true };
+}
+function installedLauncher(npm) {
+  const res = spawnSync(npm.file, [...npm.prefix, "root", "-g"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+  const root = res.status === 0 && typeof res.stdout === "string" ? res.stdout.trim() : "";
+  if (!root) return null;
+  const launcher = path.join(root, "token-goat", "dist", "token-goat.mjs");
+  return fs.existsSync(launcher) ? launcher : null;
+}
+
+export {
+  UPDATE_CACHE_TTL_MS,
+  FAILED_CHECK_TTL_MS,
+  getCachedUpdateStatus,
+  saveCachedUpdateStatus,
+  getRegistryUrl,
+  npmInvocation,
+  runningPackageRoot,
+  isDevCheckout,
+  upgradeDecision,
+  currentUpgradeDecision,
+  DEV_CHECKOUT_ADVICE,
+  updateAdvice,
+  fetchViaNpm,
+  fetchViaHttp,
+  fetchLatestVersion,
+  compareSemver,
+  checkUpdateStatus,
+  cmdUpgrade,
+  performUpgrade
+};