@tempoxyz/patron 0.0.28 → 0.0.29

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-IMQMGXBT.js");
+  const { runHookProcess } = await import("./chunks/hook-process-6WSLYXC7.js");
   await runHookProcess().catch(() => void 0);
   process.exit(0);
 } else if (process.argv[2] === "pay") {
-  const { runPayProcess } = await import("./chunks/hook-process-IMQMGXBT.js");
+  const { runPayProcess } = await import("./chunks/hook-process-6WSLYXC7.js");
   await runPayProcess().catch(() => void 0);
   process.exit(0);
 } else {
-  const { run } = await import("./chunks/-5Q7V7W7W.js");
+  const { run } = await import("./chunks/-OLVAZG3H.js");
   process.exitCode = await run(process.argv.slice(2));
 }

package/dist/chunks/{-5Q7V7W7W.js → -OLVAZG3H.js}

@@ -1,12 +1,14 @@
 import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 import {
+  CLAUDE_HOOK_STATUS,
   FileTokenStore,
   LINK_TOKEN_STEP,
   STARTER_TOKENS,
   budgetTokens,
   buyTokens,
   codexHome,
+  codexNotifyCommand,
   codexPaths,
   hasPatronHandler,
   installCodex,
@@ -15,6 +17,7 @@ import {
   loadIssuer,
   needsRefill,
   parseUsd,
+  patronCommands,
   purchasableTokens,
   readJsonObject,
   redeem,
@@ -26,10 +29,10 @@ import {
   withPatronStatus,
   withoutPatronHandlers,
   writeJsonObject
-} from "./chunk-EKFENOVR.js";
+} from "./chunk-SAEZ54SS.js";
 import {
   startRefill
-} from "./chunk-TV5VLFTD.js";
+} from "./chunk-3CYJJJR3.js";
 import {
   resolveSettings,
   settingsFor
@@ -47,7 +50,7 @@ import {
   updateUsage,
   writeConfig,
   writePrivateFile
-} from "./chunk-EV7OA6GK.js";
+} from "./chunk-ZOQJ4CZE.js";
 import {
   DEFAULT_MONTHLY_BUDGET_USD,
   MAX_TOKENS_PER_PAGE,
@@ -70,9 +73,9 @@ import { homedir as homedir2 } from "node:os";
 
 // src/agents.ts
 import { constants } from "node:fs";
-import { access as access2, realpath as realpath2 } from "node:fs/promises";
+import { access as access2, readFile as readFile4, realpath as realpath2 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { delimiter, join as join5 } from "node:path";
+import { delimiter, join as join5, resolve } from "node:path";
 
 // src/amp.ts
 import { mkdir, readFile, rm } from "node:fs/promises";
@@ -134,13 +137,17 @@ async function installAmpPlugin(path, command) {
   return "installed";
 }
 async function upgradeAmpPlugin(path) {
+  const command = await ampPluginCommand(path);
+  if (command === void 0) return false;
+  return await installAmpPlugin(path, command) === "installed";
+}
+async function ampPluginCommand(path) {
   const current = await readText(path);
-  if (current === void 0 || !current.startsWith(AMP_PLUGIN_MARKER)) return false;
+  if (current === void 0 || !current.startsWith(AMP_PLUGIN_MARKER)) return void 0;
   const literal = /^const COMMAND = (".*")$/m.exec(current)?.[1];
-  if (!literal) return false;
+  if (!literal) return void 0;
   const command = JSON.parse(literal);
-  if (typeof command !== "string") return false;
-  return await installAmpPlugin(path, command) === "installed";
+  return typeof command === "string" ? command : void 0;
 }
 async function removeAmpPlugin(path) {
   const current = await readText(path);
@@ -161,7 +168,6 @@ async function readText(path) {
 var CLAUDE_MATCHER = "WebFetch|WebSearch";
 var HOOK_TIMEOUT_SECONDS = 30;
 var EVENT = "PostToolUse";
-var CLAUDE_HOOK_STATUS = "Patron: pay the site this read";
 function patronGroup(command) {
   return {
     hooks: [
@@ -176,8 +182,8 @@ function patronGroup(command) {
     matcher: CLAUDE_MATCHER
   };
 }
-function withPatronHook(settings, command) {
-  return withPatronGroup(settings, EVENT, patronGroup(command));
+function withPatronHook(settings, command, known) {
+  return withPatronGroup(settings, EVENT, patronGroup(command), known);
 }
 async function upgradeClaudeHook(path) {
   const settings = await readJsonObject(path);
@@ -186,8 +192,8 @@ async function upgradeClaudeHook(path) {
   await writeJsonObject(path, next);
   return true;
 }
-function withoutPatronHook(settings) {
-  return withoutPatronHandlers(settings, EVENT);
+function withoutPatronHook(settings, known) {
+  return withoutPatronHandlers(settings, EVENT, known);
 }
 function hasPatronHook(settings, command) {
   return hasPatronHandler(settings, EVENT, {
@@ -195,16 +201,17 @@ function hasPatronHook(settings, command) {
     ...command === void 0 ? {} : { command }
   });
 }
-async function installClaudeHook(path, command) {
+async function installClaudeHook(path, command, known) {
   const settings = await readJsonObject(path);
-  if (hasPatronHook(settings, command)) return "unchanged";
-  await writeJsonObject(path, withPatronHook(settings, command));
+  if (hasPatronHook(settings, command) && patronCommands(settings, EVENT).length === 1)
+    return "unchanged";
+  await writeJsonObject(path, withPatronHook(settings, command, known));
   return "installed";
 }
-async function removeClaudeHook(path) {
+async function removeClaudeHook(path, known) {
   const settings = await readJsonObject(path);
-  if (!hasPatronHandler(settings, EVENT)) return "missing";
-  await writeJsonObject(path, withoutPatronHook(settings));
+  if (!hasPatronHandler(settings, EVENT, known ? { known } : {})) return "missing";
+  await writeJsonObject(path, withoutPatronHook(settings, known));
   return "removed";
 }
 
@@ -216,42 +223,46 @@ var EVENT2 = "postToolUse";
 function cursorHooksPath(home) {
   return join2(home, ".cursor", "hooks.json");
 }
-function withCursorHook(config, command) {
-  const stripped = withoutCursorHook(config);
+function withCursorHook(config, command, known) {
+  const stripped = withoutCursorHook(config, known);
   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) {
+function withoutCursorHook(config, known) {
   const entries = isObject(config.hooks) ? config.hooks[EVENT2] : void 0;
-  if (!Array.isArray(entries) || !entries.some(isPatronHandler)) return { ...config };
+  const patron = (entry) => isPatronHandler(entry, known);
+  if (!Array.isArray(entries) || !entries.some(patron)) return { ...config };
   return withHooksKey(
     config,
     EVENT2,
-    entries.filter((entry) => !isPatronHandler(entry))
+    entries.filter((entry) => !patron(entry))
   );
 }
 function cursorEntry(command) {
   return { command, matcher: CURSOR_MATCHER, timeout: HOOK_TIMEOUT_SECONDS2 };
 }
-function hasCursorHook(config, command) {
+function hasCursorHook(config, command, known) {
   const entries = isObject(config.hooks) ? config.hooks[EVENT2] : void 0;
   if (!Array.isArray(entries)) return false;
-  if (command === void 0) return entries.some(isPatronHandler);
+  if (command === void 0) return entries.some((entry) => isPatronHandler(entry, known));
   const wanted = JSON.stringify(cursorEntry(command));
-  return entries.some((entry) => JSON.stringify(entry) === wanted);
+  const patron = entries.filter(
+    (entry) => isPatronHandler(entry, known) || JSON.stringify(entry) === wanted
+  );
+  return patron.length === 1 && JSON.stringify(patron[0]) === wanted;
 }
-async function installCursorHook(path, command) {
+async function installCursorHook(path, command, known) {
   const config = await readJsonObject(path);
-  if (hasCursorHook(config, command)) return "unchanged";
-  await writeJsonObject(path, withCursorHook(config, command));
+  if (hasCursorHook(config, command, known)) return "unchanged";
+  await writeJsonObject(path, withCursorHook(config, command, known));
   return "installed";
 }
-async function removeCursorHook(path) {
+async function removeCursorHook(path, known) {
   const config = await readJsonObject(path);
-  if (!hasCursorHook(config)) return "missing";
-  await writeJsonObject(path, withoutCursorHook(config));
+  if (!hasCursorHook(config, void 0, known)) return "missing";
+  await writeJsonObject(path, withoutCursorHook(config, known));
   return "removed";
 }
 
@@ -408,32 +419,33 @@ var ADAPTERS = {
     install: async (command, { env, home }) => ({
       state: await installAmpPlugin(ampPluginPath(env, home), command)
     }),
+    // The plugin file starts with Patron's marker, so it needs no known commands.
     remove: ({ env, home }) => removeAmpPlugin(ampPluginPath(env, home)),
     upgrade: ({ env, home }) => upgradeAmpPlugin(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)
+    install: async (command, environment, known) => ({
+      state: await installClaudeHook(claudeSettingsPath(environment), command, known)
     }),
-    remove: (environment) => removeClaudeHook(claudeSettingsPath(environment)),
+    remove: (environment, known) => removeClaudeHook(claudeSettingsPath(environment), known),
     upgrade: (environment) => upgradeClaudeHook(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)),
+    install: (command, { env, home }, known) => installCodex(codexPaths(env, home), command, process.platform, known),
+    remove: ({ env, home }, known) => removeCodex(codexPaths(env, home), known),
     upgrade: ({ env, home }) => upgradeCodex(codexPaths(env, home))
   },
   cursor: {
     files: ({ home }) => [cursorHooksPath(home)],
     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)
+    install: async (command, { home }, known) => ({
+      state: await installCursorHook(cursorHooksPath(home), command, known)
     }),
-    remove: ({ home }) => removeCursorHook(cursorHooksPath(home))
+    remove: ({ home }, known) => removeCursorHook(cursorHooksPath(home), known)
   }
 };
 function claudeDirectory({ env, home }) {
@@ -452,12 +464,13 @@ async function detectAgents(environment) {
 }
 async function installAgents(agents, command, environment) {
   const store = originalsStore(environment);
+  const known = await knownCommands(environment, [command]);
   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);
+        const { note, state } = await ADAPTERS[agent].install(command, environment, known);
         if (state !== "installed") await forgetOriginals(store, recorded);
         return { agent, label: AGENT_LABELS[agent], state, ...note ? { note } : {} };
       } catch (error) {
@@ -477,10 +490,17 @@ async function upgradeAgents(agents, environment) {
 }
 async function removeAgents(environment) {
   const store = originalsStore(environment);
+  const patronHome = environment.env.PATRON_HOME || join5(environment.home, ".patron");
+  const stable = `${quote(process.execPath)} ${quote(stableBin(patronHome))} hook`;
+  const known = await knownCommands(environment, [
+    await hookCommand(environment.env, process.argv[1], process.execPath, patronHome),
+    stable,
+    withPatronHome(stable, environment.env.PATRON_HOME)
+  ]);
   return Promise.all(
     AGENT_IDS.map(async (agent) => {
       try {
-        const state = await ADAPTERS[agent].remove(environment);
+        const state = await ADAPTERS[agent].remove(environment, known);
         if (state === "removed")
           await restoreOriginals(store, ADAPTERS[agent].files(environment)).catch(
             () => void 0
@@ -492,6 +512,32 @@ async function removeAgents(environment) {
     })
   );
 }
+async function knownCommands({ env, home }, extra) {
+  const paths = codexPaths(env, home);
+  const found = await Promise.all([
+    readJsonObject(claudeSettingsPath({ env, home })).then(
+      (settings) => patronCommands(settings, "PostToolUse"),
+      () => []
+    ),
+    readJsonObject(paths.hooks).then(
+      (settings) => patronCommands(settings, "Stop"),
+      () => []
+    ),
+    readFile4(paths.config, "utf8").then(
+      (toml) => [codexNotifyCommand(toml)],
+      () => []
+    ),
+    ampPluginCommand(ampPluginPath(env, home)).then(
+      (command) => [command],
+      () => []
+    )
+  ]);
+  return new Set(
+    [...found.flat(), ...extra].filter(
+      (command) => typeof command === "string" && command !== ""
+    )
+  );
+}
 function originalsStore({ env, home }) {
   return originalsPath(env.PATRON_HOME || join5(home, ".patron"));
 }
@@ -505,6 +551,9 @@ function failure(agent, error) {
 }
 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;
+  return withPatronHome(await runCommand(script, node, patronHome), env.PATRON_HOME);
+}
+async function runCommand(script, node, patronHome) {
   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`;
@@ -512,6 +561,9 @@ async function hookCommand(env = process.env, script = process.argv[1], node = p
     return `${quote(node)} ${quote(stableBin(patronHome))} hook`;
   return "npx -y @tempoxyz/patron hook";
 }
+function withPatronHome(command, patronHome) {
+  return patronHome ? `PATRON_HOME=${quote(resolve(patronHome))} ${command}` : command;
+}
 function quote(value) {
   return /^[\w./:@-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -697,16 +749,24 @@ 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) => {
   if (config.wallet === "link") {
-    const { openLinkWallet } = await import("./wallet-6TDMXRWW.js");
+    const { openLinkWallet } = await import("./wallet-LOLL66ID.js");
     return openLinkWallet(config, maxUnits);
   }
-  const { openWallet } = await import("./wallet-6TDMXRWW.js");
+  const { openWallet } = await import("./wallet-LOLL66ID.js");
   return openWallet(settings, config.wallet, issuer, maxUnits);
 };
+var REFILL_LOCK_STALE_MS = 5 * 60 * 1e3;
 async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpenWallet) {
+  await ensureHome(settings.home);
+  return withLock(
+    statePaths(settings.home).purchaseLock,
+    () => buyLocked(settings, config, wanted, openWallet),
+    { staleMs: REFILL_LOCK_STALE_MS, timeoutMs: REFILL_LOCK_STALE_MS }
+  );
+}
+async function buyLocked(settings, config, wanted, openWallet) {
   const usage = await readUsage(settings.home);
   const count = purchasableTokens(config, usage, wanted);
   if (count === 0) return 0;
@@ -729,10 +789,28 @@ async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpe
   });
   return tokens.length;
 }
+var REFILL_DELAY_MS = { max: 10 * 60 * 1e3, min: 60 * 1e3 };
+async function delayedRefill(base, openWallet = defaultOpenWallet, sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)), random = Math.random) {
+  if (!await readConfig(base.home)) return 0;
+  const release = await tryLock(
+    statePaths(base.home).refillWait,
+    REFILL_DELAY_MS.max + REFILL_LOCK_STALE_MS
+  );
+  if (!release) return 0;
+  try {
+    await sleep(
+      REFILL_DELAY_MS.min + random() * (REFILL_DELAY_MS.max - REFILL_DELAY_MS.min)
+    );
+  } finally {
+    await release();
+  }
+  return refill(base, openWallet);
+}
 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);
+  await loadIssuer(settings.home, settings.gatewayUrl).catch(() => void 0);
   const release = await tryLock(
     statePaths(settings.home).refillLock,
     REFILL_LOCK_STALE_MS
@@ -846,6 +924,7 @@ PATRON_PRIVATE_KEY (testnet automation), PATRON_BUDGET_USD (non-interactive setu
 PATRON_WALLET=link (pay with Link through link-cli), PATRON_LINK_CLI (its path).`;
 var UsageError = class extends Error {
 };
+var TIP_BATCH = 8;
 function defaults() {
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const color = supportsColor(process.stdout);
@@ -915,7 +994,7 @@ async function run(argv, overrides = {}) {
         await uninstall(deps);
         return 0;
       case "refill":
-        await refill(deps.settings, deps.openWallet).catch(() => 0);
+        await (args[0] === "--delay" ? delayedRefill(deps.settings, deps.openWallet) : refill(deps.settings, deps.openWallet)).catch(() => 0);
         return 0;
       case "help":
       case "--help":
@@ -1084,7 +1163,7 @@ async function tempoSignIn(deps, budgetUnits, issuer) {
     deps,
     deps.settings.privateKey ? "Using PATRON_PRIVATE_KEY" : "Signing in with Tempo Wallet"
   );
-  const { signIn } = await import("./wallet-6TDMXRWW.js");
+  const { signIn } = await import("./wallet-LOLL66ID.js");
   const account = await signIn(deps.settings, {
     budgetUnits,
     issuer,
@@ -1124,8 +1203,8 @@ 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.");
+    if (value === void 0 || value < 1e-3)
+      throw new UsageError("PATRON_BUDGET_USD must be at least 0.001.");
     return value;
   }
   const prompter = deps.prompter();
@@ -1198,7 +1277,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-6TDMXRWW.js");
+    const { authorizeBudget } = await import("./wallet-LOLL66ID.js");
     const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
       fetch: deps.fetch
     });
@@ -1259,37 +1338,71 @@ async function tip(deps, url, amount = "0.10") {
   const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
     fetch: deps.fetch
   });
-  const tokens = await store.takeMany(count);
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
   let paid = 0;
+  let sent = 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";
+  try {
+    while (sent < count && !stopped) {
+      const batch = await store.takeMany(Math.min(TIP_BATCH, count - sent));
+      if (batch.length === 0) break;
+      sent += batch.length;
+      const unsent = [];
+      let rejected = 0;
+      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;
+          })
+        )
+      );
+      const ok = results.filter((result) => result?.ok).length;
+      for (const result of results)
+        if (result && !result.ok) {
+          rejected += 1;
+          rejection = result.error ?? "rejected";
+        }
+      sent -= unsent.length;
+      await store.add(unsent);
+      if (ok > 0)
+        await updateUsage(settings.home, (usage) => {
+          usage.domains[domain] = (usage.domains[domain] ?? 0) + ok;
+          usage.tippedTokens += ok;
+        });
+      paid += ok;
+      if (count > TIP_BATCH && ok > 0)
+        say(
+          deps,
+          styleText(
+            `  ${tokensUsd(paid)} of ${tokensUsd(count)} sent`,
+            "dim",
+            deps.color
+          )
+        );
+      if (ok === 0 && (rejected > 0 || unsent.length > 0)) break;
     }
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
   }
-  await store.add(unsent);
-  if (paid > 0)
-    await updateUsage(settings.home, (usage) => {
-      usage.domains[domain] = (usage.domains[domain] ?? 0) + paid;
-      usage.tippedTokens += paid;
-    });
+  if (stopped && sent < count)
+    throw new Error(
+      `Tip stopped: tipped ${domain} ${tokensUsd(paid)} of ${tokensUsd(count)}; the rest stays in your balance.`
+    );
   if (paid === 0)
     throw new Error(
       rejection ? `Patron rejected the tip to ${domain}: ${rejection}.` : `Could not reach Patron to tip ${domain}; your balance was kept.`
@@ -1316,7 +1429,7 @@ async function setName(deps, name) {
   const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
     fetch: deps.fetch
   });
-  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-6TDMXRWW.js")).openWallet(s, c.wallet, i, max));
+  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-LOLL66ID.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 });
@@ -1324,9 +1437,11 @@ async function setName(deps, name) {
 }
 async function uninstall(deps) {
   const config = await readConfig(deps.settings.home);
-  const results = (await removeAgents(deps.agents)).filter(
-    (result) => result.state !== "missing"
-  );
+  const removed = await removeAgents(deps.agents);
+  const results = removed.filter((result) => result.state !== "missing");
+  const notFound = removed.filter(
+    (result) => result.state === "missing" && config?.agents.includes(result.agent)
+  ).map((result) => result.label);
   say(deps, styleText("Patron uninstall", "bold", deps.color));
   for (const line of formatAgentResults(results, deps.color)) say(deps, line);
   if (results.length === 0)
@@ -1358,6 +1473,10 @@ async function uninstall(deps) {
         deps.color
       )
     );
+  if (notFound.length > 0)
+    throw new Error(
+      `Found no Patron hook to remove for ${notFound.join(", ")}. If a hook running "patron hook" is still in its settings, delete it by hand.`
+    );
 }
 function readVersion() {
   for (const path of ["../package.json", "../../package.json"]) {

package/dist/chunks/{chunk-TV5VLFTD.js → chunk-3CYJJJR3.js}

@@ -4,10 +4,11 @@ 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]) {
+function startRefill(options = {}, script = process.argv[1]) {
   try {
     if (!script) return;
-    const [command, args] = refillCommand(script);
+    const [command, refillArgs] = refillCommand(script);
+    const args = options.delayed ? [...refillArgs, "--delay"] : refillArgs;
     const child = spawn(command, args, {
       detached: true,
       env: process.env,

package/dist/chunks/{chunk-EKFENOVR.js → chunk-SAEZ54SS.js}

@@ -8,7 +8,7 @@ import {
   readJson,
   statePaths,
   writePrivateFile
-} from "./chunk-EV7OA6GK.js";
+} from "./chunk-ZOQJ4CZE.js";
 import {
   ISSUER_NAME,
   MAX_TOKENS_PER_PURCHASE,
@@ -14990,7 +14990,7 @@ async function redeem(options) {
 
 // src/budget.ts
 var LINK_TOKEN_STEP = 10;
-var REFILL_THRESHOLD = 200;
+var REFILL_THRESHOLD = 400;
 var STARTER_TOKENS = 100;
 function budgetTokens(monthlyBudgetUsd) {
   if (!Number.isFinite(monthlyBudgetUsd) || monthlyBudgetUsd <= 0) return 0;
@@ -15030,11 +15030,28 @@ import { dirname } from "node:path";
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isPatronHandler(handler) {
+var CLAUDE_HOOK_STATUS = "Patron: pay the site this read";
+var CODEX_HOOK_STATUS = "Patron: pay the sites this turn read";
+var PATRON_STATUSES = /* @__PURE__ */ new Set([
+  CLAUDE_HOOK_STATUS,
+  CODEX_HOOK_STATUS
+]);
+var NO_COMMANDS = /* @__PURE__ */ new Set();
+function isPatronHandler(handler, known = NO_COMMANDS) {
   if (!isObject(handler) || typeof handler.command !== "string") return false;
+  if (typeof handler.statusMessage === "string" && PATRON_STATUSES.has(handler.statusMessage))
+    return true;
+  if (known.has(handler.command)) return true;
   return /patron/i.test(handler.command) && /\shook\s*$/.test(handler.command);
 }
-function withoutPatronHandlers(settings, event) {
+function patronCommands(settings, event) {
+  const groups = isObject(settings.hooks) ? settings.hooks[event] : void 0;
+  if (!Array.isArray(groups)) return [];
+  return groups.flatMap(
+    (group) => isObject(group) && Array.isArray(group.hooks) ? group.hooks.filter((handler) => isPatronHandler(handler)).map((handler) => handler.command) : []
+  );
+}
+function withoutPatronHandlers(settings, event, known = NO_COMMANDS) {
   const groups = isObject(settings.hooks) ? settings.hooks[event] : void 0;
   if (!isObject(settings.hooks) || !Array.isArray(groups)) return { ...settings };
   let changed = false;
@@ -15044,7 +15061,7 @@ function withoutPatronHandlers(settings, event) {
       kept.push(group);
       continue;
     }
-    const handlers = group.hooks.filter((handler) => !isPatronHandler(handler));
+    const handlers = group.hooks.filter((handler) => !isPatronHandler(handler, known));
     if (handlers.length === group.hooks.length) kept.push(group);
     else {
       changed = true;
@@ -15054,8 +15071,8 @@ function withoutPatronHandlers(settings, event) {
   if (!changed) return { ...settings };
   return withHooksKey(settings, event, kept);
 }
-function withPatronGroup(settings, event, group) {
-  const next = withoutPatronHandlers(settings, event);
+function withPatronGroup(settings, event, group, known = NO_COMMANDS) {
+  const next = withoutPatronHandlers(settings, event, known);
   const hooks = isObject(next.hooks) ? next.hooks : {};
   const groups = Array.isArray(hooks[event]) ? hooks[event] : [];
   return withHooksKey(next, event, [...groups, group]);
@@ -15065,7 +15082,7 @@ function hasPatronHandler(settings, event, options = {}) {
   if (!Array.isArray(groups)) return false;
   return groups.some(
     (group) => isObject(group) && (options.matcher === void 0 || group.matcher === options.matcher) && Array.isArray(group.hooks) && group.hooks.some(
-      (handler) => isPatronHandler(handler) && (options.command === void 0 || handler.command === options.command)
+      (handler) => isPatronHandler(handler, options.known) && (options.command === void 0 || handler.command === options.command)
     )
   );
 }
@@ -15131,10 +15148,9 @@ function codexPaths(env, home) {
   const root = codexHome(env, home);
   return { config: join(root, "config.toml"), hooks: join(root, "hooks.json") };
 }
-function withCodexStopHook(settings, command) {
-  return withPatronGroup(settings, EVENT, stopGroup(command));
+function withCodexStopHook(settings, command, known) {
+  return withPatronGroup(settings, EVENT, stopGroup(command), known);
 }
-var CODEX_HOOK_STATUS = "Patron: pay the sites this turn read";
 function stopGroup(command) {
   return {
     hooks: [
@@ -15150,7 +15166,7 @@ function stopGroup(command) {
 function hasStopGroup(settings, command) {
   const groups = isObject(settings.hooks) ? settings.hooks[EVENT] : void 0;
   const wanted = JSON.stringify(stopGroup(command));
-  return Array.isArray(groups) && groups.some((group) => JSON.stringify(group) === wanted);
+  return Array.isArray(groups) && groups.some((group) => JSON.stringify(group) === wanted) && patronCommands(settings, EVENT).length === 1;
 }
 function codexNotifyLine(command) {
   const argv = ["sh", "-c", `${command} "$1"`, "patron"];
@@ -15174,6 +15190,21 @@ function withCodexNotify(toml, command) {
     text: lines.map((value, at) => at === index ? line : value).join("\n")
   };
 }
+function codexNotifyCommand(toml) {
+  const lines = toml.split("\n");
+  const line = lines[topLevelNotify(lines)];
+  if (!line?.includes(CODEX_NOTIFY_MARKER)) return void 0;
+  const array = /=\s*(\[.*\])/.exec(
+    line.slice(0, line.lastIndexOf(CODEX_NOTIFY_MARKER))
+  )?.[1];
+  try {
+    const argv = JSON.parse(array ?? "");
+    const script = Array.isArray(argv) ? argv[2] : void 0;
+    return typeof script === "string" && script.endsWith(' "$1"') ? script.slice(0, -' "$1"'.length) : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function withoutCodexNotify(toml) {
   const lines = toml.split("\n");
   const index = topLevelNotify(lines);
@@ -15187,11 +15218,11 @@ function topLevelNotify(lines) {
   }
   return -1;
 }
-async function installCodex(paths, command, platform = process.platform) {
+async function installCodex(paths, command, platform = process.platform, known) {
   const settings = await readJsonObject(paths.hooks);
   const hookChanged = !hasStopGroup(settings, command);
   if (hookChanged)
-    await writeJsonObject(paths.hooks, withCodexStopHook(settings, command));
+    await writeJsonObject(paths.hooks, withCodexStopHook(settings, command, known));
   let notify = "taken";
   if (platform !== "win32") {
     const toml = await readText(paths.config);
@@ -15209,11 +15240,11 @@ async function upgradeCodex(paths) {
   await writeJsonObject(paths.hooks, next);
   return true;
 }
-async function removeCodex(paths) {
+async function removeCodex(paths, known) {
   let removed = false;
   const settings = await readJsonObject(paths.hooks);
-  if (hasPatronHandler(settings, EVENT)) {
-    await writeJsonObject(paths.hooks, withoutPatronHandlers(settings, EVENT));
+  if (hasPatronHandler(settings, EVENT, known ? { known } : {})) {
+    await writeJsonObject(paths.hooks, withoutPatronHandlers(settings, EVENT, known));
     removed = true;
   }
   const toml = await readText(paths.config);
@@ -15239,14 +15270,19 @@ async function writeText(path, text) {
 
 // src/issuer.ts
 var ISSUER_TTL_MS = 60 * 60 * 1e3;
+async function storedIssuer(home, gatewayUrl, now = Date.now()) {
+  const cached = await readJson(statePaths(home).issuer).catch(() => void 0);
+  const parsed = IssuerInfo.safeParse(cached?.issuer);
+  if (!parsed.success || cached?.gatewayUrl !== gatewayUrl) return void 0;
+  const at = typeof cached.at === "number" ? cached.at : Number.NEGATIVE_INFINITY;
+  return { issuer: parsed.data, stale: !(now - at < ISSUER_TTL_MS) };
+}
 async function loadIssuer(home, gatewayUrl, options = {}) {
   const now = options.now ?? Date.now();
   const path = statePaths(home).issuer;
   if (!options.fresh) {
-    const cached = await readJson(path).catch(() => void 0);
-    const parsed = IssuerInfo.safeParse(cached?.issuer);
-    if (parsed.success && cached?.gatewayUrl === gatewayUrl && typeof cached.at === "number" && now - cached.at < ISSUER_TTL_MS)
-      return parsed.data;
+    const cached = await storedIssuer(home, gatewayUrl, now);
+    if (cached && !cached.stale) return cached.issuer;
   }
   const issuer = await getIssuer(gatewayUrl, options.fetch);
   await ensureHome(home);
@@ -15370,7 +15406,9 @@ export {
   parseUsd,
   tipTokens,
   isObject,
+  CLAUDE_HOOK_STATUS,
   isPatronHandler,
+  patronCommands,
   withoutPatronHandlers,
   withPatronGroup,
   hasPatronHandler,
@@ -15380,9 +15418,11 @@ export {
   withPatronStatus,
   codexHome,
   codexPaths,
+  codexNotifyCommand,
   installCodex,
   upgradeCodex,
   removeCodex,
+  storedIssuer,
   loadIssuer,
   FileTokenStore
 };

package/dist/chunks/{chunk-EV7OA6GK.js → chunk-ZOQJ4CZE.js}

@@ -19881,7 +19881,9 @@ function statePaths(home) {
     issuer: join(home, "issuer.json"),
     key: join(home, "key"),
     linkRefill: join(home, "link-refill.json"),
+    purchaseLock: join(home, "purchase.lock"),
     refillLock: join(home, "refill.lock"),
+    refillWait: join(home, "refill-wait.lock"),
     stateLock: join(home, "state.lock"),
     tokens: join(home, "tokens.enc"),
     usage: join(home, "usage.json"),

package/dist/chunks/{hook-N2SVXVUR.js → hook-HYV4BSCN.js}

@@ -12,11 +12,11 @@ import {
 import {
   FileTokenStore,
   codexHome,
-  loadIssuer,
   needsRefill,
   redeem,
-  refillSize
-} from "./chunk-EKFENOVR.js";
+  refillSize,
+  storedIssuer
+} from "./chunk-SAEZ54SS.js";
 import {
   settingsFor
 } from "./chunk-OQXACACU.js";
@@ -25,7 +25,7 @@ import {
   readUsage,
   updateUsage,
   writePrivateFile
-} from "./chunk-EV7OA6GK.js";
+} from "./chunk-ZOQJ4CZE.js";
 import {
   clampTokensPerPage,
   withLock
@@ -250,11 +250,15 @@ async function payReads(dependencies, deadline) {
   }
   if (config.paused) return { paid: [], refill: false, skipped: "paused" };
   if (domains.length === 0) return { paid: [], refill: false, skipped: "empty" };
+  const now = dependencies.now?.() ?? /* @__PURE__ */ new Date();
+  const stored = await storedIssuer(settings.home, settings.gatewayUrl, now.getTime());
+  if (!stored) {
+    dependencies.startRefill();
+    return { paid: [], refill: true, skipped: "no-issuer" };
+  }
+  const { issuer } = stored;
   const store = new FileTokenStore(settings.home);
   const boundedFetch = withDeadline(dependencies.fetch ?? fetch, deadline);
-  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
-    fetch: boundedFetch
-  });
   const perPage = clampTokensPerPage(config.tokensPerPage);
   const taken = await store.takeWithRemaining(domains.length * perPage, domains.length);
   const { empty, paid, unspent } = await redeemRounds(
@@ -269,7 +273,6 @@ async function payReads(dependencies, deadline) {
     }
   );
   await store.add(unspent);
-  const now = dependencies.now?.() ?? /* @__PURE__ */ new Date();
   if (paid.length > 0)
     await updateUsage(
       settings.home,
@@ -280,7 +283,7 @@ async function payReads(dependencies, deadline) {
       },
       now
     );
-  const refill = needsRefill(taken.remaining + unspent.length) && refillSize(config, await readUsage(settings.home, now)) > 0;
+  const refill = stored.stale || needsRefill(taken.remaining + unspent.length) && refillSize(config, await readUsage(settings.home, now)) > 0;
   if (refill) dependencies.startRefill();
   return {
     paid,

package/dist/chunks/{hook-process-IMQMGXBT.js → hook-process-6WSLYXC7.js}

@@ -11,7 +11,7 @@ import {
 import {
   startDrain,
   startRefill
-} from "./chunk-TV5VLFTD.js";
+} from "./chunk-3CYJJJR3.js";
 import {
   resolveSettings
 } from "./chunk-OQXACACU.js";
@@ -178,7 +178,7 @@ async function runHookProcess(argument = process.argv[3]) {
   await payEvent(
     event,
     settings,
-    () => startRefill(),
+    () => startRefill({ delayed: true }),
     started + HOOK_TIMEOUT_MS - Date.now()
   );
 }
@@ -191,7 +191,7 @@ async function runPayProcess() {
   const refill = () => {
     if (Date.now() - refilledAt < REFILL_RETRY_MS) return;
     refilledAt = Date.now();
-    startRefill();
+    startRefill({ delayed: true });
   };
   await drainQueue(settings.home, {
     deadline: Date.now() + DRAIN_MAX_MS,
@@ -202,7 +202,7 @@ async function runPayProcess() {
 }
 async function payEvent(event, settings, refill, timeoutMs) {
   if (timeoutMs <= 0) return;
-  const { runHook } = await import("./hook-N2SVXVUR.js");
+  const { runHook } = await import("./hook-HYV4BSCN.js");
   await runHook(
     {
       readInput: async () => event.raw,

package/dist/chunks/{wallet-6TDMXRWW.js → wallet-LOLL66ID.js}

@@ -2,7 +2,7 @@ import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 import {
   statePaths
-} from "./chunk-EV7OA6GK.js";
+} from "./chunk-ZOQJ4CZE.js";
 import {
   accessKeyLimitUnits
 } from "./chunk-EISHX7Q3.js";

package/package.json

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