@pushary/agent-hooks 0.94.0 → 0.95.0

package/dist/chunk-GI5UQSG7.js

@@ -0,0 +1,266 @@
+import {
+  isBridgeLocator
+} from "./chunk-GHCGSEPE.js";
+import {
+  pusharyHookExecutable
+} from "./chunk-5SJ54JJO.js";
+import {
+  BELL_HOOK_BINARY
+} from "./chunk-DSTLA2TC.js";
+import {
+  parseFlags
+} from "./chunk-GMXKITVA.js";
+import {
+  UsageError
+} from "./chunk-7QLSKOSU.js";
+import {
+  isValidApiKey
+} from "./chunk-Z6CP5ZZD.js";
+
+// 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 isRecord = (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 = isRecord(document?.[containerKey]) ? document[containerKey] : null;
+  const pushary = isRecord(servers?.pushary) ? servers.pushary : null;
+  const headers = isRecord(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 = isRecord(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 = isRecord(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 = isRecord(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) => isRecord(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 (!isRecord(value) || value.version !== 1 || typeof value.agent !== "string" || !AGENT_CHOICES.includes(value.agent) || !isRecord(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 && !isRecord(value.codexTrust)) return false;
+  if (value.mcpServer !== void 0 && (!isRecord(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) => isRecord(item) && Number.isInteger(item.index) && item.index >= 0 && isRecord(item.value)));
+};
+var restoreHookTakeover = (document, receipt) => {
+  const before = JSON.stringify(document);
+  const appOwnsNow = hookOwnerOf(document) === "app";
+  const hooks = isRecord(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 {
+  AGENT_CHOICES,
+  effectiveVerify,
+  effectiveControlMode,
+  parseSetupOptions,
+  mcpBearerKey,
+  captureMcpServer,
+  restoreMcpServer,
+  captureHookTakeover,
+  isHookTakeoverReceipt,
+  restoreHookTakeover,
+  hookOwnerOf,
+  planHooks,
+  describeAppOwnership,
+  KEEP_HINT,
+  describeHookOwnership
+};

package/dist/{chunk-ZO2XG3CX.js → chunk-LSXJH2HB.js}

@@ -1,6 +1,6 @@
 import {
   parseVersion
-} from "./chunk-RX75MRGC.js";
+} from "./chunk-BMOFXRGS.js";
 
 // src/setup/agent-probe.ts
 import { execSync } from "child_process";

package/dist/{chunk-YANV5TGK.js → chunk-MDQOBG5J.js}

@@ -4,9 +4,6 @@ import {
 import {
   codexHomeFrom
 } from "./chunk-Y6XXFXVB.js";
-import {
-  HOOK_LOCATOR_BINARY
-} from "./chunk-Z6CP5ZZD.js";
 
 // src/vscode-config.ts
 import { homedir } from "os";
@@ -332,82 +329,6 @@ var hasInstructionBlock = (filePath) => {
 // src/hooks-spec.ts
 var CURSOR_GATE_SCRIPT = "pushary-gate.mjs";
 
-// src/diagnostics/bridge.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join3 } from "path";
-var BRIDGE_BUNDLE_IDENTIFIER = "com.pushary.app";
-var BRIDGE_HELPER_SUFFIX = "/Contents/Helpers/pushary-bridge";
-var BRIDGE_BUNDLE_ROOTS = ["/Applications/Pushary.app", "$HOME/Applications/Pushary.app"];
-var expandHome = (path, home) => path.replaceAll("$HOME", home);
-var parseBridgeStub = (contents, stubPath) => {
-  const helperSuffix = contents.match(/^H=(\S+)$/m)?.[1] ?? BRIDGE_HELPER_SUFFIX;
-  const cachePath = contents.match(/^C="([^"\n]+)"$/m)?.[1] ?? join3(dirname3(stubPath), ".bridge-cache");
-  const rootsLine = contents.match(/^for P in ((?:"[^"\n]*"\s*)+); do$/m)?.[1];
-  const bundleRoots = rootsLine ? [...rootsLine.matchAll(/"([^"]*)"/g)].map((match) => match[1]) : BRIDGE_BUNDLE_ROOTS;
-  const bundleIdentifier = contents.match(/kMDItemCFBundleIdentifier == "([^"]+)"/)?.[1] ?? BRIDGE_BUNDLE_IDENTIFIER;
-  return { helperSuffix, cachePath, bundleRoots, bundleIdentifier };
-};
-var resolveBridgeStub = (stubPath, probe) => {
-  const contents = probe.readFile(stubPath);
-  if (contents === null) return { kind: "no-stub", stub: stubPath };
-  const shape = parseBridgeStub(contents, stubPath);
-  const helperIn = (bundle) => `${bundle}${shape.helperSuffix}`;
-  const looked = [];
-  for (const root of shape.bundleRoots.map((root2) => expandHome(root2, probe.home))) {
-    looked.push(root);
-    if (probe.exists(helperIn(root))) return { kind: "bundle", helper: helperIn(root), via: "root" };
-  }
-  const cached = shape.cachePath ? probe.readFile(shape.cachePath)?.split("\n")[0]?.trim() : void 0;
-  if (cached) {
-    looked.push(cached);
-    if (probe.exists(helperIn(cached))) return { kind: "bundle", helper: helperIn(cached), via: "cache" };
-  }
-  for (const found of probe.mdfind(shape.bundleIdentifier)) {
-    looked.push(found);
-    if (probe.exists(helperIn(found))) return { kind: "bundle", helper: helperIn(found), via: "spotlight" };
-  }
-  return { kind: "missing", stub: stubPath, looked };
-};
-var BRIDGE_GONE_MESSAGE = "the Mac app is gone but its hooks remain; run pushary setup or reinstall the app";
-var describeBridgeResolution = (resolution) => {
-  switch (resolution.kind) {
-    case "bundle":
-      return `${resolution.helper} (${resolution.via === "root" ? "installed" : resolution.via === "cache" ? "cached path" : "found by Spotlight"})`;
-    case "missing":
-      return BRIDGE_GONE_MESSAGE;
-    case "no-stub":
-      return `${resolution.stub} is not there; ${BRIDGE_GONE_MESSAGE}`;
-  }
-};
-var isBridgeLocator = (executable) => executable !== null && executable.split(/[/\\]/).pop() === HOOK_LOCATOR_BINARY;
-var spotlight = (bundleIdentifier) => {
-  if (process.platform !== "darwin") return [];
-  try {
-    return execFileSync("/usr/bin/mdfind", [`kMDItemCFBundleIdentifier == "${bundleIdentifier}"`], {
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).split("\n").map((line) => line.trim()).filter((line) => line !== "");
-  } catch {
-    return [];
-  }
-};
-var readOrNull = (path) => {
-  try {
-    return readFileSync2(path, "utf-8");
-  } catch {
-    return null;
-  }
-};
-var liveBridgeProbe = () => ({
-  exists: existsSync3,
-  readFile: readOrNull,
-  mdfind: spotlight,
-  home: homedir3()
-});
-
 export {
   registerPluginLocation,
   unregisterPluginLocation,
@@ -425,9 +346,5 @@ export {
   writeInstructionBlock,
   removeInstructionBlock,
   hasInstructionBlock,
-  CURSOR_GATE_SCRIPT,
-  resolveBridgeStub,
-  describeBridgeResolution,
-  isBridgeLocator,
-  liveBridgeProbe
+  CURSOR_GATE_SCRIPT
 };

package/dist/chunk-N6FAXQDD.js

@@ -0,0 +1,276 @@
+import {
+  resolvePathBinary
+} from "./chunk-L4ZCFMWW.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_PIP_PACKAGE = "hermes-plugin-pushary";
+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)"
+];
+
+export {
+  isHermesConfigReceipt,
+  HERMES_PIP_PACKAGE,
+  HERMES_CONFIG_SCRIPT,
+  resolveHermesPython,
+  runHermesPythonScript,
+  createGuards,
+  describeSetupSideEffects
+};

package/dist/{chunk-5HGLZGI4.js → chunk-OXTRFRMD.js}

@@ -1028,6 +1028,7 @@ var handleSessionEnd = async (input, agent = CLAUDE_CODE_AGENT, options = {}) =>
       }
     }
     if (!isDefaultSession(sessionKey)) removePendingSession(sessionKey);
+    if (options.reportClosed === false) return;
     await reportEvent({
       event: "session_closed",
       agentType: agent.type,