@zhangferry-dev/tokendash 1.5.0 → 1.6.1

package/dist/server/claudeBlocksParser.js

@@ -142,7 +142,7 @@ export function getClaudeBlocksByProject(project) {
                 const outputTokens = usage.output_tokens;
                 const cacheCreationTokens = usage.cache_creation_input_tokens;
                 const cacheReadTokens = usage.cache_read_input_tokens;
-                const totalTokens = inputTokens + outputTokens + cacheReadTokens;
+                const totalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
                 if (totalTokens === 0)
                     continue;
                 const hourKey = getHourKey(event.timestamp);
@@ -167,7 +167,7 @@ export function getClaudeBlocksByProject(project) {
     const blocks = [];
     let idx = 0;
     for (const [hourKey, bucket] of hourMap) {
-        const totalTokens = bucket.inputTokens + bucket.outputTokens + bucket.cacheReadTokens;
+        const totalTokens = bucket.inputTokens + bucket.outputTokens + bucket.cacheCreationTokens + bucket.cacheReadTokens;
         blocks.push({
             id: `claude-project-${idx}`,
             startTime: `${hourKey}:00:00.000Z`,

package/dist/server/claudeJsonlParser.d.ts

@@ -1,5 +1,5 @@
 import type { DailyResponse, ProjectsResponse, BlockEntry } from '../shared/types.js';
-export declare function calculateCost(inputTokens: number, cacheReadTokens: number, outputTokens: number, model: string): number;
+export declare function calculateCost(inputTokens: number, cacheReadTokens: number, outputTokens: number, model: string, cacheCreationTokens?: number): number;
 /** Decode Claude's encoded project directory name.
  *  Claude encodes paths: /Users/foo/bar → -Users-foo-bar
  *  Since '-' replaces '/' and project names can contain '-',

package/dist/server/claudeJsonlParser.js

@@ -3,18 +3,18 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 const MODEL_PRICING = {
     // Claude 4.6
-    'claude-opus-4-6': { inputPer1M: 15, cacheReadPer1M: 1.50, outputPer1M: 75 },
-    'claude-sonnet-4-6': { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 },
+    'claude-opus-4-6': { inputPer1M: 15, cacheCreationPer1M: 18.75, cacheReadPer1M: 1.50, outputPer1M: 75 },
+    'claude-sonnet-4-6': { inputPer1M: 3, cacheCreationPer1M: 3.75, cacheReadPer1M: 0.30, outputPer1M: 15 },
     // Claude 4.5
-    'claude-sonnet-4-5-20250514': { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 },
-    'claude-haiku-4-5-20251001': { inputPer1M: 0.80, cacheReadPer1M: 0.08, outputPer1M: 4 },
+    'claude-sonnet-4-5-20250514': { inputPer1M: 3, cacheCreationPer1M: 3.75, cacheReadPer1M: 0.30, outputPer1M: 15 },
+    'claude-haiku-4-5-20251001': { inputPer1M: 0.80, cacheCreationPer1M: 1, cacheReadPer1M: 0.08, outputPer1M: 4 },
     // Older Claude models
-    'claude-3-5-sonnet-20241022': { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 },
-    'claude-3-5-haiku-20241022': { inputPer1M: 0.80, cacheReadPer1M: 0.08, outputPer1M: 4 },
-    'claude-3-opus-20240229': { inputPer1M: 15, cacheReadPer1M: 1.50, outputPer1M: 75 },
-    'claude-3-haiku-20240307': { inputPer1M: 0.25, cacheReadPer1M: 0.03, outputPer1M: 1.25 },
+    'claude-3-5-sonnet-20241022': { inputPer1M: 3, cacheCreationPer1M: 3.75, cacheReadPer1M: 0.30, outputPer1M: 15 },
+    'claude-3-5-haiku-20241022': { inputPer1M: 0.80, cacheCreationPer1M: 1, cacheReadPer1M: 0.08, outputPer1M: 4 },
+    'claude-3-opus-20240229': { inputPer1M: 15, cacheCreationPer1M: 18.75, cacheReadPer1M: 1.50, outputPer1M: 75 },
+    'claude-3-haiku-20240307': { inputPer1M: 0.25, cacheCreationPer1M: 0.30, cacheReadPer1M: 0.03, outputPer1M: 1.25 },
 };
-const DEFAULT_PRICING = { inputPer1M: 3, cacheReadPer1M: 0.30, outputPer1M: 15 };
+const DEFAULT_PRICING = { inputPer1M: 3, cacheCreationPer1M: 3.75, cacheReadPer1M: 0.30, outputPer1M: 15 };
 function getPricing(model) {
     // Try exact match first, then prefix match
     if (MODEL_PRICING[model])
@@ -26,13 +26,16 @@ function getPricing(model) {
     }
     return DEFAULT_PRICING;
 }
-export function calculateCost(inputTokens, cacheReadTokens, outputTokens, model) {
+export function calculateCost(inputTokens, cacheReadTokens, outputTokens, model, cacheCreationTokens = 0) {
     const p = getPricing(model);
-    const nonCachedInput = Math.max(inputTokens - cacheReadTokens, 0);
-    return (nonCachedInput / 1_000_000) * p.inputPer1M
+    return (inputTokens / 1_000_000) * p.inputPer1M
+        + (cacheCreationTokens / 1_000_000) * p.cacheCreationPer1M
         + (cacheReadTokens / 1_000_000) * p.cacheReadPer1M
         + (outputTokens / 1_000_000) * p.outputPer1M;
 }
+function totalClaudeTokens(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+    return inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+}
 // ---------------------------------------------------------------------------
 // JSONL parsing with mtime cache
 // ---------------------------------------------------------------------------
@@ -160,7 +163,7 @@ function parseAllSessions(project) {
                 const outputTokens = usage.output_tokens || 0;
                 const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
                 const cacheReadTokens = usage.cache_read_input_tokens || 0;
-                const totalTokens = inputTokens + outputTokens + cacheReadTokens;
+                const totalTokens = totalClaudeTokens(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
                 if (totalTokens === 0)
                     continue;
                 entries.push({
@@ -248,8 +251,8 @@ export function getDailyResponse(project, tz = DEFAULT_TZ) {
         agg.outputTokens += e.outputTokens;
         agg.cacheCreationTokens += e.cacheCreationTokens;
         agg.cacheReadTokens += e.cacheReadTokens;
-        agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
-        const cost = calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+        agg.totalTokens += totalClaudeTokens(e.inputTokens, e.outputTokens, e.cacheCreationTokens, e.cacheReadTokens);
+        const cost = calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model, e.cacheCreationTokens);
         agg.totalCost += cost;
         if (!agg.models.has(e.model)) {
             agg.models.set(e.model, { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, cost: 0 });
@@ -294,8 +297,8 @@ export function getProjectsResponse(tz = DEFAULT_TZ) {
         agg.outputTokens += e.outputTokens;
         agg.cacheCreationTokens += e.cacheCreationTokens;
         agg.cacheReadTokens += e.cacheReadTokens;
-        agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
-        const cost = calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+        agg.totalTokens += totalClaudeTokens(e.inputTokens, e.outputTokens, e.cacheCreationTokens, e.cacheReadTokens);
+        const cost = calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model, e.cacheCreationTokens);
         agg.totalCost += cost;
         if (!agg.models.has(e.model)) {
             agg.models.set(e.model, { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, cost: 0 });
@@ -331,13 +334,13 @@ export function getBlocksResponse(project, tz = DEFAULT_TZ) {
         bucket.outputTokens += e.outputTokens;
         bucket.cacheCreationTokens += e.cacheCreationTokens;
         bucket.cacheReadTokens += e.cacheReadTokens;
-        bucket.costUSD += calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+        bucket.costUSD += calculateCost(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model, e.cacheCreationTokens);
         bucket.models.add(e.model);
     }
     const blocks = [];
     let idx = 0;
     for (const [hourKey, bucket] of hourMap) {
-        const totalTokens = bucket.inputTokens + bucket.outputTokens + bucket.cacheReadTokens;
+        const totalTokens = totalClaudeTokens(bucket.inputTokens, bucket.outputTokens, bucket.cacheCreationTokens, bucket.cacheReadTokens);
         blocks.push({
             id: `claude-${idx}`,
             startTime: `${hourKey}:00:00`,

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,
+                    cachedInputTokens: Math.min(rawEvent.cachedInputTokens, rawEvent.inputTokens),
+                };
+                const eventKey = [
                     timestamp,
-                    inputTokens: last.input_tokens,
-                    cachedInputTokens: last.cached_input_tokens,
-                    outputTokens: last.output_tokens,
-                    reasoningOutputTokens: last.reasoning_output_tokens,
-                    totalTokens: last.total_tokens,
-                });
+                    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;
@@ -228,30 +264,34 @@ function addAccToBucket(bucket, ev, model) {
     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,
+        cacheReadTokens: display.cachedInputTokens,
+        totalTokens: display.totalTokens,
         totalCost,
         modelsUsed: modelNames,
         modelBreakdowns,
     };
 }
 function buildModelBreakdowns(modelAccs) {
-    return [...modelAccs.entries()].map(([modelName, acc]) => ({
-        modelName,
-        inputTokens: acc.inputTokens,
-        outputTokens: acc.outputTokens,
-        cacheCreationTokens: 0,
-        cacheReadTokens: acc.cachedInputTokens,
-        cost: calculateCost(acc, new Set([modelName])),
-    }));
+    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';
@@ -320,7 +360,7 @@ function buildDailyResponse(sessions, options) {
     return {
         daily,
         totals: {
-            inputTokens: totalsAcc.inputTokens,
+            inputTokens: displayInputTokens(totalsAcc.inputTokens, totalsAcc.cachedInputTokens),
             outputTokens: totalsAcc.outputTokens,
             cacheCreationTokens: 0,
             cacheReadTokens: totalsAcc.cachedInputTokens,
@@ -377,7 +417,7 @@ function buildBlocksResponse(sessions, 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,

package/dist/server/index.js

@@ -12,11 +12,22 @@ const CLI_USAGE = [
     '  tokendash --port <number> [--no-open]',
     '  tokendash --tray [--port <number>]',
 ].join('\n');
+const PACKAGE_NAME = '@zhangferry-dev/tokendash';
 function getPackageVersion() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
-    const packageJson = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
-    return packageJson.version ?? 'unknown';
+    const packageJsonPaths = [
+        join(__dirname, '..', '..', 'package.json'), // dist/server/index.js
+        join(__dirname, '..', 'package.json'), // dist/electron-server.cjs
+    ];
+    for (const packageJsonPath of packageJsonPaths) {
+        if (!existsSync(packageJsonPath))
+            continue;
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        if (packageJson.version)
+            return packageJson.version;
+    }
+    return 'unknown';
 }
 function exitWithCliError(message) {
     console.error(message);
@@ -137,7 +148,11 @@ export function createApp(_port, baseDir) {
     const app = express();
     const router = express.Router();
     // Register API routes
-    registerApiRoutes(router);
+    registerApiRoutes(router, {
+        packageName: PACKAGE_NAME,
+        version: getPackageVersion(),
+        dashboardUrl: `http://localhost:${resolvePort(_port)}`,
+    });
     app.use('/api', router);
     const { baseDir: _baseDir, isProduction } = resolveStaticAssetBaseDir(import.meta.url, baseDir);
     const popoverPath = isProduction

package/dist/server/routes/api.d.ts

@@ -1,2 +1,7 @@
 import { type Router } from 'express';
-export declare function registerApiRoutes(router: Router): void;
+export interface AppInfo {
+    packageName: string;
+    version: string;
+    dashboardUrl?: string;
+}
+export declare function registerApiRoutes(router: Router, appInfo: AppInfo): void;

package/dist/server/routes/api.js

@@ -26,7 +26,17 @@ function getAgents(_req, res) {
         res.status(500).json({ error: 'Failed to detect agents', hint: message });
     }
 }
-export function registerApiRoutes(router) {
+function getAppInfo(info) {
+    return (req, res) => {
+        const host = req.get('host');
+        res.json({
+            ...info,
+            dashboardUrl: host ? `${req.protocol}://${host}` : info.dashboardUrl,
+        });
+    };
+}
+export function registerApiRoutes(router, appInfo) {
+    router.get('/app-info', getAppInfo(appInfo));
     router.get('/agents', getAgents);
     router.get('/daily', getDaily);
     router.get('/monthly', getMonthly);

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,9 @@ try {
 }
 
 const { formatTokens } = require('./trayBadge.cjs');
+const { checkForUpdates, downloadUpdateAsset } = require('./updateService.cjs');
+const { syncNpmPackageVersion } = require('./npmSync.cjs');
+const { findCompatibleServer, getDashboardUrl } = require('./serverReuse.cjs');
 
 // Resolve trayHelper binary: extract from asar if needed
 function resolveTrayHelperPath() {
@@ -52,6 +54,9 @@ let server = null;
 let trayProcess = null;
 let selectedAgents = null; // null = use all available agents
 let serverPort = parseInt(process.env.TOKENDASH_PORT || '3456', 10);
+let dashboardUrl = getDashboardUrl(serverPort);
+let lastUpdateInfo = null;
+let isDownloadingUpdate = false;
 const POPOVER_WIDTH = 380;
 const POPOVER_HEIGHT = 540;
 const PACKAGE_NAME = '@zhangferry-dev/tokendash';
@@ -97,39 +102,8 @@ 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 getServerBaseUrl() {
+  return dashboardUrl || getDashboardUrl(serverPort);
 }
 
 function getAppInfo() {
@@ -258,17 +232,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 + '%');
 }
 
@@ -276,7 +252,8 @@ function updateTrayBadge() {
   const d = new Date(); const today = d.getFullYear() + "-" + String(d.getMonth()+1).padStart(2,"0") + "-" + String(d.getDate()).padStart(2,"0");
 
   // Fetch agents list, then fetch daily data for each agent in parallel
-  fetchJson(`http://localhost:${serverPort}/api/agents`)
+  const serverBaseUrl = getServerBaseUrl();
+  fetchJson(`${serverBaseUrl}/api/agents`)
     .then((agentData) => {
       let agents = (agentData && Array.isArray(agentData.available)) ? agentData.available : ['claude'];
       if (agents.length === 0) {
@@ -293,7 +270,7 @@ function updateTrayBadge() {
       const agentKey = getTrayAgentKey(agents);
       return Promise.all(
         agents.map(agent =>
-          fetchJson(`http://localhost:${serverPort}/api/daily?agent=${agent}`)
+          fetchJson(`${serverBaseUrl}/api/daily?agent=${agent}`)
             .catch(() => null)
         )
       ).then(results => ({ agentKey, results }));
@@ -337,7 +314,7 @@ function updateTrayBadge() {
         return;
       }
 
-      applyTraySnapshot({ today, agentKey, totalTokens, totalCost, totalCacheRead });
+      applyTraySnapshot({ today, agentKey, totalTokens, totalInput, totalCost, totalCacheRead });
     })
     .catch((err) => {
       if (err.code !== 'ECONNREFUSED') {
@@ -381,7 +358,7 @@ function createPopoverWindow() {
     },
   });
 
-  popover.loadURL(`http://localhost:${serverPort}/popover.html`);
+  popover.loadURL(`${getServerBaseUrl()}/popover.html`);
 
   popover.on('blur', () => {
     popover.hide();
@@ -397,8 +374,7 @@ function createPopoverWindow() {
 
 function registerIpcHandlers() {
   ipcMain.handle('tokendash:open-dashboard', (_event, url) => {
-    const target = typeof url === 'string' && url.length > 0 ? url : `http://localhost:${serverPort}`;
-    return shell.openExternal(target);
+    return shell.openExternal(getServerBaseUrl());
   });
 
   ipcMain.handle('tokendash:get-app-info', () => {
@@ -413,19 +389,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 +403,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();
@@ -477,15 +469,34 @@ app.whenReady().then(async () => {
     if (server) server.close();
   });
 
-  // Create and bind Express server
-  // Pass dist/ directory so createApp resolves client assets correctly
+  const currentVersion = getAppInfo().version;
+  syncNpmPackageVersion(PACKAGE_NAME, currentVersion).then((result) => {
+    if (!result || result.ok) return;
+    console.warn('Could not sync npm package version:', result.error || 'unknown error');
+  }).catch((error) => {
+    console.warn('Could not sync npm package version:', error instanceof Error ? error.message : String(error));
+  });
+
+  const existingServer = await findCompatibleServer(serverPort, currentVersion, PACKAGE_NAME);
+  if (existingServer) {
+    serverPort = existingServer.port;
+    dashboardUrl = existingServer.dashboardUrl;
+    console.log(`tokendash reusing CLI server on ${dashboardUrl}`);
+    startTrayHelper();
+    createPopoverWindow();
+    return;
+  }
+
+  // Create and bind Express server.
+  // Pass dist/ directory so createApp resolves client assets correctly.
   const distDir = path.join(__dirname, '..', 'dist');
   const expressApp = createApp(serverPort, distDir);
   try {
     const result = await listenWithFallback(expressApp, serverPort);
     server = result.server;
     serverPort = result.port;
-    console.log(`tokendash running on http://localhost:${result.port}`);
+    dashboardUrl = getDashboardUrl(result.port);
+    console.log(`tokendash running on ${dashboardUrl}`);
   } catch (err) {
     console.error('Failed to start server:', err);
     app.quit();

package/electron/npmSync.cjs

@@ -0,0 +1,62 @@
+const { spawn } = require('node:child_process');
+
+function normalizeVersion(version) {
+  return String(version || '').trim().replace(/^v/, '');
+}
+
+function shouldInstallPackage(installedVersion, targetVersion) {
+  const installed = normalizeVersion(installedVersion);
+  const target = normalizeVersion(targetVersion);
+  return Boolean(target) && installed !== target;
+}
+
+function buildNpmInstallArgs(packageName, version) {
+  return ['install', '-g', `${packageName}@${version}`];
+}
+
+function runCommand(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    child.on('error', (error) => resolve({ ok: false, stdout, stderr, error }));
+    child.on('close', (code) => resolve({ ok: code === 0, code, stdout, stderr }));
+  });
+}
+
+async function getInstalledPackageVersion(packageName) {
+  const result = await runCommand('npm', ['list', '-g', packageName, '--depth=0', '--json']);
+  if (!result.ok) return null;
+  try {
+    const data = JSON.parse(result.stdout);
+    return normalizeVersion(data && data.dependencies && data.dependencies[packageName] && data.dependencies[packageName].version);
+  } catch (_) {
+    return null;
+  }
+}
+
+async function syncNpmPackageVersion(packageName, version) {
+  const installedVersion = await getInstalledPackageVersion(packageName);
+  if (!shouldInstallPackage(installedVersion, version)) {
+    return { ok: true, installedVersion, targetVersion: version, changed: false };
+  }
+
+  const result = await runCommand('npm', buildNpmInstallArgs(packageName, version));
+  return {
+    ok: result.ok,
+    installedVersion,
+    targetVersion: version,
+    changed: result.ok,
+    error: result.ok ? null : (result.error ? result.error.message : result.stderr || `npm exited with ${result.code}`),
+  };
+}
+
+module.exports = {
+  buildNpmInstallArgs,
+  getInstalledPackageVersion,
+  shouldInstallPackage,
+  syncNpmPackageVersion,
+};