@zhangferry-dev/tokendash 1.4.0 → 1.5.0

package/dist/server/analyticsParser.js

@@ -48,9 +48,56 @@ function countLines(text) {
 // Claude Code session scanning & tool extraction
 // ---------------------------------------------------------------------------
 const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+const projectNameCache = new Map();
+/** Decode Claude's encoded project directory name.
+ *  Claude encodes paths: /Users/foo/bar → -Users-foo-bar
+ *  Since '-' replaces '/' and project names can contain '-',
+ *  we use filesystem checks to find the correct last segment.
+ */
 function extractProjectName(dirName) {
-    const parts = dirName.replace(/^-/, '').split('-');
-    return parts[parts.length - 1] || dirName;
+    if (!dirName.startsWith('-'))
+        return dirName;
+    const cached = projectNameCache.get(dirName);
+    if (cached)
+        return cached;
+    const segments = dirName.replace(/^-/, '').split('-').filter(Boolean);
+    if (segments.length === 0) {
+        projectNameCache.set(dirName, dirName);
+        return dirName;
+    }
+    if (segments.length === 1) {
+        projectNameCache.set(dirName, segments[0]);
+        return segments[0];
+    }
+    let bestName = segments[segments.length - 1];
+    for (let splitAt = segments.length - 1; splitAt >= 1; splitAt--) {
+        const parentSegments = segments.slice(0, splitAt);
+        const candidateName = segments.slice(splitAt).join('-');
+        let parentPath = '/';
+        let valid = true;
+        for (const seg of parentSegments) {
+            const regular = join(parentPath, seg);
+            const hidden = join(parentPath, '.' + seg);
+            if (existsSync(regular)) {
+                parentPath = regular;
+            }
+            else if (existsSync(hidden)) {
+                parentPath = hidden;
+            }
+            else {
+                valid = false;
+                break;
+            }
+        }
+        if (!valid)
+            continue;
+        if (existsSync(join(parentPath, candidateName)) || existsSync(join(parentPath, '.' + candidateName))) {
+            bestName = candidateName;
+            break;
+        }
+    }
+    projectNameCache.set(dirName, bestName);
+    return bestName;
 }
 function matchesProject(dirName, filter) {
     return extractProjectName(dirName) === extractProjectName(filter);
@@ -273,5 +320,22 @@ export function computeAnalytics(toolCalls, timezone = 'Asia/Shanghai') {
         toolCallTrend.push(entry);
     }
     toolCallTrend.sort((a, b) => a.date.localeCompare(b.date));
+    // Fill missing tool values with 0 so chart lines don't break
+    if (toolCallTrend.length > 0) {
+        const allTools = new Set();
+        for (const entry of toolCallTrend) {
+            for (const key of Object.keys(entry)) {
+                if (key !== 'date')
+                    allTools.add(key);
+            }
+        }
+        for (const entry of toolCallTrend) {
+            for (const tool of allTools) {
+                if (entry[tool] === undefined) {
+                    entry[tool] = 0;
+                }
+            }
+        }
+    }
     return { codeChangeTrend, toolUsageDistribution, productivityKPIs, toolCallTrend };
 }

package/dist/server/claudeBlocksParser.js

@@ -24,13 +24,56 @@ const ClaudeEventSchema = z.object({
 // 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
+const projectNameCache = new Map();
+/** Decode Claude's encoded project directory name.
+ *  Claude encodes paths: /Users/foo/bar → -Users-foo-bar
+ *  Since '-' replaces '/' and project names can contain '-',
+ *  we use filesystem checks to find the correct last segment.
  */
 function extractProjectName(dirName) {
-    const parts = dirName.replace(/^-/, '').split('-');
-    return parts[parts.length - 1] || dirName;
+    if (!dirName.startsWith('-'))
+        return dirName;
+    const cached = projectNameCache.get(dirName);
+    if (cached)
+        return cached;
+    const segments = dirName.replace(/^-/, '').split('-').filter(Boolean);
+    if (segments.length === 0) {
+        projectNameCache.set(dirName, dirName);
+        return dirName;
+    }
+    if (segments.length === 1) {
+        projectNameCache.set(dirName, segments[0]);
+        return segments[0];
+    }
+    let bestName = segments[segments.length - 1];
+    for (let splitAt = segments.length - 1; splitAt >= 1; splitAt--) {
+        const parentSegments = segments.slice(0, splitAt);
+        const candidateName = segments.slice(splitAt).join('-');
+        let parentPath = '/';
+        let valid = true;
+        for (const seg of parentSegments) {
+            const regular = join(parentPath, seg);
+            const hidden = join(parentPath, '.' + seg);
+            if (existsSync(regular)) {
+                parentPath = regular;
+            }
+            else if (existsSync(hidden)) {
+                parentPath = hidden;
+            }
+            else {
+                valid = false;
+                break;
+            }
+        }
+        if (!valid)
+            continue;
+        if (existsSync(join(parentPath, candidateName)) || existsSync(join(parentPath, '.' + candidateName))) {
+            bestName = candidateName;
+            break;
+        }
+    }
+    projectNameCache.set(dirName, bestName);
+    return bestName;
 }
 /** Match project display name against a filter (also normalizes the filter) */
 function matchesProject(dirName, filter) {

package/dist/server/claudeJsonlParser.d.ts

@@ -1,5 +1,11 @@
 import type { DailyResponse, ProjectsResponse, BlockEntry } from '../shared/types.js';
 export declare function calculateCost(inputTokens: number, cacheReadTokens: number, outputTokens: number, model: string): number;
+/** Decode Claude's encoded project directory name.
+ *  Claude encodes paths: /Users/foo/bar → -Users-foo-bar
+ *  Since '-' replaces '/' and project names can contain '-',
+ *  we use filesystem checks to find the correct last segment.
+ */
+export declare function extractProjectName(dirName: string): string;
 export declare function getDateKey(timestamp: string, tz: string): string;
 export declare function getHourKey(timestamp: string, tz: string): string;
 export declare function getDailyResponse(project?: string | null, tz?: string): DailyResponse;

package/dist/server/claudeJsonlParser.js

@@ -38,9 +38,58 @@ export function calculateCost(inputTokens, cacheReadTokens, outputTokens, model)
 // ---------------------------------------------------------------------------
 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;
+const projectNameCache = new Map();
+/** Decode Claude's encoded project directory name.
+ *  Claude encodes paths: /Users/foo/bar → -Users-foo-bar
+ *  Since '-' replaces '/' and project names can contain '-',
+ *  we use filesystem checks to find the correct last segment.
+ */
+export function extractProjectName(dirName) {
+    if (!dirName.startsWith('-'))
+        return dirName;
+    const cached = projectNameCache.get(dirName);
+    if (cached)
+        return cached;
+    const segments = dirName.replace(/^-/, '').split('-').filter(Boolean);
+    if (segments.length === 0) {
+        projectNameCache.set(dirName, dirName);
+        return dirName;
+    }
+    if (segments.length === 1) {
+        projectNameCache.set(dirName, segments[0]);
+        return segments[0];
+    }
+    let bestName = segments[segments.length - 1];
+    // Try from right: find the longest last segment that forms a valid path
+    for (let splitAt = segments.length - 1; splitAt >= 1; splitAt--) {
+        const parentSegments = segments.slice(0, splitAt);
+        const candidateName = segments.slice(splitAt).join('-');
+        // Build parent path, handling hidden directories (dot prefix)
+        let parentPath = '/';
+        let valid = true;
+        for (const seg of parentSegments) {
+            const regular = join(parentPath, seg);
+            const hidden = join(parentPath, '.' + seg);
+            if (existsSync(regular)) {
+                parentPath = regular;
+            }
+            else if (existsSync(hidden)) {
+                parentPath = hidden;
+            }
+            else {
+                valid = false;
+                break;
+            }
+        }
+        if (!valid)
+            continue;
+        if (existsSync(join(parentPath, candidateName)) || existsSync(join(parentPath, '.' + candidateName))) {
+            bestName = candidateName;
+            break;
+        }
+    }
+    projectNameCache.set(dirName, bestName);
+    return bestName;
 }
 function matchesProject(dirName, filter) {
     return extractProjectName(dirName) === extractProjectName(filter);
@@ -228,7 +277,7 @@ export function getProjectsResponse(tz = DEFAULT_TZ) {
     const projectMap = new Map();
     for (const e of entries) {
         const date = getDateKey(e.timestamp, tz);
-        const projectName = e.projectDir;
+        const projectName = extractProjectName(e.projectDir);
         if (!projectMap.has(projectName)) {
             projectMap.set(projectName, new Map());
         }

package/dist/server/codexParser.d.ts

@@ -1,5 +1,5 @@
 import type { DailyResponse, ProjectsResponse, BlocksResponse } from '../shared/types.js';
-interface ParsedTokenEvent {
+export interface ParsedTokenEvent {
     timestamp: string;
     inputTokens: number;
     cachedInputTokens: number;
@@ -29,19 +29,22 @@ 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).
+ * Codex can emit duplicate token_count events for the same turn, with identical
+ * total_token_usage and last_token_usage snapshots a few seconds apart. These
+ * are repeated status updates, not separate billable usage records, so only the
+ * first occurrence of each cumulative total_token_usage snapshot should count.
  */
 export declare function parseCodexSession(filepath: string): ParsedSession | null;
 /** Parse all Codex sessions. */
 export declare function parseAllSessions(): ParsedSession[];
+export declare function buildCodexResponsesFromSessions(sessions: ParsedSession[], options?: Partial<AggregateOptions>): {
+    daily: DailyResponse;
+    projects: ProjectsResponse;
+    blocks: BlocksResponse;
+};
 /** 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

@@ -21,6 +21,15 @@ const TokenCountPayloadSchema = z.object({
     type: z.literal('token_count'),
     info: TokenCountInfoSchema,
 });
+function tokenUsageKey(usage) {
+    return [
+        usage.input_tokens,
+        usage.cached_input_tokens,
+        usage.output_tokens,
+        usage.reasoning_output_tokens,
+        usage.total_tokens,
+    ].join(':');
+}
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -73,11 +82,10 @@ export function scanCodexSessions() {
 /**
  * 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).
+ * Codex can emit duplicate token_count events for the same turn, with identical
+ * total_token_usage and last_token_usage snapshots a few seconds apart. These
+ * are repeated status updates, not separate billable usage records, so only the
+ * first occurrence of each cumulative total_token_usage snapshot should count.
  */
 export function parseCodexSession(filepath) {
     let content;
@@ -93,6 +101,7 @@ export function parseCodexSession(filepath) {
     let model = '';
     let createdAt = '';
     const tokenEvents = [];
+    const seenTotalUsageSnapshots = new Set();
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -118,7 +127,6 @@ export function parseCodexSession(filepath) {
             }
         }
         // 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') {
@@ -131,6 +139,10 @@ export function parseCodexSession(filepath) {
                 const info = parseResult.data.info;
                 if (!info)
                     continue;
+                const totalUsageKey = tokenUsageKey(info.total_token_usage);
+                if (seenTotalUsageSnapshots.has(totalUsageKey))
+                    continue;
+                seenTotalUsageSnapshots.add(totalUsageKey);
                 const last = info.last_token_usage;
                 tokenEvents.push({
                     timestamp,
@@ -207,8 +219,18 @@ function mergeAcc(a, b) {
     a.reasoningOutputTokens += b.reasoningOutputTokens;
     a.totalTokens += b.totalTokens;
 }
-function accToEntry(date, acc, models) {
-    const cost = calculateCost(acc, models);
+function addAccToBucket(bucket, ev, model) {
+    addAcc(bucket.acc, ev);
+    if (!model)
+        return;
+    if (!bucket.models.has(model))
+        bucket.models.set(model, emptyAcc());
+    addAcc(bucket.models.get(model), ev);
+}
+function accToEntry(date, acc, modelAccs) {
+    const modelNames = [...modelAccs.keys()];
+    const modelBreakdowns = buildModelBreakdowns(modelAccs);
+    const totalCost = modelBreakdowns.reduce((sum, model) => sum + model.cost, 0);
     return {
         date,
         inputTokens: acc.inputTokens,
@@ -216,23 +238,19 @@ function accToEntry(date, acc, models) {
         cacheCreationTokens: 0,
         cacheReadTokens: acc.cachedInputTokens,
         totalTokens: acc.totalTokens,
-        totalCost: cost,
-        modelsUsed: [...models],
-        modelBreakdowns: buildModelBreakdowns(acc, models, cost),
+        totalCost,
+        modelsUsed: modelNames,
+        modelBreakdowns,
     };
 }
-function buildModelBreakdowns(acc, models, totalCost) {
-    const modelList = [...models];
-    if (modelList.length === 0)
-        return [];
-    const costPerModel = totalCost / modelList.length;
-    return modelList.map(name => ({
-        modelName: name,
+function buildModelBreakdowns(modelAccs) {
+    return [...modelAccs.entries()].map(([modelName, acc]) => ({
+        modelName,
         inputTokens: acc.inputTokens,
         outputTokens: acc.outputTokens,
         cacheCreationTokens: 0,
         cacheReadTokens: acc.cachedInputTokens,
-        cost: costPerModel,
+        cost: calculateCost(acc, new Set([modelName])),
     }));
 }
 function groupSessions(sessions, options) {
@@ -266,12 +284,9 @@ function groupSessions(sessions, options) {
                     break;
             }
             if (!grouped.has(key)) {
-                grouped.set(key, { acc: emptyAcc(), models: new Set() });
+                grouped.set(key, { acc: emptyAcc(), models: new Map() });
             }
-            const entry = grouped.get(key);
-            addAcc(entry.acc, ev);
-            if (session.model)
-                entry.models.add(session.model);
+            addAccToBucket(grouped.get(key), ev, session.model);
         }
     }
     return grouped;
@@ -279,23 +294,29 @@ function groupSessions(sessions, options) {
 // ---------------------------------------------------------------------------
 // Public API — response builders for route handlers
 // ---------------------------------------------------------------------------
-/** Aggregate and return DailyResponse format (for /daily?agent=codex) */
-export function getDailyResponse(options) {
-    const sessions = parseAllSessions();
+export function buildCodexResponsesFromSessions(sessions, options) {
+    return {
+        daily: buildDailyResponse(sessions, options),
+        projects: buildProjectsResponse(sessions, options),
+        blocks: buildBlocksResponse(sessions, options),
+    };
+}
+function buildDailyResponse(sessions, options) {
     const grouped = groupSessions(sessions, { groupBy: 'day', ...options });
     const daily = [];
     const totalsAcc = emptyAcc();
+    const totalModels = new Map();
     for (const [date, { acc, models }] of grouped) {
         daily.push(accToEntry(date, acc, models));
         mergeAcc(totalsAcc, acc);
+        for (const [model, modelAcc] of models) {
+            if (!totalModels.has(model))
+                totalModels.set(model, emptyAcc());
+            mergeAcc(totalModels.get(model), modelAcc);
+        }
     }
-    // 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);
+    const totalCost = buildModelBreakdowns(totalModels).reduce((sum, model) => sum + model.cost, 0);
     return {
         daily,
         totals: {
@@ -308,15 +329,16 @@ export function getDailyResponse(options) {
         },
     };
 }
-/** Aggregate and return ProjectsResponse format (for /projects?agent=codex) */
-export function getProjectsResponse(options) {
-    const sessions = parseAllSessions();
+function buildProjectsResponse(sessions, options) {
     const tz = options?.timezone || 'Asia/Shanghai';
-    const projects = {};
+    const projectGroups = new Map();
     for (const session of sessions) {
         const projectName = extractProjectName(session.cwd);
-        // Per-project daily grouping
-        const dailyMap = new Map();
+        if (options?.project && projectName !== options.project)
+            continue;
+        if (!projectGroups.has(projectName))
+            projectGroups.set(projectName, new Map());
+        const dailyMap = projectGroups.get(projectName);
         for (const ev of session.tokenEvents) {
             const evDate = new Date(ev.timestamp);
             if (options?.since && evDate < options.since)
@@ -325,32 +347,25 @@ export function getProjectsResponse(options) {
                 continue;
             const dayKey = getDateKey(ev.timestamp, tz);
             if (!dailyMap.has(dayKey)) {
-                dailyMap.set(dayKey, { acc: emptyAcc(), models: new Set() });
+                dailyMap.set(dayKey, { acc: emptyAcc(), models: new Map() });
             }
-            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));
+            addAccToBucket(dailyMap.get(dayKey), ev, session.model);
         }
     }
-    // Sort each project's daily entries
-    for (const key of Object.keys(projects)) {
-        projects[key].sort((a, b) => a.date.localeCompare(b.date));
+    const projects = {};
+    for (const [projectName, dailyMap] of projectGroups) {
+        projects[projectName] = [...dailyMap.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([date, { acc, models }]) => accToEntry(date, acc, models));
     }
     return { projects };
 }
-/** Aggregate and return BlocksResponse format (hourly, for /blocks?agent=codex) */
-export function getBlocksResponse(options) {
-    const sessions = parseAllSessions();
+function buildBlocksResponse(sessions, options) {
     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 cost = buildModelBreakdowns(models).reduce((sum, model) => sum + model.cost, 0);
         const [datePart, timePart] = hourKey.split(' ');
         const hour = timePart.split(':')[0];
         blocks.push({
@@ -369,11 +384,22 @@ export function getBlocksResponse(options) {
             },
             totalTokens: acc.totalTokens,
             costUSD: cost,
-            models: [...models],
+            models: [...models.keys()],
         });
         idx++;
     }
-    // Sort by startTime
     blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
     return { blocks };
 }
+/** Aggregate and return DailyResponse format (for /daily?agent=codex) */
+export function getDailyResponse(options) {
+    return buildDailyResponse(parseAllSessions(), options);
+}
+/** Aggregate and return ProjectsResponse format (for /projects?agent=codex) */
+export function getProjectsResponse(options) {
+    return buildProjectsResponse(parseAllSessions(), options);
+}
+/** Aggregate and return BlocksResponse format (hourly, for /blocks?agent=codex) */
+export function getBlocksResponse(options) {
+    return buildBlocksResponse(parseAllSessions(), options);
+}

package/dist/server/index.d.ts

@@ -1,4 +1,8 @@
 import type { Express } from 'express';
+export declare function resolveStaticAssetBaseDir(moduleUrl?: string, baseDir?: string): {
+    baseDir: string;
+    isProduction: boolean;
+};
 export declare function createApp(_port: number, baseDir?: string): Express;
 declare function main(): Promise<void>;
 export { main };

package/dist/server/index.js

@@ -1,7 +1,7 @@
 import express from 'express';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { registerApiRoutes } from './routes/api.js';
 import { detectAvailableAgents } from './agentDetection.js';
 import open from 'open';
@@ -117,22 +117,38 @@ async function listenWithPortFallback(app, preferredPort) {
     }
     throw new Error(`Could not find an available port starting from ${preferredPort}`);
 }
+export function resolveStaticAssetBaseDir(moduleUrl = import.meta.url, baseDir) {
+    if (baseDir)
+        return { baseDir: resolve(baseDir), isProduction: true };
+    const moduleDir = dirname(fileURLToPath(moduleUrl));
+    const isProduction = moduleUrl.includes('/dist/');
+    if (!isProduction)
+        return { baseDir: resolve(moduleDir), isProduction: false };
+    // The CLI entrypoint runs from dist/server/index.js while the Vite assets are
+    // emitted to dist/client. Resolve the production asset base to dist instead
+    // of dist/server so / resolves to dist/client/index.html in installed npm
+    // packages. Electron passes dist explicitly and is unaffected by this branch.
+    if (basename(moduleDir) === 'server') {
+        return { baseDir: resolve(dirname(moduleDir)), isProduction: true };
+    }
+    return { baseDir: resolve(moduleDir), isProduction: true };
+}
 export function createApp(_port, baseDir) {
     const app = express();
     const router = express.Router();
     // Register API routes
     registerApiRoutes(router);
     app.use('/api', router);
-    // Resolve paths: use provided baseDir or compute from import.meta.url
-    const _baseDir = baseDir ?? dirname(fileURLToPath(import.meta.url));
-    const isProduction = baseDir
-        ? true
-        : import.meta.url.includes('dist/');
+    const { baseDir: _baseDir, isProduction } = resolveStaticAssetBaseDir(import.meta.url, baseDir);
     const popoverPath = isProduction
         ? join(_baseDir, 'client', 'popover.html')
         : join(_baseDir, '..', '..', 'public', 'popover.html');
-    app.get('/popover.html', (_req, res) => {
-        res.sendFile(popoverPath);
+    app.get('/popover.html', (_req, res, next) => {
+        if (!existsSync(popoverPath)) {
+            next();
+            return;
+        }
+        res.type('html').send(readFileSync(popoverPath, 'utf8'));
     });
     // Check if running from dist (production build)
     if (isProduction) {