@zhangferry-dev/tokendash 1.6.1 → 1.6.2

package/dist/server/quota/schemas.d.ts

@@ -0,0 +1,358 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for the normalized quota contract.
+ *
+ * Provider adapter OUTPUT is validated here before it leaves the service,
+ * so the API response (and the Swift client) can always trust the shape.
+ * Validation is tolerant of additive upstream fields — adapters strip those —
+ * but strict on fields used in calculations.
+ */
+export declare const QuotaWindowSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    usedPercent: z.ZodDefault<z.ZodNumber>;
+    remainingPercent: z.ZodDefault<z.ZodNumber>;
+    used: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    durationMins: z.ZodOptional<z.ZodNumber>;
+    resetsAt: z.ZodOptional<z.ZodString>;
+    isUnlimited: z.ZodOptional<z.ZodBoolean>;
+    modelName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    usedPercent: number;
+    remainingPercent: number;
+    modelName?: string | undefined;
+    used?: number | undefined;
+    limit?: number | undefined;
+    durationMins?: number | undefined;
+    resetsAt?: string | undefined;
+    isUnlimited?: boolean | undefined;
+}, {
+    id: string;
+    label: string;
+    modelName?: string | undefined;
+    usedPercent?: number | undefined;
+    remainingPercent?: number | undefined;
+    used?: number | undefined;
+    limit?: number | undefined;
+    durationMins?: number | undefined;
+    resetsAt?: string | undefined;
+    isUnlimited?: boolean | undefined;
+}>;
+export declare const QuotaProviderStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<["ok", "auth_failed", "not_configured", "upstream_unavailable", "rate_limited", "malformed_response", "timed_out", "error"]>;
+    message: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+    message?: string | undefined;
+    category?: string | undefined;
+}, {
+    state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+    message?: string | undefined;
+    category?: string | undefined;
+}>;
+export declare const QuotaSnapshotSchema: z.ZodObject<{
+    provider: z.ZodEnum<["codex", "claude", "glm", "minimax", "kimi"]>;
+    displayName: z.ZodString;
+    planName: z.ZodOptional<z.ZodString>;
+    fetchedAt: z.ZodString;
+    freshness: z.ZodEnum<["live", "cached", "stale"]>;
+    windows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        usedPercent: z.ZodDefault<z.ZodNumber>;
+        remainingPercent: z.ZodDefault<z.ZodNumber>;
+        used: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        durationMins: z.ZodOptional<z.ZodNumber>;
+        resetsAt: z.ZodOptional<z.ZodString>;
+        isUnlimited: z.ZodOptional<z.ZodBoolean>;
+        modelName: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        usedPercent: number;
+        remainingPercent: number;
+        modelName?: string | undefined;
+        used?: number | undefined;
+        limit?: number | undefined;
+        durationMins?: number | undefined;
+        resetsAt?: string | undefined;
+        isUnlimited?: boolean | undefined;
+    }, {
+        id: string;
+        label: string;
+        modelName?: string | undefined;
+        usedPercent?: number | undefined;
+        remainingPercent?: number | undefined;
+        used?: number | undefined;
+        limit?: number | undefined;
+        durationMins?: number | undefined;
+        resetsAt?: string | undefined;
+        isUnlimited?: boolean | undefined;
+    }>, "many">>;
+    status: z.ZodObject<{
+        state: z.ZodEnum<["ok", "auth_failed", "not_configured", "upstream_unavailable", "rate_limited", "malformed_response", "timed_out", "error"]>;
+        message: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+        message?: string | undefined;
+        category?: string | undefined;
+    }, {
+        state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+        message?: string | undefined;
+        category?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+    status: {
+        state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+        message?: string | undefined;
+        category?: string | undefined;
+    };
+    windows: {
+        id: string;
+        label: string;
+        usedPercent: number;
+        remainingPercent: number;
+        modelName?: string | undefined;
+        used?: number | undefined;
+        limit?: number | undefined;
+        durationMins?: number | undefined;
+        resetsAt?: string | undefined;
+        isUnlimited?: boolean | undefined;
+    }[];
+    displayName: string;
+    fetchedAt: string;
+    freshness: "live" | "cached" | "stale";
+    planName?: string | undefined;
+}, {
+    provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+    status: {
+        state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+        message?: string | undefined;
+        category?: string | undefined;
+    };
+    displayName: string;
+    fetchedAt: string;
+    freshness: "live" | "cached" | "stale";
+    windows?: {
+        id: string;
+        label: string;
+        modelName?: string | undefined;
+        usedPercent?: number | undefined;
+        remainingPercent?: number | undefined;
+        used?: number | undefined;
+        limit?: number | undefined;
+        durationMins?: number | undefined;
+        resetsAt?: string | undefined;
+        isUnlimited?: boolean | undefined;
+    }[] | undefined;
+    planName?: string | undefined;
+}>;
+export declare const QuotaResponseSchema: z.ZodObject<{
+    providers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodEnum<["codex", "claude", "glm", "minimax", "kimi"]>;
+        displayName: z.ZodString;
+        planName: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodString;
+        freshness: z.ZodEnum<["live", "cached", "stale"]>;
+        windows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            usedPercent: z.ZodDefault<z.ZodNumber>;
+            remainingPercent: z.ZodDefault<z.ZodNumber>;
+            used: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            durationMins: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodString>;
+            isUnlimited: z.ZodOptional<z.ZodBoolean>;
+            modelName: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            label: string;
+            usedPercent: number;
+            remainingPercent: number;
+            modelName?: string | undefined;
+            used?: number | undefined;
+            limit?: number | undefined;
+            durationMins?: number | undefined;
+            resetsAt?: string | undefined;
+            isUnlimited?: boolean | undefined;
+        }, {
+            id: string;
+            label: string;
+            modelName?: string | undefined;
+            usedPercent?: number | undefined;
+            remainingPercent?: number | undefined;
+            used?: number | undefined;
+            limit?: number | undefined;
+            durationMins?: number | undefined;
+            resetsAt?: string | undefined;
+            isUnlimited?: boolean | undefined;
+        }>, "many">>;
+        status: z.ZodObject<{
+            state: z.ZodEnum<["ok", "auth_failed", "not_configured", "upstream_unavailable", "rate_limited", "malformed_response", "timed_out", "error"]>;
+            message: z.ZodOptional<z.ZodString>;
+            category: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+            message?: string | undefined;
+            category?: string | undefined;
+        }, {
+            state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+            message?: string | undefined;
+            category?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+        status: {
+            state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+            message?: string | undefined;
+            category?: string | undefined;
+        };
+        windows: {
+            id: string;
+            label: string;
+            usedPercent: number;
+            remainingPercent: number;
+            modelName?: string | undefined;
+            used?: number | undefined;
+            limit?: number | undefined;
+            durationMins?: number | undefined;
+            resetsAt?: string | undefined;
+            isUnlimited?: boolean | undefined;
+        }[];
+        displayName: string;
+        fetchedAt: string;
+        freshness: "live" | "cached" | "stale";
+        planName?: string | undefined;
+    }, {
+        provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+        status: {
+            state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+            message?: string | undefined;
+            category?: string | undefined;
+        };
+        displayName: string;
+        fetchedAt: string;
+        freshness: "live" | "cached" | "stale";
+        windows?: {
+            id: string;
+            label: string;
+            modelName?: string | undefined;
+            usedPercent?: number | undefined;
+            remainingPercent?: number | undefined;
+            used?: number | undefined;
+            limit?: number | undefined;
+            durationMins?: number | undefined;
+            resetsAt?: string | undefined;
+            isUnlimited?: boolean | undefined;
+        }[] | undefined;
+        planName?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    providers: {
+        provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+        status: {
+            state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+            message?: string | undefined;
+            category?: string | undefined;
+        };
+        windows: {
+            id: string;
+            label: string;
+            usedPercent: number;
+            remainingPercent: number;
+            modelName?: string | undefined;
+            used?: number | undefined;
+            limit?: number | undefined;
+            durationMins?: number | undefined;
+            resetsAt?: string | undefined;
+            isUnlimited?: boolean | undefined;
+        }[];
+        displayName: string;
+        fetchedAt: string;
+        freshness: "live" | "cached" | "stale";
+        planName?: string | undefined;
+    }[];
+}, {
+    providers?: {
+        provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+        status: {
+            state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+            message?: string | undefined;
+            category?: string | undefined;
+        };
+        displayName: string;
+        fetchedAt: string;
+        freshness: "live" | "cached" | "stale";
+        windows?: {
+            id: string;
+            label: string;
+            modelName?: string | undefined;
+            usedPercent?: number | undefined;
+            remainingPercent?: number | undefined;
+            used?: number | undefined;
+            limit?: number | undefined;
+            durationMins?: number | undefined;
+            resetsAt?: string | undefined;
+            isUnlimited?: boolean | undefined;
+        }[] | undefined;
+        planName?: string | undefined;
+    }[] | undefined;
+}>;
+export declare function validateQuotaSnapshot(data: unknown): {
+    provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+    status: {
+        state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+        message?: string | undefined;
+        category?: string | undefined;
+    };
+    windows: {
+        id: string;
+        label: string;
+        usedPercent: number;
+        remainingPercent: number;
+        modelName?: string | undefined;
+        used?: number | undefined;
+        limit?: number | undefined;
+        durationMins?: number | undefined;
+        resetsAt?: string | undefined;
+        isUnlimited?: boolean | undefined;
+    }[];
+    displayName: string;
+    fetchedAt: string;
+    freshness: "live" | "cached" | "stale";
+    planName?: string | undefined;
+};
+export declare function validateQuotaResponse(data: unknown): {
+    providers: {
+        provider: "claude" | "codex" | "glm" | "minimax" | "kimi";
+        status: {
+            state: "ok" | "auth_failed" | "not_configured" | "upstream_unavailable" | "rate_limited" | "malformed_response" | "timed_out" | "error";
+            message?: string | undefined;
+            category?: string | undefined;
+        };
+        windows: {
+            id: string;
+            label: string;
+            usedPercent: number;
+            remainingPercent: number;
+            modelName?: string | undefined;
+            used?: number | undefined;
+            limit?: number | undefined;
+            durationMins?: number | undefined;
+            resetsAt?: string | undefined;
+            isUnlimited?: boolean | undefined;
+        }[];
+        displayName: string;
+        fetchedAt: string;
+        freshness: "live" | "cached" | "stale";
+        planName?: string | undefined;
+    }[];
+};

package/dist/server/quota/schemas.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for the normalized quota contract.
+ *
+ * Provider adapter OUTPUT is validated here before it leaves the service,
+ * so the API response (and the Swift client) can always trust the shape.
+ * Validation is tolerant of additive upstream fields — adapters strip those —
+ * but strict on fields used in calculations.
+ */
+export const QuotaWindowSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    usedPercent: z.number().min(0).max(100).default(0),
+    remainingPercent: z.number().min(0).max(100).default(0),
+    used: z.number().optional(),
+    limit: z.number().optional(),
+    durationMins: z.number().optional(),
+    resetsAt: z.string().optional(),
+    isUnlimited: z.boolean().optional(),
+    modelName: z.string().optional(),
+});
+export const QuotaProviderStatusSchema = z.object({
+    state: z.enum([
+        'ok',
+        'auth_failed',
+        'not_configured',
+        'upstream_unavailable',
+        'rate_limited',
+        'malformed_response',
+        'timed_out',
+        'error',
+    ]),
+    message: z.string().optional(),
+    category: z.string().optional(),
+});
+export const QuotaSnapshotSchema = z.object({
+    provider: z.enum(['codex', 'claude', 'glm', 'minimax', 'kimi']),
+    displayName: z.string(),
+    planName: z.string().optional(),
+    fetchedAt: z.string(),
+    freshness: z.enum(['live', 'cached', 'stale']),
+    windows: z.array(QuotaWindowSchema).default([]),
+    status: QuotaProviderStatusSchema,
+});
+export const QuotaResponseSchema = z.object({
+    providers: z.array(QuotaSnapshotSchema).default([]),
+});
+export function validateQuotaSnapshot(data) {
+    return QuotaSnapshotSchema.parse(data);
+}
+export function validateQuotaResponse(data) {
+    return QuotaResponseSchema.parse(data);
+}

package/dist/server/quota/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Normalized quota domain types.
+ *
+ * These are provider-neutral. Every provider adapter converts its own
+ * heterogeneous response shape into this contract so the rest of the app
+ * never sees provider-specific fields.
+ *
+ * Mirrored on the Swift side by TokenDashSwift/Sources/TokenDash/Models/APIModels.swift.
+ */
+export type QuotaProviderId = 'codex' | 'claude' | 'glm' | 'minimax' | 'kimi';
+/** A normalized snapshot of one provider's current quota state. */
+export interface QuotaSnapshot {
+    /** Stable provider id, e.g. "codex" | "claude" | "glm" | "minimax" | "kimi". */
+    provider: QuotaProviderId;
+    /** Human-facing name, e.g. "OpenAI Codex". */
+    displayName: string;
+    /** Subscription tier when known, e.g. "Pro" | "Plus" | "LEVEL_INTERMEDIATE". */
+    planName?: string;
+    /** ISO 8601 timestamp of the most recent successful fetch. */
+    fetchedAt: string;
+    /** "live" = fresh this cycle, "cached" = within ttl, "stale" = last good after a failure. */
+    freshness: 'live' | 'cached' | 'stale';
+    /** Independent quota windows. Never merged into one synthetic number. */
+    windows: QuotaWindow[];
+    /** Structured status — never carries secrets, only redacted messages. */
+    status: QuotaProviderStatus;
+}
+/** A single independent quota window (e.g. 5-hour, weekly, MCP-monthly). */
+export interface QuotaWindow {
+    /** Stable per-snapshot id, e.g. "five_hour" | "weekly" | "codex_primary". */
+    id: string;
+    /** Human label, e.g. "5-Hour Window" | "Weekly". */
+    label: string;
+    /** Consumed percentage 0-100. */
+    usedPercent: number;
+    /** Remaining percentage 0-100 (100 - usedPercent). */
+    remainingPercent: number;
+    /** Absolute used value when the provider reports one. */
+    used?: number;
+    /** Absolute limit value when the provider reports one. */
+    limit?: number;
+    /** Window length in minutes (300 = 5h, 10080 = 7d). */
+    durationMins?: number;
+    /** ISO 8601 timestamp when this window resets. */
+    resetsAt?: string;
+    /** True for unlimited / boosted windows. */
+    isUnlimited?: boolean;
+    /** Per-model windows (MiniMax returns per-model buckets). */
+    modelName?: string;
+}
+export type QuotaProviderState = 'ok' | 'auth_failed' | 'not_configured' | 'upstream_unavailable' | 'rate_limited' | 'malformed_response' | 'timed_out' | 'error';
+/**
+ * Structured provider status. Flat shape (not a discriminated union) so it
+ * round-trips cleanly through the Zod schema. Adapters populate `message`
+ * only when it carries actionable detail; `state: 'ok'` omits it.
+ */
+export interface QuotaProviderStatus {
+    state: QuotaProviderState;
+    message?: string;
+    category?: string;
+}
+/** Full API response for GET /api/quota — only configured providers appear. */
+export interface QuotaResponse {
+    providers: QuotaSnapshot[];
+}

package/dist/server/quota/types.js

@@ -0,0 +1,10 @@
+/**
+ * Normalized quota domain types.
+ *
+ * These are provider-neutral. Every provider adapter converts its own
+ * heterogeneous response shape into this contract so the rest of the app
+ * never sees provider-specific fields.
+ *
+ * Mirrored on the Swift side by TokenDashSwift/Sources/TokenDash/Models/APIModels.swift.
+ */
+export {};

package/dist/server/routes/api.js

@@ -7,6 +7,20 @@ import { getAnalytics } from './analytics.js';
 import { detectAvailableAgents } from '../agentDetection.js';
 import { isOpenClawAccessible } from '../openclawParser.js';
 import { isOpencodeAccessible } from '../opencodeParser.js';
+import { quotaService } from '../quota/index.js';
+async function getQuota(_req, res) {
+    // Fresh data only — quotaService handles cache, stale retention, and per-provider
+    // failure isolation internally. One provider's error never fails the whole response.
+    const force = _req.query.refresh === '1' || _req.query.refresh === 'true';
+    try {
+        const data = force ? await quotaService.refreshAll() : await quotaService.fetchAll();
+        res.json(data);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        res.status(500).json({ error: 'Failed to fetch quota', hint: message });
+    }
+}
 function getAgents(_req, res) {
     try {
         const agents = detectAvailableAgents();
@@ -44,4 +58,5 @@ export function registerApiRoutes(router, appInfo) {
     router.get('/projects', getProjects);
     router.get('/blocks', getBlocks);
     router.get('/analytics', getAnalytics);
+    router.get('/quota', getQuota);
 }

package/dist/server/routes/insights.d.ts

@@ -0,0 +1,2 @@
+import { type Request, type Response } from 'express';
+export declare function getInsights(req: Request, res: Response): Promise<void>;

package/dist/server/routes/insights.js

@@ -0,0 +1,155 @@
+import { cache } from '../cache.js';
+import { validateInsights } from '../../shared/schemas.js';
+import { getDailyResponse as getCodexDailyResponse, getProjectsResponse as getCodexProjectsResponse } from '../codexParser.js';
+import { getDailyResponse as getOpenClawDailyResponse, getProjectsResponse as getOpenClawProjectsResponse } from '../openclawParser.js';
+import { getDailyResponse as getOpencodeDailyResponse, getProjectsResponse as getOpencodeProjectsResponse } from '../opencodeParser.js';
+import { getDailyResponse as getClaudeDailyResponse, getProjectsResponse as getClaudeProjectsResponse } from '../claudeJsonlParser.js';
+import { detectAvailableAgents } from '../agentDetection.js';
+import { isOpenClawAccessible } from '../openclawParser.js';
+import { isOpencodeAccessible } from '../opencodeParser.js';
+import { buildInsightsResponse, mergeDailyResponsesByDate } from '../insightsCalculator.js';
+const SUPPORTED_AGENTS = ['claude', 'codex', 'openclaw', 'opencode'];
+export async function getInsights(req, res) {
+    const agent = req.query.agent || 'claude';
+    const project = req.query.project || undefined;
+    const cacheKey = `insights:${agent}:${project || 'all'}`;
+    try {
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            res.json(cached);
+            return;
+        }
+        const stale = cache.getStale(cacheKey);
+        if (stale) {
+            refreshInsightsCache(agent, project, cacheKey);
+            res.json(stale);
+            return;
+        }
+        const data = fetchInsightsData(agent, project);
+        cache.set(cacheKey, data);
+        res.json(data);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error('Error fetching insights:', error);
+        res.status(502).json({
+            error: `Failed to fetch insights from ${agent}`,
+            hint: message,
+        });
+    }
+}
+function fetchInsightsData(agent, project) {
+    if (agent === 'all') {
+        return validateInsights(fetchAllAgentInsights());
+    }
+    const selectedAgent = normalizeAgent(agent);
+    const daily = fetchDailyData(selectedAgent);
+    const projects = fetchProjectsData(selectedAgent);
+    const scopedDaily = project ? (projects.projects[project] ?? []) : daily.daily;
+    return validateInsights(buildInsightsResponse({
+        agent: selectedAgent,
+        project,
+        daily: scopedDaily,
+        projects: project ? undefined : projects,
+    }));
+}
+function fetchAllAgentInsights() {
+    const available = availableAgents();
+    const dailyResponses = [];
+    const partialAgents = [];
+    const todayDrivers = [];
+    for (const agent of available) {
+        try {
+            const daily = fetchDailyData(agent);
+            dailyResponses.push(daily);
+            const today = todayEntry(daily);
+            if (today.totalTokens > 0 || today.totalCost > 0) {
+                todayDrivers.push({
+                    name: agent,
+                    tokens: today.totalTokens,
+                    cost: today.totalCost,
+                    share: 0,
+                });
+            }
+        }
+        catch {
+            partialAgents.push(agent);
+        }
+    }
+    const totalTokens = todayDrivers.reduce((sum, driver) => sum + driver.tokens, 0);
+    const topAgent = todayDrivers
+        .map(driver => ({ ...driver, share: totalTokens > 0 ? driver.tokens / totalTokens : 0 }))
+        .sort((a, b) => b.tokens - a.tokens)[0];
+    return buildInsightsResponse({
+        agent: 'all',
+        daily: mergeDailyResponsesByDate(dailyResponses.map(response => response.daily)),
+        topAgent,
+        partialAgents,
+    });
+}
+function todayEntry(response) {
+    const today = [
+        new Date().getFullYear(),
+        String(new Date().getMonth() + 1).padStart(2, '0'),
+        String(new Date().getDate()).padStart(2, '0'),
+    ].join('-');
+    return response.daily.find(entry => entry.date === today) ?? {
+        date: today,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        modelsUsed: [],
+        modelBreakdowns: [],
+    };
+}
+function availableAgents() {
+    const detected = detectAvailableAgents();
+    const agents = [];
+    if (detected.claude)
+        agents.push('claude');
+    if (detected.codex)
+        agents.push('codex');
+    if (isOpenClawAccessible())
+        agents.push('openclaw');
+    if (isOpencodeAccessible())
+        agents.push('opencode');
+    return agents.length > 0 ? agents : ['claude'];
+}
+function normalizeAgent(agent) {
+    return SUPPORTED_AGENTS.includes(agent) ? agent : 'claude';
+}
+function fetchDailyData(agent) {
+    if (agent === 'codex') {
+        return getCodexDailyResponse();
+    }
+    else if (agent === 'openclaw') {
+        return getOpenClawDailyResponse();
+    }
+    else if (agent === 'opencode') {
+        return getOpencodeDailyResponse();
+    }
+    return getClaudeDailyResponse();
+}
+function fetchProjectsData(agent) {
+    if (agent === 'codex') {
+        return getCodexProjectsResponse();
+    }
+    else if (agent === 'openclaw') {
+        return getOpenClawProjectsResponse();
+    }
+    else if (agent === 'opencode') {
+        return getOpencodeProjectsResponse();
+    }
+    return getClaudeProjectsResponse();
+}
+function refreshInsightsCache(agent, project, cacheKey) {
+    Promise.resolve()
+        .then(() => {
+        const data = fetchInsightsData(agent, project);
+        cache.set(cacheKey, data);
+    })
+        .catch(err => console.error('Background refresh failed (insights):', err));
+}