@pushary/agent-hooks 0.27.0 → 0.28.1

package/dist/chunk-LXUHXG2X.js

@@ -0,0 +1,937 @@
+import {
+  callMcpTool,
+  withRetry
+} from "./chunk-DWED7BS3.js";
+import {
+  ACTION_BODY_MAX,
+  DECISION_LINE_MAX,
+  extractPolicyArg,
+  isApprovalMode,
+  isSafeReadOnlyCommand,
+  matchRankWeight,
+  matchToolPattern,
+  redactSecrets,
+  redactSecretsDeep
+} from "./chunk-C4BMEVK7.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-NKXSILEW.js";
+
+// src/validate.ts
+var isPolicyConfig = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return Array.isArray(d.policies) && typeof d.defaultTimeoutSeconds === "number" && typeof d.defaultTimeoutAction === "string";
+};
+var isAskUserResponse = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return typeof d.correlationId === "string" && typeof d.status === "string";
+};
+var isWaitForAnswerResponse = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return typeof d.answered === "boolean";
+};
+
+// src/api.ts
+var askUser = async (apiKey, params, timeoutMs = 15e3) => {
+  const result = await callMcpTool(apiKey, "ask_user", { ...params, wait: false }, { maxRetries: 3, timeoutMs });
+  if (!isAskUserResponse(result)) throw new Error("Invalid ask_user response");
+  return result;
+};
+var waitForAnswer = async (apiKey, correlationId, timeoutMs = 3e4) => {
+  const result = await callMcpTool(apiKey, "wait_for_answer", {
+    correlationId,
+    timeoutMs
+  }, { timeoutMs: timeoutMs + 1e4 });
+  if (!isWaitForAnswerResponse(result)) throw new Error("Invalid wait_for_answer response");
+  return result;
+};
+var cancelQuestion = async (apiKey, correlationId) => {
+  await callMcpTool(apiKey, "cancel_question", { correlationId });
+};
+var sendNotification = async (apiKey, params, timeoutMs = 15e3) => {
+  await callMcpTool(apiKey, "send_notification", { ...params }, { maxRetries: 3, timeoutMs });
+};
+
+// src/policy.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+var CACHE_TTL_MS = 60 * 1e3;
+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) => {
+  return withRetry(async () => {
+    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}`);
+    }
+    const raw = await response.json();
+    if (!isPolicyConfig(raw)) throw new Error("Invalid policy response");
+    return raw;
+  }, { maxAttempts: 2 });
+};
+var getPolicy = async (apiKey, expectedVersion) => {
+  const path = cacheFile(apiKey);
+  let staleCache = null;
+  if (existsSync(path)) {
+    try {
+      const stat = readFileSync(path, "utf-8");
+      const cached = JSON.parse(stat);
+      if (!isPolicyConfig(cached)) throw new Error("Corrupted cache");
+      const versionStale = expectedVersion != null && (cached._policyVersion ?? null) !== expectedVersion;
+      const ttlFresh = !cached._cachedAt || Date.now() - cached._cachedAt < CACHE_TTL_MS;
+      if (ttlFresh && !versionStale) {
+        return cached;
+      }
+      staleCache = cached;
+    } catch {
+    }
+  }
+  try {
+    const policy = await fetchPolicy(apiKey);
+    try {
+      writeFileSync(path, JSON.stringify({ ...policy, _cachedAt: Date.now(), _policyVersion: expectedVersion ?? null }), "utf-8");
+    } catch {
+    }
+    return policy;
+  } catch {
+    if (staleCache) return staleCache;
+    throw new Error("Failed to fetch policy and no cached policy available");
+  }
+};
+var findBestMatch = (policies, toolName, arg) => {
+  let best;
+  let bestWeight = 0;
+  let bestLength = -1;
+  for (const candidate of policies) {
+    const rank = matchToolPattern(candidate.tool, toolName, arg);
+    if (rank === "none") continue;
+    const weight = matchRankWeight(rank);
+    const length = rank === "prefix" ? candidate.tool.length : -1;
+    if (weight > bestWeight || weight === bestWeight && length > bestLength) {
+      best = { policy: candidate, rank };
+      bestWeight = weight;
+      bestLength = length;
+    }
+  }
+  return best;
+};
+var autoApprove = (tool) => ({
+  tool,
+  timeoutSeconds: 0,
+  timeoutAction: "approve",
+  mode: "terminal_only",
+  pushFirstSeconds: 0
+});
+var resolveAutoResolveOrigin = (config, toolName, toolInput) => {
+  const arg = toolInput ? extractPolicyArg(toolName, toolInput) : void 0;
+  const match = findBestMatch(config.policies, toolName, arg);
+  const governedBySpecificRule = match?.rank === "exact" || match?.rank === "prefix";
+  if (!governedBySpecificRule && toolName === "Bash" && typeof arg === "string" && isSafeReadOnlyCommand(arg)) {
+    return "safe_readonly";
+  }
+  return "policy_timeout";
+};
+var resolvePolicy = (config, toolName, modeOverride, toolInput) => {
+  const arg = toolInput ? extractPolicyArg(toolName, toolInput) : void 0;
+  const match = findBestMatch(config.policies, toolName, arg);
+  let base = match?.policy ?? config.policies.find((p) => p.tool === "*") ?? {
+    tool: toolName,
+    timeoutSeconds: config.defaultTimeoutSeconds,
+    timeoutAction: config.defaultTimeoutAction,
+    mode: config.defaultMode ?? "push_first",
+    pushFirstSeconds: config.defaultPushFirstSeconds ?? 20
+  };
+  const governedBySpecificRule = match?.rank === "exact" || match?.rank === "prefix";
+  if (!governedBySpecificRule && toolName === "Bash" && typeof arg === "string" && isSafeReadOnlyCommand(arg)) {
+    base = autoApprove(base.tool);
+  }
+  const effectiveOverride = modeOverride ?? config.modeOverride;
+  if (effectiveOverride) {
+    return { ...base, mode: effectiveOverride };
+  }
+  return base;
+};
+var toPolicyVersion = (value) => typeof value === "string" || typeof value === "number" ? String(value) : null;
+var fetchModeState = async (apiKey, sessionId) => {
+  try {
+    const baseUrl = getBaseUrl();
+    const url = sessionId ? `${baseUrl}/api/mcp/mode?session=${encodeURIComponent(sessionId)}` : `${baseUrl}/api/mcp/mode`;
+    const response = await fetch(url, {
+      headers: { "Authorization": `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!response.ok) return { mode: null, kill: false, policyVersion: null };
+    const data = await response.json();
+    const mode = data.override?.mode;
+    return {
+      mode: isApprovalMode(mode) ? mode : null,
+      kill: data.kill === true,
+      policyVersion: toPolicyVersion(data.policyVersion)
+    };
+  } catch {
+    return { mode: null, kill: false, policyVersion: null };
+  }
+};
+var fetchModeOverride = async (apiKey) => (await fetchModeState(apiKey)).mode;
+
+// src/describe.ts
+import { isAbsolute, relative } from "path";
+var hookPrefixes = {
+  Bash: (input) => `bash: ${input.command ?? "(no command)"}`,
+  Write: (input) => `write file: ${input.file_path ?? "(unknown path)"}`,
+  Edit: (input) => `edit file: ${input.file_path ?? "(unknown path)"}`,
+  Read: (input) => `read file: ${input.file_path ?? "(unknown path)"}`
+};
+var eventPrefixes = {
+  Bash: (input) => `ran: ${String(input.command ?? "")}`,
+  Write: (input) => `wrote: ${input.file_path ?? "unknown"}`,
+  Edit: (input) => `edited: ${input.file_path ?? "unknown"}`,
+  Read: (input) => `read: ${input.file_path ?? "unknown"}`
+};
+var EVENT_ACTION_MAX = 120;
+var HOOK_FALLBACK_MAX = 200;
+var describeToolCall = (toolName, toolInput, format = "hook") => {
+  const prefixes = format === "hook" ? hookPrefixes : eventPrefixes;
+  const builder = prefixes[toolName];
+  const raw = builder ? builder(toolInput) : format === "hook" ? `${toolName}: ${JSON.stringify(toolInput)}` : `${toolName}: done`;
+  const redacted = redactSecrets(raw);
+  if (format === "event") return redacted.slice(0, EVENT_ACTION_MAX);
+  return builder ? redacted : redacted.slice(0, HOOK_FALLBACK_MAX);
+};
+var TOOL_TARGET_MAX_LENGTH = 80;
+var deriveCommandHead = (command) => {
+  if (typeof command !== "string") return void 0;
+  const head = command.trim().split(/\s+/).slice(0, 2).join(" ");
+  return head ? head.slice(0, TOOL_TARGET_MAX_LENGTH) : void 0;
+};
+var deriveToolTarget = (toolName, toolInput) => {
+  if (toolName === "Bash") {
+    return deriveCommandHead(toolInput.command);
+  }
+  if (toolName === "Edit" || toolName === "Write") {
+    const filePath = toolInput.file_path;
+    if (typeof filePath !== "string") return void 0;
+    const separator = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+    const base = filePath.slice(separator + 1);
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0) return void 0;
+    return base.slice(dot).slice(0, TOOL_TARGET_MAX_LENGTH);
+  }
+  return void 0;
+};
+var RECEIPT_TARGET_MAX_LENGTH = 256;
+var isToolResultError = (toolResult) => {
+  try {
+    return Boolean(toolResult && ("error" in toolResult || "is_error" in toolResult));
+  } catch {
+    return false;
+  }
+};
+var relativizeReceiptPath = (filePath, cwd) => {
+  if (!cwd || !isAbsolute(filePath)) return filePath;
+  return relative(cwd, filePath);
+};
+var deriveReceiptMeta = (toolName, toolInput, toolResult, cwd) => {
+  try {
+    const ok = !isToolResultError(toolResult);
+    if (toolName === "Edit" || toolName === "Write") {
+      const filePath = toolInput.file_path;
+      if (typeof filePath !== "string" || !filePath) return void 0;
+      return {
+        kind: toolName === "Edit" ? "edit" : "write",
+        target: relativizeReceiptPath(filePath, cwd).slice(0, RECEIPT_TARGET_MAX_LENGTH),
+        ok
+      };
+    }
+    if (toolName === "Bash") {
+      const head = deriveCommandHead(toolInput.command);
+      if (!head) return void 0;
+      return {
+        kind: head === "git commit" ? "commit" : "bash",
+        target: head,
+        ok
+      };
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var firstString = (...values) => values.find((v) => typeof v === "string" && v.length > 0);
+var ACTION_BODY_TRUNCATION_MARKER = "\n\u2026 [truncated]";
+var capActionBody = (text) => text.length <= ACTION_BODY_MAX ? text : `${text.slice(0, ACTION_BODY_MAX - ACTION_BODY_TRUNCATION_MARKER.length)}${ACTION_BODY_TRUNCATION_MARKER}`;
+var rawActionBody = (toolName, toolInput) => {
+  if (toolName === "Edit" || toolName === "replace") {
+    const before = firstString(toolInput.old_string);
+    const after = firstString(toolInput.new_string);
+    if (before === void 0 && after === void 0) return void 0;
+    return `- ${before ?? ""}
++ ${after ?? ""}`;
+  }
+  if (toolName === "Write" || toolName === "write_file") return firstString(toolInput.content);
+  if (toolName === "Bash" || toolName === "run_shell_command" || toolName === "shell" || toolName === "apply_patch") {
+    return firstString(toolInput.command);
+  }
+  return void 0;
+};
+var deriveActionBody = (toolName, toolInput) => {
+  try {
+    const raw = rawActionBody(toolName, toolInput);
+    if (!raw) return void 0;
+    return capActionBody(redactSecretsDeep(raw));
+  } catch {
+    return void 0;
+  }
+};
+var deriveAction = (toolName, toolInput) => describeToolCall(toolName, toolInput, "hook").slice(0, DECISION_LINE_MAX);
+var BLOCKER_BY_MODE = {
+  push_only: "Approval required before this runs",
+  push_first: "Paused for your approval before continuing",
+  escalate: "Escalated to you after the approval timeout"
+};
+var deriveBlocker = (mode, reason) => {
+  const text = reason?.replace(/\s+/g, " ").trim() || BLOCKER_BY_MODE[mode] || "Waiting for your approval";
+  return text.slice(0, DECISION_LINE_MAX);
+};
+
+// src/identity.ts
+import { createHash as createHash2 } from "crypto";
+import { hostname } from "os";
+var deriveMachineId = (host) => createHash2("sha256").update(host).digest("hex").slice(0, 8);
+var getMachineId = () => deriveMachineId(hostname());
+
+// src/pending.ts
+import { join as join2 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2, readdirSync, unlinkSync, rmSync, statSync } from "fs";
+var PENDING_DIR = join2(tmpdir2(), "pushary-pending");
+var DEFAULT_SESSION = "_no_session";
+var GRACE_MS = 10 * 60 * 1e3;
+var sanitize = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
+var dirFor = (sessionId) => join2(PENDING_DIR, sanitize(sessionId));
+var isDefaultSession = (sessionId) => sanitize(sessionId) === DEFAULT_SESSION;
+var savePendingQuestion = (sessionId, correlationId) => {
+  const dir = dirFor(sessionId);
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync2(join2(dir, correlationId), "", "utf-8");
+};
+var listPendingQuestions = (sessionId) => {
+  const dir = dirFor(sessionId);
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  if (!isDefaultSession(sessionId)) return files;
+  const cutoff = Date.now() - GRACE_MS;
+  return files.filter((name) => {
+    try {
+      return statSync(join2(dir, name)).mtimeMs < cutoff;
+    } catch {
+      return false;
+    }
+  });
+};
+var removePendingQuestion = (sessionId, correlationId) => {
+  try {
+    unlinkSync(join2(dirFor(sessionId), correlationId));
+  } catch {
+  }
+};
+var removePendingSession = (sessionId) => {
+  try {
+    rmSync(dirFor(sessionId), { recursive: true, force: true });
+  } catch {
+  }
+};
+
+// src/usage.ts
+import { closeSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, readSync, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+var DEFAULT_PRICES = [
+  { match: "opus-4-1", in: 15, out: 75 },
+  { match: "opus-4-0", in: 15, out: 75 },
+  { match: "3-opus", in: 15, out: 75 },
+  { match: "opus", in: 5, out: 25 },
+  { match: "haiku", in: 1, out: 5 },
+  { match: "sonnet", in: 3, out: 15 }
+];
+var FALLBACK_PRICE = { match: "", in: 3, out: 15 };
+var CACHE_WRITE_MULTIPLIER = 1.25;
+var CACHE_READ_MULTIPLIER = 0.1;
+var RECENT_ID_LIMIT = 200;
+var READ_CHUNK_BYTES = 1024 * 1024;
+var isModelPrice = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.match === "string" && typeof candidate.in === "number" && typeof candidate.out === "number";
+};
+var priceTable = () => {
+  const raw = process.env.PUSHARY_MODEL_PRICING?.trim();
+  if (!raw) return DEFAULT_PRICES;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed) && parsed.length > 0 && parsed.every(isModelPrice)) return parsed;
+  } catch {
+  }
+  return DEFAULT_PRICES;
+};
+var estimateCostUsd = (usage, model) => {
+  const price = priceTable().find((p) => model.includes(p.match)) ?? FALLBACK_PRICE;
+  const perTokenIn = price.in / 1e6;
+  const perTokenOut = price.out / 1e6;
+  return usage.inputTokens * perTokenIn + usage.outputTokens * perTokenOut + usage.cacheCreationTokens * perTokenIn * CACHE_WRITE_MULTIPLIER + usage.cacheReadTokens * perTokenIn * CACHE_READ_MULTIPLIER;
+};
+var stateDir = () => process.env.PUSHARY_USAGE_DIR?.trim() || join3(tmpdir3(), "pushary-usage");
+var stateFile = (sessionId) => join3(stateDir(), sessionId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+var emptyState = () => ({ offset: 0, tokensIn: 0, tokensOut: 0, costUsd: 0, recentIds: [] });
+var readState = (path) => {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    if (typeof parsed.offset === "number" && parsed.offset >= 0 && typeof parsed.tokensIn === "number" && typeof parsed.tokensOut === "number" && typeof parsed.costUsd === "number" && Array.isArray(parsed.recentIds)) {
+      return {
+        offset: parsed.offset,
+        tokensIn: parsed.tokensIn,
+        tokensOut: parsed.tokensOut,
+        costUsd: parsed.costUsd,
+        recentIds: parsed.recentIds.filter((id) => typeof id === "string")
+      };
+    }
+  } catch {
+  }
+  return emptyState();
+};
+var readRange = (path, start, end) => {
+  const fd = openSync(path, "r");
+  try {
+    const chunks = [];
+    let position = start;
+    while (position < end) {
+      const length = Math.min(READ_CHUNK_BYTES, end - position);
+      const buffer = Buffer.alloc(length);
+      const bytesRead = readSync(fd, buffer, 0, length, position);
+      if (bytesRead <= 0) break;
+      chunks.push(buffer.subarray(0, bytesRead));
+      position += bytesRead;
+    }
+    return Buffer.concat(chunks);
+  } finally {
+    closeSync(fd);
+  }
+};
+var toCount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+var applyLine = (state, line) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return 0;
+  }
+  if (parsed.type !== "assistant") return 0;
+  const usage = parsed.message?.usage;
+  if (!usage || typeof usage !== "object") return 0;
+  const model = typeof parsed.message?.model === "string" ? parsed.message.model : "";
+  if (model.includes("<synthetic>")) return 0;
+  const id = typeof parsed.message?.id === "string" ? parsed.message.id : null;
+  if (id) {
+    if (state.recentIds.includes(id)) return 0;
+    state.recentIds.push(id);
+    if (state.recentIds.length > RECENT_ID_LIMIT) state.recentIds.splice(0, state.recentIds.length - RECENT_ID_LIMIT);
+  }
+  const messageUsage = {
+    inputTokens: toCount(usage.input_tokens),
+    outputTokens: toCount(usage.output_tokens),
+    cacheCreationTokens: toCount(usage.cache_creation_input_tokens),
+    cacheReadTokens: toCount(usage.cache_read_input_tokens)
+  };
+  const cost = estimateCostUsd(messageUsage, model);
+  state.tokensIn += messageUsage.inputTokens + messageUsage.cacheCreationTokens + messageUsage.cacheReadTokens;
+  state.tokensOut += messageUsage.outputTokens;
+  state.costUsd += cost;
+  return cost;
+};
+var USER_PROMPT_TAIL_BYTES = 256 * 1024;
+var USER_PROMPT_MAX = 2048;
+var extractUserText = (content) => {
+  if (typeof content === "string") return content.replace(/\s+/g, " ").trim() || void 0;
+  if (Array.isArray(content)) {
+    const text = content.filter((block) => Boolean(block) && typeof block === "object").filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join(" ").replace(/\s+/g, " ").trim();
+    return text || void 0;
+  }
+  return void 0;
+};
+var readLastUserPrompt = (transcriptPath) => {
+  try {
+    const size = statSync2(transcriptPath).size;
+    const start = Math.max(0, size - USER_PROMPT_TAIL_BYTES);
+    const lines = readRange(transcriptPath, start, size).toString("utf-8").split("\n");
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (parsed.type !== "user") continue;
+      const text = extractUserText(parsed.message?.content);
+      if (text) return text.slice(0, USER_PROMPT_MAX);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var readNewUsage = (transcriptPath, sessionId) => {
+  try {
+    const size = statSync2(transcriptPath).size;
+    const path = stateFile(sessionId);
+    let state = readState(path);
+    if (size < state.offset) state = { ...emptyState(), recentIds: state.recentIds };
+    let deltaUsd = 0;
+    if (size > state.offset) {
+      const buffer = readRange(transcriptPath, state.offset, size);
+      const lastNewline = buffer.lastIndexOf(10);
+      if (lastNewline >= 0) {
+        const complete = buffer.subarray(0, lastNewline + 1);
+        for (const line of complete.toString("utf-8").split("\n")) {
+          if (line.trim()) deltaUsd += applyLine(state, line);
+        }
+        state.offset += lastNewline + 1;
+      }
+    }
+    mkdirSync2(stateDir(), { recursive: true });
+    writeFileSync3(path, JSON.stringify(state), "utf-8");
+    if (state.tokensIn === 0 && state.tokensOut === 0) return null;
+    return {
+      tokensIn: state.tokensIn,
+      tokensOut: state.tokensOut,
+      costUsd: state.costUsd,
+      deltaUsd
+    };
+  } catch {
+    return null;
+  }
+};
+
+// src/codex-adapter.ts
+import { resolve } from "path";
+var CODEX_AGENT = { type: "codex", label: "Codex" };
+var codexAllow = () => ({ kind: "allow" });
+var codexDeny = (reason) => ({ kind: "deny", reason });
+var codexPass = () => ({ kind: "pass" });
+var toCodexWire = (event, decision) => {
+  if (event === "PermissionRequest") {
+    if (decision.kind === "allow") {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PermissionRequest",
+          decision: { behavior: "allow" }
+        }
+      };
+    }
+    if (decision.kind === "deny") {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PermissionRequest",
+          decision: { behavior: "deny", message: decision.reason }
+        }
+      };
+    }
+    return null;
+  }
+  if (event === "PreToolUse" && decision.kind === "deny") {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: decision.reason
+      }
+    };
+  }
+  return null;
+};
+var parseApplyPatchOps = (command) => {
+  if (typeof command !== "string") return [];
+  const ops = [];
+  for (const line of command.split("\n")) {
+    const file = line.match(/^\*\*\*\s+(Add|Update|Delete) File:\s+(.+?)\s*$/);
+    if (file) {
+      ops.push({ op: file[1].toLowerCase(), path: file[2] });
+      continue;
+    }
+    const move = line.match(/^\*\*\*\s+Move to:\s+(.+?)\s*$/);
+    if (move) ops.push({ op: "move", path: move[1] });
+  }
+  return ops;
+};
+var parseApplyPatchFiles = (command) => [...new Set(parseApplyPatchOps(command).map((entry) => entry.path))];
+var describeApplyPatch = (command) => {
+  const ops = parseApplyPatchOps(command);
+  if (ops.length === 0) return null;
+  const files = [...new Set(ops.map((entry) => entry.path))];
+  if (files.length === 1) {
+    const verb = ops[0].op === "add" ? "create" : ops[0].op === "delete" ? "delete" : ops[0].op === "move" ? "move" : "edit";
+    return `${verb} file: ${files[0]}`;
+  }
+  return `apply patch to ${files.length} files`;
+};
+var toPolicyLookup = (toolName, toolInput, cwd) => {
+  if (toolName !== "apply_patch") return { tool: toolName, input: toolInput };
+  const command = toolInput.command;
+  const files = parseApplyPatchFiles(command);
+  if (files.length === 1) {
+    return { tool: "Edit", input: { file_path: cwd ? resolve(cwd, files[0]) : files[0] } };
+  }
+  return { tool: "Edit", input: typeof command === "string" ? { file_path: command } : {} };
+};
+var permissionTimeoutDecision = (timeoutAction) => {
+  if (timeoutAction === "approve") return codexAllow();
+  if (timeoutAction === "deny") return codexDeny("No response within timeout");
+  return codexPass();
+};
+var preToolUseTimeoutDecision = (timeoutAction, denyReason = "No response within timeout") => timeoutAction === "deny" ? codexDeny(denyReason) : codexPass();
+
+// src/throttle.ts
+import { join as join4 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
+var THROTTLE_DIR = join4(tmpdir4(), "pushary-throttle");
+var markerPath = (key) => join4(THROTTLE_DIR, createHash3("sha256").update(key).digest("hex").slice(0, 16));
+var throttlePass = (key, windowMs) => {
+  try {
+    const path = markerPath(key);
+    if (existsSync3(path) && Date.now() - statSync3(path).mtimeMs < windowMs) return false;
+    mkdirSync3(THROTTLE_DIR, { recursive: true });
+    writeFileSync4(path, "", "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/events.ts
+import { basename, join as join5 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, statSync as statSync4, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+var INTENT_DIR = join5(tmpdir5(), "pushary-intent");
+var INTENT_MAX_BYTES = 2048;
+var INTENT_GRACE_MS = 10 * 60 * 1e3;
+var sanitizeSession = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
+var intentFile = (sessionId) => join5(INTENT_DIR, sanitizeSession(sessionId));
+var saveLastPrompt = (sessionId, prompt) => {
+  try {
+    const trimmed = prompt.replace(/\s+/g, " ").trim().slice(0, INTENT_MAX_BYTES);
+    if (!trimmed) return;
+    mkdirSync4(INTENT_DIR, { recursive: true });
+    writeFileSync5(intentFile(sessionId), trimmed, "utf-8");
+  } catch {
+  }
+};
+var readLastPrompt = (sessionId) => {
+  try {
+    const path = intentFile(sessionId);
+    if (isDefaultSession(sessionId) && statSync4(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
+    const value = readFileSync3(path, "utf-8").trim();
+    return value.length > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var reconcilePendingQuestions = async (sessionId) => {
+  const late = [];
+  try {
+    const files = listPendingQuestions(sessionId);
+    if (files.length === 0) return late;
+    const apiKey = getApiKey();
+    for (const correlationId of files) {
+      try {
+        const answer = await waitForAnswer(apiKey, correlationId, 1e3);
+        if (answer.answered) {
+          late.push({ correlationId, value: answer.value });
+          continue;
+        }
+        await cancelQuestion(apiKey, correlationId).catch(() => {
+        });
+      } catch {
+        continue;
+      }
+      removePendingQuestion(sessionId, correlationId);
+    }
+  } catch {
+  }
+  return late;
+};
+var describeLateAnswer = (value) => {
+  const v = (value ?? "").trim();
+  if (v === "yes") return "approved it";
+  if (v === "no") return "rejected it";
+  if (v === "defer") return "chose to handle it on this machine";
+  return v ? `answered "${v.slice(0, 200)}"` : "responded";
+};
+var buildLateAnswerContext = (late) => {
+  if (late.length === 0) return void 0;
+  const parts = late.map((l) => `you ${describeLateAnswer(l.value)} on your phone`);
+  return `Pushary: a permission prompt you were sent was answered late \u2014 ${parts.join("; ")} \u2014 after the terminal already took over. Treat this as the user's latest intent; do not assume the earlier terminal decision matched it.`;
+};
+var notifyLateAnswers = async (apiKey, late, agentName, sessionId) => {
+  if (late.length === 0) return;
+  const summary = late.map((l) => describeLateAnswer(l.value)).join(", ");
+  await sendNotification(apiKey, {
+    title: "Answer arrived late",
+    body: `You ${summary} after the agent had already moved on.`,
+    agentName,
+    sessionId
+  }, 2500).catch(() => {
+  });
+};
+var CLAUDE_CODE_AGENT = { type: "claude_code", label: "Claude Code" };
+var POLICY_CACHE_TTL_MS = 5 * 60 * 1e3;
+var readFreshCachedPolicy = (apiKey) => {
+  const hash = createHash4("sha256").update(apiKey).digest("hex").slice(0, 12);
+  const path = join5(tmpdir5(), `pushary-policy-${hash}.json`);
+  if (!existsSync4(path)) return null;
+  const cached = JSON.parse(readFileSync3(path, "utf-8"));
+  if (!isPolicyConfig(cached)) return null;
+  if (!cached._cachedAt || Date.now() - cached._cachedAt >= POLICY_CACHE_TTL_MS) return null;
+  return cached;
+};
+var deriveDecisionSource = (toolName, toolInput, liveMode) => {
+  try {
+    if (liveMode.kill) return "terminal";
+    const policy = readFreshCachedPolicy(getApiKey());
+    if (!policy) return void 0;
+    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput);
+    if (resolved.timeoutSeconds === 0 && resolved.timeoutAction === "approve") return "policy_auto";
+    if (resolved.mode === "push_only" || resolved.mode === "push_first") return "human";
+    return "terminal";
+  } catch {
+    return void 0;
+  }
+};
+var deriveAutoDecisionBeacon = (toolName, toolInput, liveMode) => {
+  try {
+    if (liveMode.kill) return void 0;
+    const policy = readFreshCachedPolicy(getApiKey());
+    if (!policy) return void 0;
+    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput);
+    if (resolved.timeoutSeconds !== 0 || resolved.timeoutAction !== "approve") return void 0;
+    return {
+      decisionOrigin: resolveAutoResolveOrigin(policy, toolName, toolInput),
+      toolName,
+      toolTarget: deriveToolTarget(toolName, toolInput)
+    };
+  } catch {
+    return void 0;
+  }
+};
+var AUTO_DECISION_WINDOW_MS = 15 * 60 * 1e3;
+var HOOK_ACTIVE_WINDOW_MS = 30 * 60 * 1e3;
+var deriveUsage = (transcriptPath, sessionId) => {
+  if (!transcriptPath || process.env.PUSHARY_COST_TRACKING === "off") return void 0;
+  try {
+    return readNewUsage(transcriptPath, sessionId || DEFAULT_SESSION) ?? void 0;
+  } catch {
+    return void 0;
+  }
+};
+var detectInstallMode = () => (process.argv[1] ?? "").includes("_npx") ? "npx" : "cli";
+var reportEvent = async (event, options = {}) => {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  return withRetry(async () => {
+    const res = await fetch(`${baseUrl}/api/agent/event`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        ...event,
+        machineId: event.machineId ?? getMachineId(),
+        installMode: detectInstallMode()
+      }),
+      signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
+    });
+    try {
+      return await res.json();
+    } catch {
+      return null;
+    }
+  }, { maxAttempts: options.maxAttempts ?? 2, baseDelayMs: 300 });
+};
+var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    const action = describeToolCall(input.tool_name, input.tool_input, "event");
+    const lookup = toPolicyLookup(input.tool_name, input.tool_input);
+    const isError = isToolResultError(input.tool_result);
+    const receiptsEnabled = process.env.PUSHARY_RECEIPTS !== "off";
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    const liveMode = await fetchModeState(getApiKey(), input.session_id);
+    const late = await reconcilePendingQuestions(sessionKey);
+    let additionalContext;
+    if (late.length > 0 && agent.type === CLAUDE_CODE_AGENT.type) {
+      additionalContext = buildLateAnswerContext(late);
+      for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
+    }
+    const decisionSource = deriveDecisionSource(lookup.tool, lookup.input, liveMode);
+    const beacon = decisionSource === "policy_auto" && throttlePass(`autodecision:${sessionKey}:${lookup.tool}`, AUTO_DECISION_WINDOW_MS) ? deriveAutoDecisionBeacon(lookup.tool, lookup.input, liveMode) : void 0;
+    const reports = [
+      reportEvent({
+        event: isError ? "tool_error" : "tool_complete",
+        agentType: agent.type,
+        agentName: `${agent.label} - ${projectName}`,
+        action,
+        sessionId: input.session_id,
+        error: isError ? String(input.tool_result?.error ?? input.tool_result?.stderr ?? "").slice(0, 500) : void 0,
+        decisionSource,
+        ...beacon ? { decisionOrigin: beacon.decisionOrigin, toolName: beacon.toolName, toolTarget: beacon.toolTarget } : {},
+        meta: receiptsEnabled ? deriveReceiptMeta(lookup.tool, lookup.input, input.tool_result, input.cwd ?? process.cwd()) : void 0,
+        usage: deriveUsage(input.transcript_path, input.session_id)
+      })
+    ];
+    if (throttlePass(`hookactive:${sessionKey}`, HOOK_ACTIVE_WINDOW_MS)) {
+      reports.push(
+        reportEvent(
+          {
+            event: "agent_hook_active",
+            agentType: agent.type,
+            agentName: `${agent.label} - ${projectName}`,
+            sessionId: input.session_id
+          },
+          { maxAttempts: 1, timeoutMs: 800 }
+        )
+      );
+    }
+    await Promise.allSettled(reports);
+    return additionalContext;
+  } catch {
+    return void 0;
+  }
+};
+var TASK_TITLE_MAX_LENGTH = 120;
+var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    const titlesEnabled = process.env.PUSHARY_TASK_TITLES !== "off";
+    const taskTitle = titlesEnabled ? input.prompt?.replace(/\s+/g, " ").trim().slice(0, TASK_TITLE_MAX_LENGTH) || void 0 : void 0;
+    if (input.prompt) saveLastPrompt(sessionKey, input.prompt);
+    const late = await reconcilePendingQuestions(sessionKey);
+    let additionalContext;
+    if (late.length > 0 && agent.type === CLAUDE_CODE_AGENT.type) {
+      additionalContext = buildLateAnswerContext(late);
+      for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
+    }
+    await reportEvent({
+      event: "user_prompt",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      sessionId: input.session_id,
+      taskTitle
+    }, { maxAttempts: 1, timeoutMs: 800 });
+    return additionalContext;
+  } catch {
+    return void 0;
+  }
+};
+var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    const late = await reconcilePendingQuestions(sessionKey);
+    const tasks = [
+      reportEvent({
+        event: "session_end",
+        agentType: agent.type,
+        agentName: `${agent.label} - ${projectName}`,
+        action: "Session ended",
+        sessionId: input.session_id,
+        usage: deriveUsage(input.transcript_path, input.session_id)
+      })
+    ];
+    if (late.length > 0) {
+      tasks.push(notifyLateAnswers(getApiKey(), late, `${agent.label} - ${projectName}`, input.session_id));
+      for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
+    }
+    if (!isDefaultSession(sessionKey)) removePendingSession(sessionKey);
+    const [reported] = await Promise.allSettled(tasks);
+    const pendingCommand = reported.status === "fulfilled" ? reported.value?.pendingCommand : void 0;
+    if (typeof pendingCommand === "string" && pendingCommand.trim().length > 0) {
+      return {
+        decision: "block",
+        reason: `The user sent a new instruction from their phone via Pushary: ${pendingCommand.trim()}`
+      };
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var handleNotification = async (input) => {
+  try {
+    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",
+      sessionId: input.session_id,
+      error: input.type === "error" ? input.message : void 0
+    });
+  } catch {
+  }
+};
+
+export {
+  askUser,
+  waitForAnswer,
+  cancelQuestion,
+  sendNotification,
+  getPolicy,
+  resolvePolicy,
+  fetchModeState,
+  fetchModeOverride,
+  describeToolCall,
+  deriveToolTarget,
+  deriveActionBody,
+  deriveAction,
+  deriveBlocker,
+  getMachineId,
+  DEFAULT_SESSION,
+  savePendingQuestion,
+  readLastUserPrompt,
+  CODEX_AGENT,
+  codexAllow,
+  codexDeny,
+  codexPass,
+  toCodexWire,
+  describeApplyPatch,
+  toPolicyLookup,
+  permissionTimeoutDecision,
+  preToolUseTimeoutDecision,
+  readLastPrompt,
+  reportEvent,
+  handlePostToolUse,
+  handleUserPrompt,
+  handleStop,
+  handleNotification
+};