@zhangferry-dev/tokendash 1.6.0 → 1.6.1

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

@@ -19,6 +19,8 @@ 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,7 @@ 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;
@@ -99,6 +102,10 @@ function fetchJson(url) {
   });
 }
 
+function getServerBaseUrl() {
+  return dashboardUrl || getDashboardUrl(serverPort);
+}
+
 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.
@@ -245,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) {
@@ -262,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 }));
@@ -350,7 +358,7 @@ function createPopoverWindow() {
     },
   });
 
-  popover.loadURL(`http://localhost:${serverPort}/popover.html`);
+  popover.loadURL(`${getServerBaseUrl()}/popover.html`);
 
   popover.on('blur', () => {
     popover.hide();
@@ -366,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', () => {
@@ -462,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,
+};

package/electron/serverReuse.cjs

@@ -0,0 +1,59 @@
+const http = require('node:http');
+
+function normalizePort(port) {
+  const value = parseInt(String(port || ''), 10);
+  return Number.isInteger(value) && value > 0 ? value : 3456;
+}
+
+function getDashboardUrl(port) {
+  return `http://localhost:${normalizePort(port)}`;
+}
+
+function isCompatibleServerInfo(info, expectedVersion, expectedPackageName) {
+  return Boolean(
+    info &&
+    info.packageName === expectedPackageName &&
+    String(info.version || '').replace(/^v/, '') === String(expectedVersion || '').replace(/^v/, '')
+  );
+}
+
+function fetchJson(url, timeoutMs = 1000) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, (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 (error) { reject(error); }
+      });
+    });
+
+    req.setTimeout(timeoutMs, () => {
+      req.destroy(new Error('Request timed out'));
+    });
+    req.on('error', reject);
+  });
+}
+
+async function findCompatibleServer(preferredPort, expectedVersion, expectedPackageName) {
+  const port = normalizePort(preferredPort);
+  try {
+    const info = await fetchJson(`${getDashboardUrl(port)}/api/app-info`);
+    if (isCompatibleServerInfo(info, expectedVersion, expectedPackageName)) {
+      return { port, dashboardUrl: info.dashboardUrl || getDashboardUrl(port), info };
+    }
+  } catch (_) {}
+  return null;
+}
+
+module.exports = {
+  fetchJson,
+  findCompatibleServer,
+  getDashboardUrl,
+  isCompatibleServerInfo,
+  normalizePort,
+};

package/electron/updateService.cjs

@@ -30,6 +30,35 @@ function fetchHttpsJson(url) {
   });
 }
 
+function fetchLatestReleaseUrl(repo) {
+  const url = `https://github.com/${repo}/releases/latest`;
+  return new Promise((resolve, reject) => {
+    const opts = new URL(url);
+    const reqOpts = {
+      hostname: opts.hostname,
+      path: opts.pathname + opts.search,
+      method: 'HEAD',
+      headers: {
+        'User-Agent': 'TokenDash',
+      },
+    };
+
+    https.request(reqOpts, (res) => {
+      if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+        resolve(new URL(res.headers.location, url).toString());
+        return;
+      }
+
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+
+      resolve(url);
+    }).on('error', reject).end();
+  });
+}
+
 function compareVersions(a, b) {
   const aParts = String(a).replace(/^v/, '').split(/[.-]/).map((part) => parseInt(part, 10) || 0);
   const bParts = String(b).replace(/^v/, '').split(/[.-]/).map((part) => parseInt(part, 10) || 0);
@@ -78,9 +107,50 @@ function getReleaseUpdateInfo(release, currentVersion, arch = process.arch) {
   };
 }
 
-async function checkForUpdates({ repo, currentVersion, arch = process.arch }) {
-  const release = await fetchHttpsJson(`https://api.github.com/repos/${repo}/releases/latest`);
-  return getReleaseUpdateInfo(release, currentVersion, arch);
+function buildDmgAssetFromVersion(repo, tagName, arch = process.arch) {
+  const version = String(tagName || '').replace(/^v/, '');
+  const archSuffix = arch === 'arm64' ? 'arm64' : arch === 'x64' ? 'x64' : 'universal';
+  const name = `TokenDash-${version}-${archSuffix}.dmg`;
+
+  return {
+    name,
+    size: 0,
+    url: `https://github.com/${repo}/releases/download/${tagName}/${name}`,
+  };
+}
+
+function getRedirectReleaseUpdateInfo(repo, releaseUrl, currentVersion, arch = process.arch) {
+  const parsedUrl = new URL(releaseUrl);
+  const tagMatch = parsedUrl.pathname.match(/\/releases\/tag\/([^/]+)\/?$/);
+  if (!tagMatch) throw new Error('Unable to determine the latest release tag.');
+
+  const tagName = decodeURIComponent(tagMatch[1]);
+  const latestVersion = tagName.replace(/^v/, '');
+  const upToDate = compareVersions(currentVersion, latestVersion) >= 0;
+
+  return {
+    currentVersion,
+    latestVersion,
+    upToDate,
+    releaseUrl: parsedUrl.toString(),
+    asset: upToDate ? null : buildDmgAssetFromVersion(repo, tagName, arch),
+  };
+}
+
+async function checkForUpdates({
+  repo,
+  currentVersion,
+  arch = process.arch,
+  fetchReleaseJson = fetchHttpsJson,
+  fetchLatestReleaseUrl: fetchLatestReleaseUrlOverride = fetchLatestReleaseUrl,
+}) {
+  try {
+    const release = await fetchReleaseJson(`https://api.github.com/repos/${repo}/releases/latest`);
+    return getReleaseUpdateInfo(release, currentVersion, arch);
+  } catch (error) {
+    const releaseUrl = await fetchLatestReleaseUrlOverride(repo);
+    return getRedirectReleaseUpdateInfo(repo, releaseUrl, currentVersion, arch);
+  }
 }
 
 function safeDownloadName(name) {
@@ -143,6 +213,8 @@ module.exports = {
   checkForUpdates,
   compareVersions,
   downloadUpdateAsset,
+  fetchLatestReleaseUrl,
+  getRedirectReleaseUpdateInfo,
   getReleaseUpdateInfo,
   selectMacDmgAsset,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhangferry-dev/tokendash",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "type": "module",
   "description": "Token Usage Analytics Dashboard",
   "publishConfig": {

package/dist/server/ccusage.d.ts

@@ -1,7 +0,0 @@
-export declare function runCcusage(args: string[], timeout?: number): Promise<string>;
-export declare function ensureUsageToolsReady(): Promise<void>;
-export declare function isClaudeCodeAvailable(): Promise<boolean>;
-export declare function detectAvailableAgents(): Promise<{
-    claude: boolean;
-    codex: boolean;
-}>;

package/dist/server/ccusage.js

@@ -1,69 +0,0 @@
-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')) {
-        return args;
-    }
-    return [...args, '--json'];
-}
-async function runCommand(spec, timeout) {
-    const { stdout } = await execFileAsync(spec.command, spec.args, {
-        timeout,
-        maxBuffer: 10 * 1024 * 1024,
-    });
-    return stdout;
-}
-function isMissingCommand(error) {
-    return typeof error === 'object'
-        && error !== null
-        && 'code' in error
-        && error.code === 'ENOENT';
-}
-async function runCcusageCommand(args, timeout, asJson) {
-    const primary = {
-        command: 'ccusage',
-        args: withJsonFlag(args, asJson),
-    };
-    const fallback = {
-        command: 'npx',
-        args: ['--yes', 'ccusage@latest', ...withJsonFlag(args, asJson)],
-    };
-    try {
-        return await runCommand(primary, timeout);
-    }
-    catch (error) {
-        if (isMissingCommand(error)) {
-            return runCommand(fallback, timeout);
-        }
-        throw error;
-    }
-}
-export async function runCcusage(args, timeout = 30_000) {
-    return runCcusageCommand(args, timeout, true);
-}
-export async function ensureUsageToolsReady() {
-    // Claude Code: check ccusage CLI
-    await runCcusageCommand(['--version'], 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/');
-    }
-}
-export async function isClaudeCodeAvailable() {
-    try {
-        await runCcusageCommand(['--version'], 120_000, false);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function detectAvailableAgents() {
-    const [claude, codex] = await Promise.all([
-        isClaudeCodeAvailable(),
-        Promise.resolve(isSessionsDirAccessible()),
-    ]);
-    return { claude, codex };
-}