tokenflexing 1.1.0

package/README.md

@@ -0,0 +1,138 @@
+# tokenflex
+
+Show off your AI token usage. Universal CLI for Claude Code, Codex, Cursor, and more.
+
+```bash
+npx tokenflex@latest scan
+```
+
+Scans your entire device for AI tool usage data, extracts token counts where possible, and shows everything else it detected. **Never reads prompts or completions — only usage/token blocks.**
+
+## Commands
+
+| Command | What |
+|---|---|
+| `tokenflex` / `tokenflex stats` | Today / 7-day / 30-day / all-time dollar + token spend per source, per model |
+| `tokenflex scan` | Universal device inventory — measured, detected, and not-found in one view |
+| `tokenflex flex` | Shareable ASCII card — drop in tweets, HN comments, or Slack |
+| `tokenflex daemon` | Preview the daily auto-refresh LaunchAgent (macOS) or Task Scheduler entry (Windows) |
+| `tokenflex daemon --install` | Install the daemon (runs `tokenflex scan` at 6:00 AM daily) |
+| `tokenflex daemon --uninstall` | Remove the daemon |
+| `tokenflex mcp` | Start MCP server — Claude Code, Cursor, and any MCP-capable agent can call tokenflex tools natively |
+| `tokenflex install-hooks --apply` | Register tokenflex as an MCP server in Claude Code or Cursor settings |
+| `tokenflex --help` | Usage |
+
+## What `tokenflex scan` detects
+
+| Tool | Status |
+|---|---|
+| **Claude Code** | ✅ Token counts + cost extracted (`~/.claude/projects/**/*.jsonl`) |
+| **Codex CLI** | ✅ Token counts + cost extracted (`~/.codex/sessions/**/*.jsonl`) |
+| **Cursor** | 🔍 Detected — SQLite `state.vscdb` reader planned |
+| **Claude Desktop** | 🔍 Detected — Electron, no token events exposed |
+| **ChatGPT Desktop** | 🔍 Detected — Electron, conversation data only |
+| **Windsurf (Codeium)** | 🔍 Detected — structured token log not exposed yet |
+| **Continue.dev** | 🔍 Detected — telemetry parser planned |
+| **Aider** | 🔍 Detected — cost-line parser planned |
+| **Cline** | 🔍 Detected — `ui_messages.json` task parser planned |
+| **Roo Code** | 🔍 Detected — `ui_messages.json` task parser planned |
+| **Kilo Code** | 🔍 Detected — `ui_messages.json` task parser planned |
+| **Zed AI** | 🔍 Detected — SQLite `threads.db` reader planned |
+| **Gemini CLI** | 🔍 Detected — `~/.gemini/tmp/*.jsonl` parser planned |
+| **OpenCode** | 🔍 Detected — `opencode/storage/message/*.json` parser planned |
+| **Amp** | 🔍 Detected — `amp/threads/T-*.json` parser planned |
+| **Antigravity (Google)** | 🔍 Detected — session cache format TBD |
+| **GitHub Copilot** | 🔍 Detected — OTEL trace extraction planned |
+| **Goose (Block)** | 🔍 Detected — SQLite `sessions.db` reader planned |
+| **Kiro (Amazon)** | 🔍 Detected — `~/.kiro/sessions/cli/*.json` parser planned |
+| **Mux** | 🔍 Detected — `session-usage.json` parser planned |
+| **OpenClaw** | 🔍 Detected — JSONL agent sessions parser planned |
+| **Crush** | 🔍 Detected — `projects.json` parser planned |
+| **Kimi (Moonshot)** | 🔍 Detected — `wire.jsonl` parser planned |
+| **Hermes** | 🔍 Detected — SQLite `state.db` reader planned |
+
+macOS, Windows, and Linux (XDG) paths covered.
+
+## Why local files?
+
+Provider Admin APIs (Anthropic / OpenAI) require **organization admin** keys that individual developers don't have. Local session JSONL files contain per-turn usage data for **anyone** using Claude Code or Codex CLI on any plan — no org key needed.
+
+## Install
+
+```bash
+# one-shot
+npx tokenflex@latest stats
+
+# or install globally
+npm install -g tokenflex
+tokenflex scan
+```
+
+Requires Node ≥ 18.
+
+## MCP Server (agent-native access)
+
+Register tokenflex as an MCP server so Claude Code, Cursor, and any MCP-capable agent can query your stats inline:
+
+```bash
+# Dry-run — shows what will be written
+npx tokenflex@latest install-hooks
+
+# Write MCP entry to ~/.claude/settings.json (Claude Code)
+npx tokenflex@latest install-hooks --apply
+
+# Write to ~/.cursor/mcp.json (Cursor)
+npx tokenflex@latest install-hooks --client cursor --apply
+
+# Project-local (writes to .claude/settings.json in current dir)
+npx tokenflex@latest install-hooks --apply --project
+```
+
+After restarting your editor, your agent gets three new tools:
+
+| Tool | What it does |
+|---|---|
+| `get_my_stats` | Token spend by period and model |
+| `get_device_scan` | Which AI tools are installed + measured |
+| `get_flex_card` | Shareable one-liner for X / HN / Slack |
+
+Or run the MCP server directly (for custom integrations):
+
+```bash
+npx tokenflex@latest mcp
+```
+
+MCP entry format for manual config:
+
+```json
+{
+  "mcpServers": {
+    "tokenflex": { "command": "npx", "args": ["-y", "tokenflex@latest", "mcp"], "type": "stdio" }
+  }
+}
+```
+
+## Daily auto-refresh
+
+```bash
+# macOS: installs a LaunchAgent that runs tokenflex scan at 6 AM
+tokenflex daemon --install
+
+# Windows: creates a Task Scheduler entry
+tokenflex daemon --install
+
+# Remove
+tokenflex daemon --uninstall
+```
+
+Cloud sync (`tokenflex login` → push to tokenflexing.com profile) ships in v0.3.
+
+## Privacy
+
+- No network calls. Pure local read.
+- Only usage blocks (token counts, model ids) are parsed — never message content.
+- `tokenflex daemon` logs to `/tmp/tokenflex-sync.log` only.
+
+## License
+
+MIT

package/bin/tokenflexing.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../src/cli.js").then((m) => m.main(process.argv.slice(2)));

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "tokenflexing",
+  "version": "1.1.0",
+  "description": "Show off your AI token usage. CLI for Claude Code, Codex, Cursor, OpenCode and more.",
+  "type": "module",
+  "bin": {
+    "tokenflexing": "bin/tokenflexing.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "tokens",
+    "ai-usage",
+    "tokenflexing",
+    "cli"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "start": "node bin/tokenflexing.js"
+  }
+}

package/src/cli.js

@@ -0,0 +1,1027 @@
+/**
+ * tokenflexing — show off your AI token usage.
+ * Universal scanner: Claude Code, Codex CLI, Cursor, Windsurf, and more.
+ * Never reads prompts or completions — only usage/token blocks.
+ */
+
+import {
+  readdirSync, statSync, readFileSync, writeFileSync,
+  existsSync, mkdirSync, unlinkSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir, userInfo } from "node:os";
+import { execFileSync } from "node:child_process";
+// node:readline used for interactive prompts in commandLogin
+import { createInterface } from "node:readline";
+
+/* ───── Platform ───────────────────────────────────────────────── */
+
+const IS_WIN = process.platform === "win32";
+const IS_MAC = process.platform === "darwin";
+const APPDATA = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+const LIB    = join(homedir(), "Library", "Application Support");
+const XDG    = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+
+/** Return mac / win / linux variant of a path array. */
+function pf(mac, win, linux) {
+  return IS_MAC ? mac : IS_WIN ? (win ?? mac) : (linux ?? mac);
+}
+
+/** Path to a VSCode-family extension's globalStorage directory. */
+function vscodeExt(extId) {
+  return pf(
+    join(LIB,    "Code", "User", "globalStorage", extId),
+    join(APPDATA,"Code", "User", "globalStorage", extId),
+    join(homedir(), ".config", "Code", "User", "globalStorage", extId)
+  );
+}
+
+/* ───── Cloud sync config ──────────────────────────────────────── */
+
+const SITE = process.env.TOKENFLEX_SITE ?? "https://tokenflexing.vercel.app";
+
+/** Where the CLI token is persisted locally. */
+function tokenPath() {
+  const base = process.env.XDG_CONFIG_HOME
+    ?? (IS_WIN ? join(APPDATA, "tokenflexing") : join(homedir(), ".config", "tokenflexing"));
+  return join(base, "token");
+}
+
+function loadToken() {
+  const p = tokenPath();
+  if (!existsSync(p)) return null;
+  return readFileSync(p, "utf8").trim() || null;
+}
+
+function saveToken(raw) {
+  const p = tokenPath();
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, raw + "\n", { mode: 0o600 });
+}
+
+/* ───── ANSI ───────────────────────────────────────────────────── */
+
+const isTTY = process.stdout.isTTY === true;
+const c = isTTY
+  ? {
+      reset: "\x1b[0m", dim: "\x1b[2m", bold: "\x1b[1m",
+      green: "\x1b[38;5;46m", flex: "\x1b[48;5;46m\x1b[38;5;232m",
+      faint: "\x1b[38;5;245m", yellow: "\x1b[38;5;226m",
+    }
+  : new Proxy({}, { get: () => "" });
+
+function pad(s, n) {
+  s = String(s);
+  return s + " ".repeat(Math.max(0, n - s.replace(/\x1b\[[0-9;]*m/g, "").length));
+}
+
+const fmtUsd = (n) =>
+  isFinite(n)
+    ? new Intl.NumberFormat("en-US", { style: "currency", currency: "USD", maximumFractionDigits: 2 }).format(n)
+    : "—";
+const fmtUsdC = (n) =>
+  isFinite(n)
+    ? new Intl.NumberFormat("en-US", { style: "currency", currency: "USD", notation: "compact", maximumFractionDigits: 1 }).format(n)
+    : "—";
+const fmtNum = (n) => new Intl.NumberFormat("en-US").format(n);
+const fmtC   = (n) => new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 }).format(n);
+
+/* ───── Sparkline ──────────────────────────────────────────────── */
+
+const BLOCKS = " ▁▂▃▄▅▆▇█";
+
+/** 14-day ASCII cost sparkline from a Map<date, {cost, tokens}>. */
+function sparkline(byDay, days = 14) {
+  const today = new Date();
+  const dates = Array.from({ length: days }, (_, i) => {
+    const d = new Date(today);
+    d.setDate(d.getDate() - (days - 1 - i));
+    return d.toISOString().slice(0, 10);
+  });
+  const vals = dates.map((d) => byDay.get(d)?.cost ?? 0);
+  const max  = Math.max(...vals, 0.0001);
+  return vals.map((v) => BLOCKS[Math.min(8, Math.round((v / max) * 8))]).join("");
+}
+
+/** Merge byDay maps from multiple parsed sources. */
+function mergeByDay(sources) {
+  const m = new Map();
+  for (const r of sources) {
+    for (const [d, b] of (r.stats.byDay ?? new Map())) {
+      const e = m.get(d) ?? { tokens: 0, cost: 0 };
+      e.tokens += b.tokens; e.cost += b.cost;
+      m.set(d, e);
+    }
+  }
+  return m;
+}
+
+/* ───── Pricing ────────────────────────────────────────────────── */
+
+const ANT_PRICE = {
+  "claude-opus-4-7":   { in: 15,  out: 75,  cached: 1.5  },
+  "claude-opus-4-6":   { in: 15,  out: 75,  cached: 1.5  },
+  "claude-sonnet-4-6": { in: 3,   out: 15,  cached: 0.3  },
+  "claude-sonnet-4-5": { in: 3,   out: 15,  cached: 0.3  },
+  "claude-haiku-4-5":  { in: 0.8, out: 4,   cached: 0.08 },
+};
+const ANT_DEFAULT = { in: 3, out: 15, cached: 0.3 };
+const CODEX_PRICE = { in: 1.25, cached: 0.13, out: 10 };
+
+function priceAnt(model, inT, outT, cachedT) {
+  const p = ANT_PRICE[model]
+    ?? Object.entries(ANT_PRICE).find(([id]) => model.startsWith(id))?.[1]
+    ?? ANT_DEFAULT;
+  return (inT * p.in + outT * p.out + cachedT * p.cached) / 1_000_000;
+}
+
+/* ───── File utils ─────────────────────────────────────────────── */
+
+function listJsonl(dir) {
+  try { return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join(dir, f)); }
+  catch { return []; }
+}
+
+function walkJsonl(dir, out = [], depth = 0) {
+  if (depth > 6) return out;
+  let entries;
+  try { entries = readdirSync(dir); } catch { return out; }
+  for (const e of entries) {
+    const p = join(dir, e);
+    let st; try { st = statSync(p); } catch { continue; }
+    if (st.isDirectory()) walkJsonl(p, out, depth + 1);
+    else if (e.endsWith(".jsonl")) out.push(p);
+    if (out.length >= 200) return out;
+  }
+  return out;
+}
+
+/* ───── Parsers ────────────────────────────────────────────────── */
+
+function parseClaudeCode() {
+  const roots = [
+    join(homedir(), ".claude", "projects"),
+    ...(IS_WIN ? [join(APPDATA, "Claude", "projects")] : []),
+  ];
+  const s = {
+    source: "Claude Code", available: false, events: 0,
+    input: 0, cached: 0, output: 0, cost: 0,
+    models: new Map(), byDay: new Map(), files: 0, projects: 0,
+  };
+  const root = roots.find(existsSync);
+  if (!root) return s;
+  let projects;
+  try {
+    projects = readdirSync(root).filter((p) => {
+      try { return statSync(join(root, p)).isDirectory(); } catch { return false; }
+    });
+  } catch { return s; }
+  if (!projects.length) return s;
+  s.available = true;
+  s.projects = projects.length;
+  for (const proj of projects.slice(0, 200)) {
+    for (const file of listJsonl(join(root, proj)).slice(0, 50)) {
+      s.files++;
+      let text; try { text = readFileSync(file, "utf8"); } catch { continue; }
+      for (const line of text.split("\n")) {
+        if (!line.trim()) continue;
+        let obj; try { obj = JSON.parse(line); } catch { continue; }
+        if (obj.type !== "assistant") continue;
+        const usage = obj.message?.usage;
+        const model = obj.message?.model;
+        if (!usage || !model) continue;
+        const inT    = usage.input_tokens ?? 0;
+        const cached = (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+        const out    = usage.output_tokens ?? 0;
+        const cost   = priceAnt(model, inT, out, cached);
+        s.events++; s.input += inT; s.cached += cached; s.output += out; s.cost += cost;
+        const m = s.models.get(model) ?? { events: 0, in: 0, out: 0, cached: 0, cost: 0 };
+        m.events++; m.in += inT; m.out += out; m.cached += cached; m.cost += cost;
+        s.models.set(model, m);
+        const day = (obj.timestamp ?? "").slice(0, 10);
+        if (day) {
+          const b = s.byDay.get(day) ?? { tokens: 0, cost: 0 };
+          b.tokens += inT + cached + out; b.cost += cost;
+          s.byDay.set(day, b);
+        }
+      }
+    }
+  }
+  return s;
+}
+
+function parseCodex() {
+  const ROOT = join(homedir(), ".codex", "sessions");
+  const s = {
+    source: "Codex CLI", available: false, events: 0,
+    input: 0, cached: 0, output: 0, thinking: 0, cost: 0,
+    models: new Map(), byDay: new Map(), files: 0, sessions: 0,
+  };
+  const files = walkJsonl(ROOT);
+  if (!files.length) return s;
+  s.available = true;
+  s.files = files.length;
+  for (const file of files) {
+    let text; try { text = readFileSync(file, "utf8"); } catch { continue; }
+    let model = "codex";
+    let prev  = { in: 0, out: 0, cached: 0, reasoning: 0 };
+    let hadEvent = false;
+    for (const line of text.split("\n")) {
+      if (!line.trim()) continue;
+      let obj; try { obj = JSON.parse(line); } catch { continue; }
+      if (obj.type === "session_meta" && obj.payload?.model) model = obj.payload.model;
+      if (obj.type !== "event_msg" || obj.payload?.type !== "token_count") continue;
+      const t = obj.payload.info?.total_token_usage;
+      if (!t) continue;
+      const inT    = Math.max(0, (t.input_tokens           ?? 0) - prev.in);
+      const outT   = Math.max(0, (t.output_tokens          ?? 0) - prev.out);
+      const cachedT= Math.max(0, (t.cached_input_tokens    ?? 0) - prev.cached);
+      const reasonT= Math.max(0, (t.reasoning_output_tokens?? 0) - prev.reasoning);
+      prev = {
+        in: t.input_tokens ?? prev.in, out: t.output_tokens ?? prev.out,
+        cached: t.cached_input_tokens ?? prev.cached,
+        reasoning: t.reasoning_output_tokens ?? prev.reasoning,
+      };
+      if (!inT && !outT && !cachedT) continue;
+      const cost = (inT * CODEX_PRICE.in + cachedT * CODEX_PRICE.cached + (outT + reasonT) * CODEX_PRICE.out) / 1_000_000;
+      s.events++; s.input += inT; s.cached += cachedT; s.output += outT; s.thinking += reasonT; s.cost += cost;
+      const m = s.models.get(model) ?? { events: 0, cost: 0 };
+      m.events++; m.cost += cost; s.models.set(model, m);
+      const day = (obj.timestamp ?? "").slice(0, 10);
+      if (day) {
+        const b = s.byDay.get(day) ?? { tokens: 0, cost: 0 };
+        b.tokens += inT + cachedT + outT + reasonT; b.cost += cost;
+        s.byDay.set(day, b);
+      }
+      hadEvent = true;
+    }
+    if (hadEvent) s.sessions++;
+  }
+  return s;
+}
+
+function periodWindows(byDay) {
+  const today    = new Date().toISOString().slice(0, 10);
+  const weekAgo  = new Date(Date.now() -  7 * 864e5).toISOString().slice(0, 10);
+  const monthAgo = new Date(Date.now() - 30 * 864e5).toISOString().slice(0, 10);
+  const w = { today: 0, week: 0, month: 0, tToday: 0, tWeek: 0, tMonth: 0 };
+  for (const [d, b] of byDay) {
+    if (d === today) { w.today += b.cost; w.tToday += b.tokens; }
+    if (d >= weekAgo)  { w.week  += b.cost; w.tWeek  += b.tokens; }
+    if (d >= monthAgo) { w.month += b.cost; w.tMonth += b.tokens; }
+  }
+  return w;
+}
+
+/* ───── Detector registry ──────────────────────────────────────── */
+
+const DETECTORS = [
+  {
+    id: "claude-code", name: "Claude Code", parseable: true, parser: parseClaudeCode,
+    roots: [join(homedir(), ".claude", "projects"), ...(IS_WIN ? [join(APPDATA, "Claude", "projects")] : [])],
+    hint: "~/.claude/projects/**/*.jsonl",
+  },
+  {
+    id: "codex-cli", name: "Codex CLI", parseable: true, parser: parseCodex,
+    roots: [join(homedir(), ".codex", "sessions")],
+    hint: "~/.codex/sessions/**/*.jsonl",
+  },
+  {
+    id: "cursor", name: "Cursor", parseable: false, parser: null,
+    roots: pf(
+      [join(LIB, "Cursor", "User", "globalStorage", "state.vscdb")],
+      [join(APPDATA, "Cursor", "User", "globalStorage", "state.vscdb")],
+      [join(homedir(), ".config", "Cursor", "User", "globalStorage", "state.vscdb")]
+    ),
+    hint: "SQLite state.vscdb — no token counts yet (planned v0.2)",
+  },
+  {
+    id: "claude-desktop", name: "Claude Desktop", parseable: false, parser: null,
+    roots: pf(
+      [join(LIB, "Claude")],
+      [join(APPDATA, "Claude")],
+      [join(homedir(), ".config", "Claude")]
+    ),
+    hint: "Electron app — no per-message token events exposed",
+  },
+  {
+    id: "chatgpt-desktop", name: "ChatGPT Desktop", parseable: false, parser: null,
+    roots: pf(
+      [join(LIB, "com.openai.chat")],
+      [join(APPDATA, "OpenAI", "ChatGPT")],
+      []
+    ),
+    hint: "Electron app — conversation data only, no token counts",
+  },
+  {
+    id: "windsurf", name: "Windsurf (Codeium)", parseable: false, parser: null,
+    roots: pf(
+      [join(LIB, "Windsurf")],
+      [join(APPDATA, "Windsurf")],
+      [join(homedir(), ".config", "Windsurf")]
+    ),
+    hint: "App data found — structured token log not exposed yet",
+  },
+  {
+    id: "continue", name: "Continue.dev", parseable: false, parser: null,
+    roots: [join(homedir(), ".continue")],
+    hint: "~/.continue/ — telemetry events not yet in token-count format",
+  },
+  {
+    id: "aider", name: "Aider", parseable: false, parser: null,
+    roots: [join(homedir(), ".aider"), join(process.cwd(), ".aider.chat.history.md")],
+    hint: ".aider.chat.history.md per-repo — cost-line parser planned v0.2",
+  },
+  {
+    id: "cline", name: "Cline", parseable: false, parser: null,
+    roots: [vscodeExt("saoudrizwan.claude-dev")],
+    hint: "VSCode extension — ui_messages.json task parser planned",
+  },
+  {
+    id: "roo-code", name: "Roo Code", parseable: false, parser: null,
+    roots: [vscodeExt("rooveterinaryinc.roo-cline")],
+    hint: "VSCode extension — ui_messages.json task parser planned",
+  },
+  {
+    id: "kilo-code", name: "Kilo Code", parseable: false, parser: null,
+    roots: [vscodeExt("kilocode.kilo-code")],
+    hint: "VSCode extension — ui_messages.json task parser planned",
+  },
+  {
+    id: "zed", name: "Zed AI", parseable: false, parser: null,
+    roots: pf(
+      [join(LIB, "Zed")],
+      [join(APPDATA, "Zed")],
+      [join(homedir(), ".config", "zed")]
+    ),
+    hint: "SQLite threads.db — reader planned",
+  },
+  {
+    id: "gemini-cli", name: "Gemini CLI", parseable: false, parser: null,
+    roots: [join(homedir(), ".gemini"), join(homedir(), ".config", "gemini")],
+    hint: "~/.gemini/tmp/*.json|*.jsonl — parser planned",
+  },
+  {
+    id: "opencode", name: "OpenCode", parseable: false, parser: null,
+    roots: [join(XDG, "opencode"), join(homedir(), ".opencode")],
+    hint: "opencode/storage/message/*.json — parser planned",
+  },
+  {
+    id: "ampcode", name: "Amp", parseable: false, parser: null,
+    roots: [join(XDG, "amp"), join(homedir(), ".amp"), join(homedir(), ".config", "amp")],
+    hint: "amp/threads/T-*.json — parser planned",
+  },
+  {
+    id: "antigravity", name: "Antigravity (Google)", parseable: false, parser: null,
+    roots: pf(
+      [join(LIB, "Antigravity")],
+      [join(APPDATA, "Antigravity")],
+      [join(homedir(), ".config", "antigravity"), join(homedir(), ".config", "tokscale", "antigravity-cache")]
+    ),
+    hint: "Antigravity session cache — format TBD",
+  },
+  {
+    id: "github-copilot", name: "GitHub Copilot", parseable: false, parser: null,
+    roots: [join(homedir(), ".copilot", "otel"), ...(process.env.COPILOT_OTEL_FILE_EXPORTER_PATH ? [process.env.COPILOT_OTEL_FILE_EXPORTER_PATH] : [])],
+    hint: "OTEL trace files — usage extraction planned",
+  },
+  {
+    id: "goose", name: "Goose (Block)", parseable: false, parser: null,
+    roots: [join(XDG, "goose", "sessions")],
+    hint: "SQLite sessions.db — reader planned",
+  },
+  {
+    id: "kiro", name: "Kiro (Amazon)", parseable: false, parser: null,
+    roots: [join(homedir(), ".kiro", "sessions", "cli")],
+    hint: "~/.kiro/sessions/cli/*.json — parser planned",
+  },
+  {
+    id: "mux", name: "Mux", parseable: false, parser: null,
+    roots: [join(homedir(), ".mux", "sessions")],
+    hint: "session-usage.json — parser planned",
+  },
+  {
+    id: "openclaw", name: "OpenClaw", parseable: false, parser: null,
+    roots: [join(homedir(), ".openclaw", "agents")],
+    hint: "*.jsonl agent sessions — parser planned",
+  },
+  {
+    id: "crush", name: "Crush", parseable: false, parser: null,
+    roots: [join(XDG, "crush")],
+    hint: "projects.json — parser planned",
+  },
+  {
+    id: "kimi", name: "Kimi (Moonshot)", parseable: false, parser: null,
+    roots: [join(homedir(), ".kimi", "sessions")],
+    hint: "wire.jsonl sessions — parser planned",
+  },
+  {
+    id: "hermes", name: "Hermes", parseable: false, parser: null,
+    roots: [process.env.HERMES_HOME ? join(process.env.HERMES_HOME) : join(homedir(), ".hermes")],
+    hint: "SQLite state.db — reader planned",
+  },
+];
+
+function runScan() {
+  return DETECTORS.map((det) => {
+    const foundRoot = det.roots.find((r) => r && existsSync(r)) ?? null;
+    if (det.parseable && det.parser) {
+      const stats = det.parser();
+      return { ...det, found: !!foundRoot || stats.available, hasData: stats.available, parsed: true, stats, foundRoot };
+    }
+    return { ...det, found: !!foundRoot, hasData: false, parsed: false, stats: null, foundRoot };
+  });
+}
+
+/* ───── MCP server ─────────────────────────────────────────────── */
+
+function commandMcp() {
+  const TOOLS = [
+    {
+      name: "get_my_stats",
+      description: "Get local AI token usage stats from Claude Code, Codex CLI, and other tools installed on this device. Returns all-time and period spend.",
+      inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+      name: "get_device_scan",
+      description: "Scan this device for all installed AI coding tools (Claude Code, Cursor, Codex, Gemini CLI, etc.) and show which have extractable token data.",
+      inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+      name: "get_flex_card",
+      description: "Get a shareable one-liner showing all-time AI token spend — great for posting on X, HN, or Slack.",
+      inputSchema: { type: "object", properties: {}, required: [] },
+    },
+  ];
+
+  function send(obj) { process.stdout.write(JSON.stringify(obj) + "\n"); }
+
+  function handle(req) {
+    const { method, id, params } = req;
+    if (method === "initialize") {
+      send({ jsonrpc: "2.0", id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "tokenflexing", version: "1.1.0" } } });
+    } else if (method === "notifications/initialized" || method === "ping") {
+      if (id !== undefined) send({ jsonrpc: "2.0", id, result: {} });
+    } else if (method === "tools/list") {
+      send({ jsonrpc: "2.0", id, result: { tools: TOOLS } });
+    } else if (method === "tools/call") {
+      const name = params?.name;
+      let text = "";
+      if (name === "get_my_stats") {
+        const measured = runScan().filter((r) => r.hasData);
+        if (!measured.length) {
+          text = "No AI usage data found on this device. Start using Claude Code or Codex CLI, then run `tokenflexing scan`.";
+        } else {
+          let totalCost = 0, totalTokens = 0;
+          const lines = [];
+          for (const r of measured) {
+            const s = r.stats;
+            const t = s.input + s.cached + s.output + (s.thinking ?? 0);
+            totalCost += s.cost; totalTokens += t;
+            lines.push(`**${s.source}**: ${fmtUsd(s.cost)} · ${fmtC(t)} tokens · ${fmtNum(s.events)} events`);
+          }
+          text = lines.join("\n") + `\n\n**Grand Total**: ${fmtUsd(totalCost)} · ${fmtC(totalTokens)} tokens\n\nFull profile → tokenflexing.com`;
+        }
+      } else if (name === "get_device_scan") {
+        const scan = runScan();
+        const measured = scan.filter((r) => r.hasData);
+        const detected = scan.filter((r) => r.found && !r.hasData);
+        const notFound = scan.filter((r) => !r.found);
+        const parts = [];
+        if (measured.length) { parts.push("**Measured** (token counts extracted):"); for (const r of measured) { const s = r.stats; parts.push(`- ${s.source}: ${fmtUsd(s.cost)} · ${fmtC(s.input + s.cached + s.output)} tokens`); } }
+        if (detected.length) { parts.push("\n**Detected** (installed, token counts not yet accessible):"); for (const r of detected) parts.push(`- ${r.name}`); }
+        if (notFound.length) { parts.push("\n**Not found** on this device:"); for (const r of notFound) parts.push(`- ${r.name}`); }
+        text = parts.join("\n");
+      } else if (name === "get_flex_card") {
+        const sources = runScan().filter((r) => r.hasData);
+        const total  = sources.reduce((a, r) => a + r.stats.cost, 0);
+        const tokens = sources.reduce((a, r) => a + r.stats.input + r.stats.cached + r.stats.output + (r.stats.thinking ?? 0), 0);
+        text = `I burned ${fmtUsdC(total)} on AI this all-time.\n${fmtC(tokens)} tokens · ${sources.map((r) => r.stats.source).join(" + ")}\nhttps://tokenflexing.com`;
+      } else {
+        send({ jsonrpc: "2.0", id, error: { code: -32601, message: `Unknown tool: ${name}` } });
+        return;
+      }
+      send({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text }] } });
+    } else {
+      if (id !== undefined) send({ jsonrpc: "2.0", id, error: { code: -32601, message: "Method not found" } });
+    }
+  }
+
+  let buf = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buf += chunk;
+    const lines = buf.split("\n");
+    buf = lines.pop() ?? "";
+    for (const line of lines) { const t = line.trim(); if (t) try { handle(JSON.parse(t)); } catch {} }
+  });
+  process.stdin.on("end", () => { if (buf.trim()) try { handle(JSON.parse(buf)); } catch {}; });
+  process.stdin.resume();
+}
+
+/* ───── Commands ───────────────────────────────────────────────── */
+
+function commandStats() {
+  const scan     = runScan();
+  const measured = scan.filter((r) => r.hasData);
+
+  console.log("");
+  console.log(`${c.bold}tokenflexing${c.reset}${c.faint} · local AI usage${c.reset}`);
+  console.log("");
+
+  if (!measured.length) {
+    const detected = scan.filter((r) => r.found);
+    if (detected.length) {
+      console.log(`${c.faint}Detected ${detected.map((d) => d.name).join(", ")} — no usage data parsed yet.${c.reset}`);
+      console.log(`${c.faint}Run 'tokenflexing scan' for full device inventory.${c.reset}`);
+    } else {
+      console.log(`${c.faint}No local AI tools detected. Run 'tokenflexing scan' for details.${c.reset}`);
+    }
+    console.log("");
+    return;
+  }
+
+  let totalCost = 0, totalTokens = 0, totalEvents = 0;
+  for (const r of measured) {
+    const s = r.stats;
+    const w = periodWindows(s.byDay);
+    totalCost   += s.cost;
+    totalTokens += s.input + s.cached + s.output + (s.thinking ?? 0);
+    totalEvents += s.events;
+
+    console.log(`${c.green}■${c.reset} ${c.bold}${s.source}${c.reset}`);
+    const detail = s.source === "Claude Code"
+      ? `${fmtNum(s.events)} turns · ${s.files} files · ${s.projects} projects`
+      : `${fmtNum(s.events)} deltas · ${s.sessions} sessions · ${s.files} files`;
+    console.log(`  ${c.faint}${detail}${c.reset}`);
+    console.log("");
+    console.log(`  ${c.faint}TODAY${c.reset}   ${pad(fmtUsd(w.today),  12)}${c.faint}${fmtC(w.tToday)} tokens${c.reset}`);
+    console.log(`  ${c.faint}7-DAY${c.reset}   ${pad(fmtUsd(w.week),   12)}${c.faint}${fmtC(w.tWeek)} tokens${c.reset}`);
+    console.log(`  ${c.faint}30-DAY${c.reset}  ${pad(fmtUsd(w.month),  12)}${c.faint}${fmtC(w.tMonth)} tokens${c.reset}`);
+    console.log(`  ${c.faint}TOTAL${c.reset}   ${c.bold}${pad(fmtUsd(s.cost), 12)}${c.reset}${c.faint}${fmtC(s.input + s.cached + s.output + (s.thinking ?? 0))} tokens${c.reset}`);
+
+    if (s.models.size) {
+      console.log("");
+      console.log(`  ${c.faint}MODELS${c.reset}`);
+      const rows = [...s.models.entries()].sort((a, b) => (b[1].cost ?? 0) - (a[1].cost ?? 0));
+      for (const [model, m] of rows) {
+        console.log(`    ${pad(model, 28)}${c.faint}${pad(fmtNum(m.events) + " turns", 16)}${c.reset}${c.bold}${fmtUsd(m.cost)}${c.reset}`);
+      }
+    }
+    console.log("");
+  }
+
+  console.log(c.flex + " GRAND TOTAL " + c.reset);
+  console.log(`  ${c.bold}${fmtUsd(totalCost)}${c.reset}${c.faint}  ·  ${fmtC(totalTokens)} tokens  ·  ${fmtNum(totalEvents)} events${c.reset}`);
+  const unmeasured = scan.filter((r) => r.found && !r.hasData);
+  if (unmeasured.length) {
+    console.log("");
+    console.log(`  ${c.faint}Also detected (not yet measurable): ${unmeasured.map((r) => r.name).join(", ")}${c.reset}`);
+    console.log(`  ${c.faint}Run 'tokenflexing scan' for full device inventory.${c.reset}`);
+  }
+  console.log("");
+}
+
+function commandFlex() {
+  const sources = runScan().filter((r) => r.hasData);
+  const total  = sources.reduce((a, r) => a + r.stats.cost, 0);
+  const tokens = sources.reduce((a, r) => a + r.stats.input + r.stats.cached + r.stats.output + (r.stats.thinking ?? 0), 0);
+  const big    = fmtUsdC(total);
+  const spark  = sparkline(mergeByDay(sources));
+  const W = 46; // inner width
+
+  function row(inner) {
+    const raw = inner.replace(/\x1b\[[0-9;]*m/g, "");
+    const pad2 = " ".repeat(Math.max(0, W - raw.length));
+    return `  ║ ${inner}${pad2} ║`;
+  }
+  const bar = "═".repeat(W + 2);
+
+  console.log("");
+  console.log(`  ╔${bar}╗`);
+  console.log(row(""));
+  console.log(row(`${c.green}◈ tokenflexing${c.reset}                   ${c.faint}tokenflexing.com${c.reset}`));
+  console.log(row(""));
+  console.log(row(`${c.bold}I burned ${c.green}${big}${c.reset}${c.bold} on AI.${c.reset}`));
+  console.log(row(`${c.faint}all-time · ${fmtC(tokens)} tokens${c.reset}`));
+  console.log(row(""));
+  if (sources.length) {
+    for (const r of sources) {
+      const s = r.stats;
+      const t = s.input + s.cached + s.output + (s.thinking ?? 0);
+      console.log(row(`  ${c.faint}${pad(s.source, 18)}${c.reset}${pad(fmtUsd(s.cost), 12)}${c.faint}${fmtC(t)} tokens${c.reset}`));
+    }
+    console.log(row(""));
+  }
+  console.log(row(`${c.faint}14d ${c.reset}${c.green}${spark}${c.reset}`));
+  console.log(row(""));
+  console.log(`  ╚${bar}╝`);
+  console.log("");
+  console.log(`  ${c.faint}Drop this anywhere — it auto-updates daily via tokenflexing daemon.${c.reset}`);
+  console.log("");
+}
+
+function commandScan() {
+  const scan     = runScan();
+  const measured = scan.filter((r) => r.hasData);
+  const detected = scan.filter((r) => r.found && !r.hasData);
+  const notFound = scan.filter((r) => !r.found);
+
+  const summary = [
+    measured.length ? `${c.green}${measured.length} measured${c.reset}` : null,
+    detected.length ? `${c.yellow}${detected.length} detected${c.reset}` : null,
+    notFound.length ? `${c.faint}${notFound.length} not found${c.reset}` : null,
+  ].filter(Boolean).join("  ·  ");
+
+  console.log("");
+  console.log(`${c.bold}tokenflexing scan${c.reset}  ${summary}`);
+  console.log("");
+
+  if (measured.length) {
+    console.log(`${c.green}${c.bold}MEASURED${c.reset}  ${c.faint}token counts extracted${c.reset}`);
+    console.log("─".repeat(56));
+    for (const r of measured) {
+      const s = r.stats;
+      const total = s.input + s.cached + s.output + (s.thinking ?? 0);
+      const spark  = sparkline(s.byDay ?? new Map(), 14);
+      console.log(
+        `  ${c.green}●${c.reset} ${pad(s.source, 18)}` +
+        `${c.bold}${pad(fmtUsd(s.cost), 11)}${c.reset}` +
+        `${c.faint}${fmtC(total)} tokens${c.reset}  ${c.green}${spark}${c.reset}`
+      );
+      console.log(`    ${c.faint}${r.hint}${c.reset}`);
+    }
+    console.log("");
+  }
+
+  if (detected.length) {
+    console.log(`${c.yellow}${c.bold}DETECTED${c.reset}  ${c.faint}installed, token counts not yet accessible${c.reset}`);
+    console.log("─".repeat(56));
+    for (const r of detected) {
+      const shortRoot = (r.foundRoot ?? "").replace(homedir(), "~");
+      console.log(`  ${c.yellow}◎${c.reset} ${pad(r.name, 22)}${c.faint}${shortRoot}${c.reset}`);
+      console.log(`    ${c.faint}${r.hint}${c.reset}`);
+    }
+    console.log("");
+  }
+
+  if (notFound.length) {
+    console.log(`${c.faint}NOT FOUND  —  ${notFound.map((r) => r.name).join(" · ")}${c.reset}`);
+    console.log("");
+  }
+
+  console.log(`${c.faint}Run 'tokenflexing stats' for full breakdown  ·  'tokenflexing daemon --install' for daily refresh${c.reset}`);
+  console.log("");
+}
+
+function commandDaemon(args) {
+  const doInstall   = args.includes("--install");
+  const doUninstall = args.includes("--uninstall");
+  const LABEL     = "com.tokenflexing.sync";
+  const PLIST     = join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+  const WIN_TASK  = "Tokenflexing Sync";
+  // Use npx so the daemon works for any user regardless of where the package is installed.
+  // npx lives in the same directory as node on all platforms.
+  const npxPath   = join(dirname(process.execPath), IS_WIN ? "npx.cmd" : "npx");
+
+  const plistContent = [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
+    `<plist version="1.0"><dict>`,
+    `  <key>Label</key><string>${LABEL}</string>`,
+    `  <key>ProgramArguments</key><array>`,
+    `    <string>${npxPath}</string>`,
+    `    <string>-y</string>`,
+    `    <string>tokenflexing@latest</string>`,
+    `    <string>scan</string>`,
+    `  </array>`,
+    `  <key>StartCalendarInterval</key><dict>`,
+    `    <key>Hour</key><integer>6</integer>`,
+    `    <key>Minute</key><integer>0</integer>`,
+    `  </dict>`,
+    `  <key>StandardOutPath</key><string>/tmp/tokenflexing-sync.log</string>`,
+    `  <key>StandardErrorPath</key><string>/tmp/tokenflexing-sync.err</string>`,
+    `  <key>RunAtLoad</key><false/>`,
+    `</dict></plist>`,
+  ].join("\n");
+
+  console.log("");
+  console.log(`${c.bold}tokenflexing daemon${c.reset}${c.faint} · daily auto-refresh at 6:00 AM${c.reset}`);
+  console.log("");
+
+  if (IS_WIN) {
+    const trArg = `"${npxPath}" -y tokenflexing@latest scan`;
+    console.log(`Platform: ${c.bold}Windows Task Scheduler${c.reset}`);
+    console.log("");
+    if (doInstall) {
+      try {
+        execFileSync("schtasks", ["/create", "/tn", WIN_TASK, "/tr", trArg, "/sc", "DAILY", "/st", "06:00", "/f"], { stdio: "inherit" });
+        console.log(`${c.green}✓${c.reset} Task created: "${WIN_TASK}"`);
+        console.log(`${c.faint}Remove: schtasks /delete /tn "${WIN_TASK}" /f${c.reset}`);
+      } catch {
+        console.error("Failed. Try running as Administrator.");
+        process.exit(1);
+      }
+    } else {
+      console.log(`${c.faint}Pass --install to create the Task Scheduler entry.${c.reset}`);
+      console.log(`${c.faint}Command: schtasks /create /tn "${WIN_TASK}" /tr "${trArg}" /sc DAILY /st 06:00 /f${c.reset}`);
+    }
+  } else {
+    const uid = String(userInfo().uid);
+    console.log(`Platform: ${c.bold}macOS LaunchAgent${c.reset}`);
+    console.log(`Target:   ${c.faint}${PLIST}${c.reset}`);
+    console.log("");
+    if (doUninstall) {
+      try {
+        if (existsSync(PLIST)) {
+          try { execFileSync("launchctl", ["bootout", `gui/${uid}`, PLIST], { stdio: "ignore" }); } catch {}
+          unlinkSync(PLIST);
+        }
+        console.log(`${c.green}✓${c.reset} Daemon removed.`);
+      } catch (err) {
+        console.error("Failed to uninstall:", err.message);
+        process.exit(1);
+      }
+    } else if (doInstall) {
+      try {
+        const dir = join(homedir(), "Library", "LaunchAgents");
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+        writeFileSync(PLIST, plistContent, "utf8");
+        execFileSync("launchctl", ["bootstrap", `gui/${uid}`, PLIST], { stdio: "ignore" });
+        console.log(`${c.green}✓${c.reset} Daemon installed. Runs daily at 6:00 AM.`);
+        console.log(`  Log:    ${c.faint}/tmp/tokenflexing-sync.log${c.reset}`);
+        console.log(`  Remove: ${c.faint}tokenflexing daemon --uninstall${c.reset}`);
+      } catch (err) {
+        console.error("Failed to install daemon:", err.message);
+        process.exit(1);
+      }
+    } else {
+      console.log(`${c.faint}Plist preview:${c.reset}`);
+      console.log(plistContent.split("\n").map((l) => `  ${c.faint}${l}${c.reset}`).join("\n"));
+      console.log("");
+      console.log(`Pass ${c.bold}--install${c.reset} to write and load.  Pass ${c.bold}--uninstall${c.reset} to remove.`);
+    }
+  }
+  console.log("");
+  console.log(`${c.faint}Cloud sync (tokenflexing login) is live. Run it to push stats to your profile.${c.reset}`);
+  console.log(`${c.faint}the daemon pushes stats to tokenflexing.com automatically.${c.reset}`);
+  console.log("");
+}
+
+function commandInstallHooks(args) {
+  const client     = arg(args, "--client") ?? "claude-code";
+  const apply      = args.includes("--apply");
+  const forProject = args.includes("--project");
+
+  const MCP_ENTRY = { command: "npx", args: ["-y", "tokenflexing@latest", "mcp"], type: "stdio" };
+
+  const CONFIGS = {
+    "claude-code": {
+      path: forProject ? join(process.cwd(), ".claude", "settings.json") : join(homedir(), ".claude", "settings.json"),
+      key: "mcpServers",
+    },
+    cursor: {
+      path: forProject ? join(process.cwd(), ".cursor", "mcp.json") : join(homedir(), ".cursor", "mcp.json"),
+      key: "mcpServers",
+    },
+  };
+
+  const cfg = CONFIGS[client];
+  if (!cfg) {
+    console.log(`${c.faint}Supported: --client claude-code  --client cursor${c.reset}`);
+    return;
+  }
+
+  console.log("");
+  console.log(`${c.bold}tokenflexing install-hooks${c.reset} · ${client}`);
+  console.log("");
+  console.log(`  Registers tokenflexing as an MCP server — your agent gets three new tools:`);
+  console.log(`    · ${c.green}get_my_stats${c.reset}      "What's my token spend this week?"`);
+  console.log(`    · ${c.green}get_device_scan${c.reset}   "Which AI tools do I have installed?"`);
+  console.log(`    · ${c.green}get_flex_card${c.reset}     "Show me my share card."`);
+  console.log("");
+  console.log(`  Target: ${c.dim}${cfg.path}${c.reset}`);
+  console.log(`  Status: ${c.dim}${existsSync(cfg.path) ? "exists — will merge" : "will be created"}${c.reset}`);
+  console.log("");
+
+  if (!apply) {
+    console.log(`${c.bold}DRY RUN${c.reset} · Pass ${c.green}--apply${c.reset} to write.`);
+    console.log(`${c.faint}Adds: { "${cfg.key}": { "tokenflexing": ${JSON.stringify(MCP_ENTRY)} } }${c.reset}`);
+    console.log("");
+    return;
+  }
+
+  let existing = {};
+  if (existsSync(cfg.path)) try { existing = JSON.parse(readFileSync(cfg.path, "utf8")); } catch {}
+  const updated = { ...existing, [cfg.key]: { ...(existing[cfg.key] ?? {}), tokenflexing: MCP_ENTRY } };
+  const dir = dirname(cfg.path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(cfg.path, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(`${c.green}✓${c.reset} tokenflexing MCP server added to ${client}.`);
+  console.log(`  Restart ${client}, then ask: "What's my token usage?" or "Show me my flex card."`);
+  console.log("");
+}
+
+async function commandLogin(args) {
+  // Support: tokenflexing login --token <raw>  (paste token from Settings page)
+  const manualToken = args && args[args.indexOf("--token") + 1];
+  if (manualToken && manualToken.startsWith("tf_live_")) {
+    saveToken(manualToken);
+    console.log("");
+    console.log(`${c.green}✓${c.reset} Token saved. Run ${c.green}tokenflexing sync${c.reset} to push your stats.`);
+    console.log("");
+    return;
+  }
+
+  // Device-code flow: POST → open browser → poll → save token
+  console.log("");
+  console.log(`${c.bold}tokenflexing login${c.reset}`);
+  console.log("");
+
+  let deviceRes;
+  try {
+    const r = await fetch(`${SITE}/api/cli/device`, { method: "POST" });
+    deviceRes = await r.json();
+  } catch {
+    console.error(`${c.faint}Could not reach ${SITE}. Check your connection.${c.reset}`);
+    process.exit(1);
+  }
+
+  if (deviceRes.error) {
+    console.error(`Error: ${deviceRes.error}`);
+    process.exit(1);
+  }
+
+  const { code, url } = deviceRes;
+  console.log(`Open this URL in your browser to authorize:`);
+  console.log("");
+  console.log(`  ${c.green}${url}${c.reset}`);
+  console.log("");
+  console.log(`Code: ${c.bold}${code}${c.reset}   (expires in 5 min)`);
+  console.log("");
+
+  // Try to open the browser automatically
+  try {
+    if (IS_MAC) execFileSync("open", [url]);
+    else if (IS_WIN) execFileSync("cmd", ["/c", "start", url]);
+    else execFileSync("xdg-open", [url]);
+  } catch { /* silently ignore — user can open manually */ }
+
+  // Poll every 2 seconds until authorized or expired
+  process.stdout.write("Waiting for authorization");
+  let rawToken = null;
+
+  for (let i = 0; i < 150; i++) {    // up to 5 min
+    await new Promise((r) => setTimeout(r, 2000));
+    process.stdout.write(".");
+
+    let pollRes;
+    try {
+      const r = await fetch(`${SITE}/api/cli/device?code=${code}`);
+      pollRes = await r.json();
+    } catch { continue; }
+
+    if (pollRes.status === "authorized") {
+      rawToken = pollRes.token;
+      break;
+    }
+    if (pollRes.status === "expired") {
+      process.stdout.write("\n");
+      console.log(`\n${c.faint}Code expired. Re-run tokenflexing login.${c.reset}`);
+      process.exit(1);
+    }
+  }
+
+  process.stdout.write("\n");
+
+  if (!rawToken) {
+    console.log(`${c.faint}Timed out. Re-run tokenflexing login.${c.reset}`);
+    process.exit(1);
+  }
+
+  saveToken(rawToken);
+  console.log("");
+  console.log(`${c.green}✓ Authorized!${c.reset} Token saved to ${tokenPath()}`);
+  console.log(`Run ${c.green}tokenflexing sync${c.reset} to push your stats now.`);
+  console.log("");
+}
+
+async function commandSync() {
+  const token = loadToken();
+  if (!token) {
+    console.log("");
+    console.log(`${c.faint}No token found. Run ${c.green}tokenflexing login${c.faint} first.${c.reset}`);
+    console.log("");
+    return;
+  }
+
+  console.log("");
+  console.log(`${c.bold}tokenflexing sync${c.reset}`);
+  console.log("");
+
+  // Collect parsed source data
+  const sources = collectSources();
+  if (!sources.length) {
+    console.log(`${c.faint}Nothing to sync — no parseable sources found.${c.reset}`);
+    console.log("");
+    return;
+  }
+
+  const scans = sources.map((s) => ({
+    source:  s.id,
+    events:  s.stats.events,
+    input:   s.stats.input,
+    output:  s.stats.output,
+    cached:  s.stats.cached,
+    cost:    s.stats.cost,
+    models:  Object.fromEntries(s.stats.models),
+  }));
+
+  let res;
+  try {
+    const r = await fetch(`${SITE}/api/sync/device`, {
+      method:  "POST",
+      headers: {
+        "Content-Type":  "application/json",
+        "Authorization": `Bearer ${token}`,
+      },
+      body: JSON.stringify({ scans }),
+    });
+    res = await r.json();
+    if (!r.ok) throw new Error(res.error ?? `HTTP ${r.status}`);
+  } catch (err) {
+    console.error(`Sync failed: ${err.message}`);
+    console.log(`${c.faint}Token may be expired. Re-run ${c.green}tokenflexing login${c.faint}.${c.reset}`);
+    process.exit(1);
+  }
+
+  console.log(`${c.green}✓ Synced ${res.synced} source(s)${c.reset} at ${res.timestamp}`);
+  console.log(`${c.faint}View your profile at ${SITE}${c.reset}`);
+  console.log("");
+}
+
+/** Return all sources that were successfully parsed and have data (for sync). */
+function collectSources() {
+  return runScan()
+    .filter((r) => r.hasData)
+    .map((r) => ({ id: r.id, name: r.name, stats: r.stats }));
+}
+
+function commandVersion() { console.log("1.1.0"); }
+
+function commandHelp() {
+  console.log("");
+  console.log(`${c.bold}tokenflexing${c.reset}${c.faint} — show off your AI token usage${c.reset}`);
+  console.log("");
+  console.log(`  ${c.green}tokenflexing${c.reset}                    show stats (default)`);
+  console.log(`  ${c.green}tokenflexing stats${c.reset}              breakdown per source + model`);
+  console.log(`  ${c.green}tokenflexing scan${c.reset}               detect ALL AI tools on this device`);
+  console.log(`  ${c.green}tokenflexing flex${c.reset}               print a shareable ASCII card`);
+  console.log(`  ${c.green}tokenflexing daemon${c.reset}             preview daily auto-refresh daemon`);
+  console.log(`  ${c.green}tokenflexing daemon --install${c.reset}   install macOS LaunchAgent / Windows task`);
+  console.log(`  ${c.green}tokenflexing daemon --uninstall${c.reset} remove daemon`);
+  console.log(`  ${c.green}tokenflexing mcp${c.reset}                start MCP server (Claude Code, Cursor, etc.)`);
+  console.log(`  ${c.green}tokenflexing install-hooks --apply${c.reset} wire MCP into Claude Code or Cursor`);
+  console.log(`  ${c.green}tokenflexing login${c.reset}              sign in and save a cloud sync token`);
+  console.log(`  ${c.green}tokenflexing login --token <tok>${c.reset}  save a token from tokenflexing.com/settings`);
+  console.log(`  ${c.green}tokenflexing sync${c.reset}               push local stats to your profile`);
+  console.log(`  ${c.green}tokenflexing --version${c.reset}          show version`);
+  console.log("");
+  console.log(`  ${c.faint}Parsed today:  Claude Code · Codex CLI${c.reset}`);
+  console.log(`  ${c.faint}Detected (25+ tools): Cursor · Windsurf · Cline · Roo Code · Kilo Code${c.reset}`);
+  console.log(`  ${c.faint}                      Zed · Gemini CLI · Amp · OpenCode · Antigravity${c.reset}`);
+  console.log(`  ${c.faint}                      Copilot · Goose · Kiro · Mux · Kimi · Crush · more${c.reset}`);
+  console.log(`  ${c.faint}Never reads prompts or completions — only usage blocks.${c.reset}`);
+  console.log("");
+}
+
+function arg(args, name) {
+  const i = args.indexOf(name);
+  return i === -1 ? undefined : args[i + 1];
+}
+
+/* ───── Entry ──────────────────────────────────────────────────── */
+
+export async function main(argv) {
+  const cmd = argv[0] ?? "stats";
+  switch (cmd) {
+    case "stats":
+    case undefined:       return commandStats();
+    case "scan":          return commandScan();
+    case "flex":          return commandFlex();
+    case "daemon":        return commandDaemon(argv.slice(1));
+    case "mcp":           return commandMcp();
+    case "install-hooks": return commandInstallHooks(argv.slice(1));
+    case "login":         return commandLogin(argv.slice(1));
+    case "sync":          return commandSync();
+    case "--version":
+    case "-V":            return commandVersion();
+    case "--help":
+    case "-h":
+    case "help":          return commandHelp();
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      console.error("Run 'tokenflexing --help' for usage.");
+      process.exit(1);
+  }
+}