@zhangferry-dev/tokendash 1.1.3 → 1.2.0

package/dist/server/claudeJsonlParser.js

@@ -0,0 +1,314 @@
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const MODEL_PRICING = {
+    // Claude 4.6
+    'claude-opus-4-6': { inputPer1M: 15, cacheReadPer1M: 1.50, outputPer1M: 75 },
+    'claude-sonnet-4-6': { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 },
+    // Claude 4.5
+    'claude-sonnet-4-5-20250514': { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 },
+    'claude-haiku-4-5-20251001': { inputPer1M: 0.80, cacheReadPer1M: 0.08, outputPer1M: 4 },
+    // Older Claude models
+    'claude-3-5-sonnet-20241022': { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 },
+    'claude-3-5-haiku-20241022': { inputPer1M: 0.80, cacheReadPer1M: 0.08, outputPer1M: 4 },
+    'claude-3-opus-20240229': { inputPer1M: 15, cacheReadPer1M: 1.50, outputPer1M: 75 },
+    'claude-3-haiku-20240307': { inputPer1M: 0.25, cacheReadPer1M: 0.03, outputPer1M: 1.25 },
+};
+const DEFAULT_PRICING = { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 };
+function getPricing(model) {
+    // Try exact match first, then prefix match
+    if (MODEL_PRICING[model])
+        return MODEL_PRICING[model];
+    const lower = model.toLowerCase();
+    for (const key of Object.keys(MODEL_PRICING)) {
+        if (lower.startsWith(key) || lower.includes(key))
+            return MODEL_PRICING[key];
+    }
+    return DEFAULT_PRICING;
+}
+export function calculateCost(inputTokens, cacheReadTokens, outputTokens, model) {
+    const p = getPricing(model);
+    const nonCachedInput = Math.max(inputTokens - cacheReadTokens, 0);
+    return (nonCachedInput / 1_000_000) * p.inputPer1M
+        + (cacheReadTokens / 1_000_000) * p.cacheReadPer1M
+        + (outputTokens / 1_000_000) * p.outputPer1M;
+}
+// ---------------------------------------------------------------------------
+// JSONL parsing with mtime cache
+// ---------------------------------------------------------------------------
+const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+const fileCache = new Map();
+function extractProjectName(dirName) {
+    const parts = dirName.replace(/^-/, '').split('-');
+    return parts[parts.length - 1] || dirName;
+}
+function matchesProject(dirName, filter) {
+    return extractProjectName(dirName) === extractProjectName(filter);
+}
+function findJsonlFiles(dir) {
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                results.push(...findJsonlFiles(join(dir, entry.name)));
+            }
+            else if (entry.name.endsWith('.jsonl')) {
+                results.push(join(dir, entry.name));
+            }
+        }
+    }
+    catch { /* skip unreadable dirs */ }
+    return results;
+}
+function parseAllSessions(project) {
+    if (!existsSync(CLAUDE_PROJECTS_DIR))
+        return [];
+    const results = [];
+    const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+    for (const dirName of projectDirs) {
+        if (project && !matchesProject(dirName, project))
+            continue;
+        const dirPath = join(CLAUDE_PROJECTS_DIR, dirName);
+        const files = findJsonlFiles(dirPath);
+        for (const filePath of files) {
+            let mtime = 0;
+            try {
+                mtime = statSync(filePath).mtimeMs;
+            }
+            catch { /* ok */ }
+            const cached = fileCache.get(filePath);
+            if (cached && cached.mtime === mtime) {
+                results.push(...cached.entries);
+                continue;
+            }
+            const entries = [];
+            let content;
+            try {
+                content = readFileSync(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                let obj;
+                try {
+                    obj = JSON.parse(trimmed);
+                }
+                catch {
+                    continue;
+                }
+                if (obj.type !== 'assistant' || !obj.message)
+                    continue;
+                const msg = obj.message;
+                const usage = msg.usage || {};
+                const inputTokens = usage.input_tokens || 0;
+                const outputTokens = usage.output_tokens || 0;
+                const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+                const cacheReadTokens = usage.cache_read_input_tokens || 0;
+                const totalTokens = inputTokens + outputTokens + cacheReadTokens;
+                if (totalTokens === 0)
+                    continue;
+                entries.push({
+                    timestamp: obj.timestamp,
+                    model: msg.model || 'unknown',
+                    inputTokens,
+                    outputTokens,
+                    cacheCreationTokens,
+                    cacheReadTokens,
+                    projectDir: dirName,
+                });
+            }
+            fileCache.set(filePath, { mtime, entries });
+            results.push(...entries);
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Timezone helpers
+// ---------------------------------------------------------------------------
+const TZ_OFFSETS = {
+    'Asia/Shanghai': 8,
+    'Asia/Tokyo': 9,
+    'America/New_York': -5,
+    'America/Los_Angeles': -8,
+    'Europe/London': 0,
+    'UTC': 0,
+};
+export function getDateKey(timestamp, tz) {
+    const offset = (TZ_OFFSETS[tz] ?? 8) * 3_600_000;
+    const d = new Date(new Date(timestamp).getTime() + offset);
+    // Use UTC methods since we manually applied the timezone offset
+    return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}-${String(d.getUTCDate()).padStart(2, '0')}`;
+}
+export function getHourKey(timestamp, tz) {
+    const offset = (TZ_OFFSETS[tz] ?? 8) * 3_600_000;
+    const d = new Date(new Date(timestamp).getTime() + offset);
+    // Use UTC methods since we manually applied the timezone offset
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const dd = String(d.getUTCDate()).padStart(2, '0');
+    const hh = String(d.getUTCHours()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}T${hh}`;
+}
+function toDailyEntry(agg) {
+    const modelBreakdowns = [...agg.models.entries()].map(([modelName, m]) => ({
+        modelName,
+        inputTokens: m.input,
+        outputTokens: m.output,
+        cacheCreationTokens: m.cacheCreation,
+        cacheReadTokens: m.cacheRead,
+        cost: m.cost,
+    }));
+    return {
+        date: agg.date,
+        inputTokens: agg.inputTokens,
+        outputTokens: agg.outputTokens,
+        cacheCreationTokens: agg.cacheCreationTokens,
+        cacheReadTokens: agg.cacheReadTokens,
+        totalTokens: agg.totalTokens,
+        totalCost: Math.round(agg.totalCost * 10000) / 10000,
+        modelsUsed: [...agg.models.keys()],
+        modelBreakdowns,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+const DEFAULT_TZ = 'Asia/Shanghai';
+export function getDailyResponse(project, tz = DEFAULT_TZ) {
+    const entries = parseAllSessions(project);
+    const dayMap = new Map();
+    for (const e of entries) {
+        const date = getDateKey(e.timestamp, tz);
+        if (!dayMap.has(date)) {
+            dayMap.set(date, {
+                date, inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0,
+                cacheReadTokens: 0, totalTokens: 0, totalCost: 0,
+                models: new Map(),
+            });
+        }
+        const agg = dayMap.get(date);
+        agg.inputTokens += e.inputTokens;
+        agg.outputTokens += e.outputTokens;
+        agg.cacheCreationTokens += e.cacheCreationTokens;
+        agg.cacheReadTokens += e.cacheReadTokens;
+        agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
+        const cost = calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+        agg.totalCost += cost;
+        if (!agg.models.has(e.model)) {
+            agg.models.set(e.model, { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, cost: 0 });
+        }
+        const m = agg.models.get(e.model);
+        m.input += e.inputTokens;
+        m.output += e.outputTokens;
+        m.cacheCreation += e.cacheCreationTokens;
+        m.cacheRead += e.cacheReadTokens;
+        m.cost += cost;
+    }
+    const daily = [...dayMap.values()].sort((a, b) => a.date.localeCompare(b.date)).map(toDailyEntry);
+    const totals = daily.reduce((acc, d) => ({
+        inputTokens: acc.inputTokens + d.inputTokens,
+        outputTokens: acc.outputTokens + d.outputTokens,
+        cacheCreationTokens: acc.cacheCreationTokens + d.cacheCreationTokens,
+        cacheReadTokens: acc.cacheReadTokens + d.cacheReadTokens,
+        totalTokens: acc.totalTokens + d.totalTokens,
+        totalCost: acc.totalCost + d.totalCost,
+    }), { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, totalTokens: 0, totalCost: 0 });
+    return { daily, totals };
+}
+export function getProjectsResponse(tz = DEFAULT_TZ) {
+    const entries = parseAllSessions();
+    const projectMap = new Map();
+    for (const e of entries) {
+        const date = getDateKey(e.timestamp, tz);
+        const projectName = e.projectDir;
+        if (!projectMap.has(projectName)) {
+            projectMap.set(projectName, new Map());
+        }
+        const dayMap = projectMap.get(projectName);
+        if (!dayMap.has(date)) {
+            dayMap.set(date, {
+                date, inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0,
+                cacheReadTokens: 0, totalTokens: 0, totalCost: 0,
+                models: new Map(),
+            });
+        }
+        const agg = dayMap.get(date);
+        agg.inputTokens += e.inputTokens;
+        agg.outputTokens += e.outputTokens;
+        agg.cacheCreationTokens += e.cacheCreationTokens;
+        agg.cacheReadTokens += e.cacheReadTokens;
+        agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
+        const cost = calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+        agg.totalCost += cost;
+        if (!agg.models.has(e.model)) {
+            agg.models.set(e.model, { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, cost: 0 });
+        }
+        const m = agg.models.get(e.model);
+        m.input += e.inputTokens;
+        m.output += e.outputTokens;
+        m.cacheCreation += e.cacheCreationTokens;
+        m.cacheRead += e.cacheReadTokens;
+        m.cost += cost;
+    }
+    const projects = {};
+    for (const [projectName, dayMap] of projectMap) {
+        projects[projectName] = [...dayMap.values()]
+            .sort((a, b) => a.date.localeCompare(b.date))
+            .map(toDailyEntry);
+    }
+    return { projects };
+}
+export function getBlocksResponse(project, tz = DEFAULT_TZ) {
+    const entries = parseAllSessions(project);
+    const hourMap = new Map();
+    for (const e of entries) {
+        const hourKey = getHourKey(e.timestamp, tz);
+        if (!hourMap.has(hourKey)) {
+            hourMap.set(hourKey, {
+                inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0,
+                cacheReadTokens: 0, costUSD: 0, models: new Set(),
+            });
+        }
+        const bucket = hourMap.get(hourKey);
+        bucket.inputTokens += e.inputTokens;
+        bucket.outputTokens += e.outputTokens;
+        bucket.cacheCreationTokens += e.cacheCreationTokens;
+        bucket.cacheReadTokens += e.cacheReadTokens;
+        bucket.costUSD += calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+        bucket.models.add(e.model);
+    }
+    const blocks = [];
+    let idx = 0;
+    for (const [hourKey, bucket] of hourMap) {
+        const totalTokens = bucket.inputTokens + bucket.outputTokens + bucket.cacheReadTokens;
+        blocks.push({
+            id: `claude-${idx}`,
+            startTime: `${hourKey}:00:00`,
+            endTime: `${hourKey}:59:59`,
+            actualEndTime: null,
+            isActive: false,
+            isGap: false,
+            entries: totalTokens > 0 ? 1 : 0,
+            tokenCounts: {
+                inputTokens: bucket.inputTokens,
+                outputTokens: bucket.outputTokens,
+                cacheCreationInputTokens: bucket.cacheCreationTokens,
+                cacheReadInputTokens: bucket.cacheReadTokens,
+            },
+            totalTokens,
+            costUSD: Math.round(bucket.costUSD * 10000) / 10000,
+            models: [...bucket.models],
+        });
+        idx++;
+    }
+    blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+    return { blocks };
+}

package/dist/server/index.js

@@ -1,7 +1,7 @@
 import express from 'express';
 import { readFileSync } from 'node:fs';
 import { registerApiRoutes } from './routes/api.js';
-import { detectAvailableAgents } from './ccusage.js';
+import { detectAvailableAgents } from './agentDetection.js';
 import open from 'open';
 const CLI_USAGE = [
     'Usage:',
@@ -52,10 +52,10 @@ function parseCliArgs() {
 }
 async function ensureUsageSupportAvailable() {
     try {
-        const agents = await detectAvailableAgents();
+        const agents = detectAvailableAgents();
         if (!agents.claude && !agents.codex) {
             console.error('Error: No AI coding assistant data found.');
-            console.error('\nDetails: Could not find Claude Code (ccusage CLI) or Codex (~/.codex/sessions/) data.');
+            console.error('\nDetails: Could not find Claude Code (~/.claude/projects/) or Codex (~/.codex/sessions/) data.');
             console.error('Please install at least one of: Claude Code or Codex CLI.');
             return false;
         }

package/dist/server/openclawParser.js

@@ -40,6 +40,7 @@ export function scanOpenClawSessions() {
         }
         for (const agentEntry of agentEntries) {
             const sessionsDir = join(agentsDir, agentEntry, 'sessions');
+            const indexedPaths = new Set();
             // Try sessions.json index first
             const indexPath = join(sessionsDir, 'sessions.json');
             try {
@@ -50,44 +51,66 @@ export function scanOpenClawSessions() {
                         continue;
                     let sessionPath;
                     if (entry.sessionFile) {
-                        sessionPath = entry.sessionFile.startsWith('/')
-                            ? entry.sessionFile
-                            : join(sessionsDir, entry.sessionFile);
+                        const filePath = entry.sessionFile;
+                        if (filePath.startsWith('/')) {
+                            // Validate absolute path stays within an OpenClaw directory
+                            if (!getOpenClawDirs().some(dir => filePath.startsWith(dir)))
+                                continue;
+                            sessionPath = filePath;
+                        }
+                        else {
+                            sessionPath = join(sessionsDir, filePath);
+                        }
                     }
                     else {
                         sessionPath = join(sessionsDir, `${entry.sessionId}.jsonl`);
                     }
+                    indexedPaths.add(sessionPath);
                     refs.push({ sessionId: entry.sessionId, sessionFile: sessionPath, agentId: agentEntry });
                 }
             }
             catch {
-                // No sessions.json — fall back to scanning .jsonl files directly
-                let files;
-                try {
-                    files = readdirSync(sessionsDir);
-                }
-                catch {
+                // No sessions.json — will scan .jsonl files below
+            }
+            // Scan for .jsonl files not already covered by the index
+            let files;
+            try {
+                files = readdirSync(sessionsDir);
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                if (!f.endsWith('.jsonl'))
                     continue;
-                }
-                for (const f of files) {
-                    if (!f.endsWith('.jsonl'))
-                        continue;
-                    const sessionId = f.replace(/\.jsonl.*$/, ''); // strip .jsonl and any suffixes
-                    refs.push({
-                        sessionId,
-                        sessionFile: join(sessionsDir, f),
-                        agentId: agentEntry,
-                    });
-                }
+                const fullPath = join(sessionsDir, f);
+                if (indexedPaths.has(fullPath))
+                    continue;
+                const sessionId = f.replace(/\.jsonl.*$/, '');
+                refs.push({ sessionId, sessionFile: fullPath, agentId: agentEntry });
             }
         }
     }
     return refs;
 }
 // ---------------------------------------------------------------------------
+// Session-level cache (mtime-based invalidation)
+// ---------------------------------------------------------------------------
+const sessionCache = new Map();
+// ---------------------------------------------------------------------------
 // JSONL parser
 // ---------------------------------------------------------------------------
 export function parseOpenClawSession(ref) {
+    let fileMtimeMs = 0;
+    try {
+        fileMtimeMs = statSync(ref.sessionFile).mtimeMs;
+    }
+    catch { /* ok */ }
+    // Return cached result if file hasn't changed
+    const cached = sessionCache.get(ref.sessionFile);
+    if (cached && cached.mtime === fileMtimeMs) {
+        return cached.result;
+    }
     let content;
     try {
         content = readFileSync(ref.sessionFile, 'utf-8');
@@ -95,12 +118,6 @@ export function parseOpenClawSession(ref) {
     catch {
         return null;
     }
-    // Fallback timestamp: file mtime
-    let fileMtimeMs = 0;
-    try {
-        fileMtimeMs = statSync(ref.sessionFile).mtimeMs;
-    }
-    catch { /* ok */ }
     const tokenEvents = [];
     let currentModel = '';
     let currentProvider = '';
@@ -161,15 +178,19 @@ export function parseOpenClawSession(ref) {
                 outputTokens: Math.max(0, output),
                 cacheReadTokens: Math.max(0, cacheRead),
                 cacheWriteTokens: Math.max(0, cacheWrite),
-                totalTokens: Math.max(0, input + output),
+                totalTokens: Math.max(0, input + output + cacheRead),
                 cost: Math.max(0, cost),
                 model: `${provider}/${model}`,
             });
         }
     }
-    if (tokenEvents.length === 0)
+    if (tokenEvents.length === 0) {
+        sessionCache.set(ref.sessionFile, { mtime: fileMtimeMs, result: null });
         return null;
-    return { id: ref.sessionId, agentId: ref.agentId, tokenEvents };
+    }
+    const result = { id: ref.sessionId, agentId: ref.agentId, tokenEvents };
+    sessionCache.set(ref.sessionFile, { mtime: fileMtimeMs, result });
+    return result;
 }
 export function parseAllOpenClawSessions() {
     return scanOpenClawSessions()
@@ -251,7 +272,6 @@ export function getDailyResponse(options) {
     const sessions = parseAllOpenClawSessions();
     const tz = options?.timezone || 'Asia/Shanghai';
     const grouped = new Map();
-    const allModels = new Set();
     const totalsAcc = emptyAcc();
     for (const session of sessions) {
         if (options?.project && session.agentId !== options.project)
@@ -267,7 +287,6 @@ export function getDailyResponse(options) {
             const entry = grouped.get(key);
             addEvent(entry.acc, ev);
             entry.models.add(ev.model);
-            allModels.add(ev.model);
         }
     }
     const daily = [];

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

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

package/dist/server/routes/analytics.js

@@ -0,0 +1,40 @@
+import { cache } from '../cache.js';
+import { validateAnalytics } from '../../shared/schemas.js';
+import { extractClaudeToolCalls, extractOpenClawToolCalls, computeAnalytics } from '../analyticsParser.js';
+const EMPTY_ANALYTICS = {
+    codeChangeTrend: [],
+    toolUsageDistribution: [],
+    productivityKPIs: { avgLinesPerEdit: 0, filesModifiedPerDay: 0, addDeleteRatio: 0, totalEdits: 0, totalFilesModified: 0, activeDaysWithEdits: 0 },
+    toolCallTrend: [],
+};
+export async function getAnalytics(req, res) {
+    const agent = req.query.agent || 'claude';
+    const project = req.query.project || undefined;
+    if (agent === 'codex') {
+        res.json(EMPTY_ANALYTICS);
+        return;
+    }
+    try {
+        const cacheKey = `analytics:${agent}:${project || 'all'}`;
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            res.json(cached);
+            return;
+        }
+        const toolCalls = agent === 'openclaw'
+            ? extractOpenClawToolCalls(project || null)
+            : extractClaudeToolCalls(project || null);
+        const data = computeAnalytics(toolCalls);
+        const validated = validateAnalytics(data);
+        cache.set(cacheKey, validated);
+        res.json(validated);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error('Error fetching analytics:', error);
+        res.status(502).json({
+            error: `Failed to fetch analytics from ${agent}`,
+            hint: message,
+        });
+    }
+}

package/dist/server/routes/api.js

@@ -3,15 +3,19 @@ import { getMonthly } from './monthly.js';
 import { getSession } from './session.js';
 import { getProjects } from './projects.js';
 import { getBlocks } from './blocks.js';
-import { detectAvailableAgents } from '../ccusage.js';
-async function getAgents(_req, res) {
+import { getAnalytics } from './analytics.js';
+import { detectAvailableAgents } from '../agentDetection.js';
+import { isOpenClawAccessible } from '../openclawParser.js';
+function getAgents(_req, res) {
     try {
-        const agents = await detectAvailableAgents();
+        const agents = detectAvailableAgents();
         const available = [];
         if (agents.claude)
             available.push('claude');
         if (agents.codex)
             available.push('codex');
+        if (isOpenClawAccessible())
+            available.push('openclaw');
         res.json({ available, default: available[0] || null });
     }
     catch (error) {
@@ -26,4 +30,5 @@ export function registerApiRoutes(router) {
     router.get('/session', getSession);
     router.get('/projects', getProjects);
     router.get('/blocks', getBlocks);
+    router.get('/analytics', getAnalytics);
 }

package/dist/server/routes/blocks.js

@@ -1,57 +1,52 @@
-import { runCcusage } from '../ccusage.js';
 import { cache } from '../cache.js';
 import { validateBlocks } from '../../shared/schemas.js';
-import { getBlocksResponse } from '../codexParser.js';
-import { getClaudeBlocksByProject } from '../claudeBlocksParser.js';
+import { getBlocksResponse as getCodexBlocksResponse } from '../codexParser.js';
+import { getBlocksResponse as getOpenClawBlocksResponse } from '../openclawParser.js';
+import { getBlocksResponse as getClaudeBlocksResponse } from '../claudeJsonlParser.js';
 export async function getBlocks(req, res) {
     const agent = req.query.agent || 'claude';
     const project = req.query.project || undefined;
     try {
-        if (agent === 'codex') {
-            const projectCacheKey = `blocks:${agent}:${project || 'all'}`;
-            const cached = cache.get(projectCacheKey);
-            if (cached) {
-                res.json(cached);
-                return;
-            }
-            const data = getBlocksResponse({ project: project || null });
-            cache.set(projectCacheKey, data);
-            res.json(data);
-            return;
-        }
-        // Claude Code with project filter: use custom JSONL parser
-        if (project) {
-            const projectCacheKey = `blocks:claude:${project}`;
-            const cached = cache.get(projectCacheKey);
-            if (cached) {
-                res.json(cached);
-                return;
-            }
-            const blocks = getClaudeBlocksByProject(project);
-            const data = { blocks };
-            cache.set(projectCacheKey, data);
-            res.json(data);
-            return;
-        }
-        // Claude Code without project filter: use ccusage blocks
-        const cacheKey = `blocks:${agent}`;
+        const cacheKey = `blocks:${agent}:${project || 'all'}`;
         const cached = cache.get(cacheKey);
         if (cached) {
             res.json(cached);
             return;
         }
-        const stdout = await runCcusage(['blocks']);
-        const data = JSON.parse(stdout);
-        const validated = validateBlocks(data);
-        cache.set(cacheKey, validated);
-        res.json(validated);
+        // Stale-while-revalidate
+        const stale = cache.getStale(cacheKey);
+        if (stale) {
+            refreshBlocksCache(agent, project, cacheKey);
+            res.json(stale);
+            return;
+        }
+        const data = fetchBlocksData(agent, project);
+        cache.set(cacheKey, data);
+        res.json(data);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : 'Unknown error';
         console.error('Error fetching blocks data:', error);
         res.status(502).json({
-            error: 'Failed to fetch blocks data from ccusage',
+            error: 'Failed to fetch blocks data',
             hint: message,
         });
     }
 }
+function fetchBlocksData(agent, project) {
+    if (agent === 'openclaw') {
+        return validateBlocks(getOpenClawBlocksResponse({ project: project || null }));
+    }
+    else if (agent === 'codex') {
+        return validateBlocks(getCodexBlocksResponse({ project: project || null }));
+    }
+    else {
+        // Claude Code: parse JSONL directly (fast, no CLI)
+        return validateBlocks(getClaudeBlocksResponse(project || null));
+    }
+}
+function refreshBlocksCache(agent, project, cacheKey) {
+    Promise.resolve()
+        .then(() => { const data = fetchBlocksData(agent, project); cache.set(cacheKey, data); })
+        .catch(err => console.error('Background refresh failed (blocks):', err));
+}