@pushary/agent-hooks 0.94.0 → 0.95.1

package/dist/bin/pushary-upgrade.js

@@ -1,14 +1,18 @@
 #!/usr/bin/env node
 import {
   reapplyAllAgents
-} from "../chunk-36LR2LOT.js";
-import "../chunk-ZO2XG3CX.js";
+} from "../chunk-IP63LMZM.js";
+import "../chunk-MF64S7WO.js";
 import {
   waitForMachineReadiness
-} from "../chunk-QGA2ZB4I.js";
-import "../chunk-HSAVPZ46.js";
-import "../chunk-RX75MRGC.js";
-import "../chunk-EZIEXHYM.js";
+} from "../chunk-RNH2AE52.js";
+import "../chunk-WJZUTMMU.js";
+import {
+  detectProviderLiveCapabilities,
+  hasSpawnProvider,
+  resolveControlPolicy
+} from "../chunk-3OXHYPZG.js";
+import "../chunk-IFCS6LXB.js";
 import {
   daemonHasRemoteProof,
   daemonServiceManagerAvailable,
@@ -19,12 +23,9 @@ import {
   replaceDaemonService,
   stopDaemonService,
   waitForDaemonRemoteProof
-} from "../chunk-ZTJF6ANY.js";
-import {
-  detectProviderLiveCapabilities,
-  hasSpawnProvider,
-  resolveControlPolicy
-} from "../chunk-3OXHYPZG.js";
+} from "../chunk-CU5KI425.js";
+import "../chunk-BWNU4MX4.js";
+import "../chunk-EZIEXHYM.js";
 import {
   needsShell
 } from "../chunk-XHKBHWLX.js";
@@ -33,15 +34,15 @@ import {
   npmErrorMessage,
   resolveGlobalBinary
 } from "../chunk-L4ZCFMWW.js";
-import "../chunk-Y3UGCQQC.js";
-import "../chunk-NVPYRDCT.js";
+import "../chunk-TTO76NZJ.js";
+import "../chunk-SSQ5X6SA.js";
 import {
   claudeJson,
   codexConfigToml,
   cursorPluginDir,
   geminiSettings,
   vscodePluginDir
-} from "../chunk-Y6XXFXVB.js";
+} from "../chunk-3F4VV5TS.js";
 import {
   exitOnHelpFlag
 } from "../chunk-BVBEURWJ.js";
@@ -51,15 +52,15 @@ import {
 } from "../chunk-DINDL2CF.js";
 import {
   readControlMode
-} from "../chunk-6BIMJIRG.js";
+} from "../chunk-JSASMV3H.js";
 import "../chunk-BC3VCZ3E.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-ODL52O5V.js";
+import "../chunk-T5B3LRYF.js";
 import "../chunk-4LL6LG5X.js";
 import {
   getApiKey
 } from "../chunk-2UMNXADU.js";
-import "../chunk-Z6CP5ZZD.js";
+import "../chunk-VOWZ5VOO.js";
 
 // bin/pushary-upgrade.ts
 import { existsSync } from "fs";

package/dist/bin/pushary-wait.js

@@ -4,18 +4,18 @@ import {
 } from "../chunk-IIENZE2J.js";
 import {
   exitOnFailedResponse
-} from "../chunk-WY4ALDYN.js";
-import "../chunk-UZFVNEEU.js";
+} from "../chunk-AQ5OAYOH.js";
+import "../chunk-PDFVIRPB.js";
 import {
   createIo
 } from "../chunk-5RUIFDTP.js";
-import {
-  rejectUnknownFlags
-} from "../chunk-GMXKITVA.js";
 import {
   exitOnHelpFlag
 } from "../chunk-BVBEURWJ.js";
 import "../chunk-43GMYSS4.js";
+import {
+  rejectUnknownFlags
+} from "../chunk-GMXKITVA.js";
 import "../chunk-DINDL2CF.js";
 import "../chunk-SAF6HGAA.js";
 import {
@@ -28,7 +28,7 @@ import {
   getApiKey,
   getBaseUrl
 } from "../chunk-2UMNXADU.js";
-import "../chunk-Z6CP5ZZD.js";
+import "../chunk-VOWZ5VOO.js";
 
 // bin/pushary-wait.ts
 exitOnHelpFlag("wait");

package/dist/{chunk-Y6XXFXVB.js → chunk-3F4VV5TS.js}

@@ -1,7 +1,7 @@
 import {
   HOOK_BUDGETS,
   HOOK_LOCATOR_BINARY
-} from "./chunk-Z6CP5ZZD.js";
+} from "./chunk-VOWZ5VOO.js";
 
 // src/removal-scope.ts
 var namesAppLocator = (command) => command.includes(HOOK_LOCATOR_BINARY);

package/dist/chunk-77U3ZVV6.js

@@ -0,0 +1,86 @@
+import {
+  HOOK_LOCATOR_BINARY
+} from "./chunk-VOWZ5VOO.js";
+
+// src/diagnostics/bridge.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } 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] ?? join(dirname(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 readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var liveBridgeProbe = () => ({
+  exists: existsSync,
+  readFile: readOrNull,
+  mdfind: spotlight,
+  home: homedir()
+});
+
+export {
+  resolveBridgeStub,
+  describeBridgeResolution,
+  isBridgeLocator,
+  liveBridgeProbe
+};

package/dist/{chunk-RH3TM7TO.js → chunk-7MGF5Q7G.js}

@@ -1,6 +1,6 @@
 import {
   readConfigFileKey
-} from "./chunk-6BIMJIRG.js";
+} from "./chunk-JSASMV3H.js";
 
 // src/bell/fleet.ts
 import { closeSync, constants, futimesSync, lstatSync, mkdirSync, openSync, readdirSync, unlinkSync } from "fs";

package/dist/{chunk-WY4ALDYN.js → chunk-AQ5OAYOH.js}

@@ -1,7 +1,7 @@
 import {
   describeKeyCheck,
   keyCheckFromResponse
-} from "./chunk-UZFVNEEU.js";
+} from "./chunk-PDFVIRPB.js";
 import {
   createIo
 } from "./chunk-5RUIFDTP.js";

package/dist/chunk-BWNU4MX4.js

@@ -0,0 +1,185 @@
+import {
+  NOTIFICATION_MATCHED_TYPES,
+  POSTTOOLUSE_MIRRORED_TOOLS,
+  PRETOOLUSE_GATED_TOOLS,
+  PRETOOLUSE_PHONE_ANSWERED_TOOLS
+} from "./chunk-TTO76NZJ.js";
+import {
+  isProtectedByScope
+} from "./chunk-3F4VV5TS.js";
+import {
+  HOOK_BUDGETS,
+  HOOK_LOCATOR_BINARY
+} from "./chunk-VOWZ5VOO.js";
+
+// src/gemini-config.ts
+var GEMINI_HOOK_BINARY = "pushary-gemini-hook";
+var GEMINI_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var GEMINI_HOOK_EVENTS = [
+  { event: "BeforeTool", matcher: "run_shell_command|write_file|replace", delivery: "approval", timeoutMs: HOOK_BUDGETS.gemini.budgetSeconds * 1e3 },
+  { event: "AfterTool", matcher: "run_shell_command|write_file|replace", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "BeforeAgent", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "AfterAgent", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "SessionStart", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "SessionEnd", delivery: "telemetry", timeoutMs: 1e4 }
+];
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyGeminiHook = (entry, scope) => {
+  const hooks = asRecord(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    const command = String(asRecord(hook)?.command ?? "");
+    if (isProtectedByScope(command, scope)) return false;
+    return command.includes(GEMINI_HOOK_BINARY) || command.includes(HOOK_LOCATOR_BINARY);
+  });
+};
+var addGeminiMcpServer = (settings, apiKey) => {
+  const mcpServers = ensureRecord(settings, "mcpServers");
+  mcpServers.pushary = {
+    httpUrl: GEMINI_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` },
+    trust: true
+  };
+};
+var addGeminiHooks = (settings, command) => {
+  const hooks = ensureRecord(settings, "hooks");
+  for (const definition of GEMINI_HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[definition.event]) ? hooks[definition.event] : [];
+    const entries = existing.filter((entry) => !isPusharyGeminiHook(entry));
+    entries.push({
+      ...definition.matcher ? { matcher: definition.matcher } : {},
+      hooks: [{
+        name: "pushary",
+        type: "command",
+        command,
+        timeout: definition.timeoutMs
+      }]
+    });
+    hooks[definition.event] = entries;
+  }
+};
+var removeGeminiHooks = (settings, scope) => {
+  const hooks = asRecord(settings.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const definition of GEMINI_HOOK_EVENTS) {
+    const entries = hooks[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry) => !isPusharyGeminiHook(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 settings.hooks;
+  return changed;
+};
+var removeGeminiMcpServer = (settings) => {
+  const mcpServers = asRecord(settings.mcpServers);
+  if (!mcpServers?.pushary) return false;
+  delete mcpServers.pushary;
+  if (Object.keys(mcpServers).length === 0) delete settings.mcpServers;
+  return true;
+};
+var removeGeminiSettings = (settings, scope) => {
+  const mcpRemoved = scope?.keepMcpServer === true ? false : removeGeminiMcpServer(settings);
+  const hooksRemoved = removeGeminiHooks(settings, scope);
+  return mcpRemoved || hooksRemoved;
+};
+var hasGeminiHooks = (settings) => {
+  const hooks = asRecord(settings.hooks);
+  if (!hooks) return false;
+  return GEMINI_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some((entry) => isPusharyGeminiHook(entry));
+  });
+};
+var missingGeminiHookEvents = (settings) => {
+  const hooks = asRecord(settings.hooks);
+  return GEMINI_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some((entry) => isPusharyGeminiHook(entry));
+  }).map((definition) => definition.event);
+};
+
+// src/agent-version.ts
+var parseVersion = (raw) => {
+  const match = raw.match(/(\d+)\.(\d+)\.(\d+)/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+};
+var compareVersion = (a, b) => {
+  for (let index = 0; index < 3; index++) {
+    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
+  }
+  return 0;
+};
+var atLeast = (version, floor) => compareVersion(version, floor) >= 0;
+var formatVersion = (version) => version.join(".");
+
+// src/claude-events.ts
+var GATED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, ...PRETOOLUSE_PHONE_ANSWERED_TOOLS].join("|");
+var MIRRORED_TOOLS = POSTTOOLUSE_MIRRORED_TOOLS.join("|");
+var ESTABLISHED = [1, 0, 0];
+var OBSERVED = [2, 0, 0];
+var CLAUDE_HOOK_EVENTS = [
+  { event: "PreToolUse", binary: "pushary-hook", matcher: GATED_TOOLS, timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: ESTABLISHED },
+  { event: "PostToolUse", binary: "pushary-post-hook", matcher: MIRRORED_TOOLS, timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Stop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "UserPromptSubmit", binary: "pushary-prompt-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Notification", binary: "pushary-notification-hook", matcher: NOTIFICATION_MATCHED_TYPES.join("|"), timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionStart", binary: "pushary-session-start-hook", matcher: "startup|resume|clear", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionEnd", binary: "pushary-session-end-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "StopFailure", binary: "pushary-stopfailure-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "PermissionRequest", binary: "pushary-permission-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: ESTABLISHED },
+  { event: "PermissionDenied", binary: "pushary-permission-denied-hook", timeout: 60, delivery: "telemetry", since: ESTABLISHED },
+  // Observability only. Each carries session shape the island cannot get any other
+  // way, and none of them decides anything.
+  { event: "SubagentStart", binary: "pushary-session-start-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "SubagentStop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PreCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PostCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "TeammateIdle", binary: "pushary-notification-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  // An MCP server asking the person for a value, answered from the phone rather
+  // than the terminal. No matcher: Claude Code matches this event on the MCP
+  // server's name, and we have no business preferring one server over another.
+  { event: "Elicitation", binary: "pushary-elicitation-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: OBSERVED }
+];
+var supportedClaudeEvents = (version) => CLAUDE_HOOK_EVENTS.filter((hook) => version ? atLeast(version, hook.since) : hook.since === ESTABLISHED);
+var registrationSignatures = (events, version) => Object.fromEntries(
+  events.map((hook) => [hook.event, `registered|${version ? formatVersion(version) : "unknown"}`])
+);
+var needsReregistration = (stored, version) => {
+  const expected = registrationSignatures(supportedClaudeEvents(version), version);
+  const keys = Object.keys(expected);
+  if (!stored) return true;
+  if (keys.length !== Object.keys(stored).length) return true;
+  return keys.some((event) => stored[event] !== expected[event]);
+};
+
+export {
+  GEMINI_HOOK_BINARY,
+  GEMINI_HOOK_EVENTS,
+  addGeminiMcpServer,
+  addGeminiHooks,
+  removeGeminiSettings,
+  hasGeminiHooks,
+  missingGeminiHookEvents,
+  parseVersion,
+  compareVersion,
+  formatVersion,
+  CLAUDE_HOOK_EVENTS,
+  supportedClaudeEvents,
+  registrationSignatures,
+  needsReregistration
+};

package/dist/{chunk-OYNPLEXP.js → chunk-C2MV4G4A.js}

@@ -1,6 +1,6 @@
 import {
   shouldDeferToNativeMode
-} from "./chunk-Z6CP5ZZD.js";
+} from "./chunk-VOWZ5VOO.js";
 
 // src/native-defer.ts
 var nativeDeferOptions = () => {