npm - @zhangferry-dev/tokendash - Versions diffs - 1.0.1 → 1.1.2 - Mend

@zhangferry-dev/tokendash 1.0.1 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/dist/client/assets/index-BaY47OM2.css +1 -0
package/dist/client/assets/{index-DOeZtR1c.js → index-CVEOcjaP.js} +50 -50
package/dist/client/index.html +3 -3
package/dist/server/ccusage.d.ts +0 -1
package/dist/server/ccusage.js +6 -10
package/dist/server/claudeBlocksParser.d.ts +6 -0
package/dist/server/claudeBlocksParser.js +150 -0
package/dist/server/codexParser.d.ts +47 -0
package/dist/server/codexParser.js +379 -0
package/dist/server/codexPricing.d.ts +32 -0
package/dist/server/codexPricing.js +43 -0
package/dist/server/index.js +97 -12
package/dist/server/routes/blocks.js +28 -3
package/dist/server/routes/daily.js +5 -7
package/dist/server/routes/projects.js +5 -7
package/dist/shared/schemas.d.ts +17 -17
package/package.json +2 -2
package/dist/client/assets/index-C9UxEhwo.css +0 -1
package/dist/server/codexNormalizer.d.ts +0 -4
package/dist/server/codexNormalizer.js +0 -50

package/dist/client/index.html CHANGED Viewed

@@ -3,10 +3,10 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>ccusage dashboard</title>
+    <title>TokenDash</title>
     <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'><text y='28' font-size='28'>⚡</text></svg>" />
-    <script type="module" crossorigin src="/assets/index-DOeZtR1c.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C9UxEhwo.css">
+    <script type="module" crossorigin src="/assets/index-CVEOcjaP.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BaY47OM2.css">
   </head>
   <body class="antialiased" style="background:#faf9f7">
     <div id="root"></div>

package/dist/server/ccusage.d.ts CHANGED Viewed

@@ -1,3 +1,2 @@
 export declare function runCcusage(args: string[], timeout?: number): Promise<string>;
-export declare function runCodex(args: string[], timeout?: number): Promise<string>;
 export declare function ensureUsageToolsReady(): Promise<void>;

package/dist/server/ccusage.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { isSessionsDirAccessible } from './codexParser.js';
 const execFileAsync = promisify(execFile);
 function withJsonFlag(args, asJson) {
     if (!asJson || args.includes('--json')) {
@@ -39,19 +40,14 @@ async function runCcusageCommand(args, timeout, asJson) {
         throw error;
     }
 }
-async function runCodexCommand(args, timeout, asJson) {
-    return runCommand({
-        command: 'npx',
-        args: ['--yes', '@ccusage/codex@latest', ...withJsonFlag(args, asJson)],
-    }, timeout);
-}
 export async function runCcusage(args, timeout = 30_000) {
     return runCcusageCommand(args, timeout, true);
 }
-export async function runCodex(args, timeout = 30_000) {
-    return runCodexCommand(args, timeout, true);
-}
 export async function ensureUsageToolsReady() {
+    // Claude Code: check ccusage CLI
     await runCcusageCommand(['--version'], 120_000, false);
-    await runCodexCommand(['--help'], 120_000, false);
+    // Codex: check local sessions directory (instant, no npm subprocess)
+    if (!isSessionsDirAccessible()) {
+        throw new Error('Codex sessions directory not found at ~/.codex/sessions/');
+    }
 }

package/dist/server/claudeBlocksParser.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import type { BlockEntry } from '../shared/types.js';
+/**
+ * Parse Claude Code JSONL files and return hourly blocks, optionally filtered by project.
+ * Only returns blocks for the specified project (or all if project is empty).
+ */
+export declare function getClaudeBlocksByProject(project: string): BlockEntry[];

package/dist/server/claudeBlocksParser.js ADDED Viewed

@@ -0,0 +1,150 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Zod schemas for Claude JSONL usage validation
+// ---------------------------------------------------------------------------
+const ClaudeUsageSchema = z.object({
+    input_tokens: z.number().default(0),
+    output_tokens: z.number().default(0),
+    cache_creation_input_tokens: z.number().default(0),
+    cache_read_input_tokens: z.number().default(0),
+}).passthrough().default({});
+const ClaudeMessageSchema = z.object({
+    usage: ClaudeUsageSchema,
+    model: z.string().optional(),
+}).passthrough();
+const ClaudeEventSchema = z.object({
+    type: z.string(),
+    timestamp: z.string(),
+    message: ClaudeMessageSchema.optional(),
+}).passthrough();
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+/** Extract project display name from encoded directory path.
+ *  -Users-zhangferry-AI-Ideas → Ideas
+ *  -Users-zhangferry-Desktop-Develop-DailyNewsReport → DailyNewsReport
+ */
+function extractProjectName(dirName) {
+    const parts = dirName.replace(/^-/, '').split('-');
+    return parts[parts.length - 1] || dirName;
+}
+/** Match project display name against a filter (also normalizes the filter) */
+function matchesProject(dirName, filter) {
+    return extractProjectName(dirName) === extractProjectName(filter);
+}
+function getHourKey(timestamp) {
+    const d = new Date(timestamp);
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    const hh = String(d.getHours()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}T${hh}`;
+}
+/**
+ * Parse Claude Code JSONL files and return hourly blocks, optionally filtered by project.
+ * Only returns blocks for the specified project (or all if project is empty).
+ */
+export function getClaudeBlocksByProject(project) {
+    if (!existsSync(CLAUDE_PROJECTS_DIR))
+        return [];
+    const hourMap = new Map();
+    const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+    for (const dirName of projectDirs) {
+        // If a project filter is set, skip non-matching directories
+        if (project && !matchesProject(dirName, project))
+            continue;
+        const dirPath = join(CLAUDE_PROJECTS_DIR, dirName);
+        let files;
+        try {
+            files = readdirSync(dirPath).filter(f => f.endsWith('.jsonl'));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const filePath = join(dirPath, file);
+            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 parsed;
+                try {
+                    parsed = JSON.parse(trimmed);
+                }
+                catch {
+                    continue;
+                }
+                // Only process assistant events with usage data
+                const result = ClaudeEventSchema.safeParse(parsed);
+                if (!result.success)
+                    continue;
+                const event = result.data;
+                if (event.type !== 'assistant' || !event.message)
+                    continue;
+                const usage = event.message.usage;
+                const inputTokens = usage.input_tokens;
+                const outputTokens = usage.output_tokens;
+                const cacheCreationTokens = usage.cache_creation_input_tokens;
+                const cacheReadTokens = usage.cache_read_input_tokens;
+                const totalTokens = inputTokens + outputTokens + cacheReadTokens;
+                if (totalTokens === 0)
+                    continue;
+                const hourKey = getHourKey(event.timestamp);
+                if (!hourMap.has(hourKey)) {
+                    hourMap.set(hourKey, {
+                        inputTokens: 0, outputTokens: 0,
+                        cacheCreationTokens: 0, cacheReadTokens: 0,
+                        models: new Set(),
+                    });
+                }
+                const bucket = hourMap.get(hourKey);
+                bucket.inputTokens += inputTokens;
+                bucket.outputTokens += outputTokens;
+                bucket.cacheCreationTokens += cacheCreationTokens;
+                bucket.cacheReadTokens += cacheReadTokens;
+                if (event.message.model)
+                    bucket.models.add(event.message.model);
+            }
+        }
+    }
+    // Convert hour map to BlockEntry[]
+    const blocks = [];
+    let idx = 0;
+    for (const [hourKey, bucket] of hourMap) {
+        const totalTokens = bucket.inputTokens + bucket.outputTokens + bucket.cacheReadTokens;
+        blocks.push({
+            id: `claude-project-${idx}`,
+            startTime: `${hourKey}:00:00.000Z`,
+            endTime: `${hourKey}:59:59.999Z`,
+            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: 0,
+            models: [...bucket.models],
+        });
+        idx++;
+    }
+    blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+    return blocks;
+}

package/dist/server/codexParser.d.ts ADDED Viewed

@@ -0,0 +1,47 @@
+import type { DailyResponse, ProjectsResponse, BlocksResponse } from '../shared/types.js';
+interface ParsedTokenEvent {
+    timestamp: string;
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    reasoningOutputTokens: number;
+    totalTokens: number;
+}
+export interface ParsedSession {
+    id: string;
+    cwd: string;
+    model: string;
+    createdAt: string;
+    tokenEvents: ParsedTokenEvent[];
+}
+export interface AggregateOptions {
+    groupBy: 'day' | 'hour' | 'month' | 'session' | 'project';
+    project?: string | null;
+    since?: Date | null;
+    until?: Date | null;
+    timezone?: string;
+}
+export declare function isSessionsDirAccessible(): boolean;
+/**
+ * Recursively find all .jsonl files under ~/.codex/sessions/
+ */
+export declare function scanCodexSessions(): string[];
+/**
+ * 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 declare function parseCodexSession(filepath: string): ParsedSession | null;
+/** Parse all Codex sessions. */
+export declare function parseAllSessions(): ParsedSession[];
+/** Aggregate and return DailyResponse format (for /daily?agent=codex) */
+export declare function getDailyResponse(options?: Partial<AggregateOptions>): DailyResponse;
+/** Aggregate and return ProjectsResponse format (for /projects?agent=codex) */
+export declare function getProjectsResponse(options?: Partial<AggregateOptions>): ProjectsResponse;
+/** Aggregate and return BlocksResponse format (hourly, for /blocks?agent=codex) */
+export declare function getBlocksResponse(options?: Partial<AggregateOptions>): BlocksResponse;
+export {};

package/dist/server/codexParser.js ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 {};