@hienlh/ppm 0.7.8 → 0.7.10

package/src/services/claude-usage.service.ts

@@ -4,9 +4,14 @@ import { existsSync, readFileSync } from "node:fs";
 import {
   insertLimitSnapshot,
   getLatestLimitSnapshot,
+  getLatestSnapshotForAccount,
+  getAllLatestSnapshots,
   cleanupOldLimitSnapshots,
   type LimitSnapshotRow,
 } from "./db.service.ts";
+import { accountService } from "./account.service.ts";
+import { decrypt } from "../lib/account-crypto.ts";
+import { accountSelector } from "./account-selector.service.ts";
 
 export interface LimitBucket {
   utilization: number;
@@ -17,104 +22,48 @@ export interface LimitBucket {
 }
 
 export interface ClaudeUsage {
-  /** ISO timestamp of last successful fetch */
   lastFetchedAt?: string;
   session?: LimitBucket;
   weekly?: LimitBucket;
   weeklyOpus?: LimitBucket;
   weeklySonnet?: LimitBucket;
-  /** Cumulative cost from SDK result events */
   totalCostUsd?: number;
 }
 
+export interface AccountUsageEntry {
+  accountId: string;
+  accountLabel: string | null;
+  accountStatus: string;
+  isOAuth: boolean;
+  usage: ClaudeUsage;
+}
+
 const API_URL = "https://api.anthropic.com/api/oauth/usage";
 const API_BETA = "oauth-2025-04-20";
 const USER_AGENT = "claude-code/1.0";
-const FETCH_TIMEOUT = 10_000; // 10s
-const POLL_INTERVAL = 120_000; // auto-fetch every 2min
-const RETRY_DELAY = 5_000; // 5s between retries
-const MAX_RETRIES = 3;
+const FETCH_TIMEOUT = 10_000;
+const POLL_INTERVAL = 300_000; // 5min
+const ACCOUNT_STAGGER_MS = 1_000; // 1s between accounts
 
-/** In-memory accumulator for cost from SDK result events */
 let inMemoryCostUsd = 0;
-
-/** Cached OAuth token (read once from Keychain/file) */
-let tokenCache: { token: string; timestamp: number } | null = null;
-const TOKEN_TTL = 300_000; // re-read token every 5min
-
-/** Auto-poll timer */
 let pollTimer: ReturnType<typeof setInterval> | null = null;
 
-/**
- * Read OAuth access token from macOS Keychain, fallback to credentials file.
- */
-function getAccessToken(): string {
-  if (tokenCache && Date.now() - tokenCache.timestamp < TOKEN_TTL) {
-    return tokenCache.token;
-  }
-
-  let creds: Record<string, any> | null = null;
+// Per-token cooldown map: token prefix → earliest allowed fetch time
+const tokenCooldowns = new Map<string, number>();
 
-  // macOS Keychain
-  if (process.platform === "darwin") {
-    try {
-      const proc = Bun.spawnSync(["security", "find-generic-password", "-s", "Claude Code-credentials", "-w"]);
-      if (proc.exitCode === 0) {
-        creds = JSON.parse(proc.stdout.toString().trim());
-      }
-    } catch { /* fallback to file */ }
-  }
-
-  // Fallback: ~/.claude/.credentials.json
-  if (!creds) {
-    const credPath = resolve(homedir(), ".claude", ".credentials.json");
-    if (existsSync(credPath)) {
-      creds = JSON.parse(readFileSync(credPath, "utf-8"));
-    }
-  }
-
-  const token = creds?.claudeAiOauth?.accessToken;
-  if (!token) throw new Error("No Claude OAuth token found");
-
-  tokenCache = { token, timestamp: Date.now() };
-  return token;
-}
-
-/** Fetch usage from Anthropic OAuth API */
-async function fetchUsageFromApi(): Promise<ClaudeUsage> {
-  const token = getAccessToken();
-  const res = await fetch(API_URL, {
-    headers: {
-      Accept: "application/json",
-      Authorization: `Bearer ${token}`,
-      "anthropic-beta": API_BETA,
-      "User-Agent": USER_AGENT,
-    },
-    signal: AbortSignal.timeout(FETCH_TIMEOUT),
-  });
-
-  if (!res.ok) {
-    throw new Error(`Usage API returned ${res.status}`);
-  }
-
-  const raw = (await res.json()) as Record<string, any>;
-  const data: ClaudeUsage = { lastFetchedAt: new Date().toISOString() };
-
-  if (raw.five_hour) data.session = parseApiBucket(raw.five_hour, 5);
-  if (raw.seven_day) data.weekly = parseApiBucket(raw.seven_day, 168);
-  if (raw.seven_day_opus) data.weeklyOpus = parseApiBucket(raw.seven_day_opus, 168);
-  if (raw.seven_day_sonnet) data.weeklySonnet = parseApiBucket(raw.seven_day_sonnet, 168);
+// Legacy: Keychain token cache for users without accounts in DB
+let tokenCache: { token: string; timestamp: number } | null = null;
+const TOKEN_TTL = 300_000;
 
-  return data;
-}
+// ---------------------------------------------------------------------------
+// Parsing helpers
+// ---------------------------------------------------------------------------
 
-/** Parse an API bucket (utilization is 0-100 from API, normalize to 0-1) */
 function parseApiBucket(raw: Record<string, any>, windowHours: number): LimitBucket {
   const utilization = (raw.utilization ?? 0) / 100;
   const resetsAt = raw.resets_at ?? "";
   const diff = resetsAt ? new Date(resetsAt).getTime() - Date.now() : 0;
   const totalMins = diff > 0 ? Math.ceil(diff / 60_000) : 0;
-
   return {
     utilization,
     resetsAt,
@@ -124,7 +73,6 @@ function parseApiBucket(raw: Record<string, any>, windowHours: number): LimitBuc
   };
 }
 
-/** Convert DB snapshot row fields back to a LimitBucket (recomputes time-relative fields) */
 function dbBucketToLimitBucket(util: number, resetsAt: string, windowHours: number): LimitBucket {
   const diff = resetsAt ? new Date(resetsAt).getTime() - Date.now() : 0;
   const totalMins = diff > 0 ? Math.ceil(diff / 60_000) : 0;
@@ -137,13 +85,8 @@ function dbBucketToLimitBucket(util: number, resetsAt: string, windowHours: numb
   };
 }
 
-/** Return ClaudeUsage from the latest DB snapshot + in-memory cost */
-export function getCachedUsage(): ClaudeUsage {
-  const row = getLatestLimitSnapshot();
-  const result: ClaudeUsage = {};
-  if (inMemoryCostUsd > 0) result.totalCostUsd = inMemoryCostUsd;
-  if (!row) return result;
-  result.lastFetchedAt = row.recorded_at;
+function snapshotToUsage(row: LimitSnapshotRow): ClaudeUsage {
+  const result: ClaudeUsage = { lastFetchedAt: row.recorded_at };
   if (row.five_hour_util != null) result.session = dbBucketToLimitBucket(row.five_hour_util, row.five_hour_resets_at ?? "", 5);
   if (row.weekly_util != null) result.weekly = dbBucketToLimitBucket(row.weekly_util, row.weekly_resets_at ?? "", 168);
   if (row.weekly_opus_util != null) result.weeklyOpus = dbBucketToLimitBucket(row.weekly_opus_util, row.weekly_opus_resets_at ?? "", 168);
@@ -151,24 +94,56 @@ export function getCachedUsage(): ClaudeUsage {
   return result;
 }
 
-/** Check if new API data differs from the last DB snapshot enough to warrant a new row */
+// ---------------------------------------------------------------------------
+// Fetch usage for a single token
+// ---------------------------------------------------------------------------
+
+async function fetchUsageForToken(token: string): Promise<ClaudeUsage> {
+  const res = await fetch(API_URL, {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+      "anthropic-beta": API_BETA,
+      "User-Agent": USER_AGENT,
+    },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
+  });
+  if (res.status === 429) {
+    const retryAfter = parseInt(res.headers.get("retry-after") ?? "60", 10);
+    const cooldownKey = token.substring(0, 20);
+    tokenCooldowns.set(cooldownKey, Date.now() + retryAfter * 1000);
+    throw new Error(`Usage API 429 — cooldown ${retryAfter}s`);
+  }
+  if (!res.ok) throw new Error(`Usage API returned ${res.status}`);
+  const raw = (await res.json()) as Record<string, any>;
+  const data: ClaudeUsage = { lastFetchedAt: new Date().toISOString() };
+  if (raw.five_hour) data.session = parseApiBucket(raw.five_hour, 5);
+  if (raw.seven_day) data.weekly = parseApiBucket(raw.seven_day, 168);
+  if (raw.seven_day_opus) data.weeklyOpus = parseApiBucket(raw.seven_day_opus, 168);
+  if (raw.seven_day_sonnet) data.weeklySonnet = parseApiBucket(raw.seven_day_sonnet, 168);
+  return data;
+}
+
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+
 function hasChanged(data: ClaudeUsage, last: LimitSnapshotRow | null): boolean {
   if (!last) return true;
-  const diff = (a: number | null | undefined, b: number | null) =>
+  const d = (a: number | null | undefined, b: number | null) =>
     a != null && (b == null || Math.abs(a - b) > 0.001);
-  if (diff(data.session?.utilization, last.five_hour_util)) return true;
-  if (diff(data.weekly?.utilization, last.weekly_util)) return true;
-  // Detect window reset (resetsAt changed)
+  if (d(data.session?.utilization, last.five_hour_util)) return true;
+  if (d(data.weekly?.utilization, last.weekly_util)) return true;
   if (data.session?.resetsAt && data.session.resetsAt !== (last.five_hour_resets_at ?? "")) return true;
   if (data.weekly?.resetsAt && data.weekly.resetsAt !== (last.weekly_resets_at ?? "")) return true;
   return false;
 }
 
-/** Persist API data to DB if changed, then cleanup old rows */
-function persistIfChanged(data: ClaudeUsage): void {
-  const last = getLatestLimitSnapshot();
+function persistIfChanged(data: ClaudeUsage, accountId: string | null): void {
+  const last = accountId ? getLatestSnapshotForAccount(accountId) : getLatestLimitSnapshot();
   if (!hasChanged(data, last)) return;
   insertLimitSnapshot({
+    account_id: accountId,
     five_hour_util: data.session?.utilization ?? null,
     five_hour_resets_at: data.session?.resetsAt ?? null,
     weekly_util: data.weekly?.utilization ?? null,
@@ -181,54 +156,141 @@ function persistIfChanged(data: ClaudeUsage): void {
   cleanupOldLimitSnapshots();
 }
 
-/** Fetch with retry logic, persist to DB if changed */
-async function fetchWithRetry(): Promise<void> {
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+// ---------------------------------------------------------------------------
+// Multi-account polling
+// ---------------------------------------------------------------------------
+
+async function fetchAllAccountUsages(): Promise<void> {
+  const accounts = accountService.list();
+  for (const acc of accounts) {
+    if (acc.status === "disabled") continue;
+    const withTokens = accountService.getWithTokens(acc.id);
+    if (!withTokens) continue;
+    const token = withTokens.accessToken;
+    // Only OAuth tokens have usage endpoint
+    if (!token.startsWith("sk-ant-oat")) continue;
+    // Check cooldown from previous 429
+    const cooldownKey = token.substring(0, 20);
+    const cooldownUntil = tokenCooldowns.get(cooldownKey);
+    if (cooldownUntil && Date.now() < cooldownUntil) {
+      const secs = Math.ceil((cooldownUntil - Date.now()) / 1000);
+      console.log(`[usage] ${acc.label ?? acc.id}: rate-limited, ${secs}s remaining`);
+      continue;
+    }
     try {
-      const data = await fetchUsageFromApi();
-      persistIfChanged(data);
-      return;
+      const data = await fetchUsageForToken(token);
+      tokenCooldowns.delete(cooldownKey); // clear cooldown on success
+      persistIfChanged(data, acc.id);
     } catch (e) {
-      const msg = (e as Error).message ?? "";
-      // Don't retry on 429 — just use stale cache
-      if (msg.includes("429")) return;
-      if (attempt < MAX_RETRIES) {
-        await new Promise((r) => setTimeout(r, RETRY_DELAY));
-      }
+      console.error(`[usage] ${acc.label ?? acc.id}:`, (e as Error).message);
     }
+    if (accounts.length > 1) await new Promise(r => setTimeout(r, ACCOUNT_STAGGER_MS));
   }
 }
 
-/** Start background auto-polling (called once on server start) */
+// Legacy: Keychain-based single-token fetch (no accounts in DB)
+function getLegacyAccessToken(): string | null {
+  if (tokenCache && Date.now() - tokenCache.timestamp < TOKEN_TTL) return tokenCache.token;
+  let creds: Record<string, any> | null = null;
+  if (process.platform === "darwin") {
+    try {
+      const proc = Bun.spawnSync(["security", "find-generic-password", "-s", "Claude Code-credentials", "-w"]);
+      if (proc.exitCode === 0) creds = JSON.parse(proc.stdout.toString().trim());
+    } catch {}
+  }
+  if (!creds) {
+    const credPath = resolve(homedir(), ".claude", ".credentials.json");
+    if (existsSync(credPath)) creds = JSON.parse(readFileSync(credPath, "utf-8"));
+  }
+  const token = creds?.claudeAiOauth?.accessToken;
+  if (!token) return null;
+  tokenCache = { token, timestamp: Date.now() };
+  return token;
+}
+
+async function fetchLegacySingleAccount(): Promise<void> {
+  const token = getLegacyAccessToken();
+  if (!token) return;
+  try {
+    const data = await fetchUsageForToken(token);
+    persistIfChanged(data, null);
+  } catch {}
+}
+
+async function pollOnce(): Promise<void> {
+  const hasAccounts = accountService.list().length > 0;
+  if (hasAccounts) {
+    await fetchAllAccountUsages();
+  } else {
+    await fetchLegacySingleAccount();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Get usage for specific account */
+export function getUsageForAccount(accountId: string): ClaudeUsage {
+  const row = getLatestSnapshotForAccount(accountId);
+  return row ? snapshotToUsage(row) : {};
+}
+
+/** Get usage for all accounts */
+export function getAllAccountUsages(): AccountUsageEntry[] {
+  const accounts = accountService.list();
+  const snapshots = getAllLatestSnapshots();
+  const snapshotMap = new Map(snapshots.map(s => [s.account_id, s]));
+  return accounts.map(acc => {
+    const withTokens = accountService.getWithTokens(acc.id);
+    const isOAuth = withTokens?.accessToken.startsWith("sk-ant-oat") ?? false;
+    const row = snapshotMap.get(acc.id);
+    return {
+      accountId: acc.id,
+      accountLabel: acc.label,
+      accountStatus: acc.status,
+      isOAuth,
+      usage: row ? snapshotToUsage(row) : {},
+    };
+  });
+}
+
+/** Get cached usage for active account (used by chat header) */
+export function getCachedUsage(): ClaudeUsage & { activeAccountId?: string; activeAccountLabel?: string } {
+  const activeId = accountSelector.lastPickedId;
+  if (activeId) {
+    const usage = getUsageForAccount(activeId);
+    const acc = accountService.list().find(a => a.id === activeId);
+    return {
+      ...usage,
+      totalCostUsd: inMemoryCostUsd > 0 ? inMemoryCostUsd : undefined,
+      activeAccountId: activeId,
+      activeAccountLabel: acc?.label ?? undefined,
+    };
+  }
+  // Legacy fallback
+  const row = getLatestLimitSnapshot();
+  const result: ClaudeUsage = {};
+  if (inMemoryCostUsd > 0) result.totalCostUsd = inMemoryCostUsd;
+  if (!row) return result;
+  return snapshotToUsage(row);
+}
+
 export function startUsagePolling(): void {
   if (pollTimer) return;
-  // Initial fetch
-  fetchWithRetry();
-  // Poll every POLL_INTERVAL
-  pollTimer = setInterval(() => fetchWithRetry(), POLL_INTERVAL);
+  pollOnce();
+  pollTimer = setInterval(() => pollOnce(), POLL_INTERVAL);
 }
 
-/** Stop background polling */
 export function stopUsagePolling(): void {
   if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
 }
 
-/**
- * Merge SDK result cost events into in-memory accumulator.
- * Rate limit utilization from SDK events is ignored — API polling is authoritative.
- */
-export function updateFromSdkEvent(
-  _rateLimitType?: string,
-  _utilization?: number,
-  costUsd?: number,
-): void {
-  if (costUsd != null) {
-    inMemoryCostUsd += costUsd;
-  }
+export function updateFromSdkEvent(_rateLimitType?: string, _utilization?: number, costUsd?: number): void {
+  if (costUsd != null) inMemoryCostUsd += costUsd;
 }
 
-/** Force immediate refresh from Anthropic API, persist to DB, return latest */
-export async function refreshUsageNow(): Promise<ClaudeUsage> {
-  await fetchWithRetry();
+export async function refreshUsageNow(): Promise<ClaudeUsage & { activeAccountId?: string; activeAccountLabel?: string }> {
+  await pollOnce();
   return getCachedUsage();
 }

package/src/services/db.service.ts

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
 
 const PPM_DIR = resolve(homedir(), ".ppm");
-const CURRENT_SCHEMA_VERSION = 4;
+const CURRENT_SCHEMA_VERSION = 5;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -188,6 +188,37 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 4;
     `);
   }
+
+  if (current < 5) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS accounts (
+        id TEXT PRIMARY KEY,
+        label TEXT,
+        email TEXT,
+        access_token TEXT NOT NULL,
+        refresh_token TEXT NOT NULL,
+        expires_at INTEGER,
+        status TEXT NOT NULL DEFAULT 'active',
+        cooldown_until INTEGER,
+        priority INTEGER NOT NULL DEFAULT 0,
+        total_requests INTEGER NOT NULL DEFAULT 0,
+        last_used_at INTEGER,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch())
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_accounts_status ON accounts(status);
+
+      PRAGMA user_version = 5;
+    `);
+  }
+
+  if (current < 6) {
+    database.exec(`
+      ALTER TABLE claude_limit_snapshots ADD COLUMN account_id TEXT;
+      CREATE INDEX IF NOT EXISTS idx_limit_snapshots_account ON claude_limit_snapshots(account_id);
+      PRAGMA user_version = 6;
+    `);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -372,6 +403,7 @@ export function getDbFilePath(): string {
 
 export interface LimitSnapshotRow {
   id: number;
+  account_id: string | null;
   five_hour_util: number | null;
   five_hour_resets_at: string | null;
   weekly_util: number | null;
@@ -386,10 +418,11 @@ export interface LimitSnapshotRow {
 export function insertLimitSnapshot(data: Omit<LimitSnapshotRow, "id" | "recorded_at">): void {
   getDb().query(
     `INSERT INTO claude_limit_snapshots
-      (five_hour_util, five_hour_resets_at, weekly_util, weekly_resets_at,
+      (account_id, five_hour_util, five_hour_resets_at, weekly_util, weekly_resets_at,
        weekly_opus_util, weekly_opus_resets_at, weekly_sonnet_util, weekly_sonnet_resets_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   ).run(
+    data.account_id ?? null,
     data.five_hour_util ?? null, data.five_hour_resets_at ?? null,
     data.weekly_util ?? null, data.weekly_resets_at ?? null,
     data.weekly_opus_util ?? null, data.weekly_opus_resets_at ?? null,
@@ -403,6 +436,23 @@ export function getLatestLimitSnapshot(): LimitSnapshotRow | null {
   ).get() as LimitSnapshotRow | null;
 }
 
+export function getLatestSnapshotForAccount(accountId: string): LimitSnapshotRow | null {
+  return getDb().query(
+    "SELECT * FROM claude_limit_snapshots WHERE account_id = ? ORDER BY recorded_at DESC LIMIT 1",
+  ).get(accountId) as LimitSnapshotRow | null;
+}
+
+export function getAllLatestSnapshots(): LimitSnapshotRow[] {
+  return getDb().query(
+    `SELECT s.* FROM claude_limit_snapshots s
+     INNER JOIN (
+       SELECT account_id, MAX(recorded_at) as max_recorded
+       FROM claude_limit_snapshots WHERE account_id IS NOT NULL
+       GROUP BY account_id
+     ) latest ON s.account_id = latest.account_id AND s.recorded_at = latest.max_recorded`,
+  ).all() as LimitSnapshotRow[];
+}
+
 export function cleanupOldLimitSnapshots(): void {
   getDb().query(
     "DELETE FROM claude_limit_snapshots WHERE recorded_at < datetime('now', '-7 days')",
@@ -534,5 +584,69 @@ export function searchTableCache(query: string): Array<TableCacheRow & { connect
   ).all(`%${escaped}%`) as Array<TableCacheRow & { connection_name: string; connection_type: string; connection_color: string | null }>;
 }
 
+// ---------------------------------------------------------------------------
+// Account helpers
+// ---------------------------------------------------------------------------
+
+export interface AccountRow {
+  id: string;
+  label: string | null;
+  email: string | null;
+  access_token: string;
+  refresh_token: string;
+  expires_at: number | null;
+  status: "active" | "cooldown" | "disabled";
+  cooldown_until: number | null;
+  priority: number;
+  total_requests: number;
+  last_used_at: number | null;
+  created_at: number;
+}
+
+export function getAccounts(): AccountRow[] {
+  return getDb().query("SELECT * FROM accounts ORDER BY priority DESC, created_at ASC").all() as AccountRow[];
+}
+
+export function getAccountById(id: string): AccountRow | null {
+  return getDb().query("SELECT * FROM accounts WHERE id = ?").get(id) as AccountRow | null;
+}
+
+export function insertAccount(row: Omit<AccountRow, "created_at">): void {
+  getDb().query(
+    `INSERT INTO accounts (id, label, email, access_token, refresh_token, expires_at, status, cooldown_until, priority, total_requests, last_used_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    row.id, row.label, row.email, row.access_token, row.refresh_token,
+    row.expires_at, row.status, row.cooldown_until, row.priority,
+    row.total_requests, row.last_used_at,
+  );
+}
+
+export function updateAccount(id: string, updates: Partial<Omit<AccountRow, "id" | "created_at">>): void {
+  const sets: string[] = [];
+  const vals: unknown[] = [];
+  if (updates.label !== undefined) { sets.push("label = ?"); vals.push(updates.label); }
+  if (updates.email !== undefined) { sets.push("email = ?"); vals.push(updates.email); }
+  if (updates.access_token !== undefined) { sets.push("access_token = ?"); vals.push(updates.access_token); }
+  if (updates.refresh_token !== undefined) { sets.push("refresh_token = ?"); vals.push(updates.refresh_token); }
+  if (updates.expires_at !== undefined) { sets.push("expires_at = ?"); vals.push(updates.expires_at); }
+  if (updates.status !== undefined) { sets.push("status = ?"); vals.push(updates.status); }
+  if (updates.cooldown_until !== undefined) { sets.push("cooldown_until = ?"); vals.push(updates.cooldown_until); }
+  if (updates.priority !== undefined) { sets.push("priority = ?"); vals.push(updates.priority); }
+  if (updates.total_requests !== undefined) { sets.push("total_requests = ?"); vals.push(updates.total_requests); }
+  if (updates.last_used_at !== undefined) { sets.push("last_used_at = ?"); vals.push(updates.last_used_at); }
+  if (sets.length === 0) return;
+  vals.push(id);
+  getDb().query(`UPDATE accounts SET ${sets.join(", ")} WHERE id = ?`).run(...(vals as SQLQueryBindings[]));
+}
+
+export function deleteAccount(id: string): void {
+  getDb().query("DELETE FROM accounts WHERE id = ?").run(id);
+}
+
+export function incrementAccountRequests(id: string): void {
+  getDb().query("UPDATE accounts SET total_requests = total_requests + 1 WHERE id = ?").run(id);
+}
+
 // Auto-close on process exit
 process.on("beforeExit", closeDb);

package/src/types/chat.ts

@@ -65,6 +65,8 @@ export interface UsageInfo {
   weekly?: LimitBucket;
   weeklyOpus?: LimitBucket;
   weeklySonnet?: LimitBucket;
+  activeAccountId?: string;
+  activeAccountLabel?: string;
 }
 
 /** Result subtype from SDK ResultMessage */

package/src/web/app.tsx

@@ -17,7 +17,6 @@ import {
 import { getAuthToken } from "@/lib/api-client";
 import { useUrlSync, parseUrlState } from "@/hooks/use-url-sync";
 import { useGlobalKeybindings } from "@/hooks/use-global-keybindings";
-import { useHealthCheck } from "@/hooks/use-health-check";
 import { useNotificationBadge } from "@/hooks/use-notification-badge";
 import { CommandPalette } from "@/components/layout/command-palette";
 import { BugReportPopup } from "@/components/shared/bug-report-popup";
@@ -100,9 +99,6 @@ export function App() {
   // Global keyboard shortcuts (Shift+Shift → command palette, Alt+[/] → cycle tabs)
   const { paletteOpen, paletteInitialQuery, closePalette } = useGlobalKeybindings();
 
-  // Health check — detects server crash/restart
-  useHealthCheck();
-
   // Notification badge — syncs document.title + favicon with unread count
   useNotificationBadge();
 

package/src/web/components/chat/chat-history-bar.tsx

@@ -167,6 +167,9 @@ export function ChatHistoryBar({
           title="Usage limits"
         >
           <Activity className="size-3" />
+          {usageInfo.activeAccountLabel && (
+            <span className="text-text-secondary font-normal truncate max-w-[60px]">[{usageInfo.activeAccountLabel}]</span>
+          )}
           <span>5h:{fiveHourPct != null ? `${fiveHourPct}%` : "--%"}</span>
           <span className="text-text-subtle">·</span>
           <span>Wk:{sevenDayPct != null ? `${sevenDayPct}%` : "--%"}</span>