@tempoxyz/patron 0.0.0-stage → 0.0.1

package/dist/chunks/chunk-NLCZ2IHE.js

@@ -0,0 +1,213 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/state.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/lock.ts
+import { open, rm, stat } from "node:fs/promises";
+async function withLock(path, fn, options = {}) {
+  const deadline = Date.now() + (options.timeoutMs ?? 3e3);
+  const staleMs = options.staleMs ?? 1e4;
+  for (; ; ) {
+    try {
+      const handle = await open(path, "wx", 384);
+      await handle.close();
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const age = await stat(path).then(
+        (stats) => Date.now() - stats.mtimeMs,
+        () => 0
+      );
+      if (age > staleMs) {
+        await rm(path, { force: true });
+        continue;
+      }
+      if (Date.now() > deadline) throw new Error(`Patron state is busy: ${path}`);
+      await new Promise((resolve) => setTimeout(resolve, 10 + Math.random() * 20));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    await rm(path, { force: true });
+  }
+}
+async function tryLock(path, staleMs) {
+  try {
+    const handle = await open(path, "wx", 384);
+    await handle.close();
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const age = await stat(path).then(
+      (stats) => Date.now() - stats.mtimeMs,
+      () => 0
+    );
+    if (age <= staleMs) return void 0;
+    await rm(path, { force: true });
+    return tryLock(path, staleMs);
+  }
+  return () => rm(path, { force: true });
+}
+
+// src/state.ts
+var AGENT_IDS = ["claude-code", "codex", "cursor", "amp"];
+function statePaths(home) {
+  return {
+    config: join(home, "config.json"),
+    issuer: join(home, "issuer.json"),
+    key: join(home, "key"),
+    refillLock: join(home, "refill.lock"),
+    stateLock: join(home, "state.lock"),
+    tokens: join(home, "tokens.enc"),
+    usage: join(home, "usage.json"),
+    usageLock: join(home, "usage.lock"),
+    wallet: join(home, "wallet.json")
+  };
+}
+function monthOf(now) {
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+}
+async function ensureHome(home) {
+  await mkdir(home, { mode: 448, recursive: true });
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function writePrivateFile(path, contents) {
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, contents, { mode: 384 });
+  await chmod(temporary, 384);
+  await rename(temporary, path);
+}
+async function readConfig(home) {
+  const value = await readJson(statePaths(home).config).catch(() => void 0);
+  if (!value || typeof value !== "object") return void 0;
+  const config = value;
+  if (config.version !== 1 || typeof config.address !== "string") return void 0;
+  return {
+    agents: Array.isArray(config.agents) ? config.agents.filter(
+      (agent) => AGENT_IDS.includes(agent)
+    ) : [],
+    address: config.address,
+    gatewayUrl: String(config.gatewayUrl ?? ""),
+    monthlyBudgetUsd: Number(config.monthlyBudgetUsd ?? 0),
+    network: config.network === "testnet" ? "testnet" : "mainnet",
+    paused: config.paused === true,
+    relayUrl: String(config.relayUrl ?? ""),
+    version: 1,
+    wallet: config.wallet === "key" ? "key" : "tempo",
+    ...typeof config.name === "string" ? { name: config.name } : {}
+  };
+}
+async function writeConfig(home, config) {
+  await ensureHome(home);
+  await writePrivateFile(
+    statePaths(home).config,
+    `${JSON.stringify(config, null, "	")}
+`
+  );
+}
+function emptyUsage(month) {
+  return { boughtTokens: 0, domains: {}, month, paidPages: 0 };
+}
+async function readUsage(home, now = /* @__PURE__ */ new Date()) {
+  const month = monthOf(now);
+  const path = statePaths(home).usage;
+  const value = await readJson(path).catch(() => {
+    throw unreadableUsage(path);
+  });
+  if (value === void 0) return emptyUsage(month);
+  if (!isUsageRecord(value)) throw unreadableUsage(path);
+  if (value.month !== month) return emptyUsage(month);
+  return {
+    boughtTokens: value.boughtTokens,
+    domains: value.domains && typeof value.domains === "object" ? { ...value.domains } : {},
+    month,
+    paidPages: Number(value.paidPages ?? 0)
+  };
+}
+function isUsageRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const usage = value;
+  return typeof usage.month === "string" && typeof usage.boughtTokens === "number" && Number.isFinite(usage.boughtTokens) && usage.boughtTokens >= 0;
+}
+function unreadableUsage(path) {
+  return new Error(
+    `${path} is unreadable, so Patron stops buying tokens. Delete it to restart this month's budget count.`
+  );
+}
+async function updateUsage(home, update, now = /* @__PURE__ */ new Date()) {
+  await ensureHome(home);
+  return withLock(statePaths(home).usageLock, async () => {
+    const usage = await readUsage(home, now);
+    update(usage);
+    await writePrivateFile(statePaths(home).usage, `${JSON.stringify(usage)}
+`);
+    return usage;
+  });
+}
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  withLock,
+  tryLock,
+  AGENT_IDS,
+  statePaths,
+  ensureHome,
+  readJson,
+  writePrivateFile,
+  readConfig,
+  writeConfig,
+  readUsage,
+  updateUsage
+};

package/dist/chunks/hook-process-QQ34YQIA.js

@@ -0,0 +1,425 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+import {
+  FileTokenStore,
+  clampTokensPerPage,
+  codexHome,
+  loadIssuer,
+  needsRefill,
+  normalizeDomain,
+  refillSize,
+  resolveSettings,
+  settingsFor,
+  spend,
+  startRefill
+} from "./chunk-6Q7AFS33.js";
+import {
+  readConfig,
+  readUsage,
+  updateUsage,
+  withLock,
+  writePrivateFile
+} from "./chunk-NLCZ2IHE.js";
+
+// src/hook.ts
+import { homedir } from "node:os";
+
+// src/hook-input.ts
+var MAX_DOMAINS_PER_HOOK = 10;
+var MAX_DEPTH = 6;
+var MAX_URLS = 50;
+var FETCH_TOOLS = /* @__PURE__ */ new Set(["WebFetch", "read_web_page"]);
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["WebSearch", "web_search"]);
+function hookUrls(payload) {
+  if (!isRecord(payload) || typeof payload.tool_name !== "string") return [];
+  const tool = payload.tool_name;
+  const response = "tool_response" in payload ? payload.tool_response : jsonValue(payload.tool_output);
+  if (FETCH_TOOLS.has(tool)) {
+    const input = payload.tool_input;
+    if (isRecord(input) && typeof input.url === "string") return [input.url];
+    const urls2 = [];
+    collectUrls(response, urls2, 0);
+    return urls2.slice(0, 1);
+  }
+  if (!SEARCH_TOOLS.has(tool)) return [];
+  const urls = [];
+  collectUrls(response, urls, 0);
+  if (urls.length === 0 && tool === "web_search") collectTextUrls(response, urls, 0);
+  return urls;
+}
+function hookDomains(payload) {
+  const domains = [];
+  for (const url of hookUrls(payload)) {
+    const domain = normalizeDomain(url);
+    if (domain && !domains.includes(domain)) domains.push(domain);
+    if (domains.length >= MAX_DOMAINS_PER_HOOK) break;
+  }
+  return domains;
+}
+function turnEnd(payload) {
+  if (!isRecord(payload)) return void 0;
+  if (payload.hook_event_name === "Stop" && typeof payload.turn_id === "string" && typeof payload.transcript_path === "string")
+    return { transcriptPath: payload.transcript_path };
+  if (payload.type === "agent-turn-complete" && typeof payload["thread-id"] === "string")
+    return { codexThreadId: payload["thread-id"] };
+  return void 0;
+}
+function isCursorPayload(payload) {
+  return isRecord(payload) && typeof payload.cursor_version === "string";
+}
+function parseHookInput(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function jsonValue(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function collectUrls(value, urls, depth) {
+  if (depth > MAX_DEPTH || urls.length >= MAX_URLS) return;
+  if (Array.isArray(value)) {
+    for (const item of value) collectUrls(item, urls, depth + 1);
+    return;
+  }
+  if (!isRecord(value)) return;
+  for (const [key, item] of Object.entries(value)) {
+    if (key === "url" && typeof item === "string") urls.push(item);
+    else collectUrls(item, urls, depth + 1);
+  }
+}
+function collectTextUrls(value, urls, depth) {
+  if (depth > MAX_DEPTH || urls.length >= MAX_URLS) return;
+  if (typeof value === "string") {
+    for (const match of value.matchAll(/https?:\/\/[^\s"'<>()[\]`]+/g)) {
+      if (urls.length >= MAX_URLS) return;
+      urls.push(match[0].replace(/[.,;:!?]+$/, ""));
+    }
+    return;
+  }
+  if (Array.isArray(value))
+    for (const item of value) collectTextUrls(item, urls, depth + 1);
+  else if (isRecord(value))
+    for (const item of Object.values(value)) collectTextUrls(item, urls, depth + 1);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/transcript.ts
+import { createHash } from "node:crypto";
+import { mkdir, open, readdir, readFile, rm, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+var MAX_ROLLOUT_READ_BYTES = 16 * 1024 * 1024;
+var SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var MAX_REMEMBERED_DOMAINS = 2e3;
+var MAX_DAY_DIRECTORIES = 400;
+function isCodexRollout(path) {
+  const name = basename(path);
+  return name.startsWith("rollout-") && name.endsWith(".jsonl");
+}
+function codexRolloutUrls(lines) {
+  const urls = [];
+  for (const line of lines) {
+    if (!line.includes("http")) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isRecord2(record) || !isRecord2(record.payload)) continue;
+    const payload = record.payload;
+    if (record.type === "response_item") responseItemUrls(payload, urls);
+    else if (record.type === "event_msg") eventUrls(payload, urls);
+  }
+  return urls;
+}
+function responseItemUrls(item, urls) {
+  if (item.type === "web_search_call") pushUrl(urls, field(item.action, "url"));
+  else if (item.type === "message" && item.role === "assistant") {
+    for (const content of asArray(item.content))
+      for (const annotation of asArray(field(content, "annotations")))
+        if (field(annotation, "type") === "url_citation")
+          pushUrl(urls, field(annotation, "url"));
+  } else if (item.type === "function_call" && item.namespace === "web" && item.name === "run" && typeof item.arguments === "string") {
+    let commands;
+    try {
+      commands = JSON.parse(item.arguments);
+    } catch {
+      return;
+    }
+    for (const key of ["open", "find"])
+      for (const operation of asArray(field(commands, key)))
+        pushUrl(urls, field(operation, "ref_id"));
+  }
+}
+function eventUrls(event, urls) {
+  const search = event.type === "web_search_end" ? event : event.type === "item_completed" && field(event.item, "type") === "WebSearch" ? event.item : void 0;
+  if (!isRecord2(search)) return;
+  pushUrl(urls, field(search.action, "url"));
+  for (const result of asArray(search.results)) pushUrl(urls, field(result, "url"));
+}
+async function takeTranscriptDomains(home, transcriptPath2, options) {
+  if (!isCodexRollout(transcriptPath2)) return [];
+  const paths = sessionPaths(home, transcriptPath2);
+  await mkdir(paths.directory, { mode: 448, recursive: true });
+  return withLock(
+    paths.lock,
+    async () => {
+      const saved = await readState(paths.state);
+      const state = saved ?? { offset: 0, paid: [], pending: [] };
+      const { lines, offset } = await readNewLines(transcriptPath2, state.offset);
+      const known = /* @__PURE__ */ new Set([...state.paid, ...state.pending]);
+      const pending = [...state.pending];
+      for (const url of codexRolloutUrls(lines)) {
+        const domain = normalizeDomain(url);
+        if (domain && !known.has(domain)) {
+          known.add(domain);
+          pending.push(domain);
+        }
+      }
+      const taken = options.discard ? [] : pending.slice(0, options.max);
+      const next = {
+        offset,
+        paid: [...state.paid, ...taken].slice(-MAX_REMEMBERED_DOMAINS),
+        pending: options.discard ? [] : pending.slice(taken.length)
+      };
+      await writePrivateFile(paths.state, JSON.stringify(next));
+      if (!saved) await pruneSessions(paths.directory).catch(() => void 0);
+      return taken;
+    },
+    { timeoutMs: 1500 }
+  );
+}
+async function findCodexRollout(codexHome2, threadId) {
+  if (!/^[0-9a-f-]{8,64}$/i.test(threadId)) return void 0;
+  const root = join(codexHome2, "sessions");
+  let searched = 0;
+  for (const year of await numericEntries(root))
+    for (const month of await numericEntries(year))
+      for (const day of await numericEntries(month)) {
+        if (++searched > MAX_DAY_DIRECTORIES) return void 0;
+        const names = await readdir(day).catch(() => []);
+        const name = names.find(
+          (entry) => isCodexRollout(entry) && (entry.endsWith(`-${threadId}.jsonl`) || entry.includes(`-${threadId}_`))
+        );
+        if (name) return join(day, name);
+      }
+  return void 0;
+}
+async function numericEntries(directory) {
+  const names = await readdir(directory).catch(() => []);
+  return names.filter((name) => /^\d+$/.test(name)).sort((left, right) => Number(right) - Number(left)).map((name) => join(directory, name));
+}
+async function readNewLines(path, from) {
+  const handle = await open(path, "r");
+  try {
+    const { size } = await handle.stat();
+    const start = size < from ? 0 : from;
+    const length = Math.min(size - start, MAX_ROLLOUT_READ_BYTES);
+    if (length <= 0) return { lines: [], offset: start };
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, start);
+    const end = buffer.subarray(0, bytesRead).lastIndexOf(10);
+    if (end === -1)
+      return {
+        lines: [],
+        offset: length === MAX_ROLLOUT_READ_BYTES ? start + length : start
+      };
+    return {
+      lines: buffer.subarray(0, end).toString("utf8").split("\n"),
+      offset: start + end + 1
+    };
+  } finally {
+    await handle.close();
+  }
+}
+function sessionPaths(home, transcriptPath2) {
+  const id = createHash("sha256").update(transcriptPath2).digest("hex").slice(0, 32);
+  const directory = join(home, "sessions");
+  return {
+    directory,
+    lock: join(directory, `${id}.lock`),
+    state: join(directory, `${id}.json`)
+  };
+}
+async function readState(path) {
+  let value;
+  try {
+    value = JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+  if (!isRecord2(value) || typeof value.offset !== "number") return void 0;
+  const strings = (list) => asArray(list).filter((item) => typeof item === "string");
+  return {
+    offset: value.offset,
+    paid: strings(value.paid),
+    pending: strings(value.pending)
+  };
+}
+async function pruneSessions(directory) {
+  const now = Date.now();
+  for (const name of await readdir(directory)) {
+    if (!name.endsWith(".json")) continue;
+    const path = join(directory, name);
+    const { mtimeMs } = await stat(path);
+    if (now - mtimeMs > SESSION_TTL_MS) await rm(path, { force: true });
+  }
+}
+function pushUrl(urls, value) {
+  if (typeof value === "string" && /^https?:\/\//i.test(value)) urls.push(value);
+}
+function field(value, key) {
+  return isRecord2(value) ? value[key] : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/hook.ts
+var HOOK_TIMEOUT_MS = 2e3;
+var ABORT_MARGIN_MS = 500;
+async function runHook(dependencies, timeoutMs = HOOK_TIMEOUT_MS) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(
+      () => resolve({ paid: [], refill: false, skipped: "timeout" }),
+      timeoutMs
+    );
+  });
+  try {
+    const deadline = Date.now() + timeoutMs - Math.min(ABORT_MARGIN_MS, timeoutMs / 4);
+    return await Promise.race([payReads(dependencies, deadline).catch(failed), timeout]);
+  } catch {
+    return failed();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function failed() {
+  return { paid: [], refill: false, skipped: "error" };
+}
+async function payReads(dependencies, deadline) {
+  const payload = parseHookInput(await dependencies.readInput());
+  const turn = turnEnd(payload);
+  let domains = turn ? [] : hookDomains(payload);
+  if (!turn && domains.length === 0) return { paid: [], refill: false, skipped: "empty" };
+  const config = await readConfig(dependencies.settings.home);
+  if (!config) return { paid: [], refill: false, skipped: "not-setup" };
+  const settings = settingsFor(dependencies.settings, config);
+  if (turn) {
+    const path = await transcriptPath(turn, dependencies.agents);
+    if (!path) return { paid: [], refill: false, skipped: "empty" };
+    domains = await takeTranscriptDomains(settings.home, path, {
+      discard: config.paused,
+      max: MAX_DOMAINS_PER_HOOK
+    });
+  }
+  if (config.paused) return { paid: [], refill: false, skipped: "paused" };
+  if (domains.length === 0) return { paid: [], refill: false, skipped: "empty" };
+  const store = new FileTokenStore(settings.home);
+  const boundedFetch = withDeadline(dependencies.fetch ?? fetch, deadline);
+  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
+    fetch: boundedFetch
+  });
+  const paid = [];
+  let empty = false;
+  const perPage = clampTokensPerPage(config.tokensPerPage);
+  reads: for (const domain of domains) {
+    for (let token = 0; token < perPage; token++) {
+      if (Date.now() >= deadline) break reads;
+      const result = await spend({
+        domain,
+        fetch: boundedFetch,
+        issuer,
+        relayUrl: settings.relayUrl,
+        store
+      }).catch(() => null);
+      if (result === void 0) {
+        empty = true;
+        break reads;
+      }
+      if (token === 0 && result?.ok) paid.push(result.domain || domain);
+      if (!result?.ok) break;
+    }
+  }
+  const now = dependencies.now?.() ?? /* @__PURE__ */ new Date();
+  if (paid.length > 0)
+    await updateUsage(
+      settings.home,
+      (usage) => {
+        usage.paidPages += paid.length;
+        for (const domain of paid)
+          usage.domains[domain] = (usage.domains[domain] ?? 0) + 1;
+      },
+      now
+    );
+  const refill = needsRefill(await store.count()) && refillSize(config, await readUsage(settings.home, now)) > 0;
+  if (refill) dependencies.startRefill();
+  return {
+    paid,
+    refill,
+    ...empty && paid.length === 0 ? { skipped: "no-tokens" } : {}
+  };
+}
+function withDeadline(fetchFn, deadline) {
+  return (input, init) => fetchFn(input, {
+    ...init,
+    signal: AbortSignal.timeout(Math.max(1, deadline - Date.now()))
+  });
+}
+function transcriptPath(turn, agents = { env: process.env, home: homedir() }) {
+  if ("transcriptPath" in turn) return Promise.resolve(turn.transcriptPath);
+  return findCodexRollout(codexHome(agents.env, agents.home), turn.codexThreadId);
+}
+
+// src/hook-process.ts
+var MAX_INPUT_BYTES = 8 * 1024 * 1024;
+async function runHookProcess(argument = process.argv[3]) {
+  setTimeout(() => process.exit(0), HOOK_TIMEOUT_MS + 500).unref();
+  const raw = argument ?? await readStdin(HOOK_TIMEOUT_MS / 2);
+  if (isCursorPayload(parseHookInput(raw))) process.stdout.write("{}\n");
+  await runHook({
+    readInput: async () => raw,
+    settings: resolveSettings(),
+    startRefill: () => startRefill()
+  });
+}
+function readStdin(timeoutMs) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let size = 0;
+    const finish = () => {
+      clearTimeout(timer);
+      process.stdin.removeAllListeners();
+      process.stdin.pause();
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    process.stdin.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_INPUT_BYTES) {
+        chunks.length = 0;
+        finish();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    process.stdin.on("end", finish);
+    process.stdin.on("error", finish);
+  });
+}
+export {
+  runHookProcess
+};