@pushary/agent-hooks 0.12.0 → 0.14.0

package/dist/chunk-TRLBBLSS.js

@@ -0,0 +1,176 @@
+import {
+  DEFAULT_SESSION,
+  askUser,
+  deriveToolTarget,
+  describeToolCall,
+  fetchModeState,
+  getMachineId,
+  getPolicy,
+  resolvePolicy,
+  savePendingQuestion,
+  sendNotification,
+  waitForAnswer
+} from "./chunk-QRXWPZKN.js";
+import {
+  getApiKey
+} from "./chunk-VUNL35KE.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("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, 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("Denied via push notification");
+  }
+  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 [policy, modeState] = await Promise.all([
+      getPolicy(apiKey),
+      fetchModeState(apiKey, input.session_id)
+    ]);
+    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-WCGKLHCL.js

@@ -0,0 +1,154 @@
+import {
+  DEFAULT_SESSION,
+  cancelQuestion,
+  describeToolCall,
+  getMachineId,
+  isDefaultSession,
+  isPolicyConfig,
+  listPendingQuestions,
+  removePendingQuestion,
+  removePendingSession,
+  resolvePolicy
+} from "./chunk-CH53PBQN.js";
+import {
+  withRetry
+} from "./chunk-3MIR7ODJ.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-VUNL35KE.js";
+
+// src/events.ts
+import { basename, join } from "path";
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { tmpdir } from "os";
+var cleanupPendingQuestions = async (sessionId) => {
+  try {
+    const files = listPendingQuestions(sessionId);
+    const apiKey = getApiKey();
+    for (const correlationId of files) {
+      try {
+        await cancelQuestion(apiKey, correlationId);
+      } catch {
+      }
+      removePendingQuestion(sessionId, correlationId);
+    }
+    if (!isDefaultSession(sessionId)) removePendingSession(sessionId);
+  } catch {
+  }
+};
+var POLICY_CACHE_TTL_MS = 5 * 60 * 1e3;
+var readFreshCachedPolicy = (apiKey) => {
+  const hash = createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
+  const path = join(tmpdir(), `pushary-policy-${hash}.json`);
+  if (!existsSync(path)) return null;
+  const cached = JSON.parse(readFileSync(path, "utf-8"));
+  if (!isPolicyConfig(cached)) return null;
+  if (!cached._cachedAt || Date.now() - cached._cachedAt >= POLICY_CACHE_TTL_MS) return null;
+  return cached;
+};
+var deriveDecisionSource = (toolName, toolInput) => {
+  try {
+    const policy = readFreshCachedPolicy(getApiKey());
+    if (!policy) return void 0;
+    const resolved = resolvePolicy(policy, toolName, null, toolInput);
+    if (resolved.timeoutSeconds === 0 && resolved.timeoutAction === "approve") return "policy_auto";
+    if (resolved.mode === "push_only" || resolved.mode === "push_first") return "human";
+    return "terminal";
+  } catch {
+    return void 0;
+  }
+};
+var reportEvent = async (event, options = {}) => {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  await withRetry(async () => {
+    await fetch(`${baseUrl}/api/agent/event`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        ...event,
+        machineId: event.machineId ?? getMachineId()
+      }),
+      signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
+    });
+  }, { maxAttempts: options.maxAttempts ?? 2, baseDelayMs: 300 });
+};
+var handlePostToolUse = async (input) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    const action = describeToolCall(input.tool_name, input.tool_input, "event");
+    const isError = input.tool_result && ("error" in input.tool_result || "is_error" in input.tool_result);
+    await Promise.allSettled([
+      cleanupPendingQuestions(input.session_id || DEFAULT_SESSION),
+      reportEvent({
+        event: isError ? "tool_error" : "tool_complete",
+        agentType: "claude_code",
+        agentName: `Claude Code - ${projectName}`,
+        action,
+        sessionId: input.session_id,
+        error: isError ? String(input.tool_result?.error ?? input.tool_result?.stderr ?? "").slice(0, 500) : void 0,
+        decisionSource: deriveDecisionSource(input.tool_name, input.tool_input)
+      })
+    ]);
+  } catch {
+  }
+};
+var TASK_TITLE_MAX_LENGTH = 120;
+var handleUserPrompt = async (input) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    const titlesEnabled = process.env.PUSHARY_TASK_TITLES !== "off";
+    const taskTitle = titlesEnabled ? input.prompt?.replace(/\s+/g, " ").trim().slice(0, TASK_TITLE_MAX_LENGTH) || void 0 : void 0;
+    await reportEvent({
+      event: "user_prompt",
+      agentType: "claude_code",
+      agentName: `Claude Code - ${projectName}`,
+      sessionId: input.session_id,
+      taskTitle
+    }, { maxAttempts: 1, timeoutMs: 800 });
+  } catch {
+  }
+};
+var handleStop = async (input) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    await Promise.allSettled([
+      cleanupPendingQuestions(input.session_id || DEFAULT_SESSION),
+      reportEvent({
+        event: "session_end",
+        agentType: "claude_code",
+        agentName: `Claude Code - ${projectName}`,
+        action: "Session ended",
+        sessionId: input.session_id
+      })
+    ]);
+  } catch {
+  }
+};
+var handleNotification = async (input) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    await reportEvent({
+      event: input.type === "error" ? "error" : "notification",
+      agentType: "claude_code",
+      agentName: `Claude Code - ${projectName}`,
+      action: input.title ?? input.message ?? "Notification",
+      sessionId: input.session_id,
+      error: input.type === "error" ? input.message : void 0
+    });
+  } catch {
+  }
+};
+
+export {
+  reportEvent,
+  handlePostToolUse,
+  handleUserPrompt,
+  handleStop,
+  handleNotification
+};

package/dist/src/index.d.ts

@@ -16,6 +16,18 @@ interface HookOutput {
 }
 declare const handlePreToolUse: (input: ToolInput) => Promise<HookOutput>;
 
+type ReceiptKind = 'edit' | 'write' | 'bash' | 'commit';
+interface ReceiptMeta {
+    kind: ReceiptKind;
+    target: string;
+    ok: boolean;
+}
+
+type DecisionSource = 'policy_auto' | 'human' | 'terminal';
+interface AgentIdentity {
+    readonly type: string;
+    readonly label: string;
+}
 interface AgentEvent {
     event: string;
     agentType: string;
@@ -24,20 +36,27 @@ interface AgentEvent {
     machineId?: string;
     sessionId?: string;
     error?: string;
+    taskTitle?: string;
+    decisionSource?: DecisionSource;
+    meta?: ReceiptMeta;
 }
-declare const reportEvent: (event: AgentEvent) => Promise<void>;
+interface ReportEventOptions {
+    maxAttempts?: number;
+    timeoutMs?: number;
+}
+declare const reportEvent: (event: AgentEvent, options?: ReportEventOptions) => Promise<void>;
 declare const handlePostToolUse: (input: {
     tool_name: string;
     tool_input: Record<string, unknown>;
     tool_result?: Record<string, unknown>;
     cwd?: string;
     session_id?: string;
-}) => Promise<void>;
+}, agent?: AgentIdentity) => Promise<void>;
 declare const handleStop: (input: {
     cwd?: string;
     session_id?: string;
     stop_hook_active?: boolean;
-}) => Promise<void>;
+}, agent?: AgentIdentity) => Promise<void>;
 declare const handleNotification: (input: {
     message?: string;
     title?: string;
@@ -55,6 +74,7 @@ interface AskUserParams {
     sessionId?: string;
     machineId?: string;
     toolName?: string;
+    toolTarget?: string;
 }
 interface AskUserResponse {
     correlationId: string;
@@ -69,7 +89,7 @@ declare const waitForAnswer: (apiKey: string, correlationId: string, timeoutMs?:
 declare const cancelQuestion: (apiKey: string, correlationId: string) => Promise<void>;
 
 declare const getPolicy: (apiKey: string) => Promise<PolicyConfig>;
-declare const resolvePolicy: (config: PolicyConfig, toolName: string, modeOverride?: ApprovalMode | null) => ToolPolicy;
+declare const resolvePolicy: (config: PolicyConfig, toolName: string, modeOverride?: ApprovalMode | null, toolInput?: Record<string, unknown>) => ToolPolicy;
 interface ModeState {
     readonly mode: ApprovalMode | null;
     readonly kill: boolean;

package/dist/src/index.js

@@ -1,22 +1,22 @@
 import {
-  fetchModeOverride,
-  fetchModeState,
-  getPolicy,
-  handlePreToolUse,
-  resolvePolicy
-} from "../chunk-W5KRWUNE.js";
-import "../chunk-IBWCHA5M.js";
+  handlePreToolUse
+} from "../chunk-TRLBBLSS.js";
 import {
   handleNotification,
   handlePostToolUse,
   handleStop,
   reportEvent
-} from "../chunk-AB4KX4XT.js";
+} from "../chunk-SH26ZOHU.js";
 import {
   askUser,
   cancelQuestion,
+  fetchModeOverride,
+  fetchModeState,
+  getPolicy,
+  resolvePolicy,
   waitForAnswer
-} from "../chunk-OF5WIOYS.js";
+} from "../chunk-QRXWPZKN.js";
+import "../chunk-22CV7V7A.js";
 import "../chunk-3MIR7ODJ.js";
 import {
   getApiKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "author": "Pushary <business@pushary.com>",
   "homepage": "https://pushary.com",
@@ -19,7 +19,9 @@
     "pushary-hook": "./dist/bin/pushary-hook.js",
     "pushary-post-hook": "./dist/bin/pushary-post-hook.js",
     "pushary-stop-hook": "./dist/bin/pushary-stop-hook.js",
+    "pushary-prompt-hook": "./dist/bin/pushary-prompt-hook.js",
     "pushary-codex": "./dist/bin/pushary-codex.js",
+    "pushary-codex-hook": "./dist/bin/pushary-codex-hook.js",
     "pushary-setup": "./dist/bin/pushary-setup.js",
     "pushary-clean": "./dist/bin/pushary-clean.js",
     "pushary-doctor": "./dist/bin/pushary-doctor.js",
@@ -32,7 +34,7 @@
   "scripts": {
     "build": "node scripts/bundle-plugin.mjs && tsup",
     "dev": "tsup --watch",
-    "test": "bun test src/api.test.ts && bun test src/claude-config.test.ts && bun test src/mcp-http.test.ts && bun test src/retry.test.ts && bun test src/validate.test.ts && bun test src/policy.test.ts && bun test src/npm.test.ts && bun test src/identity.test.ts && bun test src/pending.test.ts && bun test src/events.test.ts && bun test src/hook.test.ts"
+    "test": "bun test src/api.test.ts && bun test src/claude-config.test.ts && bun test src/mcp-http.test.ts && bun test src/retry.test.ts && bun test src/validate.test.ts && bun test src/policy.test.ts && bun test src/npm.test.ts && bun test src/identity.test.ts && bun test src/pending.test.ts && bun test src/events.test.ts && bun test src/describe.test.ts && bun test src/suggestions.test.ts && bun test src/hook.test.ts && bun test src/codex-adapter.test.ts && bun test src/codex-config.test.ts"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.2",