usagelens 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usagelens",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Local dashboard for your AI coding usage across Claude Code, Codex CLI, and Cursor. Reads your machine's local data and serves an interactive dashboard on localhost. Read-only, offline, zero runtime dependencies.",
   "type": "module",
   "bin": {
@@ -31,5 +31,13 @@
     "cli"
   ],
   "author": "Aayush Jain",
-  "license": "MIT"
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aayushGofynd/usagelens.git"
+  },
+  "homepage": "https://github.com/aayushGofynd/usagelens#readme",
+  "bugs": {
+    "url": "https://github.com/aayushGofynd/usagelens/issues"
+  }
 }

package/src/lib/accounts.mjs

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+
+const HOME = homedir();
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+// Decode the payload of a JWT without verifying (local, read-only, best-effort).
+function jwtPayload(token) {
+  try {
+    const seg = String(token).split('.')[1];
+    const json = Buffer.from(seg.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
+    return JSON.parse(json);
+  } catch { return null; }
+}
+
+// Claude: oauthAccount lives in a .claude.json near the config/projects dir.
+export function claudeAccount(root) {
+  const candidates = [
+    join(root, '.claude.json'),
+    join(dirname(root), '.claude.json'),      // <root>/projects -> <root>/.claude.json
+    root.replace(/\/?$/, '') + '.json',       // ~/.claude-work -> ~/.claude-work.json
+    join(HOME, '.claude.json'),
+  ];
+  for (const c of candidates) {
+    const j = readJson(c);
+    const oa = j?.oauthAccount;
+    if (oa?.emailAddress) return oa.emailAddress;
+  }
+  return null;
+}
+
+// Codex: email from the id_token JWT, else account_id, from auth.json.
+export function codexAccount(root) {
+  for (const c of [join(root, 'auth.json'), join(HOME, '.codex', 'auth.json')]) {
+    const j = readJson(c);
+    if (!j) continue;
+    const p = jwtPayload(j.tokens?.id_token);
+    const email = p?.email || p?.['https://api.openai.com/profile']?.email;
+    if (email) return email;
+    const acct = j.tokens?.account_id;
+    if (acct) return `openai:${String(acct).slice(0, 8)}`;
+  }
+  return null;
+}
+
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+// Antigravity (Gemini): display name from the VS Code state DB auth status.
+export function antigravityAccount() {
+  const db = join(HOME, 'Library', 'Application Support', 'Antigravity', 'User', 'globalStorage', 'state.vscdb');
+  if (!existsSync(db)) return null;
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    const d = new DatabaseSync(db, { readOnly: true });
+    const row = d.prepare("SELECT value FROM ItemTable WHERE key='antigravityAuthStatus'").get();
+    d.close();
+    const v = row && JSON.parse(row.value);
+    return v?.name || v?.email || null;
+  } catch { return null; }
+}
+
+// Fallback label when no identity can be derived.
+export function fallbackAccount(dir) { return basename(dir) || 'local'; }

package/src/lib/adapters.mjs

@@ -1,137 +1,195 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { costOf } from './pricing.mjs';
+import { antigravityAccount, claudeAccount, codexAccount, fallbackAccount } from './accounts.mjs';
 
 const HOME = homedir();
+const require = createRequire(import.meta.url);
+const expand = (p) => (p.startsWith('~') ? join(HOME, p.slice(1)) : p);
 
-function walk(dir) {
+function walk(dir, ext) {
   if (!existsSync(dir)) return [];
   const out = [];
   for (const name of readdirSync(dir)) {
     let p = join(dir, name), st;
     try { st = statSync(p); } catch { continue; }
-    if (st.isDirectory()) out.push(...walk(p));
-    else if (name.endsWith('.jsonl')) out.push(p);
+    if (st.isDirectory()) out.push(...walk(p, ext));
+    else if (!ext || name.endsWith(ext)) out.push(p);
   }
   return out;
 }
 
 // ---------- Claude ----------
-export function loadClaude() {
-  const root = join(HOME, '.claude', 'projects');
-  if (!existsSync(root)) return { events: [], commits: [], status: { tool: 'claude', available: false, note: 'no ~/.claude/projects' } };
+export function loadClaude(dir, account) {
+  const root = dir ?? join(HOME, '.claude', 'projects');
+  if (!existsSync(root)) return { events: [], commits: [], activity: [], status: { tool: 'claude', account, available: false, note: 'no projects dir' } };
   const events = [];
-  for (const f of walk(root)) {
-    let text;
-    try { text = readFileSync(f, 'utf8'); } catch { continue; }
+  for (const f of walk(root, '.jsonl')) {
+    let text; try { text = readFileSync(f, 'utf8'); } catch { continue; }
     for (const line of text.split('\n')) {
       if (!line.trim()) continue;
-      let row;
-      try { row = JSON.parse(line); } catch { continue; }
+      let row; try { row = JSON.parse(line); } catch { continue; }
       if (row.type !== 'assistant') continue;
       const m = row.message, u = m?.usage;
       if (!u || !m?.model) continue;
       const cwd = row.cwd ?? 'unknown';
       const t = {
-        inputTokens: u.input_tokens ?? 0,
-        outputTokens: u.output_tokens ?? 0,
-        cacheReadTokens: u.cache_read_input_tokens ?? 0,
-        cacheCreateTokens: u.cache_creation_input_tokens ?? 0,
+        inputTokens: u.input_tokens ?? 0, outputTokens: u.output_tokens ?? 0,
+        cacheReadTokens: u.cache_read_input_tokens ?? 0, cacheCreateTokens: u.cache_creation_input_tokens ?? 0,
       };
       events.push({
-        tool: 'claude', model: m.model, project: basename(cwd), projectPath: cwd,
+        tool: 'claude', account, model: m.model, project: basename(cwd), projectPath: cwd,
         gitBranch: row.gitBranch || undefined, timestamp: row.timestamp,
         sessionId: row.sessionId ?? basename(f, '.jsonl'), ...t, costUsd: costOf(m.model, t),
       });
     }
   }
-  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
-  return { events, commits: [], status: { tool: 'claude', available: true, lastActivity: last, count: events.length } };
+  return { events, commits: [], activity: [], status: statusOf('claude', account, events) };
 }
 
 // ---------- Codex ----------
-export function loadCodex() {
-  const base = join(HOME, '.codex');
-  const files = ['sessions', 'archived_sessions'].flatMap((r) => walk(join(base, r)));
-  if (files.length === 0) return { events: [], commits: [], status: { tool: 'codex', available: false, note: 'no ~/.codex sessions' } };
+export function loadCodex(dir, account) {
+  const base = dir ?? join(HOME, '.codex');
+  const files = ['sessions', 'archived_sessions'].flatMap((r) => walk(join(base, r), '.jsonl'));
+  if (files.length === 0) return { events: [], commits: [], activity: [], status: { tool: 'codex', account, available: false, note: 'no sessions' } };
   const events = [];
   for (const f of files) {
-    let text;
-    try { text = readFileSync(f, 'utf8'); } catch { continue; }
+    let text; try { text = readFileSync(f, 'utf8'); } catch { continue; }
     let model = 'gpt-5', cwd = 'unknown', sessionId = basename(f, '.jsonl');
     for (const line of text.split('\n')) {
       if (!line.trim()) continue;
-      let row;
-      try { row = JSON.parse(line); } catch { continue; }
+      let row; try { row = JSON.parse(line); } catch { continue; }
       const p = row.payload ?? row;
-      // Codex sessions nest the real event type inside event_msg/response_item payloads.
       const kind = (row.type === 'event_msg' || row.type === 'response_item') ? (p.type ?? row.type) : row.type;
       if (kind === 'session_meta') { cwd = p.cwd ?? cwd; sessionId = p.id ?? sessionId; }
       else if (kind === 'turn_context') { if (p.model) model = p.model; if (p.cwd) cwd = p.cwd; }
       else if (kind === 'token_count') {
-        const last = p.info?.last_token_usage;
-        if (!last) continue;
+        const last = p.info?.last_token_usage; if (!last) continue;
         const cached = last.cached_input_tokens ?? 0;
         const t = {
-          inputTokens: Math.max(0, (last.input_tokens ?? 0) - cached),
-          outputTokens: last.output_tokens ?? 0,
+          inputTokens: Math.max(0, (last.input_tokens ?? 0) - cached), outputTokens: last.output_tokens ?? 0,
           cacheReadTokens: cached, cacheCreateTokens: 0,
         };
         if (t.inputTokens + t.outputTokens + t.cacheReadTokens === 0) continue;
         events.push({
-          tool: 'codex', model, project: basename(cwd), projectPath: cwd,
+          tool: 'codex', account, model, project: basename(cwd), projectPath: cwd,
           timestamp: row.timestamp, sessionId, ...t, costUsd: costOf(model, t),
         });
       }
     }
   }
-  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
-  return { events, commits: [], status: { tool: 'codex', available: true, lastActivity: last, count: events.length } };
+  return { events, commits: [], activity: [], status: statusOf('codex', account, events) };
 }
 
 // ---------- Cursor ----------
-export function loadCursor() {
-  const path = join(HOME, '.cursor', 'ai-tracking', 'ai-code-tracking.db');
-  if (!existsSync(path)) return { events: [], commits: [], status: { tool: 'cursor', available: false, note: 'no cursor ai-tracking db' } };
+export function loadCursor(dir, account) {
+  const path = join(dir ?? join(HOME, '.cursor'), 'ai-tracking', 'ai-code-tracking.db');
+  if (!existsSync(path)) return { events: [], commits: [], activity: [], status: { tool: 'cursor', account, available: false, note: 'no ai-tracking db' } };
   const commits = [];
   try {
     const { DatabaseSync } = require('node:sqlite');
     const db = new DatabaseSync(path, { readOnly: true });
-    const rows = db.prepare(
-      'SELECT commitHash, branchName, scoredAt, linesAdded, v1AiPercentage, v2AiPercentage FROM scored_commits'
-    ).all();
+    const rows = db.prepare('SELECT commitHash, branchName, scoredAt, linesAdded, v1AiPercentage, v2AiPercentage FROM scored_commits').all();
     for (const r of rows) {
       const total = r.linesAdded ?? 0;
       const aiPct = Number(r.v2AiPercentage ?? r.v1AiPercentage ?? 0) || 0;
       const aiLines = Math.round((total * aiPct) / 100);
       commits.push({
-        tool: 'cursor', timestamp: new Date(Number(r.scoredAt)).toISOString(),
+        tool: 'cursor', account, timestamp: new Date(Number(r.scoredAt)).toISOString(),
         commitHash: r.commitHash, branchName: r.branchName ?? 'unknown',
         totalLines: total, aiLines, humanLines: Math.max(0, total - aiLines), aiPct,
       });
     }
     db.close();
   } catch (e) {
-    return { events: [], commits: [], status: { tool: 'cursor', available: false, note: 'cursor db unreadable: ' + e.message } };
+    return { events: [], commits: [], activity: [], status: { tool: 'cursor', account, available: false, note: 'db unreadable: ' + e.message } };
   }
   const last = commits.reduce((a, c) => (!a || c.timestamp > a ? c.timestamp : a), undefined);
-  return { events: [], commits, status: { tool: 'cursor', available: true, lastActivity: last, count: commits.length } };
+  return { events: [], commits, activity: [], status: { tool: 'cursor', account, available: true, lastActivity: last, count: commits.length, kind: 'authorship' } };
 }
 
-// require shim for ESM (node:sqlite import)
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
+// ---------- Antigravity (Gemini) — activity only, no tokens ----------
+export function loadAntigravity(dir, account) {
+  const base = dir ?? join(HOME, '.gemini', 'antigravity');
+  if (!existsSync(base)) return { events: [], commits: [], activity: [], status: { tool: 'antigravity', account, available: false, note: 'not installed' } };
+  const activity = [];
+  // conversations = sessions
+  for (const f of walk(join(base, 'conversations'), '.pb')) {
+    let ts; try { ts = new Date(statSync(f).mtimeMs).toISOString(); } catch { continue; }
+    activity.push({ tool: 'antigravity', account, kind: 'session', project: 'antigravity', timestamp: ts });
+  }
+  // code_tracker = AI-touched files, project = workspace dir (minus trailing hash)
+  for (const root of ['active', 'history']) {
+    const rd = join(base, 'code_tracker', root);
+    if (!existsSync(rd)) continue;
+    for (const ws of readdirSync(rd)) {
+      const wsDir = join(rd, ws);
+      let st; try { st = statSync(wsDir); } catch { continue; }
+      if (!st.isDirectory()) continue;
+      const project = ws.replace(/_[0-9a-f]{40}$/, '') || 'antigravity';
+      for (const f of walk(wsDir)) {
+        const m = basename(f).match(/_(\d{14})-/);
+        let ts;
+        if (m) { const d = m[1]; ts = `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}T${d.slice(8, 10)}:${d.slice(10, 12)}:${d.slice(12, 14)}`; }
+        else { try { ts = new Date(statSync(f).mtimeMs).toISOString(); } catch { continue; } }
+        activity.push({ tool: 'antigravity', account, kind: 'file', project, timestamp: ts });
+      }
+    }
+  }
+  const last = activity.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
+  return { events: [], commits: [], activity, status: { tool: 'antigravity', account, available: activity.length > 0, lastActivity: last, count: activity.length, kind: 'activity' } };
+}
+
+function statusOf(tool, account, events) {
+  const last = events.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined);
+  return { tool, account, available: events.length > 0, lastActivity: last, count: events.length, kind: 'tokens' };
+}
+
+// ---------- source composition ----------
+function defaultSources() {
+  return [
+    { tool: 'claude', dir: join(HOME, '.claude', 'projects'), account: claudeAccount(join(HOME, '.claude', 'projects')) },
+    { tool: 'codex', dir: join(HOME, '.codex'), account: codexAccount(join(HOME, '.codex')) },
+    { tool: 'cursor', dir: join(HOME, '.cursor'), account: 'cursor (local)' },
+    { tool: 'antigravity', dir: join(HOME, '.gemini', 'antigravity'), account: antigravityAccount() },
+  ];
+}
+
+function configuredSources() {
+  const cfg = join(HOME, '.usagelens.json');
+  if (!existsSync(cfg)) return null;
+  try {
+    const j = JSON.parse(readFileSync(cfg, 'utf8'));
+    if (!Array.isArray(j.sources) || j.sources.length === 0) return null;
+    return j.sources.map((s) => ({ tool: s.tool, dir: expand(s.dir ?? ''), account: s.label ?? s.account ?? null }));
+  } catch { return null; }
+}
+
+const LOADERS = { claude: loadClaude, codex: loadCodex, cursor: loadCursor, antigravity: loadAntigravity };
 
 export function loadAll() {
-  const events = [], commits = [], statuses = [];
-  for (const fn of [loadClaude, loadCodex, loadCursor]) {
-    try { const r = fn(); events.push(...r.events); commits.push(...r.commits); statuses.push(r.status); }
-    catch (e) { statuses.push({ tool: fn.name.replace('load', '').toLowerCase(), available: false, note: e.message }); }
+  const sources = configuredSources() ?? defaultSources();
+  const events = [], commits = [], activity = [], statuses = [];
+  const accounts = new Set();
+  for (const s of sources) {
+    const loader = LOADERS[s.tool];
+    if (!loader) { statuses.push({ tool: s.tool, available: false, note: 'unknown tool' }); continue; }
+    const account = s.account || fallbackAccount(s.dir);
+    try {
+      const r = loader(s.dir, account);
+      events.push(...r.events); commits.push(...r.commits); activity.push(...(r.activity ?? []));
+      statuses.push(r.status);
+      if (r.status.available) accounts.add(account);
+    } catch (e) { statuses.push({ tool: s.tool, account, available: false, note: e.message }); }
   }
-  // detect-only tools with no parseable usage
-  for (const [tool, rel] of [['gemini', '.gemini'], ['copilot', '.copilot'], ['ollama', '.ollama']]) {
-    if (existsSync(join(HOME, rel))) statuses.push({ tool, available: false, note: 'detected, no usage metrics exposed' });
+  // tools present on disk but exposing no usable local usage
+  for (const [tool, rel, note] of [
+    ['copilot', '.copilot', 'no local usage (editor/cloud only)'],
+    ['ollama', '.ollama', 'no logged inference calls (server pings only)'],
+  ]) {
+    if (existsSync(join(HOME, rel))) statuses.push({ tool, available: false, note });
   }
-  return { events, commits, statuses };
+  return { events, commits, activity, statuses, accounts: [...accounts].sort() };
 }

package/src/lib/aggregate.mjs

@@ -141,11 +141,30 @@ function authorship(commits) {
   };
 }
 
-export function buildPayload(ds, range, now) {
+function activitySummary(activity) {
+  const byProject = new Map();
+  const byDay = new Set();
+  let sessions = 0, files = 0;
+  for (const a of activity) {
+    if (a.kind === 'session') sessions += 1; else files += 1;
+    byProject.set(a.project, (byProject.get(a.project) ?? 0) + 1);
+    byDay.add(localDayKey(a.timestamp));
+  }
+  return {
+    total: activity.length, sessions, files, activeDays: byDay.size,
+    byProject: [...byProject.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count).slice(0, 8),
+  };
+}
+
+export function buildPayload(ds, range, now, account) {
   const win = rangeWindow(range, now), prior = priorWindow(range, now);
-  const cur = ds.events.filter((e) => inWin(e.timestamp, win));
-  const prev = ds.events.filter((e) => inWin(e.timestamp, prior));
-  const commits = ds.commits.filter((c) => inWin(c.timestamp, win));
+  const pick = (arr) => (account && account !== 'all' ? arr.filter((x) => x.account === account) : arr);
+  const evAll = pick(ds.events), coAll = pick(ds.commits), acAll = pick(ds.activity ?? []);
+  const cur = evAll.filter((e) => inWin(e.timestamp, win));
+  const prev = evAll.filter((e) => inWin(e.timestamp, prior));
+  const commits = coAll.filter((c) => inWin(c.timestamp, win));
+  const activity = acAll.filter((a) => inWin(a.timestamp, win));
+  const lastAll = [...cur.map((e) => e.timestamp), ...commits.map((c) => c.timestamp), ...activity.map((a) => a.timestamp)];
   return {
     summary: summarize(cur, prev),
     breakdowns: { byTool: group(cur, (e) => e.tool), byModel: group(cur, (e) => e.model), byProject: group(cur, (e) => e.project, 12) },
@@ -153,7 +172,9 @@ export function buildPayload(ds, range, now) {
     heatmap: heatmap(cur),
     sessions: sessionShape(cur),
     authorship: authorship(commits),
+    activity: activitySummary(activity),
     tools: ds.statuses,
-    meta: { range, generatedAt: now.toISOString(), lastActivity: cur.reduce((a, e) => (!a || e.timestamp > a ? e.timestamp : a), undefined) },
+    accounts: ds.accounts ?? [],
+    meta: { range, account: account ?? 'all', generatedAt: now.toISOString(), lastActivity: lastAll.reduce((a, t) => (!a || t > a ? t : a), undefined) },
   };
 }

package/src/public/app.js

@@ -217,9 +217,28 @@ function render(d) {
   ]);
   app.append(el('div', { class: 'grid' }, [panel('CODE AUTHORSHIP · CURSOR', 'weekly AI vs human lines', authBody)]));
 
+  // activity (Antigravity / Gemini) — count-only signal, no tokens
+  if (d.activity && d.activity.total > 0) {
+    const maxA = d.activity.byProject[0]?.count || 1;
+    const actBody = el('div', {}, [
+      el('div', { class: 'statPair', style: 'margin-bottom:10px' }, [
+        el('div', {}, [el('div', { class: 'k' }, 'SESSIONS'), el('div', { class: 'v' }, fmtInt(d.activity.sessions))]),
+        el('div', {}, [el('div', { class: 'k' }, 'AI-TOUCHED FILES'), el('div', { class: 'v' }, fmtInt(d.activity.files))]),
+        el('div', {}, [el('div', { class: 'k' }, 'ACTIVE DAYS'), el('div', { class: 'v' }, fmtInt(d.activity.activeDays))]),
+      ]),
+      ...d.activity.byProject.map((p) => barRow(p.key, `${fmtInt(p.count)}`, (p.count / maxA) * 100, 'var(--c5)')),
+    ]);
+    app.append(el('div', { class: 'grid' }, [panel('ACTIVITY · ANTIGRAVITY (GEMINI)', 'sessions & AI-touched files · no token data', actBody)]));
+  }
+
   // tool chips
-  const chips = el('div', { class: 'tools' }, d.tools.map((t) =>
-    el('div', { class: 'chip ' + (t.available ? 'on' : ''), html: `<span class="d" style="background:${t.available ? 'var(--good)' : 'var(--line)'};width:8px;height:8px;border-radius:50%;display:inline-block"></span><b>${esc(t.tool)}</b> ${t.available ? (t.count != null ? fmtInt(t.count) + ' records' : 'active') : esc(t.note || 'no data')}` })));
+  const kindLabel = { tokens: 'tokens', authorship: 'code lines', activity: 'activity' };
+  const chips = el('div', { class: 'tools' }, d.tools.map((t) => {
+    const detail = t.available
+      ? `${t.count != null ? fmtInt(t.count) + ' ' + (kindLabel[t.kind] || 'records') : 'active'}${t.account ? ' · ' + esc(t.account) : ''}`
+      : esc(t.note || 'no data');
+    return el('div', { class: 'chip ' + (t.available ? 'on' : ''), html: `<span class="d" style="background:${t.available ? 'var(--good)' : 'var(--line)'};width:8px;height:8px;border-radius:50%;display:inline-block"></span><b>${esc(t.tool)}</b> ${detail}` });
+  }));
   app.append(el('div', {}, [el('div', { class: 'clabel', style: 'margin-top:8px' }, 'TOOLS DETECTED'), chips]));
   app.append(el('div', { class: 'foot' }, `Generated ${new Date(d.meta.generatedAt).toLocaleString()} · read-only from ~/.claude, ~/.codex, ~/.cursor · cost is estimated API-equivalent, not a bill`));
 }
@@ -227,7 +246,7 @@ function render(d) {
 let range = '30d';
 async function load() {
   try {
-    const r = await fetch('/api/dashboard?range=' + range);
+    const r = await fetch(`/api/dashboard?range=${range}&account=all`);
     render(await r.json());
   } catch (e) { $('#app').innerHTML = '<div class="loading">Failed: ' + e.message + '</div>'; }
 }

package/src/public/index.html

@@ -22,6 +22,8 @@
   h1.hero b{color:var(--accent);font-weight:600;font-variant-numeric:tabular-nums}
   .heroSub{color:var(--sub);font-size:14px;margin:0}
   .heroSub b{color:var(--ink);font-weight:600}
+  .controls{display:flex;gap:10px;align-items:center;flex-wrap:wrap}
+  #account{font-family:var(--mono);font-size:13px;color:var(--ink);background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:7px 12px;cursor:pointer;max-width:280px}
   .toggle{display:inline-flex;gap:2px;background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:3px}
   .toggle button{border:0;background:transparent;color:var(--sub);font-weight:600;font-size:13px;
     padding:6px 14px;border-radius:7px;cursor:pointer;font-family:var(--mono)}

package/src/server.mjs

@@ -29,10 +29,11 @@ function parseArgs(argv) {
 
 const { port, open } = parseArgs(process.argv.slice(2));
 
-process.stdout.write('usagelens · scanning ~/.claude, ~/.codex, ~/.cursor …\n');
+process.stdout.write('usagelens · scanning Claude, Codex, Cursor, Antigravity …\n');
 const t0 = Date.now();
 const dataset = loadAll();
-process.stdout.write(`usagelens · loaded ${dataset.events.length} usage events + ${dataset.commits.length} commits in ${Date.now() - t0}ms\n`);
+process.stdout.write(`usagelens · loaded ${dataset.events.length} usage events + ${dataset.commits.length} commits + ${dataset.activity.length} activity in ${Date.now() - t0}ms\n`);
+process.stdout.write(`usagelens · accounts: ${dataset.accounts.join(', ') || 'none'}\n`);
 for (const s of dataset.statuses) process.stdout.write(`   ${s.available ? '✓' : '·'} ${s.tool}${s.count != null ? ` (${s.count})` : ''}${s.note ? ' — ' + s.note : ''}\n`);
 
 const server = createServer((req, res) => {
@@ -40,7 +41,8 @@ const server = createServer((req, res) => {
   if (url.pathname === '/api/dashboard') {
     const rq = url.searchParams.get('range');
     const range = ['7d', '30d', '90d'].includes(rq) ? rq : '30d';
-    const body = JSON.stringify(buildPayload(dataset, range, new Date()));
+    const account = url.searchParams.get('account') || 'all';
+    const body = JSON.stringify(buildPayload(dataset, range, new Date(), account));
     res.writeHead(200, { 'content-type': 'application/json' }).end(body);
     return;
   }