@pushary/agent-hooks 0.4.5 → 0.4.6

package/dist/bin/pushary-setup.js

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import {
+  addClaudeMcpServer,
+  addPusharyHooks,
+  addPusharyToolPermissions
+} from "../chunk-AC4UYAGX.js";
 
 // bin/pushary-setup.ts
 import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from "fs";
@@ -10,7 +15,9 @@ import { fileURLToPath } from "url";
 var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
 var CLAUDE_JSON = join(homedir(), ".claude.json");
 var CURSOR_MCP = join(".cursor", "mcp.json");
-var SKILL_DIR = join(homedir(), ".claude", "skills", "pushary");
+var CURSOR_RULES_DIR = join(".cursor", "rules");
+var CLAUDE_SKILL_DIR = join(homedir(), ".claude", "skills", "pushary");
+var CODEX_SKILL_DIR = join(homedir(), ".codex", "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`;
@@ -30,7 +37,8 @@ var writeJson = (path, data) => {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
 };
-var spinner = async (label, fn) => {
+var formatError = (err) => err instanceof Error ? err.message : String(err);
+var spinner = async (label, fn, options = {}) => {
   const frames = ["   ", ".  ", ".. ", "..."];
   let i = 0;
   const interval = setInterval(() => {
@@ -41,10 +49,11 @@ var spinner = async (label, fn) => {
     clearInterval(interval);
     process.stdout.write(`\r  ${check} ${label}
 `);
-  } catch {
+  } catch (err) {
     clearInterval(interval);
-    process.stdout.write(`\r  ${yellow("!")} ${label} ${dim("(skipped)")}
+    process.stdout.write(`\r  ${yellow("!")} ${label} ${dim(`(${formatError(err)})`)}
 `);
+    if (!options.optional) throw err;
   }
 };
 var getPackageVersion = () => {
@@ -76,74 +85,37 @@ var installGlobally = async () => {
     execSync("npm install -g @pushary/agent-hooks@latest", { stdio: "ignore" });
   });
 };
-var addMcpServer = (apiKey) => {
-  const data = readJson(CLAUDE_JSON);
-  const mcpServers = data.mcpServers ?? {};
-  mcpServers.pushary = {
-    type: "http",
-    url: "https://pushary.com/api/mcp/mcp",
-    headers: { Authorization: `Bearer ${apiKey}` }
-  };
-  data.mcpServers = mcpServers;
-  writeJson(CLAUDE_JSON, data);
-};
-var addPermissionHooks = (settings) => {
-  const hooks = settings.hooks ?? {};
-  const preToolUse = hooks.PreToolUse ?? [];
-  if (!JSON.stringify(preToolUse).includes("pushary-hook")) {
-    preToolUse.push({
-      matcher: "Bash|Write|Edit",
-      hooks: [{
-        type: "command",
-        command: "pushary-hook",
-        timeout: 120
-      }]
-    });
-    hooks.PreToolUse = preToolUse;
-  }
-  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 _cachedSkillContent = null;
+var fetchSkillContent = async () => {
+  if (_cachedSkillContent) return _cachedSkillContent;
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(__dirname, "..", "..", "data", "SKILL.md"),
+    join(__dirname, "..", "data", "SKILL.md")
+  ];
+  const source = candidates.find((path) => existsSync(path));
+  if (!source) throw new Error("packaged skill not found");
+  _cachedSkillContent = readFileSync(source, "utf-8");
+  return _cachedSkillContent;
 };
-var addToolPermissions = (settings) => {
-  const permissions = settings.permissions ?? {};
-  const allow = permissions.allow ?? [];
-  const filtered = allow.filter((r) => !r.includes("pushary"));
-  const rule = "mcp__pushary__*";
-  if (!filtered.includes(rule)) filtered.push(rule);
-  permissions.allow = filtered;
-  settings.permissions = permissions;
+var installSkillToDir = async (dir, label) => {
+  await spinner(label, async () => {
+    const content = await fetchSkillContent();
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "SKILL.md"), content, "utf-8");
+  });
 };
-var installSkill = async () => {
-  await spinner("Installing Pushary skill", async () => {
-    const res = await fetch("https://raw.githubusercontent.com/pushary/pushary-skill/main/skills/pushary/SKILL.md", {
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!res.ok) throw new Error(`Failed to fetch skill (${res.status})`);
-    const content = await res.text();
-    if (!existsSync(SKILL_DIR)) mkdirSync(SKILL_DIR, { recursive: true });
-    writeFileSync(join(SKILL_DIR, "SKILL.md"), content, "utf-8");
+var installCursorRule = async () => {
+  await spinner("Installing Pushary rules", async () => {
+    const content = await fetchSkillContent();
+    const body = content.replace(/^---[\s\S]*?---\n*/m, "");
+    const mdc = `---
+alwaysApply: true
+---
+
+${body}`;
+    if (!existsSync(CURSOR_RULES_DIR)) mkdirSync(CURSOR_RULES_DIR, { recursive: true });
+    writeFileSync(join(CURSOR_RULES_DIR, "pushary.mdc"), mdc, "utf-8");
   });
 };
 var setupClaudeCode = async (apiKey) => {
@@ -152,19 +124,21 @@ var setupClaudeCode = async (apiKey) => {
 `);
   const settings = readJson(CLAUDE_SETTINGS);
   await spinner("Adding MCP server (type: http)", async () => {
-    addMcpServer(apiKey);
+    const data = readJson(CLAUDE_JSON);
+    addClaudeMcpServer(data, apiKey);
+    writeJson(CLAUDE_JSON, data);
   });
   await spinner("Auto-allowing Pushary tools", async () => {
-    addToolPermissions(settings);
+    addPusharyToolPermissions(settings);
   });
   await installGlobally();
   await spinner("Adding hooks (PreToolUse, PostToolUse, Stop)", async () => {
-    addPermissionHooks(settings);
+    addPusharyHooks(settings);
   });
   await spinner(`Writing ${CLAUDE_SETTINGS}`, async () => {
     writeJson(CLAUDE_SETTINGS, settings);
   });
-  await installSkill();
+  await installSkillToDir(CLAUDE_SKILL_DIR, "Installing Pushary skill");
   console.log();
   console.log(`  ${dim("What this configured:")}`);
   console.log(`  ${dim("\u2022")} MCP server: your agent can send notifications and ask questions`);
@@ -196,10 +170,7 @@ var setupHermes = async (_apiKey) => {
     console.log(`  ${dim("  Install Python 3.10+ and re-run setup to fix.")}`);
   }
   await spinner("Enabling plugin", async () => {
-    try {
-      execSync("hermes plugins enable pushary", { stdio: "ignore" });
-    } catch {
-    }
+    execSync("hermes plugins enable pushary", { stdio: "ignore" });
   });
   console.log();
   console.log(`  ${dim("What this configured:")}`);
@@ -250,6 +221,7 @@ notify = ["${pusharyCodexPath}"]
       appendFileSync(codexConfig, notifyLine, "utf-8");
     }
   });
+  await installSkillToDir(CODEX_SKILL_DIR, "Installing Pushary skill");
   console.log();
   console.log(`  ${dim("What this configured:")}`);
   console.log(`  ${dim("\u2022")} MCP server: Codex can send notifications and ask questions`);
@@ -270,7 +242,7 @@ var setupCursor = async (apiKey) => {
     config.mcpServers = mcpServers;
     writeJson(CURSOR_MCP, config);
   });
-  await installSkill();
+  await installCursorRule();
 };
 var saveApiKey = async (apiKey) => {
   await spinner("Saving API key to shell profile", async () => {
@@ -379,4 +351,10 @@ var main = async () => {
   console.log(`  ${dim("3.")} Run ${cyan("npx @pushary/agent-hooks doctor")} to verify`);
   console.log();
 };
-main();
+main().catch((err) => {
+  console.log();
+  console.log(`  ${yellow("!")} Setup failed: ${formatError(err)}`);
+  console.log(`  ${dim("Run")} ${cyan("npx @pushary/agent-hooks doctor")} ${dim("after fixing the issue, then rerun setup.")}`);
+  console.log();
+  process.exit(1);
+});

package/dist/{chunk-KINE5LNQ.js → chunk-4TQW4K6T.js}

@@ -1,7 +1,7 @@
 import {
   askUser,
   waitForAnswer
-} from "./chunk-4TWRLEOX.js";
+} from "./chunk-M5SRSBLS.js";
 import {
   getApiKey,
   getBaseUrl

package/dist/chunk-AC4UYAGX.js

@@ -0,0 +1,136 @@
+// src/claude-config.ts
+var PUSHARY_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var PUSHARY_PERMISSION_RULE = "mcp__pushary__*";
+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 isPusharyPermission = (rule) => typeof rule === "string" && (rule.includes("pushary") || rule.includes("MCP(pushary"));
+var isPusharyHook = (entry) => {
+  const hooks = asRecord(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    const command = String(asRecord(hook)?.command ?? "");
+    return command.includes("pushary-hook") || command.includes("pushary-post-hook") || command.includes("pushary-stop-hook");
+  });
+};
+var addClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = ensureRecord(config, "mcpServers");
+  mcpServers.pushary = {
+    type: "http",
+    url: PUSHARY_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+};
+var removeClaudeMcpServers = (config) => {
+  let changed = false;
+  const removeFrom = (target) => {
+    const mcpServers = asRecord(target.mcpServers);
+    if (!mcpServers?.pushary) return;
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete target.mcpServers;
+    changed = true;
+  };
+  removeFrom(config);
+  const projects = asRecord(config.projects);
+  if (projects) {
+    for (const project of Object.values(projects)) {
+      const projectConfig = asRecord(project);
+      if (projectConfig) removeFrom(projectConfig);
+    }
+  }
+  return changed;
+};
+var addPusharyToolPermissions = (settings) => {
+  const permissions = ensureRecord(settings, "permissions");
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filtered = allow.filter((rule) => !isPusharyPermission(rule));
+  if (!filtered.includes(PUSHARY_PERMISSION_RULE)) {
+    filtered.push(PUSHARY_PERMISSION_RULE);
+  }
+  permissions.allow = filtered;
+};
+var addPusharyHooks = (settings) => {
+  const hooks = ensureRecord(settings, "hooks");
+  const preToolUse = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+  if (!preToolUse.some(isPusharyHook)) {
+    preToolUse.push({
+      matcher: "Bash|Write|Edit",
+      hooks: [{
+        type: "command",
+        command: "pushary-hook",
+        timeout: 120
+      }]
+    });
+    hooks.PreToolUse = preToolUse;
+  }
+  const postToolUse = Array.isArray(hooks.PostToolUse) ? hooks.PostToolUse : [];
+  if (!postToolUse.some(isPusharyHook)) {
+    postToolUse.push({
+      matcher: "Bash|Write|Edit",
+      hooks: [{
+        type: "command",
+        command: "pushary-post-hook",
+        timeout: 10
+      }]
+    });
+    hooks.PostToolUse = postToolUse;
+  }
+  const stop = Array.isArray(hooks.Stop) ? hooks.Stop : [];
+  if (!stop.some(isPusharyHook)) {
+    stop.push({
+      hooks: [{
+        type: "command",
+        command: "pushary-stop-hook",
+        timeout: 10
+      }]
+    });
+    hooks.Stop = stop;
+  }
+};
+var removePusharySettings = (settings) => {
+  let changed = removeClaudeMcpServers(settings);
+  const permissions = asRecord(settings.permissions);
+  if (permissions && Array.isArray(permissions.allow)) {
+    const filtered = permissions.allow.filter((rule) => !isPusharyPermission(rule));
+    if (filtered.length !== permissions.allow.length) {
+      if (filtered.length === 0) {
+        delete permissions.allow;
+      } else {
+        permissions.allow = filtered;
+      }
+      if (Object.keys(permissions).length === 0) delete settings.permissions;
+      changed = true;
+    }
+  }
+  const hooks = asRecord(settings.hooks);
+  if (hooks) {
+    for (const key of ["PreToolUse", "PostToolUse", "Stop"]) {
+      const entries = hooks[key];
+      if (!Array.isArray(entries)) continue;
+      const filtered = entries.filter((entry) => !isPusharyHook(entry));
+      if (filtered.length !== entries.length) {
+        if (filtered.length === 0) {
+          delete hooks[key];
+        } else {
+          hooks[key] = filtered;
+        }
+        changed = true;
+      }
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  return changed;
+};
+
+export {
+  addClaudeMcpServer,
+  removeClaudeMcpServers,
+  addPusharyToolPermissions,
+  addPusharyHooks,
+  removePusharySettings
+};

package/dist/chunk-M5SRSBLS.js

@@ -0,0 +1,23 @@
+import {
+  callMcpTool
+} from "./chunk-RJKW6LLC.js";
+
+// src/api.ts
+var askUser = async (apiKey, params) => {
+  return callMcpTool(apiKey, "ask_user", { ...params });
+};
+var waitForAnswer = async (apiKey, correlationId, timeoutMs = 3e4) => {
+  return callMcpTool(apiKey, "wait_for_answer", {
+    correlationId,
+    timeoutMs
+  });
+};
+var cancelQuestion = async (apiKey, correlationId) => {
+  await callMcpTool(apiKey, "cancel_question", { correlationId });
+};
+
+export {
+  askUser,
+  waitForAnswer,
+  cancelQuestion
+};

package/dist/chunk-RJKW6LLC.js

@@ -0,0 +1,78 @@
+import {
+  getBaseUrl
+} from "./chunk-VUNL35KE.js";
+
+// src/mcp-http.ts
+var parseSseJson = (body) => {
+  const messages = [];
+  for (const event of body.split(/\r?\n\r?\n/)) {
+    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+    if (!data) continue;
+    messages.push(JSON.parse(data));
+  }
+  const message = messages.at(-1);
+  if (!message) throw new Error("Empty response from Pushary");
+  return message;
+};
+var parseMcpResponse = (body, contentType) => {
+  if (contentType?.includes("text/event-stream")) {
+    return parseSseJson(body);
+  }
+  return JSON.parse(body);
+};
+var sendMcpRequest = async (apiKey, message, options = {}) => {
+  const baseUrl = options.baseUrl ?? getBaseUrl();
+  const fetchFn = options.fetchFn ?? fetch;
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    "Authorization": `Bearer ${apiKey}`
+  };
+  if (options.sessionId) {
+    headers["Mcp-Session-Id"] = options.sessionId;
+  }
+  const response = await fetchFn(`${baseUrl}/api/mcp/mcp`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(message),
+    signal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : void 0
+  });
+  const body = await response.text();
+  const contentType = response.headers.get("content-type");
+  let data = null;
+  if (body.trim()) {
+    try {
+      data = parseMcpResponse(body, contentType);
+    } catch (err) {
+      if (response.ok) throw err;
+    }
+  }
+  if (!response.ok) {
+    const message2 = data?.error?.message ?? (body.trim() || response.statusText);
+    throw new Error(`Pushary MCP error: ${response.status} ${message2}`);
+  }
+  if (!data) throw new Error("Empty response from Pushary");
+  if (data.error) throw new Error(data.error.message ?? "Pushary MCP error");
+  return {
+    data,
+    sessionId: response.headers.get("mcp-session-id") ?? "",
+    status: response.status,
+    statusText: response.statusText
+  };
+};
+var callMcpTool = async (apiKey, toolName, params, options = {}) => {
+  const { data } = await sendMcpRequest(apiKey, {
+    jsonrpc: "2.0",
+    id: options.id ?? Date.now(),
+    method: "tools/call",
+    params: { name: toolName, arguments: params }
+  }, options);
+  const text = data.result?.content?.[0]?.text;
+  if (!text) throw new Error("Empty response from Pushary");
+  return JSON.parse(text);
+};
+
+export {
+  sendMcpRequest,
+  callMcpTool
+};

package/dist/src/index.js

@@ -2,12 +2,13 @@ import {
   getPolicy,
   handlePreToolUse,
   resolvePolicy
-} from "../chunk-KINE5LNQ.js";
+} from "../chunk-4TQW4K6T.js";
 import {
   askUser,
   cancelQuestion,
   waitForAnswer
-} from "../chunk-4TWRLEOX.js";
+} from "../chunk-M5SRSBLS.js";
+import "../chunk-RJKW6LLC.js";
 import {
   handleNotification,
   handlePostToolUse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "author": "Pushary <business@pushary.com>",
   "homepage": "https://pushary.com",
@@ -25,11 +25,13 @@
     "pushary-doctor": "./dist/bin/pushary-doctor.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "data"
   ],
   "scripts": {
     "build": "tsup src/index.ts bin/pushary.ts bin/pushary-hook.ts bin/pushary-post-hook.ts bin/pushary-stop-hook.ts bin/pushary-codex.ts bin/pushary-setup.ts bin/pushary-clean.ts bin/pushary-doctor.ts --format esm --dts --outDir dist",
-    "dev": "tsup src/index.ts bin/pushary.ts bin/pushary-hook.ts bin/pushary-post-hook.ts bin/pushary-stop-hook.ts bin/pushary-codex.ts bin/pushary-setup.ts bin/pushary-clean.ts bin/pushary-doctor.ts --format esm --watch"
+    "dev": "tsup src/index.ts bin/pushary.ts bin/pushary-hook.ts bin/pushary-post-hook.ts bin/pushary-stop-hook.ts bin/pushary-codex.ts bin/pushary-setup.ts bin/pushary-clean.ts bin/pushary-doctor.ts --format esm --watch",
+    "test": "bun test src/api.test.ts && bun test src/claude-config.test.ts && bun test src/mcp-http.test.ts"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.2"

package/dist/chunk-4TWRLEOX.js

@@ -1,49 +0,0 @@
-import {
-  getBaseUrl
-} from "./chunk-VUNL35KE.js";
-
-// 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 });
-};
-
-export {
-  askUser,
-  waitForAnswer,
-  cancelQuestion
-};