@tempoxyz/patron 0.0.20 → 0.0.22

package/README.md

@@ -50,7 +50,9 @@ and the site's domain through an Oblivious HTTP relay (RFC 9458): the relay sees
 not the content; the gateway sees the content but not your IP.
 
 Local state lives in `~/.patron`: settings, seals encrypted with AES-256-GCM under a key
-file readable only by you, and this month's per-site counts, which never leave the machine.
+file readable only by you, this month's per-site counts, which never leave the machine, and
+a copy of the CLI in `~/.patron/cli` that agent hooks start with node, so a read never waits
+on npx. Running `npx @tempoxyz/patron` updates the copy.
 
 ## Budget
 

package/dist/bin.js

@@ -4,14 +4,14 @@ const require = __patronCreateRequire(import.meta.url)
 
 // src/bin.ts
 if (process.argv[2] === "hook") {
-  const { runHookProcess } = await import("./chunks/hook-process-Y2W56T2X.js");
+  const { runHookProcess } = await import("./chunks/hook-process-D5ENJPRB.js");
   await runHookProcess().catch(() => void 0);
   process.exit(0);
 } else if (process.argv[2] === "pay") {
-  const { runPayProcess } = await import("./chunks/hook-process-Y2W56T2X.js");
+  const { runPayProcess } = await import("./chunks/hook-process-D5ENJPRB.js");
   await runPayProcess().catch(() => void 0);
   process.exit(0);
 } else {
-  const { run } = await import("./chunks/-RNUFDXSV.js");
+  const { run } = await import("./chunks/-PMO5HHO2.js");
   process.exitCode = await run(process.argv.slice(2));
 }

package/dist/chunks/{-RNUFDXSV.js → -PMO5HHO2.js}

@@ -2,6 +2,7 @@ import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 import {
   FileTokenStore,
+  LINK_TOKEN_STEP,
   LeaderboardResponse,
   PatronInfo,
   STARTER_TOKENS,
@@ -28,10 +29,10 @@ import {
   withPatronStatus,
   withoutPatronHandlers,
   writeJsonObject
-} from "./chunk-UFBFF3R6.js";
+} from "./chunk-QKBTYUXG.js";
 import {
   startRefill
-} from "./chunk-CV2WYKM7.js";
+} from "./chunk-HEQBEBKL.js";
 import {
   DEFAULT_MONTHLY_BUDGET_USD,
   MAX_TOKENS_PER_PAGE,
@@ -57,18 +58,19 @@ import {
   withLock,
   writeConfig,
   writePrivateFile
-} from "./chunk-RDEPJ6XD.js";
+} from "./chunk-UWIBR62N.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/index.ts
 import { readFileSync } from "node:fs";
-import { rm as rm3 } from "node:fs/promises";
-import { homedir } from "node:os";
+import { rm as rm5 } from "node:fs/promises";
+import { homedir as homedir2 } 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";
+import { access as access2, realpath as realpath2 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { delimiter, join as join5 } from "node:path";
 
 // src/amp.ts
 import { mkdir, readFile, rm } from "node:fs/promises";
@@ -322,6 +324,66 @@ function parse(text) {
   }
 }
 
+// src/stable-install.ts
+import {
+  access,
+  cp,
+  mkdir as mkdir2,
+  readdir,
+  readFile as readFile3,
+  readlink,
+  realpath,
+  rename,
+  rm as rm3,
+  symlink
+} from "node:fs/promises";
+import { basename, dirname as dirname3, join as join4 } from "node:path";
+function stableBin(home) {
+  return join4(home, "cli", "current", "dist", "bin.js");
+}
+async function installStableCli(home, script = process.argv[1]) {
+  const resolved = script ? await realpath(script).catch(() => void 0) : void 0;
+  if (!resolved || !/[/\\]_npx[/\\]/.test(resolved) || basename(resolved) !== "bin.js")
+    return void 0;
+  const packageDir = dirname3(dirname3(resolved));
+  const { version } = JSON.parse(await readFile3(join4(packageDir, "package.json"), "utf8"));
+  if (typeof version !== "string" || !/^[\w.+-]+$/.test(version)) return void 0;
+  const root = join4(home, "cli");
+  const target = join4(root, version);
+  await mkdir2(root, { recursive: true, mode: 448 });
+  if (!await isFile(join4(target, "dist", "bin.js"))) {
+    const staging = `${target}.${process.pid}.tmp`;
+    await rm3(staging, { force: true, recursive: true });
+    await cp(join4(packageDir, "dist"), join4(staging, "dist"), { recursive: true });
+    await cp(join4(packageDir, "package.json"), join4(staging, "package.json"));
+    await rm3(target, { force: true, recursive: true });
+    await rename(staging, target);
+  }
+  const current = join4(root, "current");
+  const linked = await readlink(current).catch(() => void 0);
+  const previous = linked ? basename(linked) : void 0;
+  if (previous !== version) {
+    const link = `${current}.${process.pid}.tmp`;
+    await rm3(link, { force: true });
+    await symlink(process.platform === "win32" ? target : version, link, "junction");
+    await rename(link, current).catch(async () => {
+      await rm3(current, { force: true, recursive: true });
+      await rename(link, current);
+    });
+  }
+  for (const entry of await readdir(root)) {
+    if (entry === "current" || entry === version || entry === previous) continue;
+    await rm3(join4(root, entry), { force: true, recursive: true });
+  }
+  return stableBin(home);
+}
+async function isFile(path) {
+  return access(path).then(
+    () => true,
+    () => false
+  );
+}
+
 // src/agents.ts
 var AGENT_LABELS = {
   amp: "Amp",
@@ -332,7 +394,7 @@ var AGENT_LABELS = {
 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 ?? ""),
+    detect: async ({ env, home }) => await exists(join5(env.XDG_CONFIG_HOME || join5(home, ".config"), "amp")) || await onPath(["amp"], env.PATH ?? ""),
     install: async (command, { env, home }) => ({
       state: await installAmpPlugin(ampPluginPath(env, home), command)
     }),
@@ -357,7 +419,7 @@ var ADAPTERS = {
   },
   cursor: {
     files: ({ home }) => [cursorHooksPath(home)],
-    detect: async ({ env, home }) => await exists(join4(home, ".cursor")) || await onPath(["cursor-agent", "cursor"], env.PATH ?? ""),
+    detect: async ({ env, home }) => await exists(join5(home, ".cursor")) || await onPath(["cursor-agent", "cursor"], env.PATH ?? ""),
     install: async (command, { home }) => ({
       state: await installCursorHook(cursorHooksPath(home), command)
     }),
@@ -365,10 +427,10 @@ var ADAPTERS = {
   }
 };
 function claudeDirectory({ env, home }) {
-  return env.CLAUDE_CONFIG_DIR || join4(home, ".claude");
+  return env.CLAUDE_CONFIG_DIR || join5(home, ".claude");
 }
 function claudeSettingsPath(environment) {
-  return join4(claudeDirectory(environment), "settings.json");
+  return join5(claudeDirectory(environment), "settings.json");
 }
 async function detectAgents(environment) {
   const found = await Promise.all(
@@ -421,7 +483,7 @@ async function removeAgents(environment) {
   );
 }
 function originalsStore({ env, home }) {
-  return originalsPath(env.PATRON_HOME || join4(home, ".patron"));
+  return originalsPath(env.PATRON_HOME || join5(home, ".patron"));
 }
 function failure(agent, error) {
   return {
@@ -431,18 +493,20 @@ function failure(agent, error) {
     state: "failed"
   };
 }
-async function hookCommand(env = process.env, script = process.argv[1], node = process.execPath) {
+async function hookCommand(env = process.env, script = process.argv[1], node = process.execPath, patronHome = env.PATRON_HOME || join5(homedir(), ".patron")) {
   if (env.PATRON_HOOK_COMMAND) return env.PATRON_HOOK_COMMAND;
-  const resolved = script ? await realpath(script).catch(() => void 0) : void 0;
+  const resolved = script ? await realpath2(script).catch(() => void 0) : void 0;
   if (resolved && /[/\\]bin\.js$/.test(resolved) && !/[/\\]_npx[/\\]/.test(resolved))
     return `${quote(node)} ${quote(resolved)} hook`;
+  if (await exists(stableBin(patronHome)))
+    return `${quote(node)} ${quote(stableBin(patronHome))} 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(
+  return access2(path).then(
     () => true,
     () => false
   );
@@ -451,7 +515,7 @@ 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(
+      const found = await access2(join5(directory, command), constants.X_OK).then(
         () => true,
         () => false
       );
@@ -617,9 +681,19 @@ ${styleText(title, "bold", color)}
 }
 
 // src/purchase.ts
+import { rm as rm4 } from "node:fs/promises";
+var LINK_REFILL_BACKOFF_MS = 60 * 60 * 1e3;
+async function linkRefillFailedAt(home) {
+  const value = await readJson(statePaths(home).linkRefill).catch(() => void 0);
+  return typeof value?.failedAt === "number" ? value.failedAt : void 0;
+}
 var REFILL_LOCK_STALE_MS = 5 * 60 * 1e3;
 var defaultOpenWallet = async (settings, config, issuer, maxUnits) => {
-  const { openWallet } = await import("./wallet-WNPT6R4M.js");
+  if (config.wallet === "link") {
+    const { openLinkWallet } = await import("./wallet-R3UWBXVC.js");
+    return openLinkWallet(config, maxUnits);
+  }
+  const { openWallet } = await import("./wallet-R3UWBXVC.js");
   return openWallet(settings, config.wallet, issuer, maxUnits);
 };
 async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpenWallet) {
@@ -645,7 +719,7 @@ async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpe
   });
   return tokens.length;
 }
-async function refill(base, openWallet = defaultOpenWallet) {
+async function refill(base, openWallet = defaultOpenWallet, now = Date.now) {
   const config = await readConfig(base.home);
   if (!config || config.paused) return 0;
   const settings = settingsFor(base, config);
@@ -656,7 +730,19 @@ async function refill(base, openWallet = defaultOpenWallet) {
   if (!release) return 0;
   try {
     if (!needsRefill(await new FileTokenStore(settings.home).count())) return 0;
-    return await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
+    if (config.wallet !== "link")
+      return await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
+    const failedAt = await linkRefillFailedAt(settings.home);
+    if (failedAt !== void 0 && now() - failedAt < LINK_REFILL_BACKOFF_MS) return 0;
+    const path = statePaths(settings.home).linkRefill;
+    try {
+      const bought = await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
+      await rm4(path, { force: true });
+      return bought;
+    } catch (error) {
+      await writePrivateFile(path, JSON.stringify({ failedAt: now() }));
+      throw error;
+    }
   } finally {
     await release();
   }
@@ -709,6 +795,18 @@ function formatStatus(view, color) {
       color
     )
   ];
+  if (view.linkRefillFailedAt !== void 0)
+    lines.push(
+      row(
+        "Refill",
+        styleText(
+          "last Link refill was not approved; approve the next one in the Link app (tries again after an hour)",
+          "yellow",
+          color
+        ),
+        color
+      )
+    );
   if (top.length > 0) lines.push(row("Top sites", top.join(" \xB7 "), color));
   return lines.join("\n");
 }
@@ -737,14 +835,15 @@ Usage: patron [command]
   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).`;
+PATRON_PRIVATE_KEY (testnet automation), PATRON_BUDGET_USD (non-interactive setup),
+PATRON_WALLET=link (pay with Link through link-cli), PATRON_LINK_CLI (its path).`;
 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() },
+    agents: { env: process.env, home: homedir2() },
     color,
     fetch: globalThis.fetch,
     interactive,
@@ -848,6 +947,18 @@ async function main(deps) {
   await status(deps, deps.interactive);
 }
 async function syncAgents(deps, config) {
+  await installStableCli(deps.settings.home).catch(() => void 0);
+  const command = await hookCommand(deps.agents.env);
+  const moved = (await installAgents(config.agents, command, deps.agents)).filter((result) => result.state === "installed").map((result) => result.agent);
+  if (moved.length > 0) {
+    say(
+      deps,
+      `Patron now starts with node for ${moved.map((a) => AGENT_LABELS[a]).join(", ")}.`
+    );
+    if (moved.includes("codex"))
+      say(deps, "  Codex: trust the hook again in /hooks when it asks.");
+    say(deps);
+  }
   const upgraded = await upgradeAgents(config.agents, deps.agents);
   if (upgraded.length > 0) {
     const names = upgraded.map((agent) => AGENT_LABELS[agent]).join(", ");
@@ -860,11 +971,7 @@ async function syncAgents(deps, config) {
     (agent) => !config.agents.includes(agent)
   );
   if (added.length === 0) return;
-  const results = await installAgents(
-    added,
-    await hookCommand(deps.agents.env),
-    deps.agents
-  );
+  const results = await installAgents(added, command, 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);
@@ -886,14 +993,12 @@ async function setup(deps) {
   });
   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-WNPT6R4M.js");
-  const account = await signIn(settings, { budgetUnits, issuer, output: deps.stdout });
-  done(deps, `Signed in as ${account.address}`);
+  const payWithLink = await askPayWithLink(deps);
+  if (payWithLink && budgetTokens(budget) < LINK_TOKEN_STEP)
+    throw new UsageError("Paying with Link needs a monthly budget of at least $0.01.");
+  const account = payWithLink ? await linkSignIn(deps) : await tempoSignIn(deps, budgetUnits, issuer);
   const config = {
+    ...account.linkPaymentMethodId ? { linkPaymentMethodId: account.linkPaymentMethodId } : {},
     address: account.address,
     agents: [],
     gatewayUrl: settings.gatewayUrl,
@@ -905,11 +1010,13 @@ async function setup(deps) {
     wallet: account.wallet
   };
   await writeConfig(settings.home, config);
-  const first = purchasableTokens(config, await readUsage(settings.home), STARTER_TOKENS);
+  const starter = config.wallet === "link" ? PACK_SIZE : STARTER_TOKENS;
+  const first = purchasableTokens(config, await readUsage(settings.home), starter);
   step(deps, `Buying ${first.toLocaleString("en-US")} seals (${tokensUsd(first)})`);
-  const bought = await buyWithinBudget(settings, config, STARTER_TOKENS, deps.openWallet);
+  const bought = await buyWithinBudget(settings, config, starter, deps.openWallet);
   done(deps, `${bought.toLocaleString("en-US")} seals ready`);
   deps.startRefill();
+  await installStableCli(settings.home).catch(() => void 0);
   const agents = await detectAgents(deps.agents);
   if (agents.length === 0) {
     say(deps);
@@ -933,6 +1040,64 @@ async function setup(deps) {
     styleText("\u2713 Patron on. Agents now pay the sites they read.", "green", deps.color)
   );
 }
+async function askPayWithLink(deps) {
+  if (deps.settings.privateKey) return false;
+  const preset = process.env.PATRON_WALLET;
+  if (preset) return preset === "link";
+  if (!deps.interactive) return false;
+  const prompter = deps.prompter();
+  try {
+    const choice = await prompter.choose(
+      "Pay with",
+      ["Tempo Wallet", "Link (your Link balance or a card, via link-cli)"],
+      0
+    );
+    return choice === 1;
+  } finally {
+    prompter.close();
+  }
+}
+async function tempoSignIn(deps, budgetUnits, issuer) {
+  step(
+    deps,
+    deps.settings.privateKey ? "Using PATRON_PRIVATE_KEY" : "Signing in with Tempo Wallet"
+  );
+  const { signIn } = await import("./wallet-R3UWBXVC.js");
+  const account = await signIn(deps.settings, {
+    budgetUnits,
+    issuer,
+    output: deps.stdout
+  });
+  done(deps, `Signed in as ${account.address}`);
+  return account;
+}
+async function linkSignIn(deps) {
+  step(deps, "Checking your Link wallet (link-cli)");
+  const { linkBalance, linkCli, linkPaymentMethods } = await import("./link-OU7W7IT6.js");
+  const cli = deps.linkCli ?? linkCli();
+  const methods = await linkPaymentMethods(cli).catch((error) => {
+    throw new Error(
+      `${error.message}
+Patron pays with Link through Stripe's Link CLI: npm i -g @stripe/link-cli, then link-cli auth login.`
+    );
+  });
+  const balance = linkBalance(methods);
+  if (balance) {
+    const available = balance.balance_details?.available_balance;
+    done(
+      deps,
+      `Paying with your Link balance${available ? ` ($${(available.amount / 100).toFixed(2)} available)` : ""}`
+    );
+    return { address: "", linkPaymentMethodId: balance.id, wallet: "link" };
+  }
+  const fallback = methods.find((method) => method.is_default) ?? methods[0];
+  if (!fallback)
+    throw new Error(
+      "Your Link wallet has no payment method. Add one at https://app.link.com."
+    );
+  done(deps, `Paying with Link: ${fallback.name}`);
+  return { address: "", linkPaymentMethodId: fallback.id, wallet: "link" };
+}
 async function askBudget(deps, fallback) {
   const preset = process.env.PATRON_BUDGET_USD;
   if (!deps.interactive) {
@@ -955,14 +1120,21 @@ async function askBudget(deps, fallback) {
 }
 async function status(deps, menu) {
   const { config, settings } = await loadSetup(deps);
-  const [tokensLeft, usage, standing] = await Promise.all([
+  const [tokensLeft, usage, standing, refillFailedAt] = await Promise.all([
     new FileTokenStore(settings.home).count(),
     readUsage(settings.home),
-    fetchStanding(settings.gatewayUrl, config.address, config.name, deps.fetch).catch(
+    config.address ? fetchStanding(settings.gatewayUrl, config.address, config.name, deps.fetch).catch(
       () => void 0
-    )
+    ) : void 0,
+    config.wallet === "link" ? linkRefillFailedAt(settings.home) : void 0
   ]);
-  say(deps, formatStatus({ config, standing, tokensLeft, usage }, deps.color));
+  say(
+    deps,
+    formatStatus(
+      { config, linkRefillFailedAt: refillFailedAt, standing, tokensLeft, usage },
+      deps.color
+    )
+  );
   if (!menu) return;
   const prompter = deps.prompter();
   let choice;
@@ -1004,7 +1176,7 @@ async function changeBudget(deps, input) {
   } 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-WNPT6R4M.js");
+    const { authorizeBudget } = await import("./wallet-R3UWBXVC.js");
     const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
       fetch: deps.fetch
     });
@@ -1113,10 +1285,14 @@ 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);
+  if (config.wallet === "link")
+    throw new UsageError(
+      "Leaderboard names belong to Tempo addresses; Link purchases are not ranked."
+    );
   const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
     fetch: deps.fetch
   });
-  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-WNPT6R4M.js")).openWallet(s, c.wallet, i, max));
+  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-R3UWBXVC.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 });
@@ -1147,7 +1323,7 @@ async function uninstall(deps) {
     }
   }
   if (purge) {
-    await rm3(deps.settings.home, { force: true, recursive: true });
+    await rm5(deps.settings.home, { force: true, recursive: true });
     done(deps, "Local data deleted.");
   } else
     say(

package/dist/chunks/{chunk-CV2WYKM7.js → chunk-HEQBEBKL.js}

@@ -3,10 +3,12 @@ const require = __patronCreateRequire(import.meta.url)
 
 // src/refill-process.ts
 import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
 function startRefill(script = process.argv[1]) {
   try {
     if (!script) return;
-    const child = spawn(process.execPath, [...process.execArgv, script, "refill"], {
+    const [command, args] = refillCommand(script);
+    const child = spawn(command, args, {
       detached: true,
       env: process.env,
       stdio: "ignore"
@@ -16,6 +18,17 @@ function startRefill(script = process.argv[1]) {
   } catch {
   }
 }
+function refillCommand(script) {
+  try {
+    createRequire(script).resolve("mppx");
+    return [process.execPath, [...process.execArgv, script, "refill"]];
+  } catch {
+    return [
+      process.platform === "win32" ? "npx.cmd" : "npx",
+      ["-y", "@tempoxyz/patron", "refill"]
+    ];
+  }
+}
 function startPayment(payload, script = process.argv[1]) {
   return new Promise((resolve) => {
     try {

package/dist/chunks/{chunk-UFBFF3R6.js → chunk-QKBTYUXG.js}

@@ -15,7 +15,7 @@ import {
   statePaths,
   withLock,
   writePrivateFile
-} from "./chunk-RDEPJ6XD.js";
+} from "./chunk-UWIBR62N.js";
 import {
   __commonJS,
   __export,
@@ -34839,6 +34839,7 @@ async function redeem(options) {
 }
 
 // src/budget.ts
+var LINK_TOKEN_STEP = 10;
 var REFILL_THRESHOLD = 200;
 var STARTER_TOKENS = 100;
 function budgetTokens(monthlyBudgetUsd) {
@@ -34848,7 +34849,10 @@ function budgetTokens(monthlyBudgetUsd) {
 }
 function purchasableTokens(config2, usage, wanted) {
   const left = budgetTokens(config2.monthlyBudgetUsd) - usage.boughtTokens;
-  return Math.max(0, Math.min(Math.floor(wanted), left, MAX_TOKENS_PER_PURCHASE));
+  const step = config2.wallet === "link" ? LINK_TOKEN_STEP : 1;
+  const asked = Math.ceil(Math.floor(wanted) / step) * step;
+  const count = Math.max(0, Math.min(asked, left, MAX_TOKENS_PER_PURCHASE));
+  return count - count % step;
 }
 function refillSize(config2, usage) {
   return purchasableTokens(config2, usage, PACK_SIZE);
@@ -35210,6 +35214,7 @@ export {
   profileMessage,
   buyTokens,
   redeem,
+  LINK_TOKEN_STEP,
   STARTER_TOKENS,
   budgetTokens,
   purchasableTokens,

package/dist/chunks/{chunk-RDEPJ6XD.js → chunk-UWIBR62N.js}

@@ -68,6 +68,7 @@ function statePaths(home) {
     config: join(home, "config.json"),
     issuer: join(home, "issuer.json"),
     key: join(home, "key"),
+    linkRefill: join(home, "link-refill.json"),
     refillLock: join(home, "refill.lock"),
     stateLock: join(home, "state.lock"),
     tokens: join(home, "tokens.enc"),
@@ -139,7 +140,8 @@ async function readConfig(home) {
     paused: config.paused === true,
     relayUrl: String(config.relayUrl ?? ""),
     version: 1,
-    wallet: config.wallet === "key" ? "key" : "tempo",
+    wallet: config.wallet === "key" || config.wallet === "link" ? config.wallet : "tempo",
+    ...typeof config.linkPaymentMethodId === "string" ? { linkPaymentMethodId: config.linkPaymentMethodId } : {},
     ...typeof config.name === "string" ? { name: config.name } : {},
     ...typeof config.tokensPerPage === "number" ? { tokensPerPage: config.tokensPerPage } : {}
   };

package/dist/chunks/{hook-IWRRBFKG.js → hook-QEFJTAKR.js}

@@ -15,7 +15,7 @@ import {
   needsRefill,
   redeem,
   refillSize
-} from "./chunk-UFBFF3R6.js";
+} from "./chunk-QKBTYUXG.js";
 import {
   clampTokensPerPage,
   settingsFor
@@ -26,7 +26,7 @@ import {
   updateUsage,
   withLock,
   writePrivateFile
-} from "./chunk-RDEPJ6XD.js";
+} from "./chunk-UWIBR62N.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/hook.ts

package/dist/chunks/{hook-process-Y2W56T2X.js → hook-process-D5ENJPRB.js}

@@ -10,7 +10,7 @@ import {
 import {
   startPayment,
   startRefill
-} from "./chunk-CV2WYKM7.js";
+} from "./chunk-HEQBEBKL.js";
 import {
   resolveSettings
 } from "./chunk-CF4LJZLC.js";
@@ -25,7 +25,7 @@ async function runHookProcess(argument = process.argv[3]) {
   if (isCursorPayload(payload)) process.stdout.write("{}\n");
   if (!turnEnd(payload) && hookDomains(payload).length === 0) return;
   if (await startPayment(raw)) return;
-  const { runHook } = await import("./hook-IWRRBFKG.js");
+  const { runHook } = await import("./hook-QEFJTAKR.js");
   await runHook({
     readInput: async () => raw,
     settings: resolveSettings(),
@@ -33,7 +33,7 @@ async function runHookProcess(argument = process.argv[3]) {
   });
 }
 async function runPayProcess() {
-  const { PAY_TIMEOUT_MS, runHook } = await import("./hook-IWRRBFKG.js");
+  const { PAY_TIMEOUT_MS, runHook } = await import("./hook-QEFJTAKR.js");
   setTimeout(() => process.exit(0), PAY_TIMEOUT_MS + 1e3).unref();
   const raw = await readStdin(HOOK_TIMEOUT_MS);
   await runHook(

package/dist/chunks/link-OU7W7IT6.js

@@ -0,0 +1,226 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+import "./chunk-GTMLTZRN.js";
+
+// src/link.ts
+import { execFile } from "node:child_process";
+import { Credential, Method } from "mppx";
+import { Mppx } from "mppx/client";
+import { Methods as StripeMethods } from "mppx/stripe";
+function linkCliPath(env = process.env) {
+  return env.PATRON_LINK_CLI || "link-cli";
+}
+var LINK_CLI_TIMEOUT_MS = 3e4;
+function quoteForCmd(arg) {
+  return `"${arg.replace(/"/g, '""').replace(/%/g, '"%"')}"`;
+}
+function linkCli(path = linkCliPath(), platform = process.platform) {
+  const windows = platform === "win32";
+  return (args, timeoutMs = LINK_CLI_TIMEOUT_MS) => new Promise((resolve, reject) => {
+    const argv = [...args, "--format", "json"];
+    execFile(
+      windows ? quoteForCmd(path) : path,
+      windows ? argv.map(quoteForCmd) : argv,
+      {
+        maxBuffer: 1024 * 1024,
+        timeout: timeoutMs,
+        ...windows ? { shell: true, windowsVerbatimArguments: true } : {}
+      },
+      (error, stdout, stderr) => {
+        const parsed = parseLastJson(stdout);
+        if (error) {
+          const code = error.code;
+          if (code === "ENOENT")
+            return reject(
+              new Error(
+                "Link CLI not found. Install it with npm i -g @stripe/link-cli, then run link-cli auth login."
+              )
+            );
+          const message = errorMessage(parsed) ?? (stderr.trim() || error.message);
+          return reject(new Error(`Link CLI: ${message}`));
+        }
+        if (parsed === void 0)
+          return reject(new Error("Link CLI returned no JSON result."));
+        resolve(parsed);
+      }
+    );
+  });
+}
+async function linkPaymentMethods(cli) {
+  const result = await cli(["payment-methods", "list"]);
+  const list = Array.isArray(result) ? result : result?.payment_details ?? [];
+  if (!Array.isArray(list)) throw new Error("Link CLI listed no payment methods.");
+  return list.filter(
+    (item) => typeof item === "object" && item !== null && typeof item.id === "string"
+  );
+}
+function linkBalance(methods) {
+  return methods.find(
+    (method) => method.balance_details?.available_balance !== void 0 || /balance/i.test(method.type)
+  );
+}
+var WAITING = /* @__PURE__ */ new Set(["created", "pending_approval", "requires_action"]);
+var PURCHASE_TIMEOUT_MS = 4 * 60 * 1e3;
+async function createLinkSpt(options) {
+  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const usd = (options.amount / 100).toFixed(2);
+  const deadline = Date.now() + (options.timeoutMs ?? PURCHASE_TIMEOUT_MS);
+  const call = (args) => {
+    const left = deadline - Date.now();
+    if (left <= 0) throw new Error("Link did not approve the purchase in time.");
+    return options.cli(args, Math.min(LINK_CLI_TIMEOUT_MS, left));
+  };
+  const retrieve = async (id) => asSpendRequest(
+    await call(["spend-request", "retrieve", id, "--include", "shared_payment_token"])
+  );
+  const created = asSpendRequest(
+    await call([
+      "spend-request",
+      "create",
+      "--credential-type",
+      "shared_payment_token",
+      "--network-id",
+      options.networkId,
+      "--amount",
+      String(options.amount),
+      "--currency",
+      "usd",
+      "--context",
+      `Patron: buying $${usd} of seals (1,000 per dollar) that pay the websites your AI agents and browser read, $0.001 per page, privately. Started by npx @tempoxyz/patron on this computer.`,
+      "--idempotency-key",
+      options.idempotencyKey,
+      "--request-approval",
+      ...options.paymentMethodId ? ["--payment-method-id", options.paymentMethodId] : []
+    ])
+  );
+  let request = created;
+  try {
+    if (WAITING.has(request.status)) {
+      const action = request.status_details?.requires_action?.next_action;
+      const url = action?.action_url ?? request.approval_url;
+      options.output.write(
+        `
+Approve $${usd} for Patron in the Link app${url ? `:
+${url}` : "."}
+
+`
+      );
+      while (WAITING.has(request.status)) {
+        assertResumable(request);
+        if (Date.now() > deadline)
+          throw new Error(`Link spend request ${request.id} was not approved in time.`);
+        await sleep(options.pollMs ?? 2e3);
+        request = await retrieve(request.id);
+      }
+    }
+    if (request.status !== "approved")
+      throw new Error(`Link spend request ${request.id} ended ${request.status}.`);
+  } catch (error) {
+    if (WAITING.has(request.status))
+      await options.cli(["spend-request", "cancel", request.id], 5e3).catch(() => void 0);
+    throw error;
+  }
+  for (let attempt = 0; attempt < 8; attempt++) {
+    const spt = request.shared_payment_token?.id;
+    if (spt) return spt;
+    await sleep(attempt === 0 ? 0 : 1e3);
+    request = await retrieve(request.id);
+  }
+  throw new Error(
+    `Link approved spend request ${request.id} but issued no payment token.`
+  );
+}
+function assertResumable(request) {
+  if (request.status !== "requires_action") return;
+  const action = request.status_details?.requires_action?.next_action;
+  if (action?.resolution === "auto_resume") return;
+  throw new Error(
+    `Link needs you to act before it can pay${action?.display_message ? `: ${action.display_message}` : "."}${action?.action_url ? ` ${action.action_url}` : ""} Patron will ask again on the next purchase.`
+  );
+}
+async function paymentMethodFor(cli, preferred, cents) {
+  if (!preferred) return void 0;
+  const methods = await linkPaymentMethods(cli).catch(() => void 0);
+  if (!methods) return preferred;
+  const method = methods.find((item) => item.id === preferred);
+  if (!method) return void 0;
+  const available = method.balance_details?.available_balance;
+  if (available && (available.currency.toLowerCase() !== "usd" || available.amount < cents))
+    return void 0;
+  return preferred;
+}
+function asSpendRequest(value) {
+  const request = Array.isArray(value) ? value.at(-1) : value;
+  if (!request || typeof request.id !== "string" || typeof request.status !== "string")
+    throw new Error("Link CLI returned an unexpected spend request.");
+  return request;
+}
+function linkFetch(options) {
+  const charge = Method.toClient(StripeMethods.charge, {
+    async createCredential({ challenge }) {
+      const { amount, currency, methodDetails } = challenge.request;
+      const cents = Number(amount);
+      if (currency.toLowerCase() !== "usd")
+        throw new Error(`Patron asked for ${currency}; Link pays only USD.`);
+      if (!Number.isSafeInteger(cents) || cents < 1 || cents > options.maxCents)
+        throw new Error(
+          `Patron asked for ${amount} cents, more than this purchase allows.`
+        );
+      if (!methodDetails.networkId) throw new Error("Patron sent no Stripe network ID.");
+      const paymentMethodId = await paymentMethodFor(
+        options.cli,
+        options.paymentMethodId,
+        cents
+      );
+      const spt = await createLinkSpt({
+        amount: cents,
+        cli: options.cli,
+        idempotencyKey: `patron-${challenge.id}`,
+        networkId: methodDetails.networkId,
+        output: options.output,
+        ...options.sleep ? { sleep: options.sleep } : {},
+        ...paymentMethodId ? { paymentMethodId } : {}
+      });
+      return Credential.serialize({ challenge, payload: { spt } });
+    }
+  });
+  return Mppx.create({
+    ...options.fetch ? { fetch: options.fetch } : {},
+    methods: [charge],
+    polyfill: false
+  }).fetch;
+}
+function parseLastJson(output) {
+  const text = output.trim();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    const lines = text.split("\n").filter((line) => line.trim());
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        return JSON.parse(lines.slice(i).join("\n"));
+      } catch {
+      }
+    }
+    return void 0;
+  }
+}
+function errorMessage(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  if (typeof record.message === "string") return record.message;
+  if (record.error && typeof record.error === "object") return errorMessage(record.error);
+  if (typeof record.error === "string") return record.error;
+  return void 0;
+}
+export {
+  createLinkSpt,
+  linkBalance,
+  linkCli,
+  linkCliPath,
+  linkFetch,
+  linkPaymentMethods,
+  paymentMethodFor,
+  quoteForCmd
+};

package/dist/chunks/{wallet-WNPT6R4M.js → wallet-R3UWBXVC.js}

@@ -2,7 +2,7 @@ import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 import {
   statePaths
-} from "./chunk-RDEPJ6XD.js";
+} from "./chunk-UWIBR62N.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/wallet.ts
@@ -118,6 +118,22 @@ async function openWallet(settings, wallet, issuer, maxUnits, output = process.s
     signMessage: (message) => provider.request({ method: "personal_sign", params: [toHex(message), address] })
   };
 }
+var UNITS_PER_CENT = 10000n;
+async function openLinkWallet(config, maxUnits, output = process.stderr) {
+  const { linkCli, linkFetch } = await import("./link-OU7W7IT6.js");
+  return {
+    address: "0x0000000000000000000000000000000000000000",
+    fetch: linkFetch({
+      cli: linkCli(),
+      maxCents: Number(maxUnits / UNITS_PER_CENT),
+      output,
+      ...config.linkPaymentMethodId ? { paymentMethodId: config.linkPaymentMethodId } : {}
+    }),
+    signMessage: async () => {
+      throw new Error("A Link wallet has no Tempo address to sign with.");
+    }
+  };
+}
 function budgetLimit(budgetUnits, currency) {
   return {
     limit: toHex(budgetUnits),
@@ -151,6 +167,7 @@ ${url}
 }
 export {
   authorizeBudget,
+  openLinkWallet,
   openWallet,
   signIn
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tempoxyz/patron",
-	"version": "0.0.20",
+	"version": "0.0.22",
 	"description": "Pay the websites your AI agents read, privately",
 	"type": "module",
 	"bin": {