@zhangferry-dev/tokendash 1.4.2 → 1.6.0

package/dist/server/codexParser.js

@@ -15,20 +15,24 @@ const TokenUsageSchema = z.object({
 }).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,
+    last_token_usage: TokenUsageSchema.optional(),
 }).nullable().default(null);
 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(':');
+function subtractTokenUsage(current, previous) {
+    return {
+        timestamp: '',
+        inputTokens: Math.max(0, current.input_tokens - (previous?.input_tokens ?? 0)),
+        cachedInputTokens: Math.max(0, current.cached_input_tokens - (previous?.cached_input_tokens ?? 0)),
+        outputTokens: Math.max(0, current.output_tokens - (previous?.output_tokens ?? 0)),
+        reasoningOutputTokens: Math.max(0, current.reasoning_output_tokens - (previous?.reasoning_output_tokens ?? 0)),
+        totalTokens: Math.max(0, current.total_tokens - (previous?.total_tokens ?? 0)),
+    };
+}
+function displayInputTokens(inputTokens, cachedInputTokens) {
+    return Math.max(0, inputTokens - cachedInputTokens);
 }
 // ---------------------------------------------------------------------------
 // Helpers
@@ -101,7 +105,9 @@ export function parseCodexSession(filepath) {
     let model = '';
     let createdAt = '';
     const tokenEvents = [];
+    let previousTotalUsage = null;
     const seenTotalUsageSnapshots = new Set();
+    const seenUsageEvents = new Set();
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -139,19 +145,43 @@ export function parseCodexSession(filepath) {
                 const info = parseResult.data.info;
                 if (!info)
                     continue;
-                const totalUsageKey = tokenUsageKey(info.total_token_usage);
+                const totalUsageKey = [
+                    info.total_token_usage.input_tokens,
+                    info.total_token_usage.cached_input_tokens,
+                    info.total_token_usage.output_tokens,
+                    info.total_token_usage.reasoning_output_tokens,
+                    info.total_token_usage.total_tokens,
+                ].join(':');
                 if (seenTotalUsageSnapshots.has(totalUsageKey))
                     continue;
                 seenTotalUsageSnapshots.add(totalUsageKey);
-                const last = info.last_token_usage;
-                tokenEvents.push({
+                const last = info.last_token_usage ?? info.total_token_usage;
+                const rawEvent = info.last_token_usage
+                    ? subtractTokenUsage(last, null)
+                    : subtractTokenUsage(last, previousTotalUsage);
+                previousTotalUsage = info.total_token_usage;
+                if (rawEvent.inputTokens === 0 && rawEvent.cachedInputTokens === 0 && rawEvent.outputTokens === 0 && rawEvent.reasoningOutputTokens === 0) {
+                    continue;
+                }
+                const event = {
+                    ...rawEvent,
                     timestamp,
-                    inputTokens: last.input_tokens,
-                    cachedInputTokens: last.cached_input_tokens,
-                    outputTokens: last.output_tokens,
-                    reasoningOutputTokens: last.reasoning_output_tokens,
-                    totalTokens: last.total_tokens,
-                });
+                    cachedInputTokens: Math.min(rawEvent.cachedInputTokens, rawEvent.inputTokens),
+                };
+                const eventKey = [
+                    timestamp,
+                    model,
+                    event.inputTokens,
+                    event.cachedInputTokens,
+                    event.outputTokens,
+                    event.reasoningOutputTokens,
+                    event.totalTokens,
+                ].join(':');
+                if (seenUsageEvents.has(eventKey)) {
+                    continue;
+                }
+                seenUsageEvents.add(eventKey);
+                tokenEvents.push(event);
             }
         }
     }
@@ -212,6 +242,12 @@ function addAcc(a, ev) {
     a.reasoningOutputTokens += ev.reasoningOutputTokens;
     a.totalTokens += ev.totalTokens;
 }
+function displayAcc(acc) {
+    return {
+        ...acc,
+        inputTokens: displayInputTokens(acc.inputTokens, acc.cachedInputTokens),
+    };
+}
 function mergeAcc(a, b) {
     a.inputTokens += b.inputTokens;
     a.cachedInputTokens += b.cachedInputTokens;
@@ -219,33 +255,43 @@ 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 display = displayAcc(acc);
+    const modelNames = [...modelAccs.keys()];
+    const modelBreakdowns = buildModelBreakdowns(modelAccs);
+    const totalCost = modelBreakdowns.reduce((sum, model) => sum + model.cost, 0);
     return {
         date,
-        inputTokens: acc.inputTokens,
-        outputTokens: acc.outputTokens,
+        inputTokens: display.inputTokens,
+        outputTokens: display.outputTokens,
         cacheCreationTokens: 0,
-        cacheReadTokens: acc.cachedInputTokens,
-        totalTokens: acc.totalTokens,
-        totalCost: cost,
-        modelsUsed: [...models],
-        modelBreakdowns: buildModelBreakdowns(acc, models, cost),
+        cacheReadTokens: display.cachedInputTokens,
+        totalTokens: display.totalTokens,
+        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,
-        inputTokens: acc.inputTokens,
-        outputTokens: acc.outputTokens,
-        cacheCreationTokens: 0,
-        cacheReadTokens: acc.cachedInputTokens,
-        cost: costPerModel,
-    }));
+function buildModelBreakdowns(modelAccs) {
+    return [...modelAccs.entries()].map(([modelName, acc]) => {
+        const display = displayAcc(acc);
+        return {
+            modelName,
+            inputTokens: display.inputTokens,
+            outputTokens: display.outputTokens,
+            cacheCreationTokens: 0,
+            cacheReadTokens: display.cachedInputTokens,
+            cost: calculateCost(acc, new Set([modelName])),
+        };
+    });
 }
 function groupSessions(sessions, options) {
     const tz = options.timezone || 'Asia/Shanghai';
@@ -278,12 +324,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;
@@ -291,27 +334,33 @@ 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: {
-            inputTokens: totalsAcc.inputTokens,
+            inputTokens: displayInputTokens(totalsAcc.inputTokens, totalsAcc.cachedInputTokens),
             outputTokens: totalsAcc.outputTokens,
             cacheCreationTokens: 0,
             cacheReadTokens: totalsAcc.cachedInputTokens,
@@ -320,15 +369,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)
@@ -337,32 +387,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({
@@ -374,18 +417,29 @@ export function getBlocksResponse(options) {
             isGap: false,
             entries: acc.totalTokens > 0 ? 1 : 0,
             tokenCounts: {
-                inputTokens: acc.inputTokens,
+                inputTokens: displayInputTokens(acc.inputTokens, acc.cachedInputTokens),
                 outputTokens: acc.outputTokens,
                 cacheCreationInputTokens: 0,
                 cacheReadInputTokens: acc.cachedInputTokens,
             },
             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) {

package/electron/main.cjs

@@ -2,7 +2,6 @@ const { app, BrowserWindow, ipcMain, screen, shell } = require('electron');
 const path = require('node:path');
 const fs = require('node:fs');
 const http = require('node:http');
-const https = require('node:https');
 const { spawn } = require('node:child_process');
 
 // Global debug logger (writes to file since stdout is lost in packaged apps)
@@ -19,6 +18,7 @@ try {
 }
 
 const { formatTokens } = require('./trayBadge.cjs');
+const { checkForUpdates, downloadUpdateAsset } = require('./updateService.cjs');
 
 // Resolve trayHelper binary: extract from asar if needed
 function resolveTrayHelperPath() {
@@ -52,6 +52,8 @@ let server = null;
 let trayProcess = null;
 let selectedAgents = null; // null = use all available agents
 let serverPort = parseInt(process.env.TOKENDASH_PORT || '3456', 10);
+let lastUpdateInfo = null;
+let isDownloadingUpdate = false;
 const POPOVER_WIDTH = 380;
 const POPOVER_HEIGHT = 540;
 const PACKAGE_NAME = '@zhangferry-dev/tokendash';
@@ -97,41 +99,6 @@ function fetchJson(url) {
   });
 }
 
-function fetchHttpsJson(url) {
-  return new Promise((resolve, reject) => {
-    const opts = new URL(url);
-    const reqOpts = {
-      hostname: opts.hostname,
-      path: opts.pathname + opts.search,
-      method: 'GET',
-      headers: { 'User-Agent': 'TokenDash' },
-    };
-    https.get(reqOpts, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        if (res.statusCode && res.statusCode >= 400) {
-          reject(new Error(`HTTP ${res.statusCode}`));
-          return;
-        }
-        try { resolve(JSON.parse(data)); }
-        catch (e) { reject(e); }
-      });
-    }).on('error', reject);
-  });
-}
-
-function compareVersions(a, b) {
-  const aParts = String(a).split('.').map((part) => parseInt(part, 10) || 0);
-  const bParts = String(b).split('.').map((part) => parseInt(part, 10) || 0);
-  const maxLen = Math.max(aParts.length, bParts.length);
-  for (let i = 0; i < maxLen; i++) {
-    const delta = (aParts[i] || 0) - (bParts[i] || 0);
-    if (delta !== 0) return delta;
-  }
-  return 0;
-}
-
 function getAppInfo() {
   // app.getVersion() returns Electron's version in dev mode (e.g. 41.5).
   // Always read from package.json to get the app's own version.
@@ -258,17 +225,19 @@ function getTrayAgentKey(agents) {
 
 function applyTraySnapshot(snapshot) {
   const totalTokens = Number(snapshot && snapshot.totalTokens) || 0;
+  const totalInput = Number(snapshot && snapshot.totalInput) || 0;
   const totalCost = Number(snapshot && snapshot.totalCost) || 0;
   const totalCacheRead = Number(snapshot && snapshot.totalCacheRead) || 0;
   const today = snapshot && snapshot.today;
   const agentKey = snapshot && snapshot.agentKey;
 
-  lastTraySnapshot = { today, agentKey, totalTokens, totalCost, totalCacheRead };
+  lastTraySnapshot = { today, agentKey, totalTokens, totalInput, totalCost, totalCacheRead };
 
   const tokenStr = formatTokens(totalTokens);
   sendTrayCommand('title:' + tokenStr);
 
-  const cacheRate = totalTokens > 0 ? ((totalCacheRead / totalTokens) * 100).toFixed(1) : '0.0';
+  const cacheInput = totalInput + totalCacheRead;
+  const cacheRate = cacheInput > 0 ? ((totalCacheRead / cacheInput) * 100).toFixed(1) : '0.0';
   sendTrayCommand('tooltip:TokenDash - ' + tokenStr + ' tokens today ($' + totalCost.toFixed(2) + ') | cache: ' + cacheRate + '%');
 }
 
@@ -337,7 +306,7 @@ function updateTrayBadge() {
         return;
       }
 
-      applyTraySnapshot({ today, agentKey, totalTokens, totalCost, totalCacheRead });
+      applyTraySnapshot({ today, agentKey, totalTokens, totalInput, totalCost, totalCacheRead });
     })
     .catch((err) => {
       if (err.code !== 'ECONNREFUSED') {
@@ -413,19 +382,10 @@ function registerIpcHandlers() {
 
   ipcMain.handle('tokendash:check-for-updates', async () => {
     const currentVersion = getAppInfo().version;
-    const releasesUrl = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
 
     try {
-      const latest = await fetchHttpsJson(releasesUrl);
-      // GitHub release tag may be "v1.3.0" or "1.3.0"
-      const tag = (latest.tag_name || '').replace(/^v/, '');
-      const latestVersion = tag || currentVersion;
-      return {
-        currentVersion,
-        latestVersion,
-        upToDate: compareVersions(currentVersion, latestVersion) >= 0,
-        releaseUrl: latest.html_url || null,
-      };
+      lastUpdateInfo = await checkForUpdates({ repo: GITHUB_REPO, currentVersion });
+      return lastUpdateInfo;
     } catch (error) {
       return {
         currentVersion,
@@ -436,6 +396,31 @@ function registerIpcHandlers() {
     }
   });
 
+  ipcMain.handle('tokendash:download-update', async (event) => {
+    if (isDownloadingUpdate) {
+      return { ok: false, error: 'An update download is already in progress.' };
+    }
+
+    const info = lastUpdateInfo;
+    if (!info || info.upToDate || !info.asset || !info.asset.url) {
+      return { ok: false, error: 'No downloadable update is available.' };
+    }
+
+    isDownloadingUpdate = true;
+    try {
+      const downloadsDir = path.join(app.getPath('downloads'), 'TokenDash Updates');
+      const filePath = await downloadUpdateAsset(info.asset, downloadsDir, (progress) => {
+        event.sender.send('tokendash:update-download-progress', progress);
+      });
+      await shell.openPath(filePath);
+      return { ok: true, filePath };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    } finally {
+      isDownloadingUpdate = false;
+    }
+  });
+
   ipcMain.handle('tokendash:quit', () => {
     app.isQuitting = true;
     stopBadgeUpdates();

package/electron/preload.cjs

@@ -13,6 +13,17 @@ contextBridge.exposeInMainWorld('electronAPI', {
   checkForUpdates() {
     return ipcRenderer.invoke('tokendash:check-for-updates');
   },
+  downloadUpdate(updateInfo) {
+    return ipcRenderer.invoke('tokendash:download-update', updateInfo);
+  },
+  onUpdateDownloadProgress(callback) {
+    if (typeof callback !== 'function') return function noop() {};
+    const listener = (_event, progress) => callback(progress);
+    ipcRenderer.on('tokendash:update-download-progress', listener);
+    return function unsubscribe() {
+      ipcRenderer.removeListener('tokendash:update-download-progress', listener);
+    };
+  },
   quitApp() {
     return ipcRenderer.invoke('tokendash:quit');
   },