@pushary/agent-hooks 0.84.0 → 0.85.0

package/dist/bin/pushary-setup.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
+import {
+  detectClaudeVersion
+} from "../chunk-AXRATIS6.js";
 import {
   claudeWired,
   codexWired,
   geminiWired
-} from "../chunk-HZNOAJGB.js";
+} from "../chunk-4QPOMJUB.js";
 import {
   runBrowserLogin
 } from "../chunk-Z3Z4VK5F.js";
 import {
   ensureDaemonRunning
-} from "../chunk-CCH775Y6.js";
+} from "../chunk-WEAQQSHQ.js";
 import {
   describeDetection,
   detectAllAgents,
@@ -21,7 +24,7 @@ import {
   shortenHome,
   vscodeSettingsTargets,
   writeInstructionBlock
-} from "../chunk-UXWEE3QI.js";
+} from "../chunk-ADISVXZL.js";
 import {
   GEMINI_HOOK_BINARY,
   addGeminiHooks,
@@ -30,13 +33,18 @@ import {
 import {
   addClaudeMcpServer,
   addPusharyHooks,
-  addPusharyToolPermissions
-} from "../chunk-UKSQWTBH.js";
+  addPusharyToolPermissions,
+  compareVersion,
+  parseVersion
+} from "../chunk-64PXDATC.js";
+import {
+  guardBinary,
+  guardNodeScript
+} from "../chunk-PWTKKQQI.js";
 import "../chunk-XHKBHWLX.js";
 import {
   installGlobally,
   npmErrorMessage,
-  quoteIfNeeded,
   resolveGlobalBinDir,
   resolveGlobalBinary
 } from "../chunk-VT4IVERX.js";
@@ -57,10 +65,10 @@ import {
   geminiSettings,
   pusharyConfigFile,
   vscodePluginDir
-} from "../chunk-SEAHGHCE.js";
+} from "../chunk-HVZIHTOO.js";
 import {
   reportEvent
-} from "../chunk-OPMSMF5R.js";
+} from "../chunk-EXMUM226.js";
 import "../chunk-RN3NOEJF.js";
 import {
   confirmAppConnection,
@@ -92,7 +100,7 @@ import {
 } from "../chunk-GMXKITVA.js";
 import {
   renderCommandHelp
-} from "../chunk-MGJBC6DD.js";
+} from "../chunk-GOEXZ5QJ.js";
 import {
   installClaudeAlias,
   resolveShellRc
@@ -234,17 +242,8 @@ var describeClosing = (facts) => {
 
 // src/setup/codex-version.ts
 import { dirname, join } from "path";
-var parseCodexVersion = (raw) => {
-  const match = raw.match(/(\d+)\.(\d+)\.(\d+)/);
-  if (!match) return null;
-  return [Number(match[1]), Number(match[2]), Number(match[3])];
-};
-var compareCodexVersion = (a, b) => {
-  for (let i = 0; i < 3; i++) {
-    if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;
-  }
-  return 0;
-};
+var parseCodexVersion = parseVersion;
+var compareCodexVersion = compareVersion;
 var versionFromManifest = (probe, binPath) => {
   let dir = dirname(binPath);
   for (let depth = 0; depth < 4; depth++) {
@@ -714,7 +713,7 @@ var setupClaudeCode = async (apiKey) => {
     addPusharyToolPermissions(settings);
   });
   await spinner("Adding hooks (approvals, activity, presence, and lifecycle events)", async () => {
-    addPusharyHooks(settings, resolveGlobalBinDir("pushary-hook"));
+    addPusharyHooks(settings, resolveGlobalBinDir("pushary-hook"), detectClaudeVersion());
   });
   await spinner(`Writing ${CLAUDE_JSON}`, async () => {
     writeJsonAtomic(CLAUDE_JSON, claudeJson2, 384);
@@ -940,7 +939,7 @@ var setupCodex = async (apiKey) => {
   const trustAuto = codexTrustAutoSupported(codexVersion);
   let trusted = false;
   if (hooksSupported) {
-    const hookCommand = quoteIfNeeded(resolveGlobalBinary("pushary-codex-hook") ?? "pushary-codex-hook");
+    const hookCommand = guardBinary(resolveGlobalBinary("pushary-codex-hook") ?? "pushary-codex-hook");
     await spinner("Adding native hooks (~/.codex/hooks.json)", async () => {
       const hooksConfig = readAgentJson(CODEX_HOOKS_JSON);
       addCodexHooks(hooksConfig, hookCommand);
@@ -1022,7 +1021,7 @@ var resolveBundledPlugin = () => {
 var installCursorUserHooks = (gateScript) => {
   const template = readJson(join2(CURSOR_PLUGIN_DIR, "hooks", "hooks.json")).hooks?.beforeShellExecution?.[0];
   if (!template) throw new Error("bundled Cursor hooks.json missing a beforeShellExecution entry");
-  const entry = { ...template, command: `node "${gateScript}"` };
+  const entry = { ...template, command: guardNodeScript(gateScript) };
   let userHooks = {};
   if (existsSync(CURSOR_USER_HOOKS)) {
     try {
@@ -1286,7 +1285,7 @@ var setupGemini = async (apiKey) => {
     addGeminiMcpServer(settings, apiKey);
   });
   await spinner("Adding hooks (BeforeTool, AfterTool, BeforeAgent, SessionStart, SessionEnd)", async () => {
-    addGeminiHooks(settings, quoteIfNeeded(resolveGlobalBinary(GEMINI_HOOK_BINARY) ?? GEMINI_HOOK_BINARY));
+    addGeminiHooks(settings, guardBinary(resolveGlobalBinary(GEMINI_HOOK_BINARY) ?? GEMINI_HOOK_BINARY));
   });
   await spinner(`Writing ${GEMINI_SETTINGS}`, async () => {
     writeJsonAtomic(GEMINI_SETTINGS, settings, KEY_FILE_MODE);

package/dist/bin/pushary-stats.js

@@ -4,8 +4,8 @@ import {
 } from "../chunk-NJ7JT26G.js";
 import {
   exitOnHelpFlag
-} from "../chunk-J4KFVOCQ.js";
-import "../chunk-MGJBC6DD.js";
+} from "../chunk-SQOFGPNX.js";
+import "../chunk-GOEXZ5QJ.js";
 import "../chunk-DINDL2CF.js";
 import "../chunk-KZERVKTD.js";
 import {

package/dist/bin/pushary-status.js

@@ -25,8 +25,8 @@ import {
 } from "../chunk-GMXKITVA.js";
 import {
   exitOnHelpFlag
-} from "../chunk-J4KFVOCQ.js";
-import "../chunk-MGJBC6DD.js";
+} from "../chunk-SQOFGPNX.js";
+import "../chunk-GOEXZ5QJ.js";
 import "../chunk-BC3VCZ3E.js";
 import "../chunk-DINDL2CF.js";
 import "../chunk-6MTNS63X.js";

package/dist/bin/pushary-stop-hook.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+import {
+  readHookInput
+} from "../chunk-6CUUA7HO.js";
 import {
   handleStop
-} from "../chunk-OPMSMF5R.js";
+} from "../chunk-EXMUM226.js";
 import "../chunk-RN3NOEJF.js";
 import "../chunk-BSZYIAZL.js";
 import "../chunk-SAF6HGAA.js";
@@ -13,12 +16,9 @@ import "../chunk-MQMPG5X4.js";
 
 // bin/pushary-stop-hook.ts
 var main = async () => {
-  let rawInput = "";
-  for await (const chunk of process.stdin) {
-    rawInput += chunk;
-  }
+  const input = await readHookInput("claude", "Stop");
+  if (!input) return;
   try {
-    const input = rawInput.trim() ? JSON.parse(rawInput) : {};
     const output = await handleStop(input);
     if (output) process.stdout.write(JSON.stringify(output));
   } catch {

package/dist/bin/pushary-stopfailure-hook.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+import {
+  readHookInput
+} from "../chunk-6CUUA7HO.js";
 import {
   handleStopFailure
-} from "../chunk-OPMSMF5R.js";
+} from "../chunk-EXMUM226.js";
 import "../chunk-RN3NOEJF.js";
 import "../chunk-BSZYIAZL.js";
 import "../chunk-SAF6HGAA.js";
@@ -13,12 +16,9 @@ import "../chunk-MQMPG5X4.js";
 
 // bin/pushary-stopfailure-hook.ts
 var main = async () => {
-  let rawInput = "";
-  for await (const chunk of process.stdin) {
-    rawInput += chunk;
-  }
+  const input = await readHookInput("claude", "StopFailure");
+  if (!input) return;
   try {
-    const input = rawInput.trim() ? JSON.parse(rawInput) : {};
     await handleStopFailure(input);
   } catch {
   }

package/dist/bin/pushary-suggestions.js

@@ -7,8 +7,8 @@ import {
 } from "../chunk-GMXKITVA.js";
 import {
   exitOnHelpFlag
-} from "../chunk-J4KFVOCQ.js";
-import "../chunk-MGJBC6DD.js";
+} from "../chunk-SQOFGPNX.js";
+import "../chunk-GOEXZ5QJ.js";
 import "../chunk-DINDL2CF.js";
 import {
   UsageError

package/dist/bin/pushary-upgrade.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  detectClaudeVersion
+} from "../chunk-AXRATIS6.js";
 import {
   GEMINI_HOOK_BINARY,
   addGeminiHooks,
@@ -9,11 +12,13 @@ import {
   addClaudeMcpServer,
   addPusharyHooks,
   addPusharyToolPermissions
-} from "../chunk-UKSQWTBH.js";
+} from "../chunk-64PXDATC.js";
+import {
+  guardBinary
+} from "../chunk-PWTKKQQI.js";
 import {
   execNpm,
   npmErrorMessage,
-  quoteIfNeeded,
   resolveGlobalBinDir,
   resolveGlobalBinary
 } from "../chunk-VT4IVERX.js";
@@ -30,11 +35,11 @@ import {
   hasCodexHooks,
   vscodePluginDir,
   vscodePluginMcp
-} from "../chunk-SEAHGHCE.js";
+} from "../chunk-HVZIHTOO.js";
 import {
   exitOnHelpFlag
-} from "../chunk-J4KFVOCQ.js";
-import "../chunk-MGJBC6DD.js";
+} from "../chunk-SQOFGPNX.js";
+import "../chunk-GOEXZ5QJ.js";
 import {
   isNewerVersion
 } from "../chunk-DINDL2CF.js";
@@ -87,7 +92,7 @@ var reapplyClaudeSettings = (apiKey, paths = {}) => {
     if (!settingsWritable) throw new Error("settings.json could not be parsed");
     const s = settings;
     addPusharyToolPermissions(s);
-    addPusharyHooks(s, resolveGlobalBinDir("pushary-hook"));
+    addPusharyHooks(s, resolveGlobalBinDir("pushary-hook"), detectClaudeVersion());
     writeJson(settingsPath, s);
     hooks = true;
   } catch {
@@ -119,7 +124,7 @@ var reapplyCodexSettings = (apiKey, paths = {}) => {
   const hooksConfig = readJson(hooksPath);
   const configured = config != null && !!config.mcp_servers?.pushary || hooksConfig != null && hasCodexHooks(hooksConfig);
   if (!configured) return { reapplied: false, hooks: false, mcp: false };
-  const command = quoteIfNeeded(resolveGlobalBinary(CODEX_HOOK_BINARY) ?? CODEX_HOOK_BINARY);
+  const command = guardBinary(resolveGlobalBinary(CODEX_HOOK_BINARY) ?? CODEX_HOOK_BINARY);
   let hooks = false;
   let mcp = false;
   if (hooksConfig != null) {
@@ -152,7 +157,7 @@ var reapplyGeminiSettings = (apiKey, paths = {}) => {
   let hooks = false;
   let mcp = false;
   try {
-    addGeminiHooks(settings, quoteIfNeeded(resolveGlobalBinary(GEMINI_HOOK_BINARY) ?? GEMINI_HOOK_BINARY));
+    addGeminiHooks(settings, guardBinary(resolveGlobalBinary(GEMINI_HOOK_BINARY) ?? GEMINI_HOOK_BINARY));
     hooks = true;
     if (apiKey) {
       addGeminiMcpServer(settings, apiKey);

package/dist/bin/pushary-wait.js

@@ -14,8 +14,8 @@ import {
 } from "../chunk-GMXKITVA.js";
 import {
   exitOnHelpFlag
-} from "../chunk-J4KFVOCQ.js";
-import "../chunk-MGJBC6DD.js";
+} from "../chunk-SQOFGPNX.js";
+import "../chunk-GOEXZ5QJ.js";
 import "../chunk-DINDL2CF.js";
 import "../chunk-SAF6HGAA.js";
 import {

package/dist/bin/pushary.js

@@ -3,7 +3,7 @@ import {
   COMMANDS,
   isCommandName,
   renderHelp
-} from "../chunk-MGJBC6DD.js";
+} from "../chunk-GOEXZ5QJ.js";
 import {
   getPackageVersion
 } from "../chunk-DINDL2CF.js";
@@ -26,6 +26,7 @@ var LOADERS = {
   connect: () => import("./pushary-connect.js"),
   bell: () => import("./pushary-bell.js"),
   doctor: () => import("./pushary-doctor.js"),
+  disconnect: () => import("./pushary-disconnect.js"),
   clean: () => import("./pushary-clean.js"),
   mode: () => import("./pushary-mode.js"),
   wait: () => import("./pushary-wait.js"),

package/dist/{chunk-HZNOAJGB.js → chunk-4QPOMJUB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-DOXSWT4Q.js";
 import {
   hasCodexHooks
-} from "./chunk-SEAHGHCE.js";
+} from "./chunk-HVZIHTOO.js";
 
 // src/diagnostics/wiring.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;

package/dist/chunk-64PXDATC.js

@@ -0,0 +1,187 @@
+import {
+  guardBinary
+} from "./chunk-PWTKKQQI.js";
+import {
+  HOOK_BUDGETS
+} from "./chunk-MQMPG5X4.js";
+
+// src/claude-config.ts
+import { join } from "path";
+
+// 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;
+
+// src/claude-tools.ts
+var PRETOOLUSE_GATED_TOOLS = [
+  "Bash",
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "NotebookEdit",
+  "PowerShell",
+  "Monitor"
+];
+var POSTTOOLUSE_MIRRORED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, "TodoWrite"];
+var PRETOOLUSE_HANDLED_TOOLS = /* @__PURE__ */ new Set([...PRETOOLUSE_GATED_TOOLS, "AskUserQuestion"]);
+
+// src/claude-events.ts
+var GATED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, "AskUserQuestion"].join("|");
+var MIRRORED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, "TodoWrite"].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, since: ESTABLISHED },
+  { event: "PostToolUse", binary: "pushary-post-hook", matcher: MIRRORED_TOOLS, timeout: 10, since: ESTABLISHED },
+  { event: "Stop", binary: "pushary-stop-hook", timeout: 10, since: ESTABLISHED },
+  { event: "UserPromptSubmit", binary: "pushary-prompt-hook", timeout: 10, since: ESTABLISHED },
+  { event: "Notification", binary: "pushary-notification-hook", matcher: "permission_prompt|idle_prompt|agent_needs_input|agent_completed", timeout: 10, since: ESTABLISHED },
+  { event: "SessionStart", binary: "pushary-session-start-hook", matcher: "startup|resume|clear", timeout: 10, since: ESTABLISHED },
+  { event: "SessionEnd", binary: "pushary-session-end-hook", timeout: 10, since: ESTABLISHED },
+  { event: "StopFailure", binary: "pushary-stopfailure-hook", timeout: 10, since: ESTABLISHED },
+  { event: "PermissionRequest", binary: "pushary-permission-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, since: ESTABLISHED },
+  { event: "PermissionDenied", binary: "pushary-permission-denied-hook", timeout: 60, 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, since: OBSERVED },
+  { event: "SubagentStop", binary: "pushary-stop-hook", timeout: 10, since: OBSERVED },
+  { event: "PreCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, since: OBSERVED },
+  { event: "PostCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, since: OBSERVED },
+  { event: "TeammateIdle", binary: "pushary-notification-hook", timeout: 10, since: OBSERVED }
+];
+var supportedClaudeEvents = (version) => CLAUDE_HOOK_EVENTS.filter((hook) => version ? atLeast(version, hook.since) : hook.since === ESTABLISHED);
+
+// src/claude-config.ts
+var PUSHARY_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var PUSHARY_PERMISSION_RULE = "mcp__pushary__*";
+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 isPusharyPermission = (rule) => typeof rule === "string" && (rule.includes("pushary") || rule.includes("MCP(pushary"));
+var HOOK_BINARIES = new Set(CLAUDE_HOOK_EVENTS.map((hook) => hook.binary));
+var namesPusharyBinary = (command) => command.split(/[\s/\\"']+/).some((segment) => HOOK_BINARIES.has(segment.replace(/\.(cmd|exe)$/i, "")));
+var isPusharyHook = (entry2) => {
+  const hooks = asRecord(entry2)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => namesPusharyBinary(String(asRecord(hook)?.command ?? "")));
+};
+var addClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = ensureRecord(config, "mcpServers");
+  mcpServers.pushary = {
+    type: "http",
+    url: PUSHARY_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+};
+var removeClaudeMcpServers = (config) => {
+  let changed = false;
+  const removeFrom = (target) => {
+    const mcpServers = asRecord(target.mcpServers);
+    if (!mcpServers?.pushary) return;
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete target.mcpServers;
+    changed = true;
+  };
+  removeFrom(config);
+  const projects = asRecord(config.projects);
+  if (projects) {
+    for (const project of Object.values(projects)) {
+      const projectConfig = asRecord(project);
+      if (projectConfig) removeFrom(projectConfig);
+    }
+  }
+  return changed;
+};
+var addPusharyToolPermissions = (settings) => {
+  const permissions = ensureRecord(settings, "permissions");
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filtered = allow.filter((rule) => !isPusharyPermission(rule));
+  if (!filtered.includes(PUSHARY_PERMISSION_RULE)) {
+    filtered.push(PUSHARY_PERMISSION_RULE);
+  }
+  permissions.allow = filtered;
+};
+var addPusharyHooks = (settings, binDir, version = null) => {
+  const resolve = (name) => guardBinary(binDir ? join(binDir, name) : name);
+  const hooks = ensureRecord(settings, "hooks");
+  const supported = new Map(supportedClaudeEvents(version).map((hook) => [hook.event, hook]));
+  for (const known of CLAUDE_HOOK_EVENTS) {
+    const current = hooks[known.event];
+    const others = (Array.isArray(current) ? current : []).filter((item) => !isPusharyHook(item));
+    const definition = supported.get(known.event);
+    if (definition) {
+      hooks[known.event] = [...others, entry(definition, resolve)];
+    } else if (others.length > 0) {
+      hooks[known.event] = others;
+    } else {
+      delete hooks[known.event];
+    }
+  }
+};
+var entry = (definition, resolve) => ({
+  ...definition.matcher ? { matcher: definition.matcher } : {},
+  hooks: [{
+    type: "command",
+    command: resolve(definition.binary),
+    timeout: definition.timeout
+  }]
+});
+var removePusharySettings = (settings) => {
+  let changed = removeClaudeMcpServers(settings);
+  const permissions = asRecord(settings.permissions);
+  if (permissions && Array.isArray(permissions.allow)) {
+    const filtered = permissions.allow.filter((rule) => !isPusharyPermission(rule));
+    if (filtered.length !== permissions.allow.length) {
+      if (filtered.length === 0) {
+        delete permissions.allow;
+      } else {
+        permissions.allow = filtered;
+      }
+      if (Object.keys(permissions).length === 0) delete settings.permissions;
+      changed = true;
+    }
+  }
+  const hooks = asRecord(settings.hooks);
+  if (hooks) {
+    for (const { event: key } of CLAUDE_HOOK_EVENTS) {
+      const entries = hooks[key];
+      if (!Array.isArray(entries)) continue;
+      const filtered = entries.filter((entry2) => !isPusharyHook(entry2));
+      if (filtered.length !== entries.length) {
+        if (filtered.length === 0) {
+          delete hooks[key];
+        } else {
+          hooks[key] = filtered;
+        }
+        changed = true;
+      }
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  return changed;
+};
+
+export {
+  parseVersion,
+  compareVersion,
+  PRETOOLUSE_HANDLED_TOOLS,
+  addClaudeMcpServer,
+  removeClaudeMcpServers,
+  addPusharyToolPermissions,
+  addPusharyHooks,
+  removePusharySettings
+};

package/dist/chunk-6CUUA7HO.js

@@ -0,0 +1,59 @@
+// src/admission.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var NO_RULES = { version: 1, disabled: [] };
+var SUPPORTED_VERSION = 1;
+var parseAdmissionRules = (raw) => {
+  if (!raw) return NO_RULES;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== SUPPORTED_VERSION) return NO_RULES;
+    if (!Array.isArray(parsed.disabled)) return NO_RULES;
+    return {
+      version: SUPPORTED_VERSION,
+      disabled: parsed.disabled.filter((rule) => typeof rule === "string")
+    };
+  } catch {
+    return NO_RULES;
+  }
+};
+var admissionRulesFile = () => process.env.PUSHARY_ADMISSION_FILE?.trim() || join(homedir(), ".pushary", "admission-rules.json");
+var readAdmissionRules = () => {
+  try {
+    return parseAdmissionRules(readFileSync(admissionRulesFile(), "utf-8"));
+  } catch {
+    return NO_RULES;
+  }
+};
+var matches = (rule, source, event) => {
+  const colon = rule.indexOf(":");
+  if (colon <= 0 || colon === rule.length - 1) return false;
+  const ruleSource = rule.slice(0, colon);
+  const ruleEvent = rule.slice(colon + 1);
+  return (ruleSource === "*" || ruleSource === source) && (ruleEvent === "*" || ruleEvent === event);
+};
+var isAdmitted = (rules, source, event) => !rules.disabled.some((rule) => matches(rule, source, event));
+var readHookInput = async (source, fallbackEvent = "", stdin = process.stdin) => {
+  let raw = "";
+  for await (const chunk of stdin) raw += chunk;
+  if (!raw.trim()) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const event = eventNameOf(parsed) ?? fallbackEvent;
+  return isAdmitted(readAdmissionRules(), source, event) ? parsed : null;
+};
+var eventNameOf = (input) => {
+  if (!("hook_event_name" in input)) return void 0;
+  const name = input.hook_event_name;
+  return typeof name === "string" && name.length > 0 ? name : void 0;
+};
+
+export {
+  readHookInput
+};

package/dist/{chunk-UXWEE3QI.js → chunk-ADISVXZL.js}

@@ -1,6 +1,6 @@
 import {
   codexHomeFrom
-} from "./chunk-SEAHGHCE.js";
+} from "./chunk-HVZIHTOO.js";
 
 // src/vscode-config.ts
 import { homedir } from "os";

package/dist/chunk-AXRATIS6.js

@@ -0,0 +1,70 @@
+import {
+  parseVersion
+} from "./chunk-64PXDATC.js";
+
+// src/setup/agent-probe.ts
+import { execSync } from "child_process";
+import { readFileSync, realpathSync } from "fs";
+
+// src/setup/claude-version.ts
+import { dirname, basename, join } from "path";
+var versionFromInstallPath = (path) => {
+  const name = basename(path);
+  return /^\d+\.\d+\.\d+$/.test(name) ? parseVersion(name) : null;
+};
+var versionFromManifest = (probe, binPath) => {
+  let dir = dirname(binPath);
+  for (let depth = 0; depth < 4; depth++) {
+    const raw = probe.readFile(join(dir, "package.json"));
+    if (raw) {
+      try {
+        const { version } = JSON.parse(raw);
+        if (typeof version === "string") {
+          const parsed = parseVersion(version);
+          if (parsed) return parsed;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+};
+var readClaudeVersion = (probe) => {
+  const onPath2 = probe.resolveOnPath();
+  if (!onPath2) return null;
+  const resolved = probe.realpath(onPath2) ?? onPath2;
+  return versionFromInstallPath(resolved) ?? versionFromManifest(probe, resolved);
+};
+
+// src/setup/agent-probe.ts
+var onPath = (name) => {
+  const command = process.platform === "win32" ? "where" : "which";
+  try {
+    const found = execSync(`${command} ${name}`, { encoding: "utf-8", stdio: "pipe", timeout: 5e3 }).split("\n")[0].trim();
+    return found || null;
+  } catch {
+    return null;
+  }
+};
+var realpath = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+};
+var readFile = (path) => {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var detectClaudeVersion = () => readClaudeVersion({ resolveOnPath: () => onPath("claude"), realpath, readFile });
+
+export {
+  detectClaudeVersion
+};