whoburnedmore 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,106 @@
+# whoburnedmore
+
+**who burned more tokens — you or them?** One command reads your local AI coding-agent usage logs, shows your burn, and gives you a **shareable dashboard with no sign-in required**.
+
+[![npm version](https://img.shields.io/npm/v/whoburnedmore.svg?color=f97316)](https://www.npmjs.com/package/whoburnedmore)
+[![npm downloads](https://img.shields.io/npm/dm/whoburnedmore.svg?color=f97316)](https://www.npmjs.com/package/whoburnedmore)
+[![license](https://img.shields.io/npm/l/whoburnedmore.svg?color=f97316)](https://www.npmjs.com/package/whoburnedmore)
+[![node](https://img.shields.io/node/v/whoburnedmore.svg?color=3c873a)](https://nodejs.org)
+
+```bash
+npx whoburnedmore
+```
+
+That's the whole thing. No install, no account, no config.
+
+---
+
+## What you'll see
+
+```text
+whoburnedmore · https://whoburnedmore.com
+
+  🔥 your burn report
+
+  claude         2.26B tokens   $2,640.07    19 days
+  codex          58.2M tokens      $16.85     5 days
+  ──────────────────────────────────────────────
+  total          2.31B tokens   $2,656.91
+  today          92.8M tokens
+
+  You burned 2.31B tokens. Your shareable dashboard:
+  https://whoburnedmore.com/d/5twjwi-jtga4r
+
+  Re-run anytime to update it · `npx whoburnedmore login` to claim a public handle and compete.
+```
+
+Your dashboard is **anonymous and unlisted by default** — only people you send the link to can see it. Run the command again anytime to refresh it.
+
+## Privacy first
+
+Only **daily aggregate numbers** ever leave your machine — date, tool, model, token counts, and estimated cost. **Never your prompts, your code, or your file names.**
+
+See exactly what would be sent, and send nothing:
+
+```bash
+npx whoburnedmore --dry-run
+```
+
+Or stay completely offline — `--local` builds the same dashboard as a self-contained HTML file on your machine and opens it in your browser, sending nothing anywhere:
+
+```bash
+npx whoburnedmore --local
+```
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `npx whoburnedmore` | Show your burn + get a shareable dashboard (no sign-in) |
+| `npx whoburnedmore --local` | Build the dashboard locally and open it (fully offline) |
+| `npx whoburnedmore --dry-run` | Print exactly what would be sent, send nothing |
+| `npx whoburnedmore --no-submit` | Print local stats only, send nothing |
+| `npx whoburnedmore login` | Sign in to claim a public handle + join the leaderboard |
+| `npx whoburnedmore logout` | Forget the local token (your data is untouched) |
+| `npx whoburnedmore install-sync` | Keep your dashboard live with a background sync (every 3h) |
+| `npx whoburnedmore uninstall-sync` | Remove the background sync |
+
+## Supported tools
+
+Usage is read via [`ccusage`](https://www.npmjs.com/package/ccusage) from any of these agents you use locally:
+
+`claude` · `codex` · `gemini` · `copilot` · `opencode` · `amp` · `droid` · `goose` · `kimi` · `qwen` · `kilo` · `openclaw` · `hermes` · `pi` · `codebuff`
+
+Whatever you have logs for is picked up automatically — you don't pass any flags.
+
+## Claim a public handle (optional)
+
+Want on the public leaderboard? Sign in with **GitHub or Google**:
+
+```bash
+npx whoburnedmore login
+```
+
+It uses a device flow — a code appears in your terminal, you approve it in the browser, and you're done. Your submissions then link to your handle at `whoburnedmore.com/u/<handle>`. You can delete your account and every row of data anytime from your profile.
+
+## Keep it live
+
+Want your dashboard to stay fresh without re-running by hand?
+
+```bash
+npx whoburnedmore install-sync     # background sync every 3h (launchd / cron / scheduled task)
+npx whoburnedmore uninstall-sync   # remove it
+```
+
+## Links
+
+- 🏆 Leaderboard — **[whoburnedmore.com](https://whoburnedmore.com)**
+- 📊 Your dashboard — printed in the terminal after your first run
+
+## Requirements
+
+Node.js >= 20.
+
+## License
+
+MIT © Arham Wani

package/dist/index.js

@@ -8,12 +8,23 @@ var __export = (target, all) => {
 // src/index.ts
 import { spawn } from "node:child_process";
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { platform as platform2 } from "node:os";
-import { join as join4 } from "node:path";
+import { createRequire as createRequire4 } from "node:module";
+import { platform as platform3 } from "node:os";
+import { join as join6 } from "node:path";
 import { createInterface } from "node:readline/promises";
 import pc2 from "picocolors";
 
+// src/args.ts
+function parseBoard(args) {
+  const eq = args.find((a) => a.startsWith("--board="));
+  if (eq) return eq.slice("--board=".length).trim() || void 0;
+  const i = args.indexOf("--board");
+  if (i !== -1 && args[i + 1] && !args[i + 1].startsWith("-")) {
+    return args[i + 1].trim() || void 0;
+  }
+  return void 0;
+}
+
 // src/api.ts
 function apiBase() {
   return process.env.WHOBURNEDMORE_API ?? "https://api.whoburnedmore.com";
@@ -67,6 +78,29 @@ async function anonSubmit(anonKey, payload) {
   }
   return body;
 }
+function claimUrl(dashboardUrl, anonKey) {
+  return `${dashboardUrl}#k=${encodeURIComponent(anonKey)}`;
+}
+async function anonVisibility(anonKey, listed) {
+  const { status, body } = await post(
+    "/v1/anon/visibility",
+    { anonKey, listed }
+  );
+  if (status !== 200) {
+    throw new Error(body.error ?? `failed (HTTP ${status})`);
+  }
+}
+async function anonRemove(anonKey) {
+  const res = await fetch(`${apiBase()}/v1/anon`, {
+    method: "DELETE",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ anonKey })
+  });
+  if (res.status !== 200) {
+    const b = await res.json().catch(() => ({}));
+    throw new Error(b.error ?? `failed (HTTP ${res.status})`);
+  }
+}
 
 // src/autosync.ts
 import { spawnSync } from "node:child_process";
@@ -232,9 +266,259 @@ function autoSyncInstalled() {
 }
 
 // src/collect.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname2, join as join5 } from "node:path";
+
+// src/cursor.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { homedir as homedir3, platform as platform2 } from "node:os";
+import { join as join4 } from "node:path";
+
+// src/tokscale.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createRequire } from "node:module";
 import { dirname, join as join3 } from "node:path";
+var LOOKBACK_DAYS = 30;
+function num(n) {
+  const v = Math.round(Number(n));
+  return Number.isFinite(v) && v > 0 ? v : 0;
+}
+function numCost(n) {
+  const v = Number(n);
+  return Number.isFinite(v) && v > 0 ? v : 0;
+}
+function mapTokscaleDay(date, json) {
+  const entries = json?.entries;
+  if (!Array.isArray(entries)) return [];
+  const out = [];
+  for (const e of entries) {
+    const inputTokens = num(e.input);
+    const outputTokens = num(e.output) + num(e.reasoning);
+    const cacheCreationTokens = num(e.cacheWrite);
+    const cacheReadTokens = num(e.cacheRead);
+    const costUSD = numCost(e.cost);
+    const total = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+    if (total === 0 && costUSD === 0) continue;
+    out.push({
+      date,
+      tool: "cursor",
+      model: typeof e.model === "string" && e.model ? e.model : "cursor",
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens,
+      cacheReadTokens,
+      costUSD,
+      origin: "cli",
+      verified: false
+    });
+  }
+  return out;
+}
+function resolveTokscaleBin() {
+  try {
+    const require3 = createRequire(import.meta.url);
+    const pkgPath = require3.resolve("tokscale/package.json");
+    const pkg = require3("tokscale/package.json");
+    const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.tokscale ?? "";
+    if (!rel) return null;
+    const binPath = join3(dirname(pkgPath), rel);
+    if (/\.(c|m)?js$/.test(binPath)) {
+      return { cmd: process.execPath, prefixArgs: [binPath] };
+    }
+    return { cmd: binPath, prefixArgs: [] };
+  } catch {
+    return null;
+  }
+}
+function runTokscaleDay(bin, day) {
+  const res = spawnSync2(
+    bin.cmd,
+    [
+      ...bin.prefixArgs,
+      "--client",
+      "cursor",
+      "--json",
+      "--since",
+      day,
+      "--until",
+      day,
+      "--group-by",
+      "model",
+      "--no-spinner"
+    ],
+    { encoding: "utf8", maxBuffer: 32 * 1024 * 1024, timeout: 6e4 }
+  );
+  if (res.status !== 0 || !res.stdout) return null;
+  try {
+    return JSON.parse(res.stdout);
+  } catch {
+    return null;
+  }
+}
+function collectCursorViaTokscale(lookbackDays = LOOKBACK_DAYS) {
+  const bin = resolveTokscaleBin();
+  if (!bin) return [];
+  const today = /* @__PURE__ */ new Date();
+  const day = (offset) => new Date(today.getTime() - offset * 864e5).toISOString().slice(0, 10);
+  if (mapTokscaleDay(day(0), runTokscaleDay(bin, day(0))).length === 0) {
+    if (mapTokscaleDay(day(1), runTokscaleDay(bin, day(1))).length === 0) {
+      return [];
+    }
+  }
+  const out = [];
+  for (let i = 0; i < lookbackDays; i++) {
+    const d = day(i);
+    out.push(...mapTokscaleDay(d, runTokscaleDay(bin, d)));
+  }
+  return out;
+}
+
+// src/cursor.ts
+var EVENTS_URL = "https://cursor.com/api/dashboard/get-filtered-usage-events";
+function cursorDbPath() {
+  const home = homedir3();
+  const os = platform2();
+  const p = os === "darwin" ? join4(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb") : os === "win32" ? join4(process.env.APPDATA ?? join4(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage", "state.vscdb") : join4(process.env.XDG_CONFIG_HOME ?? join4(home, ".config"), "Cursor", "User", "globalStorage", "state.vscdb");
+  return existsSync3(p) ? p : null;
+}
+function readCursorToken(db) {
+  const require3 = createRequire2(import.meta.url);
+  try {
+    const { DatabaseSync } = require3("node:sqlite");
+    const d = new DatabaseSync(db, { readOnly: true });
+    const row = d.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/accessToken");
+    d.close();
+    if (row?.value) return String(row.value);
+  } catch {
+  }
+  try {
+    const res = spawnSync3(
+      "sqlite3",
+      [db, "SELECT value FROM ItemTable WHERE key='cursorAuth/accessToken';"],
+      { encoding: "utf8", timeout: 1e4 }
+    );
+    const out = res.stdout?.trim();
+    if (res.status === 0 && out) return out;
+  } catch {
+  }
+  return null;
+}
+function cursorCookie(token) {
+  try {
+    const part = token.split(".")[1];
+    if (!part) return null;
+    const json = JSON.parse(
+      Buffer.from(part, "base64url").toString("utf8")
+    );
+    if (!json.sub) return null;
+    return `WorkosCursorSessionToken=${json.sub}%3A%3A${token}`;
+  } catch {
+    return null;
+  }
+}
+function num2(n) {
+  const v = Math.round(Number(n));
+  return Number.isFinite(v) && v > 0 ? v : 0;
+}
+function mapCursorEvents(events) {
+  const byDay = /* @__PURE__ */ new Map();
+  const byHour = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const tu = e.tokenUsage;
+    const ms = Number(e.timestamp);
+    if (!tu || !Number.isFinite(ms)) continue;
+    const d = new Date(ms);
+    const date = d.toISOString().slice(0, 10);
+    const model = e.model || "cursor";
+    const input = num2(tu.inputTokens);
+    const output = num2(tu.outputTokens);
+    const cacheWrite = num2(tu.cacheWriteTokens);
+    const cacheRead = num2(tu.cacheReadTokens);
+    const cost = Math.max(0, (Number(tu.totalCents) || 0) / 100);
+    const total = input + output + cacheWrite + cacheRead;
+    if (total === 0 && cost === 0) continue;
+    const key = `${date}|${model}`;
+    const day = byDay.get(key) ?? {
+      date,
+      tool: "cursor",
+      model,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0,
+      costUSD: 0,
+      origin: "cli",
+      verified: false
+    };
+    day.inputTokens += input;
+    day.outputTokens += output;
+    day.cacheCreationTokens += cacheWrite;
+    day.cacheReadTokens += cacheRead;
+    day.costUSD += cost;
+    byDay.set(key, day);
+    const hour = new Date(
+      Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours())
+    ).toISOString();
+    const blk = byHour.get(hour) ?? { startTime: hour, totalTokens: 0, costUSD: 0 };
+    blk.totalTokens += total;
+    blk.costUSD += cost;
+    byHour.set(hour, blk);
+  }
+  const entries = [...byDay.values()].map((e) => ({
+    ...e,
+    costUSD: Number(e.costUSD.toFixed(4))
+  }));
+  const blocks = [...byHour.values()].map((b) => ({
+    ...b,
+    costUSD: Number(b.costUSD.toFixed(4))
+  }));
+  return { entries, blocks };
+}
+async function fetchCursorEvents(cookie, maxPages = 30, pageSize = 500) {
+  const all = [];
+  for (let page = 1; page <= maxPages; page++) {
+    const res = await fetch(EVENTS_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Origin: "https://cursor.com",
+        Cookie: cookie
+      },
+      body: JSON.stringify({ page, pageSize }),
+      signal: AbortSignal.timeout(2e4)
+    });
+    if (!res.ok) break;
+    const body = await res.json();
+    const batch = body.usageEventsDisplay ?? [];
+    all.push(...batch);
+    if (batch.length < pageSize) break;
+  }
+  return all;
+}
+async function collectCursor() {
+  try {
+    const db = cursorDbPath();
+    const token = db ? readCursorToken(db) : null;
+    const cookie = token ? cursorCookie(token) : null;
+    if (cookie) {
+      const events = await fetchCursorEvents(cookie);
+      const { entries, blocks } = mapCursorEvents(events);
+      if (entries.length > 0) return { entries, blocks, found: true };
+    }
+  } catch {
+  }
+  try {
+    const entries = collectCursorViaTokscale();
+    if (entries.length > 0) return { entries, blocks: [], found: true };
+  } catch {
+  }
+  return { entries: [], blocks: [], found: false };
+}
+
+// src/collect.ts
 var SOURCES = [
   "claude",
   "codex",
@@ -315,43 +599,110 @@ function mapCcusageDaily(tool, json) {
     for (const c of candidates) {
       const tokens = c.inputTokens + c.outputTokens + c.cacheCreationTokens + c.cacheReadTokens;
       if (tokens === 0 && c.costUSD === 0) continue;
-      entries.push({ date, tool, ...c });
+      entries.push({ date, tool, ...c, origin: "cli", verified: false });
     }
   }
   return entries;
 }
+function mapCcusageSessions(json) {
+  const sessions = json?.session;
+  if (!Array.isArray(sessions)) return [];
+  const out = [];
+  for (const raw of sessions) {
+    const s = raw;
+    const sessionId = typeof s.period === "string" ? s.period : typeof s.sessionId === "string" ? s.sessionId : null;
+    if (!sessionId) continue;
+    const inputTokens = norm(s.inputTokens);
+    const outputTokens = norm(s.outputTokens);
+    const cacheCreationTokens = norm(s.cacheCreationTokens);
+    const cacheReadTokens = norm(s.cacheReadTokens);
+    if (inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens === 0)
+      continue;
+    const models = Array.isArray(s.modelsUsed) ? s.modelsUsed.filter((m) => typeof m === "string") : [];
+    const meta = s.metadata ?? {};
+    out.push({
+      sessionId: sessionId.slice(0, 128),
+      tool: typeof s.agent === "string" ? s.agent : "unknown",
+      model: models[0] ?? "unknown",
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens,
+      cacheReadTokens,
+      costUSD: normCost(s.totalCost ?? s.costUSD),
+      lastActivity: typeof meta.lastActivity === "string" ? meta.lastActivity : (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return out;
+}
+function mapCcusageBlocks(json) {
+  const blocks = json?.blocks;
+  if (!Array.isArray(blocks)) return [];
+  const out = [];
+  for (const raw of blocks) {
+    const b = raw;
+    if (b.isGap === true) continue;
+    if (typeof b.startTime !== "string") continue;
+    const totalTokens = norm(b.totalTokens);
+    const costUSD = normCost(b.costUSD);
+    if (totalTokens === 0 && costUSD === 0) continue;
+    out.push({ startTime: b.startTime, totalTokens, costUSD });
+  }
+  return out;
+}
 function resolveCcusageBin() {
-  const require3 = createRequire(import.meta.url);
+  const require3 = createRequire3(import.meta.url);
   const pkgPath = require3.resolve("ccusage/package.json");
   const pkg = require3("ccusage/package.json");
   const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.ccusage ?? "ccusage";
-  const binPath = join3(dirname(pkgPath), rel);
+  const binPath = join5(dirname2(pkgPath), rel);
   if (/\.(c|m)?js$/.test(binPath)) {
     return { cmd: process.execPath, prefixArgs: [binPath] };
   }
   return { cmd: binPath, prefixArgs: [] };
 }
-function collectAll() {
+function runCcusage(cmd, args) {
+  const res = spawnSync4(cmd, args, {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: 12e4
+  });
+  if (res.status !== 0 || !res.stdout) return null;
+  try {
+    return JSON.parse(res.stdout);
+  } catch {
+    return null;
+  }
+}
+async function collectAll() {
   const { cmd, prefixArgs } = resolveCcusageBin();
   const entries = [];
   const toolsFound = [];
   for (const source of SOURCES) {
-    const res = spawnSync2(
-      cmd,
-      [...prefixArgs, source, "daily", "--json", "--offline"],
-      { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, timeout: 12e4 }
-    );
-    if (res.status !== 0 || !res.stdout) continue;
-    try {
-      const mapped = mapCcusageDaily(source, JSON.parse(res.stdout));
-      if (mapped.length > 0) {
-        entries.push(...mapped);
-        toolsFound.push(source);
-      }
-    } catch {
+    const json = runCcusage(cmd, [
+      ...prefixArgs,
+      source,
+      "daily",
+      "--json",
+      "--offline"
+    ]);
+    if (!json) continue;
+    const mapped = mapCcusageDaily(source, json);
+    if (mapped.length > 0) {
+      entries.push(...mapped);
+      toolsFound.push(source);
     }
   }
-  return { entries, toolsFound };
+  const sessionJson = runCcusage(cmd, [...prefixArgs, "session", "--json", "--offline"]);
+  const blockJson = runCcusage(cmd, [...prefixArgs, "blocks", "--json", "--offline"]);
+  const sessions = sessionJson ? mapCcusageSessions(sessionJson) : [];
+  const blocks = blockJson ? mapCcusageBlocks(blockJson) : [];
+  const cursor = await collectCursor();
+  if (cursor.found) {
+    entries.push(...cursor.entries);
+    blocks.push(...cursor.blocks);
+    toolsFound.push("cursor");
+  }
+  return { entries, sessions, blocks, toolsFound };
 }
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
@@ -4398,6 +4749,22 @@ var NEVER = INVALID;
 // ../shared/dist/index.js
 var DateString = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/, "must be YYYY-MM-DD");
 var tokenCount = external_exports.number().int().nonnegative();
+var ConnectorProvider = external_exports.enum([
+  "anthropic-api",
+  "openai-api",
+  "openrouter",
+  "google-api",
+  "cursor"
+]);
+var UsageOrigin = external_exports.enum([
+  "cli",
+  "anthropic-api",
+  "openai-api",
+  "openrouter",
+  "google-api",
+  "cursor",
+  "import"
+]);
 var DailyUsageEntry = external_exports.object({
   date: DateString,
   /** Source agent id, e.g. "claude", "codex", "gemini", "copilot". */
@@ -4409,11 +4776,38 @@ var DailyUsageEntry = external_exports.object({
   cacheCreationTokens: tokenCount,
   cacheReadTokens: tokenCount,
   /** Estimated cost in USD for this entry. */
+  costUSD: external_exports.number().nonnegative(),
+  /** Where this entry came from. Defaults to the local CLI for back-compat. */
+  origin: UsageOrigin.default("cli"),
+  /** True when the numbers come from a provider's authoritative usage API. */
+  verified: external_exports.boolean().default(false)
+});
+var Timestamp = external_exports.string().min(1).max(40);
+var SessionEntry = external_exports.object({
+  sessionId: external_exports.string().min(1).max(128),
+  tool: external_exports.string().min(1).max(64),
+  model: external_exports.string().min(1).max(128),
+  inputTokens: tokenCount,
+  outputTokens: tokenCount,
+  cacheCreationTokens: tokenCount,
+  cacheReadTokens: tokenCount,
+  costUSD: external_exports.number().nonnegative(),
+  lastActivity: Timestamp
+});
+var BlockEntry = external_exports.object({
+  startTime: Timestamp,
+  totalTokens: tokenCount,
   costUSD: external_exports.number().nonnegative()
 });
 var SubmitPayload = external_exports.object({
   cliVersion: external_exports.string().min(1).max(32),
-  entries: external_exports.array(DailyUsageEntry).min(1).max(2e4)
+  entries: external_exports.array(DailyUsageEntry).min(1).max(2e4),
+  /** Optional per-conversation rollups (ccusage session). Back-compat: omittable. */
+  sessions: external_exports.array(SessionEntry).max(1e4).optional(),
+  /** Optional time-window rollups (ccusage blocks) for peak-hours analysis. */
+  blocks: external_exports.array(BlockEntry).max(1e4).optional(),
+  /** Optional friends-board code (from `--board=<code>`): auto-join this board on submit. */
+  board: external_exports.string().min(1).max(32).optional()
 });
 var AnonSubmitPayload = SubmitPayload.extend({
   /** Client-generated secret (hex). The server stores only its hash. */
@@ -4623,11 +5017,27 @@ function renderDashboardHtml(entries, generatedAt = /* @__PURE__ */ new Date())
 `;
 }
 
+// src/publish.ts
+async function publishLocal(payload, deps) {
+  if (!await deps.confirm("  Publish this to the public leaderboard?")) {
+    deps.log("  Kept local. Nothing left your machine.");
+    return false;
+  }
+  const key = deps.ensureAnonKey();
+  const res = await deps.anonSubmit(key, payload);
+  deps.log(`  Published \u2014 you're on the board: ${res.dashboardUrl}`);
+  deps.openBrowser(claimUrl(res.dashboardUrl, key));
+  deps.log(
+    "  Sign in there to claim it, or `npx whoburnedmore private` to hide it again."
+  );
+  return true;
+}
+
 // src/index.ts
-var require2 = createRequire2(import.meta.url);
+var require2 = createRequire4(import.meta.url);
 var VERSION = require2("../package.json").version;
 function openBrowser(url) {
-  const os = platform2();
+  const os = platform3();
   const [cmd, args] = os === "darwin" ? ["open", [url]] : os === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
 }
@@ -4662,7 +5072,7 @@ async function confirm(question) {
 function showLocalDashboard(entries) {
   const dir = defaultConfigDir();
   mkdirSync3(dir, { recursive: true });
-  const file = join4(dir, "dashboard.html");
+  const file = join6(dir, "dashboard.html");
   writeFileSync3(file, renderDashboardHtml(entries));
   console.log();
   console.log(`  Local dashboard: ${pc2.cyan(`file://${file}`)}`);
@@ -4672,8 +5082,9 @@ function showLocalDashboard(entries) {
 async function run(flags) {
   if (!flags.quiet) {
     console.log(pc2.dim(`whoburnedmore v${VERSION} \xB7 ${flags.local ? "local mode" : apiBase()}`));
+    console.log(pc2.dim("  Calculating your burn from local usage\u2026"));
   }
-  const { entries, toolsFound } = collectAll();
+  const { entries, sessions, blocks, toolsFound } = await collectAll();
   if (entries.length === 0) {
     console.log();
     console.log("  Nothing to burn yet \u2014 no local usage found from any coding agent.");
@@ -4681,6 +5092,9 @@ async function run(flags) {
     return;
   }
   const payload = { cliVersion: VERSION, entries };
+  if (sessions.length > 0) payload.sessions = sessions;
+  if (blocks.length > 0) payload.blocks = blocks;
+  if (flags.board) payload.board = flags.board;
   if (flags.dryRun) {
     console.log(pc2.dim("\n  --dry-run: this exact payload would be sent, nothing else:\n"));
     console.log(JSON.stringify(payload, null, 2));
@@ -4689,6 +5103,15 @@ async function run(flags) {
   if (!flags.quiet) printSummary(entries);
   if (flags.local) {
     showLocalDashboard(entries);
+    if (!flags.quiet && process.stdin.isTTY) {
+      await publishLocal(payload, {
+        confirm,
+        ensureAnonKey,
+        anonSubmit,
+        openBrowser,
+        log: (line) => console.log(pc2.dim(line))
+      });
+    }
     return;
   }
   if (flags.noSubmit) {
@@ -4698,6 +5121,10 @@ async function run(flags) {
   const config = loadConfig();
   if (config?.token) {
     const result = await submitUsage(config.token, payload);
+    if (!flags.quiet) {
+      console.log(pc2.dim("  Opening your dashboard in your browser\u2026"));
+      openBrowser(result.boardUrl ?? result.profileUrl);
+    }
     console.log(
       `  Submitted ${pc2.bold(String(result.upserted))} day-entries from ${toolsFound.join(", ")}.`
     );
@@ -4707,28 +5134,46 @@ async function run(flags) {
       );
     }
     console.log(`  ${pc2.cyan(result.profileUrl)}`);
+    if (result.boardUrl) {
+      console.log(`  \u{1F91D} You're on the friends board: ${pc2.cyan(result.boardUrl)}`);
+    }
   } else {
-    const result = await anonSubmit(ensureAnonKey(), payload);
+    const anonKey = ensureAnonKey();
+    const result = await anonSubmit(anonKey, payload);
+    const target = result.boardUrl ?? claimUrl(result.dashboardUrl, anonKey);
+    if (!flags.quiet) {
+      console.log(pc2.dim("  Opening your dashboard in your browser\u2026"));
+      openBrowser(target);
+    }
     console.log(
       `  Submitted ${pc2.bold(String(result.upserted))} day-entries from ${toolsFound.join(", ")}.`
     );
-    console.log(
-      `  You burned ${pc2.bold(formatTokens(result.totalTokens))} tokens. Your dashboard:`
-    );
-    console.log(`  ${pc2.cyan(result.dashboardUrl)}`);
-    if (!flags.quiet) {
+    if (result.boardUrl) {
+      console.log(
+        `  You burned ${pc2.bold(formatTokens(result.totalTokens))} tokens \u2014 \u{1F91D} you're on the friends board:`
+      );
+      console.log(`  ${pc2.cyan(result.boardUrl)}`);
+      console.log(pc2.dim(`  Your dashboard: ${result.dashboardUrl}`));
+    } else {
       console.log(
-        pc2.dim("  Re-run anytime to update it \xB7 `npx whoburnedmore login` to claim a public handle and compete.")
+        `  You burned ${pc2.bold(formatTokens(result.totalTokens))} tokens \u2014 you're on the public leaderboard:`
       );
+      console.log(`  ${pc2.cyan(result.dashboardUrl)}`);
+      if (!flags.quiet) {
+        console.log(
+          pc2.dim("  Claim it (name + X) to own your rank, or make it private / remove it.")
+        );
+        console.log(
+          pc2.dim("  Manage anytime: `npx whoburnedmore private` \xB7 `npx whoburnedmore public` \xB7 `npx whoburnedmore remove`.")
+        );
+      }
     }
   }
   console.log();
-  if (!flags.quiet && !autoSyncInstalled()) {
-    if (await confirm("  Keep your stats live? Install background sync (every 3h)?")) {
-      console.log(`  ${installAutoSync()}`);
-    } else {
-      console.log(pc2.dim("  OK \u2014 re-run `npx whoburnedmore` anytime, or `npx whoburnedmore install-sync` later."));
-    }
+  if (!flags.quiet) {
+    console.log(
+      autoSyncInstalled() ? pc2.dim("  Background sync is on \u2014 your page keeps updating automatically (`npx whoburnedmore uninstall-sync` to stop).") : pc2.dim("  Re-run anytime to update \xB7 `npx whoburnedmore install-sync` to keep it live in the background.")
+    );
   }
 }
 async function main() {
@@ -4744,7 +5189,8 @@ async function main() {
     dryRun: args.includes("--dry-run"),
     noSubmit: args.includes("--no-submit"),
     local: args.includes("--local"),
-    quiet: command === "sync"
+    quiet: command === "sync",
+    board: parseBoard(args)
   };
   switch (command) {
     case "run":
@@ -4763,6 +5209,29 @@ async function main() {
       console.log("  Logged out. Your leaderboard data is untouched.");
       console.log(pc2.dim("  Delete your data anytime from your profile page."));
       break;
+    case "private":
+    case "public": {
+      const cfg = loadConfig();
+      if (!cfg?.anonKey) {
+        console.log("  No anonymous dashboard on this machine \u2014 run `npx whoburnedmore` first.");
+        break;
+      }
+      await anonVisibility(cfg.anonKey, command === "public");
+      console.log(
+        command === "public" ? "  Your dashboard is public on the leaderboard again." : "  Your dashboard is now private \u2014 off the public leaderboard."
+      );
+      break;
+    }
+    case "remove": {
+      const cfg = loadConfig();
+      if (!cfg?.anonKey) {
+        console.log("  No anonymous dashboard on this machine \u2014 nothing to remove.");
+        break;
+      }
+      await anonRemove(cfg.anonKey);
+      console.log("  Removed your anonymous dashboard and all its data.");
+      break;
+    }
     case "install-sync":
       console.log(`  ${installAutoSync()}`);
       break;
@@ -4789,19 +5258,24 @@ function printHelp() {
   ${pc2.bold("whoburnedmore")} \u2014 who burned more tokens, you or them?
 
   ${pc2.bold("usage")}
-    npx whoburnedmore              show your burn + get a shareable dashboard (no sign-in)
+    npx whoburnedmore              burn + land on the public leaderboard, open your dashboard
+    npx whoburnedmore --board=CODE compare with friends \u2014 join their board (no sign-in)
     npx whoburnedmore --local      build the dashboard on your machine and open it (offline)
     npx whoburnedmore --dry-run    print exactly what would be sent, send nothing
     npx whoburnedmore --no-submit  print local stats only, send nothing
+    npx whoburnedmore private      hide your anonymous dashboard from the leaderboard
+    npx whoburnedmore public       put it back on the leaderboard
+    npx whoburnedmore remove       delete your anonymous dashboard and its data
     npx whoburnedmore login        sign in to claim a public handle + join the leaderboard
     npx whoburnedmore logout       forget the local token
     npx whoburnedmore install-sync     keep your dashboard live (background sync, 3h)
     npx whoburnedmore uninstall-sync   remove background sync
 
-  By default your dashboard is anonymous and unlisted \u2014 only people you share
-  the link with can see it. Only daily aggregate numbers (date, tool, model,
-  token counts, est. cost) ever leave your machine. Never prompts, code, or
-  file names. With --local, nothing leaves your machine at all.
+  By default your dashboard is public on the leaderboard as an anonymous burner \u2014
+  claim it (sign in for a handle + X) to own your rank, or run \`private\`/\`remove\`
+  to pull it. Only daily aggregate numbers (date, tool, model, token counts, est.
+  cost) ever leave your machine \u2014 never prompts, code, or file names. With --local,
+  nothing leaves your machine at all.
 `);
 }
 main().catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whoburnedmore",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Find out who burned more — submit your AI coding-agent token usage to the public leaderboard at whoburnedmore.com",
   "type": "module",
   "bin": {
@@ -10,7 +10,7 @@
     "dist/index.js"
   ],
   "scripts": {
-    "build": "rm -rf dist && esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js --external:ccusage --external:picocolors",
+    "build": "rm -rf dist && esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js --external:ccusage --external:picocolors --external:tokscale",
     "test": "vitest run",
     "lint": "tsc -p tsconfig.json --noEmit",
     "prepublishOnly": "pnpm run build",
@@ -20,7 +20,8 @@
   },
   "dependencies": {
     "ccusage": "20.0.9",
-    "picocolors": "^1.1.1"
+    "picocolors": "^1.1.1",
+    "tokscale": "^1.2.7"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",