@tempoxyz/patron 0.0.0-stage → 0.0.10

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

@@ -0,0 +1,429 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+import {
+  FileTokenStore,
+  clampTokensPerPage,
+  codexHome,
+  loadIssuer,
+  needsRefill,
+  normalizePayee,
+  refillSize,
+  resolveSettings,
+  settingsFor,
+  spend,
+  startRefill
+} from "./chunk-DEUBVELW.js";
+import {
+  readConfig,
+  readUsage,
+  updateUsage,
+  withLock,
+  writePrivateFile
+} from "./chunk-6TTNL3HT.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 = normalizePayee(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 = normalizePayee(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);
+  let pending = domains.slice();
+  rounds: for (let round = 0; round < perPage && pending.length > 0; round++) {
+    const next = [];
+    for (const domain of pending) {
+      if (Date.now() >= deadline) break rounds;
+      const result = await spend({
+        domain,
+        fetch: boundedFetch,
+        issuer,
+        relayUrl: settings.relayUrl,
+        store
+      }).catch(() => null);
+      if (result === void 0) {
+        empty = true;
+        break rounds;
+      }
+      if (!result?.ok) continue;
+      if (round === 0) paid.push(result.domain || domain);
+      next.push(domain);
+    }
+    pending = next;
+  }
+  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
+};

package/dist/chunks/wallet-MEBNL43A.js

@@ -0,0 +1,155 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+import {
+  statePaths
+} from "./chunk-6TTNL3HT.js";
+
+// src/wallet.ts
+import { Store } from "accounts";
+import { Provider as CliProvider, Storage } from "accounts/cli";
+import { Mppx, tempo as mppxTempo } from "mppx/client";
+import { toHex } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { tempo, tempoModerato } from "viem/chains";
+
+// src/browser.ts
+import { spawn } from "node:child_process";
+async function openBrowserUrl(url) {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+// src/wallet.ts
+var BUDGET_PERIOD_SECONDS = 30 * 24 * 60 * 60;
+async function signIn(settings, options) {
+  if (settings.privateKey)
+    return { address: privateKeyToAccount(settings.privateKey).address, wallet: "key" };
+  const provider = tempoProvider(settings, options.issuer.chainId, options.output);
+  await Store.waitForHydration(provider.store);
+  const result = await provider.request({
+    method: "wallet_connect",
+    params: [
+      {
+        capabilities: {
+          authorizeAccessKey: {
+            expiry: 0,
+            limits: [budgetLimit(options.budgetUnits, options.issuer.currency)]
+          }
+        }
+      }
+    ]
+  });
+  const address = result.accounts[0]?.address;
+  if (!address) throw new Error("Tempo Wallet did not authorize Patron.");
+  return { address, wallet: "tempo" };
+}
+async function authorizeBudget(settings, options) {
+  if (settings.privateKey) return;
+  const provider = tempoProvider(settings, options.issuer.chainId, options.output);
+  await Store.waitForHydration(provider.store);
+  await provider.request({
+    method: "wallet_authorizeAccessKey",
+    params: [
+      { expiry: 0, limits: [budgetLimit(options.budgetUnits, options.issuer.currency)] }
+    ]
+  });
+}
+async function openWallet(settings, wallet, issuer, maxUnits, output = process.stderr) {
+  const policy = {
+    currencies: [issuer.currency],
+    decimals: 6,
+    expectedChainId: issuer.chainId,
+    maxAtomicAmount: maxUnits.toString()
+  };
+  if (wallet === "key") {
+    if (!settings.privateKey)
+      throw new Error(
+        "This Patron install pays with PATRON_PRIVATE_KEY, which is not set."
+      );
+    const account = privateKeyToAccount(settings.privateKey);
+    const payment2 = Mppx.create({
+      methods: [mppxTempo.charge({ account, ...policy })],
+      polyfill: false
+    });
+    return {
+      address: account.address,
+      fetch: payment2.fetch,
+      signMessage: (message) => account.signMessage({ message })
+    };
+  }
+  const provider = tempoProvider(settings, issuer.chainId, output);
+  await Store.waitForHydration(provider.store);
+  const [address] = await provider.request({ method: "eth_accounts" });
+  if (!address)
+    throw new Error(
+      "Tempo Wallet is signed out. Run npx @tempoxyz/patron to sign in again."
+    );
+  const accessKey = provider.store.getState().accessKeys.find(
+    (key) => key.access.toLowerCase() === address.toLowerCase() && key.chainId === issuer.chainId
+  );
+  const mppParameters = provider.getMppxParameters(
+    accessKey ? { accessKey: accessKey.address } : void 0
+  );
+  const payment = Mppx.create({
+    methods: [
+      mppxTempo.charge({
+        account: provider.getAccount(),
+        mode: "pull",
+        ...policy,
+        ...mppParameters
+      })
+    ],
+    polyfill: false
+  });
+  return {
+    address,
+    fetch: payment.fetch,
+    signMessage: (message) => provider.request({ method: "personal_sign", params: [toHex(message), address] })
+  };
+}
+function budgetLimit(budgetUnits, currency) {
+  return {
+    limit: toHex(budgetUnits),
+    period: BUDGET_PERIOD_SECONDS,
+    token: currency
+  };
+}
+function tempoProvider(settings, chainId, output) {
+  const chain = chainId === tempoModerato.id ? tempoModerato : tempo;
+  return CliProvider.create({
+    chains: [chain],
+    mpp: false,
+    name: "Patron",
+    open: async (url, prompt) => {
+      const code = prompt.userCode.replace(/^(.{4})(.{4})$/, "$1-$2");
+      output.write(
+        `
+Tempo Wallet sign-in
+Confirm code ${code} in your browser:
+${url}
+
+`
+      );
+      await openBrowserUrl(url).catch(() => void 0);
+    },
+    storage: Storage.filesystem({
+      key: "patron-tempo",
+      path: statePaths(settings.home).wallet
+    })
+  });
+}
+export {
+  authorizeBudget,
+  openWallet,
+  signIn
+};

package/package.json

@@ -1,6 +1,48 @@
 {
-  "name": "@tempoxyz/patron",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@tempoxyz/patron",
+	"version": "0.0.10",
+	"description": "Pay the websites your AI agents read, privately",
+	"type": "module",
+	"bin": {
+		"patron": "dist/bin.js"
+	},
+	"files": [
+		"dist"
+	],
+	"engines": {
+		"node": ">=22"
+	},
+	"homepage": "https://patron-web.tempo-dev.workers.dev",
+	"keywords": [
+		"agent",
+		"amp",
+		"claude-code",
+		"codex",
+		"cursor",
+		"patron",
+		"privacy-pass",
+		"tempo"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "node scripts/build.mjs",
+		"check:types": "tsc --project tsconfig.json --noEmit",
+		"prepack": "pnpm build",
+		"test": "vitest run"
+	},
+	"devDependencies": {
+		"@patron/client": "workspace:*",
+		"@patron/protocol": "workspace:*",
+		"@types/node": "24.19.2",
+		"esbuild": "0.28.2",
+		"typescript": "5.9.3",
+		"vitest": "4.1.12"
+	},
+	"dependencies": {
+		"accounts": "0.21.1",
+		"mppx": "0.15.0",
+		"viem": "2.57.12"
+	}
+}