taximeter 0.1.0

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+import {
+  Ledger,
+  budgetSchema,
+  closeProxy,
+  countsAsSpend,
+  createProxy,
+  diagnosticSchema,
+  expandPath,
+  formatAmount,
+  httpUrlSchema,
+  integerStringSchema,
+  labelSchema,
+  loadConfig,
+  matchesAsset,
+  paymentEventSchema,
+  portInputSchema,
+  spentForBudget,
+  toCsv,
+  toInvoice,
+  toJson,
+  totalSchema,
+  totals
+} from "../chunk-I7YXGTRZ.js";
+
+// src/cli/index.ts
+import { CommanderError } from "commander";
+
+// src/cli/program.ts
+import { existsSync as existsSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { Command } from "commander";
+import { z as z4 } from "zod";
+
+// src/server/lifecycle.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { z as z3 } from "zod";
+
+// src/server/index.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { createServer } from "http";
+import { dirname, extname, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { z as z2 } from "zod";
+
+// src/server/schema.ts
+import { z } from "zod";
+var dashboardEventSchema = paymentEventSchema.omit({ raw: true });
+var groupSchema = totalSchema.extend({ key: z.string().nullable() });
+var dashboardStateSchema = z.object({
+  version: z.literal("0.1.0"),
+  generatedAt: z.iso.datetime(),
+  totalEvents: z.number().int(),
+  blockedEvents: z.number().int(),
+  unknownEvents: z.number().int(),
+  totals: z.array(totalSchema),
+  events: z.array(dashboardEventSchema),
+  diagnostics: z.array(diagnosticSchema),
+  groups: z.object({
+    task: z.array(groupSchema),
+    agent: z.array(groupSchema),
+    host: z.array(groupSchema)
+  }),
+  hours: z.array(z.object({ ts: z.iso.datetime(), totals: z.array(totalSchema) })),
+  globalBudget: budgetSchema.nullable(),
+  budgets: z.array(
+    z.object({
+      network: z.string(),
+      asset: z.string(),
+      limit: integerStringSchema,
+      spent: integerStringSchema,
+      remaining: integerStringSchema,
+      window: z.string().nullable()
+    })
+  ),
+  proxy: z.object({ port: z.number().int(), upstream: z.string().optional() })
+});
+
+// src/server/state.ts
+function groups(events, field) {
+  const groups2 = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const key = event[field] ?? null;
+    const members = groups2.get(key) ?? [];
+    members.push(event);
+    groups2.set(key, members);
+  }
+  return [...groups2].flatMap(
+    ([key, members]) => totals(members).map((total) => ({ key, ...total }))
+  );
+}
+function dashboardState(ledger, config, now = Date.now()) {
+  const events = ledger.view();
+  const total = totals(events);
+  const budget = config.budgets.global;
+  const budgets = budget ? total.filter(
+    (total2) => matchesAsset(budget.asset, total2) && (!budget.network || budget.network === total2.network)
+  ).map((total2) => {
+    const representative = events.find(
+      (event) => event.network === total2.network && event.asset.toLowerCase() === total2.asset
+    );
+    const spent = representative ? spentForBudget(representative, events, budget, "global", now) : "0";
+    const remaining = BigInt(budget.amount) - BigInt(spent);
+    return {
+      network: total2.network,
+      asset: total2.asset,
+      limit: budget.amount,
+      spent,
+      remaining: (remaining < 0n ? 0n : remaining).toString(),
+      window: budget.window ?? null
+    };
+  }) : [];
+  const hour = new Date(now);
+  hour.setUTCMinutes(0, 0, 0);
+  const hours = Array.from({ length: 24 }, (_, index) => {
+    const start = hour.getTime() - (23 - index) * 36e5;
+    const rows = events.filter((event) => {
+      const ts = Date.parse(event.attemptedAt ?? event.ts);
+      return ts >= start && ts < start + 36e5 && ts <= now;
+    });
+    return { ts: new Date(start).toISOString(), totals: totals(rows) };
+  });
+  return dashboardStateSchema.parse({
+    version: "0.1.0",
+    generatedAt: new Date(now).toISOString(),
+    totalEvents: events.length,
+    blockedEvents: events.filter((event) => event.status === "blocked").length,
+    unknownEvents: events.filter(
+      (event) => countsAsSpend(event) && event.settlementStatus === "unknown"
+    ).length,
+    totals: total,
+    events: [...events].reverse().slice(0, 30).map(({ raw: _raw, ...event }) => event),
+    diagnostics: ledger.diagnostics().slice(-10).reverse(),
+    groups: {
+      task: groups(events, "taskId"),
+      agent: groups(events, "agentId"),
+      host: groups(events, "host")
+    },
+    hours,
+    globalBudget: budget,
+    budgets,
+    proxy: { port: config.ports.proxy, upstream: config.upstream }
+  });
+}
+
+// src/server/index.ts
+var querySchema = z2.strictObject({ format: z2.enum(["csv", "json", "invoice"]).optional() });
+var types = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2"
+};
+function uiDirectory() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return [resolve(here, "ui"), resolve(here, "../ui"), resolve(here, "../../dist/ui")].find(
+    (path) => existsSync(resolve(path, "index.html"))
+  ) ?? resolve(here, "ui");
+}
+function json(response, status, value) {
+  response.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+  response.end(JSON.stringify(value));
+}
+function createDashboard(options2) {
+  const root = resolve(options2.uiRoot ?? uiDirectory());
+  return createServer((request, response) => {
+    response.setHeader(
+      "Content-Security-Policy",
+      "default-src 'self'; connect-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; frame-ancestors 'none'; base-uri 'none'; object-src 'none'"
+    );
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    response.setHeader("Referrer-Policy", "no-referrer");
+    try {
+      const input = z2.object({
+        method: z2.string(),
+        url: z2.string(),
+        headers: z2.object({
+          host: z2.string(),
+          origin: z2.string().optional(),
+          "sec-fetch-site": z2.string().optional()
+        })
+      }).parse(request);
+      const localPort = request.socket.localPort;
+      const allowed = [`127.0.0.1:${localPort}`, `localhost:${localPort}`];
+      if (!allowed.includes(input.headers.host.toLowerCase()) || input.headers.origin && !allowed.map((host) => `http://${host}`).includes(input.headers.origin) || input.headers["sec-fetch-site"] === "cross-site") {
+        json(response, 403, { error: "local_origin_required" });
+        return;
+      }
+      if (!["GET", "HEAD"].includes(input.method)) {
+        response.setHeader("Allow", "GET, HEAD");
+        json(response, 405, { error: "read_only" });
+        return;
+      }
+      const url = new URL(input.url, `http://${input.headers.host}`);
+      if (url.origin !== `http://${input.headers.host}`) {
+        json(response, 400, { error: "invalid_request" });
+        return;
+      }
+      const entries = [...url.searchParams];
+      if (new Set(entries.map(([key]) => key)).size !== entries.length) {
+        json(response, 400, { error: "invalid_request" });
+        return;
+      }
+      const query = querySchema.parse(Object.fromEntries(entries));
+      if (url.pathname === "/api/summary") {
+        json(response, 200, dashboardState(options2.ledger, options2.config));
+        return;
+      }
+      if (url.pathname === "/api/export") {
+        const format = query.format ?? "json";
+        const events = options2.ledger.view();
+        const body = format === "csv" ? toCsv(events) : format === "invoice" ? toInvoice(events) : toJson(events);
+        response.writeHead(200, {
+          "Content-Type": format === "csv" ? "text/csv; charset=utf-8" : format === "invoice" ? "text/html; charset=utf-8" : "application/json",
+          "Cache-Control": "no-store",
+          "Content-Disposition": `attachment; filename="taximeter.${format === "invoice" ? "html" : format}"`
+        });
+        response.end(body);
+        return;
+      }
+      const decoded = decodeURIComponent(url.pathname);
+      const path = resolve(root, `.${decoded === "/" ? "/index.html" : decoded}`);
+      if (!path.startsWith(`${root}${sep}`)) {
+        json(response, 403, { error: "forbidden" });
+        return;
+      }
+      if (!existsSync(path) || !statSync(path).isFile() || !types[extname(path)]) {
+        if (url.pathname === "/" && !existsSync(resolve(root, "index.html"))) {
+          response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          response.end(
+            "<!doctype html><title>Taximeter</title><h1>Taximeter</h1><p>The local ledger is ready. Contributors: run npm run build to build the dashboard.</p>"
+          );
+          return;
+        }
+        json(response, 404, { error: "not_found" });
+        return;
+      }
+      response.writeHead(200, {
+        "Content-Type": types[extname(path)],
+        "Cache-Control": path.endsWith("index.html") ? "no-cache" : "public, max-age=31536000, immutable"
+      });
+      response.end(readFileSync(path));
+    } catch {
+      json(response, 400, { error: "invalid_request" });
+    }
+  });
+}
+
+// src/server/lifecycle.ts
+async function listenLocal(server, port2) {
+  await new Promise((resolve3, reject) => {
+    server.once("error", reject);
+    server.listen(port2, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve3();
+    });
+  });
+  return z3.object({ port: z3.number() }).parse(server.address()).port;
+}
+function assertStopped(db) {
+  if (db === ":memory:") return;
+  const path = `${db}.lock`;
+  if (!existsSync2(path)) return;
+  const lock = z3.object({ pid: z3.number().int().positive() }).parse(JSON.parse(readFileSync2(path, "utf8")));
+  try {
+    process.kill(lock.pid, 0);
+  } catch (error) {
+    if (z3.object({ code: z3.literal("ESRCH") }).safeParse(error).success) {
+      unlinkSync(path);
+      return;
+    }
+    throw new Error("Cannot determine whether the ledger is in use.");
+  }
+  throw new Error("Taximeter is already running for this ledger. Stop it first.");
+}
+function acquireLock(db) {
+  if (db === ":memory:") return () => {
+  };
+  assertStopped(db);
+  const lock = `${db}.lock`;
+  writeFileSync(lock, JSON.stringify({ pid: process.pid }), { flag: "wx", mode: 384 });
+  return () => unlinkSync(lock);
+}
+async function startServices(input) {
+  const config = { ...input, ports: { ...input.ports }, db: expandPath(input.db) };
+  assertStopped(config.db);
+  const ledger = new Ledger(config.db);
+  let release;
+  try {
+    release = acquireLock(config.db);
+  } catch (error) {
+    ledger.close();
+    throw error;
+  }
+  const proxy = createProxy({ ledger, config });
+  const dashboard = createDashboard({ ledger, config });
+  try {
+    const proxyPort = await listenLocal(proxy, config.ports.proxy);
+    config.ports.proxy = proxyPort;
+    const dashboardPort = await listenLocal(dashboard, config.ports.dashboard);
+    let closed = false;
+    return {
+      ledger,
+      proxy,
+      dashboard,
+      proxyPort,
+      dashboardPort,
+      async close() {
+        if (closed) return;
+        closed = true;
+        dashboard.closeAllConnections();
+        await Promise.all([
+          closeProxy(proxy),
+          new Promise((resolve3) => dashboard.close(() => resolve3()))
+        ]);
+        ledger.close();
+        release();
+      }
+    };
+  } catch (error) {
+    if (proxy.listening) await closeProxy(proxy);
+    if (dashboard.listening) dashboard.close();
+    ledger.close();
+    release();
+    throw error;
+  }
+}
+
+// src/cli/program.ts
+var common = z4.strictObject({ db: z4.string().optional(), config: z4.string().optional() });
+var port = portInputSchema.optional();
+var startFlags = common.extend({
+  proxyPort: port,
+  dashboardPort: port,
+  upstream: httpUrlSchema.optional()
+});
+var reportFlags = common.extend({
+  json: z4.boolean().optional(),
+  task: labelSchema.optional(),
+  agent: labelSchema.optional(),
+  host: labelSchema.optional()
+});
+var exportFlags = common.extend({
+  json: z4.string().min(1).optional(),
+  csv: z4.string().min(1).optional(),
+  invoice: z4.string().min(1).optional()
+}).refine(
+  (flags) => [flags.json, flags.csv, flags.invoice].filter(Boolean).length <= 1,
+  "Choose one export format"
+);
+var resetFlags = common.extend({ yes: z4.boolean().default(false) });
+function options(command) {
+  return command.option("--db <path>", "SQLite ledger path").option("--config <path>", "Explicit config file");
+}
+function configFrom(flags) {
+  return loadConfig(flags.db ? { db: flags.db } : {}, { configFile: flags.config });
+}
+async function runCli(input, output = (text) => process.stdout.write(text)) {
+  const argv = z4.array(z4.string()).parse(input);
+  const program = new Command().name("taximeter").description("A taximeter for your AI agents.").version("0.1.0").exitOverride();
+  program.configureOutput({ writeOut: output, writeErr: (text) => process.stderr.write(text) });
+  options(program.command("start").description("Start the local proxy and dashboard")).option("--proxy-port <port>", "Proxy port (0 selects an available port)").option("--dashboard-port <port>", "Dashboard port").option("--upstream <url>", "Forward origin-form requests to this HTTP(S) upstream").action(async (raw) => {
+    const flags = startFlags.parse(raw);
+    const config = loadConfig(
+      {
+        ...flags.db ? { db: flags.db } : {},
+        ...flags.upstream ? { upstream: flags.upstream } : {},
+        ports: {
+          ...flags.proxyPort !== void 0 ? { proxy: flags.proxyPort } : {},
+          ...flags.dashboardPort !== void 0 ? { dashboard: flags.dashboardPort } : {}
+        }
+      },
+      { configFile: flags.config }
+    );
+    const running = await startServices(config);
+    output(
+      `Taximeter 0.1.0
+Proxy: http://127.0.0.1:${running.proxyPort}
+Dashboard: http://127.0.0.1:${running.dashboardPort}
+Point an HTTP-proxy-aware agent at http://127.0.0.1:${running.proxyPort}.
+HTTPS CONNECT is unmetered; use --upstream or withMeter for HTTPS payments.
+`
+    );
+    const shutdown = () => {
+      process.off("SIGINT", shutdown);
+      process.off("SIGTERM", shutdown);
+      void running.close().catch(() => {
+        process.exitCode = 1;
+      });
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+  options(
+    program.command("report").description("Print exact totals, separately per network and asset")
+  ).option("--json", "Machine-readable integer-string totals").option("--task <id>", "Filter by task").option("--agent <id>", "Filter by agent").option("--host <host>", "Filter by host").action((raw) => {
+    const flags = reportFlags.parse(raw);
+    const db = configFrom(flags).db;
+    const ledger = new Ledger(existsSync3(db) ? db : ":memory:");
+    try {
+      const events = ledger.view().filter(
+        (event) => (!flags.task || event.taskId === flags.task) && (!flags.agent || event.agentId === flags.agent) && (!flags.host || event.host === flags.host)
+      );
+      const total = totals(events);
+      if (flags.json) output(`${JSON.stringify(total, null, 2)}
+`);
+      else
+        output(
+          total.length ? `${total.map((item) => `${item.decimalsKnown ? formatAmount(item.amount, item.decimals) : item.amount} ${item.assetSymbol ?? `${item.asset} atomic units`} | ${item.network} | ${item.unknownAmount} atomic units uncertain`).join("\n")}
+` : "No payments recorded.\n"
+        );
+    } finally {
+      ledger.close();
+    }
+  });
+  options(program.command("export").description("Export the local ledger")).option("--json <file>", "Write JSON to a new file (default: stdout)").option("--csv <file>", "Write CSV with exact counted and authorized amounts").option("--invoice <file>", "Write a printable HTML payment statement").action((raw) => {
+    const flags = exportFlags.parse(raw);
+    const db = configFrom(flags).db;
+    const ledger = new Ledger(existsSync3(db) ? db : ":memory:");
+    try {
+      const events = ledger.view();
+      const data = flags.csv ? toCsv(events) : flags.invoice ? toInvoice(events) : toJson(events);
+      const file = flags.csv ?? flags.invoice ?? flags.json;
+      if (file) {
+        writeFileSync2(resolve2(file), data, { flag: "wx", mode: 384 });
+        output(`Exported ${resolve2(file)}
+`);
+      } else output(data);
+    } finally {
+      ledger.close();
+    }
+  });
+  options(
+    program.command("reset").description("Archive the current ledger after all writers have stopped")
+  ).option("--yes", "Confirm archiving the current ledger").action((raw) => {
+    const flags = resetFlags.parse(raw);
+    if (!flags.yes)
+      throw new Error(
+        "Stop all Taximeter and SDK instances, then run taximeter reset --yes to archive the ledger."
+      );
+    const { db } = configFrom(flags);
+    assertStopped(db);
+    if (!existsSync3(db)) {
+      output("No ledger to archive.\n");
+      return;
+    }
+    const release = acquireLock(db);
+    try {
+      const ledger = new Ledger(db);
+      ledger.close();
+      const archive = `${db.endsWith(".db") ? db.slice(0, -3) : db}.archive-${Date.now()}.db`;
+      if (existsSync3(archive)) throw new Error("Archive path already exists; retry later.");
+      renameSync(db, archive);
+      for (const suffix of ["-wal", "-shm"])
+        if (existsSync3(`${db}${suffix}`)) renameSync(`${db}${suffix}`, `${archive}${suffix}`);
+      output(`Archived ${archive}
+`);
+    } finally {
+      release();
+    }
+  });
+  options(
+    program.command("doctor").description("Check local config and SQLite without network requests")
+  ).action((raw) => {
+    const config = configFrom(common.parse(raw));
+    const ledger = new Ledger(existsSync3(config.db) ? config.db : ":memory:");
+    try {
+      output(
+        `Configuration: valid
+SQLite: ready (${ledger.events().length} events)
+Ledger: ${config.db}
+Listener binding: 127.0.0.1
+HTTPS CONNECT: unmetered
+Network checks: none
+`
+      );
+    } finally {
+      ledger.close();
+    }
+  });
+  await program.parseAsync(argv, { from: "user" });
+}
+
+// src/cli/index.ts
+runCli(process.argv.slice(2)).catch((error) => {
+  if (error instanceof CommanderError && error.exitCode === 0) return;
+  if (!(error instanceof CommanderError))
+    process.stderr.write(
+      `Taximeter: ${error instanceof Error ? error.message : "command failed"}
+`
+    );
+  process.exitCode = 1;
+});