@pushary/agent-hooks 0.19.0 → 0.20.0

package/dist/bin/pushary-clean.js

@@ -6,8 +6,9 @@ import {
 import {
   execNpm,
   removeCodexHooks,
-  removeGeminiSettings
-} from "../chunk-ZWBS3T7Q.js";
+  removeGeminiSettings,
+  removeInstructionBlock
+} from "../chunk-UIBTFZUD.js";
 
 // bin/pushary-clean.ts
 import { existsSync, readFileSync, writeFileSync, rmSync } from "fs";
@@ -135,6 +136,19 @@ var main = async () => {
   } else {
     console.log(`  ${skip} Codex hooks ${dim("(not found)")}`);
   }
+  const codexAgentsMd = join(homedir(), ".codex", "AGENTS.md");
+  if (removeInstructionBlock(codexAgentsMd)) {
+    console.log(`  ${check} Codex AGENTS.md ${dim("(removed Pushary block)")}`);
+  } else {
+    console.log(`  ${skip} Codex AGENTS.md ${dim("(no pushary block)")}`);
+  }
+  const codexSkillDir = join(homedir(), ".codex", "skills", "pushary");
+  if (existsSync(codexSkillDir)) {
+    rmSync(codexSkillDir, { recursive: true });
+    console.log(`  ${check} Codex skill directory ${dim("(removed)")}`);
+  } else {
+    console.log(`  ${skip} Codex skill directory ${dim("(not found)")}`);
+  }
   const geminiSettingsPath = join(homedir(), ".gemini", "settings.json");
   const geminiSettings = readJson(geminiSettingsPath);
   if (geminiSettings) {
@@ -147,6 +161,12 @@ var main = async () => {
   } else {
     console.log(`  ${skip} Gemini CLI settings ${dim("(not found)")}`);
   }
+  const geminiMd = join(homedir(), ".gemini", "GEMINI.md");
+  if (removeInstructionBlock(geminiMd)) {
+    console.log(`  ${check} Gemini GEMINI.md ${dim("(removed Pushary block)")}`);
+  } else {
+    console.log(`  ${skip} Gemini GEMINI.md ${dim("(no pushary block)")}`);
+  }
   for (const shellFile of SHELL_FILES) {
     try {
       const content = readFileSync(shellFile, "utf-8");

package/dist/bin/pushary-doctor.js

@@ -4,9 +4,10 @@ import {
   execNpm,
   hasCodexHooks,
   hasGeminiHooks,
+  hasInstructionBlock,
   missingCodexHookEvents,
   missingGeminiHookEvents
-} from "../chunk-ZWBS3T7Q.js";
+} from "../chunk-UIBTFZUD.js";
 import {
   callMcpTool,
   sendMcpRequest
@@ -189,6 +190,9 @@ var main = async () => {
     }
     const codexSkillPath = join(homedir(), ".codex", "skills", "pushary", "SKILL.md");
     check(existsSync(codexSkillPath), "Codex: skill installed");
+    const codexAgentsMd = join(homedir(), ".codex", "AGENTS.md");
+    const hasCodexInstructions = hasInstructionBlock(codexAgentsMd);
+    check(hasCodexInstructions, "Codex: proactive instructions (AGENTS.md)", hasCodexInstructions ? codexAgentsMd : "missing \u2014 re-run setup so Codex asks via push, not the terminal");
   }
   const geminiSettingsPath = join(homedir(), ".gemini", "settings.json");
   const geminiSettings = readJson(geminiSettingsPath);
@@ -213,6 +217,9 @@ var main = async () => {
     } else {
       check(false, "Gemini CLI: native hooks installed", "no Pushary hooks in ~/.gemini/settings.json \u2014 re-run setup");
     }
+    const geminiMd = join(homedir(), ".gemini", "GEMINI.md");
+    const hasGeminiInstructions = hasInstructionBlock(geminiMd);
+    check(hasGeminiInstructions, "Gemini CLI: proactive instructions (GEMINI.md)", hasGeminiInstructions ? geminiMd : "missing \u2014 re-run setup so Gemini asks via push, not the terminal");
   }
   const cursorPluginDir = join(homedir(), ".cursor", "plugins", "local", "pushary");
   if (existsSync(cursorPluginDir)) {

package/dist/bin/pushary-setup.js

@@ -11,8 +11,10 @@ import {
   addGeminiHooks,
   addGeminiMcpServer,
   execNpm,
-  npmErrorMessage
-} from "../chunk-ZWBS3T7Q.js";
+  npmErrorMessage,
+  renderAgentInstructions,
+  writeInstructionBlock
+} from "../chunk-UIBTFZUD.js";
 import {
   isValidApiKey
 } from "../chunk-USUCPCUC.js";
@@ -303,7 +305,9 @@ var CURSOR_USER_HOOKS = join(homedir(), ".cursor", "hooks.json");
 var CLAUDE_SKILL_DIR = join(homedir(), ".claude", "skills", "pushary");
 var CODEX_HOME = process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
 var CODEX_SKILL_DIR = join(CODEX_HOME, "skills", "pushary");
+var CODEX_AGENTS_MD = join(CODEX_HOME, "AGENTS.md");
 var GEMINI_SETTINGS = join(homedir(), ".gemini", "settings.json");
+var GEMINI_MD = join(homedir(), ".gemini", "GEMINI.md");
 var PUSHARY_CONFIG_DIR = join(homedir(), ".pushary");
 var PUSHARY_CONFIG_FILE = join(PUSHARY_CONFIG_DIR, "config.json");
 var SHELL_FILES = [".zshrc", ".zprofile", ".bashrc", ".bash_profile"].map((f) => join(homedir(), f));
@@ -667,9 +671,13 @@ var setupCodex = async (_apiKey) => {
     });
   }
   await installSkillToDir(CODEX_SKILL_DIR, "Installing Pushary skill");
+  await spinner("Teaching Codex to ask via push (~/.codex/AGENTS.md)", async () => {
+    writeInstructionBlock(CODEX_AGENTS_MD, renderAgentInstructions("Codex"));
+  });
   console.log();
   console.log(`  ${dim2("What this configured:")}`);
   console.log(`  ${dim2("\u2022")} MCP server: Codex can send notifications and ask questions`);
+  console.log(`  ${dim2("\u2022")} Proactive instructions: ~/.codex/AGENTS.md tells Codex to ask via push, not the terminal`);
   console.log(`  ${dim2("\u2022")} Auto-allowed tools: no permission prompts for Pushary MCP calls`);
   if (hooksSupported) {
     console.log(`  ${dim2("\u2022")} Native hooks: phone approvals, policy enforcement, kill switch, session tracking`);
@@ -829,9 +837,13 @@ var setupGemini = async (apiKey) => {
   await spinner(`Writing ${GEMINI_SETTINGS}`, async () => {
     writeJson(GEMINI_SETTINGS, settings);
   });
+  await spinner("Teaching Gemini to ask via push (~/.gemini/GEMINI.md)", async () => {
+    writeInstructionBlock(GEMINI_MD, renderAgentInstructions("Gemini"));
+  });
   console.log();
   console.log(`  ${dim2("What this configured:")}`);
   console.log(`  ${dim2("\u2022")} MCP server: Gemini can send notifications and ask questions`);
+  console.log(`  ${dim2("\u2022")} Proactive instructions: ~/.gemini/GEMINI.md tells Gemini to ask via push, not the terminal`);
   console.log(`  ${dim2("\u2022")} Hooks: phone approvals, policy enforcement, kill switch, session tracking`);
   console.log(`  ${dim2("\u2022")} Gate covers ${bold2("run_shell_command")}, ${bold2("write_file")}, and ${bold2("replace")}`);
   console.log(`  ${dim2("\u2022")} Auto-allowed tools: Pushary MCP calls run without a confirmation prompt`);

package/dist/chunk-UIBTFZUD.js

@@ -0,0 +1,314 @@
+// src/codex-config.ts
+import { createHash } from "crypto";
+var CODEX_HOOK_BINARY = "pushary-codex-hook";
+var CODEX_HOOK_EVENTS = [
+  { event: "PermissionRequest", matcher: "Bash|apply_patch", timeout: 180, statusMessage: "Waiting for your phone" },
+  { event: "PreToolUse", matcher: "Bash|apply_patch", timeout: 180, statusMessage: "Checking Pushary policy" },
+  { event: "PostToolUse", matcher: "Bash|apply_patch", timeout: 10 },
+  { event: "UserPromptSubmit", timeout: 10 },
+  { event: "Stop", timeout: 10 },
+  { event: "SessionStart", matcher: "startup|resume", timeout: 10 }
+];
+var CODEX_EVENT_KEY = {
+  PermissionRequest: "permission_request",
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  UserPromptSubmit: "user_prompt_submit",
+  Stop: "stop",
+  SessionStart: "session_start"
+};
+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 isPusharyCodexHook = (entry) => {
+  const hooks = asRecord(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => String(asRecord(hook)?.command ?? "").includes(CODEX_HOOK_BINARY));
+};
+var addCodexHooks = (config, command) => {
+  const hooks = ensureRecord(config, "hooks");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[definition.event]) ? hooks[definition.event] : [];
+    const entries = existing.filter((entry) => !isPusharyCodexHook(entry));
+    entries.push({
+      ...definition.matcher ? { matcher: definition.matcher } : {},
+      hooks: [{
+        type: "command",
+        command,
+        timeout: definition.timeout,
+        ...definition.statusMessage ? { statusMessage: definition.statusMessage } : {}
+      }]
+    });
+    hooks[definition.event] = entries;
+  }
+};
+var removeCodexHooks = (config) => {
+  const hooks = asRecord(config.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry) => !isPusharyCodexHook(entry));
+    if (filtered.length !== entries.length) {
+      if (filtered.length === 0) {
+        delete hooks[definition.event];
+      } else {
+        hooks[definition.event] = filtered;
+      }
+      changed = true;
+    }
+  }
+  if (Object.keys(hooks).length === 0) delete config.hooks;
+  return changed;
+};
+var hasCodexHooks = (config) => {
+  const hooks = asRecord(config.hooks);
+  if (!hooks) return false;
+  return CODEX_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some(isPusharyCodexHook);
+  });
+};
+var missingCodexHookEvents = (config) => {
+  const hooks = asRecord(config.hooks);
+  return CODEX_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some(isPusharyCodexHook);
+  }).map((definition) => definition.event);
+};
+var canonicalJson = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
+  const obj = value;
+  return "{" + Object.keys(obj).sort().map((key) => JSON.stringify(key) + ":" + canonicalJson(obj[key])).join(",") + "}";
+};
+var codexHookTrustHash = (definition, command) => {
+  const hook = { async: false, command, timeout: definition.timeout, type: "command" };
+  if (definition.statusMessage) hook.statusMessage = definition.statusMessage;
+  const identity = { event_name: CODEX_EVENT_KEY[definition.event], hooks: [hook] };
+  if (definition.matcher) identity.matcher = definition.matcher;
+  return "sha256:" + createHash("sha256").update(canonicalJson(identity), "utf8").digest("hex");
+};
+var codexHookStateKey = (hooksJsonPath, event) => `${hooksJsonPath}:${CODEX_EVENT_KEY[event]}:0:0`;
+var addCodexHookTrust = (config, hooksJsonPath, command) => {
+  const hooks = ensureRecord(config, "hooks");
+  const state = ensureRecord(hooks, "state");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const key = codexHookStateKey(hooksJsonPath, definition.event);
+    const existing = asRecord(state[key]) ?? {};
+    state[key] = { ...existing, trusted_hash: codexHookTrustHash(definition, command) };
+  }
+};
+
+// src/gemini-config.ts
+var GEMINI_HOOK_BINARY = "pushary-gemini-hook";
+var GEMINI_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var GEMINI_HOOK_EVENTS = [
+  { event: "BeforeTool", matcher: "run_shell_command|write_file|replace", timeoutMs: 18e4 },
+  { event: "AfterTool", matcher: "run_shell_command|write_file|replace", timeoutMs: 1e4 },
+  { event: "BeforeAgent", timeoutMs: 1e4 },
+  { event: "SessionStart", timeoutMs: 1e4 },
+  { event: "SessionEnd", timeoutMs: 1e4 }
+];
+var asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord2 = (target, key) => {
+  const existing = asRecord2(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyGeminiHook = (entry) => {
+  const hooks = asRecord2(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => String(asRecord2(hook)?.command ?? "").includes(GEMINI_HOOK_BINARY));
+};
+var addGeminiMcpServer = (settings, apiKey) => {
+  const mcpServers = ensureRecord2(settings, "mcpServers");
+  mcpServers.pushary = {
+    httpUrl: GEMINI_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` },
+    trust: true
+  };
+};
+var addGeminiHooks = (settings, command) => {
+  const hooks = ensureRecord2(settings, "hooks");
+  for (const definition of GEMINI_HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[definition.event]) ? hooks[definition.event] : [];
+    const entries = existing.filter((entry) => !isPusharyGeminiHook(entry));
+    entries.push({
+      ...definition.matcher ? { matcher: definition.matcher } : {},
+      hooks: [{
+        name: "pushary",
+        type: "command",
+        command,
+        timeout: definition.timeoutMs
+      }]
+    });
+    hooks[definition.event] = entries;
+  }
+};
+var removeGeminiHooks = (settings) => {
+  const hooks = asRecord2(settings.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const definition of GEMINI_HOOK_EVENTS) {
+    const entries = hooks[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry) => !isPusharyGeminiHook(entry));
+    if (filtered.length !== entries.length) {
+      if (filtered.length === 0) {
+        delete hooks[definition.event];
+      } else {
+        hooks[definition.event] = filtered;
+      }
+      changed = true;
+    }
+  }
+  if (Object.keys(hooks).length === 0) delete settings.hooks;
+  return changed;
+};
+var removeGeminiMcpServer = (settings) => {
+  const mcpServers = asRecord2(settings.mcpServers);
+  if (!mcpServers?.pushary) return false;
+  delete mcpServers.pushary;
+  if (Object.keys(mcpServers).length === 0) delete settings.mcpServers;
+  return true;
+};
+var removeGeminiSettings = (settings) => {
+  const mcpRemoved = removeGeminiMcpServer(settings);
+  const hooksRemoved = removeGeminiHooks(settings);
+  return mcpRemoved || hooksRemoved;
+};
+var hasGeminiHooks = (settings) => {
+  const hooks = asRecord2(settings.hooks);
+  if (!hooks) return false;
+  return GEMINI_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some(isPusharyGeminiHook);
+  });
+};
+var missingGeminiHookEvents = (settings) => {
+  const hooks = asRecord2(settings.hooks);
+  return GEMINI_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some(isPusharyGeminiHook);
+  }).map((definition) => definition.event);
+};
+
+// src/instruction-file.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { dirname } from "path";
+var PUSHARY_BEGIN = "<!-- BEGIN PUSHARY (managed by @pushary/agent-hooks; do not edit this block) -->";
+var PUSHARY_END = "<!-- END PUSHARY -->";
+var instructionBody = (label) => `## Pushary notifications and approvals
+
+You have Pushary MCP tools that reach the user on their phone. Use them proactively. Do not wait for the user to ask.
+
+- When you need the user to make a decision or answer a clarifying question, call \`ask_user\` instead of guessing or stalling. Use type "confirm" for yes/no, "select" for a fixed set of options, and "input" for free text. \`ask_user\` blocks until the user replies or it times out, so you do not need a separate wait step.
+- Before any risky or irreversible step (deleting files, force pushing, spending money, sending external messages), call \`ask_user\` with type "confirm" and wait for approval.
+- When you are blocked, stuck, or hit an error you cannot resolve on your own, call \`send_notification\` so the user knows, and call \`ask_user\` if you need a decision to continue.
+- When a task that took several steps finishes, call \`send_notification\` so the user knows it is done.
+- Use \`cancel_question\` to retract a pending question once it is no longer needed.
+
+Pass \`agentName\` as "${label} - <project folder name>" so the user knows which session is asking. If a question times out with no answer, retry once with a longer timeout before falling back to asking in the terminal.`;
+var renderAgentInstructions = (label) => instructionBody(label);
+var wrap = (body) => `${PUSHARY_BEGIN}
+${body}
+${PUSHARY_END}`;
+var writeInstructionBlock = (filePath, body) => {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+  }
+  const block = wrap(body);
+  const start = existing.indexOf(PUSHARY_BEGIN);
+  const end = existing.indexOf(PUSHARY_END);
+  let next;
+  if (start !== -1 && end !== -1 && end > start) {
+    next = existing.slice(0, start) + block + existing.slice(end + PUSHARY_END.length);
+  } else {
+    const prefix = existing.trim() ? existing.replace(/\s*$/, "") + "\n\n" : "";
+    next = prefix + block + "\n";
+  }
+  writeFileSync(filePath, next, "utf-8");
+};
+var removeInstructionBlock = (filePath) => {
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+    return false;
+  }
+  const start = existing.indexOf(PUSHARY_BEGIN);
+  const end = existing.indexOf(PUSHARY_END);
+  if (start === -1 || end === -1 || end < start) return false;
+  const remaining = (existing.slice(0, start) + existing.slice(end + PUSHARY_END.length)).trim();
+  if (remaining === "") {
+    rmSync(filePath, { force: true });
+  } else {
+    writeFileSync(filePath, remaining + "\n", "utf-8");
+  }
+  return true;
+};
+var hasInstructionBlock = (filePath) => {
+  try {
+    return readFileSync(filePath, "utf-8").includes(PUSHARY_BEGIN);
+  } catch {
+    return false;
+  }
+};
+
+// src/npm.ts
+import { execSync } from "child_process";
+var cleanNpmEnv = () => {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.toLowerCase().startsWith("npm_config_workspace")) continue;
+    env[key] = value;
+  }
+  return env;
+};
+var npmErrorMessage = (err) => {
+  const e = err;
+  const text = [e?.stderr, e?.stdout].map((part) => part ? part.toString() : "").join("\n");
+  const line = text.split("\n").map((l) => l.replace(/^npm error\s*/i, "").trim()).find((l) => l && !l.startsWith("A complete log") && !/^code\s/i.test(l));
+  return line || e?.message || String(err);
+};
+var execNpm = (args, options = {}) => {
+  return execSync(`npm ${args}`, {
+    timeout: 12e4,
+    stdio: "pipe",
+    ...options,
+    env: { ...cleanNpmEnv(), ...options.env ?? {} }
+  });
+};
+
+export {
+  addCodexHooks,
+  removeCodexHooks,
+  hasCodexHooks,
+  missingCodexHookEvents,
+  addCodexHookTrust,
+  GEMINI_HOOK_BINARY,
+  addGeminiMcpServer,
+  addGeminiHooks,
+  removeGeminiSettings,
+  hasGeminiHooks,
+  missingGeminiHookEvents,
+  renderAgentInstructions,
+  writeInstructionBlock,
+  removeInstructionBlock,
+  hasInstructionBlock,
+  npmErrorMessage,
+  execNpm
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "author": "Pushary <business@pushary.com>",
   "homepage": "https://pushary.com",
@@ -38,7 +38,7 @@
   "scripts": {
     "build": "node scripts/bundle-plugin.mjs && tsup",
     "dev": "tsup --watch",
-    "test": "bun test src/api.test.ts && bun test src/claude-config.test.ts && bun test src/config.test.ts && bun test src/mcp-http.test.ts && bun test src/retry.test.ts && bun test src/usage.test.ts && bun test src/validate.test.ts && bun test src/policy.test.ts && bun test src/npm.test.ts && bun test src/identity.test.ts && bun test src/pending.test.ts && bun test src/events.test.ts && bun test src/describe.test.ts && bun test src/suggestions.test.ts && bun test src/safe-commands.test.ts && bun test src/hook.test.ts && bun test src/codex-adapter.test.ts && bun test src/codex-config.test.ts && bun test src/gemini-adapter.test.ts && bun test src/gemini-config.test.ts && bun test src/pairing.test.ts"
+    "test": "bun test src/api.test.ts && bun test src/claude-config.test.ts && bun test src/config.test.ts && bun test src/mcp-http.test.ts && bun test src/retry.test.ts && bun test src/usage.test.ts && bun test src/validate.test.ts && bun test src/policy.test.ts && bun test src/npm.test.ts && bun test src/identity.test.ts && bun test src/pending.test.ts && bun test src/events.test.ts && bun test src/describe.test.ts && bun test src/suggestions.test.ts && bun test src/safe-commands.test.ts && bun test src/hook.test.ts && bun test src/codex-adapter.test.ts && bun test src/codex-config.test.ts && bun test src/gemini-adapter.test.ts && bun test src/gemini-config.test.ts && bun test src/instruction-file.test.ts && bun test src/pairing.test.ts"
   },
   "dependencies": {
     "@inquirer/prompts": "^8.4.2",