@pushary/agent-hooks 0.2.8 → 0.4.0

package/dist/bin/pushary-doctor.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+// bin/pushary-doctor.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { confirm } from "@inquirer/prompts";
+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 red = (s) => `\x1B[31m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var pass = green("\u2713");
+var fail = red("\u2717");
+var warn = yellow("!");
+var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
+var SKILL_PATH = join(homedir(), ".claude", "skills", "pushary", "SKILL.md");
+var MCP_URL = "https://pushary.com/api/mcp/mcp";
+var readJson = (path) => {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+var results = [];
+var check = (passed, label, detail) => {
+  results.push({ passed, label, detail });
+  const icon = passed ? pass : fail;
+  const suffix = detail ? ` ${dim(`(${detail})`)}` : "";
+  console.log(`  ${icon} ${label}${suffix}`);
+};
+var main = async () => {
+  console.log();
+  console.log(`  ${bold("Pushary Doctor")}`);
+  console.log();
+  console.log(`  ${dim("Configuration")}`);
+  const apiKey = process.env.PUSHARY_API_KEY;
+  check(!!apiKey, "API key in environment", apiKey ? `pk_${apiKey.split(".")[0]?.slice(3, 7)}...` : "PUSHARY_API_KEY not set");
+  const settings = readJson(CLAUDE_SETTINGS);
+  if (settings) {
+    const mcpServers = settings.mcpServers;
+    const pusharyServer = mcpServers?.pushary;
+    check(!!pusharyServer, "Claude Code: MCP server configured");
+    if (pusharyServer) {
+      check(pusharyServer.type === "http", "Claude Code: MCP server type", pusharyServer.type ? String(pusharyServer.type) : 'missing \u2014 add type: "http"');
+    }
+    const hooks = settings.hooks;
+    const hasPreHook = JSON.stringify(hooks?.PreToolUse ?? []).includes("pushary-hook");
+    const hasPostHook = JSON.stringify(hooks?.PostToolUse ?? []).includes("pushary-post-hook");
+    const hasStopHook = JSON.stringify(hooks?.Stop ?? []).includes("pushary-stop-hook");
+    check(hasPreHook, "Claude Code: PreToolUse hook");
+    check(hasPostHook, "Claude Code: PostToolUse hook");
+    check(hasStopHook, "Claude Code: Stop hook");
+    const permissions = settings.permissions;
+    const hasWildcard = permissions?.allow?.some((r) => r === "MCP(pushary:*)") ?? false;
+    check(hasWildcard, "Claude Code: Pushary tools auto-allowed", hasWildcard ? "MCP(pushary:*)" : "missing");
+    const hasLegacyPerms = permissions?.allow?.some((r) => r.startsWith("mcp__pushary__")) ?? false;
+    if (hasLegacyPerms) {
+      console.log(`  ${warn} Legacy individual permissions detected ${dim("(run pushary clean, then setup again)")}`);
+    }
+  } else {
+    check(false, "Claude Code: settings.json", "not found");
+  }
+  check(existsSync(SKILL_PATH), "Skill installed", existsSync(SKILL_PATH) ? SKILL_PATH : "not found");
+  let globalVersion = "";
+  try {
+    const { execSync } = await import("child_process");
+    globalVersion = execSync("npm list -g @pushary/agent-hooks --depth=0 2>/dev/null", { encoding: "utf-8" }).match(/@pushary\/agent-hooks@([\d.]+)/)?.[1] ?? "";
+  } catch {
+  }
+  check(!!globalVersion, "Global package installed", globalVersion || "not found");
+  console.log();
+  console.log(`  ${dim("Connectivity")}`);
+  if (!apiKey) {
+    check(false, "MCP server reachable", "skipped \u2014 no API key");
+    check(false, "API key valid", "skipped");
+    check(false, "MCP handshake", "skipped");
+  } else {
+    let sessionId = "";
+    let toolCount = 0;
+    try {
+      const initRes = await fetch(MCP_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json, text/event-stream",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+          params: {
+            protocolVersion: "2025-03-26",
+            capabilities: {},
+            clientInfo: { name: "pushary-doctor", version: "1.0" }
+          }
+        }),
+        signal: AbortSignal.timeout(1e4)
+      });
+      check(initRes.ok, "MCP server reachable", `${initRes.status} ${initRes.statusText}`);
+      sessionId = initRes.headers.get("mcp-session-id") ?? "";
+      check(!!sessionId, "Session ID returned", sessionId ? `${sessionId.slice(0, 8)}...` : "missing \u2014 update MCP SDK");
+      const initBody = await initRes.text();
+      const initMatch = initBody.match(/data: (.+)/);
+      if (initMatch) {
+        const initData = JSON.parse(initMatch[1]);
+        check(!!initData.result?.serverInfo, "API key valid", initData.result?.serverInfo?.name ?? "unknown server");
+      }
+      const toolsRes = await fetch(MCP_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json, text/event-stream",
+          "Authorization": `Bearer ${apiKey}`,
+          ...sessionId ? { "Mcp-Session-Id": sessionId } : {}
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 2,
+          method: "tools/list",
+          params: {}
+        }),
+        signal: AbortSignal.timeout(1e4)
+      });
+      const toolsBody = await toolsRes.text();
+      const toolsMatch = toolsBody.match(/data: (.+)/);
+      if (toolsMatch) {
+        const toolsData = JSON.parse(toolsMatch[1]);
+        toolCount = toolsData.result?.tools?.length ?? 0;
+      }
+      check(toolCount > 0, "MCP tools discovered", `${toolCount} tools`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "unknown error";
+      check(false, "MCP server reachable", msg);
+    }
+    console.log();
+    console.log(`  ${dim("Notification Delivery")}`);
+    try {
+      const notifRes = await fetch("https://pushary.com/api/v1/server/send", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          title: "Pushary Doctor",
+          body: "If you see this, push notifications are working."
+        }),
+        signal: AbortSignal.timeout(1e4)
+      });
+      check(notifRes.ok, "Push notification sent", notifRes.ok ? "check your phone" : `${notifRes.status}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "network error";
+      check(false, "Push notification sent", msg);
+    }
+    const testQuestion = await confirm({ message: "Test question roundtrip? (sends a push notification)", default: false });
+    if (testQuestion) {
+      console.log();
+      console.log(`  ${dim("Question Roundtrip")}`);
+      try {
+        const askRes = await fetch(MCP_URL, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "Authorization": `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 3,
+            method: "tools/call",
+            params: {
+              name: "ask_user",
+              arguments: {
+                question: "Pushary Doctor: tap Yes to verify the roundtrip works.",
+                type: "confirm",
+                agentName: "Pushary Doctor"
+              }
+            }
+          }),
+          signal: AbortSignal.timeout(15e3)
+        });
+        const askBody = await askRes.text();
+        const askMatch = askBody.match(/data: (.+)/);
+        let correlationId = "";
+        if (askMatch) {
+          const askData = JSON.parse(askMatch[1]);
+          const content = askData.result?.content?.[0]?.text;
+          if (content) {
+            const parsed = JSON.parse(content);
+            correlationId = parsed.correlationId;
+          }
+        }
+        if (correlationId) {
+          console.log(`  ${dim("\u2192")} Question sent, waiting for your answer...`);
+          const start = Date.now();
+          const waitRes = await fetch(MCP_URL, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Accept": "application/json, text/event-stream",
+              "Authorization": `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 4,
+              method: "tools/call",
+              params: {
+                name: "wait_for_answer",
+                arguments: { correlationId, timeoutMs: 55e3 }
+              }
+            }),
+            signal: AbortSignal.timeout(6e4)
+          });
+          const waitBody = await waitRes.text();
+          const waitMatch = waitBody.match(/data: (.+)/);
+          if (waitMatch) {
+            const waitData = JSON.parse(waitMatch[1]);
+            const content = waitData.result?.content?.[0]?.text;
+            if (content) {
+              const parsed = JSON.parse(content);
+              const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+              check(parsed.answered === true, "Answer received", `"${parsed.value}" (${elapsed}s roundtrip)`);
+            } else {
+              check(false, "Answer received", "no response within timeout");
+            }
+          }
+        } else {
+          check(false, "Question sent", "failed to get correlationId");
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "unknown error";
+        check(false, "Question roundtrip", msg);
+      }
+    }
+  }
+  console.log();
+  const failed = results.filter((r) => !r.passed);
+  if (failed.length === 0) {
+    console.log(`  ${green(bold("All checks passed."))}`);
+  } else {
+    console.log(`  ${red(bold(`${failed.length} check${failed.length === 1 ? "" : "s"} failed:`))}`);
+    for (const f of failed) {
+      console.log(`  ${fail} ${f.label}${f.detail ? ` \u2014 ${f.detail}` : ""}`);
+    }
+    console.log();
+    console.log(`  ${dim("Run")} ${cyan("npx @pushary/agent-hooks@latest clean")} ${dim("then")} ${cyan("setup")} ${dim("to fix.")}`);
+  }
+  console.log();
+};
+main();

package/dist/bin/pushary-hook.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import {
   handlePreToolUse
-} from "../chunk-5ZMTG7GF.js";
+} from "../chunk-KINE5LNQ.js";
+import "../chunk-4TWRLEOX.js";
+import "../chunk-VUNL35KE.js";
 
 // bin/pushary-hook.ts
 var main = async () => {

package/dist/bin/pushary-post-hook.d.ts

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

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {
+  handlePostToolUse
+} from "../chunk-EQE6Z4YQ.js";
+import "../chunk-VUNL35KE.js";
+
+// bin/pushary-post-hook.ts
+var main = async () => {
+  let rawInput = "";
+  for await (const chunk of process.stdin) {
+    rawInput += chunk;
+  }
+  if (!rawInput.trim()) {
+    process.exit(0);
+  }
+  try {
+    const input = JSON.parse(rawInput);
+    await handlePostToolUse(input);
+  } catch {
+  }
+};
+main();

package/dist/bin/pushary-setup.js

@@ -2,14 +2,14 @@
 
 // bin/pushary-setup.ts
 import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from "fs";
-import { join } from "path";
+import { join, dirname } from "path";
 import { homedir } from "os";
-import { createInterface } from "readline";
 import { execSync } from "child_process";
-var rl = createInterface({ input: process.stdin, output: process.stdout });
-var ask = (q) => new Promise((r) => rl.question(q, r));
+import { checkbox, input, confirm } from "@inquirer/prompts";
+import { fileURLToPath } from "url";
 var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
 var CURSOR_MCP = join(".cursor", "mcp.json");
+var SKILL_DIR = join(homedir(), ".claude", "skills", "pushary");
 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`;
@@ -40,12 +40,28 @@ var spinner = async (label, fn) => {
     clearInterval(interval);
     process.stdout.write(`\r  ${check} ${label}
 `);
-  } catch (err) {
+  } catch {
     clearInterval(interval);
     process.stdout.write(`\r  ${yellow("!")} ${label} ${dim("(skipped)")}
 `);
   }
 };
+var checkForUpdates = async () => {
+  try {
+    const res = await fetch("https://registry.npmjs.org/@pushary/agent-hooks/latest", {
+      signal: AbortSignal.timeout(3e3)
+    });
+    const data = await res.json();
+    const latest = data.version;
+    const current = process.env.npm_package_version;
+    if (latest && current && latest !== current) {
+      console.log(`  ${yellow("!")} Update available: ${dim(current)} \u2192 ${green(latest)}`);
+      console.log(`  ${dim("Run:")} npx @pushary/agent-hooks@${latest} setup`);
+      console.log();
+    }
+  } catch {
+  }
+};
 var installGlobally = async () => {
   await spinner("Installing pushary-hook globally", async () => {
     execSync("npm install -g @pushary/agent-hooks@latest", { stdio: "ignore" });
@@ -54,6 +70,7 @@ var installGlobally = async () => {
 var addMcpServer = (settings, apiKey) => {
   const mcpServers = settings.mcpServers ?? {};
   mcpServers.pushary = {
+    type: "http",
     url: "https://pushary.com/api/mcp/mcp",
     headers: { Authorization: `Bearer ${apiKey}` }
   };
@@ -72,42 +89,86 @@ var addPermissionHooks = (settings) => {
       }]
     });
     hooks.PreToolUse = preToolUse;
-    settings.hooks = hooks;
   }
+  const postToolUse = hooks.PostToolUse ?? [];
+  if (!JSON.stringify(postToolUse).includes("pushary-post-hook")) {
+    postToolUse.push({
+      matcher: "Bash|Write|Edit",
+      hooks: [{
+        type: "command",
+        command: "pushary-post-hook",
+        timeout: 10
+      }]
+    });
+    hooks.PostToolUse = postToolUse;
+  }
+  const stop = hooks.Stop ?? [];
+  if (!JSON.stringify(stop).includes("pushary-stop-hook")) {
+    stop.push({
+      hooks: [{
+        type: "command",
+        command: "pushary-stop-hook",
+        timeout: 10
+      }]
+    });
+    hooks.Stop = stop;
+  }
+  settings.hooks = hooks;
 };
 var addToolPermissions = (settings) => {
   const permissions = settings.permissions ?? {};
   const allow = permissions.allow ?? [];
+  const filtered = allow.filter((r) => !r.includes("pushary"));
   const rule = "MCP(pushary:*)";
-  if (!allow.includes(rule)) allow.push(rule);
-  permissions.allow = allow;
+  if (!filtered.includes(rule)) filtered.push(rule);
+  permissions.allow = filtered;
   settings.permissions = permissions;
 };
+var installSkill = async () => {
+  await spinner("Installing Pushary skill", async () => {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const skillSource = join(__dirname, "..", "data", "SKILL.md");
+    let content;
+    if (existsSync(skillSource)) {
+      content = readFileSync(skillSource, "utf-8");
+    } else {
+      const res = await fetch("https://raw.githubusercontent.com/pushary/pushary-skill/main/skills/pushary/SKILL.md", {
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) throw new Error("Failed to fetch skill");
+      content = await res.text();
+    }
+    if (!existsSync(SKILL_DIR)) mkdirSync(SKILL_DIR, { recursive: true });
+    writeFileSync(join(SKILL_DIR, "SKILL.md"), content, "utf-8");
+  });
+};
 var setupClaudeCode = async (apiKey) => {
   console.log(`
   ${bold("Setting up Claude Code")}
 `);
   const settings = readJson(CLAUDE_SETTINGS);
-  await spinner("Adding MCP server", async () => {
+  await spinner("Adding MCP server (type: http)", async () => {
     addMcpServer(settings, apiKey);
   });
   await spinner("Auto-allowing Pushary tools", async () => {
     addToolPermissions(settings);
   });
   await installGlobally();
-  await spinner("Adding permission hooks (Bash, Write, Edit)", async () => {
+  await spinner("Adding hooks (PreToolUse, PostToolUse, Stop)", async () => {
     addPermissionHooks(settings);
   });
   await spinner(`Writing ${CLAUDE_SETTINGS}`, async () => {
     writeJson(CLAUDE_SETTINGS, settings);
   });
+  await installSkill();
   console.log();
   console.log(`  ${dim("What this configured:")}`);
   console.log(`  ${dim("\u2022")} MCP server: your agent can send notifications and ask questions`);
-  console.log(`  ${dim("\u2022")} Permission hooks: approve Bash/Write/Edit from your phone`);
-  console.log(`  ${dim("\u2022")} Auto-allowed tools: no permission prompts for Pushary`);
+  console.log(`  ${dim("\u2022")} Skill: teaches your agent when and how to use Pushary`);
+  console.log(`  ${dim("\u2022")} Hooks: route permission approvals through push notifications`);
+  console.log(`  ${dim("\u2022")} Auto-allowed tools: no permission prompts for Pushary MCP calls`);
 };
-var setupHermes = async (apiKey) => {
+var setupHermes = async (_apiKey) => {
   console.log(`
   ${bold("Setting up Hermes Agent")}
 `);
@@ -132,7 +193,54 @@ var setupHermes = async (apiKey) => {
   console.log(`  ${dim("What this configured:")}`);
   console.log(`  ${dim("\u2022")} Native tools: pushary_notify, pushary_ask, pushary_wait, pushary_cancel`);
   console.log(`  ${dim("\u2022")} Auto-notifications: push alert when tools return errors`);
-  console.log(`  ${dim("\u2022")} Session alerts: opt-in with PUSHARY_AUTO_NOTIFY_SESSION_END=1`);
+};
+var setupCodex = async (_apiKey) => {
+  console.log(`
+  ${bold("Setting up Codex")}
+`);
+  const hasCodex = (() => {
+    try {
+      execSync("which codex", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (!hasCodex) {
+    console.log(`  ${yellow("!")} Codex CLI not found. Skipping.`);
+    console.log(`  ${dim("Install Codex and re-run setup to configure.")}`);
+    return;
+  }
+  await installGlobally();
+  await spinner("Adding Pushary MCP server to Codex", async () => {
+    try {
+      execSync(
+        "codex mcp add pushary --url https://pushary.com/api/mcp/mcp --bearer-token-env-var PUSHARY_API_KEY",
+        { stdio: "ignore" }
+      );
+    } catch {
+    }
+  });
+  const codexConfig = join(homedir(), ".codex", "config.toml");
+  await spinner("Adding notify handler for Codex events", async () => {
+    const pusharyCodexPath = execSync("which pushary-codex", { encoding: "utf-8" }).trim();
+    if (!pusharyCodexPath) throw new Error("pushary-codex not found");
+    let config = "";
+    try {
+      config = readFileSync(codexConfig, "utf-8");
+    } catch {
+    }
+    if (!config.includes("pushary-codex")) {
+      const notifyLine = `
+notify = ["${pusharyCodexPath}"]
+`;
+      appendFileSync(codexConfig, notifyLine, "utf-8");
+    }
+  });
+  console.log();
+  console.log(`  ${dim("What this configured:")}`);
+  console.log(`  ${dim("\u2022")} MCP server: Codex can send notifications and ask questions`);
+  console.log(`  ${dim("\u2022")} Notify handler: captures turn completions and approval requests`);
 };
 var setupCursor = async (apiKey) => {
   console.log(`
@@ -142,12 +250,14 @@ var setupCursor = async (apiKey) => {
     const config = readJson(CURSOR_MCP);
     const mcpServers = config.mcpServers ?? {};
     mcpServers.pushary = {
+      type: "http",
       url: "https://pushary.com/api/mcp/mcp",
       headers: { Authorization: `Bearer ${apiKey}` }
     };
     config.mcpServers = mcpServers;
     writeJson(CURSOR_MCP, config);
   });
+  await installSkill();
 };
 var saveApiKey = async (apiKey) => {
   await spinner("Saving API key to shell profile", async () => {
@@ -165,8 +275,12 @@ export PUSHARY_API_KEY="${apiKey}"
   });
 };
 var sendTestNotification = async (apiKey) => {
-  let notifResult = "";
-  await spinner("Sending test notification", async () => {
+  const frames = ["   ", ".  ", ".. ", "..."];
+  let i = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r  ${dim(frames[i++ % frames.length])} Sending test notification`);
+  }, 200);
+  try {
     const response = await fetch("https://pushary.com/api/v1/server/send", {
       method: "POST",
       headers: {
@@ -179,69 +293,68 @@ var sendTestNotification = async (apiKey) => {
       })
     });
     const data = await response.json().catch(() => ({}));
+    clearInterval(interval);
     if (!response.ok) {
-      notifResult = `Could not send: ${data.error ?? response.statusText}`;
-      return;
+      const reason = data.error ?? response.statusText;
+      process.stdout.write(`\r  ${yellow("!")} Sending test notification ${dim(`(${reason})`)}
+`);
+      console.log(`  ${dim("Make sure you enabled notifications at")} ${cyan("pushary.com")}`);
+    } else {
+      process.stdout.write(`\r  ${check} Sending test notification
+`);
+      console.log(`  ${dim("Check your phone!")}`);
     }
-    notifResult = "sent";
-  });
-  if (notifResult === "sent") {
-    console.log(`  ${dim("Check your phone!")}`);
-  } else if (notifResult) {
-    console.log(`  ${dim(notifResult)}`);
-    console.log(`  ${dim("Make sure you enabled notifications at")} ${cyan("pushary.com")}`);
+  } catch (err) {
+    clearInterval(interval);
+    const msg = err instanceof Error ? err.message : "network error";
+    process.stdout.write(`\r  ${yellow("!")} Sending test notification ${dim(`(${msg})`)}
+`);
   }
 };
+var AGENT_SETUP = {
+  claude_code: setupClaudeCode,
+  codex: setupCodex,
+  hermes: setupHermes,
+  cursor: setupCursor
+};
 var main = async () => {
+  const version = process.env.npm_package_version ?? "0.3";
   console.log();
-  console.log(`  ${bold("Pushary")} ${dim("v" + (process.env.npm_package_version ?? "0.2"))}`);
+  console.log(`  ${bold("Pushary")} ${dim("v" + version)}`);
   console.log(`  ${dim("Push notifications for AI coding agents")}`);
   console.log();
+  await checkForUpdates();
   console.log(`  ${dim("Get your API key at")} ${cyan("pushary.com/sign-up")}`);
   console.log();
-  const apiKey = await ask(`  API key: `);
+  const apiKey = await input({ message: "API key:" });
   if (!apiKey.trim() || !apiKey.includes(".")) {
     console.log(`
   ${yellow("!")} Invalid key format. Expected: pk_xxx.sk_xxx`);
     console.log(`  ${dim("Get yours at")} ${cyan("https://pushary.com/sign-up?from=ai-coding")}
 `);
-    rl.close();
     process.exit(1);
   }
   const trimmedKey = apiKey.trim();
-  console.log();
-  console.log(`  ${bold("Which agent do you use?")}`);
-  console.log();
-  console.log(`  ${cyan("1.")} Claude Code  ${dim("MCP + permission hooks + auto-allowed tools")}`);
-  console.log(`  ${cyan("2.")} Hermes       ${dim("native plugin + auto-error notifications")}`);
-  console.log(`  ${cyan("3.")} Cursor       ${dim("MCP server")}`);
-  console.log(`  ${cyan("4.")} All          ${dim("configure everything")}`);
-  console.log(`  ${cyan("5.")} Other        ${dim("just save the API key")}`);
-  console.log();
-  const choice = await ask(`  Choice ${dim("[1-5]")}: `);
+  const agents = await checkbox({
+    message: "Which agents do you use? " + dim("(space = toggle, enter = confirm)"),
+    choices: [
+      { name: `Claude Code  ${dim("MCP + hooks + auto-allowed tools")}`, value: "claude_code" },
+      { name: `Codex        ${dim("MCP server via codex mcp add")}`, value: "codex" },
+      { name: `Hermes       ${dim("native plugin + auto-error notifications")}`, value: "hermes" },
+      { name: `Cursor       ${dim("MCP server")}`, value: "cursor" }
+    ]
+  });
   await saveApiKey(trimmedKey);
-  switch (choice.trim()) {
-    case "1":
-      await setupClaudeCode(trimmedKey);
-      break;
-    case "2":
-      await setupHermes(trimmedKey);
-      break;
-    case "3":
-      await setupCursor(trimmedKey);
-      break;
-    case "4":
-      await setupClaudeCode(trimmedKey);
-      await setupHermes(trimmedKey);
-      await setupCursor(trimmedKey);
-      break;
-    case "5":
-    default:
-      break;
+  if (agents.length === 0) {
+    console.log(`
+  ${dim("No agents selected. API key saved.")}`);
+  } else {
+    for (const agent of agents) {
+      await AGENT_SETUP[agent](trimmedKey);
+    }
   }
-  console.log();
-  const test = await ask(`  Send a test notification? ${dim("[Y/n]")} `);
-  if (test.toLowerCase() !== "n") {
+  const sendTest = await confirm({ message: "Send a test notification?", default: true });
+  if (sendTest) {
     await sendTestNotification(trimmedKey);
   }
   console.log();
@@ -250,8 +363,7 @@ var main = async () => {
   console.log(`  ${dim("Next:")}`);
   console.log(`  ${dim("1.")} Enable notifications on your phone at ${cyan("pushary.com")}`);
   console.log(`  ${dim("2.")} Restart your agent to load the new config`);
-  console.log(`  ${dim("3.")} Start coding \u2014 your agent will notify you automatically`);
+  console.log(`  ${dim("3.")} Run ${cyan("npx @pushary/agent-hooks doctor")} to verify`);
   console.log();
-  rl.close();
 };
 main();

package/dist/bin/pushary-stop-hook.d.ts

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

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  handleStop
+} from "../chunk-EQE6Z4YQ.js";
+import "../chunk-VUNL35KE.js";
+
+// bin/pushary-stop-hook.ts
+var main = async () => {
+  let rawInput = "";
+  for await (const chunk of process.stdin) {
+    rawInput += chunk;
+  }
+  try {
+    const input = rawInput.trim() ? JSON.parse(rawInput) : {};
+    await handleStop(input);
+  } catch {
+  }
+};
+main();