feat: electron-updater + Codex CLI monitoring (opt-in)

Auto-update
- electron-updater checks sooua/TokenWatch on GitHub Releases at startup
  (15s delay) and every 4 hours; active only in packaged builds
- autoDownload=false: user confirms before the download begins
- autoInstallOnAppQuit=true: installs silently on next graceful exit
- UpdateBanner shows four states (available / downloading / downloaded /
  error) above the main window header with Download / Install & restart
  buttons and a dismiss X
- Settings: toggle for automatic checking + "Check for updates now" btn
- electron-builder.json gains a github publish provider (owner=sooua)

Codex CLI monitoring (opt-in, off by default)
- New CodexService tails ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl,
  extracts the latest event_msg.type=token_count event, and surfaces
  the primary (5h) + secondary (7d) rate-limit windows that Codex itself
  records — no estimation needed
- New CodexCard renders two progress bars (used_percent + reset-in),
  last session tokens, context window %, total sessions, last event
  timestamp; warm palette consistent with the Claude sections
- Auto-hides when ~/.codex/sessions is missing, so enabling without
  Codex installed is a no-op instead of a broken card
- Settings: "Show Codex CLI card" switch — off by default so Claude
  stays the hero of the dashboard
- Tail-read implementation (64 KB from file end) to avoid loading
  multi-MB session transcripts just to see the latest token counts

UI polish
- Dashboard hero title renamed to "Claude Code — usage overview" /
  "Claude Code — 用量概览" so the page's provider context is explicit
- i18n keys added under `codex.*` and `update.*`; both en and zh

Author: sooua

electron-builder.json

@@ -4,6 +4,14 @@
   "directories": {
     "output": "release"
   },
+  "publish": [
+    {
+      "provider": "github",
+      "owner": "sooua",
+      "repo": "TokenWatch",
+      "releaseType": "release"
+    }
+  ],
   "files": [
     "dist/**/*",
     "assets/**/*",

main.ts

@@ -2,19 +2,15 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import {
-  BrowserWindow,
-  Menu,
-  Tray,
-  app,
-  ipcMain,
-  nativeImage,
-  screen,
-} from 'electron';
+import { BrowserWindow, Menu, Tray, app, ipcMain, nativeImage, screen } from 'electron';
+import electronUpdater from 'electron-updater';
 import { CCUsageService } from './src/services/ccusageService.js';
+import { CodexService } from './src/services/codexService.js';
 import { NotificationService } from './src/services/notificationService.js';
 import { SettingsService } from './src/services/settingsService.js';
 
+const { autoUpdater } = electronUpdater;
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -76,6 +72,7 @@ class TokenWatchApp {
   private tray: Tray | null = null;
   private window: BrowserWindow | null = null;
   private usageService: CCUsageService;
+  private codexService: CodexService;
   private notificationService: NotificationService;
   private settingsService: SettingsService;
   private updateInterval: NodeJS.Timeout | null = null;
@@ -93,9 +90,12 @@ class TokenWatchApp {
   private miniHudContent: 'percentage' | 'percentageCost' | 'percentageCostBurn' =
     'percentageCost';
   private miniHudSavePositionTimer: NodeJS.Timeout | null = null;
+  private autoUpdateTimer: NodeJS.Timeout | null = null;
+  private autoUpdateInitialized = false;
 
   constructor() {
     this.usageService = CCUsageService.getInstance();
+    this.codexService = CodexService.getInstance();
     this.notificationService = NotificationService.getInstance();
     this.settingsService = SettingsService.getInstance();
   }
@@ -117,6 +117,7 @@ class TokenWatchApp {
     });
 
     this.applyLaunchOnStartup(settings.launchOnStartup === true);
+    this.initAutoUpdate(settings.autoCheckUpdates !== false);
 
     this.createTray();
     this.createWindow();
@@ -320,6 +321,83 @@ class TokenWatchApp {
     }
   }
 
+  // --- Auto-update (electron-updater against GitHub Releases) -------------
+  // Only active in a packaged build — in dev there's no installed copy to
+  // replace. Events are forwarded to the renderer so the UI can show a banner
+  // and progress.
+
+  private initAutoUpdate(enabled: boolean) {
+    if (!app.isPackaged) return;
+
+    if (!this.autoUpdateInitialized) {
+      autoUpdater.autoDownload = false; // User confirms before the download starts
+      autoUpdater.autoInstallOnAppQuit = true;
+
+      autoUpdater.on('checking-for-update', () => this.emitUpdate({ status: 'checking' }));
+      autoUpdater.on('update-available', (info) =>
+        this.emitUpdate({
+          status: 'available',
+          version: info?.version,
+          releaseNotes:
+            typeof info?.releaseNotes === 'string' ? info.releaseNotes : undefined,
+          releaseDate: info?.releaseDate,
+        })
+      );
+      autoUpdater.on('update-not-available', () =>
+        this.emitUpdate({ status: 'not-available' })
+      );
+      autoUpdater.on('download-progress', (progress) =>
+        this.emitUpdate({
+          status: 'downloading',
+          percent: progress.percent,
+          bytesPerSecond: progress.bytesPerSecond,
+          transferred: progress.transferred,
+          total: progress.total,
+        })
+      );
+      autoUpdater.on('update-downloaded', (info) =>
+        this.emitUpdate({ status: 'downloaded', version: info?.version })
+      );
+      autoUpdater.on('error', (err) =>
+        this.emitUpdate({ status: 'error', error: err?.message || String(err) })
+      );
+
+      this.autoUpdateInitialized = true;
+    }
+
+    // Clear any existing periodic check before re-arming with the current
+    // preference — the setting can flip at runtime.
+    if (this.autoUpdateTimer) {
+      clearInterval(this.autoUpdateTimer);
+      this.autoUpdateTimer = null;
+    }
+
+    if (enabled) {
+      // First check runs shortly after boot so it doesn't compete with
+      // ccusage's cold-start parsing for network bandwidth.
+      setTimeout(() => {
+        autoUpdater.checkForUpdates().catch((err) => {
+          console.error('Initial update check failed:', err);
+        });
+      }, 15_000);
+
+      this.autoUpdateTimer = setInterval(
+        () => {
+          autoUpdater.checkForUpdates().catch((err) => {
+            console.error('Periodic update check failed:', err);
+          });
+        },
+        4 * 60 * 60 * 1000 // 4 hours
+      );
+    }
+  }
+
+  private emitUpdate(payload: Record<string, unknown>) {
+    if (this.window && !this.window.isDestroyed()) {
+      this.window.webContents.send('update-status', payload);
+    }
+  }
+
   private applyLaunchOnStartup(enabled: boolean) {
     // On Windows this writes HKCU\Software\Microsoft\Windows\CurrentVersion\Run.
     // On macOS it uses the LSBackgroundOnly launchd item. Linux is a no-op.
@@ -599,6 +677,34 @@ class TokenWatchApp {
     ipcMain.handle('mini-hud-open-main', () => {
       this.showWindow();
     });
+    // Auto-update — renderer can trigger a check, start the download after
+    // we've announced an available version, or install what's already
+    // downloaded.
+    ipcMain.handle('update-check', async () => {
+      if (!app.isPackaged) {
+        this.emitUpdate({ status: 'not-available', info: 'dev build' });
+        return;
+      }
+      try {
+        await autoUpdater.checkForUpdates();
+      } catch (err) {
+        console.error('update-check failed:', err);
+        this.emitUpdate({ status: 'error', error: (err as Error)?.message || String(err) });
+      }
+    });
+    ipcMain.handle('update-download', async () => {
+      try {
+        await autoUpdater.downloadUpdate();
+      } catch (err) {
+        console.error('update-download failed:', err);
+        this.emitUpdate({ status: 'error', error: (err as Error)?.message || String(err) });
+      }
+    });
+    ipcMain.handle('update-install', () => {
+      this.isQuitting = true;
+      autoUpdater.quitAndInstall(false, true);
+    });
+
     ipcMain.handle('mini-hud-close', () => {
       // Called by the close-button inside the HUD itself. Persist the flip so
       // the HUD stays off across relaunches.
@@ -618,6 +724,15 @@ class TokenWatchApp {
       }
     });
 
+    ipcMain.handle('get-codex-stats', async () => {
+      try {
+        return await this.codexService.getStats();
+      } catch (error) {
+        console.error('Error getting codex stats:', error);
+        return { installed: false } as const;
+      }
+    });
+
     ipcMain.handle('get-cached-usage-stats', () => {
       try {
         return this.usageService.loadPersistedStats();
@@ -702,6 +817,10 @@ class TokenWatchApp {
           this.applyLaunchOnStartup(settings.launchOnStartup);
         }
 
+        if (typeof settings.autoCheckUpdates === 'boolean') {
+          this.initAutoUpdate(settings.autoCheckUpdates);
+        }
+
         if (typeof settings.miniHud === 'boolean' && settings.miniHud !== this.miniHudEnabled) {
           this.miniHudEnabled = settings.miniHud;
           if (this.miniHudEnabled) {