@zhangferry-dev/tokendash 1.1.0 → 1.1.3

package/dist/server/openclawParser.js

@@ -0,0 +1,366 @@
+import { readFileSync, readdirSync, statSync, accessSync, constants } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+// ---------------------------------------------------------------------------
+// Directory helpers
+// ---------------------------------------------------------------------------
+/** All directories OpenClaw may have used (current + legacy names). */
+function getOpenClawDirs() {
+    const home = homedir();
+    return [
+        join(home, '.openclaw'),
+        join(home, '.clawdbot'), // legacy name 1
+        join(home, '.moltbot'), // legacy name 2
+        join(home, '.moldbot'), // legacy name 3
+    ];
+}
+export function isOpenClawAccessible() {
+    for (const dir of getOpenClawDirs()) {
+        try {
+            accessSync(join(dir, 'agents'), constants.R_OK);
+            return true;
+        }
+        catch {
+            // try next
+        }
+    }
+    return false;
+}
+/** Scan all OpenClaw agent dirs and collect session file references. */
+export function scanOpenClawSessions() {
+    const refs = [];
+    for (const baseDir of getOpenClawDirs()) {
+        const agentsDir = join(baseDir, 'agents');
+        let agentEntries;
+        try {
+            agentEntries = readdirSync(agentsDir);
+        }
+        catch {
+            continue;
+        }
+        for (const agentEntry of agentEntries) {
+            const sessionsDir = join(agentsDir, agentEntry, 'sessions');
+            // Try sessions.json index first
+            const indexPath = join(sessionsDir, 'sessions.json');
+            try {
+                const raw = readFileSync(indexPath, 'utf-8');
+                const index = JSON.parse(raw);
+                for (const entry of Object.values(index)) {
+                    if (!entry.sessionId)
+                        continue;
+                    let sessionPath;
+                    if (entry.sessionFile) {
+                        sessionPath = entry.sessionFile.startsWith('/')
+                            ? entry.sessionFile
+                            : join(sessionsDir, entry.sessionFile);
+                    }
+                    else {
+                        sessionPath = join(sessionsDir, `${entry.sessionId}.jsonl`);
+                    }
+                    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 {
+                    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,
+                    });
+                }
+            }
+        }
+    }
+    return refs;
+}
+// ---------------------------------------------------------------------------
+// JSONL parser
+// ---------------------------------------------------------------------------
+export function parseOpenClawSession(ref) {
+    let content;
+    try {
+        content = readFileSync(ref.sessionFile, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    // Fallback timestamp: file mtime
+    let fileMtimeMs = 0;
+    try {
+        fileMtimeMs = statSync(ref.sessionFile).mtimeMs;
+    }
+    catch { /* ok */ }
+    const tokenEvents = [];
+    let currentModel = '';
+    let currentProvider = '';
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const type = obj.type;
+        if (type === 'model_change') {
+            if (obj.modelId)
+                currentModel = obj.modelId;
+            if (obj.provider)
+                currentProvider = obj.provider;
+            continue;
+        }
+        if (type === 'custom' && obj.customType === 'model-snapshot') {
+            const data = obj.data || {};
+            if (data.modelId)
+                currentModel = data.modelId;
+            if (data.provider)
+                currentProvider = data.provider;
+            continue;
+        }
+        if (type === 'message') {
+            const msg = obj.message || {};
+            if (msg.role !== 'assistant')
+                continue;
+            const usage = msg.usage || {};
+            if (!usage)
+                continue;
+            // Model: prefer embedded, fall back to tracked state
+            const model = (msg.model || currentModel || '').trim();
+            const provider = (msg.provider || currentProvider || '').trim();
+            if (!model)
+                continue; // can't attribute cost without a model
+            // Update tracked state
+            if (model)
+                currentModel = model;
+            if (provider)
+                currentProvider = provider;
+            const input = Number(usage.input ?? 0);
+            const output = Number(usage.output ?? 0);
+            const cacheRead = Number(usage.cacheRead ?? 0);
+            const cacheWrite = Number(usage.cacheWrite ?? 0);
+            const costObj = usage.cost || {};
+            const cost = Number(costObj.total ?? 0);
+            const timestampMs = Number(msg.timestamp ?? fileMtimeMs);
+            tokenEvents.push({
+                timestampMs,
+                inputTokens: Math.max(0, input),
+                outputTokens: Math.max(0, output),
+                cacheReadTokens: Math.max(0, cacheRead),
+                cacheWriteTokens: Math.max(0, cacheWrite),
+                totalTokens: Math.max(0, input + output),
+                cost: Math.max(0, cost),
+                model: `${provider}/${model}`,
+            });
+        }
+    }
+    if (tokenEvents.length === 0)
+        return null;
+    return { id: ref.sessionId, agentId: ref.agentId, tokenEvents };
+}
+export function parseAllOpenClawSessions() {
+    return scanOpenClawSessions()
+        .map(parseOpenClawSession)
+        .filter((s) => s !== null);
+}
+// ---------------------------------------------------------------------------
+// Date / timezone helpers (same logic as codexParser)
+// ---------------------------------------------------------------------------
+const TZ_OFFSETS = {
+    'Asia/Shanghai': 8,
+    'Asia/Tokyo': 9,
+    'America/New_York': -5,
+    'America/Los_Angeles': -8,
+    'Europe/London': 0,
+    'UTC': 0,
+};
+function getTzOffsetHours(tz) {
+    return TZ_OFFSETS[tz] ?? 8;
+}
+function msToLocalDate(ms, tz) {
+    return new Date(ms + getTzOffsetHours(tz) * 3_600_000);
+}
+function getDateKey(ms, tz) {
+    return msToLocalDate(ms, tz).toISOString().slice(0, 10);
+}
+function getHourKey(ms, tz) {
+    const d = msToLocalDate(ms, tz);
+    return d.toISOString().slice(0, 13).replace('T', ' ') + ':00';
+}
+function getMonthKey(ms, tz) {
+    return getDateKey(ms, tz).slice(0, 7);
+}
+// ---------------------------------------------------------------------------
+// Aggregation helpers
+// ---------------------------------------------------------------------------
+function emptyAcc() {
+    return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0, cost: 0 };
+}
+function addEvent(acc, ev) {
+    acc.inputTokens += ev.inputTokens;
+    acc.outputTokens += ev.outputTokens;
+    acc.cacheReadTokens += ev.cacheReadTokens;
+    acc.cacheWriteTokens += ev.cacheWriteTokens;
+    acc.totalTokens += ev.totalTokens;
+    acc.cost += ev.cost;
+}
+function mergeAcc(a, b) {
+    a.inputTokens += b.inputTokens;
+    a.outputTokens += b.outputTokens;
+    a.cacheReadTokens += b.cacheReadTokens;
+    a.cacheWriteTokens += b.cacheWriteTokens;
+    a.totalTokens += b.totalTokens;
+    a.cost += b.cost;
+}
+function accToEntry(date, acc, models) {
+    const modelList = [...models];
+    const costPerModel = modelList.length > 0 ? acc.cost / modelList.length : 0;
+    return {
+        date,
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+        cacheCreationTokens: acc.cacheWriteTokens,
+        cacheReadTokens: acc.cacheReadTokens,
+        totalTokens: acc.totalTokens,
+        totalCost: acc.cost,
+        modelsUsed: modelList,
+        modelBreakdowns: modelList.map(name => ({
+            modelName: name,
+            inputTokens: acc.inputTokens,
+            outputTokens: acc.outputTokens,
+            cacheCreationTokens: acc.cacheWriteTokens,
+            cacheReadTokens: acc.cacheReadTokens,
+            cost: costPerModel,
+        })),
+    };
+}
+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)
+            continue;
+        for (const ev of session.tokenEvents) {
+            if (options?.since && ev.timestampMs < options.since.getTime())
+                continue;
+            if (options?.until && ev.timestampMs > options.until.getTime())
+                continue;
+            const key = getDateKey(ev.timestampMs, tz);
+            if (!grouped.has(key))
+                grouped.set(key, { acc: emptyAcc(), models: new Set() });
+            const entry = grouped.get(key);
+            addEvent(entry.acc, ev);
+            entry.models.add(ev.model);
+            allModels.add(ev.model);
+        }
+    }
+    const daily = [];
+    for (const [date, { acc, models }] of grouped) {
+        daily.push(accToEntry(date, acc, models));
+        mergeAcc(totalsAcc, acc);
+    }
+    daily.sort((a, b) => a.date.localeCompare(b.date));
+    return {
+        daily,
+        totals: {
+            inputTokens: totalsAcc.inputTokens,
+            outputTokens: totalsAcc.outputTokens,
+            cacheCreationTokens: totalsAcc.cacheWriteTokens,
+            cacheReadTokens: totalsAcc.cacheReadTokens,
+            totalTokens: totalsAcc.totalTokens,
+            totalCost: totalsAcc.cost,
+        },
+    };
+}
+export function getProjectsResponse(options) {
+    const sessions = parseAllOpenClawSessions();
+    const tz = options?.timezone || 'Asia/Shanghai';
+    const projects = {};
+    for (const session of sessions) {
+        const projectName = session.agentId;
+        const dailyMap = new Map();
+        for (const ev of session.tokenEvents) {
+            if (options?.since && ev.timestampMs < options.since.getTime())
+                continue;
+            if (options?.until && ev.timestampMs > options.until.getTime())
+                continue;
+            const dayKey = getDateKey(ev.timestampMs, tz);
+            if (!dailyMap.has(dayKey))
+                dailyMap.set(dayKey, { acc: emptyAcc(), models: new Set() });
+            addEvent(dailyMap.get(dayKey).acc, ev);
+            dailyMap.get(dayKey).models.add(ev.model);
+        }
+        if (!projects[projectName])
+            projects[projectName] = [];
+        for (const [date, { acc, models }] of dailyMap) {
+            projects[projectName].push(accToEntry(date, acc, models));
+        }
+    }
+    for (const key of Object.keys(projects)) {
+        projects[key].sort((a, b) => a.date.localeCompare(b.date));
+    }
+    return { projects };
+}
+export function getBlocksResponse(options) {
+    const sessions = parseAllOpenClawSessions();
+    const tz = options?.timezone || 'Asia/Shanghai';
+    const grouped = new Map();
+    for (const session of sessions) {
+        if (options?.project && session.agentId !== options.project)
+            continue;
+        for (const ev of session.tokenEvents) {
+            if (options?.since && ev.timestampMs < options.since.getTime())
+                continue;
+            if (options?.until && ev.timestampMs > options.until.getTime())
+                continue;
+            const key = getHourKey(ev.timestampMs, tz);
+            if (!grouped.has(key))
+                grouped.set(key, { acc: emptyAcc(), models: new Set() });
+            addEvent(grouped.get(key).acc, ev);
+            grouped.get(key).models.add(ev.model);
+        }
+    }
+    const blocks = [];
+    let idx = 0;
+    for (const [hourKey, { acc, models }] of grouped) {
+        const [datePart, timePart] = hourKey.split(' ');
+        const hour = timePart.split(':')[0];
+        blocks.push({
+            id: `openclaw-hour-${idx}`,
+            startTime: `${datePart}T${hour}:00:00`,
+            endTime: `${datePart}T${hour}:59:59`,
+            actualEndTime: null,
+            isActive: false,
+            isGap: false,
+            entries: acc.totalTokens > 0 ? 1 : 0,
+            tokenCounts: {
+                inputTokens: acc.inputTokens,
+                outputTokens: acc.outputTokens,
+                cacheCreationInputTokens: acc.cacheWriteTokens,
+                cacheReadInputTokens: acc.cacheReadTokens,
+            },
+            totalTokens: acc.totalTokens,
+            costUSD: acc.cost,
+            models: [...models],
+        });
+        idx++;
+    }
+    blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+    return { blocks };
+}

package/dist/server/routes/api.js

@@ -3,7 +3,24 @@ 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) {
+    try {
+        const agents = await detectAvailableAgents();
+        const available = [];
+        if (agents.claude)
+            available.push('claude');
+        if (agents.codex)
+            available.push('codex');
+        res.json({ available, default: available[0] || null });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        res.status(500).json({ error: 'Failed to detect agents', hint: message });
+    }
+}
 export function registerApiRoutes(router) {
+    router.get('/agents', getAgents);
     router.get('/daily', getDaily);
     router.get('/monthly', getMonthly);
     router.get('/session', getSession);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhangferry-dev/tokendash",
-  "version": "1.1.0",
+  "version": "1.1.3",
   "type": "module",
   "description": "Token Usage Analytics Dashboard",
   "publishConfig": {
@@ -9,7 +9,7 @@
   "main": "./dist/server/index.js",
   "types": "./dist/server/index.d.ts",
   "bin": {
-    "tokendash": "./bin/tokendash.js"
+    "tokendash": "bin/tokendash.js"
   },
   "files": [
     "dist",