@pushary/agent-hooks 0.2.8 → 0.4.0

package/dist/bin/pushary.js

@@ -6,16 +6,23 @@ if (command === "setup") {
   await import("./pushary-setup.js");
 } else if (command === "hook") {
   await import("./pushary-hook.js");
+} else if (command === "clean") {
+  await import("./pushary-clean.js");
+} else if (command === "doctor") {
+  await import("./pushary-doctor.js");
 } else {
   console.log(`
 Pushary Agent Hooks
 
 Commands:
-  setup    Configure Claude Code or Cursor with Pushary
+  setup    Configure Claude Code, Codex, Hermes, or Cursor with Pushary
+  doctor   Verify your Pushary installation is working
+  clean    Remove all Pushary configuration
   hook     Run as a PreToolUse hook (reads stdin, writes stdout)
 
 Usage:
-  npx pushary setup
-  npx pushary hook
+  npx @pushary/agent-hooks@latest setup
+  npx @pushary/agent-hooks@latest doctor
+  npx @pushary/agent-hooks@latest clean
 `);
 }

package/dist/chunk-4TWRLEOX.js

@@ -0,0 +1,49 @@
+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
+};

package/dist/chunk-EQE6Z4YQ.js

@@ -0,0 +1,77 @@
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-VUNL35KE.js";
+
+// src/events.ts
+import { hostname } from "os";
+import { basename } from "path";
+var reportEvent = async (event) => {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  await fetch(`${baseUrl}/api/agent/event`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      ...event,
+      machineId: event.machineId ?? hostname()
+    })
+  });
+};
+var handlePostToolUse = async (input) => {
+  const projectName = basename(input.cwd ?? process.cwd());
+  let action;
+  switch (input.tool_name) {
+    case "Bash":
+      action = `ran: ${String(input.tool_input.command ?? "").slice(0, 120)}`;
+      break;
+    case "Write":
+      action = `wrote: ${input.tool_input.file_path ?? "unknown"}`;
+      break;
+    case "Edit":
+      action = `edited: ${input.tool_input.file_path ?? "unknown"}`;
+      break;
+    case "Read":
+      action = `read: ${input.tool_input.file_path ?? "unknown"}`;
+      break;
+    default:
+      action = `${input.tool_name}: done`;
+  }
+  const isError = input.tool_result && ("error" in input.tool_result || "is_error" in input.tool_result);
+  await reportEvent({
+    event: isError ? "tool_error" : "tool_complete",
+    agentType: "claude_code",
+    agentName: `Claude Code - ${projectName}`,
+    action,
+    error: isError ? String(input.tool_result?.error ?? input.tool_result?.stderr ?? "").slice(0, 500) : void 0
+  });
+};
+var handleStop = async (input) => {
+  const projectName = basename(input.cwd ?? process.cwd());
+  await reportEvent({
+    event: "session_end",
+    agentType: "claude_code",
+    agentName: `Claude Code - ${projectName}`,
+    action: "Session ended"
+  });
+};
+var handleNotification = async (input) => {
+  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",
+    error: input.type === "error" ? input.message : void 0
+  });
+};
+
+export {
+  reportEvent,
+  handlePostToolUse,
+  handleStop,
+  handleNotification
+};

package/dist/chunk-KINE5LNQ.js

@@ -0,0 +1,136 @@
+import {
+  askUser,
+  waitForAnswer
+} from "./chunk-4TWRLEOX.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-VUNL35KE.js";
+
+// 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, asking in terminal");
+  }
+};
+
+export {
+  getPolicy,
+  resolvePolicy,
+  handlePreToolUse
+};

package/dist/chunk-VUNL35KE.js

@@ -0,0 +1,16 @@
+// 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";
+
+export {
+  getApiKey,
+  getBaseUrl
+};

package/dist/pushary-clean-RM6TBJ3H.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+// bin/pushary-clean.ts
+import { existsSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+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 yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var check = green("\u2713");
+var skip = yellow("\u2013");
+var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_LOCAL = join(homedir(), ".claude", "settings.local.json");
+var SKILL_DIR = join(homedir(), ".claude", "skills", "pushary");
+var CURSOR_MCP = join(".cursor", "mcp.json");
+var SHELL_FILES = [".zshrc", ".bashrc"].map((f) => join(homedir(), f));
+var readJson = (path) => {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+var writeJson = (path, data) => {
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+};
+var isPusharyPermission = (rule) => rule.includes("pushary") || rule.includes("MCP(pushary");
+var isPusharyHook = (entry) => {
+  const hooks = entry.hooks;
+  if (!hooks) return false;
+  return hooks.some((h) => {
+    const cmd = String(h.command ?? "");
+    return cmd.includes("pushary-hook") || cmd.includes("pushary-post-hook") || cmd.includes("pushary-stop-hook");
+  });
+};
+var cleanSettingsFile = (path, label) => {
+  const data = readJson(path);
+  if (!data) {
+    console.log(`  ${skip} ${label} ${dim("(not found)")}`);
+    return;
+  }
+  let changed = false;
+  const mcpServers = data.mcpServers;
+  if (mcpServers?.pushary) {
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete data.mcpServers;
+    changed = true;
+  }
+  const permissions = data.permissions;
+  if (permissions?.allow) {
+    const allow = permissions.allow;
+    const filtered = allow.filter((r) => !isPusharyPermission(r));
+    if (filtered.length !== allow.length) {
+      permissions.allow = filtered;
+      if (filtered.length === 0) delete permissions.allow;
+      if (Object.keys(permissions).length === 0) delete data.permissions;
+      changed = true;
+    }
+  }
+  const hooks = data.hooks;
+  if (hooks) {
+    for (const key of ["PreToolUse", "PostToolUse", "Stop"]) {
+      const entries = hooks[key];
+      if (!entries) continue;
+      const filtered = entries.filter((e) => !isPusharyHook(e));
+      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 data.hooks;
+  }
+  if (changed) {
+    writeJson(path, data);
+    console.log(`  ${check} ${label} ${dim("(cleaned)")}`);
+  } else {
+    console.log(`  ${skip} ${label} ${dim("(no pushary entries)")}`);
+  }
+};
+var main = async () => {
+  console.log();
+  console.log(`  ${bold("Pushary Clean")}`);
+  console.log(`  ${dim("Removes all Pushary configuration")}`);
+  console.log();
+  cleanSettingsFile(CLAUDE_SETTINGS, "Claude Code settings");
+  cleanSettingsFile(CLAUDE_SETTINGS_LOCAL, "Claude Code settings.local");
+  const cursorData = readJson(CURSOR_MCP);
+  if (cursorData) {
+    const mcpServers = cursorData.mcpServers;
+    if (mcpServers?.pushary) {
+      delete mcpServers.pushary;
+      writeJson(CURSOR_MCP, cursorData);
+      console.log(`  ${check} Cursor MCP config ${dim("(cleaned)")}`);
+    } else {
+      console.log(`  ${skip} Cursor MCP config ${dim("(no pushary entries)")}`);
+    }
+  } else {
+    console.log(`  ${skip} Cursor MCP config ${dim("(not found)")}`);
+  }
+  if (existsSync(SKILL_DIR)) {
+    rmSync(SKILL_DIR, { recursive: true });
+    console.log(`  ${check} Skill directory ${dim("(removed)")}`);
+  } else {
+    console.log(`  ${skip} Skill directory ${dim("(not found)")}`);
+  }
+  const codexConfig = join(homedir(), ".codex", "config.toml");
+  try {
+    let config = readFileSync(codexConfig, "utf-8");
+    if (config.includes("pushary-codex")) {
+      config = config.split("\n").filter((l) => !l.includes("pushary-codex")).join("\n");
+      writeFileSync(codexConfig, config, "utf-8");
+      console.log(`  ${check} Codex config ${dim("(cleaned)")}`);
+    } else {
+      console.log(`  ${skip} Codex config ${dim("(no pushary entries)")}`);
+    }
+  } catch {
+    console.log(`  ${skip} Codex config ${dim("(not found)")}`);
+  }
+  for (const shellFile of SHELL_FILES) {
+    try {
+      const content = readFileSync(shellFile, "utf-8");
+      if (content.includes("PUSHARY_API_KEY")) {
+        const cleaned = content.split("\n").filter((l) => !l.includes("PUSHARY_API_KEY")).join("\n");
+        writeFileSync(shellFile, cleaned, "utf-8");
+        console.log(`  ${check} ${shellFile.split("/").pop()} ${dim("(removed API key)")}`);
+      }
+    } catch {
+    }
+  }
+  try {
+    execSync("npm uninstall -g @pushary/agent-hooks", { stdio: "ignore" });
+    console.log(`  ${check} Global package ${dim("(uninstalled)")}`);
+  } catch {
+    console.log(`  ${skip} Global package ${dim("(not installed)")}`);
+  }
+  console.log();
+  console.log(`  ${green(bold("Clean complete."))}`);
+  console.log(`  ${dim("Run")} npx @pushary/agent-hooks@latest setup ${dim("to reinstall.")}`);
+  console.log();
+};
+main();