burnrate-cli 0.0.0-stage → 0.1.0

package/dist/pricing.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import path from "node:path";
+export const WEB_SEARCH_USD = 10 / 1000;
+export const BUILTIN_PRICES = {
+    // Anthropic — Claude 5 family
+    "claude-fable-5-1": { input: 10, output: 50, cacheRead: 0.25 },
+    "claude-mythos-5-1": { input: 10, output: 50, cacheRead: 0.25 },
+    "claude-fable-5": { input: 10, output: 50, cacheRead: 1 },
+    "claude-mythos-5": { input: 10, output: 50, cacheRead: 1 },
+    "claude-opus-5-5": { input: 4, output: 20, cacheRead: 0.2 },
+    "claude-opus-5": { input: 5, output: 25, cacheRead: 0.5 },
+    "claude-sonnet-5-5": { input: 2, output: 10, cacheRead: 0.2 },
+    "claude-sonnet-5": { input: 2, output: 10, cacheRead: 0.2 },
+    "claude-haiku-5-5": { input: 0.1, output: 0.5, cacheRead: 0.01 },
+    // Anthropic — Claude 4 family
+    "claude-opus-4-8": { input: 5, output: 25, cacheRead: 0.5 },
+    "claude-opus-4-7": { input: 5, output: 25, cacheRead: 0.5 },
+    "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5 },
+    "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5 },
+    "claude-opus-4-1": { input: 15, output: 75, cacheRead: 1.5 },
+    "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5 },
+    "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3 },
+    "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3 },
+    "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3 },
+    "claude-3-7-sonnet": { input: 3, output: 15, cacheRead: 0.3 },
+    "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1 },
+    "claude-3-5-haiku": { input: 0.8, output: 4, cacheRead: 0.08 },
+    // OpenAI — models used by Codex CLI (cached input = cacheRead)
+    "gpt-5-codex": { input: 1.25, output: 10, cacheRead: 0.125 },
+    "gpt-5.1-codex": { input: 1.25, output: 10, cacheRead: 0.125 },
+    "gpt-5.1": { input: 1.25, output: 10, cacheRead: 0.125 },
+    "gpt-5-mini": { input: 0.25, output: 2, cacheRead: 0.025 },
+    "gpt-5-nano": { input: 0.05, output: 0.4, cacheRead: 0.005 },
+    "gpt-5": { input: 1.25, output: 10, cacheRead: 0.125 },
+    "o4-mini": { input: 1.1, output: 4.4, cacheRead: 0.275 },
+    "o3": { input: 2, output: 8, cacheRead: 0.5 },
+    "gpt-4.1": { input: 2, output: 8, cacheRead: 0.5 },
+};
+export class PriceBook {
+    table;
+    keys;
+    cache = new Map();
+    constructor(overrides = {}) {
+        this.table = { ...BUILTIN_PRICES, ...overrides };
+        // Longest key first so "gpt-5-codex" wins over "gpt-5".
+        this.keys = Object.keys(this.table).sort((a, b) => b.length - a.length);
+    }
+    static load(dir) {
+        const file = path.join(dir, "prices.json");
+        try {
+            return new PriceBook(JSON.parse(fs.readFileSync(file, "utf8")));
+        }
+        catch {
+            return new PriceBook();
+        }
+    }
+    lookup(model) {
+        if (this.cache.has(model))
+            return this.cache.get(model);
+        const m = model.toLowerCase().replace(/^(anthropic\.|us\.anthropic\.|openai\/)/, "").replace(/@.*$/, "");
+        let found = this.table[m] ?? null;
+        if (!found) {
+            const k = this.keys.find((key) => m.startsWith(key) || m.startsWith(key + "-"));
+            found = k ? this.table[k] : null;
+        }
+        this.cache.set(model, found);
+        return found;
+    }
+    /** USD cost of one event; null when the model is unpriced. */
+    cost(e) {
+        const p = this.lookup(e.model);
+        if (!p)
+            return null;
+        const w5 = p.cacheWrite5m ?? p.input * 1.25;
+        const w1h = p.cacheWrite1h ?? p.input * 2;
+        return ((e.input * p.input +
+            e.output * p.output +
+            e.cacheRead * p.cacheRead +
+            e.cacheWrite5m * w5 +
+            e.cacheWrite1h * w1h) /
+            1e6 +
+            e.webSearches * WEB_SEARCH_USD);
+    }
+}

package/dist/server.js

@@ -0,0 +1,99 @@
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { summarize } from "./aggregate.js";
+import { loadConfig, PLAN_PRESETS, saveConfig } from "./config.js";
+import { PriceBook } from "./pricing.js";
+import { Store } from "./store.js";
+const here = path.dirname(fileURLToPath(import.meta.url));
+const ASSETS = {
+    "/": "index.html",
+    "/index.html": "index.html",
+    "/app.js": "app.js",
+    "/styles.css": "styles.css",
+    "/favicon.svg": "favicon.svg",
+};
+const TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+};
+function send(res, status, body, type = "application/json") {
+    res.writeHead(status, {
+        "Content-Type": type,
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+        "Content-Security-Policy": "default-src 'self'; img-src 'self' data:; style-src 'self'; script-src 'self'",
+        "Referrer-Policy": "no-referrer",
+    });
+    res.end(body);
+}
+function readBody(req, limit = 64 * 1024) {
+    return new Promise((resolve, reject) => {
+        let size = 0;
+        const chunks = [];
+        req.on("data", (c) => {
+            size += c.length;
+            if (size > limit) {
+                reject(new Error("too large"));
+                req.destroy();
+            }
+            else
+                chunks.push(c);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+const num = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined);
+export function createServer(opts) {
+    const store = new Store(opts.dataDir).load();
+    let lastScan = 0;
+    const allowedHosts = new Set([`127.0.0.1:${opts.port}`, `localhost:${opts.port}`, `[::1]:${opts.port}`]);
+    return http.createServer(async (req, res) => {
+        try {
+            // DNS-rebinding protection: only answer to localhost host headers.
+            if (!req.headers.host || !allowedHosts.has(req.headers.host))
+                return send(res, 403, '{"error":"forbidden host"}');
+            const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+            if (req.method === "GET" && ASSETS[url.pathname]) {
+                const file = path.join(here, "dashboard", ASSETS[url.pathname]);
+                return send(res, 200, fs.readFileSync(file), TYPES[path.extname(file)]);
+            }
+            if (req.method === "GET" && url.pathname === "/api/summary") {
+                if (Date.now() - lastScan > 2000) {
+                    store.scan({ extraPaths: opts.extraPaths, titles: opts.titles, defaults: opts.defaults });
+                    lastScan = Date.now();
+                }
+                const days = Math.min(Math.max(Number(url.searchParams.get("days")) || 30, 1), 365);
+                const cfg = loadConfig(opts.dataDir);
+                const s = summarize(store.events, store.meta.sessions, store.meta.limits, store.meta.rateLimits, cfg, PriceBook.load(opts.dataDir), { days });
+                return send(res, 200, JSON.stringify({ ...s, config: cfg, planPresets: PLAN_PRESETS }));
+            }
+            if (req.method === "POST" && url.pathname === "/api/config") {
+                // CSRF: require same-origin JSON.
+                const origin = req.headers.origin;
+                if (!origin || !allowedHosts.has(new URL(origin).host) || !String(req.headers["content-type"]).startsWith("application/json")) {
+                    return send(res, 403, '{"error":"forbidden"}');
+                }
+                const body = JSON.parse(await readBody(req));
+                const cfg = loadConfig(opts.dataDir);
+                if (body.budgets && typeof body.budgets === "object") {
+                    cfg.budgets = { blockUsd: num(body.budgets.blockUsd), weekUsd: num(body.budgets.weekUsd), monthUsd: num(body.budgets.monthUsd) };
+                }
+                if ("plan" in body) {
+                    const p = body.plan;
+                    cfg.plan = p && typeof p.name === "string" && num(p.monthlyUsd) ? { name: p.name.slice(0, 40), monthlyUsd: num(p.monthlyUsd) } : undefined;
+                }
+                saveConfig(opts.dataDir, cfg);
+                return send(res, 200, JSON.stringify({ ok: true, config: cfg }));
+            }
+            send(res, 404, '{"error":"not found"}');
+        }
+        catch (err) {
+            send(res, 500, JSON.stringify({ error: err instanceof Error ? err.message : "error" }));
+        }
+    });
+}

package/dist/store.js

@@ -0,0 +1,216 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseClaudeLine } from "./parsers/claude.js";
+import { parseCodexLine } from "./parsers/codex.js";
+import { logRoots } from "./paths.js";
+const STATE_VERSION = 1;
+function walk(dir, out = []) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory())
+            walk(p, out);
+        else if (e.isFile() && e.name.endsWith(".jsonl"))
+            out.push(p);
+    }
+    return out;
+}
+/**
+ * Append-only local store in ~/.burnrate:
+ *   events.ndjson  one UsageEvent per line (unique by key)
+ *   state.json     per-file byte offsets for incremental parsing
+ *   meta.json      sessions, limit hits, latest rate-limit snapshots
+ */
+export class Store {
+    dir;
+    eventsFile;
+    stateFile;
+    metaFile;
+    files = {};
+    meta = { sessions: {}, limits: [], rateLimits: {} };
+    events = [];
+    keys = new Set();
+    constructor(dir) {
+        this.dir = dir;
+        this.eventsFile = path.join(dir, "events.ndjson");
+        this.stateFile = path.join(dir, "state.json");
+        this.metaFile = path.join(dir, "meta.json");
+    }
+    load() {
+        fs.mkdirSync(this.dir, { recursive: true });
+        try {
+            const s = JSON.parse(fs.readFileSync(this.stateFile, "utf8"));
+            if (s.version === STATE_VERSION)
+                this.files = s.files ?? {};
+        }
+        catch {
+            /* fresh */
+        }
+        try {
+            this.meta = { sessions: {}, limits: [], rateLimits: {}, ...JSON.parse(fs.readFileSync(this.metaFile, "utf8")) };
+        }
+        catch {
+            /* fresh */
+        }
+        if (!Object.keys(this.files).length) {
+            // No state → rebuild events from scratch to stay consistent.
+            fs.rmSync(this.eventsFile, { force: true });
+            this.meta = { sessions: {}, limits: [], rateLimits: {} };
+        }
+        try {
+            for (const line of fs.readFileSync(this.eventsFile, "utf8").split("\n")) {
+                if (!line)
+                    continue;
+                try {
+                    const e = JSON.parse(line);
+                    if (!this.keys.has(e.key)) {
+                        this.keys.add(e.key);
+                        this.events.push(e);
+                    }
+                }
+                catch {
+                    /* skip torn line */
+                }
+            }
+        }
+        catch {
+            /* no events yet */
+        }
+        return this;
+    }
+    apply(rec, fresh) {
+        switch (rec.kind) {
+            case "usage":
+                if (!this.keys.has(rec.event.key)) {
+                    this.keys.add(rec.event.key);
+                    this.events.push(rec.event);
+                    fresh.push(rec.event);
+                }
+                break;
+            case "session": {
+                const cur = this.meta.sessions[rec.session];
+                if (!cur) {
+                    this.meta.sessions[rec.session] = {
+                        agent: rec.meta.agent,
+                        title: rec.meta.title ?? null,
+                        project: rec.meta.project ?? "",
+                        firstTs: rec.meta.firstTs ?? Date.now(),
+                    };
+                }
+                else {
+                    if (!cur.title && rec.meta.title)
+                        cur.title = rec.meta.title;
+                    if (!cur.project && rec.meta.project)
+                        cur.project = rec.meta.project;
+                    if (rec.meta.firstTs && Number.isFinite(rec.meta.firstTs) && rec.meta.firstTs < cur.firstTs)
+                        cur.firstTs = rec.meta.firstTs;
+                }
+                break;
+            }
+            case "limit": {
+                const dup = this.meta.limits.some((l) => l.agent === rec.hit.agent && Math.abs(l.ts - rec.hit.ts) < 60_000);
+                if (!dup)
+                    this.meta.limits.push(rec.hit);
+                break;
+            }
+            case "ratelimit": {
+                const cur = this.meta.rateLimits[rec.snapshot.agent];
+                if (!cur || rec.snapshot.ts >= cur.ts)
+                    this.meta.rateLimits[rec.snapshot.agent] = rec.snapshot;
+                break;
+            }
+        }
+    }
+    readFile(root, file, fresh, titles) {
+        let st;
+        try {
+            st = fs.statSync(file);
+        }
+        catch {
+            return;
+        }
+        let fs0 = this.files[file];
+        if (fs0 && st.size === fs0.size && st.mtimeMs === fs0.mtimeMs)
+            return;
+        if (!fs0 || st.size < fs0.offset)
+            fs0 = { size: 0, mtimeMs: 0, offset: 0 };
+        if (root.agent === "codex" && !fs0.codex)
+            fs0.codex = { session: path.basename(file, ".jsonl"), project: "", model: "" };
+        const fd = fs.openSync(file, "r");
+        const CHUNK = 8 * 1024 * 1024;
+        let offset = fs0.offset;
+        let carry = Buffer.alloc(0);
+        try {
+            while (offset + carry.length < st.size) {
+                const want = Math.min(CHUNK, st.size - offset - carry.length);
+                const chunk = Buffer.alloc(want);
+                const read = fs.readSync(fd, chunk, 0, want, offset + carry.length);
+                if (read <= 0)
+                    break;
+                const buf = carry.length ? Buffer.concat([carry, chunk.subarray(0, read)]) : chunk.subarray(0, read);
+                const lastNl = buf.lastIndexOf(0x0a);
+                if (lastNl === -1) {
+                    carry = buf;
+                    continue;
+                }
+                let pos = 0;
+                while (pos <= lastNl) {
+                    const nl = buf.indexOf(0x0a, pos);
+                    const line = buf.subarray(pos, nl).toString("utf8");
+                    const lineOffset = offset + pos;
+                    pos = nl + 1;
+                    if (!line.trim())
+                        continue;
+                    const recs = root.agent === "codex" ? parseCodexLine(line, file, lineOffset, fs0.codex) : parseClaudeLine(line, file);
+                    for (const r of recs) {
+                        if (!titles && r.kind === "session")
+                            r.meta.title = undefined;
+                        this.apply(r, fresh);
+                    }
+                }
+                offset += lastNl + 1;
+                carry = Buffer.from(buf.subarray(lastNl + 1));
+            }
+            // Only complete lines are consumed; a partial trailing line is re-read next scan.
+            this.files[file] = { ...fs0, size: st.size, mtimeMs: st.mtimeMs, offset };
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    scan(opts = {}) {
+        const fresh = [];
+        const roots = logRoots(opts.extraPaths, opts.defaults !== false);
+        const summary = [];
+        let filesScanned = 0;
+        for (const root of roots) {
+            const files = walk(root.dir);
+            if (files.length)
+                summary.push({ agent: root.agent, dir: root.dir, files: files.length });
+            for (const f of files) {
+                this.readFile(root, f, fresh, opts.titles !== false);
+                filesScanned++;
+            }
+        }
+        if (fresh.length)
+            fs.appendFileSync(this.eventsFile, fresh.map((e) => JSON.stringify(e)).join("\n") + "\n");
+        this.meta.limits.sort((a, b) => a.ts - b.ts);
+        fs.writeFileSync(this.stateFile, JSON.stringify({ version: STATE_VERSION, files: this.files }));
+        fs.writeFileSync(this.metaFile, JSON.stringify(this.meta));
+        return { filesScanned, newEvents: fresh.length, roots: summary };
+    }
+    reset() {
+        for (const f of [this.eventsFile, this.stateFile, this.metaFile])
+            fs.rmSync(f, { force: true });
+        this.files = {};
+        this.events = [];
+        this.keys.clear();
+        this.meta = { sessions: {}, limits: [], rateLimits: {} };
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "burnrate-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "See what your coding agents really cost \u2014 and when you'll hit the limit. Local, multi-agent spend & quota meter for Claude Code and Codex.",
+  "type": "module",
+  "bin": {
+    "burnrate": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-assets.mjs",
+    "dev": "npm run build && node dist/cli.js",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "ai",
+    "cost",
+    "usage",
+    "tokens",
+    "quota",
+    "cli",
+    "statusline"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.20.5",
+    "typescript": "^5.9.3",
+    "vitest": "^5.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pidoxy/burnrate.git"
+  },
+  "homepage": "https://github.com/pidoxy/burnrate#readme",
+  "bugs": {
+    "url": "https://github.com/pidoxy/burnrate/issues"
+  }
+}