@pushary/agent-hooks 0.23.0 → 0.25.0

package/dist/chunk-YTMKB44I.js

@@ -0,0 +1,220 @@
+import {
+  askUser,
+  describeToolCall,
+  isPolicyConfig,
+  savePendingQuestion,
+  sendNotification,
+  waitForAnswer
+} from "./chunk-4Z4MB37G.js";
+import {
+  getApiKey,
+  getBaseUrl,
+  withRetry
+} from "./chunk-O6A5RHWY.js";
+
+// src/policy.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var cacheFile = (apiKey) => {
+  const hash = createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
+  return join(tmpdir(), `pushary-policy-${hash}.json`);
+};
+var fetchPolicy = async (apiKey) => {
+  return withRetry(async () => {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/api/mcp/policy`, {
+      headers: { "Authorization": `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch policy: ${response.status}`);
+    }
+    const raw = await response.json();
+    if (!isPolicyConfig(raw)) throw new Error("Invalid policy response");
+    return raw;
+  }, { maxAttempts: 2 });
+};
+var getPolicy = async (apiKey) => {
+  const path = cacheFile(apiKey);
+  let staleCache = null;
+  if (existsSync(path)) {
+    try {
+      const stat = readFileSync(path, "utf-8");
+      const cached = JSON.parse(stat);
+      if (!isPolicyConfig(cached)) throw new Error("Corrupted cache");
+      if (!cached._cachedAt || Date.now() - cached._cachedAt < CACHE_TTL_MS) {
+        return cached;
+      }
+      staleCache = cached;
+    } catch {
+    }
+  }
+  try {
+    const policy = await fetchPolicy(apiKey);
+    try {
+      writeFileSync(path, JSON.stringify({ ...policy, _cachedAt: Date.now() }), "utf-8");
+    } catch {
+    }
+    return policy;
+  } catch {
+    if (staleCache) return staleCache;
+    throw new Error("Failed to fetch policy and no cached policy available");
+  }
+};
+var resolvePolicy = (config, toolName, modeOverride) => {
+  const base = config.policies.find((p) => p.tool === toolName) ?? config.policies.find((p) => p.tool === "*") ?? {
+    tool: toolName,
+    timeoutSeconds: config.defaultTimeoutSeconds,
+    timeoutAction: config.defaultTimeoutAction,
+    mode: config.defaultMode ?? "push_first",
+    pushFirstSeconds: config.defaultPushFirstSeconds ?? 20
+  };
+  const effectiveOverride = modeOverride ?? config.modeOverride;
+  if (effectiveOverride) {
+    return { ...base, mode: effectiveOverride };
+  }
+  return base;
+};
+
+// 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) => {
+  let result;
+  try {
+    result = await askUser(apiKey, {
+      question: `Allow ${description}?`,
+      type: "confirm",
+      context: `Agent wants to run this in ${projectName}`,
+      agentName: `Claude Code - ${projectName}`
+    });
+  } 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("Denied via push notification");
+  }
+  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) => {
+  let result;
+  try {
+    result = await askUser(apiKey, {
+      question: `Allow ${description}?`,
+      type: "confirm",
+      context: `Agent wants to run this in ${projectName}`,
+      agentName: `Claude Code - ${projectName}`
+    });
+  } 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("Denied via push notification");
+  }
+  savePendingQuestion(result.correlationId);
+  return ask("Sent as push notification. You can also approve here.");
+};
+var handleNotifyOnly = async (apiKey, description, projectName) => {
+  try {
+    await sendNotification(apiKey, {
+      title: "Agent needs approval",
+      body: description,
+      agentName: `Claude Code - ${projectName}`
+    });
+  } catch {
+  }
+  return ask();
+};
+var handlePreToolUse = async (input) => {
+  try {
+    const apiKey = getApiKey();
+    const policy = await getPolicy(apiKey);
+    const toolPolicy = resolvePolicy(policy, input.tool_name);
+    if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "approve") {
+      return allow();
+    }
+    const description = describeToolCall(input.tool_name, input.tool_input, "hook");
+    const projectName = basename(input.cwd ?? process.cwd());
+    switch (toolPolicy.mode) {
+      case "push_only":
+        return handlePushOnly(apiKey, description, projectName, toolPolicy.timeoutSeconds, toolPolicy.timeoutAction);
+      case "terminal_only":
+        return handleTerminalOnly();
+      case "push_first":
+        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds);
+      case "notify_only":
+        return handleNotifyOnly(apiKey, description, projectName);
+      default:
+        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds);
+    }
+  } catch {
+    return ask("Pushary unavailable, falling back to terminal approval");
+  }
+};
+
+export {
+  getPolicy,
+  resolvePolicy,
+  handlePreToolUse
+};

package/dist/chunk-ZWBS3T7Q.js

@@ -0,0 +1,244 @@
+// 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 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/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,
+  addCodexHookTrust,
+  GEMINI_HOOK_BINARY,
+  addGeminiMcpServer,
+  addGeminiHooks,
+  removeGeminiSettings,
+  hasGeminiHooks,
+  missingGeminiHookEvents,
+  npmErrorMessage,
+  execNpm
+};

package/dist/pushary-mode-T7XOPI6Z.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-VUNL35KE.js";
+
+// bin/pushary-mode.ts
+var VALID_MODES = ["push_only", "push_first", "terminal_only", "notify_only"];
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var parseDuration = (value) => {
+  const match = value.match(/^(\d+)(m|h)$/);
+  if (!match) return null;
+  const num = Number(match[1]);
+  return match[2] === "h" ? num * 3600 : num * 60;
+};
+var main = async () => {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  const mode = process.argv[2];
+  const forFlag = process.argv[3];
+  const forValue = process.argv[4];
+  const headers = {
+    "Authorization": `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  if (!mode || mode === "status") {
+    const res2 = await fetch(`${baseUrl}/api/mcp/mode`, { headers });
+    const data2 = await res2.json();
+    if (!data2.override) {
+      console.log(`  Mode: ${cyan("default")} ${dim("(using per-tool policies)")}`);
+    } else {
+      console.log(`  Mode: ${green(data2.override.mode)}`);
+      if (data2.override.expiresAt) {
+        console.log(`  Expires: ${new Date(data2.override.expiresAt).toLocaleString()}`);
+      } else {
+        console.log(`  ${dim("Sticky (no expiry)")}`);
+      }
+    }
+    return;
+  }
+  if (mode === "clear" || mode === "reset") {
+    await fetch(`${baseUrl}/api/mcp/mode`, { method: "DELETE", headers });
+    console.log(`  ${green("\u2713")} Mode override cleared \u2014 using per-tool policies`);
+    return;
+  }
+  if (!VALID_MODES.includes(mode)) {
+    console.log(`  ${yellow("!")} Invalid mode: ${mode}`);
+    console.log(`  Valid modes: ${VALID_MODES.join(", ")}`);
+    console.log(`  ${dim("Usage: pushary mode <mode> [--for <duration>]")}`);
+    console.log(`  ${dim("Example: pushary mode push_only --for 30m")}`);
+    return;
+  }
+  let ttlSeconds;
+  if (forFlag === "--for" && forValue) {
+    ttlSeconds = parseDuration(forValue);
+    if (!ttlSeconds) {
+      console.log(`  ${yellow("!")} Invalid duration: ${forValue} ${dim("(use e.g. 30m, 1h)")}`);
+      return;
+    }
+  }
+  const res = await fetch(`${baseUrl}/api/mcp/mode`, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({ mode, ttlSeconds })
+  });
+  if (!res.ok) {
+    const err = await res.json();
+    console.log(`  ${yellow("!")} Failed: ${err.error ?? res.statusText}`);
+    return;
+  }
+  const data = await res.json();
+  console.log(`  ${green("\u2713")} Mode set to ${cyan(data.override.mode)}`);
+  if (data.override.expiresAt) {
+    console.log(`  Expires: ${new Date(data.override.expiresAt).toLocaleString()}`);
+  }
+};
+main().catch((err) => {
+  console.error(`  ${yellow("!")} ${err instanceof Error ? err.message : err}`);
+  process.exit(1);
+});

package/dist/src/index.d.ts

@@ -24,6 +24,17 @@ interface ReceiptMeta {
     ok: boolean;
 }
 
+declare const getPolicy: (apiKey: string, expectedVersion?: string | null) => Promise<PolicyConfig>;
+type AutoResolveOrigin = 'safe_readonly' | 'policy_timeout';
+declare const resolvePolicy: (config: PolicyConfig, toolName: string, modeOverride?: ApprovalMode | null, toolInput?: Record<string, unknown>) => ToolPolicy;
+interface ModeState {
+    readonly mode: ApprovalMode | null;
+    readonly kill: boolean;
+    readonly policyVersion: string | null;
+}
+declare const fetchModeState: (apiKey: string, sessionId?: string) => Promise<ModeState>;
+declare const fetchModeOverride: (apiKey: string) => Promise<ApprovalMode | null>;
+
 interface UsageReport {
     readonly tokensIn: number;
     readonly tokensOut: number;
@@ -46,6 +57,10 @@ interface AgentEvent {
     error?: string;
     taskTitle?: string;
     decisionSource?: DecisionSource;
+    decisionOrigin?: AutoResolveOrigin;
+    toolName?: string;
+    toolTarget?: string;
+    agents?: readonly string[];
     meta?: ReceiptMeta;
     usage?: UsageReport;
 }
@@ -111,16 +126,6 @@ declare const askUser: (apiKey: string, params: AskUserParams, timeoutMs?: numbe
 declare const waitForAnswer: (apiKey: string, correlationId: string, timeoutMs?: number) => Promise<WaitForAnswerResponse>;
 declare const cancelQuestion: (apiKey: string, correlationId: string) => Promise<void>;
 
-declare const getPolicy: (apiKey: string, expectedVersion?: string | null) => Promise<PolicyConfig>;
-declare const resolvePolicy: (config: PolicyConfig, toolName: string, modeOverride?: ApprovalMode | null, toolInput?: Record<string, unknown>) => ToolPolicy;
-interface ModeState {
-    readonly mode: ApprovalMode | null;
-    readonly kill: boolean;
-    readonly policyVersion: string | null;
-}
-declare const fetchModeState: (apiKey: string, sessionId?: string) => Promise<ModeState>;
-declare const fetchModeOverride: (apiKey: string) => Promise<ApprovalMode | null>;
-
 declare const getApiKey: () => string;
 declare const getBaseUrl: () => string;
 

package/dist/src/index.js

@@ -1,6 +1,6 @@
 import {
   handlePreToolUse
-} from "../chunk-FGZZRCOG.js";
+} from "../chunk-O2QL6U6G.js";
 import "../chunk-KQYIHZ5E.js";
 import {
   askUser,
@@ -14,8 +14,7 @@ import {
   reportEvent,
   resolvePolicy,
   waitForAnswer
-} from "../chunk-M4GDBGXF.js";
-import "../chunk-WPVL6VIT.js";
+} from "../chunk-GYPPVD3P.js";
 import "../chunk-DWED7BS3.js";
 import {
   getApiKey,

package/package.json

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