@tempoxyz/patron 0.0.27 → 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-QQPBFRY6.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-QQPBFRY6.js");
+  const { runPayProcess } = await import("./chunks/hook-process-6WSLYXC7.js");
   await runPayProcess().catch(() => void 0);
   process.exit(0);
 } else {
-  const { run } = await import("./chunks/-PBBSDRMM.js");
+  const { run } = await import("./chunks/-OLVAZG3H.js");
   process.exitCode = await run(process.argv.slice(2));
 }

package/dist/chunks/{-PBBSDRMM.js → -OLVAZG3H.js}

@@ -1,14 +1,14 @@
 import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 import {
+  CLAUDE_HOOK_STATUS,
   FileTokenStore,
   LINK_TOKEN_STEP,
-  LeaderboardResponse,
-  PatronInfo,
   STARTER_TOKENS,
   budgetTokens,
   buyTokens,
   codexHome,
+  codexNotifyCommand,
   codexPaths,
   hasPatronHandler,
   installCodex,
@@ -17,7 +17,7 @@ import {
   loadIssuer,
   needsRefill,
   parseUsd,
-  profileMessage,
+  patronCommands,
   purchasableTokens,
   readJsonObject,
   redeem,
@@ -29,26 +29,20 @@ import {
   withPatronStatus,
   withoutPatronHandlers,
   writeJsonObject
-} from "./chunk-F5CY5O7O.js";
+} from "./chunk-SAEZ54SS.js";
 import {
   startRefill
-} from "./chunk-TV5VLFTD.js";
+} from "./chunk-3CYJJJR3.js";
 import {
-  DEFAULT_MONTHLY_BUDGET_USD,
-  MAX_TOKENS_PER_PAGE,
-  MIN_TOKENS_PER_PAGE,
-  PACK_SIZE,
-  TOKEN_PRICE_UNITS,
-  clampTokensPerPage,
-  formatUsd,
-  normalizePayee,
   resolveSettings,
-  settingsFor,
-  tokensToUnits
-} from "./chunk-WZRGCKEK.js";
+  settingsFor
+} from "./chunk-OQXACACU.js";
 import {
   AGENT_IDS,
+  LeaderboardResponse,
+  PatronInfo,
   ensureHome,
+  profileMessage,
   readConfig,
   readJson,
   readUsage,
@@ -56,11 +50,20 @@ import {
   updateUsage,
   writeConfig,
   writePrivateFile
-} from "./chunk-MZJEM2SE.js";
+} from "./chunk-ZOQJ4CZE.js";
 import {
+  DEFAULT_MONTHLY_BUDGET_USD,
+  MAX_TOKENS_PER_PAGE,
+  MIN_TOKENS_PER_PAGE,
+  PACK_SIZE,
+  TOKEN_PRICE_UNITS,
+  clampTokensPerPage,
+  formatUsd,
+  normalizePayee,
+  tokensToUnits,
   tryLock,
   withLock
-} from "./chunk-O64T22EK.js";
+} from "./chunk-EISHX7Q3.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/index.ts
@@ -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-OJP2JREM.js");
+    const { openLinkWallet } = await import("./wallet-LOLL66ID.js");
     return openLinkWallet(config, maxUnits);
   }
-  const { openWallet } = await import("./wallet-OJP2JREM.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);
@@ -861,6 +940,19 @@ function defaults() {
     stdout: process.stdout
   };
 }
+var REFRESHES_STABLE_COPY = /* @__PURE__ */ new Set([
+  "status",
+  "pause",
+  "resume",
+  "budget",
+  "per-page",
+  "tip",
+  "name"
+]);
+async function refreshStableCli(deps) {
+  const config = await readConfig(deps.settings.home).catch(() => void 0);
+  if (config) await installStableCli(deps.settings.home).catch(() => void 0);
+}
 async function run(argv, overrides = {}) {
   const base = { ...defaults(), ...overrides };
   let shared;
@@ -873,6 +965,8 @@ async function run(argv, overrides = {}) {
   };
   const [command, ...args] = argv;
   try {
+    if (command !== void 0 && REFRESHES_STABLE_COPY.has(command))
+      await refreshStableCli(deps);
     switch (command) {
       case void 0:
         await main(deps);
@@ -900,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":
@@ -1069,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-OJP2JREM.js");
+  const { signIn } = await import("./wallet-LOLL66ID.js");
   const account = await signIn(deps.settings, {
     budgetUnits,
     issuer,
@@ -1109,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();
@@ -1181,9 +1275,9 @@ async function changeBudget(deps, 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) {
+  if (config.wallet === "tempo" && budget >= config.monthlyBudgetUsd) {
     step(deps, "Approve the new spending limit in Tempo Wallet");
-    const { authorizeBudget } = await import("./wallet-OJP2JREM.js");
+    const { authorizeBudget } = await import("./wallet-LOLL66ID.js");
     const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
       fetch: deps.fetch
     });
@@ -1237,43 +1331,78 @@ async function tip(deps, url, amount = "0.10") {
       throw new Error(
         `This tip needs ${tokensUsd(missing)} more than this month's budget allows. Raise it with patron budget <usd>.`
       );
-    step(deps, `Adding ${tokensUsd(missing)} to your balance`);
-    await buyWithinBudget(settings, config, missing, deps.openWallet);
+    const amount2 = Math.max(missing, purchasableTokens(config, usage, PACK_SIZE));
+    step(deps, `Adding ${tokensUsd(amount2)} to your balance`);
+    await buyWithinBudget(settings, config, amount2, deps.openWallet);
   }
   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.`
@@ -1300,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-OJP2JREM.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 });
@@ -1308,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)
@@ -1342,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,