@tempoxyz/patron 0.0.0-stage → 0.0.1

package/dist/chunks/-MVQH5G3L.js

@@ -0,0 +1,1105 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+import {
+  DEFAULT_MONTHLY_BUDGET_USD,
+  FileTokenStore,
+  LeaderboardResponse,
+  MAX_TOKENS_PER_PAGE,
+  MIN_TOKENS_PER_PAGE,
+  PACK_SIZE,
+  PatronInfo,
+  STARTER_TOKENS,
+  TOKEN_PRICE_UNITS,
+  budgetTokens,
+  buyTokens,
+  clampTokensPerPage,
+  codexHome,
+  codexPaths,
+  formatUsd,
+  hasPatronHandler,
+  installCodex,
+  isObject,
+  isPatronHandler,
+  loadIssuer,
+  needsRefill,
+  normalizeDomain,
+  parseUsd,
+  profileMessage,
+  purchasableTokens,
+  readJsonObject,
+  redeem,
+  removeCodex,
+  resolveSettings,
+  settingsFor,
+  startRefill,
+  tipTokens,
+  tokensToUnits,
+  withHooksKey,
+  withPatronGroup,
+  withoutPatronHandlers,
+  writeJsonObject
+} from "./chunk-6Q7AFS33.js";
+import {
+  AGENT_IDS,
+  ensureHome,
+  readConfig,
+  readJson,
+  readUsage,
+  statePaths,
+  tryLock,
+  updateUsage,
+  withLock,
+  writeConfig,
+  writePrivateFile
+} from "./chunk-NLCZ2IHE.js";
+
+// src/index.ts
+import { readFileSync } from "node:fs";
+import { rm as rm3 } from "node:fs/promises";
+import { homedir } from "node:os";
+
+// src/agents.ts
+import { constants } from "node:fs";
+import { access, realpath } from "node:fs/promises";
+import { delimiter, join as join4 } from "node:path";
+
+// src/amp.ts
+import { mkdir, readFile, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var AMP_PLUGIN_MARKER = "// Patron for Amp. Generated by npx @tempoxyz/patron; npx @tempoxyz/patron uninstall removes it.";
+var AMP_WEB_TOOLS = ["read_web_page", "web_search"];
+function ampPluginPath(env, home) {
+  return join(env.XDG_CONFIG_HOME || join(home, ".config"), "amp", "plugins", "patron.ts");
+}
+function ampPluginSource(command) {
+  return `${AMP_PLUGIN_MARKER}
+import { spawn } from 'node:child_process'
+import type { PluginAPI } from '@ampcode/plugin'
+
+export const description = 'Patron: pays $0.001 to each site Amp reads with read_web_page or web_search, privately.'
+
+const COMMAND = ${JSON.stringify(command)}
+const TOOLS = new Set(${JSON.stringify(AMP_WEB_TOOLS)})
+
+export default function (amp: PluginAPI) {
+	amp.on('tool.result', (event) => {
+		if (event.status !== 'done' || !TOOLS.has(event.tool)) return
+		try {
+			const child = spawn(COMMAND, { detached: true, shell: true, stdio: ['pipe', 'ignore', 'ignore'] })
+			child.on('error', () => undefined)
+			child.stdin?.on('error', () => undefined)
+			child.stdin?.end(
+				JSON.stringify({
+					hook_event_name: 'tool.result',
+					tool_input: event.input,
+					tool_name: event.tool,
+					tool_response: event.tool === 'web_search' ? event.output : undefined,
+				}),
+			)
+			child.unref()
+		} catch {
+			// Paying must never affect the agent.
+		}
+	})
+}
+`;
+}
+async function installAmpPlugin(path, command) {
+  const current = await readText(path);
+  const source = ampPluginSource(command);
+  if (current === source) return "unchanged";
+  if (current !== void 0 && !current.startsWith(AMP_PLUGIN_MARKER))
+    throw new Error(`${path} exists and is not Patron's; left unchanged.`);
+  await mkdir(dirname(path), { recursive: true });
+  await writePrivateFile(path, source);
+  return "installed";
+}
+async function removeAmpPlugin(path) {
+  const current = await readText(path);
+  if (current === void 0 || !current.startsWith(AMP_PLUGIN_MARKER)) return "missing";
+  await rm(path, { force: true });
+  return "removed";
+}
+async function readText(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+
+// src/claude-code.ts
+var CLAUDE_MATCHER = "WebFetch|WebSearch";
+var HOOK_TIMEOUT_SECONDS = 30;
+var EVENT = "PostToolUse";
+function withPatronHook(settings, command) {
+  return withPatronGroup(settings, EVENT, {
+    hooks: [{ async: true, command, timeout: HOOK_TIMEOUT_SECONDS, type: "command" }],
+    matcher: CLAUDE_MATCHER
+  });
+}
+function withoutPatronHook(settings) {
+  return withoutPatronHandlers(settings, EVENT);
+}
+function hasPatronHook(settings, command) {
+  return hasPatronHandler(settings, EVENT, {
+    matcher: CLAUDE_MATCHER,
+    ...command === void 0 ? {} : { command }
+  });
+}
+async function installClaudeHook(path, command) {
+  const settings = await readJsonObject(path);
+  if (hasPatronHook(settings, command)) return "unchanged";
+  await writeJsonObject(path, withPatronHook(settings, command));
+  return "installed";
+}
+async function removeClaudeHook(path) {
+  const settings = await readJsonObject(path);
+  if (!hasPatronHandler(settings, EVENT)) return "missing";
+  await writeJsonObject(path, withoutPatronHook(settings));
+  return "removed";
+}
+
+// src/cursor.ts
+import { join as join2 } from "node:path";
+var CURSOR_MATCHER = "WebFetch|WebSearch";
+var HOOK_TIMEOUT_SECONDS2 = 10;
+var EVENT2 = "postToolUse";
+function cursorHooksPath(home) {
+  return join2(home, ".cursor", "hooks.json");
+}
+function withCursorHook(config, command) {
+  const stripped = withoutCursorHook(config);
+  const next = typeof stripped.version === "number" ? stripped : { version: 1, ...stripped };
+  const hooks = isObject(next.hooks) ? next.hooks : {};
+  const entries = Array.isArray(hooks[EVENT2]) ? hooks[EVENT2] : [];
+  return withHooksKey(next, EVENT2, [...entries, cursorEntry(command)]);
+}
+function withoutCursorHook(config) {
+  const entries = isObject(config.hooks) ? config.hooks[EVENT2] : void 0;
+  if (!Array.isArray(entries) || !entries.some(isPatronHandler)) return { ...config };
+  return withHooksKey(
+    config,
+    EVENT2,
+    entries.filter((entry) => !isPatronHandler(entry))
+  );
+}
+function cursorEntry(command) {
+  return { command, matcher: CURSOR_MATCHER, timeout: HOOK_TIMEOUT_SECONDS2 };
+}
+function hasCursorHook(config, command) {
+  const entries = isObject(config.hooks) ? config.hooks[EVENT2] : void 0;
+  if (!Array.isArray(entries)) return false;
+  if (command === void 0) return entries.some(isPatronHandler);
+  const wanted = JSON.stringify(cursorEntry(command));
+  return entries.some((entry) => JSON.stringify(entry) === wanted);
+}
+async function installCursorHook(path, command) {
+  const config = await readJsonObject(path);
+  if (hasCursorHook(config, command)) return "unchanged";
+  await writeJsonObject(path, withCursorHook(config, command));
+  return "installed";
+}
+async function removeCursorHook(path) {
+  const config = await readJsonObject(path);
+  if (!hasCursorHook(config)) return "missing";
+  await writeJsonObject(path, withoutCursorHook(config));
+  return "removed";
+}
+
+// src/originals.ts
+import { chmod, readFile as readFile2, rm as rm2, stat, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+function originalsPath(patronHome) {
+  return join3(patronHome, "agent-originals.json");
+}
+async function rememberOriginals(store, paths) {
+  return update(store, async (originals) => {
+    const added = [];
+    for (const path of paths) {
+      if (path in originals) continue;
+      originals[path] = await snapshot(path);
+      added.push(path);
+    }
+    return added;
+  });
+}
+async function forgetOriginals(store, paths) {
+  if (paths.length === 0) return;
+  await update(store, async (originals) => {
+    for (const path of paths) delete originals[path];
+  });
+}
+async function restoreOriginals(store, paths) {
+  await update(store, async (originals) => {
+    for (const path of paths) {
+      if (!(path in originals)) continue;
+      const original = originals[path] ?? null;
+      delete originals[path];
+      const current = await snapshot(path);
+      if (!sameContent(path, current?.text, original)) continue;
+      if (original === null) await rm2(path, { force: true });
+      else if (current?.text !== original.text || current.mode !== original.mode) {
+        await writeFile(path, original.text);
+        await chmod(path, original.mode);
+      }
+    }
+  });
+}
+async function update(store, change) {
+  await ensureHome(dirname2(store));
+  return withLock(`${store}.lock`, async () => {
+    const saved = await readJson(store).catch(() => void 0);
+    const originals = saved && typeof saved === "object" && !Array.isArray(saved) ? { ...saved } : {};
+    const result = await change(originals);
+    await writePrivateFile(store, JSON.stringify(originals));
+    return result;
+  });
+}
+async function snapshot(path) {
+  try {
+    const [text, info] = await Promise.all([readFile2(path, "utf8"), stat(path)]);
+    return { mode: info.mode & 511, text };
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function sameContent(path, current, original) {
+  const before = original?.text ?? "";
+  const after = current ?? "";
+  if (before === after) return true;
+  if (!path.endsWith(".json")) return false;
+  const left = parse(after);
+  if (original === null)
+    return isDeepStrictEqual(left, {}) || isDeepStrictEqual(left, { version: 1 });
+  const right = parse(before);
+  return left !== void 0 && right !== void 0 && isDeepStrictEqual(left, right);
+}
+function parse(text) {
+  if (text.trim() === "") return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/agents.ts
+var AGENT_LABELS = {
+  amp: "Amp",
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor"
+};
+var ADAPTERS = {
+  amp: {
+    files: ({ env, home }) => [ampPluginPath(env, home)],
+    detect: async ({ env, home }) => await exists(join4(env.XDG_CONFIG_HOME || join4(home, ".config"), "amp")) || await onPath(["amp"], env.PATH ?? ""),
+    install: async (command, { env, home }) => ({
+      state: await installAmpPlugin(ampPluginPath(env, home), command)
+    }),
+    remove: ({ env, home }) => removeAmpPlugin(ampPluginPath(env, home))
+  },
+  "claude-code": {
+    files: (environment) => [claudeSettingsPath(environment)],
+    detect: async (environment) => await exists(claudeDirectory(environment)) || await onPath(["claude"], environment.env.PATH ?? ""),
+    install: async (command, environment) => ({
+      state: await installClaudeHook(claudeSettingsPath(environment), command)
+    }),
+    remove: (environment) => removeClaudeHook(claudeSettingsPath(environment))
+  },
+  codex: {
+    files: ({ env, home }) => Object.values(codexPaths(env, home)),
+    detect: async ({ env, home }) => await exists(codexHome(env, home)) || await onPath(["codex"], env.PATH ?? ""),
+    install: (command, { env, home }) => installCodex(codexPaths(env, home), command),
+    remove: ({ env, home }) => removeCodex(codexPaths(env, home))
+  },
+  cursor: {
+    files: ({ home }) => [cursorHooksPath(home)],
+    detect: async ({ env, home }) => await exists(join4(home, ".cursor")) || await onPath(["cursor-agent", "cursor"], env.PATH ?? ""),
+    install: async (command, { home }) => ({
+      state: await installCursorHook(cursorHooksPath(home), command)
+    }),
+    remove: ({ home }) => removeCursorHook(cursorHooksPath(home))
+  }
+};
+function claudeDirectory({ env, home }) {
+  return env.CLAUDE_CONFIG_DIR || join4(home, ".claude");
+}
+function claudeSettingsPath(environment) {
+  return join4(claudeDirectory(environment), "settings.json");
+}
+async function detectAgents(environment) {
+  const found = await Promise.all(
+    AGENT_IDS.map(
+      async (agent) => await ADAPTERS[agent].detect(environment) ? agent : void 0
+    )
+  );
+  return found.filter((agent) => agent !== void 0);
+}
+async function installAgents(agents, command, environment) {
+  const store = originalsStore(environment);
+  return Promise.all(
+    agents.map(async (agent) => {
+      let recorded = [];
+      try {
+        recorded = await rememberOriginals(store, ADAPTERS[agent].files(environment));
+        const { note, state } = await ADAPTERS[agent].install(command, environment);
+        if (state !== "installed") await forgetOriginals(store, recorded);
+        return { agent, label: AGENT_LABELS[agent], state, ...note ? { note } : {} };
+      } catch (error) {
+        await forgetOriginals(store, recorded).catch(() => void 0);
+        return failure(agent, error);
+      }
+    })
+  );
+}
+async function removeAgents(environment) {
+  const store = originalsStore(environment);
+  return Promise.all(
+    AGENT_IDS.map(async (agent) => {
+      try {
+        const state = await ADAPTERS[agent].remove(environment);
+        if (state === "removed")
+          await restoreOriginals(store, ADAPTERS[agent].files(environment)).catch(
+            () => void 0
+          );
+        return { agent, label: AGENT_LABELS[agent], state };
+      } catch (error) {
+        return failure(agent, error);
+      }
+    })
+  );
+}
+function originalsStore({ env, home }) {
+  return originalsPath(env.PATRON_HOME || join4(home, ".patron"));
+}
+function failure(agent, error) {
+  return {
+    agent,
+    detail: error.message,
+    label: AGENT_LABELS[agent],
+    state: "failed"
+  };
+}
+async function hookCommand(env = process.env, script = process.argv[1], node = process.execPath) {
+  if (env.PATRON_HOOK_COMMAND) return env.PATRON_HOOK_COMMAND;
+  const resolved = script ? await realpath(script).catch(() => void 0) : void 0;
+  if (resolved && /[/\\]bin\.js$/.test(resolved) && !/[/\\]_npx[/\\]/.test(resolved))
+    return `${quote(node)} ${quote(resolved)} hook`;
+  return "npx -y @tempoxyz/patron hook";
+}
+function quote(value) {
+  return /^[\w./:@-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
+async function exists(path) {
+  return access(path).then(
+    () => true,
+    () => false
+  );
+}
+async function onPath(commands, path) {
+  for (const directory of path.split(delimiter)) {
+    if (!directory) continue;
+    for (const command of commands) {
+      const found = await access(join4(directory, command), constants.X_OK).then(
+        () => true,
+        () => false
+      );
+      if (found) return true;
+    }
+  }
+  return false;
+}
+
+// src/gateway.ts
+var STANDING_TIMEOUT_MS = 3e3;
+function shortAddress(address) {
+  const lower = address.toLowerCase();
+  return `${lower.slice(0, 6)}\u2026${lower.slice(-4)}`;
+}
+async function fetchStanding(gatewayUrl, address, name, fetchFn = fetch, timeoutMs = STANDING_TIMEOUT_MS) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  const direct = await fetchFn(
+    new URL(`/v1/patrons/${address.toLowerCase()}`, gatewayUrl),
+    { signal }
+  ).then(
+    async (response) => response.ok ? await response.json() : void 0
+  ).catch(() => void 0);
+  const info = PatronInfo.safeParse(direct);
+  if (info.success)
+    return {
+      rank: info.data.rank,
+      tokens: info.data.tokens,
+      usd: info.data.usd,
+      ...info.data.name ? { name: info.data.name } : {}
+    };
+  const board = await fetchFn(new URL("/v1/leaderboard", gatewayUrl), { signal }).then(
+    async (response) => response.ok ? await response.json() : void 0
+  ).catch(() => void 0);
+  const parsed = LeaderboardResponse.safeParse(board);
+  if (!parsed.success) return void 0;
+  const names = /* @__PURE__ */ new Set([shortAddress(address), ...name ? [name] : []]);
+  const index = parsed.data.patrons.findIndex((patron) => names.has(patron.name));
+  const row2 = parsed.data.patrons[index];
+  if (!row2) return void 0;
+  return { name: row2.name, rank: index + 1, tokens: row2.tokens, usd: row2.usd };
+}
+async function setProfile(gatewayUrl, wallet, name, fetchFn = fetch) {
+  const signature = await wallet.signMessage(profileMessage(wallet.address, name));
+  const response = await fetchFn(new URL("/v1/profile", gatewayUrl), {
+    body: JSON.stringify({ address: wallet.address, name, signature }),
+    headers: { "content-type": "application/json" },
+    method: "POST"
+  });
+  if (!response.ok)
+    throw new Error(`Profile update failed: ${response.status} ${await response.text()}`);
+}
+
+// src/prompts.ts
+import { createInterface } from "node:readline/promises";
+
+// src/prompt-input.ts
+import { createReadStream, openSync } from "node:fs";
+import { isatty, ReadStream } from "node:tty";
+function openPromptInput() {
+  if (!process.stdin.isTTY) return { close: () => void 0, input: process.stdin };
+  try {
+    const terminalPath = process.platform === "win32" ? "CONIN$" : "/dev/tty";
+    const fd = openSync(terminalPath, "r");
+    const input = isatty(fd) ? new ReadStream(fd) : createReadStream(terminalPath, { autoClose: true, fd });
+    return { close: () => input.destroy(), input };
+  } catch {
+    return { close: () => void 0, input: process.stdin };
+  }
+}
+
+// src/terminal-style.ts
+var RESET = "\x1B[0m";
+var ANSI = {
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  purple: "\x1B[35m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m"
+};
+function supportsColor(output, requested = true) {
+  return requested && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb" && Boolean(output.isTTY);
+}
+function styleText(value, style, enabled) {
+  return enabled ? `${ANSI[style]}${value}${RESET}` : value;
+}
+
+// src/prompts.ts
+function createPrompter(output = process.stdout, color = false, input) {
+  const promptInput = input ? { close: () => void 0, input } : openPromptInput();
+  const readline = createInterface({ input: promptInput.input, output, terminal: false });
+  const lines = readline[Symbol.asyncIterator]();
+  const read = async (query) => {
+    output.write(query);
+    const next = await lines.next();
+    return next.done ? void 0 : String(next.value).trim();
+  };
+  const ask = async (question, fallback) => {
+    const answer = await read(
+      `${styleText("?", "cyan", color)} ${question} ${styleText(`[${fallback}]`, "dim", color)} `
+    );
+    if (answer === void 0) throw new Error("Cancelled.");
+    return answer === "" ? fallback : answer;
+  };
+  return {
+    ask,
+    choose: async (title, options, fallback) => {
+      output.write(`
+${styleText(title, "bold", color)}
+`);
+      options.forEach((option, index) => {
+        output.write(`  ${styleText(String(index + 1), "cyan", color)}. ${option}
+`);
+      });
+      for (; ; ) {
+        const answer = await ask("Choose", String(fallback + 1));
+        const index = Number(answer) - 1;
+        if (Number.isInteger(index) && index >= 0 && index < options.length) return index;
+        output.write(`Choose 1 to ${options.length}.
+`);
+      }
+    },
+    close: () => {
+      readline.close();
+      promptInput.close();
+    },
+    confirm: async (question, fallback) => {
+      const hint = styleText(fallback ? "[Y/n]" : "[y/N]", "dim", color);
+      for (; ; ) {
+        const answer = await read(`${styleText("?", "cyan", color)} ${question} ${hint} `);
+        if (answer === void 0) throw new Error("Cancelled.");
+        const normalized = answer.toLowerCase();
+        if (normalized === "") return fallback;
+        if (normalized === "y" || normalized === "yes") return true;
+        if (normalized === "n" || normalized === "no") return false;
+        output.write("Enter y or n.\n");
+      }
+    }
+  };
+}
+
+// src/purchase.ts
+var REFILL_LOCK_STALE_MS = 5 * 60 * 1e3;
+var defaultOpenWallet = async (settings, config, issuer, maxUnits) => {
+  const { openWallet } = await import("./wallet-3AFTEAOI.js");
+  return openWallet(settings, config.wallet, issuer, maxUnits);
+};
+async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpenWallet) {
+  const usage = await readUsage(settings.home);
+  const count = purchasableTokens(config, usage, wanted);
+  if (count === 0) return 0;
+  const issuer = await loadIssuer(settings.home, settings.gatewayUrl);
+  const wallet = await openWallet(
+    settings,
+    config,
+    issuer,
+    BigInt(count) * TOKEN_PRICE_UNITS
+  );
+  const tokens = await buyTokens({
+    count,
+    fetch: wallet.fetch,
+    gatewayUrl: settings.gatewayUrl,
+    issuer
+  });
+  await new FileTokenStore(settings.home).add(tokens);
+  await updateUsage(settings.home, (current) => {
+    current.boughtTokens += tokens.length;
+  });
+  return tokens.length;
+}
+async function refill(base, openWallet = defaultOpenWallet) {
+  const config = await readConfig(base.home);
+  if (!config || config.paused) return 0;
+  const settings = settingsFor(base, config);
+  const release = await tryLock(
+    statePaths(settings.home).refillLock,
+    REFILL_LOCK_STALE_MS
+  );
+  if (!release) return 0;
+  try {
+    if (!needsRefill(await new FileTokenStore(settings.home).count())) return 0;
+    return await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
+  } finally {
+    await release();
+  }
+}
+
+// src/render.ts
+function tokensUsd(tokens) {
+  return `$${twoDecimals(formatUsd(tokensToUnits(tokens)))}`;
+}
+function twoDecimals(usd) {
+  const [whole = "0", fraction = ""] = usd.split(".");
+  return `${whole}.${fraction.padEnd(2, "0")}`;
+}
+function row(label, value, color) {
+  return `  ${styleText(label.padEnd(13), "dim", color)}${value}`;
+}
+function formatStatus(view, color) {
+  const { config, tokensLeft, usage, standing } = view;
+  const state = config.paused ? styleText("\u25CF paused", "yellow", color) : styleText("\u25CF on", "green", color);
+  const network = config.network === "testnet" ? styleText(" \xB7 testnet", "dim", color) : "";
+  const bought = tokensUsd(usage.boughtTokens);
+  const budget = `$${twoDecimals(String(config.monthlyBudgetUsd))}`;
+  const top = Object.entries(usage.domains).sort(([, left], [, right]) => right - left).slice(0, 3).map(([domain, count]) => `${domain} ${count}`);
+  const lines = [
+    `${styleText("Patron", "bold", color)}  ${state}${network}`,
+    row(
+      "Tokens left",
+      `${tokensLeft.toLocaleString("en-US")} (${tokensUsd(tokensLeft)})`,
+      color
+    ),
+    row(
+      "Per page",
+      `$${(clampTokensPerPage(config.tokensPerPage) / 1e3).toFixed(3)}`,
+      color
+    ),
+    row("Pages paid", `${usage.paidPages.toLocaleString("en-US")} this month`, color),
+    row(
+      "Budget used",
+      `${bought} of ${budget} this month (${budgetTokens(config.monthlyBudgetUsd) > 0 ? Math.min(100, Math.round(usage.boughtTokens / budgetTokens(config.monthlyBudgetUsd) * 100)) : 0}%)`,
+      color
+    ),
+    row(
+      "Rank",
+      standing?.rank ? `#${standing.rank} \xB7 ${standing.tokens.toLocaleString("en-US")} tokens bought` : styleText("not ranked yet", "dim", color),
+      color
+    ),
+    row(
+      "Agents",
+      config.agents.length > 0 ? config.agents.map((agent) => AGENT_LABELS[agent]).join(", ") : styleText("none", "dim", color),
+      color
+    )
+  ];
+  if (top.length > 0) lines.push(row("Top sites", top.join(" \xB7 "), color));
+  return lines.join("\n");
+}
+function formatAgentResults(results, color) {
+  return results.map((result) => {
+    const [glyph, style, text] = result.state === "failed" ? ["\u2717", "red", `hook not installed: ${result.detail ?? "unknown error"}`] : result.state === "removed" ? ["\u2713", "green", "hook removed"] : result.state === "missing" ? ["\xB7", "dim", "no hook to remove"] : result.state === "unchanged" ? ["\u2713", "green", "hook already installed"] : ["\u2713", "green", "hook installed"];
+    const note = result.note ? styleText(` (${result.note})`, "dim", color) : "";
+    return `  ${styleText(glyph, style, color)} ${result.label} ${text}${note}`;
+  });
+}
+
+// src/index.ts
+var VERSION = readVersion();
+var HELP = `patron@${VERSION} \u2014 pay the websites your agents read, privately
+
+Usage: patron [command]
+
+  (none)            Set up, or show status and options
+  status            Tokens left, pages paid, budget and rank
+  pause | resume    Stop or restart paying
+  budget <usd>      Change the monthly budget
+  per-page <usd>    What each site gets per page read, $0.001 to $0.01
+  tip <url> [usd]   Tip a site (default $0.10)
+  name <handle>     Set your public leaderboard name
+  uninstall         Remove agent hooks
+  hook              Run by agents after each web read (reads the event JSON)
+
+Environment: PATRON_HOME, PATRON_GATEWAY_URL, PATRON_RELAY_URL, PATRON_NETWORK,
+PATRON_PRIVATE_KEY (testnet automation), PATRON_BUDGET_USD (non-interactive setup).`;
+var UsageError = class extends Error {
+};
+function defaults() {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const color = supportsColor(process.stdout);
+  return {
+    agents: { env: process.env, home: homedir() },
+    color,
+    fetch: globalThis.fetch,
+    interactive,
+    prompter: () => createPrompter(process.stdout, color),
+    settings: resolveSettings(),
+    stderr: process.stderr,
+    startRefill: () => startRefill(),
+    stdout: process.stdout
+  };
+}
+async function run(argv, overrides = {}) {
+  const base = { ...defaults(), ...overrides };
+  let shared;
+  const deps = {
+    ...base,
+    prompter: () => {
+      shared ??= base.prompter();
+      return { ...shared, close: () => void 0 };
+    }
+  };
+  const [command, ...args] = argv;
+  try {
+    switch (command) {
+      case void 0:
+        await main(deps);
+        return 0;
+      case "status":
+        await status(deps, false);
+        return 0;
+      case "pause":
+      case "resume":
+        await setPaused(deps, command === "pause");
+        return 0;
+      case "budget":
+        await changeBudget(deps, args[0]);
+        return 0;
+      case "per-page":
+        await changePerPage(deps, args[0]);
+        return 0;
+      case "tip":
+        await tip(deps, args[0], args[1]);
+        return 0;
+      case "name":
+        await setName(deps, args[0]);
+        return 0;
+      case "uninstall":
+        await uninstall(deps);
+        return 0;
+      case "refill":
+        await refill(deps.settings, deps.openWallet).catch(() => 0);
+        return 0;
+      case "help":
+      case "--help":
+      case "-h":
+        deps.stdout.write(`${HELP}
+`);
+        return 0;
+      case "--version":
+      case "-v":
+        deps.stdout.write(`${VERSION}
+`);
+        return 0;
+      default:
+        throw new UsageError(`Unknown command: ${command}
+
+${HELP}`);
+    }
+  } catch (error) {
+    deps.stderr.write(
+      `${styleText("\u2717", "red", deps.color)} ${error.message}
+`
+    );
+    return error instanceof UsageError ? 2 : 1;
+  } finally {
+    shared?.close();
+  }
+}
+async function loadSetup(deps) {
+  const config = await readConfig(deps.settings.home);
+  if (!config) throw new Error("Patron is not set up. Run npx @tempoxyz/patron.");
+  return { config, settings: settingsFor(deps.settings, config) };
+}
+function say(deps, line = "") {
+  deps.stdout.write(`${line}
+`);
+}
+function step(deps, message) {
+  say(deps, `${styleText("\u2192", "cyan", deps.color)} ${message}`);
+}
+function done(deps, message) {
+  say(deps, `${styleText("\u2713", "green", deps.color)} ${message}`);
+}
+async function main(deps) {
+  const config = await readConfig(deps.settings.home);
+  if (!config) return setup(deps);
+  await syncAgents(deps, config);
+  await status(deps, deps.interactive);
+}
+async function syncAgents(deps, config) {
+  const added = (await detectAgents(deps.agents)).filter(
+    (agent) => !config.agents.includes(agent)
+  );
+  if (added.length === 0) return;
+  const results = await installAgents(
+    added,
+    await hookCommand(deps.agents.env),
+    deps.agents
+  );
+  for (const line of formatAgentResults(results, deps.color)) say(deps, line);
+  say(deps);
+  const installed = results.filter((result) => result.state !== "failed").map((result) => result.agent);
+  if (installed.length > 0)
+    await writeConfig(deps.settings.home, {
+      ...config,
+      agents: [...config.agents, ...installed]
+    });
+}
+async function setup(deps) {
+  const settings = deps.settings;
+  say(deps, styleText(`Patron v${VERSION}`, "bold", deps.color));
+  say(
+    deps,
+    styleText(
+      "Pay every site your agents read, $0.001 a page, privately.",
+      "dim",
+      deps.color
+    )
+  );
+  say(deps);
+  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
+    fetch: deps.fetch,
+    fresh: true
+  }).catch((error) => {
+    throw new Error(`Cannot reach Patron at ${settings.gatewayUrl}: ${error.message}`);
+  });
+  const budget = await askBudget(deps, DEFAULT_MONTHLY_BUDGET_USD);
+  const budgetUnits = BigInt(budgetTokens(budget)) * TOKEN_PRICE_UNITS;
+  step(
+    deps,
+    settings.privateKey ? "Using PATRON_PRIVATE_KEY" : "Signing in with Tempo Wallet"
+  );
+  const { signIn } = await import("./wallet-3AFTEAOI.js");
+  const account = await signIn(settings, { budgetUnits, issuer, output: deps.stdout });
+  done(deps, `Signed in as ${account.address}`);
+  const config = {
+    address: account.address,
+    agents: [],
+    gatewayUrl: settings.gatewayUrl,
+    monthlyBudgetUsd: budget,
+    network: settings.network,
+    paused: false,
+    relayUrl: settings.relayUrl,
+    version: 1,
+    wallet: account.wallet
+  };
+  await writeConfig(settings.home, config);
+  const first = purchasableTokens(config, await readUsage(settings.home), STARTER_TOKENS);
+  step(deps, `Buying ${first.toLocaleString("en-US")} tokens (${tokensUsd(first)})`);
+  const bought = await buyWithinBudget(settings, config, STARTER_TOKENS, deps.openWallet);
+  done(deps, `${bought.toLocaleString("en-US")} tokens ready`);
+  deps.startRefill();
+  const agents = await detectAgents(deps.agents);
+  if (agents.length === 0) {
+    say(deps);
+    say(
+      deps,
+      "No supported agent found. Install Claude Code, Codex, Cursor or Amp, then run npx @tempoxyz/patron again."
+    );
+    return;
+  }
+  const results = await installAgents(
+    agents,
+    await hookCommand(deps.agents.env),
+    deps.agents
+  );
+  for (const line of formatAgentResults(results, deps.color)) say(deps, line);
+  config.agents = results.filter((result) => result.state !== "failed").map((r) => r.agent);
+  await writeConfig(settings.home, config);
+  say(deps);
+  say(
+    deps,
+    styleText("\u2713 Patron on. Agents now pay the sites they read.", "green", deps.color)
+  );
+}
+async function askBudget(deps, fallback) {
+  const preset = process.env.PATRON_BUDGET_USD;
+  if (!deps.interactive) {
+    const value = preset ? parseUsd(preset) : fallback;
+    if (value === void 0 || value <= 0)
+      throw new UsageError("PATRON_BUDGET_USD must be a positive amount.");
+    return value;
+  }
+  const prompter = deps.prompter();
+  try {
+    for (; ; ) {
+      const answer = await prompter.ask("Monthly budget in USD", `$${fallback}`);
+      const value = parseUsd(answer);
+      if (value !== void 0 && value >= 1e-3) return value;
+      say(deps, "Enter an amount such as 5 or 2.50.");
+    }
+  } finally {
+    prompter.close();
+  }
+}
+async function status(deps, menu) {
+  const { config, settings } = await loadSetup(deps);
+  const [tokensLeft, usage, standing] = await Promise.all([
+    new FileTokenStore(settings.home).count(),
+    readUsage(settings.home),
+    fetchStanding(settings.gatewayUrl, config.address, config.name, deps.fetch).catch(
+      () => void 0
+    )
+  ]);
+  say(deps, formatStatus({ config, standing, tokensLeft, usage }, deps.color));
+  if (!menu) return;
+  const prompter = deps.prompter();
+  let choice;
+  try {
+    choice = await prompter.choose(
+      "Options",
+      [
+        config.paused ? "Resume" : "Pause",
+        "Change budget",
+        "Change per-page amount",
+        "Uninstall",
+        "Done"
+      ],
+      4
+    );
+  } finally {
+    prompter.close();
+  }
+  if (choice === 0) await setPaused(deps, !config.paused);
+  if (choice === 1) await changeBudget(deps, void 0);
+  if (choice === 2) await changePerPage(deps, void 0);
+  if (choice === 3) await uninstall(deps);
+}
+async function setPaused(deps, paused) {
+  const { config, settings } = await loadSetup(deps);
+  await writeConfig(settings.home, { ...config, paused });
+  done(
+    deps,
+    paused ? "Patron paused. Agents read without paying." : "Patron on. Agents pay the sites they read."
+  );
+}
+async function changeBudget(deps, input) {
+  const { config, settings } = await loadSetup(deps);
+  let budget;
+  if (input !== void 0) {
+    budget = parseUsd(input);
+    if (budget === void 0 || budget < 1e-3)
+      throw new UsageError("Usage: patron budget <usd>, such as patron budget 10");
+  } else budget = await askBudget(deps, config.monthlyBudgetUsd);
+  if (config.wallet === "tempo" && budget > config.monthlyBudgetUsd) {
+    step(deps, "Approve the new spending limit in Tempo Wallet");
+    const { authorizeBudget } = await import("./wallet-3AFTEAOI.js");
+    const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
+      fetch: deps.fetch
+    });
+    await authorizeBudget(settings, {
+      budgetUnits: BigInt(budgetTokens(budget)) * TOKEN_PRICE_UNITS,
+      issuer,
+      output: deps.stdout
+    });
+  }
+  await writeConfig(settings.home, { ...config, monthlyBudgetUsd: budget });
+  done(deps, `Monthly budget set to $${twoDecimals(String(budget))}.`);
+}
+async function changePerPage(deps, input) {
+  const { config, settings } = await loadSetup(deps);
+  const min = (MIN_TOKENS_PER_PAGE / 1e3).toFixed(3);
+  const max = (MAX_TOKENS_PER_PAGE / 1e3).toFixed(3);
+  let answer = input;
+  if (answer === void 0) {
+    const prompter = deps.prompter();
+    try {
+      answer = await prompter.ask(
+        `Per page in USD ($${min} to $${max})`,
+        `$${(clampTokensPerPage(config.tokensPerPage) / 1e3).toFixed(3)}`
+      );
+    } finally {
+      prompter.close();
+    }
+  }
+  const usd = parseUsd(answer);
+  const tokens = usd === void 0 ? NaN : Math.round(usd * 1e3);
+  if (usd === void 0 || Math.abs(usd * 1e3 - tokens) > 1e-9 || tokens < MIN_TOKENS_PER_PAGE || tokens > MAX_TOKENS_PER_PAGE)
+    throw new UsageError(
+      `Usage: patron per-page <usd>, $${min} to $${max} in steps of $0.001, such as patron per-page 0.005`
+    );
+  await writeConfig(settings.home, { ...config, tokensPerPage: tokens });
+  done(deps, `Each site now gets $${(tokens / 1e3).toFixed(3)} per page.`);
+}
+async function tip(deps, url, amount = "0.10") {
+  const domain = url ? normalizeDomain(url) : null;
+  const usd = parseUsd(amount);
+  if (!domain || usd === void 0) throw new UsageError("Usage: patron tip <url> [usd]");
+  const count = tipTokens(usd);
+  if (count < 1) throw new UsageError("The smallest tip is $0.001.");
+  const { config, settings } = await loadSetup(deps);
+  const store = new FileTokenStore(settings.home);
+  const missing = count - await store.count();
+  if (missing > 0) {
+    const usage = await readUsage(settings.home);
+    if (purchasableTokens(config, usage, missing) < missing)
+      throw new Error(
+        `This tip needs ${tokensUsd(missing)} more than this month's budget allows. Raise it with patron budget <usd>.`
+      );
+    step(deps, `Buying ${missing.toLocaleString("en-US")} tokens (${tokensUsd(missing)})`);
+    await buyWithinBudget(settings, config, missing, deps.openWallet);
+  }
+  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
+    fetch: deps.fetch
+  });
+  const tokens = await store.takeMany(count);
+  let paid = 0;
+  let rejection;
+  const unsent = [];
+  for (let index = 0; index < tokens.length; index += 8) {
+    const batch = tokens.slice(index, index + 8);
+    const results = await Promise.all(
+      batch.map(
+        (token) => redeem({
+          domain,
+          fetch: deps.fetch,
+          issuer,
+          relayUrl: settings.relayUrl,
+          token
+        }).catch(() => {
+          unsent.push(token);
+          return void 0;
+        })
+      )
+    );
+    for (const result of results) {
+      if (result?.ok) paid += 1;
+      else if (result) rejection = result.error ?? "rejected";
+    }
+  }
+  await store.add(unsent);
+  if (paid > 0)
+    await updateUsage(settings.home, (usage) => {
+      usage.domains[domain] = (usage.domains[domain] ?? 0) + paid;
+    });
+  if (paid === 0)
+    throw new Error(
+      rejection ? `Patron rejected the tip to ${domain}: ${rejection}.` : `Could not reach Patron to tip ${domain}; your tokens were kept.`
+    );
+  if (paid < count)
+    say(
+      deps,
+      styleText(
+        `  ${count - paid} of ${count} tokens did not go through.`,
+        "yellow",
+        deps.color
+      )
+    );
+  done(deps, `Tipped ${domain} ${tokensUsd(paid)}.`);
+}
+async function setName(deps, name) {
+  if (!name || !/^[\p{L}\p{N}_.-]{1,32}$/u.test(name))
+    throw new UsageError("Usage: patron name <handle> (1 to 32 letters, digits, _ . -)");
+  const { config, settings } = await loadSetup(deps);
+  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
+    fetch: deps.fetch
+  });
+  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-3AFTEAOI.js")).openWallet(s, c.wallet, i, max));
+  const wallet = await open(settings, config, issuer, 0n);
+  await setProfile(settings.gatewayUrl, wallet, name, deps.fetch);
+  await writeConfig(settings.home, { ...config, name });
+  done(deps, `Leaderboard name set to ${name}.`);
+}
+async function uninstall(deps) {
+  const config = await readConfig(deps.settings.home);
+  const results = (await removeAgents(deps.agents)).filter(
+    (result) => result.state !== "missing"
+  );
+  say(deps, styleText("Patron uninstall", "bold", deps.color));
+  for (const line of formatAgentResults(results, deps.color)) say(deps, line);
+  if (results.length === 0)
+    say(deps, styleText("  \xB7 No agent hooks to remove", "dim", deps.color));
+  if (!config) return;
+  await writeConfig(deps.settings.home, { ...config, agents: [] });
+  const tokensLeft = await new FileTokenStore(deps.settings.home).count().catch(() => 0);
+  let purge = false;
+  if (deps.interactive) {
+    const prompter = deps.prompter();
+    try {
+      purge = await prompter.confirm(
+        `Also delete ${deps.settings.home}${tokensLeft > 0 ? ` and ${tokensLeft} unspent tokens (${tokensUsd(tokensLeft)})` : ""}?`,
+        false
+      );
+    } finally {
+      prompter.close();
+    }
+  }
+  if (purge) {
+    await rm3(deps.settings.home, { force: true, recursive: true });
+    done(deps, "Local data deleted.");
+  } else
+    say(
+      deps,
+      styleText(
+        `  Kept ${deps.settings.home}; run npx @tempoxyz/patron to turn Patron back on.`,
+        "dim",
+        deps.color
+      )
+    );
+}
+function readVersion() {
+  for (const path of ["../package.json", "../../package.json"]) {
+    try {
+      const metadata = JSON.parse(
+        readFileSync(new URL(path, import.meta.url), "utf8")
+      );
+      if (metadata.name === "@tempoxyz/patron" && metadata.version)
+        return metadata.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+export {
+  run
+};