tokmon 0.19.7 → 0.20.0

package/dist/chunk-STCMWCFW.js

@@ -1,564 +0,0 @@
-#!/usr/bin/env node
-import {
-  PROVIDERS,
-  buildAccounts,
-  cacheDir,
-  detectProviders,
-  resolveTimezone
-} from "./chunk-UAPL47GL.js";
-
-// src/web/server.ts
-import { createServer } from "http";
-
-// src/web/colors.ts
-var NAMED_HEX = {
-  green: "#6caa71",
-  greenBright: "#79be7e",
-  cyan: "#7ccbcd",
-  cyanBright: "#84dde0",
-  blue: "#6d96b4",
-  blueBright: "#67b5ed",
-  magenta: "#bd7bcd",
-  magentaBright: "#d389e5",
-  yellow: "#c4ac62",
-  yellowBright: "#d9c074",
-  red: "#b45648",
-  redBright: "#cf6a5a",
-  white: "#dee5eb",
-  whiteBright: "#f3f5f5",
-  gray: "#8d9090",
-  grey: "#8d9090"
-};
-var FALLBACK = "#8d9090";
-function namedHex(name) {
-  if (!name) return FALLBACK;
-  if (name.startsWith("#")) return name;
-  return NAMED_HEX[name] ?? FALLBACK;
-}
-function colorHex(accountColor, providerColorName) {
-  if (accountColor) {
-    if (accountColor.startsWith("#")) return accountColor;
-    const named = NAMED_HEX[accountColor];
-    if (named) return named;
-  }
-  return namedHex(providerColorName);
-}
-
-// src/web/data.ts
-async function resolveAccounts(config) {
-  const detected = await detectProviders();
-  const accounts = buildAccounts({ ...config, disabledProviders: [] }, detected);
-  return accounts.map((a) => {
-    const p = PROVIDERS[a.providerId];
-    return {
-      account: a,
-      hasUsage: p.hasUsage || !!p.fetchTable,
-      hasBilling: p.hasBilling,
-      color: colorHex(a.color, PROVIDERS[a.providerId].color)
-    };
-  });
-}
-async function fetchAccountSummary(account, tz) {
-  const p = PROVIDERS[account.providerId];
-  if (!p.fetchSummary) return null;
-  return p.fetchSummary(account, tz).catch(() => null);
-}
-async function fetchAccountTable(account, tz) {
-  const p = PROVIDERS[account.providerId];
-  if (!p.fetchTable) return null;
-  return p.fetchTable(account, tz).catch(() => null);
-}
-async function fetchAccountBilling(account) {
-  const p = PROVIDERS[account.providerId];
-  if (!p.fetchBilling) return null;
-  return p.fetchBilling(account).catch(() => null);
-}
-function assembleSnapshot(opts) {
-  const accounts = opts.resolved.map((r) => {
-    const u = opts.usage.get(r.account.id);
-    return {
-      id: r.account.id,
-      providerId: r.account.providerId,
-      name: r.account.name,
-      color: r.color,
-      hasUsage: r.hasUsage,
-      hasBilling: r.hasBilling,
-      dashboard: u?.dashboard ?? null,
-      table: u?.table ?? null,
-      billing: opts.billing.get(r.account.id) ?? null
-    };
-  });
-  const seen = /* @__PURE__ */ new Set();
-  const providers = [];
-  for (const r of opts.resolved) {
-    if (seen.has(r.account.providerId)) continue;
-    seen.add(r.account.providerId);
-    providers.push({
-      id: r.account.providerId,
-      name: PROVIDERS[r.account.providerId].name,
-      color: namedHex(PROVIDERS[r.account.providerId].color)
-    });
-  }
-  return {
-    version: opts.version,
-    generatedAt: Date.now(),
-    tz: opts.tz,
-    intervalMs: opts.intervalMs,
-    providers,
-    accounts
-  };
-}
-function tzFor(config) {
-  return resolveTimezone(config.timezone);
-}
-
-// src/web/static.ts
-import { createReadStream, existsSync, readFileSync } from "fs";
-import { stat } from "fs/promises";
-import { fileURLToPath } from "url";
-import { extname, join, normalize, sep } from "path";
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".map": "application/json; charset=utf-8",
-  ".webmanifest": "application/manifest+json"
-};
-function findWebRoot() {
-  const candidates = ["./web/", "../web/", "../dist/web/", "../../dist/web/"];
-  for (const rel of candidates) {
-    try {
-      const dir = fileURLToPath(new URL(rel, import.meta.url));
-      if (existsSync(join(dir, "index.html"))) return dir.replace(/[\\/]+$/, "");
-    } catch {
-    }
-  }
-  return null;
-}
-function resolveStaticPath(webRoot, urlPath) {
-  let clean;
-  try {
-    clean = decodeURIComponent(urlPath.split("?")[0]);
-  } catch {
-    return null;
-  }
-  const rel = normalize(clean).replace(/^(\.\.[/\\])+/, "").replace(/^[/\\]+/, "");
-  const full = join(webRoot, rel);
-  if (full !== webRoot && !full.startsWith(webRoot + sep)) return null;
-  return full;
-}
-function send(res, status, type, body) {
-  res.writeHead(status, { "Content-Type": type, "Cache-Control": "no-store" });
-  res.end(body);
-}
-function sendJson(res, status, data) {
-  send(res, status, "application/json; charset=utf-8", JSON.stringify(data));
-}
-function serveStatic(webRoot, urlPath, res) {
-  const path = urlPath.split("?")[0];
-  const filePath = resolveStaticPath(webRoot, path === "/" ? "/index.html" : path);
-  if (!filePath) {
-    send(res, 403, "text/plain", "forbidden");
-    return;
-  }
-  void stat(filePath).then((st) => {
-    if (st.isFile()) {
-      const type = MIME[extname(filePath).toLowerCase()] || "application/octet-stream";
-      const immutable = filePath.includes(`${sep}assets${sep}`);
-      res.writeHead(200, {
-        "Content-Type": type,
-        "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "no-cache"
-      });
-      createReadStream(filePath).pipe(res);
-    } else {
-      throw new Error("not a file");
-    }
-  }).catch(() => {
-    if (extname(path)) {
-      send(res, 404, "text/plain", "not found");
-      return;
-    }
-    const indexPath = join(webRoot, "index.html");
-    if (!existsSync(indexPath)) {
-      send(res, 404, "text/plain", "not found");
-      return;
-    }
-    res.writeHead(200, { "Content-Type": MIME[".html"], "Cache-Control": "no-cache" });
-    createReadStream(indexPath).on("error", () => {
-      try {
-        res.destroy();
-      } catch {
-      }
-    }).pipe(res);
-  });
-}
-function appVersion() {
-  for (const rel of ["../package.json", "../../package.json"]) {
-    try {
-      const p = fileURLToPath(new URL(rel, import.meta.url));
-      const pkg = JSON.parse(readFileSync(p, "utf-8"));
-      if (typeof pkg.version === "string") return pkg.version;
-    } catch {
-    }
-  }
-  return "";
-}
-
-// src/web/vite-dev.ts
-import { existsSync as existsSync2 } from "fs";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
-import { createRequire } from "module";
-import { join as join2 } from "path";
-function isDevMode() {
-  const forced = process.env.TOKMON_WEB_MODE;
-  if (forced === "dev") return true;
-  if (forced === "prod") return false;
-  return import.meta.url.includes("/src/");
-}
-function findWebSource() {
-  for (const rel of ["../../web/", "../web/", "./web/"]) {
-    try {
-      const dir = fileURLToPath2(new URL(rel, import.meta.url));
-      if (existsSync2(join2(dir, "vite.config.ts")) && existsSync2(join2(dir, "index.html"))) {
-        return dir.replace(/[\\/]+$/, "");
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-async function createViteDevServer(httpServer, log) {
-  const root = findWebSource();
-  if (!root) {
-    log("  \u26A0 dev mode: web/ source not found");
-    return null;
-  }
-  try {
-    const req = createRequire(pathToFileURL(join2(root, "package.json")).href);
-    const vitePath = req.resolve("vite");
-    const vite = await import(pathToFileURL(vitePath).href);
-    const dev = await vite.createServer({
-      root,
-      configFile: join2(root, "vite.config.ts"),
-      server: { middlewareMode: true, hmr: { server: httpServer } },
-      appType: "spa",
-      clearScreen: false,
-      logLevel: "warn"
-    });
-    log("  \u25C6 dev mode \u2014 Vite HMR attached (edit web/src and it hot-reloads)");
-    return dev;
-  } catch (e) {
-    log(`  \u26A0 couldn't start Vite dev server: ${e.message}`);
-    log("    run `pnpm --prefix web install` (or `npm run web:install`) for HMR, or `npm run build` for a static bundle");
-    return null;
-  }
-}
-var MISSING_BUILD_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>tokmon web</title>
-<style>body{background:#0a0d0e;color:#cdd6d8;font:14px ui-monospace,Menlo,monospace;padding:3rem;line-height:1.7}
-code{color:#e6b450}</style></head><body>
-<h1 style="color:#00d787">tokmon web</h1>
-<p>The dashboard isn't available.</p>
-<p><b>Prod:</b> run <code>npm run build</code> (builds <code>dist/web</code>), then <code>tokmon serve</code>.</p>
-<p><b>Dev:</b> run <code>pnpm --prefix web install</code> so the Vite dev server (HMR) can start.</p>
-</body></html>`;
-
-// src/web/data-engine.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-import { join as join3 } from "path";
-var TABLE_INTERVAL_MS = 3e5;
-var SSE_HEARTBEAT_MS = 25e3;
-var IDLE_PAUSE_MS = 6e4;
-var SNAPSHOT_CACHE_THROTTLE_MS = 2e4;
-var snapshotCacheFile = () => join3(cacheDir(), "web-snapshot.json");
-var sseFrame = (s) => `event: snapshot
-data: ${JSON.stringify(s)}
-
-`;
-function createDataEngine(opts) {
-  const { version, tz, summaryIntervalMs, billingIntervalMs, resolved } = opts;
-  const usage = /* @__PURE__ */ new Map();
-  const billing = /* @__PURE__ */ new Map();
-  let current = null;
-  let currentFrame = null;
-  const sseClients = /* @__PURE__ */ new Map();
-  let lastActivity = Date.now();
-  let stopped = false;
-  let summaryTimer;
-  let tableTimer;
-  let billingTimer;
-  let lastPersist = 0;
-  const idle = () => sseClients.size === 0 && Date.now() - lastActivity > IDLE_PAUSE_MS;
-  const usageEntry = (id) => {
-    let u = usage.get(id);
-    if (!u) {
-      u = { dashboard: null, table: null };
-      usage.set(id, u);
-    }
-    return u;
-  };
-  const hydrateFromCache = () => {
-    try {
-      const cached = JSON.parse(readFileSync2(snapshotCacheFile(), "utf-8"));
-      if (!cached || !Array.isArray(cached.accounts)) return;
-      for (const a of cached.accounts) {
-        if (a.dashboard || a.table) usage.set(a.id, { dashboard: a.dashboard, table: a.table });
-        if (a.billing) billing.set(a.id, a.billing);
-      }
-      current = assembleSnapshot({ version, tz, intervalMs: summaryIntervalMs, resolved, usage, billing });
-      currentFrame = sseFrame(current);
-    } catch {
-    }
-  };
-  const persist = () => {
-    if (!current) return;
-    if (!current.accounts.some((a) => a.hasUsage && a.table != null)) return;
-    if (Date.now() - lastPersist < SNAPSHOT_CACHE_THROTTLE_MS) return;
-    lastPersist = Date.now();
-    try {
-      mkdirSync(cacheDir(), { recursive: true });
-      writeFileSync(snapshotCacheFile(), JSON.stringify(current));
-    } catch {
-    }
-  };
-  const rebuild = () => {
-    if (stopped) return;
-    current = assembleSnapshot({ version, tz, intervalMs: summaryIntervalMs, resolved, usage, billing });
-    currentFrame = sseFrame(current);
-    persist();
-    if (sseClients.size === 0) return;
-    for (const res of sseClients.keys()) {
-      try {
-        res.write(currentFrame);
-      } catch {
-      }
-    }
-  };
-  const usageAccounts = resolved.filter((r) => r.hasUsage);
-  const billingAccounts = resolved.filter((r) => r.hasBilling);
-  let summaryBusy = false;
-  const refreshSummary = async (force = false) => {
-    if (stopped || summaryBusy || !force && idle()) return;
-    summaryBusy = true;
-    try {
-      for (const r of usageAccounts) {
-        if (stopped) return;
-        usageEntry(r.account.id).dashboard = await fetchAccountSummary(r.account, tz);
-      }
-      rebuild();
-    } finally {
-      summaryBusy = false;
-    }
-  };
-  let tableBusy = false;
-  const refreshTable = async (force = false) => {
-    if (stopped || tableBusy || !force && idle()) return;
-    tableBusy = true;
-    try {
-      for (const r of usageAccounts) {
-        if (stopped) return;
-        usageEntry(r.account.id).table = await fetchAccountTable(r.account, tz);
-      }
-      rebuild();
-    } finally {
-      tableBusy = false;
-    }
-  };
-  let billingBusy = false;
-  const refreshBilling = async (force = false) => {
-    if (stopped || billingBusy || !force && idle()) return;
-    billingBusy = true;
-    try {
-      for (const r of billingAccounts) {
-        if (stopped) return;
-        billing.set(r.account.id, await fetchAccountBilling(r.account));
-      }
-      rebuild();
-    } finally {
-      billingBusy = false;
-    }
-  };
-  hydrateFromCache();
-  return {
-    snapshot: () => current,
-    start() {
-      void refreshSummary(true);
-      void refreshTable(true);
-      void refreshBilling(true);
-      summaryTimer = setInterval(() => {
-        void refreshSummary();
-      }, summaryIntervalMs);
-      tableTimer = setInterval(() => {
-        void refreshTable();
-      }, TABLE_INTERVAL_MS);
-      billingTimer = setInterval(() => {
-        void refreshBilling();
-      }, billingIntervalMs);
-      summaryTimer.unref?.();
-      tableTimer.unref?.();
-      billingTimer.unref?.();
-    },
-    touch() {
-      lastActivity = Date.now();
-    },
-    addSseClient(res) {
-      res.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache, no-transform",
-        Connection: "keep-alive"
-      });
-      res.write("retry: 3000\n\n");
-      if (currentFrame) res.write(currentFrame);
-      const beat = setInterval(() => {
-        try {
-          res.write(": ping\n\n");
-        } catch {
-        }
-      }, SSE_HEARTBEAT_MS);
-      beat.unref?.();
-      sseClients.set(res, beat);
-      lastActivity = Date.now();
-      if (!current || Date.now() - current.generatedAt > summaryIntervalMs) {
-        void refreshSummary(true);
-        void refreshTable(true);
-      }
-      return () => {
-        clearInterval(beat);
-        sseClients.delete(res);
-      };
-    },
-    stop() {
-      stopped = true;
-      clearInterval(summaryTimer);
-      clearInterval(tableTimer);
-      clearInterval(billingTimer);
-      for (const [res, beat] of sseClients) {
-        clearInterval(beat);
-        try {
-          res.end();
-        } catch {
-        }
-      }
-      sseClients.clear();
-    }
-  };
-}
-
-// src/web/server.ts
-var HOST = "127.0.0.1";
-var DEFAULT_PORT = 4317;
-var MAX_PORT_TRIES = 20;
-var MIN_SUMMARY_INTERVAL_MS = 8e3;
-var BILLING_INTERVAL_FALLBACK_MIN = 5;
-function createRouter(engine, vite, webRoot) {
-  return (req, res) => {
-    const url = req.url || "/";
-    const path = url.split("?")[0];
-    if (path === "/api/data") {
-      engine.touch();
-      sendJson(res, 200, engine.snapshot() ?? { pending: true });
-      return;
-    }
-    if (path === "/healthz") {
-      sendJson(res, 200, { ok: true, ready: engine.snapshot() !== null });
-      return;
-    }
-    if (path === "/api/stream") {
-      const cleanup = engine.addSseClient(res);
-      req.on("close", cleanup);
-      return;
-    }
-    if (vite) {
-      vite.middlewares(req, res, () => {
-        send(res, 404, "text/plain", "not found");
-      });
-      return;
-    }
-    if (!webRoot) {
-      send(res, 503, "text/html; charset=utf-8", MISSING_BUILD_HTML);
-      return;
-    }
-    serveStatic(webRoot, url, res);
-  };
-}
-async function startWebServer(opts) {
-  const { config } = opts;
-  const tz = tzFor(config);
-  const version = appVersion();
-  const summaryIntervalMs = Math.max(MIN_SUMMARY_INTERVAL_MS, (config.interval || 2) * 1e3);
-  const billingIntervalMs = Math.max(1, config.billingInterval || BILLING_INTERVAL_FALLBACK_MIN) * 6e4;
-  const log = (msg) => {
-    if (opts.log) process.stdout.write(msg + "\n");
-  };
-  const resolved = await resolveAccounts(config);
-  const server = createServer();
-  let vite = null;
-  if (isDevMode()) vite = await createViteDevServer(server, log);
-  const webRoot = vite ? null : findWebRoot();
-  if (!vite && !webRoot) log("  \u26A0 no dashboard available \u2014 see the page for build/dev instructions");
-  const engine = createDataEngine({ version, tz, summaryIntervalMs, billingIntervalMs, resolved });
-  server.addListener("request", createRouter(engine, vite, webRoot));
-  const port = await listenWithFallback(server, opts.port ?? DEFAULT_PORT);
-  const serverUrl = `http://${HOST}:${port}`;
-  if (vite?.warmupRequest) {
-    try {
-      await Promise.race([vite.warmupRequest("/src/main.tsx"), delay(5e3)]);
-    } catch {
-    }
-  }
-  engine.start();
-  return {
-    url: serverUrl,
-    port,
-    snapshot: engine.snapshot,
-    stop: () => new Promise((resolve) => {
-      engine.stop();
-      const closeHttp = () => {
-        server.close(() => resolve());
-        server.closeAllConnections?.();
-      };
-      if (vite) vite.close().then(closeHttp, closeHttp);
-      else closeHttp();
-    })
-  };
-}
-function delay(ms) {
-  return new Promise((resolve) => {
-    const t = setTimeout(resolve, ms);
-    t.unref?.();
-  });
-}
-function listenWithFallback(server, startPort) {
-  return new Promise((resolve, reject) => {
-    let port = startPort;
-    let tries = 0;
-    const attempt = () => {
-      server.once("error", (err) => {
-        if (err.code === "EADDRINUSE" && tries < MAX_PORT_TRIES) {
-          tries++;
-          port++;
-          setImmediate(attempt);
-        } else {
-          reject(err);
-        }
-      });
-      server.listen(port, HOST, () => resolve(port));
-    };
-    attempt();
-  });
-}
-
-export {
-  startWebServer
-};

package/dist/server-VMB5ZLZC.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-import {
-  startWebServer
-} from "./chunk-STCMWCFW.js";
-import "./chunk-UAPL47GL.js";
-export {
-  startWebServer
-};