@tempoxyz/patron 0.0.28 → 0.0.30

package/dist/chunks/{chunk-HQ2ZLUTT.js → chunk-23MZSDN6.js}

@@ -3,7 +3,7 @@ const require = __patronCreateRequire(import.meta.url)
 import {
   isExcludedByDefault,
   normalizePayee
-} from "./chunk-EISHX7Q3.js";
+} from "./chunk-AKOXBXV3.js";
 
 // src/hook-input.ts
 var HOOK_TIMEOUT_MS = 2e3;

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

@@ -3,22 +3,22 @@ const require = __patronCreateRequire(import.meta.url)
 import {
   IssueResponse,
   IssuerInfo,
-  RedeemResponse,
-  ensureHome,
-  readJson,
-  statePaths,
-  writePrivateFile
-} from "./chunk-EV7OA6GK.js";
+  RedeemResponse
+} from "./chunk-ROVOCDKE.js";
 import {
   ISSUER_NAME,
   MAX_TOKENS_PER_PURCHASE,
   PACK_SIZE,
   TOKEN_PRICE_UNITS,
   TOKEN_TYPE,
+  ensureHome,
   fromBase64Url,
+  readJson,
+  statePaths,
   toBase64Url,
-  withLock
-} from "./chunk-EISHX7Q3.js";
+  withLock,
+  writePrivateFile
+} from "./chunk-AKOXBXV3.js";
 import {
   __commonJS,
   __export,
@@ -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-EISHX7Q3.js → chunk-AKOXBXV3.js}

@@ -960,6 +960,203 @@ function normalizePayee(input) {
   return normalizeDomain(trimmed);
 }
 
+// src/lock.ts
+import { open, rm, stat } from "node:fs/promises";
+async function withLock(path, fn, options = {}) {
+  const deadline = Date.now() + (options.timeoutMs ?? 3e3);
+  const staleMs = options.staleMs ?? 1e4;
+  for (; ; ) {
+    try {
+      const handle = await open(path, "wx", 384);
+      await handle.close();
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const age = await stat(path).then(
+        (stats) => Date.now() - stats.mtimeMs,
+        () => 0
+      );
+      if (age > staleMs) {
+        await rm(path, { force: true });
+        continue;
+      }
+      if (Date.now() > deadline) throw new Error(`Patron state is busy: ${path}`);
+      await new Promise((resolve2) => setTimeout(resolve2, 10 + Math.random() * 20));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    await rm(path, { force: true });
+  }
+}
+async function tryLock(path, staleMs) {
+  try {
+    const handle = await open(path, "wx", 384);
+    await handle.close();
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const age = await stat(path).then(
+      (stats) => Date.now() - stats.mtimeMs,
+      () => 0
+    );
+    if (age <= staleMs) return void 0;
+    await rm(path, { force: true });
+    return tryLock(path, staleMs);
+  }
+  return () => rm(path, { force: true });
+}
+
+// src/state.ts
+import { randomBytes } from "node:crypto";
+import {
+  chmod,
+  lstat,
+  mkdir,
+  readFile,
+  readlink,
+  rename,
+  rm as rm2,
+  writeFile
+} from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+var AGENT_IDS = ["claude-code", "codex", "cursor", "amp"];
+function statePaths(home) {
+  return {
+    config: join(home, "config.json"),
+    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"),
+    spacing: join(home, "spacing.json"),
+    spacingLock: join(home, "spacing.lock"),
+    stateLock: join(home, "state.lock"),
+    tokens: join(home, "tokens.enc"),
+    usage: join(home, "usage.json"),
+    usageLock: join(home, "usage.lock"),
+    wallet: join(home, "wallet.json")
+  };
+}
+function monthOf(now) {
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+}
+async function ensureHome(home) {
+  await mkdir(home, { mode: 448, recursive: true });
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function writePrivateFile(link, contents) {
+  const target = await symlinkTarget(link);
+  if (target !== link) {
+    try {
+      return await replaceFile(target, contents);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EACCES" && code !== "EROFS" && code !== "EPERM") throw error;
+    }
+  }
+  await replaceFile(link, contents);
+}
+async function symlinkTarget(path, depth = 0) {
+  if (depth > 8) return path;
+  try {
+    const stats = await lstat(path);
+    if (!stats.isSymbolicLink()) return path;
+    return symlinkTarget(resolve(dirname(path), await readlink(path)), depth + 1);
+  } catch {
+    return path;
+  }
+}
+async function replaceFile(path, contents) {
+  const temporary = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    await writeFile(temporary, contents, { mode: 384 });
+    await chmod(temporary, 384);
+    await rename(temporary, path);
+  } catch (error) {
+    await rm2(temporary, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function readConfig(home) {
+  const value = await readJson(statePaths(home).config).catch(() => void 0);
+  if (!value || typeof value !== "object") return void 0;
+  const config = value;
+  if (config.version !== 1 || typeof config.address !== "string") return void 0;
+  return {
+    agents: Array.isArray(config.agents) ? config.agents.filter(
+      (agent) => AGENT_IDS.includes(agent)
+    ) : [],
+    address: config.address,
+    gatewayUrl: String(config.gatewayUrl ?? ""),
+    monthlyBudgetUsd: Number(config.monthlyBudgetUsd ?? 0),
+    network: config.network === "testnet" ? "testnet" : "mainnet",
+    paused: config.paused === true,
+    relayUrl: String(config.relayUrl ?? ""),
+    version: 1,
+    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 } : {}
+  };
+}
+async function writeConfig(home, config) {
+  await ensureHome(home);
+  await writePrivateFile(
+    statePaths(home).config,
+    `${JSON.stringify(config, null, "	")}
+`
+  );
+}
+function emptyUsage(month) {
+  return { boughtTokens: 0, domains: {}, month, paidPages: 0, tippedTokens: 0 };
+}
+async function readUsage(home, now = /* @__PURE__ */ new Date()) {
+  const month = monthOf(now);
+  const path = statePaths(home).usage;
+  const value = await readJson(path).catch(() => {
+    throw unreadableUsage(path);
+  });
+  if (value === void 0) return emptyUsage(month);
+  if (!isUsageRecord(value)) throw unreadableUsage(path);
+  if (value.month !== month) return emptyUsage(month);
+  return {
+    boughtTokens: value.boughtTokens,
+    domains: value.domains && typeof value.domains === "object" ? { ...value.domains } : {},
+    month,
+    paidPages: Number(value.paidPages ?? 0),
+    tippedTokens: Number(value.tippedTokens ?? 0)
+  };
+}
+function isUsageRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const usage = value;
+  return typeof usage.month === "string" && typeof usage.boughtTokens === "number" && Number.isFinite(usage.boughtTokens) && usage.boughtTokens >= 0;
+}
+function unreadableUsage(path) {
+  return new Error(
+    `${path} is unreadable, so Patron stops adding to your balance. Delete it to restart this month's budget count.`
+  );
+}
+async function updateUsage(home, update, now = /* @__PURE__ */ new Date()) {
+  await ensureHome(home);
+  return withLock(statePaths(home).usageLock, async () => {
+    const usage = await readUsage(home, now);
+    update(usage);
+    await writePrivateFile(statePaths(home).usage, `${JSON.stringify(usage)}
+`);
+    return usage;
+  });
+}
+
 // ../protocol/src/encoding.ts
 function toBase64Url(bytes) {
   let binary = "";
@@ -1164,53 +1361,6 @@ function tokensToUnits(tokens) {
   return BigInt(tokens) * TOKEN_PRICE_UNITS;
 }
 
-// src/lock.ts
-import { open, rm, stat } from "node:fs/promises";
-async function withLock(path, fn, options = {}) {
-  const deadline = Date.now() + (options.timeoutMs ?? 3e3);
-  const staleMs = options.staleMs ?? 1e4;
-  for (; ; ) {
-    try {
-      const handle = await open(path, "wx", 384);
-      await handle.close();
-      break;
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      const age = await stat(path).then(
-        (stats) => Date.now() - stats.mtimeMs,
-        () => 0
-      );
-      if (age > staleMs) {
-        await rm(path, { force: true });
-        continue;
-      }
-      if (Date.now() > deadline) throw new Error(`Patron state is busy: ${path}`);
-      await new Promise((resolve) => setTimeout(resolve, 10 + Math.random() * 20));
-    }
-  }
-  try {
-    return await fn();
-  } finally {
-    await rm(path, { force: true });
-  }
-}
-async function tryLock(path, staleMs) {
-  try {
-    const handle = await open(path, "wx", 384);
-    await handle.close();
-  } catch (error) {
-    if (error.code !== "EEXIST") throw error;
-    const age = await stat(path).then(
-      (stats) => Date.now() - stats.mtimeMs,
-      () => 0
-    );
-    if (age <= staleMs) return void 0;
-    await rm(path, { force: true });
-    return tryLock(path, staleMs);
-  }
-  return () => rm(path, { force: true });
-}
-
 export {
   TOKEN_PRICE_UNITS,
   PACK_SIZE,
@@ -1229,5 +1379,14 @@ export {
   formatUsd,
   tokensToUnits,
   withLock,
-  tryLock
+  tryLock,
+  AGENT_IDS,
+  statePaths,
+  ensureHome,
+  readJson,
+  writePrivateFile,
+  readConfig,
+  writeConfig,
+  readUsage,
+  updateUsage
 };

package/dist/chunks/{chunk-OQXACACU.js → chunk-NDBTADXZ.js}

@@ -2,16 +2,22 @@ import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 
 // src/settings.ts
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var DEFAULT_GATEWAY_URL = "https://patron-gateway.tempo-dev.workers.dev";
 var DEFAULT_RELAY_URL = "https://patron-relay.tempo-dev.workers.dev";
-function resolveSettings(env = process.env) {
+function inferHome(script) {
+  const match = script ? /^(.+)[/\\]cli[/\\][^/\\]+[/\\]dist[/\\]bin\.js$/.exec(script) : null;
+  const home = match?.[1];
+  return home && existsSync(join(home, "cli", "current")) ? home : void 0;
+}
+function resolveSettings(env = process.env, script = process.argv[1]) {
   const key = env.PATRON_PRIVATE_KEY?.trim();
   const privateKey = key && /^0x[0-9a-fA-F]{64}$/.test(key) ? key : void 0;
   return {
     gatewayUrl: env.PATRON_GATEWAY_URL || DEFAULT_GATEWAY_URL,
-    home: env.PATRON_HOME || join(homedir(), ".patron"),
+    home: env.PATRON_HOME || inferHome(script) || join(homedir(), ".patron"),
     network: env.PATRON_NETWORK === "testnet" ? "testnet" : "mainnet",
     overridden: {
       gatewayUrl: Boolean(env.PATRON_GATEWAY_URL),
@@ -32,6 +38,7 @@ function settingsFor(settings, saved) {
 }
 
 export {
+  inferHome,
   resolveSettings,
   settingsFor
 };