@pushary/agent-hooks 0.20.0 → 0.21.0

package/dist/bin/pushary-clean.js

@@ -8,7 +8,7 @@ import {
   removeCodexHooks,
   removeGeminiSettings,
   removeInstructionBlock
-} from "../chunk-UIBTFZUD.js";
+} from "../chunk-BHAMEPOP.js";
 
 // bin/pushary-clean.ts
 import { existsSync, readFileSync, writeFileSync, rmSync } from "fs";

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

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  denyReasonFrom
+} from "../chunk-N7VXDBQU.js";
 import {
   CODEX_AGENT,
   codexAllow,
@@ -69,6 +72,19 @@ var consumeApproval = (toolUseId) => {
     return false;
   }
 };
+var NOTIFY_TTL_MS = 60 * 1e3;
+var claimNotify = (toolUseId) => {
+  if (!toolUseId) return true;
+  const path = join(APPROVAL_DIR, `notify-${sanitizeId(toolUseId)}`);
+  try {
+    if (existsSync(path) && Date.now() - statSync(path).mtimeMs < NOTIFY_TTL_MS) return false;
+    if (!existsSync(APPROVAL_DIR)) mkdirSync(APPROVAL_DIR, { recursive: true, mode: 448 });
+    writeFileSync(path, "", { encoding: "utf-8", mode: 384 });
+    return true;
+  } catch {
+    return true;
+  }
+};
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var pollForAnswer = async (apiKey, correlationId, deadlineMs, pollInterval = 2e3) => {
   while (Date.now() < deadlineMs) {
@@ -133,7 +149,7 @@ var decidePermissionRequest = async (input) => {
     }
     if (toolPolicy.mode === "terminal_only") return codexPass();
     if (toolPolicy.mode === "notify_only") {
-      await notifyApprovalNeeded(apiKey, input);
+      if (claimNotify(input.tool_use_id)) await notifyApprovalNeeded(apiKey, input);
       return codexPass();
     }
     const waitSeconds = toolPolicy.mode === "push_first" ? toolPolicy.pushFirstSeconds : toolPolicy.timeoutSeconds;
@@ -143,7 +159,7 @@ var decidePermissionRequest = async (input) => {
         if (toolPolicy.mode === "push_only") markApproved(input.tool_use_id);
         return codexAllow();
       }
-      return codexDeny("Denied via push notification");
+      return codexDeny(denyReasonFrom(answer.value));
     }
     savePendingQuestion(input.session_id || DEFAULT_SESSION, correlationId);
     if (toolPolicy.mode === "push_first") return codexPass();
@@ -176,13 +192,13 @@ var decidePreToolUse = async (input) => {
       }
       const { answer, correlationId } = pushed;
       if (answer.answered) {
-        return answer.value === "yes" ? codexPass() : codexDeny("Denied via push notification");
+        return answer.value === "yes" ? codexPass() : codexDeny(denyReasonFrom(answer.value));
       }
       savePendingQuestion(input.session_id || DEFAULT_SESSION, correlationId);
       return preToolUseTimeoutDecision(toolPolicy.timeoutAction);
     }
     if (toolPolicy.mode === "notify_only") {
-      await notifyApprovalNeeded(apiKey, input);
+      if (claimNotify(input.tool_use_id)) await notifyApprovalNeeded(apiKey, input);
       return codexPass();
     }
     return codexPass();

package/dist/bin/pushary-doctor.js

@@ -6,8 +6,9 @@ import {
   hasGeminiHooks,
   hasInstructionBlock,
   missingCodexHookEvents,
-  missingGeminiHookEvents
-} from "../chunk-UIBTFZUD.js";
+  missingGeminiHookEvents,
+  untrustedCodexHookEvents
+} from "../chunk-BHAMEPOP.js";
 import {
   callMcpTool,
   sendMcpRequest
@@ -62,6 +63,20 @@ var extractHookCommand = (entries, needle) => {
   }
   return null;
 };
+var extractHookTimeout = (entries, needle) => {
+  if (!Array.isArray(entries)) return null;
+  for (const entry of entries) {
+    const hookList = entry.hooks;
+    if (!Array.isArray(hookList)) continue;
+    for (const candidate of hookList) {
+      const hook = candidate;
+      if (typeof hook.command === "string" && hook.command.includes(needle) && typeof hook.timeout === "number") {
+        return hook.timeout;
+      }
+    }
+  }
+  return null;
+};
 var results = [];
 var check = (passed, label, detail) => {
   results.push({ passed, label, detail });
@@ -149,15 +164,30 @@ var main = async () => {
   const codexHooksJson = readJson(codexHooksPath);
   if (existsSync(codexConfigPath) || codexHooksJson) {
     const codexConfig = existsSync(codexConfigPath) ? readFileSync(codexConfigPath, "utf-8") : "";
-    const hasPusharyMcp = codexConfig.includes("[mcp_servers.pushary]");
-    check(hasPusharyMcp, "Codex: MCP server configured");
-    if (hasPusharyMcp) {
-      const hasAutoApprove = codexConfig.includes('default_tools_approval_mode = "approve"');
-      check(hasAutoApprove, "Codex: tools auto-allowed", hasAutoApprove ? 'default_tools_approval_mode = "approve"' : "missing \u2014 MCP calls will prompt for approval");
-      const hasPerToolOverrides = /\[mcp_servers\.pushary\.tools\./.test(codexConfig);
-      if (hasPerToolOverrides) {
+    let codexParsed = {};
+    try {
+      codexParsed = parseTOML(codexConfig);
+    } catch {
+    }
+    const codexMcp = codexParsed.mcp_servers?.pushary;
+    const codexTransport = !!codexMcp && (typeof codexMcp.url === "string" || typeof codexMcp.command === "string");
+    const codexEnvVar = codexMcp && typeof codexMcp.bearer_token_env_var === "string" ? codexMcp.bearer_token_env_var : void 0;
+    const codexHasCred = !!codexEnvVar || !!codexMcp && typeof codexMcp.bearer_token === "string";
+    const codexMcpOk = !!codexMcp && codexTransport && codexHasCred;
+    check(codexMcpOk, "Codex: MCP server configured", codexMcpOk ? void 0 : !codexMcp ? "no [mcp_servers.pushary] \u2014 re-run setup" : !codexTransport ? "entry has no url \u2014 `codex mcp add` likely failed, re-run setup" : "entry has no bearer_token/_env_var \u2014 re-run setup");
+    if (codexMcp) {
+      const hasAutoApprove = codexMcp.default_tools_approval_mode === "approve";
+      check(hasAutoApprove, "Codex: tools auto-allowed", hasAutoApprove ? "default_tools_approval_mode = approve" : "missing \u2014 MCP calls will prompt for approval");
+      if (codexMcp.tools && typeof codexMcp.tools === "object") {
         console.log(`  ${warn} Codex: per-tool approval overrides detected ${dim("(redundant with default_tools_approval_mode)")}`);
       }
+      if (codexEnvVar) {
+        const envValue = process.env[codexEnvVar]?.trim();
+        check(!!envValue, `Codex: MCP key available in shell ($${codexEnvVar})`, envValue ? "set" : `not set \u2014 Codex reads its key from your shell; the ~/.pushary/config.json fallback only covers hooks. Add the export to your profile or re-run setup`);
+        if (envValue && apiKey && envValue !== apiKey) {
+          console.log(`  ${warn} Codex: $${codexEnvVar} differs from your active key ${dim("(rotate or re-run setup so hooks and MCP match)")}`);
+        }
+      }
     }
     const codexNotifyPath = codexConfig.match(/["']([^"']*pushary-codex[^"']*)["']/)?.[1] ?? null;
     const hooksInstalled = !!codexHooksJson && hasCodexHooks(codexHooksJson);
@@ -169,18 +199,16 @@ var main = async () => {
         const resolves = commandResolves(hookCommand);
         check(resolves, "Codex: hook command resolves", resolves ? hookCommand : `not on PATH: ${hookCommand}`);
       }
-      let hooksFeatureDisabled = false;
-      try {
-        const parsed = parseTOML(codexConfig);
-        const features = parsed.features;
-        hooksFeatureDisabled = !!features && typeof features === "object" && features.hooks === false;
-      } catch {
-      }
+      const features = codexParsed.features;
+      const hooksFeatureDisabled = !!features && typeof features === "object" && features.hooks === false;
       check(!hooksFeatureDisabled, "Codex: hooks feature enabled", hooksFeatureDisabled ? "[features].hooks = false in config.toml" : void 0);
       if (codexNotifyPath) {
         console.log(`  ${warn} Codex: stale legacy notify entry ${dim("(double-push risk, re-run setup to remove it)")}`);
       }
-      console.log(`  ${warn} Codex: trust the hooks inside Codex ${dim("(type /hooks in Codex and trust them, once; cannot be checked from here)")}`);
+      if (hookCommand) {
+        const untrusted = untrustedCodexHookEvents(codexParsed, codexHooksPath, hookCommand);
+        check(untrusted.length === 0, "Codex: hooks trusted", untrusted.length === 0 ? "all events trusted" : `untrusted (${untrusted.join(", ")}) \u2014 type /hooks in Codex and trust them, once`);
+      }
     } else {
       check(!!codexNotifyPath, "Codex: notify handler configured (deprecated)", codexNotifyPath ? "upgrade Codex and re-run setup for native hooks" : "missing, re-run setup");
       if (codexNotifyPath) {
@@ -203,17 +231,32 @@ var main = async () => {
     if (geminiPushary) {
       check(typeof geminiPushary.httpUrl === "string", "Gemini CLI: MCP transport", geminiPushary.httpUrl ? String(geminiPushary.httpUrl) : "missing \u2014 add httpUrl");
       check(geminiPushary.trust === true, "Gemini CLI: tools auto-allowed", geminiPushary.trust === true ? "trust: true" : "missing \u2014 MCP calls will prompt for confirmation");
+      const geminiAuth = geminiPushary.headers?.Authorization;
+      if (typeof geminiAuth === "string") {
+        if (geminiAuth.includes("${PUSHARY_API_KEY}")) {
+          check(false, "Gemini CLI: API key embedded", "header has an unexpanded ${PUSHARY_API_KEY} \u2014 re-run setup to embed the key");
+        } else if (apiKey && geminiAuth !== `Bearer ${apiKey}`) {
+          check(false, "Gemini CLI: API key matches active key", "embedded key differs from your active key (rotated?) \u2014 re-run setup");
+        } else {
+          check(true, "Gemini CLI: API key embedded");
+        }
+      }
     }
     const geminiHooksInstalled = hasGeminiHooks(geminiSettings);
     if (geminiHooksInstalled) {
       const missingEvents = missingGeminiHookEvents(geminiSettings);
       check(missingEvents.length === 0, "Gemini CLI: native hooks installed", missingEvents.length === 0 ? "all 5 events" : `missing ${missingEvents.join(", ")}, re-run setup`);
       const geminiHooks = geminiSettings.hooks;
-      const hookCommand = extractHookCommand(geminiHooks?.BeforeTool, GEMINI_HOOK_BINARY);
+      const hookCommand = extractHookCommand(geminiHooks?.BeforeTool, GEMINI_HOOK_BINARY) ?? extractHookCommand(geminiHooks?.AfterTool, GEMINI_HOOK_BINARY) ?? extractHookCommand(geminiHooks?.SessionStart, GEMINI_HOOK_BINARY);
       if (hookCommand) {
         const resolves = commandResolves(hookCommand);
         check(resolves, "Gemini CLI: hook command resolves", resolves ? hookCommand : `not on PATH: ${hookCommand}`);
       }
+      const geminiTimeout = extractHookTimeout(geminiHooks?.BeforeTool, GEMINI_HOOK_BINARY);
+      if (typeof geminiTimeout === "number") {
+        const ok = geminiTimeout >= 3e4;
+        check(ok, "Gemini CLI: hook timeout", ok ? `${geminiTimeout}ms` : `${geminiTimeout}ms too short (Gemini timeouts are milliseconds) \u2014 re-run setup`);
+      }
     } else {
       check(false, "Gemini CLI: native hooks installed", "no Pushary hooks in ~/.gemini/settings.json \u2014 re-run setup");
     }

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

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  denyReasonFrom
+} from "../chunk-N7VXDBQU.js";
 import {
   handlePostToolUse,
   handleStop,
@@ -64,7 +67,6 @@ var geminiTimeoutDecision = (timeoutAction, denyReason = "No response within tim
 var KILL_REASON = "Stopped by user: this agent was halted from Pushary";
 var MAX_WAIT_SECONDS = 170;
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var denyReasonFrom = (value) => value && value !== "no" && value !== "yes" ? `Denied from your phone: ${value}` : "Denied via push notification";
 var pollForAnswer = async (apiKey, correlationId, deadlineMs, pollInterval = 2e3) => {
   while (Date.now() < deadlineMs) {
     const remaining = Math.min(Math.max(deadlineMs - Date.now(), 1e3), 3e4);

package/dist/bin/pushary-hook.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import {
   handlePreToolUse
-} from "../chunk-SDREQWNI.js";
+} from "../chunk-FXYTRZHC.js";
+import "../chunk-N7VXDBQU.js";
 import "../chunk-ACE77TKQ.js";
 import "../chunk-USUCPCUC.js";
 import "../chunk-DWED7BS3.js";

package/dist/bin/pushary-setup.js

@@ -14,7 +14,7 @@ import {
   npmErrorMessage,
   renderAgentInstructions,
   writeInstructionBlock
-} from "../chunk-UIBTFZUD.js";
+} from "../chunk-BHAMEPOP.js";
 import {
   isValidApiKey
 } from "../chunk-USUCPCUC.js";
@@ -541,7 +541,7 @@ var setupHermes = async (_apiKey) => {
 };
 var CODEX_HOOKS_JSON = join(CODEX_HOME, "hooks.json");
 var CODEX_HOOKS_MIN_VERSION = [0, 122, 0];
-var CODEX_TRUST_VERIFIED_MAX = [0, 138, 0];
+var CODEX_TRUST_VERIFIED_MAX = [0, 142, 2];
 var parseCodexVersion = (raw) => {
   const match = raw.match(/(\d+)\.(\d+)\.(\d+)/);
   if (!match) return null;

package/dist/chunk-BHAMEPOP.js

@@ -0,0 +1,323 @@
+// src/codex-config.ts
+import { createHash } from "crypto";
+var CODEX_HOOK_BINARY = "pushary-codex-hook";
+var CODEX_HOOK_EVENTS = [
+  { event: "PermissionRequest", matcher: "Bash|apply_patch", timeout: 180, statusMessage: "Waiting for your phone" },
+  { event: "PreToolUse", matcher: "Bash|apply_patch", timeout: 180, statusMessage: "Checking Pushary policy" },
+  { event: "PostToolUse", matcher: "Bash|apply_patch", timeout: 10 },
+  { event: "UserPromptSubmit", timeout: 10 },
+  { event: "Stop", timeout: 10 },
+  { event: "SessionStart", matcher: "startup|resume", timeout: 10 }
+];
+var CODEX_EVENT_KEY = {
+  PermissionRequest: "permission_request",
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  UserPromptSubmit: "user_prompt_submit",
+  Stop: "stop",
+  SessionStart: "session_start"
+};
+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 isPusharyCodexHook = (entry) => {
+  const hooks = asRecord(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => String(asRecord(hook)?.command ?? "").includes(CODEX_HOOK_BINARY));
+};
+var addCodexHooks = (config, command) => {
+  const hooks = ensureRecord(config, "hooks");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[definition.event]) ? hooks[definition.event] : [];
+    const entries = existing.filter((entry) => !isPusharyCodexHook(entry));
+    entries.push({
+      ...definition.matcher ? { matcher: definition.matcher } : {},
+      hooks: [{
+        type: "command",
+        command,
+        timeout: definition.timeout,
+        ...definition.statusMessage ? { statusMessage: definition.statusMessage } : {}
+      }]
+    });
+    hooks[definition.event] = entries;
+  }
+};
+var removeCodexHooks = (config) => {
+  const hooks = asRecord(config.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry) => !isPusharyCodexHook(entry));
+    if (filtered.length !== entries.length) {
+      if (filtered.length === 0) {
+        delete hooks[definition.event];
+      } else {
+        hooks[definition.event] = filtered;
+      }
+      changed = true;
+    }
+  }
+  if (Object.keys(hooks).length === 0) delete config.hooks;
+  return changed;
+};
+var hasCodexHooks = (config) => {
+  const hooks = asRecord(config.hooks);
+  if (!hooks) return false;
+  return CODEX_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some(isPusharyCodexHook);
+  });
+};
+var missingCodexHookEvents = (config) => {
+  const hooks = asRecord(config.hooks);
+  return CODEX_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some(isPusharyCodexHook);
+  }).map((definition) => definition.event);
+};
+var canonicalJson = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
+  const obj = value;
+  return "{" + Object.keys(obj).sort().map((key) => JSON.stringify(key) + ":" + canonicalJson(obj[key])).join(",") + "}";
+};
+var codexHookTrustHash = (definition, command) => {
+  const hook = { async: false, command, timeout: definition.timeout, type: "command" };
+  if (definition.statusMessage) hook.statusMessage = definition.statusMessage;
+  const identity = { event_name: CODEX_EVENT_KEY[definition.event], hooks: [hook] };
+  if (definition.matcher) identity.matcher = definition.matcher;
+  return "sha256:" + createHash("sha256").update(canonicalJson(identity), "utf8").digest("hex");
+};
+var codexHookStateKey = (hooksJsonPath, event) => `${hooksJsonPath}:${CODEX_EVENT_KEY[event]}:0:0`;
+var untrustedCodexHookEvents = (config, hooksJsonPath, command) => {
+  const state = asRecord(asRecord(config.hooks)?.state);
+  return CODEX_HOOK_EVENTS.filter((definition) => {
+    const entry = asRecord(state?.[codexHookStateKey(hooksJsonPath, definition.event)]);
+    const stored = entry?.trusted_hash;
+    return stored !== codexHookTrustHash(definition, command);
+  }).map((definition) => definition.event);
+};
+var addCodexHookTrust = (config, hooksJsonPath, command) => {
+  const hooks = ensureRecord(config, "hooks");
+  const state = ensureRecord(hooks, "state");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const key = codexHookStateKey(hooksJsonPath, definition.event);
+    const existing = asRecord(state[key]) ?? {};
+    state[key] = { ...existing, trusted_hash: codexHookTrustHash(definition, command) };
+  }
+};
+
+// 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", timeoutMs: 18e4 },
+  { event: "AfterTool", matcher: "run_shell_command|write_file|replace", timeoutMs: 1e4 },
+  { event: "BeforeAgent", timeoutMs: 1e4 },
+  { event: "SessionStart", timeoutMs: 1e4 },
+  { event: "SessionEnd", timeoutMs: 1e4 }
+];
+var asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord2 = (target, key) => {
+  const existing = asRecord2(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyGeminiHook = (entry) => {
+  const hooks = asRecord2(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => String(asRecord2(hook)?.command ?? "").includes(GEMINI_HOOK_BINARY));
+};
+var addGeminiMcpServer = (settings, apiKey) => {
+  const mcpServers = ensureRecord2(settings, "mcpServers");
+  mcpServers.pushary = {
+    httpUrl: GEMINI_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` },
+    trust: true
+  };
+};
+var addGeminiHooks = (settings, command) => {
+  const hooks = ensureRecord2(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) => {
+  const hooks = asRecord2(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));
+    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 = asRecord2(settings.mcpServers);
+  if (!mcpServers?.pushary) return false;
+  delete mcpServers.pushary;
+  if (Object.keys(mcpServers).length === 0) delete settings.mcpServers;
+  return true;
+};
+var removeGeminiSettings = (settings) => {
+  const mcpRemoved = removeGeminiMcpServer(settings);
+  const hooksRemoved = removeGeminiHooks(settings);
+  return mcpRemoved || hooksRemoved;
+};
+var hasGeminiHooks = (settings) => {
+  const hooks = asRecord2(settings.hooks);
+  if (!hooks) return false;
+  return GEMINI_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some(isPusharyGeminiHook);
+  });
+};
+var missingGeminiHookEvents = (settings) => {
+  const hooks = asRecord2(settings.hooks);
+  return GEMINI_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some(isPusharyGeminiHook);
+  }).map((definition) => definition.event);
+};
+
+// src/instruction-file.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { dirname } from "path";
+var PUSHARY_BEGIN = "<!-- BEGIN PUSHARY (managed by @pushary/agent-hooks; do not edit this block) -->";
+var PUSHARY_END = "<!-- END PUSHARY -->";
+var instructionBody = (label) => `## Pushary notifications and approvals
+
+You have Pushary MCP tools that reach the user on their phone. Use them proactively. Do not wait for the user to ask.
+
+- When you need the user to make a decision or answer a clarifying question, call \`ask_user\` instead of guessing or stalling. Use type "confirm" for yes/no, "select" for a fixed set of options, and "input" for free text. \`ask_user\` blocks until the user replies or it times out, so you do not need a separate wait step.
+- Before any risky or irreversible step (deleting files, force pushing, spending money, sending external messages), call \`ask_user\` with type "confirm" and wait for approval.
+- When you are blocked, stuck, or hit an error you cannot resolve on your own, call \`send_notification\` so the user knows, and call \`ask_user\` if you need a decision to continue.
+- When a task that took several steps finishes, call \`send_notification\` so the user knows it is done.
+- Use \`cancel_question\` to retract a pending question once it is no longer needed.
+
+Pass \`agentName\` as "${label} - <project folder name>" so the user knows which session is asking. If a question times out with no answer, retry once with a longer timeout before falling back to asking in the terminal.`;
+var renderAgentInstructions = (label) => instructionBody(label);
+var wrap = (body) => `${PUSHARY_BEGIN}
+${body}
+${PUSHARY_END}`;
+var writeInstructionBlock = (filePath, body) => {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+  }
+  const block = wrap(body);
+  const start = existing.indexOf(PUSHARY_BEGIN);
+  const end = existing.indexOf(PUSHARY_END);
+  let next;
+  if (start !== -1 && end !== -1 && end > start) {
+    next = existing.slice(0, start) + block + existing.slice(end + PUSHARY_END.length);
+  } else {
+    const prefix = existing.trim() ? existing.replace(/\s*$/, "") + "\n\n" : "";
+    next = prefix + block + "\n";
+  }
+  writeFileSync(filePath, next, "utf-8");
+};
+var removeInstructionBlock = (filePath) => {
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+    return false;
+  }
+  const start = existing.indexOf(PUSHARY_BEGIN);
+  const end = existing.indexOf(PUSHARY_END);
+  if (start === -1 || end === -1 || end < start) return false;
+  const remaining = (existing.slice(0, start) + existing.slice(end + PUSHARY_END.length)).trim();
+  if (remaining === "") {
+    rmSync(filePath, { force: true });
+  } else {
+    writeFileSync(filePath, remaining + "\n", "utf-8");
+  }
+  return true;
+};
+var hasInstructionBlock = (filePath) => {
+  try {
+    return readFileSync(filePath, "utf-8").includes(PUSHARY_BEGIN);
+  } catch {
+    return false;
+  }
+};
+
+// src/npm.ts
+import { execSync } from "child_process";
+var cleanNpmEnv = () => {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.toLowerCase().startsWith("npm_config_workspace")) continue;
+    env[key] = value;
+  }
+  return env;
+};
+var npmErrorMessage = (err) => {
+  const e = err;
+  const text = [e?.stderr, e?.stdout].map((part) => part ? part.toString() : "").join("\n");
+  const line = text.split("\n").map((l) => l.replace(/^npm error\s*/i, "").trim()).find((l) => l && !l.startsWith("A complete log") && !/^code\s/i.test(l));
+  return line || e?.message || String(err);
+};
+var execNpm = (args, options = {}) => {
+  return execSync(`npm ${args}`, {
+    timeout: 12e4,
+    stdio: "pipe",
+    ...options,
+    env: { ...cleanNpmEnv(), ...options.env ?? {} }
+  });
+};
+
+export {
+  addCodexHooks,
+  removeCodexHooks,
+  hasCodexHooks,
+  missingCodexHookEvents,
+  untrustedCodexHookEvents,
+  addCodexHookTrust,
+  GEMINI_HOOK_BINARY,
+  addGeminiMcpServer,
+  addGeminiHooks,
+  removeGeminiSettings,
+  hasGeminiHooks,
+  missingGeminiHookEvents,
+  renderAgentInstructions,
+  writeInstructionBlock,
+  removeInstructionBlock,
+  hasInstructionBlock,
+  npmErrorMessage,
+  execNpm
+};

package/dist/chunk-FXYTRZHC.js

@@ -0,0 +1,177 @@
+import {
+  denyReasonFrom
+} from "./chunk-N7VXDBQU.js";
+import {
+  DEFAULT_SESSION,
+  askUser,
+  deriveToolTarget,
+  describeToolCall,
+  fetchModeState,
+  getMachineId,
+  getPolicy,
+  resolvePolicy,
+  savePendingQuestion,
+  sendNotification,
+  waitForAnswer
+} from "./chunk-ACE77TKQ.js";
+import {
+  getApiKey
+} from "./chunk-NKXSILEW.js";
+
+// src/hook.ts
+import { basename } from "path";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var allow = () => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "allow"
+  }
+});
+var deny = (reason) => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "deny",
+    permissionDecisionReason: reason
+  }
+});
+var ask = (reason) => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "ask",
+    ...reason ? { permissionDecisionReason: reason } : {}
+  }
+});
+var pollForAnswer = async (apiKey, correlationId, deadlineMs, pollInterval = 2e3) => {
+  while (Date.now() < deadlineMs) {
+    const remaining = Math.min(Math.max(deadlineMs - Date.now(), 1e3), 3e4);
+    let answer;
+    try {
+      answer = await waitForAnswer(apiKey, correlationId, remaining);
+    } catch {
+      if (Date.now() + pollInterval >= deadlineMs) break;
+      await sleep(pollInterval);
+      continue;
+    }
+    if (answer.answered) return answer;
+    if (Date.now() + pollInterval >= deadlineMs) break;
+    await sleep(pollInterval);
+  }
+  return { answered: false };
+};
+var handlePushOnly = async (apiKey, description, projectName, timeoutSeconds, timeoutAction, sessionId, machineId, toolName, toolTarget) => {
+  let result;
+  try {
+    result = await askUser(apiKey, {
+      question: `Allow ${description}?`,
+      type: "confirm",
+      context: `Agent wants to run this in ${projectName}`,
+      agentName: `Claude Code - ${projectName}`,
+      sessionId,
+      machineId,
+      toolName,
+      toolTarget
+    });
+  } catch {
+    switch (timeoutAction) {
+      case "approve":
+        return allow();
+      case "deny":
+        return deny("Push notification failed, denying per policy");
+      default:
+        return ask("Push notification failed, asking in terminal");
+    }
+  }
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  const answer = await pollForAnswer(apiKey, result.correlationId, deadline);
+  if (answer.answered) {
+    return answer.value === "yes" ? allow() : deny(denyReasonFrom(answer.value));
+  }
+  switch (timeoutAction) {
+    case "approve":
+      return allow();
+    case "deny":
+      return deny("No response within timeout");
+    default:
+      return ask("No push response, asking in terminal");
+  }
+};
+var handleTerminalOnly = () => {
+  return ask();
+};
+var handlePushFirst = async (apiKey, description, projectName, pushFirstSeconds, sessionId, machineId, toolName, toolTarget) => {
+  let result;
+  try {
+    result = await askUser(apiKey, {
+      question: `Allow ${description}?`,
+      type: "confirm",
+      context: `Agent wants to run this in ${projectName}`,
+      agentName: `Claude Code - ${projectName}`,
+      sessionId,
+      machineId,
+      toolName,
+      toolTarget
+    });
+  } catch {
+    return ask("Push notification failed, asking in terminal");
+  }
+  const deadline = Date.now() + pushFirstSeconds * 1e3;
+  const answer = await pollForAnswer(apiKey, result.correlationId, deadline, 1500);
+  if (answer.answered) {
+    return answer.value === "yes" ? allow() : deny(denyReasonFrom(answer.value));
+  }
+  savePendingQuestion(sessionId || DEFAULT_SESSION, result.correlationId);
+  return ask("Sent as push notification. You can also approve here.");
+};
+var handleNotifyOnly = async (apiKey, description, projectName, sessionId, machineId) => {
+  try {
+    await sendNotification(apiKey, {
+      title: "Agent needs approval",
+      body: description,
+      agentName: `Claude Code - ${projectName}`,
+      sessionId,
+      machineId
+    });
+  } catch {
+  }
+  return ask();
+};
+var handlePreToolUse = async (input) => {
+  try {
+    const apiKey = getApiKey();
+    const modeState = await fetchModeState(apiKey, input.session_id);
+    const policy = await getPolicy(apiKey, modeState.policyVersion);
+    if (modeState.kill) {
+      return deny("Stopped by user \u2014 this agent was halted from Pushary");
+    }
+    const toolPolicy = resolvePolicy(policy, input.tool_name, modeState.mode, input.tool_input);
+    if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "approve") {
+      return allow();
+    }
+    if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "deny") {
+      return deny(`Denied by policy for ${toolPolicy.tool}`);
+    }
+    const description = describeToolCall(input.tool_name, input.tool_input, "hook");
+    const projectName = basename(input.cwd ?? process.cwd());
+    const sessionId = input.session_id;
+    const machineId = getMachineId();
+    const toolTarget = deriveToolTarget(input.tool_name, input.tool_input);
+    switch (toolPolicy.mode) {
+      case "push_only":
+        return handlePushOnly(apiKey, description, projectName, toolPolicy.timeoutSeconds, toolPolicy.timeoutAction, sessionId, machineId, input.tool_name, toolTarget);
+      case "terminal_only":
+        return handleTerminalOnly();
+      case "push_first":
+        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds, sessionId, machineId, input.tool_name, toolTarget);
+      case "notify_only":
+        return handleNotifyOnly(apiKey, description, projectName, sessionId, machineId);
+      default:
+        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds, sessionId, machineId, input.tool_name, toolTarget);
+    }
+  } catch {
+    return ask("Pushary unavailable, falling back to terminal approval");
+  }
+};
+
+export {
+  handlePreToolUse
+};

package/dist/chunk-N7VXDBQU.js

@@ -0,0 +1,6 @@
+// src/answer.ts
+var denyReasonFrom = (value) => value && value !== "no" && value !== "yes" ? `Denied from your phone: ${value}` : "Denied via push notification";
+
+export {
+  denyReasonFrom
+};

package/dist/src/index.js

@@ -1,6 +1,7 @@
 import {
   handlePreToolUse
-} from "../chunk-SDREQWNI.js";
+} from "../chunk-FXYTRZHC.js";
+import "../chunk-N7VXDBQU.js";
 import {
   handleNotification,
   handlePostToolUse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "author": "Pushary <business@pushary.com>",
   "homepage": "https://pushary.com",