@pushary/agent-hooks 0.1.0 → 0.1.1

package/dist/bin/pushary-hook.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   handlePreToolUse
-} from "../chunk-I546R6K2.js";
+} from "../chunk-5ZMTG7GF.js";
 
 // bin/pushary-hook.ts
 var main = async () => {
@@ -22,9 +22,9 @@ var main = async () => {
     process.exit(0);
   }
   try {
-    const decision = await handlePreToolUse(input);
-    if (decision) {
-      process.stdout.write(JSON.stringify(decision));
+    const output = await handlePreToolUse(input);
+    if (output) {
+      process.stdout.write(JSON.stringify(output));
     }
   } catch (err) {
     process.stderr.write(

package/dist/chunk-5ZMTG7GF.js

@@ -0,0 +1,184 @@
+// src/config.ts
+var getApiKey = () => {
+  const key = process.env.PUSHARY_API_KEY;
+  if (!key) {
+    throw new Error(
+      "PUSHARY_API_KEY environment variable is not set. Get your API key at https://pushary.com/sign-up?from=ai-coding"
+    );
+  }
+  return key;
+};
+var getBaseUrl = () => process.env.PUSHARY_BASE_URL ?? "https://pushary.com";
+
+// src/api.ts
+var mcpToolCall = async (apiKey, toolName, params) => {
+  const baseUrl = getBaseUrl();
+  const response = await fetch(`${baseUrl}/api/mcp/mcp`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: { name: toolName, arguments: params }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Pushary API error: ${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  if (json.error) throw new Error(json.error.message);
+  const text = json.result?.content?.[0]?.text;
+  if (!text) throw new Error("Empty response from Pushary");
+  return JSON.parse(text);
+};
+var askUser = async (apiKey, params) => {
+  const result = await mcpToolCall(apiKey, "ask_user", { ...params });
+  return result;
+};
+var waitForAnswer = async (apiKey, correlationId, timeoutMs = 3e4) => {
+  const result = await mcpToolCall(apiKey, "wait_for_answer", {
+    correlationId,
+    timeoutMs
+  });
+  return result;
+};
+var cancelQuestion = async (apiKey, correlationId) => {
+  await mcpToolCall(apiKey, "cancel_question", { correlationId });
+};
+
+// src/policy.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+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) => {
+  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}`);
+  }
+  return response.json();
+};
+var getPolicy = async (apiKey) => {
+  const path = cacheFile(apiKey);
+  if (existsSync(path)) {
+    try {
+      return JSON.parse(readFileSync(path, "utf-8"));
+    } catch {
+    }
+  }
+  const policy = await fetchPolicy(apiKey);
+  writeFileSync(path, JSON.stringify(policy), "utf-8");
+  return policy;
+};
+var resolvePolicy = (config, toolName) => {
+  const exact = config.policies.find((p) => p.tool === toolName);
+  if (exact) return exact;
+  const wildcard = config.policies.find((p) => p.tool === "*");
+  if (wildcard) return wildcard;
+  return {
+    tool: toolName,
+    timeoutSeconds: config.defaultTimeoutSeconds,
+    timeoutAction: config.defaultTimeoutAction
+  };
+};
+
+// src/hook.ts
+import { basename } from "path";
+var describeToolCall = (input) => {
+  const { tool_name, tool_input } = input;
+  switch (tool_name) {
+    case "Bash":
+      return `bash: ${tool_input.command ?? "(no command)"}`;
+    case "Write":
+      return `write file: ${tool_input.file_path ?? "(unknown path)"}`;
+    case "Edit":
+      return `edit file: ${tool_input.file_path ?? "(unknown path)"}`;
+    case "Read":
+      return `read file: ${tool_input.file_path ?? "(unknown path)"}`;
+    default:
+      return `${tool_name}: ${JSON.stringify(tool_input).slice(0, 200)}`;
+  }
+};
+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",
+    permissionDecisionReason: reason
+  }
+});
+var handlePreToolUse = async (input) => {
+  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);
+  const projectName = basename(input.cwd ?? process.cwd());
+  const result = await askUser(apiKey, {
+    question: `Allow ${description}?`,
+    type: "confirm",
+    context: `Agent wants to run this in ${projectName}`,
+    agentName: `Claude Code - ${projectName}`
+  });
+  const deadline = Date.now() + toolPolicy.timeoutSeconds * 1e3;
+  const pollInterval = 2e3;
+  while (Date.now() < deadline) {
+    const remaining = Math.min(
+      Math.max(deadline - Date.now(), 1e3),
+      3e4
+    );
+    const answer = await waitForAnswer(apiKey, result.correlationId, remaining);
+    if (answer.answered) {
+      return answer.value === "yes" ? allow() : deny("Denied via Pushary push notification");
+    }
+    if (Date.now() + pollInterval >= deadline) break;
+    await sleep(pollInterval);
+  }
+  switch (toolPolicy.timeoutAction) {
+    case "approve":
+      return allow();
+    case "deny":
+      return deny("No response within timeout");
+    case "escalate":
+    default:
+      return ask("Pushary: no response \u2014 asking in terminal");
+  }
+};
+
+export {
+  getApiKey,
+  getBaseUrl,
+  askUser,
+  waitForAnswer,
+  cancelQuestion,
+  getPolicy,
+  resolvePolicy,
+  handlePreToolUse
+};

package/dist/src/index.d.ts

@@ -1,12 +1,17 @@
 interface ToolInput {
     tool_name: string;
     tool_input: Record<string, unknown>;
+    session_id?: string;
+    cwd?: string;
 }
-interface HookDecision {
-    decision: 'approve' | 'deny';
-    reason?: string;
+interface HookOutput {
+    hookSpecificOutput: {
+        hookEventName: 'PreToolUse';
+        permissionDecision: 'allow' | 'deny' | 'ask';
+        permissionDecisionReason?: string;
+    };
 }
-declare const handlePreToolUse: (input: ToolInput) => Promise<HookDecision | null>;
+declare const handlePreToolUse: (input: ToolInput) => Promise<HookOutput | null>;
 
 interface AskUserParams {
     question: string;

package/dist/src/index.js

@@ -7,7 +7,7 @@ import {
   handlePreToolUse,
   resolvePolicy,
   waitForAnswer
-} from "../chunk-I546R6K2.js";
+} from "../chunk-5ZMTG7GF.js";
 export {
   askUser,
   cancelQuestion,

package/package.json

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