@pushary/agent-hooks 0.14.3 → 0.15.0

package/dist/chunk-HWEMAAOY.js

@@ -0,0 +1,370 @@
+import {
+  DEFAULT_SESSION,
+  cancelQuestion,
+  deriveReceiptMeta,
+  describeToolCall,
+  fetchModeState,
+  getMachineId,
+  isDefaultSession,
+  isPolicyConfig,
+  isToolResultError,
+  listPendingQuestions,
+  removePendingQuestion,
+  removePendingSession,
+  resolvePolicy
+} from "./chunk-HRQEECB6.js";
+import {
+  withRetry
+} from "./chunk-DWED7BS3.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-NKXSILEW.js";
+
+// src/codex-adapter.ts
+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 toPolicyLookup = (toolName, toolInput) => {
+  if (toolName !== "apply_patch") return { tool: toolName, input: toolInput };
+  const command = toolInput.command;
+  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/usage.ts
+import { closeSync, mkdirSync, openSync, readFileSync, readSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } 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() || join(tmpdir(), "pushary-usage");
+var stateFile = (sessionId) => join(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(readFileSync(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 readNewUsage = (transcriptPath, sessionId) => {
+  try {
+    const size = statSync(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;
+      }
+    }
+    mkdirSync(stateDir(), { recursive: true });
+    writeFileSync(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/events.ts
+import { basename, join as join2 } from "path";
+import { createHash } from "crypto";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+var cleanupPendingQuestions = async (sessionId) => {
+  try {
+    const files = listPendingQuestions(sessionId);
+    const apiKey = getApiKey();
+    for (const correlationId of files) {
+      try {
+        await cancelQuestion(apiKey, correlationId);
+      } catch {
+      }
+      removePendingQuestion(sessionId, correlationId);
+    }
+    if (!isDefaultSession(sessionId)) removePendingSession(sessionId);
+  } catch {
+  }
+};
+var CLAUDE_CODE_AGENT = { type: "claude_code", label: "Claude Code" };
+var POLICY_CACHE_TTL_MS = 5 * 60 * 1e3;
+var readFreshCachedPolicy = (apiKey) => {
+  const hash = createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
+  const path = join2(tmpdir2(), `pushary-policy-${hash}.json`);
+  if (!existsSync(path)) return null;
+  const cached = JSON.parse(readFileSync2(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 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 reportEvent = async (event, options = {}) => {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  await withRetry(async () => {
+    await fetch(`${baseUrl}/api/agent/event`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        ...event,
+        machineId: event.machineId ?? getMachineId()
+      }),
+      signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
+    });
+  }, { 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 liveMode = await fetchModeState(getApiKey(), input.session_id);
+    await Promise.allSettled([
+      cleanupPendingQuestions(input.session_id || DEFAULT_SESSION),
+      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: deriveDecisionSource(lookup.tool, lookup.input, liveMode),
+        meta: receiptsEnabled ? deriveReceiptMeta(lookup.tool, lookup.input, input.tool_result, input.cwd ?? process.cwd()) : void 0,
+        usage: deriveUsage(input.transcript_path, input.session_id)
+      })
+    ]);
+  } catch {
+  }
+};
+var TASK_TITLE_MAX_LENGTH = 120;
+var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    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;
+    await reportEvent({
+      event: "user_prompt",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      sessionId: input.session_id,
+      taskTitle
+    }, { maxAttempts: 1, timeoutMs: 800 });
+  } catch {
+  }
+};
+var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename(input.cwd ?? process.cwd());
+    await Promise.allSettled([
+      cleanupPendingQuestions(input.session_id || DEFAULT_SESSION),
+      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)
+      })
+    ]);
+  } catch {
+  }
+};
+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 {
+  CODEX_AGENT,
+  codexAllow,
+  codexDeny,
+  codexPass,
+  toCodexWire,
+  toPolicyLookup,
+  permissionTimeoutDecision,
+  preToolUseTimeoutDecision,
+  reportEvent,
+  handlePostToolUse,
+  handleUserPrompt,
+  handleStop,
+  handleNotification
+};

package/dist/chunk-NKXSILEW.js

@@ -0,0 +1,29 @@
+// src/config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var configFilePath = () => process.env.PUSHARY_CONFIG_FILE?.trim() || join(homedir(), ".pushary", "config.json");
+var readKeyFromConfigFile = () => {
+  try {
+    const parsed = JSON.parse(readFileSync(configFilePath(), "utf-8"));
+    const key = typeof parsed.apiKey === "string" ? parsed.apiKey.trim() : "";
+    return key || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var getApiKey = () => {
+  const envKey = process.env.PUSHARY_API_KEY?.trim();
+  if (envKey) return envKey;
+  const fileKey = readKeyFromConfigFile();
+  if (fileKey) return fileKey;
+  throw new Error(
+    "PUSHARY_API_KEY is not set and no key was found in ~/.pushary/config.json. Run `npx @pushary/agent-hooks setup`, or get your API key at https://pushary.com/sign-up?from=ai-coding"
+  );
+};
+var getBaseUrl = () => process.env.PUSHARY_BASE_URL ?? "https://pushary.com";
+
+export {
+  getApiKey,
+  getBaseUrl
+};

package/dist/chunk-VC6U3QGF.js

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