pushary 1.8.0

package/dist/chunk-A2A2YTMG.js

@@ -0,0 +1,835 @@
+import {
+  CLI_PACKAGE_NAMES,
+  HOOK_BUDGETS,
+  HOOK_LOCATOR_BINARY,
+  OWNERSHIP_PROBE_COMMAND,
+  classifyGlobalFolder,
+  classifyGlobalInstall,
+  cmdShimTarget,
+  decideCommandOwner,
+  globalInstallTarget,
+  globalPackageFolder,
+  globalRootFor,
+  isReleaseVersion,
+  ownPackageName,
+  withHookHoldBudget
+} from "./chunk-NQTHFF4W.js";
+
+// src/npm.ts
+import { execFileSync, execSync } from "child_process";
+import { existsSync, readFileSync, readlinkSync, realpathSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+var latestReleaseUrl = (packageName) => `https://registry.npmjs.org/${packageName}/latest`;
+var REGISTRY_TIMEOUT_MS = 5e3;
+var LATEST_TAG = "latest";
+var cleanNpmEnv = () => {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.toLowerCase().startsWith("npm_config_workspace")) continue;
+    env[key] = value;
+  }
+  return env;
+};
+var NPM_ERROR_METADATA = /^(code|syscall|path|dest|errno)\s/i;
+var npmErrorMessage = (err) => {
+  const e = err;
+  const text = [e?.stderr, e?.stdout].map((part) => part ? part.toString() : "").join("\n");
+  const line = text.split("\n").map((l) => l.replace(/^npm error\s*/i, "").trim()).find((l) => l && !l.startsWith("A complete log") && !NPM_ERROR_METADATA.test(l));
+  return line || e?.message || String(err);
+};
+var execNpm = (args, options = {}) => {
+  return execSync(`npm ${args}`, {
+    timeout: 12e4,
+    stdio: "pipe",
+    ...options,
+    env: { ...cleanNpmEnv(), ...options.env ?? {} }
+  });
+};
+var GLOBAL_PREFIX_TIMEOUT_MS = 5e3;
+var readGlobalPrefix = () => {
+  try {
+    const prefix = execNpm("prefix -g --no-workspaces", { timeout: GLOBAL_PREFIX_TIMEOUT_MS }).toString().trim();
+    return prefix === "" ? void 0 : prefix;
+  } catch {
+    return void 0;
+  }
+};
+var resolveGlobalBinary = (name) => {
+  const prefix = readGlobalPrefix();
+  if (prefix === void 0) return void 0;
+  const candidates = process.platform === "win32" ? [join(prefix, `${name}.cmd`), join(prefix, name)] : [join(prefix, "bin", name)];
+  return candidates.find(existsSync);
+};
+var resolvePathBinary = (name, platform = process.platform) => {
+  try {
+    return execFileSync(platform === "win32" ? "where" : "which", [name], {
+      encoding: "utf8",
+      stdio: "pipe",
+      timeout: 5e3
+    }).split(/\r?\n/, 1)[0]?.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var NPM_MISSING_MESSAGE = "npm is not on PATH, and the hooks run from a global npm install.";
+var NPM_LOOKUP = process.platform === "win32" ? "where npm" : "command -v npm";
+var npmIsOnPath = () => {
+  try {
+    execSync(NPM_LOOKUP, { env: cleanNpmEnv(), stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var GLOBAL_LIST_TIMEOUT_MS = 3e4;
+var globalPackageState = (name) => {
+  try {
+    const listing = JSON.parse(execNpm("list -g --depth=0 --json --no-workspaces", { timeout: GLOBAL_LIST_TIMEOUT_MS }).toString());
+    const dependencies = typeof listing === "object" && listing !== null && "dependencies" in listing ? listing.dependencies : void 0;
+    return typeof dependencies === "object" && dependencies !== null && name in dependencies ? "installed" : "absent";
+  } catch {
+    return "unknown";
+  }
+};
+var NpmMissingError = class extends Error {
+  constructor() {
+    super(NPM_MISSING_MESSAGE);
+    this.name = "NpmMissingError";
+  }
+};
+var resolveBinary = (name) => resolveGlobalBinary(name) ?? resolvePathBinary(name);
+var resolvePackageVersionFromBinary = (binary, packageName) => {
+  try {
+    let dir = dirname(realpathSync(binary));
+    const packagePath = packageName.split("/");
+    for (let depth = 0; depth < 8; depth++) {
+      for (const manifest of [
+        join(dir, "package.json"),
+        join(dir, "node_modules", ...packagePath, "package.json")
+      ]) {
+        try {
+          const value = JSON.parse(readFileSync(manifest, "utf8"));
+          if (value.name === packageName && typeof value.version === "string") return value.version;
+        } catch {
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return void 0;
+};
+var resolveGlobalPackageVersion = (name) => {
+  try {
+    const result = JSON.parse(execNpm("list -g --depth=0 --json --no-workspaces", { timeout: 5e3 }).toString());
+    const value = result.dependencies?.[name]?.version;
+    return typeof value === "string" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var localImportsPresent = (entry, packageDir, seen = /* @__PURE__ */ new Set()) => {
+  if (seen.has(entry)) return true;
+  seen.add(entry);
+  try {
+    const source = readFileSync(entry, "utf8");
+    for (const match of source.matchAll(/\b(?:import|export)\s+(?:[^"'()]*?\s+from\s+)?["'](\.{1,2}\/[^"']+)["']|\bimport\s*\(\s*["'](\.{1,2}\/[^"']+)["']/g)) {
+      const dependency = resolve(dirname(entry), match[1] ?? match[2]);
+      const localPath = relative(packageDir, dependency);
+      if (localPath.startsWith("..") || isAbsolute(localPath) || !existsSync(dependency)) return false;
+      if (/\.[cm]?js$/.test(dependency) && !localImportsPresent(dependency, packageDir, seen)) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+var packageBinsPresent = (packageDir, prefix, platform = process.platform, requiredFiles = []) => {
+  try {
+    const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+    if (!manifest.bin || typeof manifest.bin !== "object" || Array.isArray(manifest.bin)) return false;
+    const bins = Object.entries(manifest.bin);
+    if (bins.length === 0) return false;
+    if (!requiredFiles.every((path) => existsSync(join(packageDir, path)))) return false;
+    const seen = /* @__PURE__ */ new Set();
+    return bins.every(([name, target]) => {
+      if (typeof target !== "string") return false;
+      const shims = platform === "win32" ? [join(prefix, `${name}.cmd`), join(prefix, name)] : [join(prefix, "bin", name)];
+      const entry = join(packageDir, target);
+      return existsSync(entry) && shims.some(existsSync) && localImportsPresent(entry, packageDir, seen);
+    });
+  } catch {
+    return false;
+  }
+};
+var AGENT_HOOKS_RUNTIME_FILES = [
+  "data/SKILL.md",
+  "data/cursor-plugin/.cursor-plugin/plugin.json",
+  "data/cursor-plugin/hooks/hooks.json",
+  "data/cursor-plugin/mcp.json",
+  "data/cursor-plugin/scripts/pushary-gate.mjs",
+  "data/cursor-plugin/scripts/redaction.mjs",
+  "data/vscode-plugin/.claude-plugin/plugin.json",
+  "data/vscode-plugin/hooks/hooks.json",
+  "data/vscode-plugin/.mcp.json",
+  "data/vscode-plugin/scripts/pushary-gate.mjs",
+  "data/vscode-plugin/scripts/redaction.mjs"
+];
+var globalPackageBinsPresent = (name, prefix, platform) => packageBinsPresent(globalPackageFolder(globalRootFor(prefix, platform), name, platform), prefix, platform, AGENT_HOOKS_RUNTIME_FILES);
+var errorCode = (error) => typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+var realpathOrUndefined = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return void 0;
+  }
+};
+var definedPaths = (paths) => paths.filter((path) => path !== void 0);
+var readPosixCommandLink = (prefix) => {
+  const command = join(prefix, "bin", OWNERSHIP_PROBE_COMMAND);
+  try {
+    const target = resolve(dirname(command), readlinkSync(command));
+    return { kind: "resolved", targets: definedPaths([target, realpathOrUndefined(command)]) };
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return { kind: "absent" };
+    const real = realpathOrUndefined(command);
+    return real === void 0 ? { kind: "unreadable" } : { kind: "resolved", targets: [real] };
+  }
+};
+var readWindowsCommandLink = (prefix) => {
+  const shim = join(prefix, `${OWNERSHIP_PROBE_COMMAND}.cmd`);
+  try {
+    const target = cmdShimTarget(prefix, readFileSync(shim, "utf8"));
+    return target === void 0 ? { kind: "unreadable" } : { kind: "resolved", targets: [target] };
+  } catch (error) {
+    return errorCode(error) === "ENOENT" ? { kind: "absent" } : { kind: "unreadable" };
+  }
+};
+var readCommandLink = (prefix, platform) => platform === "win32" ? readWindowsCommandLink(prefix) : readPosixCommandLink(prefix);
+var readFolderManifest = (folder) => {
+  try {
+    return { kind: "read", manifest: JSON.parse(readFileSync(join(folder, "package.json"), "utf8")) };
+  } catch {
+    return { kind: "unreadable" };
+  }
+};
+var readGlobalFolder = (root, name, platform = process.platform) => classifyGlobalFolder(name, readFolderManifest(globalPackageFolder(root, name, platform)));
+var installedIfOurs = (folder) => folder.kind === "ours" ? [folder.installed] : [];
+var readInstalledCliPackages = (root, platform = process.platform) => CLI_PACKAGE_NAMES.flatMap((name) => installedIfOurs(readGlobalFolder(root, name, platform)));
+var globalRootsFor = (prefix, platform) => {
+  const root = globalRootFor(prefix, platform);
+  return definedPaths([root, realpathOrUndefined(root)]);
+};
+var readCommandOwner = (prefix, platform = process.platform) => decideCommandOwner({
+  platform,
+  globalRoots: globalRootsFor(prefix, platform),
+  link: readCommandLink(prefix, platform),
+  installed: readInstalledCliPackages(globalRootFor(prefix, platform), platform).map((installed) => installed.name)
+});
+var NPM_UNAVAILABLE_OWNER = { kind: "unknown", reason: "npm_unavailable" };
+var readGlobalCliInstallAt = (prefix, platform = process.platform) => classifyGlobalInstall(readInstalledCliPackages(globalRootFor(prefix, platform), platform), readCommandOwner(prefix, platform));
+var readGlobalCliInstall = (platform = process.platform) => {
+  const prefix = readGlobalPrefix();
+  return prefix === void 0 ? { kind: "unavailable" } : readGlobalCliInstallAt(prefix, platform);
+};
+var resolveGlobalBinDir = (probe) => {
+  if (process.platform === "win32") return void 0;
+  const resolved = resolveGlobalBinary(probe);
+  return resolved ? resolved.slice(0, resolved.length - probe.length - 1) : void 0;
+};
+var quoteIfNeeded = (path) => /\s/.test(path) ? `"${path}"` : path;
+var fetchLatestPublishedVersion = async (request) => {
+  try {
+    const response = await (request.fetchImpl ?? fetch)(latestReleaseUrl(request.packageName), {
+      signal: AbortSignal.timeout(request.timeoutMs ?? REGISTRY_TIMEOUT_MS)
+    });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    const version = body && typeof body === "object" && "version" in body ? body.version : void 0;
+    return typeof version === "string" && isReleaseVersion(version) ? version : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var POSIX_SHELL_WORD = /^[\w@%+=:,./-]+$/;
+var quoteForPosixShell = (value) => POSIX_SHELL_WORD.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+var installPackageGlobally = (request, runNpm = execNpm) => {
+  const prefixFlag = request.prefix === void 0 ? "" : ` --prefix ${quoteForPosixShell(request.prefix)}`;
+  const spec = quoteForPosixShell(`${request.packageName}@${request.version}`);
+  runNpm(`install -g --no-workspaces${prefixFlag} ${spec}`, { timeout: request.timeoutMs });
+};
+var needsGlobalInstall = (requested, installed, binaryPresent) => requested !== installed || !binaryPresent;
+var planGlobalInstall = (platform) => {
+  const prefix = readGlobalPrefix();
+  const owner = prefix === void 0 ? NPM_UNAVAILABLE_OWNER : readCommandOwner(prefix, platform);
+  return { prefix, packageName: globalInstallTarget(owner, ownPackageName()) };
+};
+var plannedGlobalPackage = () => planGlobalInstall(process.platform).packageName;
+var installedVersionOf = (prefix, name, platform) => {
+  const folder = readGlobalFolder(globalRootFor(prefix, platform), name, platform);
+  return folder.kind === "ours" ? folder.installed.version : void 0;
+};
+var asCachedResult = (result) => result === "installed" ? "cached" : result;
+var installState;
+var installGlobally = (options) => {
+  if (installState) {
+    return installState.then(asCachedResult);
+  }
+  const started = (async () => {
+    if (!npmIsOnPath()) throw new NpmMissingError();
+    const platform = process.platform;
+    const { prefix, packageName } = planGlobalInstall(platform);
+    const pinned = process.env.PUSHARY_PIN_GLOBAL_VERSION !== "0";
+    if (pinned && prefix !== void 0 && !needsGlobalInstall(
+      options.version,
+      installedVersionOf(prefix, packageName, platform),
+      globalPackageBinsPresent(packageName, prefix, platform)
+    )) {
+      return "skipped";
+    }
+    const version = pinned && options.version && options.version !== "0.0.0" ? options.version : LATEST_TAG;
+    installPackageGlobally({ packageName, version, timeoutMs: options.timeoutMs ?? 12e4 });
+    return "installed";
+  })();
+  installState = started;
+  started.catch(() => {
+    if (installState === started) installState = void 0;
+  });
+  return started;
+};
+
+// src/hook-command.ts
+var HOOK_SHELL = "/bin/sh -c";
+var holdBudgetOf = (hook) => hook.holds ? hook.timeout : void 0;
+var LOCATE = 'B=$(command -v "$0") || exit 0; [ -f "$B" ] || exit 0; [ -x "$B" ] || exit 0';
+var NODE_PRESENT = "command -v node >/dev/null 2>&1 || exit 0";
+var CURSOR_NO_OPINION = { permission: "deny", user_message: "Command denied via Pushary.", agent_message: "Pushary hook is unavailable. Repair the integration before retrying." };
+var shellDoubleQuoted = (text) => `"${text.replace(/(["\\$`])/g, "\\$1")}"`;
+var CURSOR_NATIVE_PROMPT = { permission: "ask" };
+var CURSOR_NATIVE_PROMPT_EVENTS = ["beforeShellExecution", "beforeMCPExecution"];
+var hookEventIsOneOf = (events) => events.flatMap((event) => [`*\\"hook_event_name\\":\\"${event}\\"*`, `*\\"hook_event_name\\":\\ \\"${event}\\"*`]).join("|");
+var CURSOR_MISS = `{ E=$(cat); case "$E" in ${hookEventIsOneOf(CURSOR_NATIVE_PROMPT_EVENTS)}) printf %s ${shellDoubleQuoted(JSON.stringify(CURSOR_NATIVE_PROMPT))} ;; *) printf %s ${shellDoubleQuoted(JSON.stringify(CURSOR_NO_OPINION))} ;; esac; exit 0; }`;
+var HOOK_GUARD_SCRIPTS = {
+  native_binary: `${LOCATE}; exec "$B" "$@"`,
+  node_binary: `${LOCATE}; ${NODE_PRESENT}; exec "$B" "$@"`,
+  node_script: `[ -f "$0" ] || exit 0; ${NODE_PRESENT}; exec node "$0" "$@"`,
+  cursor_gate_script: `[ -f "$0" ] || ${CURSOR_MISS}; command -v node >/dev/null 2>&1 || ${CURSOR_MISS}; exec node "$0" "$@"`
+};
+var BINARY_GUARDS = {
+  native: "native_binary",
+  node: "node_binary"
+};
+var guardKindOf = (target) => {
+  switch (target.kind) {
+    case "node":
+      return "node_script";
+    case "cursor_gate":
+      return "cursor_gate_script";
+    case "binary":
+      return BINARY_GUARDS[target.runtime];
+  }
+};
+var targetPath = (target) => target.kind === "binary" ? target.path : target.script;
+var runsThroughNode = (target) => target.kind !== "binary";
+var guardHookCommand = (target, platform = process.platform) => {
+  const path = quoteIfNeeded(targetPath(target));
+  if (platform === "win32") return runsThroughNode(target) ? `node ${path}` : path;
+  return `${HOOK_SHELL} '${HOOK_GUARD_SCRIPTS[guardKindOf(target)]}' ${path}`;
+};
+var guardBinary = (path, platform) => guardHookCommand({ kind: "binary", path, runtime: "node" }, platform);
+var guardCursorGate = (script, platform) => guardHookCommand({ kind: "cursor_gate", script }, platform);
+var guardedArgv = (target, args = [], platform = process.platform) => {
+  const path = targetPath(target);
+  if (platform === "win32") {
+    return runsThroughNode(target) ? ["node", path, ...args] : [path, ...args];
+  }
+  const [shell, ...shellArgs] = HOOK_SHELL.split(/\s+/);
+  return [shell, ...shellArgs, HOOK_GUARD_SCRIPTS[guardKindOf(target)], path, ...args];
+};
+
+// src/codex-config.ts
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/registration-holder.ts
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var registeredCommands = (document) => {
+  const hooks = asRecord(document?.hooks);
+  if (!hooks) return [];
+  const found = [];
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) continue;
+    for (const item of value) {
+      const inner = asRecord(item)?.hooks;
+      if (!Array.isArray(inner)) continue;
+      for (const hook of inner) {
+        const command = asRecord(hook)?.command;
+        if (typeof command === "string") found.push({ event, command });
+      }
+    }
+  }
+  return found;
+};
+var wholeSegments = (command) => command.split(/[\s/\\"']+/).map((segment) => segment.replace(/\.(cmd|exe)$/i, ""));
+var namesLocator = (command) => wholeSegments(command).includes(HOOK_LOCATOR_BINARY);
+var namesCliBinary = (command, cliBinaries) => wholeSegments(command).some((segment) => cliBinaries.has(segment));
+var namesOurBinary = (command, cliBinaries) => namesLocator(command) || namesCliBinary(command, cliBinaries);
+var registrationHolderOf = (document, cliBinaries) => {
+  const commands = registeredCommands(document);
+  if (commands.some(({ command }) => namesLocator(command))) return "app";
+  return commands.some(({ command }) => namesCliBinary(command, cliBinaries)) ? "cli" : "none";
+};
+
+// src/hook-entries.ts
+var registerHookEntry = (existing, isOurs, entry) => {
+  const rewritten = [];
+  let placed = false;
+  for (const item of existing) {
+    if (!isOurs(item)) {
+      rewritten.push(item);
+      continue;
+    }
+    if (placed) continue;
+    rewritten.push(entry);
+    placed = true;
+  }
+  if (!placed) rewritten.push(entry);
+  return rewritten;
+};
+
+// src/removal-scope.ts
+var namesAppLocator = (command) => command.includes(HOOK_LOCATOR_BINARY);
+var isProtectedByScope = (command, scope) => scope?.keepAppWiring === true && namesAppLocator(command);
+
+// src/canonical-json.ts
+var canonicalJson = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
+  const record = value;
+  return "{" + Object.keys(record).sort().map((key) => JSON.stringify(key) + ":" + canonicalJson(record[key])).join(",") + "}";
+};
+
+// src/codex-config.ts
+var CODEX_HOOK_BINARY = "pushary-codex-hook";
+var codexHome = () => codexHomeFrom(homedir());
+var codexHomeFrom = (home) => process.env.CODEX_HOME?.trim() || join2(home, ".codex");
+var codexConfigToml = () => join2(codexHome(), "config.toml");
+var codexHooksJsonIn = (home) => join2(home, "hooks.json");
+var codexHooksJson = () => codexHooksJsonIn(codexHome());
+var codexAgentsMd = () => join2(codexHome(), "AGENTS.md");
+var codexSkillDir = () => join2(codexHome(), "skills", "pushary");
+var CODEX_HOOK_EVENTS = [
+  { event: "PermissionRequest", delivery: "approval", timeout: HOOK_BUDGETS.codex.budgetSeconds, statusMessage: "Waiting for your phone" },
+  { event: "PreToolUse", matcher: "Bash|apply_patch|mcp__.*", delivery: "approval", timeout: HOOK_BUDGETS.codex.budgetSeconds, statusMessage: "Checking Pushary policy" },
+  { event: "PostToolUse", matcher: "Bash|apply_patch|mcp__.*", delivery: "telemetry", timeout: 10 },
+  { event: "UserPromptSubmit", delivery: "telemetry", timeout: 10 },
+  { event: "Stop", delivery: "rescue", timeout: HOOK_BUDGETS.codex.budgetSeconds, holds: true },
+  // `clear` alongside startup and resume, matching what we already do on Claude
+  // Code. Codex names all three in its own SessionStart sources, and without it a
+  // session the person started by clearing is one we never see begin.
+  { event: "SessionStart", matcher: "startup|resume|clear", delivery: "telemetry", timeout: 10 },
+  // Codex caps SessionEnd at 3s and defaults it to 1s, unlike every other event
+  // here. It also runs synchronously whatever `async` says, so the handler must
+  // fit the window rather than assume the 10s Claude Code allows.
+  { event: "SessionEnd", delivery: "telemetry", timeout: 3 },
+  // Observability only, and the four Codex names we were not registering at all.
+  // Every one is in codex-cli 0.151.0's own `HookEventName` enum
+  // (subagent_start, subagent_stop, pre_compact, post_compact), and we already
+  // carry all four on Claude Code, so the island showed subagent and compaction
+  // shape for one agent and not the other. None of them decides anything.
+  { event: "SubagentStart", delivery: "telemetry", timeout: 5 },
+  { event: "SubagentStop", delivery: "telemetry", timeout: 5 },
+  { event: "PreCompact", matcher: "manual|auto", delivery: "telemetry", timeout: 5 },
+  { event: "PostCompact", matcher: "manual|auto", delivery: "telemetry", timeout: 5 }
+];
+var CODEX_EVENT_KEY = {
+  PermissionRequest: "permission_request",
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  UserPromptSubmit: "user_prompt_submit",
+  Stop: "stop",
+  SessionStart: "session_start",
+  SessionEnd: "session_end",
+  SubagentStart: "subagent_start",
+  SubagentStop: "subagent_stop",
+  PreCompact: "pre_compact",
+  PostCompact: "post_compact"
+};
+var codexEventKeyOf = (event) => event.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+var asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord2(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var CODEX_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var addCodexMcpServer = (config, apiKey) => {
+  const servers = ensureRecord(config, "mcp_servers");
+  const pushary = ensureRecord(servers, "pushary");
+  pushary.url = CODEX_MCP_URL;
+  ensureRecord(pushary, "http_headers").Authorization = `Bearer ${apiKey}`;
+  pushary.default_tools_approval_mode = "approve";
+  delete pushary.bearer_token_env_var;
+  delete pushary.tools;
+};
+var readCodexMcpAuth = (config) => {
+  const pushary = asRecord2(asRecord2(config.mcp_servers)?.pushary);
+  if (!pushary) return void 0;
+  const authorization = asRecord2(pushary.http_headers)?.Authorization;
+  if (typeof authorization === "string" && authorization.startsWith("Bearer ")) {
+    return { method: "embedded", key: authorization.slice("Bearer ".length).trim() };
+  }
+  if (typeof pushary.bearer_token_env_var === "string") {
+    return { method: "env", envVar: pushary.bearer_token_env_var };
+  }
+  if (typeof pushary.bearer_token === "string") return { method: "legacy-bearer" };
+  return void 0;
+};
+var isPusharyCodexCommand = (command) => command.includes(CODEX_HOOK_BINARY) || command.includes(HOOK_LOCATOR_BINARY);
+var isPusharyCommand = (hook, scope) => {
+  const command = String(asRecord2(hook)?.command ?? "");
+  if (isProtectedByScope(command, scope)) return false;
+  return isPusharyCodexCommand(command);
+};
+var isPusharyCodexHook = (entry, scope) => {
+  const hooks = asRecord2(entry)?.hooks;
+  return Array.isArray(hooks) && hooks.some((hook) => isPusharyCommand(hook, scope));
+};
+var CODEX_CLI_BINARIES = /* @__PURE__ */ new Set([CODEX_HOOK_BINARY]);
+var codexRegistrationHolder = (hooksConfig) => registrationHolderOf(hooksConfig, CODEX_CLI_BINARIES);
+var addCodexHooks = (config, command) => {
+  const hooks = ensureRecord(config, "hooks");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[definition.event]) ? hooks[definition.event] : [];
+    hooks[definition.event] = registerHookEntry(existing, isPusharyCodexHook, {
+      ...definition.matcher ? { matcher: definition.matcher } : {},
+      hooks: [{
+        type: "command",
+        command: withHookHoldBudget(command, holdBudgetOf(definition)),
+        timeout: definition.timeout,
+        ...definition.statusMessage ? { statusMessage: definition.statusMessage } : {}
+      }]
+    });
+  }
+};
+var removeCodexHooks = (config, scope) => {
+  const hooks = asRecord2(config.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry) => !isPusharyCodexHook(entry, scope));
+    if (filtered.length !== entries.length) {
+      if (filtered.length === 0) {
+        delete hooks[definition.event];
+      } else {
+        hooks[definition.event] = filtered;
+      }
+      changed = true;
+    }
+  }
+  if (Object.keys(hooks).length === 0) delete config.hooks;
+  return changed;
+};
+var hasCodexHooks = (config) => {
+  const hooks = asRecord2(config.hooks);
+  if (!hooks) return false;
+  return CODEX_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some((entry) => isPusharyCodexHook(entry));
+  });
+};
+var missingCodexHookEvents = (config) => {
+  const hooks = asRecord2(config.hooks);
+  return CODEX_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some((entry) => isPusharyCodexHook(entry));
+  }).map((definition) => definition.event);
+};
+var codexHookTrustHash = (definition, command) => {
+  const hook = { command: withHookHoldBudget(command, holdBudgetOf(definition)), timeout: definition.timeout, type: "command" };
+  if (definition.statusMessage) hook.statusMessage = definition.statusMessage;
+  const entry = { hooks: [hook] };
+  if (definition.matcher) entry.matcher = definition.matcher;
+  return codexEntryTrustHash(CODEX_EVENT_KEY[definition.event], entry);
+};
+var codexEntryTrustHash = (eventKey, entry) => {
+  const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+  const identity = {
+    event_name: eventKey,
+    hooks: hooks.map((hook) => ({ async: false, ...asRecord2(hook) }))
+  };
+  if (typeof entry.matcher === "string") identity.matcher = entry.matcher;
+  return "sha256:" + createHash("sha256").update(canonicalJson(identity), "utf8").digest("hex");
+};
+var codexHookPositions = (hooksConfig) => {
+  const hooks = asRecord2(hooksConfig?.hooks);
+  const positions = {};
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks?.[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const entryIndex = entries.findIndex((entry) => isPusharyCodexHook(entry));
+    if (entryIndex < 0) continue;
+    const inner = asRecord2(entries[entryIndex])?.hooks;
+    const hookIndex = Array.isArray(inner) ? inner.findIndex((hook) => isPusharyCommand(hook)) : -1;
+    positions[definition.event] = [entryIndex, Math.max(hookIndex, 0)];
+  }
+  return positions;
+};
+var codexHookStateKey = (hooksJsonPath, event, position) => `${hooksJsonPath}:${CODEX_EVENT_KEY[event]}:${position[0]}:${position[1]}`;
+var codexVacatedIndexes = (hooksConfig) => {
+  const hooks = asRecord2(hooksConfig?.hooks);
+  const vacated = {};
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks?.[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const ours = entries.flatMap((entry, index) => isPusharyCodexHook(entry) ? [index] : []);
+    if (ours.length > 1) vacated[definition.event] = ours[1];
+  }
+  return vacated;
+};
+var dropVacatedCodexHookTrust = (config, hooksJsonPath, vacated) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  if (!state) return false;
+  let changed = false;
+  for (const [event, from] of Object.entries(vacated)) {
+    const prefix = `${hooksJsonPath}:${CODEX_EVENT_KEY[event] ?? codexEventKeyOf(event)}:`;
+    for (const key of Object.keys(state)) {
+      if (!key.startsWith(prefix)) continue;
+      const entryIndex = Number(key.slice(prefix.length).split(":")[0]);
+      if (!Number.isInteger(entryIndex) || entryIndex < from) continue;
+      delete state[key];
+      changed = true;
+    }
+  }
+  return changed;
+};
+var captureCodexHookTrust = (config, hooksJsonPath, positions) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  if (!state) return {};
+  const snapshot = {};
+  for (const [event, position] of Object.entries(positions)) {
+    const value = state[codexHookStateKey(hooksJsonPath, event, position)];
+    if (value !== void 0) snapshot[event] = structuredClone(value);
+  }
+  return snapshot;
+};
+var restoreCodexHookTrust = (config, hooksJsonPath, positions, snapshot) => {
+  const restorable = Object.entries(snapshot).filter(([event]) => positions[event] !== void 0);
+  if (restorable.length === 0) return false;
+  const state = ensureRecord(ensureRecord(config, "hooks"), "state");
+  for (const [event, value] of restorable) {
+    state[codexHookStateKey(hooksJsonPath, event, positions[event])] = structuredClone(value);
+  }
+  return true;
+};
+var codexTrustGaps = (config, hooksConfig, hooksJsonPath, command, positions) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  const hooks = asRecord2(hooksConfig?.hooks);
+  const gaps = [];
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const position = positions[definition.event];
+    if (!position) continue;
+    const stored = asRecord2(state?.[codexHookStateKey(hooksJsonPath, definition.event, position)])?.trusted_hash;
+    const eventKey = CODEX_EVENT_KEY[definition.event] ?? definition.event;
+    const onDisk = asRecord2(
+      asRecord2(hooks?.[definition.event]) ?? (Array.isArray(hooks?.[definition.event]) ? hooks[definition.event][position[0]] : void 0)
+    );
+    const diskHash = onDisk ? codexEntryTrustHash(eventKey, onDisk) : void 0;
+    if (stored !== void 0 && diskHash !== void 0 && stored === diskHash) {
+      if (diskHash !== codexHookTrustHash(definition, command)) {
+        gaps.push({ event: definition.event, kind: "stale" });
+      }
+      continue;
+    }
+    if (stored !== (diskHash ?? codexHookTrustHash(definition, command))) {
+      gaps.push({ event: definition.event, kind: "untrusted" });
+    }
+  }
+  return gaps;
+};
+var removeCodexMcpServer = (config) => {
+  const servers = asRecord2(config.mcp_servers);
+  if (!servers?.pushary) return false;
+  delete servers.pushary;
+  if (Object.keys(servers).length === 0) delete config.mcp_servers;
+  return true;
+};
+var removeCodexHookTrust = (config, hooksJsonPath, positions) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  if (!state) return false;
+  let changed = false;
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const position = positions[definition.event];
+    if (!position) continue;
+    const key = codexHookStateKey(hooksJsonPath, definition.event, position);
+    if (key in state) {
+      delete state[key];
+      changed = true;
+    }
+  }
+  if (changed && Object.keys(state).length === 0) {
+    const hooks = asRecord2(config.hooks);
+    if (hooks) {
+      delete hooks.state;
+      if (Object.keys(hooks).length === 0) delete config.hooks;
+    }
+  }
+  return changed;
+};
+var removeCodexSettings = (config, hooksJsonPath, positions) => {
+  const mcp = removeCodexMcpServer(config);
+  const trust = removeCodexHookTrust(config, hooksJsonPath, positions);
+  return mcp || trust;
+};
+var addCodexHookTrust = (config, hooksJsonPath, command, positions) => {
+  const hooks = ensureRecord(config, "hooks");
+  const state = ensureRecord(hooks, "state");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const position = positions[definition.event];
+    if (!position) continue;
+    const key = codexHookStateKey(hooksJsonPath, definition.event, position);
+    const ours = codexHookTrustHash(definition, command);
+    const existing = asRecord2(state[key]) ?? {};
+    state[key] = { ...existing, trusted_hash: ours };
+    for (const stale of staleTrustKeys(state, hooksJsonPath, definition.event, key, ours)) {
+      delete state[stale];
+    }
+  }
+};
+var staleTrustKeys = (state, hooksJsonPath, event, currentKey, ourHash) => {
+  const prefix = `${hooksJsonPath}:${CODEX_EVENT_KEY[event]}:`;
+  return Object.keys(state).filter(
+    (key) => key !== currentKey && key.startsWith(prefix) && asRecord2(state[key])?.trusted_hash === ourHash
+  );
+};
+
+// src/setup/paths.ts
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var claudeSettings = () => join3(homedir2(), ".claude", "settings.json");
+var claudeJson = () => join3(homedir2(), ".claude.json");
+var claudeSkillDir = () => join3(homedir2(), ".claude", "skills", "pushary");
+var cursorPluginDir = () => join3(homedir2(), ".cursor", "plugins", "local", "pushary");
+var cursorUserHooks = () => join3(homedir2(), ".cursor", "hooks.json");
+var cursorUserMcp = () => join3(homedir2(), ".cursor", "mcp.json");
+var vscodePluginDir = () => join3(homedir2(), ".pushary", "plugins", "vscode");
+var vscodePluginMcp = () => join3(vscodePluginDir(), ".mcp.json");
+var claudeSettingsLocal = () => join3(homedir2(), ".claude", "settings.local.json");
+var pusharyDir = () => join3(homedir2(), ".pushary");
+var claudeMcpReceipt = () => join3(pusharyDir(), "setup", "claude-mcp.json");
+var bridgeAgentKey = () => join3(pusharyDir(), "bridge-auth", "agent-key.json");
+var autoUpdateState = () => join3(pusharyDir(), "auto-update.json");
+var autoUpdateLock = () => join3(pusharyDir(), "auto-update.lock");
+var autoUpdateLog = () => join3(pusharyDir(), "logs", "auto-update.log");
+var clientReportClaims = () => join3(pusharyDir(), "client-reports");
+var claudeRegistrationReceipt = () => join3(pusharyDir(), "setup", "claude-registration.json");
+var hermesConfig = () => join3(homedir2(), ".hermes", "config.yaml");
+var hermesConfigReceipt = () => join3(pusharyDir(), "setup", "hermes-config.json");
+var fxQuestionRuleReceipt = () => join3(pusharyDir(), "setup", "fx-question-rule.json");
+var hookTakeoverReceipt = (agent) => join3(pusharyDir(), "setup", `hook-takeover-${agent}.json`);
+var codexSkillDir2 = () => join3(codexHome(), "skills", "pushary");
+var codexAgentsMd2 = () => join3(codexHome(), "AGENTS.md");
+var geminiSettings = () => join3(homedir2(), ".gemini", "settings.json");
+var geminiMd = () => join3(homedir2(), ".gemini", "GEMINI.md");
+var pusharyConfigFile = () => join3(homedir2(), ".pushary", "config.json");
+var fxConfigDir = () => join3(homedir2(), ".fx");
+var fxMcpProfile = () => join3(fxConfigDir(), "mcp.json");
+var fxSettings = () => join3(fxConfigDir(), "settings.json");
+var fxAgentsMd = () => join3(fxConfigDir(), "AGENTS.md");
+
+export {
+  registeredCommands,
+  namesOurBinary,
+  registrationHolderOf,
+  LATEST_TAG,
+  cleanNpmEnv,
+  npmErrorMessage,
+  execNpm,
+  readGlobalPrefix,
+  resolveGlobalBinary,
+  resolvePathBinary,
+  npmIsOnPath,
+  globalPackageState,
+  NpmMissingError,
+  resolveBinary,
+  resolvePackageVersionFromBinary,
+  resolveGlobalPackageVersion,
+  readGlobalFolder,
+  readGlobalCliInstallAt,
+  readGlobalCliInstall,
+  resolveGlobalBinDir,
+  fetchLatestPublishedVersion,
+  installPackageGlobally,
+  plannedGlobalPackage,
+  installGlobally,
+  holdBudgetOf,
+  guardBinary,
+  guardCursorGate,
+  guardedArgv,
+  registerHookEntry,
+  isProtectedByScope,
+  canonicalJson,
+  CODEX_HOOK_BINARY,
+  codexHome,
+  codexHomeFrom,
+  codexConfigToml,
+  codexHooksJsonIn,
+  codexHooksJson,
+  codexAgentsMd,
+  codexSkillDir,
+  CODEX_HOOK_EVENTS,
+  addCodexMcpServer,
+  readCodexMcpAuth,
+  isPusharyCodexCommand,
+  codexRegistrationHolder,
+  addCodexHooks,
+  removeCodexHooks,
+  hasCodexHooks,
+  missingCodexHookEvents,
+  codexHookPositions,
+  codexVacatedIndexes,
+  dropVacatedCodexHookTrust,
+  captureCodexHookTrust,
+  restoreCodexHookTrust,
+  codexTrustGaps,
+  removeCodexHookTrust,
+  removeCodexSettings,
+  addCodexHookTrust,
+  claudeSettings,
+  claudeJson,
+  claudeSkillDir,
+  cursorPluginDir,
+  cursorUserHooks,
+  cursorUserMcp,
+  vscodePluginDir,
+  vscodePluginMcp,
+  claudeSettingsLocal,
+  pusharyDir,
+  claudeMcpReceipt,
+  bridgeAgentKey,
+  autoUpdateState,
+  autoUpdateLock,
+  autoUpdateLog,
+  clientReportClaims,
+  claudeRegistrationReceipt,
+  hermesConfig,
+  hermesConfigReceipt,
+  fxQuestionRuleReceipt,
+  hookTakeoverReceipt,
+  codexSkillDir2,
+  codexAgentsMd2,
+  geminiSettings,
+  geminiMd,
+  pusharyConfigFile,
+  fxConfigDir,
+  fxMcpProfile,
+  fxSettings,
+  fxAgentsMd
+};