@pushary/agent-hooks 0.14.2 → 0.14.4

package/dist/chunk-DWED7BS3.js

@@ -0,0 +1,112 @@
+import {
+  getBaseUrl
+} from "./chunk-NKXSILEW.js";
+
+// src/retry.ts
+var isRetryable = (err) => {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message;
+  return /\b(502|503|429)\b/.test(msg) || /ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed/i.test(msg) || msg.includes("AbortError");
+};
+var withRetry = async (fn, options = {}) => {
+  const {
+    maxAttempts = 3,
+    baseDelayMs = 500,
+    maxDelayMs = 5e3,
+    shouldRetry = isRetryable
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt + 1 >= maxAttempts || !shouldRetry(err)) throw err;
+      const jitter = Math.random() * 0.3 + 0.85;
+      const delay = Math.min(baseDelayMs * 2 ** attempt * jitter, maxDelayMs);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+};
+
+// src/mcp-http.ts
+var parseSseJson = (body) => {
+  const messages = [];
+  for (const event of body.split(/\r?\n\r?\n/)) {
+    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+    if (!data) continue;
+    try {
+      messages.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  const message = messages.at(-1);
+  if (!message) throw new Error("Empty response from Pushary");
+  return message;
+};
+var parseMcpResponse = (body, contentType) => {
+  if (contentType?.includes("text/event-stream")) {
+    return parseSseJson(body);
+  }
+  return JSON.parse(body);
+};
+var sendMcpRequest = async (apiKey, message, options = {}) => {
+  return withRetry(async () => {
+    const baseUrl = options.baseUrl ?? getBaseUrl();
+    const fetchFn = options.fetchFn ?? fetch;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json, text/event-stream",
+      "Authorization": `Bearer ${apiKey}`
+    };
+    if (options.sessionId) {
+      headers["Mcp-Session-Id"] = options.sessionId;
+    }
+    const response = await fetchFn(`${baseUrl}/api/mcp/mcp`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(message),
+      signal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : void 0
+    });
+    const body = await response.text();
+    const contentType = response.headers.get("content-type");
+    let data = null;
+    if (body.trim()) {
+      try {
+        data = parseMcpResponse(body, contentType);
+      } catch (err) {
+        if (response.ok) throw err;
+      }
+    }
+    if (!response.ok) {
+      const msg = data?.error?.message ?? (body.trim() || response.statusText);
+      throw new Error(`Pushary MCP error: ${response.status} ${msg}`);
+    }
+    if (!data) throw new Error("Empty response from Pushary");
+    if (data.error) throw new Error(data.error.message ?? "Pushary MCP error");
+    return {
+      data,
+      sessionId: response.headers.get("mcp-session-id") ?? "",
+      status: response.status,
+      statusText: response.statusText
+    };
+  }, { maxAttempts: options.maxRetries ?? 1 });
+};
+var callMcpTool = async (apiKey, toolName, params, options = {}) => {
+  const { data } = await sendMcpRequest(apiKey, {
+    jsonrpc: "2.0",
+    id: options.id ?? Date.now(),
+    method: "tools/call",
+    params: { name: toolName, arguments: params }
+  }, options);
+  const text = data.result?.content?.[0]?.text;
+  if (!text) throw new Error("Empty response from Pushary");
+  return JSON.parse(text);
+};
+
+export {
+  withRetry,
+  sendMcpRequest,
+  callMcpTool
+};

package/dist/chunk-HRQEECB6.js

@@ -0,0 +1,315 @@
+import {
+  extractPolicyArg,
+  isApprovalMode,
+  matchRankWeight,
+  matchToolPattern
+} from "./chunk-22CV7V7A.js";
+import {
+  callMcpTool,
+  withRetry
+} from "./chunk-DWED7BS3.js";
+import {
+  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) => {
+  const result = await callMcpTool(apiKey, "ask_user", { ...params, wait: false }, { maxRetries: 3 });
+  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
+  });
+  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) => {
+  await callMcpTool(apiKey, "send_notification", { ...params }, { maxRetries: 3 });
+};
+
+// 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 = candidate;
+      bestWeight = weight;
+      bestLength = length;
+    }
+  }
+  return best;
+};
+var resolvePolicy = (config, toolName, modeOverride, toolInput) => {
+  const arg = toolInput ? extractPolicyArg(toolName, toolInput) : void 0;
+  const base = findBestMatch(config.policies, toolName, arg) ?? config.policies.find((p) => p.tool === "*") ?? {
+    tool: toolName,
+    timeoutSeconds: config.defaultTimeoutSeconds,
+    timeoutAction: config.defaultTimeoutAction,
+    mode: config.defaultMode ?? "push_first",
+    pushFirstSeconds: config.defaultPushFirstSeconds ?? 20
+  };
+  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 ?? "").slice(0, 120)}`,
+  Write: (input) => `wrote: ${input.file_path ?? "unknown"}`,
+  Edit: (input) => `edited: ${input.file_path ?? "unknown"}`,
+  Read: (input) => `read: ${input.file_path ?? "unknown"}`
+};
+var describeToolCall = (toolName, toolInput, format = "hook") => {
+  const prefixes = format === "hook" ? hookPrefixes : eventPrefixes;
+  const builder = prefixes[toolName];
+  if (builder) return builder(toolInput);
+  return format === "hook" ? `${toolName}: ${JSON.stringify(toolInput).slice(0, 200)}` : `${toolName}: done`;
+};
+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;
+  }
+};
+
+// 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 {
+  }
+};
+
+export {
+  isPolicyConfig,
+  askUser,
+  waitForAnswer,
+  cancelQuestion,
+  sendNotification,
+  getPolicy,
+  resolvePolicy,
+  fetchModeState,
+  fetchModeOverride,
+  describeToolCall,
+  deriveToolTarget,
+  isToolResultError,
+  deriveReceiptMeta,
+  getMachineId,
+  DEFAULT_SESSION,
+  isDefaultSession,
+  savePendingQuestion,
+  listPendingQuestions,
+  removePendingQuestion,
+  removePendingSession
+};

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
+};