@tempoxyz/patron 0.0.22 → 0.0.24

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

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

@@ -29,10 +29,10 @@ import {
   withPatronStatus,
   withoutPatronHandlers,
   writeJsonObject
-} from "./chunk-QKBTYUXG.js";
+} from "./chunk-NQ6RRPM6.js";
 import {
   startRefill
-} from "./chunk-HEQBEBKL.js";
+} from "./chunk-TV5VLFTD.js";
 import {
   DEFAULT_MONTHLY_BUDGET_USD,
   MAX_TOKENS_PER_PAGE,
@@ -45,7 +45,7 @@ import {
   resolveSettings,
   settingsFor,
   tokensToUnits
-} from "./chunk-CF4LJZLC.js";
+} from "./chunk-WZRGCKEK.js";
 import {
   AGENT_IDS,
   ensureHome,
@@ -53,12 +53,14 @@ import {
   readJson,
   readUsage,
   statePaths,
-  tryLock,
   updateUsage,
-  withLock,
   writeConfig,
   writePrivateFile
-} from "./chunk-UWIBR62N.js";
+} from "./chunk-SGQ525FB.js";
+import {
+  tryLock,
+  withLock
+} from "./chunk-O64T22EK.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/index.ts
@@ -690,10 +692,10 @@ async function linkRefillFailedAt(home) {
 var REFILL_LOCK_STALE_MS = 5 * 60 * 1e3;
 var defaultOpenWallet = async (settings, config, issuer, maxUnits) => {
   if (config.wallet === "link") {
-    const { openLinkWallet } = await import("./wallet-R3UWBXVC.js");
+    const { openLinkWallet } = await import("./wallet-7M2LEO4J.js");
     return openLinkWallet(config, maxUnits);
   }
-  const { openWallet } = await import("./wallet-R3UWBXVC.js");
+  const { openWallet } = await import("./wallet-7M2LEO4J.js");
   return openWallet(settings, config.wallet, issuer, maxUnits);
 };
 async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpenWallet) {
@@ -1062,7 +1064,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-R3UWBXVC.js");
+  const { signIn } = await import("./wallet-7M2LEO4J.js");
   const account = await signIn(deps.settings, {
     budgetUnits,
     issuer,
@@ -1176,7 +1178,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-R3UWBXVC.js");
+    const { authorizeBudget } = await import("./wallet-7M2LEO4J.js");
     const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
       fetch: deps.fetch
     });
@@ -1292,7 +1294,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-R3UWBXVC.js")).openWallet(s, c.wallet, i, max));
+  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-7M2LEO4J.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 });

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

@@ -8,14 +8,16 @@ import {
   TOKEN_TYPE,
   fromBase64Url,
   toBase64Url
-} from "./chunk-CF4LJZLC.js";
+} from "./chunk-WZRGCKEK.js";
 import {
   ensureHome,
   readJson,
   statePaths,
-  withLock,
   writePrivateFile
-} from "./chunk-UWIBR62N.js";
+} from "./chunk-SGQ525FB.js";
+import {
+  withLock
+} from "./chunk-O64T22EK.js";
 import {
   __commonJS,
   __export,

package/dist/chunks/chunk-O64T22EK.js

@@ -0,0 +1,54 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+
+// 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 {
+  withLock,
+  tryLock
+};

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

@@ -1,7 +1,11 @@
 import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
+import {
+  withLock
+} from "./chunk-O64T22EK.js";
 
 // src/state.ts
+import { randomBytes } from "node:crypto";
 import {
   chmod,
   lstat,
@@ -9,59 +13,10 @@ import {
   readFile,
   readlink,
   rename,
-  rm as rm2,
+  rm,
   writeFile
 } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
-
-// 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
 var AGENT_IDS = ["claude-code", "codex", "cursor", "amp"];
 function statePaths(home) {
   return {
@@ -114,13 +69,13 @@ async function symlinkTarget(path, depth = 0) {
   }
 }
 async function replaceFile(path, contents) {
-  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  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);
+    await rm(temporary, { force: true }).catch(() => void 0);
     throw error;
   }
 }
@@ -195,8 +150,6 @@ async function updateUsage(home, update, now = /* @__PURE__ */ new Date()) {
 }
 
 export {
-  withLock,
-  tryLock,
   AGENT_IDS,
   statePaths,
   ensureHome,

package/dist/chunks/{chunk-RJRJWNSQ.js → chunk-SIIFXQ6S.js}

@@ -3,10 +3,11 @@ const require = __patronCreateRequire(import.meta.url)
 import {
   isExcludedByDefault,
   normalizePayee
-} from "./chunk-CF4LJZLC.js";
+} from "./chunk-WZRGCKEK.js";
 
 // src/hook-input.ts
 var HOOK_TIMEOUT_MS = 2e3;
+var PAY_TIMEOUT_MS = 2e4;
 var MAX_DOMAINS_PER_HOOK = 10;
 var MAX_DEPTH = 6;
 var MAX_URLS = 50;
@@ -105,6 +106,7 @@ function isRecord(value) {
 
 export {
   HOOK_TIMEOUT_MS,
+  PAY_TIMEOUT_MS,
   MAX_DOMAINS_PER_HOOK,
   hookDomains,
   payableDomain,

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

@@ -29,18 +29,17 @@ function refillCommand(script) {
     ];
   }
 }
-function startPayment(payload, script = process.argv[1]) {
+function startDrain(script = process.argv[1]) {
   return new Promise((resolve) => {
     try {
       if (!script) return resolve(false);
       const child = spawn(process.execPath, [...process.execArgv, script, "pay"], {
         detached: true,
         env: process.env,
-        stdio: ["pipe", "ignore", "ignore"]
+        stdio: "ignore"
       });
       child.on("error", () => resolve(false));
-      child.stdin.on("error", () => resolve(false));
-      child.stdin.end(payload, () => {
+      child.on("spawn", () => {
         child.unref();
         resolve(true);
       });
@@ -52,5 +51,5 @@ function startPayment(payload, script = process.argv[1]) {
 
 export {
   startRefill,
-  startPayment
+  startDrain
 };

package/dist/chunks/{chunk-CF4LJZLC.js → chunk-WZRGCKEK.js}

@@ -849,9 +849,16 @@ function normalizeDomain(input) {
   if (!hostname || hostname === "localhost" || hostname.endsWith(".localhost"))
     return null;
   const parsed = (0, import_tldts.parse)(hostname, { allowPrivateDomains: true });
-  if (parsed.isIp || !parsed.domain || !(parsed.isIcann || parsed.isPrivate)) return null;
+  if (parsed.isIp) return null;
+  if (isEnsGatewayName(hostname)) return hostname;
+  if (!parsed.domain || !(parsed.isIcann || parsed.isPrivate)) return null;
   return authorSite(hostname, parsed.domain) ?? parsed.domain;
 }
+var ENS_GATEWAYS = /* @__PURE__ */ new Set(["eth.limo", "eth.link"]);
+function isEnsGatewayName(hostname) {
+  const dot = hostname.indexOf(".");
+  return dot > 0 && ENS_GATEWAYS.has(hostname.slice(dot + 1));
+}
 function authorSite(hostname, domain) {
   if (!AUTHOR_PLATFORMS.has(domain)) return null;
   const author = hostname.slice(0, -(domain.length + 1)).split(".").at(-1);

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

@@ -3,11 +3,12 @@ const require = __patronCreateRequire(import.meta.url)
 import {
   HOOK_TIMEOUT_MS,
   MAX_DOMAINS_PER_HOOK,
+  PAY_TIMEOUT_MS,
   hookDomains,
   parseHookInput,
   payableDomain,
   turnEnd
-} from "./chunk-RJRJWNSQ.js";
+} from "./chunk-SIIFXQ6S.js";
 import {
   FileTokenStore,
   codexHome,
@@ -15,18 +16,20 @@ import {
   needsRefill,
   redeem,
   refillSize
-} from "./chunk-QKBTYUXG.js";
+} from "./chunk-NQ6RRPM6.js";
 import {
   clampTokensPerPage,
   settingsFor
-} from "./chunk-CF4LJZLC.js";
+} from "./chunk-WZRGCKEK.js";
 import {
   readConfig,
   readUsage,
   updateUsage,
-  withLock,
   writePrivateFile
-} from "./chunk-UWIBR62N.js";
+} from "./chunk-SGQ525FB.js";
+import {
+  withLock
+} from "./chunk-O64T22EK.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/hook.ts
@@ -208,7 +211,6 @@ function isRecord(value) {
 }
 
 // src/hook.ts
-var PAY_TIMEOUT_MS = 2e4;
 var ABORT_MARGIN_MS = 500;
 async function runHook(dependencies, timeoutMs = HOOK_TIMEOUT_MS) {
   let timer;

package/dist/chunks/hook-process-QIK6YAOS.js

@@ -0,0 +1,243 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+import {
+  HOOK_TIMEOUT_MS,
+  PAY_TIMEOUT_MS,
+  hookDomains,
+  isCursorPayload,
+  parseHookInput,
+  turnEnd
+} from "./chunk-SIIFXQ6S.js";
+import {
+  startDrain,
+  startRefill
+} from "./chunk-TV5VLFTD.js";
+import {
+  resolveSettings
+} from "./chunk-WZRGCKEK.js";
+import {
+  tryLock
+} from "./chunk-O64T22EK.js";
+import "./chunk-GTMLTZRN.js";
+
+// src/hook-process.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/pay-queue.ts
+import { randomBytes } from "node:crypto";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  utimes,
+  writeFile
+} from "node:fs/promises";
+import { join } from "node:path";
+function queuePaths(home) {
+  return {
+    dir: join(home, "pay-queue"),
+    lock: join(home, "pay.lock"),
+    start: join(home, "pay.start")
+  };
+}
+var MAX_QUEUED = 500;
+var PAY_CONCURRENCY = 8;
+var DRAIN_STALE_MS = 6e4;
+var START_STALE_MS = 15e3;
+async function enqueue(home, event) {
+  try {
+    const { dir } = queuePaths(home);
+    await mkdir(dir, { recursive: true, mode: 448 });
+    if ((await queued(dir)).length >= MAX_QUEUED) return void 0;
+    const name = `${String(Date.now()).padStart(15, "0")}-${randomBytes(6).toString("hex")}.json`;
+    const temporary = join(dir, `.${name}.tmp`);
+    await writeFile(temporary, JSON.stringify(event), { mode: 384 });
+    const path = join(dir, name);
+    await rename(temporary, path);
+    return path;
+  } catch {
+    return void 0;
+  }
+}
+async function take(path) {
+  const taken = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.taken`;
+  try {
+    await rename(path, taken);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      await rm(path, { force: true }).catch(() => void 0);
+    return void 0;
+  }
+  try {
+    const event = JSON.parse(await readFile(taken, "utf8"));
+    return typeof event?.raw === "string" ? event : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    await rm(taken, { force: true }).catch(() => void 0);
+  }
+}
+async function drainerRunning(home, now = Date.now()) {
+  return stat(queuePaths(home).lock).then(
+    (stats) => now - stats.mtimeMs <= DRAIN_STALE_MS,
+    () => false
+  );
+}
+async function claimStart(home) {
+  return tryLock(queuePaths(home).start, START_STALE_MS).catch(() => void 0);
+}
+async function drainQueue(home, options) {
+  const { dir, lock, start } = queuePaths(home);
+  const deadline = options.deadline ?? Number.POSITIVE_INFINITY;
+  let processed = 0;
+  for (; ; ) {
+    const release = await tryLock(lock, DRAIN_STALE_MS).catch(() => void 0);
+    if (!release) return processed;
+    await rm(start, { force: true }).catch(() => void 0);
+    let pass = 0;
+    try {
+      pass = await drainHeld(dir, lock, options, deadline);
+    } finally {
+      await release();
+    }
+    processed += pass;
+    if (pass === 0 || Date.now() >= deadline || (await queued(dir)).length === 0)
+      return processed;
+  }
+}
+async function drainHeld(dir, lock, options, deadline) {
+  let processed = 0;
+  let pending = [];
+  const seen = /* @__PURE__ */ new Set();
+  const next = async () => {
+    for (; ; ) {
+      if (pending.length === 0)
+        pending = (await queued(dir)).filter((name2) => !seen.has(name2));
+      const name = pending.shift();
+      if (!name) return void 0;
+      if (seen.has(name)) continue;
+      seen.add(name);
+      return name;
+    }
+  };
+  const worker = async () => {
+    for (; ; ) {
+      if (Date.now() >= deadline) return;
+      const name = await next();
+      if (!name) return;
+      const event = await take(join(dir, name));
+      if (!event) continue;
+      await options.pay(event).catch(() => void 0);
+      processed++;
+      const now = /* @__PURE__ */ new Date();
+      await utimes(lock, now, now).catch(() => void 0);
+    }
+  };
+  const workers = Math.max(1, options.concurrency ?? PAY_CONCURRENCY);
+  await Promise.all(Array.from({ length: workers }, worker));
+  return processed;
+}
+async function queuedCount(home) {
+  return (await queued(queuePaths(home).dir)).length;
+}
+async function queued(dir) {
+  const names = await readdir(dir).catch(() => []);
+  return names.filter((name) => name.endsWith(".json") && !name.startsWith(".")).sort();
+}
+
+// src/hook-process.ts
+var DRAIN_MAX_MS = 12e4;
+var REFILL_RETRY_MS = 3e4;
+var MAX_INPUT_BYTES = 8 * 1024 * 1024;
+async function runHookProcess(argument = process.argv[3]) {
+  const started = Date.now();
+  setTimeout(() => process.exit(0), HOOK_TIMEOUT_MS + 500).unref();
+  const raw = argument ?? await readStdin(HOOK_TIMEOUT_MS / 2);
+  const payload = parseHookInput(raw);
+  if (isCursorPayload(payload)) process.stdout.write("{}\n");
+  if (!turnEnd(payload) && hookDomains(payload).length === 0) return;
+  const settings = resolveSettings();
+  const event = {
+    raw,
+    codexHome: process.env.CODEX_HOME || join2(homedir(), ".codex")
+  };
+  const path = await enqueue(settings.home, event);
+  if (path) {
+    if (await drainerRunning(settings.home)) return;
+    const claim = await claimStart(settings.home);
+    if (!claim) return;
+    if (await startDrain()) return;
+    await claim();
+    const own = await take(path);
+    if (!own) return;
+  }
+  await payEvent(
+    event,
+    settings,
+    () => startRefill(),
+    started + HOOK_TIMEOUT_MS - Date.now()
+  );
+}
+async function runPayProcess() {
+  setTimeout(() => process.exit(0), DRAIN_MAX_MS + PAY_TIMEOUT_MS + 5e3).unref();
+  const settings = resolveSettings();
+  const raw = await readStdin(HOOK_TIMEOUT_MS);
+  if (raw.trim()) await enqueue(settings.home, { raw });
+  let refilledAt = Number.NEGATIVE_INFINITY;
+  const refill = () => {
+    if (Date.now() - refilledAt < REFILL_RETRY_MS) return;
+    refilledAt = Date.now();
+    startRefill();
+  };
+  await drainQueue(settings.home, {
+    deadline: Date.now() + DRAIN_MAX_MS,
+    pay: (event) => payEvent(event, settings, refill, PAY_TIMEOUT_MS)
+  });
+  if (!await drainerRunning(settings.home) && await queuedCount(settings.home) > 0)
+    await startDrain();
+}
+async function payEvent(event, settings, refill, timeoutMs) {
+  if (timeoutMs <= 0) return;
+  const { runHook } = await import("./hook-RJN6WCIT.js");
+  await runHook(
+    {
+      readInput: async () => event.raw,
+      settings,
+      startRefill: refill,
+      ...event.codexHome ? { agents: { env: { CODEX_HOME: event.codexHome }, home: homedir() } } : {}
+    },
+    timeoutMs
+  );
+}
+function readStdin(timeoutMs) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let size = 0;
+    const finish = () => {
+      clearTimeout(timer);
+      process.stdin.removeAllListeners();
+      process.stdin.pause();
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    process.stdin.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_INPUT_BYTES) {
+        chunks.length = 0;
+        finish();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    process.stdin.on("end", finish);
+    process.stdin.on("error", finish);
+  });
+}
+export {
+  runHookProcess,
+  runPayProcess
+};

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

@@ -2,7 +2,8 @@ import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 import {
   statePaths
-} from "./chunk-UWIBR62N.js";
+} from "./chunk-SGQ525FB.js";
+import "./chunk-O64T22EK.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/wallet.ts

package/package.json

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

package/dist/chunks/hook-process-D5ENJPRB.js

@@ -1,75 +0,0 @@
-import { createRequire as __patronCreateRequire } from 'node:module'
-const require = __patronCreateRequire(import.meta.url)
-import {
-  HOOK_TIMEOUT_MS,
-  hookDomains,
-  isCursorPayload,
-  parseHookInput,
-  turnEnd
-} from "./chunk-RJRJWNSQ.js";
-import {
-  startPayment,
-  startRefill
-} from "./chunk-HEQBEBKL.js";
-import {
-  resolveSettings
-} from "./chunk-CF4LJZLC.js";
-import "./chunk-GTMLTZRN.js";
-
-// src/hook-process.ts
-var MAX_INPUT_BYTES = 8 * 1024 * 1024;
-async function runHookProcess(argument = process.argv[3]) {
-  setTimeout(() => process.exit(0), HOOK_TIMEOUT_MS + 500).unref();
-  const raw = argument ?? await readStdin(HOOK_TIMEOUT_MS / 2);
-  const payload = parseHookInput(raw);
-  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-QEFJTAKR.js");
-  await runHook({
-    readInput: async () => raw,
-    settings: resolveSettings(),
-    startRefill: () => startRefill()
-  });
-}
-async function runPayProcess() {
-  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(
-    {
-      readInput: async () => raw,
-      settings: resolveSettings(),
-      startRefill: () => startRefill()
-    },
-    PAY_TIMEOUT_MS
-  );
-}
-function readStdin(timeoutMs) {
-  return new Promise((resolve) => {
-    const chunks = [];
-    let size = 0;
-    const finish = () => {
-      clearTimeout(timer);
-      process.stdin.removeAllListeners();
-      process.stdin.pause();
-      resolve(Buffer.concat(chunks).toString("utf8"));
-    };
-    const timer = setTimeout(finish, timeoutMs);
-    process.stdin.on("data", (chunk) => {
-      size += chunk.length;
-      if (size > MAX_INPUT_BYTES) {
-        chunks.length = 0;
-        finish();
-        return;
-      }
-      chunks.push(chunk);
-    });
-    process.stdin.on("end", finish);
-    process.stdin.on("error", finish);
-  });
-}
-export {
-  runHookProcess,
-  runPayProcess
-};