token-goat 2.9.29 → 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
+};