@pushary/agent-hooks 0.18.3 → 0.20.0

package/dist/bin/pushary-clean.js

@@ -5,8 +5,10 @@ import {
 } from "../chunk-5MA3CPZB.js";
 import {
   execNpm,
-  removeCodexHooks
-} from "../chunk-VC6U3QGF.js";
+  removeCodexHooks,
+  removeGeminiSettings,
+  removeInstructionBlock
+} from "../chunk-UIBTFZUD.js";
 
 // bin/pushary-clean.ts
 import { existsSync, readFileSync, writeFileSync, rmSync } from "fs";
@@ -134,6 +136,37 @@ 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) {
+    if (removeGeminiSettings(geminiSettings)) {
+      writeJson(geminiSettingsPath, geminiSettings);
+      console.log(`  ${check} Gemini CLI settings ${dim("(cleaned)")}`);
+    } else {
+      console.log(`  ${skip} Gemini CLI settings ${dim("(no pushary entries)")}`);
+    }
+  } 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-codex-hook.js

@@ -12,7 +12,7 @@ import {
   reportEvent,
   toCodexWire,
   toPolicyLookup
-} from "../chunk-Y633ZIJF.js";
+} from "../chunk-QY4L6XHN.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -25,8 +25,8 @@ import {
   savePendingQuestion,
   sendNotification,
   waitForAnswer
-} from "../chunk-2BE2IPMO.js";
-import "../chunk-RZLVE57X.js";
+} from "../chunk-ACE77TKQ.js";
+import "../chunk-USUCPCUC.js";
 import "../chunk-DWED7BS3.js";
 import {
   getApiKey

package/dist/bin/pushary-codex.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   reportEvent
-} from "../chunk-Y633ZIJF.js";
+} from "../chunk-QY4L6XHN.js";
 import {
   askUser,
   getMachineId,
   waitForAnswer
-} from "../chunk-2BE2IPMO.js";
-import "../chunk-RZLVE57X.js";
+} from "../chunk-ACE77TKQ.js";
+import "../chunk-USUCPCUC.js";
 import "../chunk-DWED7BS3.js";
 import {
   getApiKey

package/dist/bin/pushary-doctor.js

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
 import {
+  GEMINI_HOOK_BINARY,
   execNpm,
   hasCodexHooks,
-  missingCodexHookEvents
-} from "../chunk-VC6U3QGF.js";
+  hasGeminiHooks,
+  hasInstructionBlock,
+  missingCodexHookEvents,
+  missingGeminiHookEvents
+} from "../chunk-UIBTFZUD.js";
 import {
   callMcpTool,
   sendMcpRequest
@@ -186,6 +190,36 @@ 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);
+  if (geminiSettings) {
+    const geminiServers = geminiSettings.mcpServers ?? {};
+    const geminiPushary = geminiServers.pushary;
+    check(!!geminiPushary, "Gemini CLI: MCP server configured");
+    if (geminiPushary) {
+      check(typeof geminiPushary.httpUrl === "string", "Gemini CLI: MCP transport", geminiPushary.httpUrl ? String(geminiPushary.httpUrl) : "missing \u2014 add httpUrl");
+      check(geminiPushary.trust === true, "Gemini CLI: tools auto-allowed", geminiPushary.trust === true ? "trust: true" : "missing \u2014 MCP calls will prompt for confirmation");
+    }
+    const geminiHooksInstalled = hasGeminiHooks(geminiSettings);
+    if (geminiHooksInstalled) {
+      const missingEvents = missingGeminiHookEvents(geminiSettings);
+      check(missingEvents.length === 0, "Gemini CLI: native hooks installed", missingEvents.length === 0 ? "all 5 events" : `missing ${missingEvents.join(", ")}, re-run setup`);
+      const geminiHooks = geminiSettings.hooks;
+      const hookCommand = extractHookCommand(geminiHooks?.BeforeTool, GEMINI_HOOK_BINARY);
+      if (hookCommand) {
+        const resolves = commandResolves(hookCommand);
+        check(resolves, "Gemini CLI: hook command resolves", resolves ? hookCommand : `not on PATH: ${hookCommand}`);
+      }
+    } 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-gemini-hook.d.ts

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

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

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import {
+  handlePostToolUse,
+  handleStop,
+  handleUserPrompt,
+  reportEvent
+} from "../chunk-QY4L6XHN.js";
+import {
+  DEFAULT_SESSION,
+  askUser,
+  deriveToolTarget,
+  describeToolCall,
+  fetchModeState,
+  getMachineId,
+  getPolicy,
+  resolvePolicy,
+  savePendingQuestion,
+  sendNotification,
+  waitForAnswer
+} from "../chunk-ACE77TKQ.js";
+import "../chunk-USUCPCUC.js";
+import "../chunk-DWED7BS3.js";
+import {
+  getApiKey
+} from "../chunk-NKXSILEW.js";
+
+// bin/pushary-gemini-hook.ts
+import { basename } from "path";
+
+// src/gemini-adapter.ts
+var GEMINI_AGENT = { type: "gemini_cli", label: "Gemini CLI" };
+var GEMINI_TOOL_MAP = {
+  run_shell_command: "Bash",
+  write_file: "Write",
+  replace: "Edit",
+  read_file: "Read"
+};
+var firstString = (...values) => values.find((v) => typeof v === "string" && v.length > 0);
+var toGeminiPolicyLookup = (toolName, toolInput) => {
+  const canonical = GEMINI_TOOL_MAP[toolName];
+  if (!canonical) return { tool: toolName, input: toolInput };
+  if (canonical === "Bash") {
+    const command = firstString(toolInput.command);
+    return { tool: "Bash", input: command ? { command } : {} };
+  }
+  const filePath = firstString(toolInput.file_path, toolInput.absolute_path, toolInput.path);
+  return { tool: canonical, input: filePath ? { file_path: filePath } : {} };
+};
+var geminiAllow = () => ({ kind: "allow" });
+var geminiDeny = (reason) => ({ kind: "deny", reason });
+var geminiPass = () => ({ kind: "pass" });
+var toGeminiWire = (decision) => {
+  if (decision.kind === "allow") return { decision: "allow" };
+  if (decision.kind === "deny") return { decision: "deny", reason: decision.reason };
+  return null;
+};
+var geminiTimeoutDecision = (timeoutAction, denyReason = "No response within timeout") => {
+  if (timeoutAction === "approve") return geminiAllow();
+  if (timeoutAction === "deny") return geminiDeny(denyReason);
+  return geminiPass();
+};
+
+// bin/pushary-gemini-hook.ts
+var KILL_REASON = "Stopped by user: this agent was halted from Pushary";
+var MAX_WAIT_SECONDS = 170;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var denyReasonFrom = (value) => value && value !== "no" && value !== "yes" ? `Denied from your phone: ${value}` : "Denied via push notification";
+var pollForAnswer = async (apiKey, correlationId, deadlineMs, pollInterval = 2e3) => {
+  while (Date.now() < deadlineMs) {
+    const remaining = Math.min(Math.max(deadlineMs - Date.now(), 1e3), 3e4);
+    let answer;
+    try {
+      answer = await waitForAnswer(apiKey, correlationId, remaining);
+    } catch {
+      if (Date.now() + pollInterval >= deadlineMs) break;
+      await sleep(pollInterval);
+      continue;
+    }
+    if (answer.answered) return answer;
+    if (Date.now() + pollInterval >= deadlineMs) break;
+    await sleep(pollInterval);
+  }
+  return { answered: false };
+};
+var agentNameFor = (input) => `${GEMINI_AGENT.label} - ${basename(input.cwd ?? process.cwd())}`;
+var pushQuestion = async (apiKey, input, lookup, waitSeconds, pollInterval = 2e3) => {
+  const projectName = basename(input.cwd ?? process.cwd());
+  const description = describeToolCall(lookup.tool, lookup.input, "hook");
+  const result = await askUser(apiKey, {
+    question: `Allow ${description}?`,
+    type: "confirm",
+    context: `Agent wants to run this in ${projectName}`,
+    agentName: agentNameFor(input),
+    sessionId: input.session_id,
+    machineId: getMachineId(),
+    toolName: lookup.tool,
+    toolTarget: deriveToolTarget(lookup.tool, lookup.input)
+  });
+  const deadline = Date.now() + Math.min(waitSeconds, MAX_WAIT_SECONDS) * 1e3;
+  const answer = await pollForAnswer(apiKey, result.correlationId, deadline, pollInterval);
+  return { answer, correlationId: result.correlationId };
+};
+var notifyApprovalNeeded = async (apiKey, input, lookup) => {
+  try {
+    await sendNotification(apiKey, {
+      title: "Agent needs approval",
+      body: describeToolCall(lookup.tool, lookup.input, "hook"),
+      agentName: agentNameFor(input),
+      sessionId: input.session_id,
+      machineId: getMachineId()
+    });
+  } catch {
+  }
+};
+var handlePushOnly = async (apiKey, input, lookup, timeoutSeconds, timeoutAction) => {
+  let pushed;
+  try {
+    pushed = await pushQuestion(apiKey, input, lookup, timeoutSeconds);
+  } catch {
+    return geminiTimeoutDecision(timeoutAction, "Push notification failed, denying per policy");
+  }
+  const { answer, correlationId } = pushed;
+  if (answer.answered) {
+    return answer.value === "yes" ? geminiAllow() : geminiDeny(denyReasonFrom(answer.value));
+  }
+  savePendingQuestion(input.session_id || DEFAULT_SESSION, correlationId);
+  return geminiTimeoutDecision(timeoutAction);
+};
+var handlePushFirst = async (apiKey, input, lookup, pushFirstSeconds) => {
+  let pushed;
+  try {
+    pushed = await pushQuestion(apiKey, input, lookup, pushFirstSeconds, 1500);
+  } catch {
+    return geminiPass();
+  }
+  const { answer, correlationId } = pushed;
+  if (answer.answered) {
+    return answer.value === "yes" ? geminiAllow() : geminiDeny(denyReasonFrom(answer.value));
+  }
+  savePendingQuestion(input.session_id || DEFAULT_SESSION, correlationId);
+  return geminiPass();
+};
+var decideBeforeTool = async (input) => {
+  try {
+    const apiKey = getApiKey();
+    const modeState = await fetchModeState(apiKey, input.session_id);
+    if (modeState.kill) return geminiDeny(KILL_REASON);
+    const lookup = toGeminiPolicyLookup(input.tool_name ?? "", input.tool_input ?? {});
+    const policy = await getPolicy(apiKey, modeState.policyVersion);
+    const toolPolicy = resolvePolicy(policy, lookup.tool, modeState.mode, lookup.input);
+    if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "approve") return geminiAllow();
+    if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "deny") {
+      return geminiDeny(`Denied by policy for ${toolPolicy.tool}`);
+    }
+    switch (toolPolicy.mode) {
+      case "push_only":
+        return handlePushOnly(apiKey, input, lookup, toolPolicy.timeoutSeconds, toolPolicy.timeoutAction);
+      case "terminal_only":
+        return geminiPass();
+      case "push_first":
+        return handlePushFirst(apiKey, input, lookup, toolPolicy.pushFirstSeconds);
+      case "notify_only":
+        await notifyApprovalNeeded(apiKey, input, lookup);
+        return geminiPass();
+      default:
+        return handlePushFirst(apiKey, input, lookup, toolPolicy.pushFirstSeconds);
+    }
+  } catch {
+    return geminiPass();
+  }
+};
+var reportSessionStart = async (input) => {
+  try {
+    await reportEvent({
+      event: "session_begin",
+      agentType: GEMINI_AGENT.type,
+      agentName: agentNameFor(input),
+      action: "Session started",
+      sessionId: input.session_id
+    }, { maxAttempts: 1, timeoutMs: 5e3 });
+  } catch {
+  }
+};
+var toCanonicalResult = (toolResponse) => {
+  if (!toolResponse || typeof toolResponse !== "object" || Array.isArray(toolResponse)) return void 0;
+  const error = toolResponse.error;
+  return error ? { error } : {};
+};
+var emit = (wire) => {
+  if (wire) process.stdout.write(JSON.stringify(wire));
+};
+var main = async () => {
+  let rawInput = "";
+  for await (const chunk of process.stdin) {
+    rawInput += chunk;
+  }
+  if (!rawInput.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(rawInput);
+  } catch {
+    process.exit(0);
+  }
+  try {
+    switch (input.hook_event_name) {
+      case "BeforeTool":
+        emit(toGeminiWire(await decideBeforeTool(input)));
+        break;
+      case "AfterTool": {
+        const lookup = toGeminiPolicyLookup(input.tool_name ?? "", input.tool_input ?? {});
+        await handlePostToolUse({
+          tool_name: lookup.tool,
+          tool_input: lookup.input,
+          tool_result: toCanonicalResult(input.tool_response),
+          cwd: input.cwd,
+          session_id: input.session_id,
+          transcript_path: input.transcript_path
+        }, GEMINI_AGENT);
+        break;
+      }
+      case "BeforeAgent":
+        await handleUserPrompt({
+          prompt: input.prompt,
+          cwd: input.cwd,
+          session_id: input.session_id
+        }, GEMINI_AGENT);
+        break;
+      case "SessionEnd":
+        await handleStop({
+          cwd: input.cwd,
+          session_id: input.session_id,
+          transcript_path: input.transcript_path
+        }, GEMINI_AGENT);
+        break;
+      case "SessionStart":
+        await reportSessionStart(input);
+        break;
+      default:
+        break;
+    }
+  } catch {
+  }
+};
+main();

package/dist/bin/pushary-hook.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   handlePreToolUse
-} from "../chunk-DKZVKEOW.js";
-import "../chunk-2BE2IPMO.js";
-import "../chunk-RZLVE57X.js";
+} from "../chunk-SDREQWNI.js";
+import "../chunk-ACE77TKQ.js";
+import "../chunk-USUCPCUC.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-NKXSILEW.js";
 

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

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   handlePostToolUse
-} from "../chunk-Y633ZIJF.js";
-import "../chunk-2BE2IPMO.js";
-import "../chunk-RZLVE57X.js";
+} from "../chunk-QY4L6XHN.js";
+import "../chunk-ACE77TKQ.js";
+import "../chunk-USUCPCUC.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-NKXSILEW.js";
 

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

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   handleUserPrompt
-} from "../chunk-Y633ZIJF.js";
-import "../chunk-2BE2IPMO.js";
-import "../chunk-RZLVE57X.js";
+} from "../chunk-QY4L6XHN.js";
+import "../chunk-ACE77TKQ.js";
+import "../chunk-USUCPCUC.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-NKXSILEW.js";
 

package/dist/bin/pushary-setup.js

@@ -5,14 +5,19 @@ import {
   addPusharyToolPermissions
 } from "../chunk-5MA3CPZB.js";
 import {
+  GEMINI_HOOK_BINARY,
   addCodexHookTrust,
   addCodexHooks,
+  addGeminiHooks,
+  addGeminiMcpServer,
   execNpm,
-  npmErrorMessage
-} from "../chunk-VC6U3QGF.js";
+  npmErrorMessage,
+  renderAgentInstructions,
+  writeInstructionBlock
+} from "../chunk-UIBTFZUD.js";
 import {
   isValidApiKey
-} from "../chunk-RZLVE57X.js";
+} from "../chunk-USUCPCUC.js";
 
 // bin/pushary-setup.ts
 import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync, cpSync, rmSync, chmodSync } from "fs";
@@ -300,6 +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));
@@ -663,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`);
@@ -799,9 +811,48 @@ var setupCustom = async (_apiKey) => {
   console.log();
   console.log(`  ${dim2("Full guide:")} ${cyan2("https://pushary.com/docs/agents/connect-any-agent")}`);
 };
+var setupGemini = async (apiKey) => {
+  console.log(`
+  ${bold2("Setting up Gemini CLI")}
+`);
+  if (!isInstalled("gemini")) {
+    console.log(`  ${yellow2("!")} Gemini CLI not found. Skipping.`);
+    console.log(`  ${dim2("Install Gemini CLI and re-run setup to configure.")}`);
+    return;
+  }
+  await installGlobally();
+  const settings = readJson(GEMINI_SETTINGS);
+  await spinner("Adding MCP server (~/.gemini/settings.json)", async () => {
+    addGeminiMcpServer(settings, apiKey);
+  });
+  await spinner("Adding hooks (BeforeTool, AfterTool, BeforeAgent, SessionStart, SessionEnd)", async () => {
+    let hookCommand = GEMINI_HOOK_BINARY;
+    try {
+      const candidate = join(execNpm("prefix -g --no-workspaces", { timeout: 5e3 }).toString().trim(), "bin", GEMINI_HOOK_BINARY);
+      if (existsSync(candidate)) hookCommand = candidate;
+    } catch {
+    }
+    addGeminiHooks(settings, hookCommand);
+  });
+  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`);
+  console.log(`  ${dim2("Restart Gemini CLI to load the new config.")}`);
+};
 var AGENT_SETUP = {
   claude_code: setupClaudeCode,
   codex: setupCodex,
+  gemini_cli: setupGemini,
   hermes: setupHermes,
   cursor: setupCursor,
   custom: setupCustom
@@ -865,6 +916,7 @@ var main = async () => {
   const detected = {
     claude_code: isInstalled("claude"),
     codex: isInstalled("codex"),
+    gemini_cli: isInstalled("gemini"),
     hermes: isInstalled("hermes"),
     cursor: isInstalled("cursor"),
     custom: false
@@ -875,6 +927,7 @@ var main = async () => {
     choices: [
       { name: `Claude Code  ${dim2("MCP + hooks + auto-allowed tools")}`, value: "claude_code", checked: detected.claude_code },
       { name: `Codex        ${dim2("MCP + native hooks + auto-allowed tools")}`, value: "codex", checked: detected.codex },
+      { name: `Gemini CLI   ${dim2("MCP + native hooks + auto-allowed tools")}`, value: "gemini_cli", checked: detected.gemini_cli },
       { name: `Hermes       ${dim2("native plugin + auto-error notifications")}`, value: "hermes", checked: detected.hermes },
       { name: `Cursor       ${dim2("plugin + permission gate")}`, value: "cursor", checked: detected.cursor },
       { name: `Other        ${dim2("any MCP or HTTP agent (Windsurf, n8n, custom)")}`, value: "custom", checked: false }

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

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   handleStop
-} from "../chunk-Y633ZIJF.js";
-import "../chunk-2BE2IPMO.js";
-import "../chunk-RZLVE57X.js";
+} from "../chunk-QY4L6XHN.js";
+import "../chunk-ACE77TKQ.js";
+import "../chunk-USUCPCUC.js";
 import "../chunk-DWED7BS3.js";
 import "../chunk-NKXSILEW.js";
 

package/dist/bin/pushary.js

@@ -17,7 +17,7 @@ if (command === "setup") {
 Pushary Agent Hooks
 
 Commands:
-  setup    Configure Claude Code, Codex, Hermes, or Cursor with Pushary
+  setup    Configure Claude Code, Codex, Gemini CLI, Hermes, or Cursor with Pushary
   doctor   Verify your Pushary installation is working
   clean    Remove all Pushary configuration
   mode     Switch approval mode (push_only, push_first, terminal_only)