@tempoxyz/patron 0.0.0-stage → 0.0.10

package/dist/chunks/chunk-6TTNL3HT.js

@@ -0,0 +1,214 @@
+import { createRequire as __patronCreateRequire } from 'node:module'
+const require = __patronCreateRequire(import.meta.url)
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/state.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } 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((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 });
+}
+
+// src/state.ts
+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"),
+    refillLock: join(home, "refill.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(path, contents) {
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, contents, { mode: 384 });
+  await chmod(temporary, 384);
+  await rename(temporary, path);
+}
+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" ? "key" : "tempo",
+    ...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 };
+}
+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)
+  };
+}
+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 buying seals. 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;
+  });
+}
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  withLock,
+  tryLock,
+  AGENT_IDS,
+  statePaths,
+  ensureHome,
+  readJson,
+  writePrivateFile,
+  readConfig,
+  writeConfig,
+  readUsage,
+  updateUsage
+};