token-goat 2.9.30 → 2.9.31

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

@@ -0,0 +1,479 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  windowsPowerShellPath
+} from "./token-goat-chunk-65N4RHP4.mjs";
+import {
+  powerShellCommandArgs
+} from "./token-goat-chunk-X2SUP3EI.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/claude_hidden_rules.ts
+init_define_import_meta_env();
+import { execFile, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var HARMLESS_FLAGS = /* @__PURE__ */ new Set(["--resume", "-r", "--continue", "-c", "--fork-session", "--session-id", "--name", "-n", "--model", "--fallback-model", "--effort", "--thinking", "--max-thinking-tokens", "--dangerously-skip-permissions", "--allow-dangerously-skip-permissions", "--permission-mode", "--enable-auto-mode", "--verbose", "--debug", "-d", "--debug-file", "--print", "-p", "--output-format", "--include-partial-messages", "--ide", "--chrome", "--no-chrome", "--mcp-config", "--strict-mcp-config", "--append-system-prompt", "--append-system-prompt-file", "--system-prompt", "--system-prompt-file", "--max-turns", "--max-budget-usd", "--worktree", "-w", "--tmux", "--version", "-v", "--allowedtools", "--allowed-tools", "--tools", "--disable-slash-commands", "--no-session-persistence"]);
+var CLI_ENTRYPOINTS = /* @__PURE__ */ new Set(["cli", "sdk-cli"]);
+var BUILTIN_AGENTS = /* @__PURE__ */ new Set(["Explore", "Plan", "general-purpose", "statusline-setup", "claude-code-guide", "web-fetch", "fork", "claude", "worker", "workflow-subagent", "comment-thread-analyst"]);
+var RULE_DIRS = ["skills", "commands", "agents"];
+var RULE_PATH = /(?:^|\/)\.claude\/(?:skills|commands|agents)(?:\/|$)/;
+var AGENT_PATH = /(?:^|\/)\.claude\/agents(?:\/|$)/;
+var CLAUDE_INSIDE = /(?:^|\/)\.claude\//;
+var SCAN_BUDGET = 2e4;
+var NESTED_STAMP_DEPTH = 3;
+var NESTED_STAMP_DIRS = 2e3;
+var SCAN_TTL_MS = 6e4;
+var RACY_MS = 2e3;
+var FILE_HEAD_BYTES = 256 * 1024;
+var OPENS_FRONTMATTER = /^\uFEFF?---[ \t]*\r?\n/;
+var processCache;
+var fixedCache;
+var nestedCache;
+function resetHiddenRuleCache() {
+  processCache = void 0;
+  fixedCache = void 0;
+  nestedCache = void 0;
+}
+function hasProc() {
+  return process.platform !== "win32" && fs.existsSync("/proc/self/cmdline");
+}
+function procCommandLine(pid) {
+  if (!hasProc()) return void 0;
+  const raw = fs.readFileSync(`/proc/${pid}/cmdline`, "utf8");
+  return raw.includes("\0\0") ? null : raw.split("\0").join(" ").trim();
+}
+function commandLineQuery(pid) {
+  if (process.platform === "win32") return [windowsPowerShellPath(), powerShellCommandArgs(`(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine`)];
+  return ["ps", ["-ww", "-o", "args=", "-p", pid]];
+}
+function executableQuery(pid) {
+  return ["ps", ["-ww", "-o", "comm=", "-p", pid]];
+}
+function resolveCommand(word) {
+  const candidates = word.includes("/") ? [path.resolve(word)] : (process.env["PATH"] ?? "").split(path.delimiter).filter((d) => d !== "").map((d) => path.join(d, word));
+  for (const candidate of candidates) {
+    try {
+      return fs.realpathSync(candidate);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function untitledLine(printed, executable) {
+  const line = printed.replace(/\r?\n$/, "");
+  if (/\s$/.test(line) || executable === null) return null;
+  const first = line.trim().split(/\s+/)[0] ?? "";
+  const real = first === "" ? null : resolveCommand(first);
+  const exec = executable.trim();
+  let execReal;
+  try {
+    execReal = exec === "" ? null : fs.realpathSync(exec);
+  } catch {
+    execReal = null;
+  }
+  return real !== null && real === execReal ? line.trim() : null;
+}
+function commandLine(pid) {
+  try {
+    const proc = procCommandLine(pid);
+    if (proc !== void 0) return proc;
+    const [file, args] = commandLineQuery(pid);
+    const res = spawnSync(file, args, { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+    if (res.error !== void 0 || res.status !== 0) return null;
+    if (process.platform === "win32") return res.stdout.trim();
+    const [exeFile, exeArgs] = executableQuery(pid);
+    const exe = spawnSync(exeFile, exeArgs, { encoding: "utf8", windowsHide: true, timeout: 15e3 });
+    return untitledLine(res.stdout, exe.error === void 0 && exe.status === 0 ? exe.stdout : null);
+  } catch {
+    return null;
+  }
+}
+function queryAsync(file, args) {
+  return new Promise((resolve2) => {
+    execFile(file, args, { encoding: "utf8", windowsHide: true, timeout: 15e3 }, (err, stdout) => resolve2(err === null ? stdout : null));
+  });
+}
+async function commandLineAsync(pid) {
+  try {
+    const proc = procCommandLine(pid);
+    if (proc !== void 0) return proc;
+    const [file, args] = commandLineQuery(pid);
+    const printed = await queryAsync(file, args);
+    if (printed === null) return null;
+    if (process.platform === "win32") return printed.trim();
+    const [exeFile, exeArgs] = executableQuery(pid);
+    return untitledLine(printed, await queryAsync(exeFile, exeArgs));
+  } catch {
+    return null;
+  }
+}
+function processKeyOf(env) {
+  return `${env["CLAUDE_CODE_SESSION_ID"] ?? ""}:${env["CLAUDE_PID"] ?? ""}:${env["CLAUDE_CODE_ENTRYPOINT"] ?? ""}`;
+}
+function entryReason(env) {
+  const entrypoint = env["CLAUDE_CODE_ENTRYPOINT"] ?? "";
+  if (!CLI_ENTRYPOINTS.has(entrypoint)) return `entry point ${entrypoint === "" ? "unknown" : entrypoint}`;
+  if (!/^[1-9]\d{0,9}$/.test(env["CLAUDE_PID"] ?? "")) return "claude process unknown";
+  return null;
+}
+function flagsOf(line) {
+  const flags = [];
+  const words = (line.match(/"[^"]*"?|\S+/g) ?? []).map((raw) => raw.replace(/^"/, "").replace(/"$/, ""));
+  for (let i = 0; i < words.length; i++) {
+    const token = words[i];
+    if (token === "--") break;
+    if (!token.startsWith("-")) continue;
+    const eq = token.indexOf("=");
+    const next = words[i + 1];
+    flags.push({ name: (eq < 0 ? token : token.slice(0, eq)).toLowerCase(), value: eq >= 0 ? token.slice(eq + 1) : next !== void 0 && !next.startsWith("-") ? next : void 0 });
+  }
+  return flags;
+}
+var PROOF_SOURCES = ["user", "project", "local"];
+function flagsReason(flags) {
+  for (const { name, value } of flags) {
+    if (name === "--setting-sources") {
+      const given = new Set((value ?? "").toLowerCase().split(",").map((v) => v.trim()));
+      const dropped = PROOF_SOURCES.find((source) => !given.has(source));
+      if (dropped !== void 0) return `claude started with --setting-sources without ${dropped}`;
+    } else if (!HARMLESS_FLAGS.has(name)) return `claude started with ${name}`;
+  }
+  return null;
+}
+function commandLineReason(line) {
+  return line === null || line === "" ? "claude command line unreadable" : flagsReason(flagsOf(line));
+}
+function processReason(env) {
+  const key = processKeyOf(env);
+  if (processCache?.key === key) return processCache.reason;
+  const entry = entryReason(env);
+  const line = entry === null ? commandLine(env["CLAUDE_PID"]) : null;
+  const reason = entry ?? commandLineReason(line);
+  if (entry !== null || line !== null) processCache = { key, reason };
+  return reason;
+}
+function isOtherHost(env) {
+  const entrypoint = env["CLAUDE_CODE_ENTRYPOINT"] ?? "";
+  return entrypoint !== "" && !CLI_ENTRYPOINTS.has(entrypoint);
+}
+function commandLineRuleSource(env) {
+  return isOtherHost(env) ? null : processReason(env);
+}
+async function primeProcessReason(env) {
+  const key = processKeyOf(env);
+  if (processCache?.key === key) return;
+  const entry = entryReason(env);
+  const line = entry === null ? await commandLineAsync(env["CLAUDE_PID"]) : null;
+  if (entry !== null || line !== null) processCache = { key, reason: entry ?? commandLineReason(line) };
+}
+function frontmatter(text) {
+  return /^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(text)?.[1];
+}
+function frontmatterAddsRule(front) {
+  if (front.includes("PermissionRequest")) return true;
+  const lines = front.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^\s*["']?disallowed[-_]?tools["']?\s*:(.*)$/i.exec(lines[i]);
+    if (m === null) continue;
+    let value = m[1];
+    for (let j = i + 1; j < lines.length && /^[\s-]/.test(lines[j]); j++) value += ` ${lines[j]}`;
+    if (value.split(/[\s,[\]"'-]+/).some((t) => t !== "" && !/^[A-Za-z0-9_*.]+$/.test(t))) return true;
+  }
+  return false;
+}
+function newScan(helpers, stamped) {
+  return { helpers, budget: SCAN_BUDGET, reason: null, stamps: stamped ? /* @__PURE__ */ new Map() : void 0, agents: /* @__PURE__ */ new Set(), pluginAgents: /* @__PURE__ */ new Set(), startedAt: Date.now(), volatile: false, walked: /* @__PURE__ */ new Set() };
+}
+function result(scan) {
+  return { reason: scan.reason, stamps: scan.stamps ?? /* @__PURE__ */ new Map(), agents: scan.agents, pluginAgents: scan.pluginAgents, volatile: scan.volatile };
+}
+function stamp(file) {
+  try {
+    const st = fs.statSync(file);
+    return `${st.mtimeMs}:${st.isDirectory() ? "dir" : st.size}`;
+  } catch (err) {
+    const code = err.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? "absent" : "unreadable";
+  }
+}
+function record(scan, file) {
+  if (scan.stamps === void 0) return;
+  const was = stamp(file);
+  scan.stamps.set(file, was);
+  if (was === "unreadable" || Number(was.slice(0, was.indexOf(":"))) > scan.startedAt - RACY_MS) scan.volatile = true;
+}
+function stillCurrent(stamps) {
+  for (const [file, was] of stamps) if (stamp(file) !== was) return false;
+  return true;
+}
+function head(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, "r");
+    const buf = Buffer.alloc(FILE_HEAD_BYTES);
+    const got = fs.readSync(fd, buf, 0, FILE_HEAD_BYTES, 0);
+    return { text: buf.subarray(0, got).toString("utf8"), cut: got === FILE_HEAD_BYTES && fs.fstatSync(fd).size > got };
+  } catch (err) {
+    const code = err.code;
+    return { failure: code === "ENOENT" || code === "ENOTDIR" ? "missing" : "unreadable" };
+  } finally {
+    if (fd !== void 0) fs.closeSync(fd);
+  }
+}
+function checkFile(file, scan, place) {
+  const lower = file.toLowerCase();
+  const json = lower.endsWith(".json");
+  if (!json && !lower.endsWith(".md")) return;
+  record(scan, file);
+  const read = head(file);
+  let text;
+  let cut;
+  if ("failure" in read) {
+    if (read.failure === "unreadable") {
+      scan.reason = `cannot read ${file}`;
+      return;
+    }
+    const indexed = scan.indexedText?.(file);
+    if (indexed === void 0) return;
+    if (indexed === null) {
+      scan.reason = `cannot read ${file} from the index`;
+      return;
+    }
+    text = indexed.slice(0, FILE_HEAD_BYTES);
+    cut = indexed.length > FILE_HEAD_BYTES;
+  } else {
+    text = read.text;
+    cut = read.cut;
+  }
+  const front = json ? void 0 : frontmatter(text) ?? "";
+  const unfinished = cut && (json || OPENS_FRONTMATTER.test(text) && frontmatter(text) === void 0);
+  if (front === void 0 ? text.includes("PermissionRequest") : frontmatterAddsRule(front)) scan.reason = `rule source ${file}`;
+  else if (unfinished) scan.reason = `cannot scan ${file}: it runs past the first ${FILE_HEAD_BYTES} bytes read`;
+  else if (front !== void 0 && place.agents) {
+    const name = /^name[ \t]*:(.*)$/m.exec(front)?.[1]?.trim().replace(/^(["'])(.*)\1$/, "$2");
+    if (name !== void 0 && name !== "") (place.plugin ? scan.pluginAgents : scan.agents).add(name);
+  }
+}
+function linksToDir(full) {
+  try {
+    return fs.lstatSync(full).isSymbolicLink() && fs.statSync(full).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function scanDir(dir, scan, place) {
+  if (scan.reason !== null || !scan.helpers.sourceAllowed(dir)) return;
+  record(scan, dir);
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") scan.reason = `cannot read ${dir}`;
+    return;
+  }
+  for (const entry of entries) {
+    if (scan.reason !== null) return;
+    if (--scan.budget < 0) {
+      scan.reason = "too many files to check";
+      return;
+    }
+    const full = path.join(dir, entry.name);
+    let isDir = entry.isDirectory();
+    let isFile = entry.isFile();
+    if (entry.isSymbolicLink()) {
+      try {
+        const st = fs.statSync(full);
+        isDir = st.isDirectory();
+        isFile = st.isFile();
+      } catch {
+        continue;
+      }
+    }
+    if (isDir && entry.name !== "node_modules" && entry.name !== ".git") {
+      if (place.depth >= 32) scan.reason = `too deep under ${dir}`;
+      else scanDir(full, scan, { ...place, depth: place.depth + 1, agents: place.agents || entry.name === "agents" });
+    } else if (isFile) {
+      checkFile(full, scan, place);
+    }
+  }
+}
+function scanClaudeDir(claudeDir, scan) {
+  for (const sub of RULE_DIRS) scanDir(path.join(claudeDir, sub), scan, { depth: 0, agents: sub === "agents", plugin: false });
+}
+function firstWalk(dir, scan) {
+  let real;
+  try {
+    real = fs.realpathSync.native(dir);
+  } catch {
+    return true;
+  }
+  const key = process.platform === "win32" ? real.toLowerCase() : real;
+  if (scan.walked.has(key)) return false;
+  scan.walked.add(key);
+  return true;
+}
+function walkForClaudeDirs(dir, scan, depth = 0) {
+  if (scan.reason !== null || !scan.helpers.sourceAllowed(dir) || !firstWalk(dir, scan)) return;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") scan.reason = `cannot read ${dir}`;
+    return;
+  }
+  for (const entry of entries) {
+    if (scan.reason !== null) return;
+    if (--scan.budget < 0) {
+      scan.reason = "too many files to check";
+      return;
+    }
+    if (entry.name === ".git") continue;
+    const full = path.join(dir, entry.name);
+    if (!entry.isDirectory() && !(entry.isSymbolicLink() && linksToDir(full))) continue;
+    if (entry.name === ".claude") scanClaudeDir(full, scan);
+    else if (depth >= 32) scan.reason = `too deep under ${dir}`;
+    else walkForClaudeDirs(full, scan, depth + 1);
+  }
+}
+function scanGitCheckout(project, scan) {
+  const list = (args) => {
+    const res = scan.helpers.runGit(["ls-files", "-z", ...args], { cwd: project, timeoutMs: 15e3 });
+    return res.exitCode === 0 ? res.stdout.split("\0").filter((entry) => entry !== "") : null;
+  };
+  const tracked = list(["-s"]);
+  const untracked = list(["-o", "--exclude-standard"]);
+  const ignored = list(["-o", "-i", "--exclude-standard", "--directory"]);
+  if (tracked === null || untracked === null || ignored === null) {
+    scan.reason = "cannot list nested skills";
+    return;
+  }
+  stampListedDirs(project, [...tracked.map((record2) => record2.slice(record2.indexOf("	") + 1)), ...untracked, ...ignored], scan);
+  const candidates = [...untracked, ...ignored.filter((rel) => !rel.endsWith("/"))];
+  const objects = /* @__PURE__ */ new Map();
+  for (const record2 of tracked) {
+    const tab = record2.indexOf("	");
+    const rel = record2.slice(tab + 1);
+    if (record2.startsWith("120000 ") || RULE_PATH.test(rel)) candidates.push(rel);
+    if (RULE_PATH.test(rel)) objects.set(path.join(project, rel), record2.slice(0, tab).split(" ")[1]);
+  }
+  scan.indexedText = (file) => {
+    const object = objects.get(file);
+    if (object === void 0) return void 0;
+    const res = scan.helpers.runGit(["cat-file", "blob", object], { cwd: project, timeoutMs: 15e3 });
+    return res.exitCode === 0 ? res.stdout : null;
+  };
+  const sorted = [...ignored].sort();
+  const ignoredDirs = sorted.filter((rel, i) => rel.endsWith("/") && sorted[i + 1]?.startsWith(rel) !== true && CLAUDE_INSIDE.test(rel));
+  for (const rel of [...candidates, ...ignoredDirs]) {
+    if (scan.reason !== null) return;
+    if (--scan.budget < 0) {
+      scan.reason = "too many files to check";
+      return;
+    }
+    const full = path.join(project, rel);
+    const place = { depth: 0, agents: AGENT_PATH.test(rel), plugin: false };
+    if (rel.endsWith("/") || linksToDir(full)) {
+      if (RULE_PATH.test(rel)) scanDir(full, scan, place);
+      else if (path.basename(full) === ".claude") scanClaudeDir(full, scan);
+      else if (!rel.endsWith("/")) walkForClaudeDirs(full, scan);
+    } else if (RULE_PATH.test(rel)) {
+      checkFile(full, scan, place);
+    }
+  }
+}
+function scanFixed(cwd, project, helpers) {
+  const scan = newScan(helpers, true);
+  const configDir = helpers.configDir();
+  const roots = [configDir, ...[cwd, project].flatMap(helpers.selfAndAncestors).map((d) => path.join(d, ".claude")), ...helpers.managedDirs().map((d) => path.join(d, ".claude"))];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const key = process.platform === "win32" ? root.toLowerCase() : root;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    scanClaudeDir(root, scan);
+  }
+  scanDir(path.join(configDir, "plugins", "cache"), scan, { depth: 0, agents: false, plugin: true });
+  return result(scan);
+}
+function gitDirOf(root) {
+  const dot = path.join(root, ".git");
+  try {
+    if (fs.statSync(dot).isDirectory()) return dot;
+    const line = fs.readFileSync(dot, "utf8").split("\n").find((l) => l.startsWith("gitdir:"));
+    const named = line?.slice("gitdir:".length).trim();
+    return named === void 0 || named === "" ? dot : path.resolve(root, named);
+  } catch {
+    return dot;
+  }
+}
+function stampGitState(root, scan) {
+  const gitDir = gitDirOf(root);
+  for (const name of ["index", "HEAD"]) record(scan, path.join(gitDir, name));
+}
+function stampListedDirs(project, listed, scan) {
+  const dirs = /* @__PURE__ */ new Set([project]);
+  for (const rel of listed) {
+    const parts = rel.split("/").filter((part) => part !== "");
+    const claude = parts.indexOf(".claude");
+    const add = (from, to) => {
+      for (let n = from; n <= to; n++) dirs.add(path.join(project, ...parts.slice(0, n)));
+    };
+    add(1, Math.min(parts.length - 1, NESTED_STAMP_DEPTH));
+    if (claude >= 0) add(claude, parts.length - 1);
+    if (dirs.size >= NESTED_STAMP_DIRS) {
+      scan.volatile = true;
+      break;
+    }
+  }
+  for (const dir of dirs) record(scan, dir);
+}
+function scanNested(project, helpers) {
+  const scan = newScan(helpers, true);
+  const root = helpers.selfAndAncestors(project).find((d) => fs.existsSync(path.join(d, ".git")));
+  if (root !== void 0) {
+    stampGitState(root, scan);
+    scanGitCheckout(project, scan);
+  } else walkForClaudeDirs(project, scan);
+  return result(scan);
+}
+function agentReason(agentType, scans) {
+  if (agentType === void 0 || BUILTIN_AGENTS.has(agentType)) return null;
+  const colon = agentType.lastIndexOf(":");
+  const known = colon < 0 ? scans.some((s) => s.agents.has(agentType)) : scans.some((s) => s.pluginAgents.has(agentType.slice(colon + 1)));
+  return known ? null : `agent ${agentType} not checked`;
+}
+function hiddenRuleSource(cwd, projectDir, env, helpers, query = {}) {
+  const now = query.now ?? Date.now();
+  const processKey = processKeyOf(env);
+  const processReasonNow = query.filesOnly === true ? null : processReason(env);
+  if (processReasonNow !== null) return processReasonNow;
+  const here = path.resolve(cwd);
+  const project = projectDir !== void 0 && path.isAbsolute(projectDir) ? path.resolve(projectDir) : here;
+  const scanKey = `${processKey}:${here}:${project}`;
+  if (fixedCache?.key !== scanKey || (fixedCache.reason !== null ? now - fixedCache.at > SCAN_TTL_MS : fixedCache.volatile || !stillCurrent(fixedCache.stamps))) fixedCache = { key: scanKey, at: now, ...scanFixed(here, project, helpers) };
+  if (fixedCache.reason !== null) return fixedCache.reason;
+  if (nestedCache?.key !== scanKey || now - nestedCache.at > SCAN_TTL_MS || nestedCache.reason === null && (nestedCache.volatile || !stillCurrent(nestedCache.stamps))) nestedCache = { key: scanKey, at: now, ...scanNested(project, helpers) };
+  return nestedCache.reason ?? agentReason(query.agentType, [fixedCache, nestedCache]);
+}
+function hiddenRules(helpers) {
+  return {
+    hidden: (cwd, agentType, filesOnly) => hiddenRuleSource(cwd, process.env["CLAUDE_PROJECT_DIR"], process.env, helpers, { agentType, filesOnly }) !== null,
+    lineRules: () => commandLineRuleSource(process.env) !== null,
+    prime: (env) => primeProcessReason(env)
+  };
+}
+export {
+  commandLineRuleSource,
+  frontmatterAddsRule,
+  hiddenRuleSource,
+  hiddenRules,
+  primeProcessReason,
+  resetHiddenRuleCache,
+  stamp
+};

package/dist/{token-goat-chunk-4LCCNRTG.mjs → token-goat-chunk-CVCEVUGK.mjs}

@@ -3,12 +3,13 @@ const require = __cjsRequire(import.meta.url);
 import {
   copyFromSharedCache,
   downloadPinned
-} from "./token-goat-chunk-PD5VKH46.mjs";
-import "./token-goat-chunk-SMVRN2HU.mjs";
+} from "./token-goat-chunk-AUNGYYQX.mjs";
+import "./token-goat-chunk-2UPZGKKY.mjs";
 import {
   loadConfig
-} from "./token-goat-chunk-7IN2MKDS.mjs";
-import "./token-goat-chunk-U4N3BN2W.mjs";
+} 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";
@@ -16,12 +17,13 @@ import "./token-goat-chunk-IVE6U7KV.mjs";
 import {
   atomicWriteText,
   ensureDirSync
-} from "./token-goat-chunk-GOLEOXZP.mjs";
+} 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-VES7EL7O.mjs";
+} from "./token-goat-chunk-CO3UYX6G.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";

package/dist/{token-goat-chunk-B2RZZCSS.mjs → token-goat-chunk-CXHOFN7R.mjs}

@@ -1,18 +1,25 @@
 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-7IN2MKDS.mjs";
+} from "./token-goat-chunk-7EZTZOMC.mjs";
 import {
   ensureDirSync
-} from "./token-goat-chunk-GOLEOXZP.mjs";
+} 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-VES7EL7O.mjs";
+} from "./token-goat-chunk-CO3UYX6G.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -102,7 +109,7 @@ function currentUpgradeDecision(status) {
 }
 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 === "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;
 }
@@ -137,6 +144,8 @@ async function fetchViaHttp(registryUrl, timeoutMs = 3500) {
         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) => {
@@ -247,18 +256,18 @@ async function checkUpdateStatus(timeoutMs = 3500, forceFresh = false) {
 async function cmdUpgrade(opts = {}, onSyncHooks) {
   const status = await checkUpdateStatus(3500, true);
   if (opts.check) {
-    if (opts.json) {
-      console.log(displaySafeJson(status, 2));
+    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 (status.error) {
-      console.log(`Current version: v${status.current}`);
-      console.log(`[!] ${status.error}`);
+    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.`);
+      console.log(`Run \`token-goat upgrade\` to update.`);
     } else {
       console.log(`token-goat is up to date (v${status.current})`);
     }
@@ -267,11 +276,11 @@ async function cmdUpgrade(opts = {}, onSyncHooks) {
   const decision = currentUpgradeDecision(status);
   switch (decision) {
     case "offline":
-      console.error(`token-goat: network.offline is set, so no update check was made and nothing was installed. Unset it (or TOKEN_GOAT_OFFLINE) to upgrade.`);
+      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(`token-goat: ${status.error ?? "could not determine the latest version"}. Nothing was installed.`);
+      console.error(formatCommandError(`${status.error ?? "could not determine the latest version"}. Nothing was installed.`));
       process.exitCode = 1;
       return;
     case "up-to-date":
@@ -288,7 +297,7 @@ async function cmdUpgrade(opts = {}, onSyncHooks) {
   console.log(`Upgrading token-goat v${status.current} -> v${status.latest}...`);
   const outcome = await performUpgrade(onSyncHooks);
   if (!outcome.ok) {
-    console.error(`token-goat: ${outcome.message}`);
+    console.error(formatCommandError(outcome.message));
     process.exitCode = 1;
     return;
   }
@@ -296,35 +305,43 @@ async function cmdUpgrade(opts = {}, onSyncHooks) {
 }
 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 '${MANUAL_INSTALL}' yourself.` };
+  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 } = await import("./token-goat-chunk-KQNZDCBD.mjs");
+    const { stopWorker, readPidFile } = await import("./token-goat-chunk-NSNSPPBG.mjs");
     const { queryServers } = await import("./token-goat-hook-client.mjs");
     await queryServers("stop");
-    stopWorker();
+    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 '${MANUAL_INSTALL}'.` };
+    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.` };
+    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: 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", timeout: 1e4, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+  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");