@zhangferry-dev/tokendash 1.0.0 → 1.1.0

package/dist/server/codexParser.js

@@ -0,0 +1,379 @@
+import { readFileSync, readdirSync, statSync, accessSync, constants } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { z } from 'zod';
+import { calculateCost } from './codexPricing.js';
+// ---------------------------------------------------------------------------
+// Zod schemas for JSONL event validation (format change detector)
+// ---------------------------------------------------------------------------
+const TokenUsageSchema = z.object({
+    input_tokens: z.number().default(0),
+    cached_input_tokens: z.number().default(0),
+    output_tokens: z.number().default(0),
+    reasoning_output_tokens: z.number().default(0),
+    total_tokens: z.number().default(0),
+}).default({ input_tokens: 0, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0, total_tokens: 0 });
+const TokenCountInfoSchema = z.object({
+    total_token_usage: TokenUsageSchema,
+    last_token_usage: TokenUsageSchema,
+}).nullable().default(null);
+const TokenCountPayloadSchema = z.object({
+    type: z.literal('token_count'),
+    info: TokenCountInfoSchema,
+});
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function getSessionsDir() {
+    return join(homedir(), '.codex', 'sessions');
+}
+export function isSessionsDirAccessible() {
+    try {
+        accessSync(getSessionsDir(), constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Recursively find all .jsonl files under ~/.codex/sessions/
+ */
+export function scanCodexSessions() {
+    const sessionsDir = getSessionsDir();
+    const results = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                walk(full);
+            }
+            else if (entry.endsWith('.jsonl')) {
+                results.push(full);
+            }
+        }
+    }
+    walk(sessionsDir);
+    return results.sort();
+}
+/**
+ * Parse a single Codex session JSONL file.
+ *
+ * CRITICAL INVARIANT: Sum ALL token_count events without any deduplication.
+ * Each Codex turn emits TWO token_count events with identical last_token_usage
+ * values (~1-2s apart) — one for reasoning, one for output completion.
+ * Both are distinct billable events. Deduplicating would produce the wrong
+ * total (4.7M instead of the correct 9.2M).
+ */
+export function parseCodexSession(filepath) {
+    let content;
+    try {
+        content = readFileSync(filepath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const lines = content.split('\n');
+    let sessionId = '';
+    let cwd = '';
+    let model = '';
+    let createdAt = '';
+    const tokenEvents = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const type = obj.type;
+        if (type === 'session_meta') {
+            const payload = obj.payload || {};
+            sessionId = payload.id || '';
+            cwd = payload.cwd || '';
+            createdAt = payload.timestamp || '';
+        }
+        if (type === 'turn_context') {
+            const payload = obj.payload || {};
+            if (!model && payload.model) {
+                model = payload.model;
+            }
+        }
+        // Extract token counts from event_msg with nested token_count payload.
+        // NEVER deduplicate — see invariant comment above.
+        if (type === 'event_msg') {
+            const payload = obj.payload || {};
+            if (payload.type === 'token_count') {
+                const timestamp = obj.timestamp || '';
+                const parseResult = TokenCountPayloadSchema.safeParse(payload);
+                if (!parseResult.success) {
+                    console.warn(`[codexParser] Schema validation failed in ${filepath}:`, parseResult.error.message);
+                    continue;
+                }
+                const info = parseResult.data.info;
+                if (!info)
+                    continue;
+                const last = info.last_token_usage;
+                tokenEvents.push({
+                    timestamp,
+                    inputTokens: last.input_tokens,
+                    cachedInputTokens: last.cached_input_tokens,
+                    outputTokens: last.output_tokens,
+                    reasoningOutputTokens: last.reasoning_output_tokens,
+                    totalTokens: last.total_tokens,
+                });
+            }
+        }
+    }
+    if (!sessionId)
+        return null;
+    return { id: sessionId, cwd, model, createdAt, tokenEvents };
+}
+/** Parse all Codex sessions. */
+export function parseAllSessions() {
+    return scanCodexSessions()
+        .map(parseCodexSession)
+        .filter((s) => s !== null);
+}
+// ---------------------------------------------------------------------------
+// Date/timezone helpers
+// ---------------------------------------------------------------------------
+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; // Default Asia/Shanghai
+}
+function toLocalISO(ts, tz) {
+    const d = new Date(ts);
+    return new Date(d.getTime() + getTzOffsetHours(tz) * 3600_000);
+}
+function getDateKey(ts, tz) {
+    return toLocalISO(ts, tz).toISOString().slice(0, 10);
+}
+function getHourKey(ts, tz) {
+    const local = toLocalISO(ts, tz);
+    return local.toISOString().slice(0, 13).replace('T', ' ') + ':00';
+}
+function getMonthKey(ts, tz) {
+    return getDateKey(ts, tz).slice(0, 7);
+}
+function extractProjectName(cwd) {
+    if (!cwd)
+        return 'unknown';
+    const parts = cwd.replace(/\/+$/, '').split('/');
+    return parts[parts.length - 1] || 'unknown';
+}
+// ---------------------------------------------------------------------------
+// Core aggregation
+// ---------------------------------------------------------------------------
+function emptyAcc() {
+    return { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0, totalTokens: 0 };
+}
+function addAcc(a, ev) {
+    a.inputTokens += ev.inputTokens;
+    a.cachedInputTokens += ev.cachedInputTokens;
+    a.outputTokens += ev.outputTokens;
+    a.reasoningOutputTokens += ev.reasoningOutputTokens;
+    a.totalTokens += ev.totalTokens;
+}
+function mergeAcc(a, b) {
+    a.inputTokens += b.inputTokens;
+    a.cachedInputTokens += b.cachedInputTokens;
+    a.outputTokens += b.outputTokens;
+    a.reasoningOutputTokens += b.reasoningOutputTokens;
+    a.totalTokens += b.totalTokens;
+}
+function accToEntry(date, acc, models) {
+    const cost = calculateCost(acc, models);
+    return {
+        date,
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+        cacheCreationTokens: 0,
+        cacheReadTokens: acc.cachedInputTokens,
+        totalTokens: acc.totalTokens,
+        totalCost: cost,
+        modelsUsed: [...models],
+        modelBreakdowns: buildModelBreakdowns(acc, models, cost),
+    };
+}
+function buildModelBreakdowns(acc, models, totalCost) {
+    const modelList = [...models];
+    if (modelList.length === 0)
+        return [];
+    const costPerModel = totalCost / modelList.length;
+    return modelList.map(name => ({
+        modelName: name,
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+        cacheCreationTokens: 0,
+        cacheReadTokens: acc.cachedInputTokens,
+        cost: costPerModel,
+    }));
+}
+function groupSessions(sessions, options) {
+    const tz = options.timezone || 'Asia/Shanghai';
+    const grouped = new Map();
+    for (const session of sessions) {
+        if (options.project && extractProjectName(session.cwd) !== options.project)
+            continue;
+        for (const ev of session.tokenEvents) {
+            const evDate = new Date(ev.timestamp);
+            if (options.since && evDate < options.since)
+                continue;
+            if (options.until && evDate > options.until)
+                continue;
+            let key;
+            switch (options.groupBy) {
+                case 'hour':
+                    key = getHourKey(ev.timestamp, tz);
+                    break;
+                case 'month':
+                    key = getMonthKey(ev.timestamp, tz);
+                    break;
+                case 'session':
+                    key = session.id;
+                    break;
+                case 'project':
+                    key = extractProjectName(session.cwd);
+                    break;
+                default:
+                    key = getDateKey(ev.timestamp, tz);
+                    break;
+            }
+            if (!grouped.has(key)) {
+                grouped.set(key, { acc: emptyAcc(), models: new Set() });
+            }
+            const entry = grouped.get(key);
+            addAcc(entry.acc, ev);
+            if (session.model)
+                entry.models.add(session.model);
+        }
+    }
+    return grouped;
+}
+// ---------------------------------------------------------------------------
+// Public API — response builders for route handlers
+// ---------------------------------------------------------------------------
+/** Aggregate and return DailyResponse format (for /daily?agent=codex) */
+export function getDailyResponse(options) {
+    const sessions = parseAllSessions();
+    const grouped = groupSessions(sessions, { groupBy: 'day', ...options });
+    const daily = [];
+    const totalsAcc = emptyAcc();
+    for (const [date, { acc, models }] of grouped) {
+        daily.push(accToEntry(date, acc, models));
+        mergeAcc(totalsAcc, acc);
+    }
+    // Sort by date ascending
+    daily.sort((a, b) => a.date.localeCompare(b.date));
+    const models = new Set();
+    for (const s of sessions)
+        if (s.model)
+            models.add(s.model);
+    const totalCost = calculateCost(totalsAcc, models);
+    return {
+        daily,
+        totals: {
+            inputTokens: totalsAcc.inputTokens,
+            outputTokens: totalsAcc.outputTokens,
+            cacheCreationTokens: 0,
+            cacheReadTokens: totalsAcc.cachedInputTokens,
+            totalTokens: totalsAcc.totalTokens,
+            totalCost,
+        },
+    };
+}
+/** Aggregate and return ProjectsResponse format (for /projects?agent=codex) */
+export function getProjectsResponse(options) {
+    const sessions = parseAllSessions();
+    const tz = options?.timezone || 'Asia/Shanghai';
+    const projects = {};
+    for (const session of sessions) {
+        const projectName = extractProjectName(session.cwd);
+        // Per-project daily grouping
+        const dailyMap = new Map();
+        for (const ev of session.tokenEvents) {
+            const evDate = new Date(ev.timestamp);
+            if (options?.since && evDate < options.since)
+                continue;
+            if (options?.until && evDate > options.until)
+                continue;
+            const dayKey = getDateKey(ev.timestamp, tz);
+            if (!dailyMap.has(dayKey)) {
+                dailyMap.set(dayKey, { acc: emptyAcc(), models: new Set() });
+            }
+            addAcc(dailyMap.get(dayKey).acc, ev);
+            if (session.model)
+                dailyMap.get(dayKey).models.add(session.model);
+        }
+        if (!projects[projectName])
+            projects[projectName] = [];
+        for (const [date, { acc, models }] of dailyMap) {
+            projects[projectName].push(accToEntry(date, acc, models));
+        }
+    }
+    // Sort each project's daily entries
+    for (const key of Object.keys(projects)) {
+        projects[key].sort((a, b) => a.date.localeCompare(b.date));
+    }
+    return { projects };
+}
+/** Aggregate and return BlocksResponse format (hourly, for /blocks?agent=codex) */
+export function getBlocksResponse(options) {
+    const sessions = parseAllSessions();
+    const grouped = groupSessions(sessions, { groupBy: 'hour', ...options });
+    const blocks = [];
+    let idx = 0;
+    for (const [hourKey, { acc, models }] of grouped) {
+        const cost = calculateCost(acc, models);
+        const [datePart, timePart] = hourKey.split(' ');
+        const hour = timePart.split(':')[0];
+        blocks.push({
+            id: `codex-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: 0,
+                cacheReadInputTokens: acc.cachedInputTokens,
+            },
+            totalTokens: acc.totalTokens,
+            costUSD: cost,
+            models: [...models],
+        });
+        idx++;
+    }
+    // Sort by startTime
+    blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+    return { blocks };
+}

package/dist/server/codexPricing.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Codex token pricing configuration.
+ *
+ * Pricing formula (confirmed by reverse-engineering @ccusage/codex):
+ *   cost = (inputTokens - cachedInputTokens) * input_rate
+ *        + cachedInputTokens * cached_rate
+ *        + outputTokens * output_rate
+ *
+ * Reasoning tokens are NOT billed separately (included in outputTokens).
+ *
+ * Update rates from https://openai.com/api/pricing/ when models change.
+ * All prices are USD per 1M tokens.
+ */
+interface ModelPricing {
+    inputPer1M: number;
+    cachedInputPer1M: number;
+    outputPer1M: number;
+}
+interface TokenCounts {
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    reasoningOutputTokens: number;
+    totalTokens: number;
+}
+/**
+ * Calculate cost in USD from token counts and model pricing.
+ * Matches the @ccusage/codex calculateCostUSD function exactly.
+ */
+export declare function calculateCost(tokens: TokenCounts, models: Set<string>): number;
+export declare function getModelPricing(model: string): ModelPricing;
+export {};

package/dist/server/codexPricing.js

@@ -0,0 +1,43 @@
+/**
+ * Codex token pricing configuration.
+ *
+ * Pricing formula (confirmed by reverse-engineering @ccusage/codex):
+ *   cost = (inputTokens - cachedInputTokens) * input_rate
+ *        + cachedInputTokens * cached_rate
+ *        + outputTokens * output_rate
+ *
+ * Reasoning tokens are NOT billed separately (included in outputTokens).
+ *
+ * Update rates from https://openai.com/api/pricing/ when models change.
+ * All prices are USD per 1M tokens.
+ */
+const MODEL_PRICING = {
+    'gpt-5.4': {
+        inputPer1M: 2.50,
+        cachedInputPer1M: 0.25,
+        outputPer1M: 15.00,
+    },
+};
+const DEFAULT_PRICING = {
+    inputPer1M: 2.50,
+    cachedInputPer1M: 0.25,
+    outputPer1M: 15.00,
+};
+/**
+ * Calculate cost in USD from token counts and model pricing.
+ * Matches the @ccusage/codex calculateCostUSD function exactly.
+ */
+export function calculateCost(tokens, models) {
+    const model = [...models][0] ?? '';
+    const pricing = MODEL_PRICING[model] ?? DEFAULT_PRICING;
+    const nonCachedInput = Math.max(tokens.inputTokens - tokens.cachedInputTokens, 0);
+    const cachedInput = Math.min(tokens.cachedInputTokens, tokens.inputTokens);
+    const outputTokens = tokens.outputTokens;
+    const inputCost = (nonCachedInput / 1_000_000) * pricing.inputPer1M;
+    const cachedCost = (cachedInput / 1_000_000) * pricing.cachedInputPer1M;
+    const outputCost = (outputTokens / 1_000_000) * pricing.outputPer1M;
+    return inputCost + cachedCost + outputCost;
+}
+export function getModelPricing(model) {
+    return MODEL_PRICING[model] ?? DEFAULT_PRICING;
+}

package/dist/server/routes/blocks.js

@@ -1,15 +1,40 @@
 import { runCcusage } from '../ccusage.js';
 import { cache } from '../cache.js';
 import { validateBlocks } from '../../shared/schemas.js';
-import { emptyBlocksResponse } from '../codexNormalizer.js';
+import { getBlocksResponse } from '../codexParser.js';
+import { getClaudeBlocksByProject } from '../claudeBlocksParser.js';
 export async function getBlocks(req, res) {
     const agent = req.query.agent || 'claude';
-    const cacheKey = `blocks:${agent}`;
+    const project = req.query.project || undefined;
     try {
         if (agent === 'codex') {
-            res.json(emptyBlocksResponse());
+            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 cached = cache.get(cacheKey);
         if (cached) {
             res.json(cached);

package/dist/server/routes/daily.js

@@ -1,7 +1,7 @@
-import { runCcusage, runCodex } from '../ccusage.js';
+import { runCcusage } from '../ccusage.js';
 import { cache } from '../cache.js';
 import { validateDaily } from '../../shared/schemas.js';
-import { normalizeCodexDailyResponse } from '../codexNormalizer.js';
+import { getDailyResponse } from '../codexParser.js';
 export async function getDaily(req, res) {
     const agent = req.query.agent || 'claude';
     const cacheKey = `daily:${agent}`;
@@ -12,11 +12,9 @@ export async function getDaily(req, res) {
             return;
         }
         if (agent === 'codex') {
-            const stdout = await runCodex(['daily']);
-            const data = JSON.parse(stdout);
-            const normalized = normalizeCodexDailyResponse(data);
-            cache.set(cacheKey, normalized);
-            res.json(normalized);
+            const data = getDailyResponse();
+            cache.set(cacheKey, data);
+            res.json(data);
         }
         else {
             const stdout = await runCcusage(['daily', '--breakdown']);

package/dist/server/routes/projects.js

@@ -1,7 +1,7 @@
-import { runCcusage, runCodex } from '../ccusage.js';
+import { runCcusage } from '../ccusage.js';
 import { cache } from '../cache.js';
 import { validateProjects } from '../../shared/schemas.js';
-import { normalizeCodexProjectsResponse } from '../codexNormalizer.js';
+import { getProjectsResponse } from '../codexParser.js';
 export async function getProjects(req, res) {
     const agent = req.query.agent || 'claude';
     const cacheKey = `projects:${agent}`;
@@ -12,11 +12,9 @@ export async function getProjects(req, res) {
             return;
         }
         if (agent === 'codex') {
-            const stdout = await runCodex(['daily']);
-            const data = JSON.parse(stdout);
-            const normalized = normalizeCodexProjectsResponse(data);
-            cache.set(cacheKey, normalized);
-            res.json(normalized);
+            const data = getProjectsResponse();
+            cache.set(cacheKey, data);
+            res.json(data);
         }
         else {
             const stdout = await runCcusage(['daily', '--instances', '--breakdown']);