@pushary/agent-hooks 0.27.0 → 0.28.1

package/dist/chunk-Z5PL3K7C.js

@@ -0,0 +1,322 @@
+// ../contracts/src/index.ts
+var APPROVAL_MODES = ["push_only", "terminal_only", "push_first", "notify_only"];
+var isApprovalMode = (value) => typeof value === "string" && APPROVAL_MODES.includes(value);
+var HOOK_BUDGETS = {
+  claude: { budgetSeconds: 120, guardSeconds: 10 },
+  codex: { budgetSeconds: 180, guardSeconds: 10 },
+  gemini: { budgetSeconds: 180, guardSeconds: 10 },
+  // The Cursor gate is a dependency-free .mjs that cannot import this module; it
+  // mirrors these as MAX_BLOCK_MS (45s) inside its 60s failClosed budget.
+  cursor: { budgetSeconds: 60, guardSeconds: 15 }
+};
+var hookMaxWaitSeconds = (agent) => Math.max(HOOK_BUDGETS[agent].budgetSeconds - HOOK_BUDGETS[agent].guardSeconds, 1);
+var hookWaitDeadline = (startMs, policyWaitSeconds, agent, nowMs) => {
+  const maxWait = hookMaxWaitSeconds(agent);
+  return Math.min(
+    nowMs + Math.min(Math.max(policyWaitSeconds, 0), maxWait) * 1e3,
+    startMs + maxWait * 1e3
+  );
+};
+var hookWaitClamped = (startMs, policyWaitSeconds, agent, nowMs) => startMs + hookMaxWaitSeconds(agent) * 1e3 < nowMs + Math.max(policyWaitSeconds, 0) * 1e3;
+var effectiveWaitSeconds = (timeoutAction, policySeconds, agent) => timeoutAction === "wait" ? hookMaxWaitSeconds(agent) : policySeconds;
+var MATCH_RANKS = ["none", "tool", "prefix", "exact"];
+var matchRankWeight = (rank) => MATCH_RANKS.indexOf(rank);
+var matchToolPattern = (pattern, toolName, arg) => {
+  const open = pattern.indexOf("(");
+  if (open === -1 || !pattern.endsWith(")")) {
+    return pattern === toolName ? "tool" : "none";
+  }
+  if (pattern.slice(0, open) !== toolName || arg === void 0) return "none";
+  const inner = pattern.slice(open + 1, -1);
+  if (inner.endsWith(":*")) {
+    return arg.startsWith(inner.slice(0, -2)) ? "prefix" : "none";
+  }
+  return arg === inner ? "exact" : "none";
+};
+var POLICY_ARG_KEYS = {
+  Bash: "command",
+  Edit: "file_path",
+  Write: "file_path"
+};
+var extractPolicyArg = (toolName, toolInput) => {
+  const key = POLICY_ARG_KEYS[toolName];
+  if (!key) return void 0;
+  const value = toolInput[key];
+  return typeof value === "string" ? value : void 0;
+};
+var SAFE_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+  "ls",
+  "pwd",
+  "cd",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "echo",
+  "printf",
+  "which",
+  "type",
+  "whoami",
+  "id",
+  "uname",
+  "arch",
+  "printenv",
+  "locale",
+  "tty",
+  "dirname",
+  "basename",
+  "realpath",
+  "readlink",
+  "stat",
+  "cut",
+  "nl",
+  "tr",
+  "comm",
+  "diff",
+  "cmp",
+  "grep",
+  "egrep",
+  "fgrep",
+  "jq",
+  "cksum",
+  "md5sum",
+  "sha1sum",
+  "sha256sum",
+  "du",
+  "df",
+  "ps",
+  "true"
+]);
+var SAFE_GIT_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "log",
+  "diff",
+  "show",
+  "rev-parse",
+  "describe",
+  "blame",
+  "shortlog",
+  "ls-files",
+  "ls-tree",
+  "cat-file",
+  "whatchanged",
+  "rev-list",
+  "name-rev",
+  "for-each-ref",
+  "var",
+  "count-objects"
+]);
+var GIT_WRITE_FLAGS = (token) => token === "--output" || token.startsWith("--output=");
+var DANGEROUS_FIND_ACTIONS = /* @__PURE__ */ new Set([
+  "-exec",
+  "-execdir",
+  "-ok",
+  "-okdir",
+  "-delete",
+  "-fprintf",
+  "-fprint",
+  "-fprint0",
+  "-fls"
+]);
+var SAFE_FIND_TOKENS = /* @__PURE__ */ new Set([
+  "-name",
+  "-iname",
+  "-path",
+  "-ipath",
+  "-wholename",
+  "-iwholename",
+  "-lname",
+  "-ilname",
+  "-regex",
+  "-iregex",
+  "-type",
+  "-xtype",
+  "-maxdepth",
+  "-mindepth",
+  "-depth",
+  "-mount",
+  "-xdev",
+  "-size",
+  "-empty",
+  "-perm",
+  "-readable",
+  "-writable",
+  "-executable",
+  "-mtime",
+  "-mmin",
+  "-atime",
+  "-amin",
+  "-ctime",
+  "-cmin",
+  "-newer",
+  "-newermt",
+  "-anewer",
+  "-cnewer",
+  "-user",
+  "-uid",
+  "-group",
+  "-gid",
+  "-nouser",
+  "-nogroup",
+  "-samefile",
+  "-inum",
+  "-links",
+  "-print",
+  "-print0",
+  "-printf",
+  "-ls",
+  "-quit",
+  "-prune",
+  "-follow",
+  "-noleaf",
+  "-ignore_readdir_race",
+  "-noignore_readdir_race",
+  "-true",
+  "-false",
+  "-not",
+  "-and",
+  "-or",
+  "-o",
+  "-a",
+  "-P",
+  "-L",
+  "-H",
+  "-D",
+  "-O"
+]);
+var SAFE_REDIRECTION = /\s*(?:[0-9]*>&[0-9-]+|(?:[0-9]*|&)>>?\s*\/dev\/null)/g;
+var basenameOf = (token) => {
+  const slash = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
+  return slash === -1 ? token : token.slice(slash + 1);
+};
+var TRUSTED_EXE_PREFIXES = [
+  "/bin/",
+  "/sbin/",
+  "/usr/bin/",
+  "/usr/sbin/",
+  "/usr/local/bin/",
+  "/opt/homebrew/bin/"
+];
+var isTrustedExecutable = (first) => {
+  if (!first.includes("/")) return true;
+  if (first.includes("..")) return false;
+  return TRUSTED_EXE_PREFIXES.some((prefix) => first.startsWith(prefix));
+};
+var tokenizeShellCommand = (command) => {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let started = false;
+  for (const ch of command) {
+    if (quote) {
+      if (ch === quote) quote = null;
+      else current += ch;
+      started = true;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      started = true;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (started) {
+        tokens.push(current);
+        current = "";
+        started = false;
+      }
+      continue;
+    }
+    current += ch;
+    started = true;
+  }
+  if (quote) return null;
+  if (started) tokens.push(current);
+  return tokens;
+};
+var isSafeSimpleCommand = (segment) => {
+  const tokens = tokenizeShellCommand(segment.trim());
+  if (!tokens || tokens.length === 0) return false;
+  const first = tokens[0];
+  if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(first) || first.includes("$")) return false;
+  if (!isTrustedExecutable(first)) return false;
+  const exe = basenameOf(first);
+  if (exe === "git") {
+    const sub = tokens[1];
+    if (!sub || sub.startsWith("-")) return false;
+    if (!SAFE_GIT_SUBCOMMANDS.has(sub)) return false;
+    return !tokens.some(GIT_WRITE_FLAGS);
+  }
+  if (exe === "find") {
+    for (let i = 1; i < tokens.length; i += 1) {
+      const t = tokens[i];
+      if (t === "(" || t === ")" || t === "!" || t === "\\(" || t === "\\)" || t === "\\!") continue;
+      if (t.startsWith("-") && (DANGEROUS_FIND_ACTIONS.has(t) || !SAFE_FIND_TOKENS.has(t))) return false;
+    }
+    return true;
+  }
+  return SAFE_SHELL_COMMANDS.has(exe);
+};
+var isSafeReadOnlyCommand = (command) => {
+  const trimmed = command.trim();
+  if (!trimmed || trimmed.length > 2e3) return false;
+  if (/[`\n\r{}]/.test(trimmed)) return false;
+  if (/;|\|\|/.test(trimmed)) return false;
+  if (/\\(?![()!])/.test(trimmed)) return false;
+  if (/(?<!\\)[()]/.test(trimmed)) return false;
+  const noRedir = trimmed.replace(SAFE_REDIRECTION, " ");
+  if (/[<>]/.test(noRedir)) return false;
+  if (noRedir.replace(/&&/g, "  ").includes("&")) return false;
+  for (const andPart of noRedir.split("&&")) {
+    if (!andPart.trim()) return false;
+    for (const segment of andPart.split("|")) {
+      if (!isSafeSimpleCommand(segment)) return false;
+    }
+  }
+  return true;
+};
+var API_KEY_PATTERN = /^pk_[a-f0-9]+\.[a-f0-9]+$/;
+var isValidApiKey = (value) => API_KEY_PATTERN.test(value);
+var ACTION_BODY_MAX = 4e3;
+var DECISION_LINE_MAX = 500;
+var SECRET_REDACTION_RULES = [
+  { pattern: /-----BEGIN[A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END[A-Z0-9 ]*PRIVATE KEY-----/g, replacement: "[redacted key]" },
+  { pattern: /\bsk-[A-Za-z0-9_-]{16,}\b/g, replacement: "[redacted]" },
+  { pattern: /\b[spr]k_(?:live|test)_[A-Za-z0-9]{8,}\b/g, replacement: "[redacted]" },
+  { pattern: /\bwhsec_[A-Za-z0-9]{16,}\b/g, replacement: "[redacted]" },
+  { pattern: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/g, replacement: "[redacted]" },
+  { pattern: /\bgithub_pat_[A-Za-z0-9_]{22,}\b/g, replacement: "[redacted]" },
+  { pattern: /\bglpat-[A-Za-z0-9_-]{20,}\b/g, replacement: "[redacted]" },
+  { pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, replacement: "[redacted]" },
+  { pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g, replacement: "[redacted]" },
+  { pattern: /\bAKIA[0-9A-Z]{16}\b/g, replacement: "[redacted]" },
+  { pattern: /\bnpm_[A-Za-z0-9]{36}\b/g, replacement: "[redacted]" },
+  { pattern: /\bxai-[A-Za-z0-9]{16,}\b/g, replacement: "[redacted]" },
+  { pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, replacement: "[redacted]" },
+  { pattern: /\bbearer\s+[A-Za-z0-9._~+/=-]+/gi, replacement: "bearer [redacted]" },
+  { pattern: /\bauthorization:\s*\S+/gi, replacement: "authorization: [redacted]" },
+  {
+    pattern: /((?:secret|token|password|passwd|api[_-]?key|access[_-]?key|client[_-]?secret|private[_-]?key)\s*[=:]\s*)("[^"]*"|'[^']*'|\S+)/gi,
+    replacement: "$1[redacted]"
+  }
+];
+var HIGH_ENTROPY_RULE = { pattern: /[A-Za-z0-9+/]{40,}={0,2}/g, replacement: "[redacted]" };
+var redactSecrets = (text) => SECRET_REDACTION_RULES.reduce((acc, rule) => acc.replace(rule.pattern, rule.replacement), text);
+var redactSecretsDeep = (text) => redactSecrets(text).replace(HIGH_ENTROPY_RULE.pattern, HIGH_ENTROPY_RULE.replacement);
+
+export {
+  isApprovalMode,
+  HOOK_BUDGETS,
+  hookWaitDeadline,
+  hookWaitClamped,
+  effectiveWaitSeconds,
+  matchRankWeight,
+  matchToolPattern,
+  extractPolicyArg,
+  isSafeReadOnlyCommand,
+  isValidApiKey,
+  ACTION_BODY_MAX,
+  DECISION_LINE_MAX,
+  redactSecrets,
+  redactSecretsDeep
+};

package/dist/chunk-ZWBS3T7Q.js

@@ -0,0 +1,244 @@
+// 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/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,
+  npmErrorMessage,
+  execNpm
+};

package/dist/pushary-mode-T7XOPI6Z.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-VUNL35KE.js";
+
+// bin/pushary-mode.ts
+var VALID_MODES = ["push_only", "push_first", "terminal_only", "notify_only"];
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var green = (s) => `\x1B[32m${s}\x1B[0m`;
+var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+var parseDuration = (value) => {
+  const match = value.match(/^(\d+)(m|h)$/);
+  if (!match) return null;
+  const num = Number(match[1]);
+  return match[2] === "h" ? num * 3600 : num * 60;
+};
+var main = async () => {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  const mode = process.argv[2];
+  const forFlag = process.argv[3];
+  const forValue = process.argv[4];
+  const headers = {
+    "Authorization": `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  if (!mode || mode === "status") {
+    const res2 = await fetch(`${baseUrl}/api/mcp/mode`, { headers });
+    const data2 = await res2.json();
+    if (!data2.override) {
+      console.log(`  Mode: ${cyan("default")} ${dim("(using per-tool policies)")}`);
+    } else {
+      console.log(`  Mode: ${green(data2.override.mode)}`);
+      if (data2.override.expiresAt) {
+        console.log(`  Expires: ${new Date(data2.override.expiresAt).toLocaleString()}`);
+      } else {
+        console.log(`  ${dim("Sticky (no expiry)")}`);
+      }
+    }
+    return;
+  }
+  if (mode === "clear" || mode === "reset") {
+    await fetch(`${baseUrl}/api/mcp/mode`, { method: "DELETE", headers });
+    console.log(`  ${green("\u2713")} Mode override cleared \u2014 using per-tool policies`);
+    return;
+  }
+  if (!VALID_MODES.includes(mode)) {
+    console.log(`  ${yellow("!")} Invalid mode: ${mode}`);
+    console.log(`  Valid modes: ${VALID_MODES.join(", ")}`);
+    console.log(`  ${dim("Usage: pushary mode <mode> [--for <duration>]")}`);
+    console.log(`  ${dim("Example: pushary mode push_only --for 30m")}`);
+    return;
+  }
+  let ttlSeconds;
+  if (forFlag === "--for" && forValue) {
+    ttlSeconds = parseDuration(forValue);
+    if (!ttlSeconds) {
+      console.log(`  ${yellow("!")} Invalid duration: ${forValue} ${dim("(use e.g. 30m, 1h)")}`);
+      return;
+    }
+  }
+  const res = await fetch(`${baseUrl}/api/mcp/mode`, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({ mode, ttlSeconds })
+  });
+  if (!res.ok) {
+    const err = await res.json();
+    console.log(`  ${yellow("!")} Failed: ${err.error ?? res.statusText}`);
+    return;
+  }
+  const data = await res.json();
+  console.log(`  ${green("\u2713")} Mode set to ${cyan(data.override.mode)}`);
+  if (data.override.expiresAt) {
+    console.log(`  Expires: ${new Date(data.override.expiresAt).toLocaleString()}`);
+  }
+};
+main().catch((err) => {
+  console.error(`  ${yellow("!")} ${err instanceof Error ? err.message : err}`);
+  process.exit(1);
+});