@cliftonc/finius 0.1.0

package/dist/server/index.js

@@ -0,0 +1,119 @@
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { banner, panel, pc } from "../branding.js";
+import { createApp } from "./app.js";
+import { EventBus } from "./events.js";
+import { normalizeLiteLlm } from "./pricing.js";
+import { githubSnapshot } from "./pricing-backfill.js";
+import { LocalBlobStore } from "./storage/blob.js";
+import { SqliteStorageAdapter } from "./storage/sqlite.js";
+// LiteLLM's community price feed: per-model input/output/cache token costs for Anthropic + OpenAI
+// (and many more). Override with FINIUS_PRICING_URL; disable the fetch with FINIUS_PRICING_FETCH=off.
+const DEFAULT_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+export function startServer(options = {}) {
+    const port = options.port ?? Number(process.env.PORT ?? 8787);
+    const hostname = options.hostname ?? process.env.FINIUS_HOST ?? "127.0.0.1";
+    const dbPath = options.dbPath ?? process.env.FINIUS_DB_PATH ?? "data/finius.sqlite";
+    const storeRawPayloads = options.storeRawPayloads ?? (process.env.FINIUS_RAW_PAYLOADS ?? "retain") !== "off";
+    const rawRetentionDaysRaw = options.rawRetentionDays ?? Number(process.env.FINIUS_RAW_RETENTION_DAYS ?? 7);
+    const rawRetentionDays = Number.isFinite(rawRetentionDaysRaw) ? rawRetentionDaysRaw : 7;
+    const blobDir = options.blobDir ?? process.env.FINIUS_BLOB_DIR;
+    const blob = blobDir ? new LocalBlobStore(resolve(blobDir)) : undefined;
+    const cronToken = options.cronToken ?? process.env.FINIUS_CRON_TOKEN;
+    const authSecret = options.authSecret ?? process.env.FINIUS_AUTH_PASSWORD;
+    const initialAuthToken = options.initialAuthToken;
+    const storage = new SqliteStorageAdapter(resolve(dbPath), { storeRawPayloads, blob });
+    if (authSecret && initialAuthToken)
+        seedInitialAuthToken(storage, initialAuthToken);
+    const events = new EventBus();
+    const app = createApp({ storage, events, cronToken, rawRetentionDays, authSecret });
+    // Resolve the built client relative to this module so the UI is served no matter the cwd
+    // (e.g. when launched via `npx @cliftonc/finius serve`). Falls back to a cwd-relative path for
+    // repo-root invocations like `npm start`.
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const clientDist = [join(moduleDir, "..", "client"), resolve("dist/client")].find((dir) => existsSync(dir));
+    if (clientDist) {
+        app.use("/*", serveStatic({ root: clientDist }));
+        app.get("*", serveStatic({ path: join(clientDist, "index.html") }));
+    }
+    // Effective transcript location: the explicit blob dir, else the adapter's default of
+    // <db-dir>/transcripts. Computed here only so we can report it on startup.
+    const resolvedDb = resolve(dbPath);
+    const transcriptsDir = blobDir ? resolve(blobDir) : join(dirname(resolvedDb), "transcripts");
+    serve({ fetch: app.fetch, hostname, port }, (info) => {
+        const url = `http://${hostname}:${info.port}`;
+        banner("serve");
+        process.stdout.write(`\n  ${pc.green("●")} ${pc.bold("Finius is live")}  ${pc.dim("·")}  ${pc.cyan(url)}\n\n`);
+        process.stdout.write(`${panel([
+            ["Dashboard", clientDist ? pc.cyan(url) : pc.yellow("not built — run `npm run build` to serve the UI")],
+            ["API", `${url}/api`],
+            ["Database", pc.dim(resolvedDb)],
+            ["Transcripts", pc.dim(transcriptsDir)],
+            ["Raw payloads", storeRawPayloads ? `retained, pruned after ${rawRetentionDays}d` : pc.dim("off")],
+            ["Auth", authSecret ? `${pc.green("secure mode")} ${pc.dim("· log in with password:")} ${pc.bold(authSecret)}` : pc.dim("open (no auth)")]
+        ])}\n\n`);
+    });
+    // Wire historical pricing backfill: when a JSONL import lands on a day we have no price for, the
+    // processing queue fetches that day's rates from LiteLLM's git history. Disabled with
+    // FINIUS_PRICING_FETCH=off (keeps the server fully offline).
+    if ((process.env.FINIUS_PRICING_FETCH ?? "on") !== "off") {
+        storage.setHistoricalPriceFetcher(githubSnapshot);
+    }
+    // Refresh model pricing in the background so we can compute cost for agents that don't report it
+    // (Codex, JSONL Claude). Non-blocking and offline-safe: on failure we keep whatever rows are
+    // already cached in model_prices and still recompute from them.
+    void syncPricing(storage);
+    const shutdown = async () => {
+        const timeout = new Promise((resolve) => windowlessSetTimeout(resolve, 5_000));
+        await Promise.race([storage.settleIngest(), timeout]);
+        storage.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    return { storage, events, clientDist, hostname, port };
+}
+function windowlessSetTimeout(callback, delay) {
+    return globalThis.setTimeout(callback, delay);
+}
+async function syncPricing(storage) {
+    if ((process.env.FINIUS_PRICING_FETCH ?? "on") === "off")
+        return;
+    const url = process.env.FINIUS_PRICING_URL ?? DEFAULT_PRICING_URL;
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const prices = normalizeLiteLlm(await res.json(), Date.now());
+        if (prices.length === 0)
+            throw new Error("no usable prices in feed");
+        await storage.importPricing(prices);
+        const { costPoints } = await storage.recomputeComputedCost();
+        console.log(panel([["Pricing", `${prices.length} models synced ${pc.dim(`(recomputed ${costPoints} cost points)`)}`]]));
+    }
+    catch (err) {
+        console.warn(`  ${pc.yellow("▲")} pricing sync failed ${pc.dim(`(${err.message})`)} — using cached pricing`);
+        // Re-apply whatever pricing is already cached so a restart still reflects locally-imported rows.
+        try {
+            await storage.recomputeComputedCost();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+function seedInitialAuthToken(storage, token) {
+    const tokenHash = createHash("sha256").update(token).digest("hex");
+    if (storage.findAuthToken(tokenHash))
+        return;
+    storage.createAuthToken(tokenHash, "owner", Date.now());
+}
+// Auto-start when executed directly (`node dist/server/index.js`), but not when this module is
+// imported by the CLI's `serve` command.
+const invokedDirectly = !!process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (invokedDirectly)
+    startServer();

package/dist/server/otel.js

@@ -0,0 +1,231 @@
+import { createHash } from "node:crypto";
+const TOKEN_METRIC = "claude_code.token.usage";
+const COST_METRIC = "claude_code.cost.usage";
+const LINES_METRIC = "claude_code.lines_of_code.count";
+const DECISION_METRIC = "claude_code.code_edit_tool.decision";
+const ACTIVE_TIME_METRIC = "claude_code.active_time.total";
+const SESSION_METRIC = "claude_code.session.count";
+const PR_METRIC = "claude_code.pull_request.count";
+const COMMIT_METRIC = "claude_code.commit.count";
+// Maps an OTLP metric to our (kind, sub-type) for the metric_points table. Returns null for
+// metrics we don't aggregate (those data points are dropped).
+function classifyMetric(metricName, attributes) {
+    switch (metricName) {
+        case TOKEN_METRIC:
+            return { kind: "tokens", tokenType: normalizeTokenType(stringAttr(attributes, "type")) };
+        case COST_METRIC:
+            return { kind: "cost", tokenType: null };
+        case LINES_METRIC:
+            return { kind: "lines", tokenType: stringAttr(attributes, "type") ?? null };
+        case DECISION_METRIC:
+            return { kind: "decision", tokenType: stringAttr(attributes, "decision") ?? null };
+        case ACTIVE_TIME_METRIC:
+            return { kind: "active_time", tokenType: stringAttr(attributes, "type") ?? null };
+        case SESSION_METRIC:
+            return { kind: "session", tokenType: stringAttr(attributes, "start_type") ?? null };
+        case PR_METRIC:
+            return { kind: "pull_request", tokenType: null };
+        case COMMIT_METRIC:
+            return { kind: "commit", tokenType: null };
+        default:
+            return null;
+    }
+}
+export function stableHash(signal, batch) {
+    return createHash("sha256").update(signal).update(JSON.stringify(batch)).digest("hex");
+}
+export function attributesToObject(attributes) {
+    const out = {};
+    for (const attr of attributes ?? []) {
+        out[attr.key] = decodeAttributeValue(attr.value);
+    }
+    return out;
+}
+export function decodeAttributeValue(value) {
+    if (!value)
+        return null;
+    if ("stringValue" in value)
+        return value.stringValue;
+    if ("intValue" in value)
+        return Number(value.intValue);
+    if ("doubleValue" in value)
+        return value.doubleValue;
+    if ("boolValue" in value)
+        return value.boolValue;
+    if ("arrayValue" in value)
+        return value.arrayValue?.values?.map(decodeAttributeValue) ?? [];
+    if ("kvlistValue" in value) {
+        return attributesToObject(value.kvlistValue?.values);
+    }
+    return null;
+}
+export function parseOtelMetricPoints(batch, source = "claude-code") {
+    const points = [];
+    const resourceMetrics = asArray(batch?.resourceMetrics);
+    for (const resourceMetric of resourceMetrics) {
+        const resourceAttrs = attributesToObject(resourceMetric.resource?.attributes);
+        const scopeMetrics = asArray(resourceMetric.scopeMetrics);
+        for (const scopeMetric of scopeMetrics) {
+            const metrics = asArray(scopeMetric.metrics);
+            for (const metric of metrics) {
+                const metricName = String(metric.name ?? "");
+                const dataPoints = getMetricDataPoints(metric);
+                for (const dataPoint of dataPoints) {
+                    const dataPointAttrs = attributesToObject(dataPoint.attributes);
+                    const attributes = { ...resourceAttrs, ...dataPointAttrs };
+                    const classified = classifyMetric(metricName, attributes);
+                    if (!classified)
+                        continue;
+                    const sessionId = stringAttr(attributes, "session.id") ?? stringAttr(attributes, "session_id") ?? "unknown-session";
+                    const timestamp = Number(unixNanoToMs(dataPoint.timeUnixNano ??
+                        dataPoint.startTimeUnixNano) ?? Date.now());
+                    const value = numericValue(dataPoint);
+                    if (!Number.isFinite(value))
+                        continue;
+                    points.push({
+                        source,
+                        signal: "otlp_metrics",
+                        sessionId,
+                        userId: stringAttr(attributes, "user.id") ?? stringAttr(attributes, "enduser.id"),
+                        userEmail: stringAttr(attributes, "user.email"),
+                        userAccountId: stringAttr(attributes, "user.account_id") ?? stringAttr(attributes, "user.account_uuid"),
+                        model: stringAttr(attributes, "model"),
+                        metricName,
+                        kind: classified.kind,
+                        tokenType: classified.tokenType,
+                        value,
+                        unit: metric.unit ?? null,
+                        timestamp,
+                        attributes
+                    });
+                }
+            }
+        }
+    }
+    return points;
+}
+/**
+ * Decodes EVERY metric data point in a batch (all metric names, not just token/cost) into a flat
+ * list of records, so the raw-events log captures the full telemetry surface. Pure/side-effect-free.
+ */
+export function parseOtelMetricRecords(batch, source = "claude-code") {
+    const records = [];
+    const resourceMetrics = asArray(batch?.resourceMetrics);
+    for (const resourceMetric of resourceMetrics) {
+        const resourceAttrs = attributesToObject(resourceMetric.resource?.attributes);
+        for (const scopeMetric of asArray(resourceMetric.scopeMetrics)) {
+            for (const metric of asArray(scopeMetric.metrics)) {
+                const m = metric;
+                const kind = m.sum ? "sum" : m.gauge ? "gauge" : m.histogram ? "histogram" : "unknown";
+                const dataPoints = asArray(m.sum?.dataPoints ?? m.gauge?.dataPoints ?? m.histogram?.dataPoints);
+                for (const dataPoint of dataPoints) {
+                    const dp = dataPoint;
+                    const rawValue = dp.asDouble ?? (dp.asInt !== undefined ? Number(dp.asInt) : dp.count !== undefined ? Number(dp.count) : null);
+                    records.push({
+                        source,
+                        metricName: String(m.name ?? ""),
+                        unit: m.unit ?? null,
+                        kind,
+                        temporality: m.sum?.aggregationTemporality ?? null,
+                        isMonotonic: m.sum?.isMonotonic ?? null,
+                        value: rawValue !== null && Number.isFinite(rawValue) ? rawValue : null,
+                        startTimeUnixNano: dp.startTimeUnixNano ?? null,
+                        timeUnixNano: dp.timeUnixNano ?? null,
+                        timestamp: Number(unixNanoToMs(dp.timeUnixNano ?? dp.startTimeUnixNano) ?? Date.now()),
+                        attributes: { ...resourceAttrs, ...attributesToObject(dp.attributes) }
+                    });
+                }
+            }
+        }
+    }
+    return records;
+}
+// Flattens an OTLP/JSON logs batch into structured records, merging resource + record attributes and
+// decoding the body. Codex's native telemetry is logs-only, so this is the seam through which we
+// capture (and, later, parse) what it sends. Pure / side-effect-free.
+//
+// Codex's native telemetry is logs-only, so this is the visibility path for it: records are indexed
+// into log_events for inspection (GET /api/logs/events), but token/cost for Codex come from the
+// authoritative rollout-JSONL path (`codex-cli-jsonl`), not from these logs — the OTel `codex.sse_event`
+// stream is a partial, cost-less subset of the rollout, so ingesting it as metrics would undercount.
+export function parseOtelLogRecords(batch) {
+    const records = [];
+    const resourceLogs = asArray(batch?.resourceLogs);
+    for (const resourceLog of resourceLogs) {
+        const resourceAttrs = attributesToObject(resourceLog.resource?.attributes);
+        for (const scopeLog of asArray(resourceLog.scopeLogs)) {
+            for (const logRecord of asArray(scopeLog.logRecords)) {
+                const lr = logRecord;
+                const attributes = { ...resourceAttrs, ...attributesToObject(lr.attributes) };
+                // Event name: the semantic `event.name` attribute FIRST (what both Claude Code and Codex
+                // actually set to the real id), then the loose top-level `eventName`/`name`. Codex's tracing
+                // appender pollutes the top-level `eventName` with a Rust source location (e.g.
+                // "event otel/src/.../session_telemetry.rs:778") and carries the true id (`codex.sse_event`, …)
+                // only in the attribute — so attribute-first is what keeps records from being mislabeled.
+                const eventName = stringAttr(attributes, "event.name") ||
+                    (typeof lr.eventName === "string" && lr.eventName) ||
+                    (typeof lr.name === "string" && lr.name) ||
+                    null;
+                records.push({
+                    eventName,
+                    severityText: typeof lr.severityText === "string" ? lr.severityText : null,
+                    timestamp: Number(unixNanoToMs(lr.timeUnixNano ?? lr.observedTimeUnixNano) ?? Date.now()),
+                    sessionId: stringAttr(attributes, "session.id") ??
+                        stringAttr(attributes, "session_id") ??
+                        stringAttr(attributes, "conversation.id") ??
+                        null,
+                    attributes,
+                    body: decodeAttributeValue(lr.body)
+                });
+            }
+        }
+    }
+    return records;
+}
+export function preferredIdentity(point) {
+    return point.userEmail ?? point.userAccountId ?? point.userId ?? "unknown";
+}
+function getMetricDataPoints(metric) {
+    const m = metric;
+    return asArray(m.sum?.dataPoints ?? m.gauge?.dataPoints ?? m.histogram?.dataPoints);
+}
+function numericValue(dataPoint) {
+    const point = dataPoint;
+    if (point.asDouble !== undefined)
+        return Number(point.asDouble);
+    if (point.asInt !== undefined)
+        return Number(point.asInt);
+    if (point.value !== undefined)
+        return Number(point.value);
+    return NaN;
+}
+function stringAttr(attributes, name) {
+    const value = attributes[name];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function unixNanoToMs(value) {
+    if (value === undefined)
+        return undefined;
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric))
+        return undefined;
+    return numeric > 10_000_000_000_000 ? Math.floor(numeric / 1_000_000) : numeric;
+}
+function normalizeTokenType(type) {
+    if (!type)
+        return "total";
+    // Claude Code emits camelCase types (cacheCreation, cacheRead) as well as snake/kebab variants.
+    const normalized = type.replace(/-/g, "_").toLowerCase();
+    if (normalized.includes("cache") && normalized.includes("creation"))
+        return "cache_creation";
+    if (normalized.includes("cache") && normalized.includes("read"))
+        return "cache_read";
+    if (normalized.includes("output"))
+        return "output";
+    if (normalized.includes("input"))
+        return "input";
+    return normalized;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}

package/dist/server/pricing-backfill.js

@@ -0,0 +1,41 @@
+import { normalizeLiteLlm } from "./pricing.js";
+// Historical-pricing fetcher. When a JSONL import carries usage on a day we have no price for, the
+// processing step asks for the prices in effect on that day; we reconstruct them from LiteLLM's git
+// history on GitHub (it only publishes *current* pricing, but every past version lives in its commits).
+// This is the I/O the storage layer stays out of — it's injected via setHistoricalPriceFetcher.
+const REPO = "BerriAI/litellm";
+const FILE = "model_prices_and_context_window.json";
+// Default fetcher: find the latest commit to the price file at or before the day, fetch that exact
+// version, and stamp its prices with the commit date as effectiveDate so they apply from then on.
+export const githubSnapshot = async (dayIso) => {
+    const commit = await latestCommit(`${dayIso}T23:59:59Z`);
+    if (!commit)
+        return null;
+    const json = await fetchJsonAt(commit.sha);
+    return normalizeLiteLlm(json, commit.date);
+};
+async function latestCommit(untilIso) {
+    const url = `https://api.github.com/repos/${REPO}/commits?path=${encodeURIComponent(FILE)}&until=${encodeURIComponent(untilIso)}&per_page=1`;
+    const res = await fetch(url, { headers: githubHeaders() });
+    if (!res.ok)
+        throw new Error(`GitHub commits HTTP ${res.status}`);
+    const commits = (await res.json());
+    if (!Array.isArray(commits) || commits.length === 0)
+        return null;
+    const date = Date.parse(commits[0].commit?.committer?.date ?? untilIso);
+    return { sha: commits[0].sha, date: Number.isFinite(date) ? date : Date.parse(untilIso) };
+}
+async function fetchJsonAt(sha) {
+    const res = await fetch(`https://raw.githubusercontent.com/${REPO}/${sha}/${FILE}`);
+    if (!res.ok)
+        throw new Error(`raw file HTTP ${res.status}`);
+    return res.json();
+}
+function githubHeaders() {
+    const headers = { Accept: "application/vnd.github+json", "User-Agent": "finius" };
+    // Optional: raises the GitHub rate limit (60/hr → 5000/hr) for large backfills.
+    const token = process.env.FINIUS_GITHUB_TOKEN;
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}

package/dist/server/pricing.js

@@ -0,0 +1,138 @@
+// Pure pricing helpers: normalize an external price feed (LiteLLM) into our ModelPrice rows, match a
+// reported model id to a price, and synthesize cost metric points from token points. Side-effect-free
+// so it unit-tests cleanly and is shared by the ingest path and the recompute/backfill path.
+//
+// The metric name used for cost we compute ourselves. It stays kind:"cost" so every existing
+// `SUM(CASE WHEN kind='cost' ...)` picks it up, but is distinguishable from an agent-reported cost
+// (Claude's `claude_code.cost.usage`) in the source-filtered comparison views.
+export const COMPUTED_COST_METRIC = "finius.cost.computed";
+// Token type (our metric_points.token_type) → the ModelPrice rate field it's priced by. Anything not
+// listed here (e.g. the "total" fallback) is intentionally unpriced so we never double-count.
+const RATE_BY_TOKEN_TYPE = {
+    input: "inputPerToken",
+    output: "outputPerToken",
+    cache_read: "cacheReadPerToken",
+    cache_creation: "cacheCreationPerToken"
+};
+export function normalizeLiteLlm(json, effectiveDate = 0) {
+    if (!json || typeof json !== "object")
+        return [];
+    const prices = [];
+    for (const [model, raw] of Object.entries(json)) {
+        if (model === "sample_spec" || !raw || typeof raw !== "object")
+            continue;
+        const entry = raw;
+        const input = numberOr0(entry.input_cost_per_token);
+        const output = numberOr0(entry.output_cost_per_token);
+        const cacheRead = numberOr0(entry.cache_read_input_token_cost);
+        const cacheCreation = numberOr0(entry.cache_creation_input_token_cost);
+        // Skip entries with no usable token rates (LiteLLM also lists embedding/audio/etc. models).
+        if (input === 0 && output === 0 && cacheRead === 0 && cacheCreation === 0)
+            continue;
+        prices.push({
+            model,
+            provider: typeof entry.litellm_provider === "string" ? entry.litellm_provider : inferProvider(model),
+            inputPerToken: input,
+            outputPerToken: output,
+            // LiteLLM omits cache-read for many models; fall back to the input rate so cache reads aren't free.
+            cacheReadPerToken: cacheRead || input,
+            cacheCreationPerToken: cacheCreation || input,
+            effectiveDate
+        });
+    }
+    return prices;
+}
+export function indexPrices(prices) {
+    const index = new Map();
+    const add = (key, price) => {
+        const list = index.get(key);
+        if (list)
+            list.push(price);
+        else
+            index.set(key, [price]);
+    };
+    for (const price of prices) {
+        const key = normalizeKey(price.model);
+        add(key, price);
+        // Also alias under the date-stripped key so a dated feed entry (claude-...-20250929) still
+        // matches an undated reported id, and vice versa.
+        const undated = key.replace(/-\d{8}$/, "");
+        if (undated !== key)
+            add(undated, price);
+    }
+    for (const list of index.values())
+        list.sort((a, b) => b.effectiveDate - a.effectiveDate);
+    return index;
+}
+// Resolve a reported model id to its candidate price rows. Tries the exact (normalized) id, then the
+// id with any trailing `-YYYYMMDD` date suffix stripped (Claude ships dated and undated variants).
+function matchKeys(model) {
+    const exact = normalizeKey(model);
+    const undated = exact.replace(/-\d{8}$/, "");
+    return undated !== exact ? [exact, undated] : [exact];
+}
+export function priceFor(model, timestamp, index) {
+    if (!model)
+        return undefined;
+    for (const key of matchKeys(model)) {
+        const list = index.get(key);
+        if (!list || list.length === 0)
+            continue;
+        // Rows are sorted newest-first; take the newest whose effectiveDate is at or before the usage.
+        const inEffect = list.find((p) => p.effectiveDate <= timestamp);
+        return inEffect ?? list[list.length - 1]; // else the oldest known rate (better than $0)
+    }
+    return undefined;
+}
+// Turn token points into synthesized cost points. One cost point per priced token point, copying the
+// source/signal/session/model/timestamp so the existing aggregation + jsonlWins precedence treat the
+// cost exactly like its tokens (and shadow it when the session has authoritative ingested cost).
+export function computeCostPoints(tokenPoints, index) {
+    const points = [];
+    for (const point of tokenPoints) {
+        if (point.kind !== "tokens" || !point.tokenType)
+            continue;
+        const rateField = RATE_BY_TOKEN_TYPE[point.tokenType];
+        if (!rateField)
+            continue;
+        const price = priceFor(point.model, point.timestamp, index);
+        if (!price)
+            continue;
+        const cost = point.value * price[rateField];
+        if (!(cost > 0))
+            continue;
+        points.push({
+            source: point.source,
+            signal: point.signal,
+            sessionId: point.sessionId,
+            userId: point.userId ?? null,
+            userEmail: point.userEmail ?? null,
+            userAccountId: point.userAccountId ?? null,
+            model: point.model ?? null,
+            metricName: COMPUTED_COST_METRIC,
+            kind: "cost",
+            tokenType: null,
+            value: cost,
+            unit: "USD",
+            timestamp: point.timestamp
+        });
+    }
+    return points;
+}
+function normalizeKey(model) {
+    // Drop a vendor prefix LiteLLM sometimes carries (e.g. "anthropic/claude-...", "openai/gpt-...").
+    const slash = model.lastIndexOf("/");
+    return (slash === -1 ? model : model.slice(slash + 1)).toLowerCase();
+}
+function inferProvider(model) {
+    const m = model.toLowerCase();
+    if (m.includes("claude"))
+        return "anthropic";
+    if (m.startsWith("gpt") || m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4") || m.includes("codex"))
+        return "openai";
+    return null;
+}
+function numberOr0(value) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+}

package/dist/server/queue.js

@@ -0,0 +1,35 @@
+// The single in-process processing queue that sits behind JSONL uploads. Uploads save their blob and
+// enqueue a task immediately; this drains them ONE AT A TIME in the background (parse → metrics → cost
+// → historical-pricing fetch). Deliberately minimal: no persistence, no priorities, one queue. A task
+// that throws is logged and skipped so one bad transcript can't wedge the queue.
+export class SerialQueue {
+    queue = [];
+    active = null;
+    enqueue(task) {
+        this.queue.push(task);
+        if (!this.active) {
+            this.active = this.drain().finally(() => {
+                this.active = null;
+            });
+        }
+    }
+    // Resolves once the queue is fully drained — used by tests and graceful shutdown.
+    async settle() {
+        while (this.active)
+            await this.active;
+    }
+    get size() {
+        return this.queue.length + (this.active ? 1 : 0);
+    }
+    async drain() {
+        while (this.queue.length) {
+            const task = this.queue.shift();
+            try {
+                await task();
+            }
+            catch (err) {
+                console.warn(`[finius] processing job failed: ${err.message}`);
+            }
+        }
+    }
+}

package/dist/server/storage/blob.js

@@ -0,0 +1,17 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export class LocalBlobStore {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    async save(key, bytes) {
+        const path = join(this.dir, key);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, bytes);
+    }
+    async read(key) {
+        const path = join(this.dir, key);
+        return existsSync(path) ? readFileSync(path) : null;
+    }
+}