@pushary/agent-hooks 0.90.1 → 0.90.2

package/dist/bin/pushary-upgrade.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   reapplyAllAgents
-} from "../chunk-BQBEH6TV.js";
-import "../chunk-H2QZRQR2.js";
+} from "../chunk-VAMBUKXH.js";
+import "../chunk-YTDH3XCE.js";
 import {
   waitForMachineReadiness
-} from "../chunk-7TPQEWUZ.js";
-import "../chunk-DZDI62LY.js";
-import "../chunk-GL3FFM7A.js";
+} from "../chunk-YTD6PJM7.js";
+import "../chunk-WGKC6PU2.js";
+import "../chunk-ELHCIEMM.js";
 import "../chunk-2LAHXHBR.js";
 import "../chunk-EZIEXHYM.js";
 import {
@@ -20,7 +20,7 @@ import {
   replaceDaemonService,
   stopDaemonService,
   waitForDaemonRemoteProof
-} from "../chunk-F2ICEWZL.js";
+} from "../chunk-Z4XCN2HH.js";
 import {
   detectProviderLiveCapabilities,
   hasSpawnProvider,
@@ -34,14 +34,14 @@ import {
   npmErrorMessage,
   resolveGlobalBinary
 } from "../chunk-L4ZCFMWW.js";
-import "../chunk-54ELC7D7.js";
+import "../chunk-AWHCZOZO.js";
 import {
   claudeJson,
   codexConfigToml,
   cursorPluginDir,
   geminiSettings,
   vscodePluginDir
-} from "../chunk-KUZWXPUS.js";
+} from "../chunk-BVNYTQ5I.js";
 import {
   exitOnHelpFlag
 } from "../chunk-BVBEURWJ.js";

package/dist/bin/pushary-wait.js

@@ -4,8 +4,8 @@ import {
 } from "../chunk-IIENZE2J.js";
 import {
   exitOnFailedResponse
-} from "../chunk-DYP6SMOR.js";
-import "../chunk-AJYV3VGU.js";
+} from "../chunk-Z6RFZKY4.js";
+import "../chunk-BXTJVM7O.js";
 import {
   createIo
 } from "../chunk-5RUIFDTP.js";

package/dist/{chunk-B6H2KAQC.js → chunk-4IEW4ZRF.js}

@@ -21,7 +21,7 @@ import {
   repoKeyFor,
   settleQuestionsForToolUse,
   throttlePass
-} from "./chunk-4LOPSGLP.js";
+} from "./chunk-TVZQMPB7.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -41,7 +41,7 @@ import {
 } from "./chunk-L4E2BIJ2.js";
 import {
   getMachineId
-} from "./chunk-54ELC7D7.js";
+} from "./chunk-AWHCZOZO.js";
 import {
   getApiKey,
   getBaseUrl

package/dist/chunk-ATUUQFDH.js

@@ -0,0 +1,536 @@
+import {
+  isBridgeLocator
+} from "./chunk-CRVJCKIN.js";
+import {
+  pusharyHookExecutable
+} from "./chunk-WGKC6PU2.js";
+import {
+  BELL_HOOK_BINARY
+} from "./chunk-DSTLA2TC.js";
+import {
+  resolvePathBinary
+} from "./chunk-L4ZCFMWW.js";
+import {
+  parseFlags
+} from "./chunk-GMXKITVA.js";
+import {
+  UsageError
+} from "./chunk-7QLSKOSU.js";
+import {
+  isValidApiKey
+} from "./chunk-VNMKIJZB.js";
+
+// src/hermes-config.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var isSnapshot = (value) => isRecord(value) && typeof value.present === "boolean" && Object.hasOwn(value, "value");
+var isHermesConfigReceipt = (value) => {
+  if (!isRecord(value)) return false;
+  return ["security", "approval", "transport", "fallback", "plugins", "enabled", "agent", "disabled"].every((key) => isSnapshot(value[key])) && typeof value.pushary_enabled === "boolean" && typeof value.clarify_disabled === "boolean";
+};
+var HERMES_CONFIG_SCRIPT = String.raw`
+import json, os, sys
+from hermes_cli.config import load_config, save_config
+
+mode, receipt_path = sys.argv[1], sys.argv[2]
+c = load_config()
+
+def snap(obj, key):
+    return {"present": key in obj, "value": obj.get(key)}
+
+restore_conflicts = []
+
+def restore(obj, key, before, ours):
+    if before.get("present") and before.get("value") == ours:
+        return
+    if before.get("present"):
+        if key in obj and obj.get(key) == before.get("value"):
+            return
+    elif key not in obj:
+        return
+    if obj.get(key) != ours:
+        restore_conflicts.append(key)
+        return
+    if before.get("present"):
+        obj[key] = before.get("value")
+    else:
+        obj.pop(key, None)
+
+def restore_container(obj, key, before, current, changed):
+    raw = obj.get(key)
+    if isinstance(before.get("value"), dict):
+        if not isinstance(raw, dict):
+            if changed:
+                restore_conflicts.append(key)
+            return
+        if current or before.get("present"):
+            obj[key] = current
+        else:
+            obj.pop(key, None)
+    elif isinstance(raw, dict) and current:
+        restore_conflicts.append(key)
+    else:
+        restore(obj, key, before, {})
+
+def restore_list_member(obj, key, before, ours, ours_before):
+    raw = obj.get(key)
+    if isinstance(before.get("value"), list):
+        if ours_before:
+            return
+        if not isinstance(raw, list):
+            restore_conflicts.append(key)
+            return
+        remaining = [item for item in raw if item != ours]
+        if remaining or before.get("present"):
+            obj[key] = remaining
+        else:
+            obj.pop(key, None)
+        return
+    if before.get("present") and raw == before.get("value"):
+        return
+    if not before.get("present") and key not in obj:
+        return
+    if not isinstance(raw, list):
+        restore_conflicts.append(key)
+        return
+    remaining = [item for item in raw if item != ours]
+    if remaining:
+        restore_conflicts.append(key)
+    else:
+        restore(obj, key, before, raw)
+
+def valid_snapshot(value):
+    return isinstance(value, dict) and isinstance(value.get("present"), bool) and "value" in value
+
+def valid_receipt(value):
+    snapshots = ["security", "approval", "transport", "fallback", "plugins", "enabled", "agent", "disabled"]
+    return (isinstance(value, dict)
+        and all(valid_snapshot(value.get(key)) for key in snapshots)
+        and isinstance(value.get("pushary_enabled"), bool)
+        and isinstance(value.get("clarify_disabled"), bool))
+
+if mode == "setup":
+    security_before = snap(c, "security")
+    s = c.get("security") if isinstance(c.get("security"), dict) else {}
+    approval_before = snap(s, "approval")
+    ap = s.get("approval") if isinstance(s.get("approval"), dict) else {}
+    plugins_before = snap(c, "plugins")
+    p = c.get("plugins") if isinstance(c.get("plugins"), dict) else {}
+    agent_before = snap(c, "agent")
+    a = c.get("agent") if isinstance(c.get("agent"), dict) else {}
+    enabled = p.get("enabled") if isinstance(p.get("enabled"), list) else []
+    disabled = a.get("disabled_toolsets") if isinstance(a.get("disabled_toolsets"), list) else []
+    receipt = {
+        "security": security_before,
+        "approval": approval_before,
+        "transport": snap(ap, "transport"),
+        "fallback": snap(ap, "transport_fallback"),
+        "plugins": plugins_before,
+        "enabled": snap(p, "enabled"),
+        "pushary_enabled": "pushary" in enabled,
+        "agent": agent_before,
+        "disabled": snap(a, "disabled_toolsets"),
+        "clarify_disabled": "clarify" in disabled,
+    }
+    if os.path.exists(receipt_path):
+        with open(receipt_path, encoding="utf-8") as handle:
+            existing_receipt = json.load(handle)
+        if not valid_receipt(existing_receipt):
+            raise ValueError("invalid Pushary Hermes setup receipt")
+    else:
+        os.makedirs(os.path.dirname(receipt_path), exist_ok=True)
+        temp = receipt_path + ".tmp"
+        with open(temp, "x", encoding="utf-8") as handle:
+            json.dump(receipt, handle)
+        os.chmod(temp, 0o600)
+        os.replace(temp, receipt_path)
+    ap["transport"] = "pushary"
+    ap["transport_fallback"] = "builtin"
+    s["approval"] = ap
+    c["security"] = s
+    p["enabled"] = enabled if "pushary" in enabled else enabled + ["pushary"]
+    c["plugins"] = p
+    a["disabled_toolsets"] = disabled if "clarify" in disabled else disabled + ["clarify"]
+    c["agent"] = a
+else:
+    receipt_exists = os.path.exists(receipt_path)
+    try:
+        with open(receipt_path, encoding="utf-8") as handle:
+            receipt = json.load(handle)
+    except (OSError, ValueError):
+        if receipt_exists:
+            raise
+        receipt = None
+    s = c.get("security") if isinstance(c.get("security"), dict) else {}
+    ap = s.get("approval") if isinstance(s.get("approval"), dict) else {}
+    if receipt:
+        if not valid_receipt(receipt):
+            raise ValueError("invalid Pushary Hermes setup receipt")
+        approval_changed = (not receipt["transport"].get("present")
+            or receipt["transport"].get("value") != "pushary"
+            or not receipt["fallback"].get("present")
+            or receipt["fallback"].get("value") != "builtin")
+        plugins_changed = not (isinstance(receipt["enabled"].get("value"), list)
+            and receipt["pushary_enabled"])
+        agent_changed = not (isinstance(receipt["disabled"].get("value"), list)
+            and receipt["clarify_disabled"])
+        restore(ap, "transport", receipt["transport"], "pushary")
+        restore(ap, "transport_fallback", receipt["fallback"], "builtin")
+    else:
+        if ap.get("transport") == "pushary": ap.pop("transport", None)
+        if ap.get("transport_fallback") == "builtin": ap.pop("transport_fallback", None)
+    if receipt:
+        restore_container(s, "approval", receipt["approval"], ap, approval_changed)
+        restore_container(c, "security", receipt["security"], s, approval_changed)
+    else:
+        if ap: s["approval"] = ap
+        else: s.pop("approval", None)
+        if s: c["security"] = s
+        else: c.pop("security", None)
+
+    p = c.get("plugins") if isinstance(c.get("plugins"), dict) else {}
+    if receipt:
+        restore_list_member(p, "enabled", receipt["enabled"], "pushary", receipt["pushary_enabled"])
+        restore_container(c, "plugins", receipt["plugins"], p, plugins_changed)
+    else:
+        enabled = p.get("enabled") if isinstance(p.get("enabled"), list) else []
+        enabled = [item for item in enabled if item != "pushary"]
+        if enabled: p["enabled"] = enabled
+        else: p.pop("enabled", None)
+        if p: c["plugins"] = p
+        else: c.pop("plugins", None)
+
+    a = c.get("agent") if isinstance(c.get("agent"), dict) else {}
+    if receipt:
+        restore_list_member(a, "disabled_toolsets", receipt["disabled"], "clarify", receipt["clarify_disabled"])
+        restore_container(c, "agent", receipt["agent"], a, agent_changed)
+    else:
+        disabled = a.get("disabled_toolsets") if isinstance(a.get("disabled_toolsets"), list) else []
+        disabled = [item for item in disabled if item != "clarify"]
+        if disabled: a["disabled_toolsets"] = disabled
+        else: a.pop("disabled_toolsets", None)
+        if a: c["agent"] = a
+        else: c.pop("agent", None)
+
+    if receipt and restore_conflicts:
+        raise ValueError("Hermes config changed after Pushary setup")
+
+save_config(c)
+`;
+var resolveHermesPython = () => {
+  const launcher = resolvePathBinary("hermes");
+  if (launcher && process.platform !== "win32") {
+    try {
+      const shebang = readFileSync(launcher, "utf-8").split("\n", 1)[0];
+      const interpreter = shebang?.startsWith("#!") ? shebang.slice(2).trim().split(/\s+/)[0] : void 0;
+      if (interpreter && /python/i.test(interpreter) && existsSync(interpreter)) return interpreter;
+    } catch {
+    }
+  }
+  const root = join(homedir(), ".hermes", "hermes-agent", "venv");
+  const candidates = process.platform === "win32" ? [join(root, "Scripts", "python.exe"), join(root, "Scripts", "python3.exe")] : [join(root, "bin", "python3"), join(root, "bin", "python")];
+  return candidates.find(existsSync) ?? null;
+};
+var runHermesPythonScript = (python, script, ...args) => {
+  const path = join(tmpdir(), `pushary-hermes-${process.pid}-${Date.now()}.py`);
+  try {
+    writeFileSync(path, script, { encoding: "utf-8", mode: 384 });
+    execFileSync(python, [path, ...args], { env: { ...process.env }, stdio: "pipe", timeout: 15e3 });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      rmSync(path, { force: true });
+    } catch {
+    }
+  }
+};
+
+// src/cli/dry-run.ts
+import { execSync } from "child_process";
+import { rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+var createGuards = (isDryRun, note) => ({
+  write: (path, contents) => {
+    if (isDryRun()) return note("rewrite", path);
+    writeFileSync2(path, contents, "utf-8");
+  },
+  remove: (path, options = {}) => {
+    if (isDryRun()) return note("remove ", path);
+    rmSync2(path, { recursive: true, force: options.force ?? false });
+  },
+  exec: (command, options, describe) => {
+    if (isDryRun()) return note("run    ", describe);
+    execSync(command, options);
+  }
+});
+var describeService = (effects) => {
+  if (effects.controlMode === "off") return "skip     the phone-start background service (--control off)";
+  const where = effects.serviceDefinitionPath ?? "the phone-start service definition";
+  const condition = effects.controlMode === "on" ? "" : ", when a supported agent and a service manager are present";
+  return `write    ${where} and register it with the OS${condition}`;
+};
+var describeSetupSideEffects = (effects) => [
+  `run      npm install -g @pushary/agent-hooks@${effects.version} (the hooks run from the global copy; up to two minutes)`,
+  `write    ${effects.configFile} (the API key, mode 600)`,
+  effects.rcPath ? `edit     ${effects.rcPath} (export PUSHARY_API_KEY)` : "print    the export line for your shell, since no rc file was found",
+  describeService(effects),
+  "ask      Add Pushary instructions to this project's CLAUDE.md/AGENTS.md? (default no)",
+  "ask      Alias claude to pushary claude? (default no)"
+];
+
+// src/setup/options.ts
+var AGENT_CHOICES = ["claude_code", "codex", "gemini_cli", "hermes", "cursor", "vscode", "opencode", "custom"];
+var CONNECT_MODES = ["app", "browser", "web", "none"];
+var CONNECT_ALIASES = { auto: "app", pwa: "web" };
+var parseConnectMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (Object.hasOwn(CONNECT_ALIASES, value)) return CONNECT_ALIASES[value];
+  if (CONNECT_MODES.includes(value)) return value;
+  throw new UsageError(`--connect must be one of: ${CONNECT_MODES.join(", ")} (got ${raw})`);
+};
+var VERIFY_MODES = ["roundtrip", "push", "none"];
+var parseVerifyMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (VERIFY_MODES.includes(value)) return value;
+  throw new UsageError(`--verify must be one of: ${VERIFY_MODES.join(", ")} (got ${raw})`);
+};
+var CONTROL_MODES = ["auto", "on", "off"];
+var parseControlMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (CONTROL_MODES.includes(value)) return value;
+  throw new UsageError(`--control must be one of: ${CONTROL_MODES.join(", ")} (got ${raw})`);
+};
+var effectiveVerify = (options, context) => {
+  if (options.verifyExplicit) return options.verify;
+  if (options.verify === "roundtrip") return "roundtrip";
+  return context.paired ? "roundtrip" : options.verify;
+};
+var SETUP_FLAGS = {
+  bools: ["key-stdin", "skip-phone", "yes", "y", "json", "dry-run", "take-over-hooks", "help", "h"],
+  values: ["key", "connect", "agents", "verify", "control", "transcripts"]
+};
+var effectiveControlMode = (options, stored, configPresent) => options.controlExplicit ? options.control : stored ?? (configPresent ? null : options.control);
+var isAgentChoice = (value) => AGENT_CHOICES.includes(value);
+var parseAgentSelection = (raw, yes) => {
+  if (raw === void 0) {
+    return yes ? { kind: "auto" } : { kind: "ask" };
+  }
+  const value = raw.trim().toLowerCase();
+  if (value === "auto") return { kind: "auto" };
+  if (value === "none") return { kind: "none" };
+  const parts = value.split(",").map((part) => part.trim()).filter((part) => part !== "");
+  if (parts.length === 0) throw new UsageError("--agents needs a value");
+  const unknown = parts.filter((part) => !isAgentChoice(part));
+  if (unknown.length > 0) {
+    throw new UsageError(
+      `--agents does not know: ${unknown.join(", ")}. Use auto, none, or any of: ${AGENT_CHOICES.join(", ")}`
+    );
+  }
+  return { kind: "explicit", agents: [...new Set(parts)] };
+};
+var parseSetupOptions = (input) => {
+  const flags = parseFlags(input.argv, SETUP_FLAGS);
+  const stray = [
+    ...flags.command !== void 0 && flags.command !== "setup" ? [flags.command] : [],
+    ...flags.rest
+  ];
+  if (stray.length > 0) {
+    throw new UsageError(
+      `setup takes no positional arguments (got ${stray.join(", ")}). Did you mean --agents ${stray[0]}?`
+    );
+  }
+  const yes = flags.bools.has("yes") || flags.bools.has("y");
+  const help = flags.bools.has("help") || flags.bools.has("h");
+  const agentsFlag = flags.values.get("agents");
+  const agents = parseAgentSelection(agentsFlag, yes);
+  const connectRaw = flags.values.get("connect");
+  const connectMode = connectRaw === void 0 ? "app" : parseConnectMode(connectRaw);
+  const verifyRaw = flags.values.get("verify");
+  const controlRaw = flags.values.get("control");
+  const transcriptsRaw = flags.values.get("transcripts")?.trim().toLowerCase();
+  if (transcriptsRaw !== void 0 && transcriptsRaw !== "on" && transcriptsRaw !== "off") {
+    throw new UsageError(`--transcripts must be one of: on, off (got ${transcriptsRaw})`);
+  }
+  const nonInteractive = yes || agentsFlag !== void 0 || flags.bools.has("json") || !input.stdinIsTty;
+  const verify = verifyRaw !== void 0 ? parseVerifyMode(verifyRaw) : nonInteractive ? "push" : "roundtrip";
+  const key = flags.values.get("key")?.trim() || null;
+  const keyStdin = flags.bools.has("key-stdin");
+  if (key && keyStdin) {
+    throw new UsageError("Pass either --key or --key-stdin, not both");
+  }
+  if (key && !isValidApiKey(key)) {
+    throw new UsageError("--key is not a valid API key. Expected the pk_xxx.xxx shape from pushary.com/dashboard/agent/settings");
+  }
+  return {
+    connectMode,
+    connectExplicit: connectRaw !== void 0,
+    // `--connect none` and `--skip-phone` are the same instruction, so they
+    // resolve to the same field rather than being checked separately at the two
+    // call sites that would inevitably drift apart.
+    skipPhone: flags.bools.has("skip-phone") || connectMode === "none",
+    // Anything that means "there is nobody to answer a prompt". A non-TTY stdin
+    // is included because that is the case that used to hang: it is better to
+    // take the defaults and say so than to wait forever for a keypress.
+    //
+    // --json counts. Under it stdout carries exactly one object and every human
+    // line is redirected to stderr, so a prompt has nowhere to render: the
+    // question goes to stderr while the run blocks on a keypress the caller
+    // cannot see it is waiting for, and whatever is reading stdout waits forever
+    // for an object that never arrives. Asking for machine-readable output is
+    // itself a statement that no human is watching.
+    nonInteractive,
+    json: flags.bools.has("json"),
+    dryRun: flags.bools.has("dry-run"),
+    help,
+    agents,
+    key,
+    keyStdin,
+    verify,
+    verifyExplicit: verifyRaw !== void 0,
+    control: controlRaw === void 0 ? "auto" : parseControlMode(controlRaw),
+    controlExplicit: controlRaw !== void 0,
+    transcripts: transcriptsRaw === void 0 ? null : transcriptsRaw === "on",
+    takeOverHooks: flags.bools.has("take-over-hooks")
+  };
+};
+
+// src/setup/hook-ownership.ts
+var commandsIn = (value) => {
+  if (Array.isArray(value)) return value.flatMap(commandsIn);
+  if (!value || typeof value !== "object") return [];
+  return Object.entries(value).flatMap(([key, item]) => key === "command" && typeof item === "string" ? [item] : commandsIn(item));
+};
+var isRecord2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var hasPaidPusharyCommand = (value) => commandsIn(value).some((command) => {
+  const executable = pusharyHookExecutable(command);
+  const name = executable?.split(/[/\\]/).pop()?.replace(/\.(cmd|exe|mjs)$/i, "");
+  return executable !== null && !isBridgeLocator(executable) && name !== BELL_HOOK_BINARY;
+});
+var hasAppCommand = (value) => commandsIn(value).some((command) => {
+  const executable = pusharyHookExecutable(command);
+  return executable !== null && isBridgeLocator(executable);
+});
+var mcpBearerKey = (document, containerKey, headersKey) => {
+  const servers = isRecord2(document?.[containerKey]) ? document[containerKey] : null;
+  const pushary = isRecord2(servers?.pushary) ? servers.pushary : null;
+  const headers = isRecord2(pushary?.[headersKey]) ? pushary[headersKey] : null;
+  const authorization = headers?.Authorization;
+  const match = typeof authorization === "string" ? authorization.trim().match(/^Bearer\s+(\S+)$/) : null;
+  return match?.[1] ?? null;
+};
+var captureMcpServer = (document, containerKey) => {
+  const container = document[containerKey];
+  const servers = isRecord2(container) ? container : null;
+  if (!servers && Object.hasOwn(document, containerKey)) {
+    return { present: false, containerValue: structuredClone(container) };
+  }
+  return servers && Object.hasOwn(servers, "pushary") ? { present: true, value: structuredClone(servers.pushary) } : { present: false };
+};
+var restoreMcpServer = (document, containerKey, snapshot) => {
+  const before = JSON.stringify(document);
+  const existing = isRecord2(document[containerKey]) ? document[containerKey] : null;
+  if (snapshot.present) {
+    const servers = existing ?? {};
+    servers.pushary = structuredClone(snapshot.value);
+    document[containerKey] = servers;
+  } else if (Object.hasOwn(snapshot, "containerValue")) {
+    document[containerKey] = structuredClone(snapshot.containerValue);
+  } else if (existing && Object.hasOwn(existing, "pushary")) {
+    delete existing.pushary;
+    if (Object.keys(existing).length === 0) delete document[containerKey];
+  }
+  return JSON.stringify(document) !== before;
+};
+var captureHookTakeover = (agent, document) => {
+  const hooks = isRecord2(document?.hooks) ? document.hooks : null;
+  if (!hooks) return null;
+  const captured = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    const appEntries = entries.flatMap((value, index) => isRecord2(value) && hasAppCommand(value) ? [{ index, value: structuredClone(value) }] : []);
+    if (appEntries.length > 0) captured[event] = appEntries;
+  }
+  return Object.keys(captured).length > 0 ? { version: 1, agent, hooks: captured } : null;
+};
+var isHookTakeoverReceipt = (value) => {
+  if (!isRecord2(value) || value.version !== 1 || typeof value.agent !== "string" || !AGENT_CHOICES.includes(value.agent) || !isRecord2(value.hooks)) return false;
+  const expectsMcp = ["claude_code", "codex", "gemini_cli", "vscode"].includes(value.agent);
+  if (value.mcpServer !== void 0 !== expectsMcp) return false;
+  if (value.codexTrust !== void 0 !== (value.agent === "codex")) return false;
+  if (value.codexTrust !== void 0 && !isRecord2(value.codexTrust)) return false;
+  if (value.mcpServer !== void 0 && (!isRecord2(value.mcpServer) || typeof value.mcpServer.present !== "boolean" || value.mcpServer.present && !Object.hasOwn(value.mcpServer, "value"))) return false;
+  return Object.values(value.hooks).every((entries) => Array.isArray(entries) && entries.length > 0 && entries.every((item) => isRecord2(item) && Number.isInteger(item.index) && item.index >= 0 && isRecord2(item.value)));
+};
+var restoreHookTakeover = (document, receipt) => {
+  const before = JSON.stringify(document);
+  const appOwnsNow = hookOwnerOf(document) === "app";
+  const hooks = isRecord2(document.hooks) ? document.hooks : {};
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) continue;
+    const kept = value.filter((entry) => !hasPaidPusharyCommand(entry));
+    if (kept.length === 0) delete hooks[event];
+    else hooks[event] = kept;
+  }
+  if (!appOwnsNow) {
+    for (const [event, snapshots] of Object.entries(receipt.hooks)) {
+      const entries = Array.isArray(hooks[event]) ? [...hooks[event]] : [];
+      for (const snapshot of snapshots) {
+        entries.splice(Math.min(snapshot.index, entries.length), 0, structuredClone(snapshot.value));
+      }
+      hooks[event] = entries;
+    }
+  }
+  document.hooks = hooks;
+  return JSON.stringify(document) !== before;
+};
+var hookOwnerOf = (document, appAvailable = true) => {
+  const hooks = document && typeof document === "object" ? document.hooks : void 0;
+  const executables = commandsIn(hooks).map(pusharyHookExecutable).filter((executable) => executable !== null);
+  if (appAvailable && executables.some(isBridgeLocator)) return "app";
+  if (executables.some((executable) => !isBridgeLocator(executable))) return "cli";
+  return "none";
+};
+var planHooks = (context) => {
+  if (context.owner !== "app") return "install";
+  if (context.takeOverHooks) return "install";
+  return "keep";
+};
+var describeAppOwnership = (agentName) => `The Pushary Mac app owns ${agentName}'s hooks.`;
+var KEEP_HINT = "Kept with the app's account. Pass --take-over-hooks to have the CLI own them instead.";
+var OWNER_LABELS = {
+  app: "the Pushary Mac app",
+  cli: "the CLI"
+};
+var describeHookOwnership = (entries, names) => {
+  const owned = entries.filter((entry) => entry.owner !== "none");
+  if (owned.length === 0) return null;
+  const parts = owned.map((entry) => `${names[entry.agent]} by ${OWNER_LABELS[entry.owner]}${entry.kept ? " (kept)" : ""}`);
+  return `Hooks: ${parts.join(", ")}.`;
+};
+
+export {
+  isHermesConfigReceipt,
+  HERMES_CONFIG_SCRIPT,
+  resolveHermesPython,
+  runHermesPythonScript,
+  createGuards,
+  describeSetupSideEffects,
+  effectiveVerify,
+  effectiveControlMode,
+  parseSetupOptions,
+  mcpBearerKey,
+  captureMcpServer,
+  restoreMcpServer,
+  captureHookTakeover,
+  isHookTakeoverReceipt,
+  restoreHookTakeover,
+  hookOwnerOf,
+  planHooks,
+  describeAppOwnership,
+  KEEP_HINT,
+  describeHookOwnership
+};

package/dist/{chunk-54ELC7D7.js → chunk-AWHCZOZO.js}

@@ -1,6 +1,6 @@
 import {
   pusharyDir
-} from "./chunk-KUZWXPUS.js";
+} from "./chunk-BVNYTQ5I.js";
 import {
   writeFileAtomic
 } from "./chunk-4LL6LG5X.js";

package/dist/{chunk-KUZWXPUS.js → chunk-BVNYTQ5I.js}

@@ -190,6 +190,25 @@ var codexHookPositions = (hooksConfig) => {
   return positions;
 };
 var codexHookStateKey = (hooksJsonPath, event, position) => `${hooksJsonPath}:${CODEX_EVENT_KEY[event]}:${position[0]}:${position[1]}`;
+var captureCodexHookTrust = (config, hooksJsonPath, positions) => {
+  const state = asRecord(asRecord(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 untrustedCodexHookEvents = (config, hooksJsonPath, command, positions) => {
   const state = asRecord(asRecord(config.hooks)?.state);
   return CODEX_HOOK_EVENTS.filter((definition) => {
@@ -270,6 +289,7 @@ var claudeSettingsLocal = () => join2(homedir2(), ".claude", "settings.local.jso
 var pusharyDir = () => join2(homedir2(), ".pushary");
 var claudeMcpReceipt = () => join2(pusharyDir(), "setup", "claude-mcp.json");
 var hermesConfigReceipt = () => join2(pusharyDir(), "setup", "hermes-config.json");
+var hookTakeoverReceipt = (agent) => join2(pusharyDir(), "setup", `hook-takeover-${agent}.json`);
 var codexSkillDir2 = () => join2(codexHome(), "skills", "pushary");
 var codexAgentsMd2 = () => join2(codexHome(), "AGENTS.md");
 var geminiSettings = () => join2(homedir2(), ".gemini", "settings.json");
@@ -295,6 +315,8 @@ export {
   missingCodexHookEvents,
   codexTrustSchemeAgrees,
   codexHookPositions,
+  captureCodexHookTrust,
+  restoreCodexHookTrust,
   untrustedCodexHookEvents,
   removeCodexHookTrust,
   removeCodexSettings,
@@ -311,6 +333,7 @@ export {
   pusharyDir,
   claudeMcpReceipt,
   hermesConfigReceipt,
+  hookTakeoverReceipt,
   codexSkillDir2,
   codexAgentsMd2,
   geminiSettings,