@pushary/agent-hooks 0.1.0 → 0.2.0

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/bin/pushary-setup.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/pushary-setup.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+// bin/pushary-setup.ts
+import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { createInterface } from "readline";
+var rl = createInterface({ input: process.stdin, output: process.stdout });
+var ask = (q) => new Promise((r) => rl.question(q, r));
+var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
+var CURSOR_MCP = join(".cursor", "mcp.json");
+var SHELL_FILES = [".zshrc", ".bashrc"].map((f) => join(homedir(), f));
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var readJson = (path) => {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+};
+var writeJson = (path, data) => {
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+};
+var setupClaudeCode = async (apiKey) => {
+  console.log(`
+${bold("Claude Code Setup")}
+`);
+  const settings = readJson(CLAUDE_SETTINGS);
+  const mcpServers = settings.mcpServers ?? {};
+  mcpServers.pushary = {
+    url: "https://pushary.com/api/mcp/mcp",
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+  settings.mcpServers = mcpServers;
+  const addHooks = await ask(`Add permission hooks? (approve/deny tools from your phone) ${dim("[Y/n]")} `);
+  if (addHooks.toLowerCase() !== "n") {
+    const hooks = settings.hooks ?? {};
+    const preToolUse = hooks.PreToolUse ?? [];
+    const alreadyHasPushary = JSON.stringify(preToolUse).includes("pushary-hook");
+    if (!alreadyHasPushary) {
+      preToolUse.push({
+        matcher: "Bash|Write|Edit",
+        hooks: [{
+          type: "command",
+          command: "pushary-hook",
+          timeout: 120
+        }]
+      });
+      hooks.PreToolUse = preToolUse;
+      settings.hooks = hooks;
+    }
+  }
+  writeJson(CLAUDE_SETTINGS, settings);
+  console.log(`  ${green("done")} MCP server added to ${dim(CLAUDE_SETTINGS)}`);
+  if (settings.hooks) {
+    console.log(`  ${green("done")} Permission hooks configured`);
+  }
+};
+var setupCursor = async (apiKey) => {
+  console.log(`
+${bold("Cursor Setup")}
+`);
+  const config = readJson(CURSOR_MCP);
+  const mcpServers = config.mcpServers ?? {};
+  mcpServers.pushary = {
+    url: "https://pushary.com/api/mcp/mcp",
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+  config.mcpServers = mcpServers;
+  writeJson(CURSOR_MCP, config);
+  console.log(`  ${green("done")} MCP server added to ${dim(CURSOR_MCP)}`);
+};
+var saveApiKey = (apiKey) => {
+  const exportLine = `
+export PUSHARY_API_KEY="${apiKey}"
+`;
+  const shellFile = SHELL_FILES.find((f) => existsSync(f));
+  if (shellFile) {
+    const content = readFileSync(shellFile, "utf-8");
+    if (content.includes("PUSHARY_API_KEY")) {
+      console.log(`  ${dim("PUSHARY_API_KEY already in")} ${shellFile}`);
+    } else {
+      appendFileSync(shellFile, exportLine, "utf-8");
+      console.log(`  ${green("done")} Added PUSHARY_API_KEY to ${dim(shellFile)}`);
+    }
+  }
+  process.env.PUSHARY_API_KEY = apiKey;
+};
+var sendTestNotification = async (apiKey) => {
+  console.log(`
+${bold("Sending test notification...")}`);
+  try {
+    const response = await fetch("https://pushary.com/api/mcp/mcp", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: "send_notification",
+          arguments: {
+            title: "Pushary is working",
+            body: "Your AI agent can now send you push notifications.",
+            agentName: "Pushary Setup"
+          }
+        }
+      })
+    });
+    if (response.ok) {
+      console.log(`  ${green("done")} Check your phone!`);
+    } else {
+      console.log(`  ${dim("Could not send test notification. Make sure you enabled notifications at pushary.com")}`);
+    }
+  } catch {
+    console.log(`  ${dim("Could not reach Pushary API. Check your internet connection.")}`);
+  }
+};
+var main = async () => {
+  console.log(`
+${bold("Pushary Setup")}
+`);
+  console.log(`Push notifications for your AI coding agents.
+`);
+  const apiKey = await ask(`Paste your API key ${dim("(from pushary.com/dashboard/agent/settings)")}: `);
+  if (!apiKey.trim() || !apiKey.includes(".")) {
+    console.log("\nInvalid API key. Get yours at https://pushary.com/sign-up?from=ai-coding\n");
+    rl.close();
+    process.exit(1);
+  }
+  const trimmedKey = apiKey.trim();
+  console.log(`
+Which agents do you use?
+`);
+  console.log(`  1. ${cyan("Claude Code")}`);
+  console.log(`  2. ${cyan("Cursor")}`);
+  console.log(`  3. ${cyan("Both")}`);
+  console.log(`  4. ${cyan("Other")} ${dim("(just save the API key)")}`);
+  console.log();
+  const choice = await ask(`Choice ${dim("[1-4]")}: `);
+  saveApiKey(trimmedKey);
+  switch (choice.trim()) {
+    case "1":
+      await setupClaudeCode(trimmedKey);
+      break;
+    case "2":
+      await setupCursor(trimmedKey);
+      break;
+    case "3":
+      await setupClaudeCode(trimmedKey);
+      await setupCursor(trimmedKey);
+      break;
+    case "4":
+    default:
+      break;
+  }
+  const test = await ask(`
+Send a test notification? ${dim("[Y/n]")} `);
+  if (test.toLowerCase() !== "n") {
+    await sendTestNotification(trimmedKey);
+  }
+  console.log(`
+${green("Setup complete.")} Your agents will now send you push notifications.
+`);
+  console.log(`${dim("Next steps:")}`);
+  console.log(`  ${dim("1.")} Enable notifications on your phone at ${cyan("pushary.com")}`);
+  console.log(`  ${dim("2.")} Configure timeout policies at ${cyan("pushary.com/dashboard/agent/policies")}`);
+  console.log(`  ${dim("3.")} Start coding with your agent
+`);
+  rl.close();
+};
+main();

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.2.0",
   "description": "Permission hooks for AI coding agents — route tool approvals through Pushary push notifications",
   "author": "Pushary <business@pushary.com>",
   "homepage": "https://pushary.com",
@@ -14,14 +14,15 @@
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "bin": {
-    "pushary-hook": "./dist/bin/pushary-hook.js"
+    "pushary-hook": "./dist/bin/pushary-hook.js",
+    "pushary-setup": "./dist/bin/pushary-setup.js"
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts bin/pushary-hook.ts --format esm --dts --outDir dist",
-    "dev": "tsup src/index.ts bin/pushary-hook.ts --format esm --watch"
+    "build": "tsup src/index.ts bin/pushary-hook.ts bin/pushary-setup.ts --format esm --dts --outDir dist",
+    "dev": "tsup src/index.ts bin/pushary-hook.ts bin/pushary-setup.ts --format esm --watch"
   },
   "devDependencies": {
     "tsup": "^8.0.0",