token-rats 0.1.0 → 0.3.0

package/dist/index.js

@@ -11,12 +11,12 @@ async function installCursorCommand(opts = {}) {
   const args = ["install", "-g", "better-sqlite3@^9.4.3"];
   console.log(`\x1B[2m$ ${pm} ${args.join(" ")}\x1B[0m
 `);
-  const exitCode = await new Promise((resolve) => {
+  const exitCode = await new Promise((resolve2) => {
     const child = spawn(pm, args, { stdio: "inherit" });
-    child.on("close", (code) => resolve(code ?? 1));
+    child.on("close", (code) => resolve2(code ?? 1));
     child.on("error", (err) => {
       console.error(`\x1B[31mFailed to launch ${pm}: ${err.message}\x1B[0m`);
-      resolve(1);
+      resolve2(1);
     });
   });
   if (exitCode === 0) {
@@ -32,6 +32,419 @@ async function installCursorCommand(opts = {}) {
   process.exit(exitCode);
 }
 
+// src/commands/install-daemon.ts
+import { execFile } from "node:child_process";
+import * as fs2 from "node:fs";
+import { createRequire } from "node:module";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+import { promisify } from "node:util";
+
+// src/lib/auth-store.ts
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function tokenDir() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  const base = xdgConfig ?? path.join(os.homedir(), ".config");
+  return path.join(base, "token-rats");
+}
+function tokenPath() {
+  return path.join(tokenDir(), "token");
+}
+function statePath() {
+  return path.join(tokenDir(), "state.json");
+}
+function disconnectedPath() {
+  return path.join(tokenDir(), "disconnected");
+}
+function saveToken(token) {
+  const dir = tokenDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(tokenPath(), token, { encoding: "utf8", mode: 384 });
+}
+function loadToken() {
+  try {
+    const token = fs.readFileSync(tokenPath(), "utf8").trim();
+    return token.length > 0 ? token : null;
+  } catch {
+    return null;
+  }
+}
+function deleteToken() {
+  try {
+    fs.unlinkSync(tokenPath());
+  } catch {
+  }
+}
+function isLoggedIn() {
+  return loadToken() !== null;
+}
+function ensureDeviceId() {
+  try {
+    const raw = fs.readFileSync(statePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.deviceId === "string" && parsed.deviceId.length > 0) {
+      return parsed.deviceId;
+    }
+  } catch {
+  }
+  const dir = tokenDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const deviceId = crypto.randomUUID();
+  const state = { deviceId, createdAt: Date.now() };
+  fs.writeFileSync(statePath(), JSON.stringify(state, null, 2), {
+    encoding: "utf8",
+    mode: 384
+  });
+  return deviceId;
+}
+function markDisconnected() {
+  const dir = tokenDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(disconnectedPath(), String(Date.now()), { mode: 384 });
+}
+function clearDisconnected() {
+  try {
+    fs.unlinkSync(disconnectedPath());
+  } catch {
+  }
+}
+function isDisconnected() {
+  return fs.existsSync(disconnectedPath());
+}
+
+// src/lib/log.ts
+var ESC = "\x1B";
+var c = {
+  reset: `${ESC}[0m`,
+  bold: `${ESC}[1m`,
+  dim: `${ESC}[2m`,
+  green: `${ESC}[32m`,
+  yellow: `${ESC}[33m`,
+  cyan: `${ESC}[36m`,
+  red: `${ESC}[31m`,
+  gray: `${ESC}[90m`
+};
+function strip(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function isTTY() {
+  return process.stdout.isTTY === true;
+}
+function color(code, text) {
+  return isTTY() ? `${code}${text}${c.reset}` : strip(text);
+}
+function info(msg) {
+  console.log(color(c.cyan, `  ${msg}`));
+}
+function success(msg) {
+  console.log(color(c.green, `\u2713 ${msg}`));
+}
+function warn(msg) {
+  console.warn(color(c.yellow, `\u26A0 ${msg}`));
+}
+function error(msg) {
+  console.error(color(c.red, `\u2717 ${msg}`));
+}
+function dim(msg) {
+  console.log(color(c.dim, `  ${msg}`));
+}
+function bold(msg) {
+  console.log(isTTY() ? `${c.bold}${msg}${c.reset}` : msg);
+}
+function spinner(label) {
+  if (!isTTY()) {
+    process.stdout.write(`  ${label}...
+`);
+    return {
+      stop(finalMsg) {
+        if (finalMsg) process.stdout.write(`  ${finalMsg}
+`);
+      }
+    };
+  }
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${c.cyan}${frames[i++ % frames.length]}${c.reset} ${label}   `);
+  }, 80);
+  return {
+    stop(finalMsg) {
+      clearInterval(interval);
+      process.stdout.write("\r\x1B[K");
+      if (finalMsg) success(finalMsg);
+    }
+  };
+}
+
+// src/commands/install-daemon.ts
+var exec = promisify(execFile);
+var LABEL = "com.tokenrats.watch";
+var LINUX_UNIT = "token-rats-watch.service";
+var WINDOWS_TASK = "TokenRatsWatch";
+function resolveCliPath() {
+  const entry = path2.resolve(process.argv[1] ?? "");
+  if (!entry.endsWith(".js")) throw new Error("Build the CLI before installing the daemon.");
+  const config = process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+  const runtime = path2.join(config, "token-rats", "runtime");
+  fs2.mkdirSync(runtime, { recursive: true });
+  const script = path2.join(runtime, "index.js");
+  if (entry !== script) fs2.copyFileSync(entry, script);
+  fs2.writeFileSync(path2.join(runtime, "package.json"), '{"type":"module"}\n');
+  const require2 = createRequire(import.meta.url);
+  const sqlPackage = path2.dirname(require2.resolve("sql.js/package.json"));
+  const destination = path2.join(runtime, "node_modules", "sql.js");
+  if (sqlPackage !== destination) fs2.cpSync(sqlPackage, destination, { recursive: true });
+  const runner = path2.join(runtime, "runner.mjs");
+  const settings = Object.fromEntries(
+    ["XDG_CONFIG_HOME", "CLAUDE_CONFIG_DIR", "CODEX_HOME", "APPDATA"].flatMap(
+      (key) => process.env[key] ? [[key, process.env[key]]] : []
+    )
+  );
+  fs2.writeFileSync(
+    runner,
+    `Object.assign(process.env, ${JSON.stringify(settings)});
+await import("./index.js");
+`
+  );
+  return { node: process.execPath, script: runner };
+}
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function systemdArg(value) {
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("$", "$$");
+  return `"${escaped}"`;
+}
+function darwinPlistPath() {
+  return path2.join(os2.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function darwinLogDir() {
+  return path2.join(os2.homedir(), "Library", "Logs", "token-rats");
+}
+function darwinPlist(node, script, apiUrl) {
+  const logDir = darwinLogDir();
+  const stdout = path2.join(logDir, "watch.out.log");
+  const stderr = path2.join(logDir, "watch.err.log");
+  return `<?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>${xml(node)}</string>
+    <string>${xml(script)}</string>
+    <string>watch</string>
+    ${apiUrl ? `<string>--api-url</string><string>${xml(apiUrl)}</string>` : ""}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xml(stdout)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(stderr)}</string>
+</dict>
+</plist>
+`;
+}
+async function darwinInstall(apiUrl) {
+  const { node, script } = resolveCliPath();
+  fs2.mkdirSync(darwinLogDir(), { recursive: true });
+  const plistPath = darwinPlistPath();
+  fs2.mkdirSync(path2.dirname(plistPath), { recursive: true });
+  fs2.writeFileSync(plistPath, darwinPlist(node, script, apiUrl), { mode: 420 });
+  await exec("launchctl", ["bootout", `gui/${process.getuid?.() ?? 0}/${LABEL}`]).catch(
+    () => void 0
+  );
+  try {
+    await exec("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 0}`, plistPath]);
+  } catch {
+    try {
+      await exec("launchctl", ["load", plistPath]);
+    } catch (err) {
+      throw new Error(
+        `Wrote ${plistPath} but failed to load it: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+async function darwinUninstall() {
+  const plistPath = darwinPlistPath();
+  try {
+    await exec("launchctl", ["bootout", `gui/${process.getuid?.() ?? 0}/${LABEL}`]);
+  } catch {
+    try {
+      await exec("launchctl", ["unload", plistPath]);
+    } catch {
+    }
+  }
+  try {
+    fs2.unlinkSync(plistPath);
+  } catch {
+  }
+}
+async function darwinStatus() {
+  if (!fs2.existsSync(darwinPlistPath())) return "not-installed";
+  try {
+    const { stdout } = await exec("launchctl", ["list"]);
+    if (stdout.split("\n").some((line) => line.endsWith(LABEL) && /^\d+\s/.test(line)))
+      return "running";
+    return "stopped";
+  } catch {
+    return "stopped";
+  }
+}
+function linuxUnitPath() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+  return path2.join(xdgConfig, "systemd", "user", LINUX_UNIT);
+}
+function linuxUnit(node, script, apiUrl) {
+  return `[Unit]
+Description=Token Rats watcher \u2014 live AI usage sync
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${systemdArg(node)} ${systemdArg(script)} watch${apiUrl ? ` --api-url ${systemdArg(apiUrl)}` : ""}
+Restart=on-failure
+RestartSec=10s
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function linuxInstall(apiUrl) {
+  const { node, script } = resolveCliPath();
+  const unitPath = linuxUnitPath();
+  fs2.mkdirSync(path2.dirname(unitPath), { recursive: true });
+  fs2.writeFileSync(unitPath, linuxUnit(node, script, apiUrl), { mode: 420 });
+  try {
+    await exec("systemctl", ["--user", "daemon-reload"]);
+    await exec("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
+    await exec("systemctl", ["--user", "restart", LINUX_UNIT]);
+  } catch (err) {
+    throw new Error(
+      `Wrote ${unitPath} but failed to enable+start it: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function linuxUninstall() {
+  try {
+    await exec("systemctl", ["--user", "disable", "--now", LINUX_UNIT]);
+  } catch {
+  }
+  try {
+    fs2.unlinkSync(linuxUnitPath());
+  } catch {
+  }
+  try {
+    await exec("systemctl", ["--user", "daemon-reload"]);
+  } catch {
+  }
+}
+async function linuxStatus() {
+  if (!fs2.existsSync(linuxUnitPath())) return "not-installed";
+  try {
+    const { stdout } = await exec("systemctl", ["--user", "is-active", LINUX_UNIT]);
+    return stdout.trim() === "active" ? "running" : "stopped";
+  } catch {
+    return "stopped";
+  }
+}
+async function windowsInstall(apiUrl) {
+  const { node, script } = resolveCliPath();
+  await exec("schtasks", [
+    "/Create",
+    "/SC",
+    "ONLOGON",
+    "/TN",
+    WINDOWS_TASK,
+    "/TR",
+    `"${node}" "${script}" watch${apiUrl ? ` --api-url "${apiUrl}"` : ""}`,
+    "/RL",
+    "LIMITED",
+    "/F"
+  ]);
+  try {
+    await exec("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
+  } catch {
+  }
+}
+async function windowsUninstall() {
+  try {
+    await exec("schtasks", ["/End", "/TN", WINDOWS_TASK]);
+  } catch {
+  }
+  try {
+    await exec("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
+  } catch {
+  }
+}
+async function windowsStatus() {
+  try {
+    const { stdout } = await exec("schtasks", ["/Query", "/TN", WINDOWS_TASK, "/FO", "CSV", "/NH"]);
+    if (stdout.includes("Running")) return "running";
+    return "stopped";
+  } catch {
+    return "not-installed";
+  }
+}
+async function installDaemonCommand(apiUrl) {
+  clearDisconnected();
+  try {
+    if (process.platform === "darwin") {
+      await darwinInstall(apiUrl);
+    } else if (process.platform === "linux") {
+      await linuxInstall(apiUrl);
+    } else if (process.platform === "win32") {
+      await windowsInstall(apiUrl);
+    } else {
+      warn(`No daemon installer for platform ${process.platform}; skipping.`);
+      return;
+    }
+    success("Background watcher installed and running.");
+    dim("It will pick up sessions from Claude Code, Codex, and Cursor every 30 seconds.");
+    dim("Manage it with `token-rats daemon-status` and `token-rats uninstall-daemon`.");
+  } catch (err) {
+    error(`Failed to install daemon: ${err instanceof Error ? err.message : String(err)}`);
+    warn("You can still run `token-rats sync` manually.");
+  }
+}
+async function uninstallDaemonCommand() {
+  if (process.platform === "darwin") {
+    await darwinUninstall();
+  } else if (process.platform === "linux") {
+    await linuxUninstall();
+  } else if (process.platform === "win32") {
+    await windowsUninstall();
+  } else {
+    warn(`No daemon installer for platform ${process.platform}; nothing to remove.`);
+    return;
+  }
+  info("Daemon removed. `token-rats sync` will still work manually.");
+}
+async function daemonStatusCommand() {
+  let status;
+  if (process.platform === "darwin") status = await darwinStatus();
+  else if (process.platform === "linux") status = await linuxStatus();
+  else if (process.platform === "win32") status = await windowsStatus();
+  else {
+    warn(`No daemon for platform ${process.platform}.`);
+    return;
+  }
+  if (status === "running") success("Token Rats watcher is running.");
+  else if (status === "stopped") warn("Token Rats watcher is installed but not running.");
+  else info("Token Rats watcher is not installed. Run `token-rats install-daemon` to start it.");
+}
+
 // ../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
@@ -385,8 +798,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data, path: path7, errorMaps, issueData } = params;
-  const fullPath = [...path7, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -508,11 +921,11 @@ var errorUtil;
 var _ZodEnum_cache;
 var _ZodNativeEnum_cache;
 var ParseInputLazyPath = class {
-  constructor(parent, value, path7, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path7;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -3947,13 +4360,28 @@ var z = /* @__PURE__ */ Object.freeze({
 });
 
 // ../contracts/src/session.ts
-var Source = z.enum(["claude-code", "cursor", "codex"]);
-var Provider = z.enum(["anthropic", "openai", "cursor", "unknown"]);
+var Source = z.enum(["claude-code", "cursor", "codex", "openrouter", "openai"]);
+var Provider = z.enum([
+  "anthropic",
+  "openai",
+  "openrouter",
+  "cursor",
+  "ollama",
+  "unknown"
+]);
+var SessionChannel = z.enum(["cli", "ide", "api", "proxy", "local", "unknown"]);
+var ID_RE = /^[A-Za-z0-9._:/+ -]+$/;
+var MODEL_RE = /^[A-Za-z0-9._:/+ -]+$/;
+var DEDUPE_KEY_RE = /^[A-Za-z0-9._:-]+$/;
+var CLIENT_RE = /^[A-Za-z0-9._-]+$/;
 var SessionRecord = z.object({
-  id: z.string().min(1),
+  accountingVersion: z.literal(2).optional(),
+  id: z.string().min(1).max(256).regex(ID_RE),
   source: Source,
   provider: Provider.optional(),
-  model: z.string().min(1),
+  client: z.string().min(1).max(64).regex(CLIENT_RE).optional(),
+  channel: SessionChannel.optional(),
+  model: z.string().min(1).max(128).regex(MODEL_RE),
   inTokens: z.number().int().nonnegative(),
   outTokens: z.number().int().nonnegative(),
   /** Anthropic cache reads / OpenAI `cached_input_tokens`. Billed cheap-or-free. */
@@ -3965,10 +4393,37 @@ var SessionRecord = z.object({
   costUsdCents: z.number().int().nonnegative(),
   startedAt: z.number().int().positive(),
   endedAt: z.number().int().positive(),
-  dedupeKey: z.string().min(1)
+  dedupeKey: z.string().min(1).max(128).regex(DEDUPE_KEY_RE)
 });
 
 // ../contracts/src/user.ts
+var ProfileAttributionEntry = z.object({
+  source: z.string(),
+  tokens: z.number().int().nonnegative(),
+  costUsdCents: z.number().int().nonnegative(),
+  sessions: z.number().int().nonnegative()
+});
+var GithubProject = z.object({
+  name: z.string().min(1).max(100),
+  fullName: z.string().min(3).max(201).regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/),
+  url: z.string().url().startsWith("https://github.com/"),
+  description: z.string().max(500).nullable()
+}).superRefine((project, context) => {
+  const repositoryName = project.fullName.split("/")[1];
+  const canonicalUrl = `https://github.com/${project.fullName}`;
+  if (repositoryName?.toLowerCase() !== project.name.toLowerCase()) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "GitHub project name is invalid" });
+  }
+  if (project.url.toLowerCase() !== canonicalUrl.toLowerCase()) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "GitHub project URL is invalid" });
+  }
+});
+var GithubProjects = z.array(GithubProject).max(3).refine(
+  (projects) => new Set(projects.map((project) => project.fullName.toLowerCase())).size === projects.length,
+  {
+    message: "GitHub projects must be unique"
+  }
+);
 var User = z.object({
   id: z.string(),
   handle: z.string(),
@@ -3988,13 +4443,20 @@ var User = z.object({
    * (other readers never see this field). `null` when GitHub didn't return a
    * verified email — the user sees a banner asking them to add one.
    */
-  email: z.string().email().nullable().optional()
+  email: z.string().email().nullable().optional(),
+  /** Full text is self-only; public profiles receive agentInstructionsPreview instead. */
+  agentInstructions: z.string().max(2e4).nullable().optional(),
+  githubProjects: GithubProjects.optional()
 });
 var PublicProfileSettings = z.object({
   publicProfile: z.boolean().optional(),
-  bio: z.string().max(200).nullable().optional()
+  bio: z.string().max(200).nullable().optional(),
+  agentInstructions: z.string().max(2e4).nullable().optional(),
+  githubProjects: GithubProjects.optional()
 });
 var Profile = User.extend({
+  /** The first ten lines of the owner's saved agent instructions. */
+  agentInstructionsPreview: z.string().max(4e3).nullable().optional(),
   totals: z.object({
     today: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() }),
     week: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() }),
@@ -4002,6 +4464,10 @@ var Profile = User.extend({
   }),
   /** Number of users this user has brought in via their referral link. */
   referredCount: z.number().int().nonnegative().optional(),
+  /** All-time attribution grouped by tool/client. */
+  sources: z.array(ProfileAttributionEntry).optional(),
+  /** All-time attribution grouped by transport channel. */
+  channels: z.array(ProfileAttributionEntry).optional(),
   /**
    * The profile owner's referral code. Self-only — present only when the
    * caller is viewing their own profile, so the page can render a
@@ -4077,8 +4543,14 @@ var LeaderboardRow = z.object({
   tokens: z.number().int().nonnegative(),
   costUsdCents: z.number().int().nonnegative(),
   sessions: z.number().int().nonnegative(),
+  /** ISO 3166-1 alpha-2 country code. Null when the user has no stamped country. */
+  country: z.string().length(2).nullable().default(null),
   /** Up to 2 dominant sources by token volume, descending. May be empty. */
-  topSources: z.array(SourceBreakdownEntry).max(2).default([])
+  topSources: z.array(SourceBreakdownEntry).max(2).default([]),
+  /** Up to 2 dominant clients/tools by token volume, descending. */
+  topClients: z.array(SourceBreakdownEntry).max(2).default([]),
+  /** Up to 2 dominant transport channels by token volume, descending. */
+  topChannels: z.array(SourceBreakdownEntry).max(2).default([])
 });
 var Leaderboard = z.object({
   range: LeaderboardRange,
@@ -4414,6 +4886,12 @@ var ENDPOINTS = {
   meReferral: "/v1/me/referral",
   // v1.2 Track AD — friends derived from shared private rooms
   meFriends: "/v1/me/friends",
+  // Multi-device — anonymized device list + revoke + heartbeat
+  meDevices: "/v1/me/devices",
+  meDeviceRevoke: (deviceId) => `/v1/me/devices/${deviceId}/revoke`,
+  meDeviceHeartbeat: "/v1/me/devices/heartbeat",
+  // CLI version + upgrade banner
+  cliVersion: "/v1/cli/version",
   // Phase 3 Track O — Org plan
   orgs: "/v1/orgs",
   org: (slug) => `/v1/orgs/${slug}`,
@@ -4547,49 +5025,147 @@ var FriendsResponse = z.object({
   friends: z.array(FriendRow)
 });
 
-// src/lib/api.ts
-var DEFAULT_API_URL = "https://api.tokenrats.com";
-function isTransient(status) {
-  return status >= 500 || status === 408 || status === 429;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-var ApiError2 = class extends Error {
-  constructor(status, body) {
-    super(`API error ${status}: ${body}`);
-    this.status = status;
-    this.body = body;
-    this.name = "ApiError";
-  }
-};
-var ApiClient = class {
-  apiUrl;
-  token;
-  constructor(opts = {}) {
-    this.apiUrl = (opts.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
-    this.token = opts.token;
+// ../contracts/src/device.ts
+var DeviceTotals = z.object({
+  tokens: z.number().int().nonnegative(),
+  costUsdCents: z.number().int().nonnegative(),
+  sessions: z.number().int().nonnegative()
+});
+var DeviceBreakdownEntry = z.object({
+  value: z.string().min(1),
+  tokens: z.number().int().nonnegative(),
+  costUsdCents: z.number().int().nonnegative(),
+  sessions: z.number().int().nonnegative()
+});
+var Device = z.object({
+  deviceId: z.string().min(1),
+  createdAt: z.number().int().nonnegative(),
+  lastSeenAt: z.number().int().nonnegative(),
+  lastHeartbeatAt: z.number().int().nonnegative().nullable(),
+  /** Derived: true iff lastHeartbeatAt is within 5 min of `now`. */
+  isLive: z.boolean(),
+  lastUploadCount: z.number().int().nonnegative(),
+  cliVersion: z.string().nullable(),
+  /** Unix-ms when the user revoked this device via the web UI, else null. */
+  revokedAt: z.number().int().nonnegative().nullable(),
+  /** True for the synthetic pre-device-id bucket. */
+  isLegacy: z.boolean().default(false),
+  /** Last observed session upload timestamp for this device, if any. */
+  lastSessionAt: z.number().int().nonnegative().nullable(),
+  /** 30-day totals for this device, computed at request time. */
+  totals: DeviceTotals,
+  /** All-time totals for this device. */
+  totalsAllTime: DeviceTotals,
+  /** Dominant sources in the last 30 days, ordered by tokens desc. */
+  topSources: z.array(DeviceBreakdownEntry).max(3).default([]),
+  /** Dominant clients/tools in the last 30 days, ordered by tokens desc. */
+  topClients: z.array(DeviceBreakdownEntry).max(3).default([]),
+  /** Dominant transport channels in the last 30 days, ordered by tokens desc. */
+  topChannels: z.array(DeviceBreakdownEntry).max(3).default([]),
+  /** Dominant providers in the last 30 days, ordered by tokens desc. */
+  topProviders: z.array(DeviceBreakdownEntry).max(3).default([]),
+  /** Dominant models in the last 30 days, ordered by tokens desc. */
+  topModels: z.array(DeviceBreakdownEntry).max(3).default([])
+});
+var GetMeDevicesResponse = z.object({
+  devices: z.array(Device)
+});
+var RevokeDeviceResponse = z.object({
+  ok: z.literal(true),
+  revokedAt: z.number().int().nonnegative()
+});
+var DeviceHeartbeatResponse = z.object({
+  ok: z.literal(true),
+  lastHeartbeatAt: z.number().int().nonnegative()
+});
+
+// ../contracts/src/cli.ts
+var CliVersionResponse = z.object({
+  latest: z.string().min(1),
+  minSupported: z.string().min(1),
+  upgradeCommand: z.string().min(1)
+});
+
+// ../contracts/src/community.ts
+var PostKind = z.enum(["idea", "agents-md", "showcase", "question"]);
+var CreatePostRequest = z.object({
+  kind: PostKind,
+  title: z.string().trim().min(3).max(160),
+  body: z.string().trim().min(1).max(3e4)
+});
+var CreateReplyRequest = z.object({ body: z.string().trim().min(1).max(1e4) });
+var CommunityPost = CreatePostRequest.extend({
+  id: z.string(),
+  handle: z.string(),
+  createdAt: z.number(),
+  replies: z.number()
+});
+var CommunityReply = z.object({
+  id: z.string(),
+  body: z.string(),
+  handle: z.string(),
+  createdAt: z.number()
+});
+
+// ../contracts/src/comparison.ts
+var UsageMonth = z.string().regex(/^20\d{2}-(0[1-9]|1[0-2])$/);
+var SubscriptionSpendRequest = z.object({
+  month: UsageMonth,
+  source: z.enum(["claude-code", "codex", "cursor"]),
+  label: z.string().trim().min(1).max(80),
+  paidUsdCents: z.number().int().min(0).max(1e8)
+});
+
+// src/lib/api.ts
+var DEFAULT_API_URL = "https://api.tokenrats.com";
+function isTransient(status) {
+  return status >= 500 || status === 408 || status === 429;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var ApiError2 = class extends Error {
+  constructor(status, body) {
+    super(`API error ${status}: ${body}`);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+var DeviceRevokedError = class extends ApiError2 {
+  constructor(body) {
+    super(401, body);
+    this.name = "DeviceRevokedError";
+  }
+};
+var ApiClient = class {
+  apiUrl;
+  token;
+  deviceId;
+  cliVersion;
+  constructor(opts = {}) {
+    this.apiUrl = (opts.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
+    this.token = opts.token;
+    this.deviceId = opts.deviceId;
+    this.cliVersion = opts.cliVersion;
   }
   setToken(token) {
     this.token = token;
   }
   headers() {
     const h = { "Content-Type": "application/json" };
-    if (this.token) {
-      h.Authorization = `Bearer ${this.token}`;
-    }
+    if (this.token) h.Authorization = `Bearer ${this.token}`;
+    if (this.deviceId) h["X-Device-Id"] = this.deviceId;
+    if (this.cliVersion) h["X-Cli-Version"] = this.cliVersion;
     return h;
   }
-  /** Perform a fetch with retry+backoff. maxRetries=3, delays: 1s, 2s, 4s. */
   async fetchWithRetry(url, init, maxRetries = 3) {
     let attempt = 0;
     let lastErr;
     while (attempt <= maxRetries) {
       try {
-        const res = await fetch(url, init);
-        if (res.ok || !isTransient(res.status)) {
-          return res;
-        }
+        const res = await fetch(url, { ...init, signal: AbortSignal.timeout(3e4) });
+        if (res.ok || !isTransient(res.status)) return res;
         lastErr = new ApiError2(res.status, await res.text());
       } catch (err) {
         lastErr = err;
@@ -4601,34 +5177,37 @@ var ApiClient = class {
     }
     throw lastErr;
   }
-  async post(path7, body) {
-    const url = `${this.apiUrl}${path7}`;
+  async failedResponseToError(res) {
+    const body = await res.text();
+    if (res.status === 401 && /device_revoked/.test(body)) {
+      return new DeviceRevokedError(body);
+    }
+    return new ApiError2(res.status, body);
+  }
+  async post(path4, body) {
+    const url = `${this.apiUrl}${path4}`;
     const res = await this.fetchWithRetry(url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify(body)
     });
-    if (!res.ok) {
-      throw new ApiError2(res.status, await res.text());
-    }
+    if (!res.ok) throw await this.failedResponseToError(res);
     return res.json();
   }
-  async get(path7) {
-    const url = `${this.apiUrl}${path7}`;
+  async get(path4) {
+    const url = `${this.apiUrl}${path4}`;
     const res = await this.fetchWithRetry(url, {
       method: "GET",
       headers: this.headers()
     });
-    if (!res.ok) {
-      throw new ApiError2(res.status, await res.text());
-    }
+    if (!res.ok) throw await this.failedResponseToError(res);
     return res.json();
   }
   /** Initiate device-code flow. */
   async cliExchange() {
     return this.post(ENDPOINTS.authCliExchange, {});
   }
-  /** Poll for auth token. Returns token on success, null on pending, throws on error. */
+  /** Poll for auth token. Returns token on success, null on pending. */
   async cliPoll(pollToken) {
     const url = `${this.apiUrl}${ENDPOINTS.authCliPoll}`;
     const res = await fetch(url, {
@@ -4640,12 +5219,8 @@ var ApiClient = class {
       const data = await res.json();
       return data.token;
     }
-    if (res.status === 202) {
-      return null;
-    }
-    if (res.status === 410) {
-      throw new ApiError2(410, "Code expired");
-    }
+    if (res.status === 202) return null;
+    if (res.status === 410) throw new ApiError2(410, "Code expired");
     throw new ApiError2(res.status, await res.text());
   }
   /** GET /v1/me */
@@ -4656,106 +5231,78 @@ var ApiClient = class {
   async uploadSessions(sessions) {
     return this.post(ENDPOINTS.sessions, { sessions });
   }
-};
-
-// src/lib/auth-store.ts
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-function tokenDir() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME;
-  const base = xdgConfig ?? path.join(os.homedir(), ".config");
-  return path.join(base, "token-rats");
-}
-function tokenPath() {
-  return path.join(tokenDir(), "token");
-}
-function saveToken(token) {
-  const dir = tokenDir();
-  fs.mkdirSync(dir, { recursive: true });
-  const file = tokenPath();
-  fs.writeFileSync(file, token, { encoding: "utf8", mode: 384 });
-}
-function loadToken() {
-  const file = tokenPath();
-  try {
-    const token = fs.readFileSync(file, "utf8").trim();
-    return token.length > 0 ? token : null;
-  } catch {
-    return null;
+  /** GET /v1/u/:handle */
+  async getProfile(handle) {
+    return this.get(ENDPOINTS.profile(handle));
   }
-}
-function deleteToken() {
-  const file = tokenPath();
-  try {
-    fs.unlinkSync(file);
-  } catch {
+  /** GET /v1/u/:handle/heatmap?range=30d — used to derive the current streak. */
+  async getHeatmap(handle) {
+    return this.get(ENDPOINTS.profileHeatmap(handle));
+  }
+  /** GET /v1/trending?range — global public leaderboard, used to derive rank. */
+  async getTrending(range = "30d") {
+    return this.get(`${ENDPOINTS.trending}?range=${range}`);
+  }
+  /** GET /v1/me/devices */
+  async getDevices() {
+    return this.get(ENDPOINTS.meDevices);
+  }
+  /** POST /v1/me/devices/heartbeat */
+  async heartbeat() {
+    return this.post(ENDPOINTS.meDeviceHeartbeat, {});
   }
-}
-function isLoggedIn() {
-  return loadToken() !== null;
-}
-
-// src/lib/log.ts
-var ESC = "\x1B";
-var c = {
-  reset: `${ESC}[0m`,
-  bold: `${ESC}[1m`,
-  dim: `${ESC}[2m`,
-  green: `${ESC}[32m`,
-  yellow: `${ESC}[33m`,
-  cyan: `${ESC}[36m`,
-  red: `${ESC}[31m`,
-  gray: `${ESC}[90m`
 };
-function strip(s) {
-  return s.replace(/\x1b\[[0-9;]*m/g, "");
-}
-function isTTY() {
-  return process.stdout.isTTY === true;
-}
-function color(code, text) {
-  return isTTY() ? `${code}${text}${c.reset}` : strip(text);
-}
-function info(msg) {
-  console.log(color(c.cyan, `  ${msg}`));
-}
-function success(msg) {
-  console.log(color(c.green, `\u2713 ${msg}`));
-}
-function warn(msg) {
-  console.warn(color(c.yellow, `\u26A0 ${msg}`));
-}
-function error(msg) {
-  console.error(color(c.red, `\u2717 ${msg}`));
-}
-function dim(msg) {
-  console.log(color(c.dim, `  ${msg}`));
-}
-function spinner(label) {
-  if (!isTTY()) {
-    process.stdout.write(`  ${label}...
-`);
-    return {
-      stop(finalMsg) {
-        if (finalMsg) process.stdout.write(`  ${finalMsg}
-`);
-      }
-    };
+
+// package.json
+var package_default = {
+  name: "token-rats",
+  version: "0.3.0",
+  description: "Track Claude Code, Codex, and Cursor usage and compare AI subscriptions.",
+  license: "MIT",
+  type: "module",
+  bin: {
+    "token-rats": "./dist/index.js"
+  },
+  files: ["dist", "README.md", "LICENSE"],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hsalberti/token-rats.git",
+    directory: "packages/cli"
+  },
+  homepage: "https://tokenrats.com",
+  keywords: ["claude", "claude-code", "cursor", "tokens", "leaderboard", "ai-usage"],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsc --noEmit -p tsconfig.json && node build.mjs",
+    typecheck: "tsc --noEmit",
+    dev: "tsx src/index.ts",
+    test: "vitest run",
+    prepublishOnly: "node build.mjs"
+  },
+  optionalDependencies: {
+    clipboardy: "^4.0.0",
+    open: "^10.1.0"
+  },
+  devDependencies: {
+    "@token-rats/contracts": "workspace:*",
+    "@token-rats/parsers": "workspace:*",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "22.10.2",
+    "@types/sql.js": "^1.4.11",
+    esbuild: "^0.24.2",
+    tsx: "4.19.2",
+    typescript: "5.7.2",
+    vitest: "2.1.8"
+  },
+  dependencies: {
+    "sql.js": "^1.14.1"
   }
-  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  let i = 0;
-  const interval = setInterval(() => {
-    process.stdout.write(`\r${c.cyan}${frames[i++ % frames.length]}${c.reset} ${label}   `);
-  }, 80);
-  return {
-    stop(finalMsg) {
-      clearInterval(interval);
-      process.stdout.write("\r\x1B[K");
-      if (finalMsg) success(finalMsg);
-    }
-  };
-}
+};
+
+// src/lib/cli-version.ts
+var CLI_VERSION = package_default.version;
 
 // src/commands/login.ts
 async function openBrowser(url) {
@@ -4768,12 +5315,12 @@ async function openBrowser(url) {
   } catch {
   }
   try {
-    const { execFile } = await import("node:child_process");
-    const { promisify } = await import("node:util");
-    const exec = promisify(execFile);
+    const { execFile: execFile2 } = await import("node:child_process");
+    const { promisify: promisify2 } = await import("node:util");
+    const exec2 = promisify2(execFile2);
     const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
     const args = process.platform === "win32" ? ["/c", "start", url] : [url];
-    await exec(cmd, args).catch(() => null);
+    await exec2(cmd, args).catch(() => null);
   } catch {
   }
 }
@@ -4789,7 +5336,12 @@ async function copyToClipboard(text) {
   return false;
 }
 async function loginCommand(opts) {
-  const client = new ApiClient({ apiUrl: opts.apiUrl });
+  const deviceId = ensureDeviceId();
+  const client = new ApiClient({
+    apiUrl: opts.apiUrl,
+    deviceId,
+    cliVersion: CLI_VERSION
+  });
   info("Authenticating with Token Rats\u2026");
   let exchange;
   try {
@@ -4837,7 +5389,16 @@ async function loginCommand(opts) {
     process.exit(1);
   }
   saveToken(token);
+  clearDisconnected();
   success("Logged in! Run `token-rats whoami` to verify.");
+  dim(`Device id: ${deviceId}`);
+  if (opts.noDaemon) {
+    info("Skipping background watcher install (--no-daemon).");
+    info("Run `token-rats sync` manually whenever you want to upload usage.");
+    return;
+  }
+  info("Installing background watcher so usage uploads automatically\u2026");
+  await installDaemonCommand(opts.apiUrl);
 }
 
 // src/commands/logout.ts
@@ -4850,9 +5411,9 @@ function logoutCommand() {
   info("Logged out. Your local token has been removed.");
 }
 
-// src/commands/sync.ts
-import * as fs7 from "node:fs";
-import * as readline from "node:readline/promises";
+// src/lib/collect.ts
+import { createHash } from "node:crypto";
+import * as fs4 from "node:fs";
 
 // ../parsers/src/hash.ts
 var FNV_PRIME = 16777619;
@@ -4884,6 +5445,7 @@ function parseClaudeCode(input) {
     text = new TextDecoder().decode(input instanceof ArrayBuffer ? new Uint8Array(input) : input);
   }
   const sessions = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
   for (const rawLine of text.split("\n")) {
     const line = rawLine.trim();
     if (line.length === 0) continue;
@@ -4917,7 +5479,8 @@ function parseClaudeCode(input) {
         outTokens: 0,
         cacheReadTokens: 0,
         cacheWriteTokens: 0,
-        model: ""
+        model: "",
+        modelAt: 0
       };
       sessions.set(sessionId, acc);
     }
@@ -4929,16 +5492,32 @@ function parseClaudeCode(input) {
     const message = ev.message;
     if (typeof message !== "object" || message === null) continue;
     const msg = message;
-    if (typeof msg.model === "string" && msg.model.length > 0) {
+    if (typeof msg.model === "string" && msg.model.length > 0 && timestamp >= acc.modelAt) {
       acc.model = msg.model;
+      acc.modelAt = timestamp;
     }
     const usage = msg.usage;
     if (typeof usage === "object" && usage !== null) {
       const u = usage;
-      acc.inTokens += toNonNegInt(u.input_tokens);
-      acc.outTokens += toNonNegInt(u.output_tokens);
-      acc.cacheReadTokens += toNonNegInt(u.cache_read_input_tokens);
-      acc.cacheWriteTokens += toNonNegInt(u.cache_creation_input_tokens);
+      const counts = {
+        input: toNonNegInt(u.input_tokens),
+        output: toNonNegInt(u.output_tokens),
+        read: toNonNegInt(u.cache_read_input_tokens),
+        write: toNonNegInt(u.cache_creation_input_tokens)
+      };
+      const key = typeof msg.id === "string" ? `${sessionId}:${msg.id}` : null;
+      const old = key ? messages.get(key) : void 0;
+      const next = {
+        input: Math.max(old?.input ?? 0, counts.input),
+        output: Math.max(old?.output ?? 0, counts.output),
+        read: Math.max(old?.read ?? 0, counts.read),
+        write: Math.max(old?.write ?? 0, counts.write)
+      };
+      acc.inTokens += next.input - (old?.input ?? 0);
+      acc.outTokens += next.output - (old?.output ?? 0);
+      acc.cacheReadTokens += next.read - (old?.read ?? 0);
+      acc.cacheWriteTokens += next.write - (old?.write ?? 0);
+      if (key) messages.set(key, next);
     }
   }
   const results = [];
@@ -4959,6 +5538,8 @@ function parseClaudeCode(input) {
       id: `claude-code:${acc.sessionId}`,
       source: "claude-code",
       provider: "anthropic",
+      client: "claude-code",
+      channel: "cli",
       model,
       inTokens: acc.inTokens,
       outTokens: acc.outTokens,
@@ -5003,10 +5584,16 @@ function parseCodex(input) {
     const payload = typeof ev.payload === "object" && ev.payload !== null ? ev.payload : null;
     if (type === "session_meta" && payload) {
       const id = typeof payload.id === "string" ? payload.id : null;
-      if (!id) continue;
+      if (!id) {
+        currentSessionId = null;
+        continue;
+      }
       currentSessionId = id;
       const metaTs = parseTimestamp(payload.timestamp) || ts;
       const acc2 = upsert(sessions, id);
+      const metaSource = typeof payload.source === "string" ? payload.source : null;
+      acc2.channel = metaSource === "api" ? "api" : metaSource ? "cli" : "unknown";
+      acc2.client = acc2.channel === "cli" ? "codex-cli" : "codex";
       if (metaTs > 0 && (acc2.startedAt === 0 || metaTs < acc2.startedAt)) {
         acc2.startedAt = metaTs;
       }
@@ -5020,7 +5607,10 @@ function parseCodex(input) {
       if (ts > acc.endedAt) acc.endedAt = ts;
     }
     if (type === "turn_context" && payload && typeof payload.model === "string") {
-      acc.model = payload.model;
+      if (ts >= acc.modelAt) {
+        acc.model = payload.model;
+        acc.modelAt = ts;
+      }
       continue;
     }
     if (type === "event_msg" && payload && payload.type === "token_count") {
@@ -5033,8 +5623,10 @@ function parseCodex(input) {
       const cachedInput = toNonNegInt2(t.cached_input_tokens);
       const output = toNonNegInt2(t.output_tokens);
       const reasoning = toNonNegInt2(t.reasoning_output_tokens);
+      if (ts < acc.usageAt) continue;
+      acc.usageAt = ts;
       acc.inTokens = Math.max(0, inputTotal - cachedInput);
-      acc.outTokens = output + reasoning;
+      acc.outTokens = output;
       acc.cacheReadTokens = cachedInput;
       acc.reasoningTokens = reasoning;
     }
@@ -5051,6 +5643,8 @@ function parseCodex(input) {
       id: `codex:${acc.sessionId}`,
       source: "codex",
       provider: "openai",
+      client: acc.client || "codex-cli",
+      channel: acc.channel,
       model,
       inTokens: acc.inTokens,
       outTokens: acc.outTokens,
@@ -5075,7 +5669,11 @@ function upsert(map, sessionId) {
       outTokens: 0,
       cacheReadTokens: 0,
       reasoningTokens: 0,
-      model: ""
+      model: "",
+      usageAt: 0,
+      modelAt: 0,
+      client: "codex-cli",
+      channel: "unknown"
     };
     map.set(sessionId, acc);
   }
@@ -5132,6 +5730,8 @@ function parseCursor(input) {
       id: `cursor:${id}`,
       source: "cursor",
       provider: "cursor",
+      client: "cursor",
+      channel: "ide",
       model,
       inTokens,
       outTokens,
@@ -5145,31 +5745,31 @@ function parseCursor(input) {
 }
 
 // src/lib/cursor-extract.ts
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync as existsSync3, readdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
 function cursorWorkspaceStorageDir() {
-  const home = homedir2();
-  const rel = join2("Cursor", "User", "workspaceStorage");
+  const home = homedir3();
+  const rel = join3("Cursor", "User", "workspaceStorage");
   if (process.platform === "darwin") {
-    return join2(home, "Library", "Application Support", rel);
+    return join3(home, "Library", "Application Support", rel);
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? join2(home, "AppData", "Roaming");
-    return join2(appData, rel);
+    const appData = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
+    return join3(appData, rel);
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join2(home, ".config");
-  return join2(xdgConfig, rel);
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join3(home, ".config");
+  return join3(xdgConfig, rel);
 }
 function discoverWorkspaceDbs() {
   const root = cursorWorkspaceStorageDir();
-  if (!existsSync(root)) return [];
+  if (!existsSync3(root)) return [];
   const out = [];
   for (const entry of readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const candidate = join2(root, entry.name, "state.vscdb");
-    if (existsSync(candidate)) out.push(candidate);
+    const candidate = join3(root, entry.name, "state.vscdb");
+    if (existsSync3(candidate)) out.push(candidate);
   }
   return out;
 }
@@ -5272,7 +5872,7 @@ async function extractCursorGenerations() {
       dbCount: 0
     };
   }
-  const seen2 = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
   const rows = [];
   let openFailures = 0;
   for (const p of dbPaths) {
@@ -5284,8 +5884,8 @@ async function extractCursorGenerations() {
       continue;
     }
     for (const r of perDb) {
-      if (seen2.has(r.id)) continue;
-      seen2.add(r.id);
+      if (seen.has(r.id)) continue;
+      seen.add(r.id);
       rows.push(r);
     }
   }
@@ -5298,373 +5898,17 @@ async function extractCursorGenerations() {
   }
   return { rows, dbCount: dbPaths.length, skipped: null };
 }
-async function extractCursorGenerationsDelta(lastMtimes, cap = 10) {
-  const dbPaths = discoverWorkspaceDbs();
-  if (dbPaths.length === 0) {
-    return { rows: [], newMtimes: /* @__PURE__ */ new Map(), scanned: 0, opened: 0 };
-  }
-  const stamped = [];
-  for (const p of dbPaths) {
-    try {
-      stamped.push({ path: p, mtimeMs: statSync(p).mtimeMs });
-    } catch {
-    }
-  }
-  stamped.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  const head = stamped.slice(0, cap);
-  const newMtimes = new Map(lastMtimes);
-  const rows = [];
-  let opened = 0;
-  for (const { path: path7, mtimeMs } of head) {
-    const prev = lastMtimes.get(path7) ?? 0;
-    if (mtimeMs <= prev) continue;
-    opened++;
-    try {
-      const perDb = await readGenerationsFromDb(path7);
-      rows.push(...perDb);
-      newMtimes.set(path7, mtimeMs);
-    } catch {
-    }
-  }
-  return { rows, newMtimes, scanned: stamped.length, opened };
-}
 
-// src/lib/daemon/linux.ts
-import { spawnSync } from "node:child_process";
+// src/lib/discover.ts
 import * as fs3 from "node:fs";
 import * as os3 from "node:os";
 import * as path3 from "node:path";
-
-// src/lib/daemon/paths.ts
-import * as fs2 from "node:fs";
-import * as os2 from "node:os";
-import * as path2 from "node:path";
-function configBase() {
-  if (process.platform === "darwin") {
-    return path2.join(os2.homedir(), "Library", "Application Support");
-  }
-  const xdg = process.env.XDG_CONFIG_HOME;
-  return xdg ?? path2.join(os2.homedir(), ".config");
-}
-function daemonStateDir() {
-  return path2.join(configBase(), "token-rats");
-}
-function daemonLogDir() {
-  return path2.join(daemonStateDir(), "logs");
-}
-function daemonStateFile() {
-  return path2.join(daemonStateDir(), "daemon-state.json");
-}
-function cliEntrypoint() {
-  const node = process.execPath;
-  const script = fs2.realpathSync(process.argv[1] ?? "");
-  return { node, script };
-}
-function entrypointIsEphemeral() {
-  const { script } = cliEntrypoint();
-  return script.includes("_npx") || script.includes(".npm/_cacache");
-}
-function ensureDaemonDirs() {
-  fs2.mkdirSync(daemonStateDir(), { recursive: true });
-  fs2.mkdirSync(daemonLogDir(), { recursive: true });
-}
-
-// src/lib/daemon/linux.ts
-var UNIT = "token-rats-watch.service";
-function unitPath() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path3.join(os3.homedir(), ".config");
-  return path3.join(xdg, "systemd", "user", UNIT);
-}
-function renderUnit(node, script, logDir) {
-  return `[Unit]
-Description=Token Rats background watcher
-After=default.target
-
-[Service]
-Type=simple
-ExecStart=${node} ${script} watch --daemon
-Restart=on-failure
-RestartSec=30
-StandardOutput=append:${path3.join(logDir, "watch.log")}
-StandardError=append:${path3.join(logDir, "watch.err.log")}
-Nice=10
-
-[Install]
-WantedBy=default.target
-`;
-}
-function systemctl(args) {
-  const r = spawnSync("systemctl", ["--user", ...args], { encoding: "utf8" });
-  return {
-    ok: r.status === 0,
-    stdout: r.stdout ?? "",
-    stderr: r.stderr ?? ""
-  };
-}
-var SystemdUnavailableError = class extends Error {
-  constructor() {
-    super("systemctl --user is unavailable on this system");
-    this.name = "SystemdUnavailableError";
-  }
-};
-function assertSystemd() {
-  const r = spawnSync("systemctl", ["--user", "--version"], { encoding: "utf8" });
-  if (r.status !== 0) throw new SystemdUnavailableError();
-}
-function lingerEnabled() {
-  const user = os3.userInfo().username;
-  const r = spawnSync("loginctl", ["show-user", user], { encoding: "utf8" });
-  if (r.status !== 0) return false;
-  return /Linger=yes/.test(r.stdout);
-}
-function installLinux(node, script) {
-  assertSystemd();
-  ensureDaemonDirs();
-  const file = unitPath();
-  fs3.mkdirSync(path3.dirname(file), { recursive: true });
-  const logDir = daemonLogDir();
-  fs3.writeFileSync(file, renderUnit(node, script, logDir), { encoding: "utf8", mode: 420 });
-  const reload = systemctl(["daemon-reload"]);
-  if (!reload.ok) {
-    throw new Error(`systemctl daemon-reload failed: ${reload.stderr.trim()}`);
-  }
-  const enable = systemctl(["enable", "--now", UNIT]);
-  if (!enable.ok) {
-    throw new Error(`systemctl enable --now failed: ${enable.stderr.trim()}`);
-  }
-  return { unit: file, logDir };
-}
-function uninstallLinux() {
-  systemctl(["disable", "--now", UNIT]);
-  try {
-    fs3.rmSync(unitPath());
-  } catch {
-  }
-  systemctl(["daemon-reload"]);
-}
-function statusLinux() {
-  const installed = fs3.existsSync(unitPath());
-  if (!installed) return { installed: false, running: false };
-  const r = systemctl(["show", UNIT, "--property=ActiveState,MainPID"]);
-  const active = /ActiveState=active/.test(r.stdout);
-  const pidMatch = r.stdout.match(/MainPID=(\d+)/);
-  const pid = pidMatch?.[1] ? Number(pidMatch[1]) : void 0;
-  return {
-    installed: true,
-    running: active && pid !== void 0 && pid > 0,
-    ...pid && pid > 0 ? { pid } : {}
-  };
-}
-
-// src/lib/daemon/macos.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import * as fs4 from "node:fs";
-import * as os4 from "node:os";
-import * as path4 from "node:path";
-var LABEL = "com.tokenrats.watch";
-function plistPath() {
-  return path4.join(os4.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
-}
-function xmlEscape(s) {
-  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
-}
-function renderPlist(node, script, logDir) {
-  const stdout = xmlEscape(path4.join(logDir, "watch.log"));
-  const stderr = xmlEscape(path4.join(logDir, "watch.err.log"));
-  return `<?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>${xmlEscape(node)}</string>
-    <string>${xmlEscape(script)}</string>
-    <string>watch</string>
-    <string>--daemon</string>
-  </array>
-  <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key>
-  <dict>
-    <key>SuccessfulExit</key><false/>
-    <key>Crashed</key><true/>
-  </dict>
-  <key>ThrottleInterval</key><integer>30</integer>
-  <key>StandardOutPath</key><string>${stdout}</string>
-  <key>StandardErrorPath</key><string>${stderr}</string>
-  <key>ProcessType</key><string>Background</string>
-</dict>
-</plist>
-`;
-}
-function uid() {
-  const fn = process.getuid;
-  if (typeof fn !== "function") throw new Error("process.getuid unavailable");
-  return fn();
-}
-function launchctl(args) {
-  const r = spawnSync2("launchctl", args, { encoding: "utf8" });
-  return {
-    ok: r.status === 0,
-    stdout: r.stdout ?? "",
-    stderr: r.stderr ?? ""
-  };
-}
-function installMacos(node, script) {
-  ensureDaemonDirs();
-  const dir = path4.dirname(plistPath());
-  fs4.mkdirSync(dir, { recursive: true });
-  const logDir = daemonLogDir();
-  const file = plistPath();
-  fs4.writeFileSync(file, renderPlist(node, script, logDir), { encoding: "utf8", mode: 420 });
-  const target = `gui/${uid()}`;
-  launchctl(["bootout", target, file]);
-  const r = launchctl(["bootstrap", target, file]);
-  if (!r.ok) {
-    throw new Error(`launchctl bootstrap failed: ${r.stderr.trim() || r.stdout.trim()}`);
-  }
-  launchctl(["kickstart", "-k", `${target}/${LABEL}`]);
-  return { plist: file, logDir };
-}
-function uninstallMacos() {
-  const file = plistPath();
-  const target = `gui/${uid()}`;
-  launchctl(["bootout", target, file]);
-  try {
-    fs4.rmSync(file);
-  } catch {
-  }
-}
-function statusMacos() {
-  const file = plistPath();
-  const installed = fs4.existsSync(file);
-  if (!installed) return { installed: false, running: false };
-  const r = launchctl(["print", `gui/${uid()}/${LABEL}`]);
-  const match = r.stdout.match(/\bpid\s*=\s*(\d+)/);
-  if (match?.[1]) return { installed: true, running: true, pid: Number(match[1]) };
-  return { installed: true, running: false };
-}
-
-// src/lib/daemon/state.ts
-import * as fs5 from "node:fs";
-function readDaemonState() {
-  try {
-    const raw = fs5.readFileSync(daemonStateFile(), "utf8");
-    const parsed = JSON.parse(raw);
-    return typeof parsed === "object" && parsed !== null ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function writeDaemonState(state) {
-  ensureDaemonDirs();
-  fs5.writeFileSync(daemonStateFile(), `${JSON.stringify(state, null, 2)}
-`, {
-    encoding: "utf8",
-    mode: 384
-  });
-}
-function markDeclined() {
-  const s = readDaemonState();
-  s.declinedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeDaemonState(s);
-}
-function markInstalled(method, script, version) {
-  const s = readDaemonState();
-  s.installedAt = (/* @__PURE__ */ new Date()).toISOString();
-  s.installedScript = script;
-  s.method = method;
-  s.cliVersion = version;
-  s.declinedAt = void 0;
-  writeDaemonState(s);
-}
-function markUninstalled() {
-  const s = readDaemonState();
-  s.method = "none";
-  s.installedAt = void 0;
-  s.installedScript = void 0;
-  writeDaemonState(s);
-}
-
-// src/lib/daemon/install.ts
-function platformMethod() {
-  if (process.platform === "darwin") return "launchd";
-  if (process.platform === "linux") return "systemd";
-  return "unsupported";
-}
-function isDaemonSupported() {
-  return platformMethod() !== "unsupported";
-}
-var DaemonUnsupportedError = class extends Error {
-  constructor(platform) {
-    super(`Background daemon is not yet supported on ${platform}`);
-    this.name = "DaemonUnsupportedError";
-  }
-};
-async function installDaemon(version) {
-  const method = platformMethod();
-  const { node, script } = cliEntrypoint();
-  const ephemeralWarning = entrypointIsEphemeral();
-  if (method === "launchd") {
-    const r = installMacos(node, script);
-    markInstalled("launchd", script, version);
-    return { method: "launchd", logDir: r.logDir, ephemeralWarning };
-  }
-  if (method === "systemd") {
-    try {
-      const r = installLinux(node, script);
-      markInstalled("systemd", script, version);
-      return {
-        method: "systemd",
-        logDir: r.logDir,
-        ephemeralWarning,
-        lingerSet: lingerEnabled()
-      };
-    } catch (err) {
-      if (err instanceof SystemdUnavailableError) {
-        throw new DaemonUnsupportedError(process.platform);
-      }
-      throw err;
-    }
-  }
-  throw new DaemonUnsupportedError(process.platform);
-}
-async function uninstallDaemon() {
-  const method = platformMethod();
-  if (method === "launchd") uninstallMacos();
-  else if (method === "systemd") uninstallLinux();
-  markUninstalled();
-}
-async function daemonStatus() {
-  const method = platformMethod();
-  const state = readDaemonState();
-  const base = {
-    method,
-    installedScript: state.installedScript,
-    installedAt: state.installedAt,
-    declinedAt: state.declinedAt
-  };
-  if (method === "launchd") {
-    const s = statusMacos();
-    return { ...base, installed: s.installed, running: s.running, ...s.pid && { pid: s.pid } };
-  }
-  if (method === "systemd") {
-    const s = statusLinux();
-    return { ...base, installed: s.installed, running: s.running, ...s.pid && { pid: s.pid } };
-  }
-  return { ...base, installed: false, running: false };
-}
-
-// src/lib/discover.ts
-import * as fs6 from "node:fs";
-import * as os5 from "node:os";
-import * as path5 from "node:path";
 function findJsonlFiles(dir) {
   const results = [];
-  if (!fs6.existsSync(dir)) return results;
-  const entries = fs6.readdirSync(dir, { withFileTypes: true });
+  if (!fs3.existsSync(dir)) return results;
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path5.join(dir, entry.name);
+    const full = path3.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...findJsonlFiles(full));
     } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -5674,43 +5918,50 @@ function findJsonlFiles(dir) {
   return results;
 }
 function claudeCodeProjectsDir() {
-  const home = os5.homedir();
+  const home = os3.homedir();
+  if (process.env.CLAUDE_CONFIG_DIR) return path3.join(process.env.CLAUDE_CONFIG_DIR, "projects");
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
-    return path5.join(profile, ".claude", "projects");
+    return path3.join(profile, ".claude", "projects");
   }
-  return path5.join(home, ".claude", "projects");
+  return path3.join(home, ".claude", "projects");
 }
 function discoverClaudeCodeFiles() {
   const dir = claudeCodeProjectsDir();
   return findJsonlFiles(dir);
 }
 function codexSessionsDirs() {
-  const home = os5.homedir();
+  const home = os3.homedir();
   const candidates = [];
+  if (process.env.CODEX_HOME) {
+    candidates.push(path3.join(process.env.CODEX_HOME, "sessions"));
+    candidates.push(path3.join(process.env.CODEX_HOME, "archived_sessions"));
+  }
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
-    candidates.push(path5.join(profile, ".codex", "sessions"));
-    const appData = process.env.APPDATA ?? path5.join(profile, "AppData", "Roaming");
-    candidates.push(path5.join(appData, "Codex", "sessions"));
+    candidates.push(path3.join(profile, ".codex", "sessions"));
+    candidates.push(path3.join(profile, ".codex", "archived_sessions"));
+    const appData = process.env.APPDATA ?? path3.join(profile, "AppData", "Roaming");
+    candidates.push(path3.join(appData, "Codex", "sessions"));
   } else {
-    candidates.push(path5.join(home, ".codex", "sessions"));
-    const snapRoot = path5.join(home, "snap", "codex");
-    if (fs6.existsSync(snapRoot)) {
-      for (const entry of fs6.readdirSync(snapRoot, { withFileTypes: true })) {
+    candidates.push(path3.join(home, ".codex", "sessions"));
+    candidates.push(path3.join(home, ".codex", "archived_sessions"));
+    const snapRoot = path3.join(home, "snap", "codex");
+    if (fs3.existsSync(snapRoot)) {
+      for (const entry of fs3.readdirSync(snapRoot, { withFileTypes: true })) {
         if (entry.isDirectory()) {
-          candidates.push(path5.join(snapRoot, entry.name, "sessions"));
+          candidates.push(path3.join(snapRoot, entry.name, "sessions"));
         }
       }
     }
   }
-  const seen2 = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
   const dirs = [];
   for (const c2 of candidates) {
     try {
-      const real = fs6.existsSync(c2) ? fs6.realpathSync(c2) : null;
-      if (real && !seen2.has(real)) {
-        seen2.add(real);
+      const real = fs3.existsSync(c2) ? fs3.realpathSync(c2) : null;
+      if (real && !seen.has(real)) {
+        seen.add(real);
         dirs.push(c2);
       }
     } catch {
@@ -5726,11 +5977,126 @@ function discoverCodexFiles() {
   return out;
 }
 
-// src/lib/version.ts
-var CLI_VERSION = "0.1.0";
+// src/lib/collect.ts
+async function collectSessions() {
+  function read(files) {
+    return files.map((file) => fs4.readFileSync(file, "utf8")).join("\n");
+  }
+  const claude = parseClaudeCode(read(discoverClaudeCodeFiles()));
+  const codex = parseCodex(read(discoverCodexFiles()));
+  const { rows } = await extractCursorGenerations();
+  const cursor = parseCursor(JSON.stringify(rows));
+  return [...claude, ...codex, ...cursor].map((record) => ({
+    ...record,
+    accountingVersion: 2,
+    dedupeKey: createHash("sha256").update(
+      JSON.stringify([
+        record.id,
+        record.source,
+        record.model,
+        record.startedAt,
+        record.inTokens,
+        record.outTokens,
+        record.cacheReadTokens ?? 0,
+        record.cacheWriteTokens ?? 0,
+        record.reasoningTokens ?? 0
+      ])
+    ).digest("hex")
+  }));
+}
+var SyncQueue = class {
+  acknowledged = /* @__PURE__ */ new Map();
+  async flush(records, upload) {
+    const fresh = records.filter((r) => this.acknowledged.get(r.id) !== JSON.stringify(r));
+    for (let i = 0; i < fresh.length; i += 90) {
+      const batch = fresh.slice(i, i + 90);
+      await upload(batch);
+      for (const record of batch) this.acknowledged.set(record.id, JSON.stringify(record));
+    }
+    return fresh.length;
+  }
+};
+function createCollector() {
+  let signature = "";
+  let records = [];
+  return async () => {
+    const files = [
+      ...discoverClaudeCodeFiles(),
+      ...discoverCodexFiles(),
+      ...discoverWorkspaceDbs().flatMap((file) => [file, `${file}-wal`])
+    ].sort();
+    const next = JSON.stringify(
+      files.map((file) => {
+        try {
+          const stat = fs4.statSync(file);
+          return [file, stat.size, stat.mtimeMs];
+        } catch {
+          return [file, null];
+        }
+      })
+    );
+    if (next !== signature) {
+      records = await collectSessions();
+      signature = next;
+    }
+    return records;
+  };
+}
 
 // src/commands/sync.ts
-var BATCH_SIZE = 500;
+var BATCH_SIZE = 90;
+var WEB_ORIGIN = "https://tokenrats.com";
+function currentStreakFromDays(days, todayUtc) {
+  const active = days.slice().sort();
+  if (active.length === 0) return 0;
+  const last = active[active.length - 1];
+  const yesterday = (() => {
+    const d = /* @__PURE__ */ new Date(`${todayUtc}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() - 1);
+    return d.toISOString().slice(0, 10);
+  })();
+  if (last !== todayUtc && last !== yesterday) return 0;
+  let streak = 1;
+  for (let i = active.length - 1; i >= 1; i--) {
+    const prev = (/* @__PURE__ */ new Date(`${active[i - 1]}T00:00:00Z`)).getTime();
+    const curr = (/* @__PURE__ */ new Date(`${active[i]}T00:00:00Z`)).getTime();
+    if (Math.round((curr - prev) / 864e5) === 1) streak++;
+    else break;
+  }
+  return streak;
+}
+async function printSyncHero(client) {
+  let handle;
+  try {
+    const me = await client.getMe();
+    handle = me.user.handle;
+  } catch {
+    return;
+  }
+  const todayUtc = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const [trending, heatmap] = await Promise.all([
+    client.getTrending("30d").catch(() => null),
+    client.getHeatmap(handle).catch(() => null)
+  ]);
+  const rank = trending?.rows.find((r) => r.handle === handle)?.rank ?? null;
+  const streak = heatmap === null ? 0 : currentStreakFromDays(
+    heatmap.heatmap.days.filter((d) => d.sessions > 0).map((d) => d.day),
+    todayUtc
+  );
+  const profileUrl = `${WEB_ORIGIN}/u/${handle}`;
+  console.log("");
+  bold("\u{1F400} Your Token Rats standing");
+  if (rank !== null) info(`Global rank: #${rank}`);
+  if (streak > 0) info(`Current streak: ${streak} day${streak === 1 ? "" : "s"} \u{1F525}`);
+  info(`Profile: ${profileUrl}`);
+  const rankPart = rank !== null ? `ranked #${rank} globally` : "on the board";
+  const streakPart = streak > 0 ? ` on a ${streak}-day streak` : "";
+  const tweet = `I'm ${rankPart}${streakPart} on @tokenrats \u2014 tracking my AI coding tokens. \u{1F400}`;
+  const intent = `https://x.com/intent/tweet?text=${encodeURIComponent(tweet)}&url=${encodeURIComponent(profileUrl)}`;
+  console.log("");
+  dim("Brag about it \u2014 Post to X:");
+  console.log(`  ${process.stdout.isTTY ? `${c.cyan}${intent}${c.reset}` : intent}`);
+}
 function chunk(arr, size) {
   const chunks = [];
   for (let i = 0; i < arr.length; i += size) {
@@ -5738,127 +6104,20 @@ function chunk(arr, size) {
   }
   return chunks;
 }
-function mergeBySessionId(records) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const r of records) {
-    const existing = byId.get(r.id);
-    if (!existing) {
-      byId.set(r.id, { ...r });
-      continue;
-    }
-    existing.inTokens += r.inTokens;
-    existing.outTokens += r.outTokens;
-    if (r.startedAt < existing.startedAt) existing.startedAt = r.startedAt;
-    if (r.endedAt > existing.endedAt) {
-      existing.endedAt = r.endedAt;
-      existing.model = r.model;
-    }
-  }
-  for (const rec of byId.values()) {
-    rec.costUsdCents = 0;
-    rec.dedupeKey = computeDedupeKey(
-      rec.source,
-      rec.model,
-      rec.startedAt,
-      rec.inTokens,
-      rec.outTokens
-    );
-  }
-  return Array.from(byId.values());
-}
 async function syncCommand(opts) {
   const token = loadToken();
   if (!token && !opts.dryRun) {
     error("Not logged in. Run `token-rats login` first.");
     process.exit(1);
   }
-  const client = opts.dryRun ? null : new ApiClient({ apiUrl: opts.apiUrl, token: token ?? void 0 });
-  const claudeFiles = discoverClaudeCodeFiles();
-  if (opts.verbose) {
-    info(`Found ${claudeFiles.length} Claude Code file(s) in ~/.claude/projects/`);
-    for (const f of claudeFiles) dim(`  ${f}`);
-  }
-  const claudeSessions = [];
-  for (const file of claudeFiles) {
-    let text;
-    try {
-      text = fs7.readFileSync(file, "utf8");
-    } catch {
-      if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
-      continue;
-    }
-    try {
-      const records = parseClaudeCode(text);
-      claudeSessions.push(...records);
-      if (opts.verbose) dim(`  ${file}: ${records.length} session(s)`);
-    } catch {
-      if (opts.verbose) warn(`Failed to parse ${file} \u2014 skipping`);
-    }
-  }
-  const codexFiles = discoverCodexFiles();
-  if (opts.verbose) {
-    info(`Found ${codexFiles.length} Codex rollout file(s)`);
-    for (const f of codexFiles) dim(`  ${f}`);
-  }
-  const codexSessions = [];
-  for (const file of codexFiles) {
-    let text;
-    try {
-      text = fs7.readFileSync(file, "utf8");
-    } catch {
-      if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
-      continue;
-    }
-    try {
-      const records = parseCodex(text);
-      codexSessions.push(...records);
-      if (opts.verbose) dim(`  ${file}: ${records.length} session(s)`);
-    } catch {
-      if (opts.verbose) warn(`Failed to parse ${file} \u2014 skipping`);
-    }
-  }
-  const cursorSessions = [];
-  const { rows, skipped, dbCount } = await extractCursorGenerations();
-  if (skipped) {
-    warn(skipped);
-  } else if (dbCount === 0) {
-    if (opts.verbose) info("No Cursor workspace storage found \u2014 skipping Cursor source");
-  } else if (rows.length > 0) {
-    if (opts.verbose) info(`Scanned ${dbCount} Cursor workspace DB(s)`);
-    try {
-      const records = parseCursor(JSON.stringify(rows));
-      cursorSessions.push(...records);
-      if (opts.verbose) {
-        dim(
-          `  Cursor: ${rows.length} generation event(s) \u2192 ${records.length} session(s) (tokens estimated, see help)`
-        );
-      }
-    } catch {
-      if (opts.verbose) warn("Failed to parse Cursor rows \u2014 skipping");
-    }
-  } else if (opts.verbose) {
-    dim(`  Scanned ${dbCount} Cursor workspace DB(s): no AI generations found`);
-  }
-  const mergedClaude = mergeBySessionId(claudeSessions);
-  if (opts.verbose && mergedClaude.length !== claudeSessions.length) {
-    dim(
-      `  Merged ${claudeSessions.length} Claude Code records into ${mergedClaude.length} sessions (subagent files folded into parents)`
-    );
-  }
-  const mergedCodex = mergeBySessionId(codexSessions);
-  const seen2 = /* @__PURE__ */ new Set();
-  const allSessions = [];
-  for (const s of [...mergedClaude, ...mergedCodex, ...cursorSessions]) {
-    if (!seen2.has(s.dedupeKey)) {
-      seen2.add(s.dedupeKey);
-      allSessions.push(s);
-    }
-  }
-  const sources = [];
-  if (claudeSessions.length > 0) sources.push("Claude Code");
-  if (codexSessions.length > 0) sources.push("Codex");
-  if (cursorSessions.length > 0) sources.push("Cursor");
-  const sourceStr = sources.length > 0 ? sources.join(" + ") : "no sources";
+  const client = opts.dryRun ? null : new ApiClient({
+    apiUrl: opts.apiUrl,
+    token: token ?? void 0,
+    deviceId: ensureDeviceId(),
+    cliVersion: CLI_VERSION
+  });
+  const allSessions = await collectSessions();
+  const sourceStr = [...new Set(allSessions.map((record) => record.source))].join(" + ") || "no sources";
   if (allSessions.length === 0) {
     info(`No sessions found from ${sourceStr}.`);
     return;
@@ -5890,6 +6149,14 @@ async function syncCommand(opts) {
       totalDuplicates += res.duplicates;
     } catch (err) {
       spin.stop();
+      if (err instanceof DeviceRevokedError) {
+        markDisconnected();
+        deleteToken();
+        error(
+          "This device was disconnected from the Token Rats web UI. Run `token-rats login` to reconnect."
+        );
+        process.exit(1);
+      }
       if (err instanceof ApiError2 && err.status === 401) {
         error("Session expired. Run `token-rats login` to re-authenticate.");
         process.exit(1);
@@ -5904,459 +6171,80 @@ async function syncCommand(opts) {
   success(
     `Synced ${allSessions.length} sessions (${totalAccepted} new, ${totalDuplicates} already on server) from ${sourceStr}`
   );
-  await maybeWireDaemon(opts);
-}
-async function maybeWireDaemon(opts) {
-  if (opts.noDaemon) return;
-  if (process.env.TOKEN_RATS_NO_DAEMON === "1") return;
-  if (!isDaemonSupported()) return;
-  const status = await daemonStatus();
-  const state = readDaemonState();
-  if (status.installed) {
-    try {
-      await installDaemon(CLI_VERSION);
-      if (opts.verbose) dim("Refreshed daemon registration (self-heal).");
-    } catch (err) {
-      warn(`Could not refresh daemon: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    return;
-  }
-  if (state.declinedAt) {
-    if (opts.verbose) dim(`Daemon prompt skipped \u2014 declined on ${state.declinedAt}`);
-    return;
-  }
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return;
-  info("");
-  info("Background sync watches Claude Code + Cursor + Codex and uploads new");
-  info("sessions automatically \u2014 no more re-running `token-rats sync`.");
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  let answer;
-  try {
-    answer = (await rl.question("Install background sync? [Y/n] ")).trim().toLowerCase();
-  } finally {
-    rl.close();
-  }
-  if (answer === "n" || answer === "no") {
-    markDeclined();
-    info("Skipped. Enable later with `token-rats watch --install`.");
-    return;
-  }
   try {
-    const r = await installDaemon(CLI_VERSION);
-    success(`Background sync enabled (${r.method}). Logs: ${r.logDir}/watch.log`);
-    info("Disable any time with `token-rats watch --uninstall`.");
-    if (r.ephemeralWarning) {
-      warn(
-        "You ran sync via npx \u2014 the daemon may break when the npx cache clears.\nRun `npm i -g token-rats` for a durable install."
-      );
-    }
-    if (r.method === "systemd" && r.lingerSet === false) {
-      warn(
-        "For the watcher to survive logout, run once:\n  sudo loginctl enable-linger $USER"
-      );
-    }
-  } catch (err) {
-    error(`Install failed: ${err instanceof Error ? err.message : String(err)}`);
-    info("You can retry later with `token-rats watch --install`.");
+    await printSyncHero(client);
+  } catch {
   }
 }
 
 // src/commands/watch.ts
-import * as fs8 from "node:fs";
-import * as path6 from "node:path";
-var CURSOR_POLL_MS = 9e4;
-var CURSOR_DB_CAP = 10;
-var REAUTH_BACKOFF_MS = 10 * 60 * 1e3;
-function makeLogger(daemon, verbose) {
-  if (daemon) {
-    const emit = (level, msg, extra) => {
-      const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, ...extra });
-      process.stderr.write(`${line}
-`);
-    };
-    return {
-      info: (m, e) => emit("info", m, e),
-      warn: (m, e) => emit("warn", m, e),
-      error: (m, e) => emit("error", m, e),
-      debug: (m, e) => {
-        if (verbose) emit("debug", m, e);
-      }
-    };
-  }
-  return {
-    info: (m) => info(m),
-    warn: (m) => warn(m),
-    error: (m) => error(m),
-    debug: (m) => {
-      if (verbose) dim(m);
-    }
-  };
-}
-var seen = /* @__PURE__ */ new Set();
-var reauthBackoffUntil = 0;
-var health = {
-  startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-  uploaded: 0,
-  duplicates: 0,
-  errors: 0,
-  lastSourceAt: {}
-};
-async function upload(client, records, log, daemon) {
-  if (records.length === 0) return;
-  if (Date.now() < reauthBackoffUntil) {
-    log.debug("Skipping upload \u2014 in reauth backoff", { records: records.length });
+async function watchCommand(opts) {
+  const token = loadToken();
+  if (!token || isDisconnected()) {
+    error("Run `token-rats login` before you start the tracker.");
+    process.exitCode = 1;
     return;
   }
-  try {
-    const res = await client.uploadSessions(records);
-    health.uploaded += res.accepted;
-    health.duplicates += res.duplicates;
-    log.info("upload", { accepted: res.accepted, duplicates: res.duplicates });
-  } catch (err) {
-    health.errors++;
-    if (err instanceof ApiError2 && err.status === 401) {
-      if (daemon) {
-        reauthBackoffUntil = Date.now() + REAUTH_BACKOFF_MS;
-        log.error("Auth expired. Run `token-rats login` to recover.", {
-          backoffUntil: new Date(reauthBackoffUntil).toISOString()
-        });
-        return;
-      }
-      error("Session expired. Run `token-rats login` to re-authenticate.");
-      process.exit(1);
-    }
-    log.warn(`Upload failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-function freshClaudeRecords(filePath, log) {
-  let text;
-  try {
-    text = fs8.readFileSync(filePath, "utf8");
-  } catch {
-    log.debug(`Could not read ${filePath} \u2014 skipping`);
-    return [];
-  }
-  let records;
-  try {
-    records = parseClaudeCode(text);
-  } catch {
-    log.debug(`Failed to parse ${filePath} \u2014 skipping`);
-    return [];
-  }
-  const fresh = [];
-  for (const r of records) {
-    if (seen.has(r.dedupeKey)) continue;
-    seen.add(r.dedupeKey);
-    fresh.push(r);
-  }
-  if (fresh.length > 0) {
-    health.lastSourceAt["claude-code"] = (/* @__PURE__ */ new Date()).toISOString();
-    log.debug(`${filePath}: ${fresh.length} new Claude Code session(s)`);
-  }
-  return fresh;
-}
-function freshCodexRecords(filePath, log) {
-  let text;
-  try {
-    text = fs8.readFileSync(filePath, "utf8");
-  } catch {
-    return [];
-  }
-  let records;
-  try {
-    records = parseCodex(text);
-  } catch {
-    return [];
-  }
-  const fresh = [];
-  for (const r of records) {
-    if (seen.has(r.dedupeKey)) continue;
-    seen.add(r.dedupeKey);
-    fresh.push(r);
-  }
-  if (fresh.length > 0) {
-    health.lastSourceAt.codex = (/* @__PURE__ */ new Date()).toISOString();
-    log.debug(`${filePath}: ${fresh.length} new Codex session(s)`);
+  const interval = opts.interval ?? 3e4;
+  if (!Number.isFinite(interval) || interval < 1e3) {
+    error("The interval must be at least 1000 milliseconds.");
+    process.exitCode = 1;
+    return;
   }
-  return fresh;
-}
-function makeDebounced(fn, ms) {
-  const timers = /* @__PURE__ */ new Map();
-  return (p) => {
-    const existing = timers.get(p);
-    if (existing) clearTimeout(existing);
-    timers.set(
-      p,
-      setTimeout(() => {
-        timers.delete(p);
-        fn(p);
-      }, ms)
-    );
+  const client = new ApiClient({
+    apiUrl: opts.apiUrl,
+    token,
+    deviceId: ensureDeviceId(),
+    cliVersion: CLI_VERSION
+  });
+  const queue = new SyncQueue();
+  const collect = createCollector();
+  let stopped = false;
+  let wake;
+  const stop = () => {
+    stopped = true;
+    wake?.();
   };
-}
-function findJsonlFiles2(dir) {
-  const out = [];
-  if (!fs8.existsSync(dir)) return out;
-  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
-    const full = path6.join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...findJsonlFiles2(full));
-    else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(full);
-  }
-  return out;
-}
-async function watchJsonlDir(dir, debounceMs, onChange, log) {
-  if (!fs8.existsSync(dir)) {
-    log.debug(`Directory missing \u2014 not watching: ${dir}`);
-    return () => {
-    };
-  }
-  const debouncedChange = makeDebounced((p) => {
-    if (p.endsWith(".jsonl")) onChange(p);
-  }, debounceMs);
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  info("Tracking Claude Code, Codex, and Cursor. Press Ctrl-C to stop.");
   try {
-    const dynImport = new Function("m", "return import(m)");
-    const chokidarMod = await dynImport("chokidar");
-    const watcher = chokidarMod.watch(`${dir}/**/*.jsonl`, {
-      ignoreInitial: true,
-      persistent: true,
-      awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
-    });
-    watcher.on("add", (p) => {
-      if (typeof p === "string") debouncedChange(p);
-    });
-    watcher.on("change", (p) => {
-      if (typeof p === "string") debouncedChange(p);
-    });
-    return () => {
-      watcher.close();
-    };
-  } catch {
-  }
-  if (process.platform === "linux") {
-    let lastMtimes = /* @__PURE__ */ new Map();
-    for (const f of findJsonlFiles2(dir)) {
+    while (!stopped) {
       try {
-        lastMtimes.set(f, fs8.statSync(f).mtimeMs);
-      } catch {
-      }
-    }
-    const handle = setInterval(() => {
-      const current = findJsonlFiles2(dir);
-      for (const f of current) {
-        try {
-          const mtime = fs8.statSync(f).mtimeMs;
-          const prev = lastMtimes.get(f) ?? 0;
-          if (mtime > prev) {
-            lastMtimes.set(f, mtime);
-            debouncedChange(f);
-          }
-        } catch {
+        const count = await queue.flush(await collect(), (batch) => client.uploadSessions(batch));
+        if (count === 0) await client.uploadSessions([]);
+        await client.heartbeat();
+        if (count > 0) success(`Synced ${count} changed record(s).`);
+      } catch (err) {
+        if (err instanceof DeviceRevokedError) {
+          markDisconnected();
+          deleteToken();
+          error("Device disconnected. Run `token-rats login` to reconnect.");
+          break;
         }
-      }
-      for (const f of current) {
-        if (!lastMtimes.has(f)) {
-          lastMtimes.set(f, Date.now());
-          debouncedChange(f);
+        if (err instanceof ApiError2 && err.status === 401) {
+          error("Session expired. Run `token-rats login` again.");
+          process.exitCode = 1;
+          break;
         }
+        warn(
+          `Sync failed. The next scan will retry: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
-      lastMtimes = new Map(current.map((f) => [f, lastMtimes.get(f) ?? 0]));
-    }, debounceMs);
-    return () => clearInterval(handle);
-  }
-  const controller = new AbortController();
-  (async () => {
-    try {
-      const { watch } = await import("node:fs/promises");
-      const watcher = watch(dir, { recursive: true, signal: controller.signal });
-      for await (const event of watcher) {
-        if (event.filename?.endsWith(".jsonl")) {
-          debouncedChange(path6.join(dir, event.filename));
-        }
-      }
-    } catch (err) {
-      if (err instanceof Error && err.name !== "AbortError") {
-        log.warn(`Watcher error on ${dir}: ${err.message}`);
-      }
-    }
-  })();
-  return () => controller.abort();
-}
-function startCursorLoop(client, log, daemon) {
-  let lastMtimes = /* @__PURE__ */ new Map();
-  let running = false;
-  let stopped = false;
-  const tick = async () => {
-    if (running || stopped) return;
-    running = true;
-    try {
-      const { rows, newMtimes, scanned, opened } = await extractCursorGenerationsDelta(
-        lastMtimes,
-        CURSOR_DB_CAP
-      );
-      lastMtimes = newMtimes;
-      if (rows.length === 0) {
-        if (opened > 0) log.debug(`Cursor poll: ${scanned} DB(s), opened ${opened}, no new rows`);
-        return;
-      }
-      let records;
-      try {
-        records = parseCursor(JSON.stringify(rows));
-      } catch {
-        log.warn("Failed to parse Cursor rows");
-        return;
-      }
-      const fresh = [];
-      for (const r of records) {
-        if (seen.has(r.dedupeKey)) continue;
-        seen.add(r.dedupeKey);
-        fresh.push(r);
-      }
-      if (fresh.length === 0) {
-        log.debug(`Cursor poll: ${rows.length} row(s), all duplicates`);
-        return;
-      }
-      health.lastSourceAt.cursor = (/* @__PURE__ */ new Date()).toISOString();
-      log.debug(
-        `Cursor poll: ${fresh.length} fresh session(s) (scanned ${scanned}, opened ${opened})`
-      );
-      await upload(client, fresh, log, daemon);
-    } finally {
-      running = false;
-    }
-  };
-  const initial = setTimeout(tick, 5e3);
-  const handle = setInterval(tick, CURSOR_POLL_MS);
-  return () => {
-    stopped = true;
-    clearTimeout(initial);
-    clearInterval(handle);
-  };
-}
-async function runWatcher(opts) {
-  const daemon = opts.daemon === true;
-  const verbose = opts.verbose === true;
-  const log = makeLogger(daemon, verbose);
-  const token = loadToken();
-  if (!token) {
-    log.error("Not logged in. Run `token-rats login` first.");
-    if (!daemon) process.exit(1);
-    reauthBackoffUntil = Date.now() + REAUTH_BACKOFF_MS;
-  }
-  const client = new ApiClient({ apiUrl: opts.apiUrl, token: token ?? void 0 });
-  const debounceMs = opts.interval ?? 2e3;
-  if (!daemon) {
-    info("Watching Claude Code + Cursor + Codex");
-    info("Press Ctrl-C to stop.\n");
-  } else {
-    log.info("watch starting", { debounceMs, cursorPollMs: CURSOR_POLL_MS });
-  }
-  const ccDir = claudeCodeProjectsDir();
-  for (const f of findJsonlFiles2(ccDir)) freshClaudeRecords(f, log);
-  for (const d of codexSessionsDirs()) {
-    for (const f of findJsonlFiles2(d)) freshCodexRecords(f, log);
-  }
-  log.debug(`Seeded ${seen.size} dedupe key(s) from initial snapshot`);
-  const cleanups = [];
-  cleanups.push(
-    await watchJsonlDir(
-      ccDir,
-      debounceMs,
-      async (filePath) => {
-        const fresh = freshClaudeRecords(filePath, log);
-        await upload(client, fresh, log, daemon);
-      },
-      log
-    )
-  );
-  for (const codexDir of codexSessionsDirs()) {
-    cleanups.push(
-      await watchJsonlDir(
-        codexDir,
-        debounceMs,
-        async (filePath) => {
-          const fresh = freshCodexRecords(filePath, log);
-          await upload(client, fresh, log, daemon);
-        },
-        log
-      )
-    );
-  }
-  cleanups.push(startCursorLoop(client, log, daemon));
-  process.on("SIGUSR1", () => {
-    log.info("health", {
-      uptimeSec: Math.round(process.uptime()),
-      uploaded: health.uploaded,
-      duplicates: health.duplicates,
-      errors: health.errors,
-      lastSourceAt: health.lastSourceAt,
-      seenKeys: seen.size,
-      reauthBackoffUntil: reauthBackoffUntil > Date.now() ? new Date(reauthBackoffUntil).toISOString() : null
-    });
-  });
-  const shutdown = () => {
-    log.info("watch stopping");
-    for (const c2 of cleanups) c2();
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}
-async function handleInstall(opts) {
-  if (!isDaemonSupported()) {
-    error(`Background daemon not supported on ${process.platform} yet.`);
-    process.exit(1);
-  }
-  try {
-    const r = await installDaemon(opts.version ?? "0.0.0");
-    success(`Background watcher installed (${r.method}).`);
-    info(`Logs: ${r.logDir}/watch.log`);
-    if (r.ephemeralWarning) {
-      warn(
-        "You ran this via npx \u2014 the daemon may break when the npx cache is cleared.\nRun `npm i -g token-rats` (or `pnpm add -g token-rats`) for a durable install."
-      );
-    }
-    if (r.method === "systemd" && r.lingerSet === false) {
-      warn(
-        "For the watcher to survive logout, run once:\n  sudo loginctl enable-linger $USER\nWithout it, the watcher resumes at your next login."
-      );
+      if (stopped) break;
+      await new Promise((resolve2) => {
+        const timer = setTimeout(resolve2, interval);
+        wake = () => {
+          clearTimeout(timer);
+          resolve2();
+        };
+      });
     }
-  } catch (err) {
-    error(`Install failed: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  }
-}
-async function handleUninstall() {
-  try {
-    await uninstallDaemon();
-    success("Background watcher uninstalled.");
-  } catch (err) {
-    error(`Uninstall failed: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  }
-}
-async function handleStatus() {
-  const s = await daemonStatus();
-  if (s.method === "unsupported") {
-    info(`Daemon not supported on ${process.platform}.`);
-    return;
-  }
-  info(`Method:      ${s.method}`);
-  info(`Installed:   ${s.installed ? "yes" : "no"}`);
-  info(`Running:     ${s.running ? `yes (pid ${s.pid ?? "?"})` : "no"}`);
-  if (s.installedAt) info(`Installed at: ${s.installedAt}`);
-  if (s.installedScript) info(`Script:      ${s.installedScript}`);
-  if (s.declinedAt) info(`Declined at: ${s.declinedAt}`);
-  info(`Log dir:     ${daemonLogDir()}`);
-  if (process.platform === "linux") {
-    info(`Linger:      ${lingerEnabled() ? "yes (survives logout)" : "no (dies on logout)"}`);
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
   }
 }
-async function watchCommand(opts) {
-  if (opts.install) return handleInstall(opts);
-  if (opts.uninstall) return handleUninstall();
-  if (opts.status) return handleStatus();
-  return runWatcher(opts);
-}
 
 // src/commands/whoami.ts
 async function whoamiCommand(opts) {
@@ -6365,11 +6253,25 @@ async function whoamiCommand(opts) {
     error("Not logged in. Run `token-rats login` first.");
     process.exit(1);
   }
-  const client = new ApiClient({ apiUrl: opts.apiUrl, token });
+  const client = new ApiClient({
+    apiUrl: opts.apiUrl,
+    token,
+    deviceId: ensureDeviceId(),
+    cliVersion: CLI_VERSION
+  });
   try {
     const res = await client.getMe();
     info(`Signed in as \x1B[1m@${res.user.handle}\x1B[0m`);
+    info(`Device id: ${ensureDeviceId()}`);
   } catch (err) {
+    if (err instanceof DeviceRevokedError) {
+      markDisconnected();
+      deleteToken();
+      error(
+        "This device was disconnected from the Token Rats web UI. Run `token-rats login` to reconnect."
+      );
+      process.exit(1);
+    }
     if (err instanceof ApiError2 && err.status === 401) {
       error("Your session has expired. Run `token-rats login` to re-authenticate.");
       process.exit(1);
@@ -6385,25 +6287,23 @@ function getVersion() {
 }
 function printHelp() {
   console.log(`
-\x1B[1mtoken-rats\x1B[0m \u2014 Strava for AI token burn  \x1B[2mv${getVersion()}\x1B[0m
+\x1B[1mtoken-rats\x1B[0m \u2014 AI usage tracker and community  \x1B[2mv${getVersion()}\x1B[0m
 
 \x1B[1mUsage:\x1B[0m
   token-rats <command> [flags]
 
 \x1B[1mCommands:\x1B[0m
-  login           Authenticate with Token Rats (opens browser)
-  sync            Upload local Claude Code + Cursor + Codex usage. On first
-                  successful sync, asks to install a background watcher
-                  (launchd on macOS, systemd --user on Linux) that keeps
-                  your leaderboard live \u2014 no more re-running sync.
-  watch           Run the foreground watcher (Ctrl-C to stop), OR manage
-                  the background watcher with --install / --uninstall /
-                  --status.
-  whoami          Show the currently signed-in account
-  logout          Clear your stored credentials
-  install-cursor  Install better-sqlite3 globally for faster Cursor reads
-                  (sql.js works out of the box \u2014 this is opt-in speed-up)
-  help            Show this help message
+  login              Authenticate with Token Rats (opens browser); installs the background watcher by default
+  sync               Read local Claude Code, Codex + Cursor logs and upload counts
+  watch              Watch logs in real-time; upload new sessions as they appear
+  whoami             Show the currently signed-in account + device id
+  logout             Clear your stored credentials
+  install-daemon     Install the background watcher (runs at logon)
+  uninstall-daemon   Remove the background watcher
+  daemon-status      Show whether the background watcher is running
+  install-cursor     Install better-sqlite3 globally for faster Cursor reads
+                     (sql.js works out of the box \u2014 this is opt-in speed-up)
+  help               Show this help message
 
 \x1B[1mFlags (all commands):\x1B[0m
   --api-url <url>   Override API URL (default: https://api.tokenrats.com)
@@ -6411,16 +6311,9 @@ function printHelp() {
 \x1B[1mFlags (sync only):\x1B[0m
   --dry-run         Parse but do not upload; print what would be sent
   --verbose         Print discovered files and per-file record counts
-  --no-daemon       Skip the post-sync prompt to install background watcher
-                    (TOKEN_RATS_NO_DAEMON=1 does the same globally)
 
 \x1B[1mFlags (watch only):\x1B[0m
-  --install         Install the background watcher (launchd / systemd --user)
-  --uninstall       Remove the background watcher
-  --status          Show whether the watcher is installed and running
-  --daemon          Internal: structured logs for launchd/systemd. Not for
-                    interactive use.
-  --interval <ms>   Debounce window in ms before uploading (default: 2000)
+  --interval <ms>   Scan interval in ms (default: 30000, minimum: 1000)
   --verbose         Print file change events and upload detail
 
 \x1B[1mPrivacy:\x1B[0m
@@ -6449,10 +6342,6 @@ function parseArgs(argv) {
   let verbose = false;
   let interval;
   let noDaemon = false;
-  let daemon = false;
-  let install = false;
-  let uninstall = false;
-  let status = false;
   let i = 0;
   while (i < argv.length) {
     const arg = argv[i];
@@ -6470,14 +6359,6 @@ function parseArgs(argv) {
       interval = Number(arg.slice("--interval=".length));
     } else if (arg === "--no-daemon") {
       noDaemon = true;
-    } else if (arg === "--daemon") {
-      daemon = true;
-    } else if (arg === "--install") {
-      install = true;
-    } else if (arg === "--uninstall") {
-      uninstall = true;
-    } else if (arg === "--status") {
-      status = true;
     } else if (arg === "--version" || arg === "-V") {
       console.log(getVersion());
       process.exit(0);
@@ -6490,56 +6371,24 @@ function parseArgs(argv) {
     i++;
   }
   const [command = null, ...rest] = positional;
-  return {
-    command,
-    apiUrl,
-    dryRun,
-    verbose,
-    interval,
-    noDaemon,
-    daemon,
-    install,
-    uninstall,
-    status,
-    rest
-  };
+  return { command, apiUrl, dryRun, verbose, interval, noDaemon, rest };
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  const {
-    command,
-    apiUrl,
-    dryRun,
-    verbose,
-    interval,
-    noDaemon,
-    daemon,
-    install,
-    uninstall,
-    status
-  } = args;
+  const { command, apiUrl, dryRun, verbose, interval, noDaemon } = args;
   if (!command || command === "help") {
     printHelp();
     process.exit(0);
   }
   switch (command) {
     case "login":
-      await loginCommand({ apiUrl });
+      await loginCommand({ apiUrl, noDaemon });
       break;
     case "sync":
-      await syncCommand({ apiUrl, dryRun, verbose, noDaemon });
+      await syncCommand({ apiUrl, dryRun, verbose });
       break;
     case "watch":
-      await watchCommand({
-        apiUrl,
-        verbose,
-        interval,
-        daemon,
-        install,
-        uninstall,
-        status,
-        version: getVersion()
-      });
+      await watchCommand({ apiUrl, verbose, interval });
       break;
     case "whoami":
       await whoamiCommand({ apiUrl });
@@ -6550,6 +6399,15 @@ async function main() {
     case "install-cursor":
       await installCursorCommand();
       break;
+    case "install-daemon":
+      await installDaemonCommand(apiUrl);
+      break;
+    case "uninstall-daemon":
+      await uninstallDaemonCommand();
+      break;
+    case "daemon-status":
+      await daemonStatusCommand();
+      break;
     default:
       console.error(`\x1B[31mUnknown command: ${command}\x1B[0m`);
       console.error("Run \x1B[1mtoken-rats help\x1B[0m for a list of commands.");