@pushary/agent-hooks 0.2.8 → 0.3.0

package/dist/bin/pushary-codex.d.ts

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

package/dist/bin/pushary-codex.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import {
+  askUser,
+  waitForAnswer
+} from "../chunk-4TWRLEOX.js";
+import {
+  reportEvent
+} from "../chunk-EQE6Z4YQ.js";
+import {
+  getApiKey
+} from "../chunk-VUNL35KE.js";
+
+// bin/pushary-codex.ts
+import { hostname } from "os";
+import { basename } from "path";
+var main = async () => {
+  let rawInput = "";
+  for await (const chunk of process.stdin) {
+    rawInput += chunk;
+  }
+  if (!rawInput.trim()) {
+    process.exit(0);
+  }
+  let event;
+  try {
+    event = JSON.parse(rawInput);
+  } catch {
+    process.exit(0);
+  }
+  const projectName = basename(event.cwd ?? process.cwd());
+  const agentName = `Codex - ${projectName}`;
+  try {
+    if (event.type === "agent-turn-complete") {
+      await reportEvent({
+        event: "turn_complete",
+        agentType: "codex",
+        agentName,
+        action: event.message ?? "Turn complete",
+        machineId: hostname()
+      });
+      process.stdout.write(JSON.stringify({ acknowledged: true }));
+    }
+    if (event.type === "approval-requested") {
+      const apiKey = getApiKey();
+      const description = event.command ?? event.message ?? "Codex needs approval";
+      await reportEvent({
+        event: "approval_requested",
+        agentType: "codex",
+        agentName,
+        action: description,
+        machineId: hostname()
+      });
+      const result = await askUser(apiKey, {
+        question: `Allow: ${description}?`,
+        type: "confirm",
+        context: `Codex wants to run this in ${projectName}`,
+        agentName
+      });
+      const deadline = Date.now() + 12e4;
+      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) {
+          const approved = answer.value === "yes";
+          process.stdout.write(JSON.stringify({ approved }));
+          await reportEvent({
+            event: approved ? "approval_granted" : "approval_denied",
+            agentType: "codex",
+            agentName,
+            action: approved ? `Approved: ${description}` : `Denied: ${description}`,
+            machineId: hostname()
+          });
+          process.exit(0);
+        }
+        if (Date.now() + 2e3 >= deadline) break;
+        await new Promise((r) => setTimeout(r, 2e3));
+      }
+      process.stdout.write(JSON.stringify({ approved: false }));
+      process.exit(0);
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[pushary-codex] Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    if (event.type === "approval-requested") {
+      process.stdout.write(JSON.stringify({ approved: false }));
+    }
+  }
+};
+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

@@ -72,8 +72,31 @@ 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 ?? {};
@@ -95,7 +118,7 @@ var setupClaudeCode = async (apiKey) => {
     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 () => {
@@ -104,7 +127,9 @@ var setupClaudeCode = async (apiKey) => {
   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")} PreToolUse: approve Bash/Write/Edit from your phone`);
+  console.log(`  ${dim("\u2022")} PostToolUse: track when tools finish`);
+  console.log(`  ${dim("\u2022")} Stop: detect when the agent session ends`);
   console.log(`  ${dim("\u2022")} Auto-allowed tools: no permission prompts for Pushary`);
 };
 var setupHermes = async (apiKey) => {
@@ -134,6 +159,55 @@ var setupHermes = async (apiKey) => {
   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`);
+  console.log(`  ${dim("\u2022")} Uses PUSHARY_API_KEY env var for auth`);
+};
 var setupCursor = async (apiKey) => {
   console.log(`
   ${bold("Setting up Cursor")}
@@ -213,29 +287,34 @@ var main = async () => {
   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(`  ${cyan("2.")} Codex        ${dim("MCP server via codex mcp add")}`);
+  console.log(`  ${cyan("3.")} Hermes       ${dim("native plugin + auto-error notifications")}`);
+  console.log(`  ${cyan("4.")} Cursor       ${dim("MCP server")}`);
+  console.log(`  ${cyan("5.")} All          ${dim("configure everything")}`);
+  console.log(`  ${cyan("6.")} Other        ${dim("just save the API key")}`);
   console.log();
-  const choice = await ask(`  Choice ${dim("[1-5]")}: `);
+  const choice = await ask(`  Choice ${dim("[1-6]")}: `);
   await saveApiKey(trimmedKey);
   switch (choice.trim()) {
     case "1":
       await setupClaudeCode(trimmedKey);
       break;
     case "2":
-      await setupHermes(trimmedKey);
+      await setupCodex(trimmedKey);
       break;
     case "3":
-      await setupCursor(trimmedKey);
+      await setupHermes(trimmedKey);
       break;
     case "4":
+      await setupCursor(trimmedKey);
+      break;
+    case "5":
       await setupClaudeCode(trimmedKey);
+      await setupCodex(trimmedKey);
       await setupHermes(trimmedKey);
       await setupCursor(trimmedKey);
       break;
-    case "5":
+    case "6":
     default:
       break;
   }
@@ -250,7 +329,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.")} Start coding. Your agent will notify you automatically`);
   console.log();
   rl.close();
 };

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();

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/src/index.d.ts

@@ -13,6 +13,35 @@ interface HookOutput {
 }
 declare const handlePreToolUse: (input: ToolInput) => Promise<HookOutput | null>;
 
+interface AgentEvent {
+    event: string;
+    agentType: string;
+    agentName?: string;
+    action?: string;
+    machineId?: string;
+    error?: string;
+}
+declare const reportEvent: (event: AgentEvent) => Promise<void>;
+declare const handlePostToolUse: (input: {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_result?: Record<string, unknown>;
+    cwd?: string;
+    session_id?: string;
+}) => Promise<void>;
+declare const handleStop: (input: {
+    cwd?: string;
+    session_id?: string;
+    stop_hook_active?: boolean;
+}) => Promise<void>;
+declare const handleNotification: (input: {
+    message?: string;
+    title?: string;
+    type?: string;
+    cwd?: string;
+    session_id?: string;
+}) => Promise<void>;
+
 interface AskUserParams {
     question: string;
     type?: 'confirm' | 'select' | 'input';
@@ -48,4 +77,4 @@ declare const resolvePolicy: (config: PolicyConfig, toolName: string) => ToolPol
 declare const getApiKey: () => string;
 declare const getBaseUrl: () => string;
 
-export { type PolicyConfig, type ToolPolicy, askUser, cancelQuestion, getApiKey, getBaseUrl, getPolicy, handlePreToolUse, resolvePolicy, waitForAnswer };
+export { type PolicyConfig, type ToolPolicy, askUser, cancelQuestion, getApiKey, getBaseUrl, getPolicy, handleNotification, handlePostToolUse, handlePreToolUse, handleStop, reportEvent, resolvePolicy, waitForAnswer };

package/dist/src/index.js

@@ -1,20 +1,34 @@
 import {
-  askUser,
-  cancelQuestion,
-  getApiKey,
-  getBaseUrl,
   getPolicy,
   handlePreToolUse,
-  resolvePolicy,
+  resolvePolicy
+} from "../chunk-KINE5LNQ.js";
+import {
+  askUser,
+  cancelQuestion,
   waitForAnswer
-} from "../chunk-5ZMTG7GF.js";
+} from "../chunk-4TWRLEOX.js";
+import {
+  handleNotification,
+  handlePostToolUse,
+  handleStop,
+  reportEvent
+} from "../chunk-EQE6Z4YQ.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "../chunk-VUNL35KE.js";
 export {
   askUser,
   cancelQuestion,
   getApiKey,
   getBaseUrl,
   getPolicy,
+  handleNotification,
+  handlePostToolUse,
   handlePreToolUse,
+  handleStop,
+  reportEvent,
   resolvePolicy,
   waitForAnswer
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.2.8",
-  "description": "Permission hooks for AI coding agents — route tool approvals through Pushary push notifications",
+  "version": "0.3.0",
+  "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "author": "Pushary <business@pushary.com>",
   "homepage": "https://pushary.com",
   "repository": {
@@ -17,14 +17,17 @@
     "agent-hooks": "./dist/bin/pushary.js",
     "pushary": "./dist/bin/pushary.js",
     "pushary-hook": "./dist/bin/pushary-hook.js",
+    "pushary-post-hook": "./dist/bin/pushary-post-hook.js",
+    "pushary-stop-hook": "./dist/bin/pushary-stop-hook.js",
+    "pushary-codex": "./dist/bin/pushary-codex.js",
     "pushary-setup": "./dist/bin/pushary-setup.js"
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts bin/pushary.ts bin/pushary-hook.ts bin/pushary-setup.ts --format esm --dts --outDir dist",
-    "dev": "tsup src/index.ts bin/pushary.ts bin/pushary-hook.ts bin/pushary-setup.ts --format esm --watch"
+    "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 --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 --format esm --watch"
   },
   "devDependencies": {
     "tsup": "^8.0.0",