token-rats 0.0.4 → 0.2.0

package/dist/index.js

@@ -32,6 +32,379 @@ 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 * 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 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 script = process.argv[1] ?? "token-rats";
+  return { node: process.execPath, script };
+}
+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) {
+  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>${node}</string>
+    <string>${script}</string>
+    <string>watch</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${stdout}</string>
+  <key>StandardErrorPath</key>
+  <string>${stderr}</string>
+</dict>
+</plist>
+`;
+}
+async function darwinInstall() {
+  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), { mode: 420 });
+  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))) 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) {
+  return `[Unit]
+Description=Token Rats watcher \u2014 live AI usage sync
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${node} ${script} watch
+Restart=on-failure
+RestartSec=10s
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function linuxInstall() {
+  const { node, script } = resolveCliPath();
+  const unitPath = linuxUnitPath();
+  fs2.mkdirSync(path2.dirname(unitPath), { recursive: true });
+  fs2.writeFileSync(unitPath, linuxUnit(node, script), { mode: 420 });
+  try {
+    await exec("systemctl", ["--user", "daemon-reload"]);
+    await exec("systemctl", ["--user", "enable", "--now", 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() {
+  const { node, script } = resolveCliPath();
+  await exec("schtasks", [
+    "/Create",
+    "/SC",
+    "ONLOGON",
+    "/TN",
+    WINDOWS_TASK,
+    "/TR",
+    `"${node}" "${script}" watch`,
+    "/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() {
+  clearDisconnected();
+  try {
+    if (process.platform === "darwin") {
+      await darwinInstall();
+    } else if (process.platform === "linux") {
+      await linuxInstall();
+    } else if (process.platform === "win32") {
+      await windowsInstall();
+    } else {
+      warn(`No daemon installer for platform ${process.platform}; skipping.`);
+      return;
+    }
+    success("Background watcher installed and running.");
+    dim("It will pick up new sessions from Claude Code logs in real time.");
+    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 +758,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path5, errorMaps, issueData } = params;
+  const fullPath = [...path5, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -508,11 +881,11 @@ var errorUtil;
 var _ZodEnum_cache;
 var _ZodNativeEnum_cache;
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path5, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path5;
     this._key = key;
   }
   get path() {
@@ -3948,12 +4321,30 @@ var z = /* @__PURE__ */ Object.freeze({
 
 // ../contracts/src/session.ts
 var Source = z.enum(["claude-code", "cursor", "codex"]);
+var Provider = z.enum([
+  "anthropic",
+  "openai",
+  "openrouter",
+  "cursor",
+  "ollama",
+  "unknown"
+]);
+var SessionChannel = z.enum(["cli", "ide", "api", "proxy", "local", "unknown"]);
 var SessionRecord = z.object({
   id: z.string().min(1),
   source: Source,
+  provider: Provider.optional(),
+  client: z.string().min(1).max(64).optional(),
+  channel: SessionChannel.optional(),
   model: z.string().min(1),
   inTokens: z.number().int().nonnegative(),
   outTokens: z.number().int().nonnegative(),
+  /** Anthropic cache reads / OpenAI `cached_input_tokens`. Billed cheap-or-free. */
+  cacheReadTokens: z.number().int().nonnegative().optional(),
+  /** Anthropic cache creation tokens. Billed at a premium for first-write only. */
+  cacheWriteTokens: z.number().int().nonnegative().optional(),
+  /** OpenAI reasoning output tokens (o-series / Codex). Billed at output rate. */
+  reasoningTokens: z.number().int().nonnegative().optional(),
   costUsdCents: z.number().int().nonnegative(),
   startedAt: z.number().int().positive(),
   endedAt: z.number().int().positive(),
@@ -3961,6 +4352,12 @@ var SessionRecord = z.object({
 });
 
 // ../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 User = z.object({
   id: z.string(),
   handle: z.string(),
@@ -3968,19 +4365,42 @@ var User = z.object({
   /** Present only when the caller is the user themselves or the user is public. */
   bio: z.string().max(200).nullable().optional(),
   twitterHandle: z.string().max(50).nullable().optional(),
-  publicProfile: z.boolean().optional()
+  /**
+   * True iff `twitter_handle` came from the OAuth flow (i.e. `twitter_user_id`
+   * is set). Self-only — used by settings UI to distinguish manual legacy
+   * handles from verified ones.
+   */
+  twitterVerified: z.boolean().optional(),
+  publicProfile: z.boolean().optional(),
+  /**
+   * Primary verified GitHub email, captured at OAuth callback time. Self-only
+   * (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()
 });
 var PublicProfileSettings = z.object({
   publicProfile: z.boolean().optional(),
-  bio: z.string().max(200).nullable().optional(),
-  twitterHandle: z.string().max(50).nullable().optional()
+  bio: z.string().max(200).nullable().optional()
 });
 var Profile = User.extend({
   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() }),
     allTime: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() })
-  })
+  }),
+  /** 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
+   * copy-able invite link without a separate fetch to /v1/me/referral.
+   */
+  referralCode: z.string().optional()
 });
 var AutobiographyStats = z.object({
   handle: z.string(),
@@ -4016,13 +4436,24 @@ var Room = z.object({
   name: z.string().min(1).max(64),
   ownerId: z.string(),
   orgId: z.string().nullable(),
-  createdAt: z.number().int().positive()
+  createdAt: z.number().int().positive(),
+  /** v1.2: public country-locked groups. `country` is set iff `isPublic` is true. */
+  isPublic: z.boolean(),
+  /** ISO-3166-1 alpha-2 (`cf-ipcountry` of the creator). Null on private rooms. */
+  country: z.string().min(2).max(2).nullable(),
+  /**
+   * True iff this room is the caller's pinned room. Populated only on
+   * caller-scoped responses (e.g. GET /v1/me/rooms); absent elsewhere.
+   */
+  isPinned: z.boolean().optional()
 });
 var RoomMember = z.object({
   userId: z.string(),
   handle: z.string(),
   avatarUrl: z.string().url().nullable(),
-  joinedAt: z.number().int().positive()
+  joinedAt: z.number().int().positive(),
+  /** OAuth-verified X handle, when present. Manual handles are not surfaced. */
+  twitterHandle: z.string().max(50).nullable().optional()
 });
 
 // ../contracts/src/leaderboard.ts
@@ -4039,8 +4470,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,
@@ -4088,8 +4525,25 @@ var ChallengeWithLeaderboard = Challenge.extend({
   winnerHandle: z.string().nullable()
 });
 
+// ../contracts/src/referral.ts
+var ReferredUser = z.object({
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  /** Unix ms — when the referred user signed up. */
+  createdAt: z.number().int()
+});
+var ReferralStats = z.object({
+  /** The user's unique referral code (URL-safe, ~8 chars). */
+  code: z.string(),
+  /** Total users referred. */
+  count: z.number().int().nonnegative(),
+  /** Most recent referred users (newest first), capped server-side. */
+  recent: z.array(ReferredUser)
+});
+
 // ../contracts/src/org.ts
-var OrgPlan = z.enum(["free", "pro"]);
+var OrgPlan = z.enum(["free", "student", "pro"]);
+var OrgStatus = z.enum(["pending", "approved"]);
 var OrgMemberRole = z.enum(["owner", "admin", "member"]);
 var OrgSlug = z.string().min(3).max(48).regex(/^[a-z0-9-]+$/, "Slug must be lowercase letters, numbers, and hyphens only");
 var Org = z.object({
@@ -4099,7 +4553,12 @@ var Org = z.object({
   plan: OrgPlan,
   seatCount: z.number().int().nonnegative(),
   githubOrgLogin: z.string().nullable(),
-  createdAt: z.number().int().positive()
+  createdAt: z.number().int().positive(),
+  /** v1.2: soft-create status. Approved orgs are fully usable; pending orgs are gated. */
+  status: OrgStatus,
+  requestedPlan: OrgPlan.nullable(),
+  founderEmail: z.string().email().nullable(),
+  founderName: z.string().nullable()
 });
 var OrgMember = z.object({
   userId: z.string(),
@@ -4144,8 +4603,17 @@ var OrgDashboard = z.object({
 var CreateOrgRequest = z.object({
   name: z.string().min(1).max(64),
   slug: OrgSlug,
-  githubOrgLogin: z.string().optional()
+  githubOrgLogin: z.string().optional(),
+  // v1.2 soft-create — required fields, trust-on-submit.
+  founderEmail: z.string().email(),
+  founderName: z.string().min(1).max(80).optional(),
+  requestedPlan: OrgPlan
+});
+var PatchOrgRequest = z.object({
+  founderEmail: z.string().email().optional(),
+  founderName: z.string().min(1).max(80).optional()
 });
+var PatchOrgResponse = z.object({ org: Org });
 var CreateOrgResponse = z.object({ org: Org });
 var GetOrgResponse = z.object({
   org: Org,
@@ -4160,6 +4628,20 @@ var CreateOrgInviteRequest = z.object({
 var CreateOrgInviteResponse = z.object({ invite: OrgInvite });
 var AcceptOrgInviteResponse = z.object({ ok: z.boolean() });
 var GetOrgDashboardResponse = z.object({ dashboard: OrgDashboard });
+var AdminPendingOrg = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: OrgSlug.nullable(),
+  requestedPlan: OrgPlan.nullable(),
+  founderEmail: z.string().email().nullable(),
+  founderName: z.string().nullable(),
+  founderHandle: z.string(),
+  createdAt: z.number().int().positive()
+});
+var GetPendingOrgsResponse = z.object({
+  orgs: z.array(AdminPendingOrg)
+});
+var ApproveOrgResponse = z.object({ org: Org });
 
 // ../contracts/src/api.ts
 var GetMeResponse = z.object({ user: User });
@@ -4171,7 +4653,9 @@ var UploadSessionsResponse = z.object({
   duplicates: z.number().int().nonnegative()
 });
 var CreateRoomRequest = z.object({
-  name: z.string().min(1).max(64)
+  name: z.string().min(1).max(64),
+  /** v1.2: when true the room is publicly listed in /groups for its country. */
+  isPublic: z.boolean().default(false)
 });
 var CreateRoomResponse = z.object({ room: Room });
 var JoinRoomResponse = z.object({ room: Room });
@@ -4191,14 +4675,60 @@ var HeatmapDay = z.object({
   tokens: z.number().int().nonnegative(),
   sessions: z.number().int().nonnegative()
 });
+var HeatmapRange = z.enum(["30d", "52w"]);
 var Heatmap = z.object({
+  range: HeatmapRange,
   from: z.string(),
   // YYYY-MM-DD UTC, inclusive
   to: z.string(),
   // YYYY-MM-DD UTC, inclusive
   days: z.array(HeatmapDay)
 });
+var GetHeatmapQuery = z.object({
+  range: HeatmapRange.default("30d")
+});
 var GetHeatmapResponse = z.object({ heatmap: Heatmap });
+var RoomSummary = z.object({
+  code: z.string(),
+  name: z.string(),
+  /** Future: true once feature #6 lands. Always false for now. */
+  isPublic: z.boolean(),
+  /** ISO country code (e.g. "DE") when isPublic is true; null otherwise. */
+  country: z.string().nullable(),
+  memberCount: z.number().int().nonnegative(),
+  total30dTokens: z.number().int().nonnegative(),
+  total30dCostUsdCents: z.number().int().nonnegative()
+});
+var GetRoomSummaryResponse = z.object({ summary: RoomSummary });
+var PublicGroupRow = z.object({
+  code: z.string(),
+  name: z.string(),
+  country: z.string().min(2).max(2),
+  memberCount: z.number().int().nonnegative(),
+  total30dTokens: z.number().int().nonnegative(),
+  total30dCostUsdCents: z.number().int().nonnegative()
+});
+var CountryBoardRow = z.object({
+  rank: z.number().int().positive(),
+  userId: z.string(),
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  tokens: z.number().int().nonnegative(),
+  costUsdCents: z.number().int().nonnegative(),
+  sessions: z.number().int().nonnegative()
+});
+var GetGroupsResponse = z.object({
+  country: z.string().min(2).max(2).nullable(),
+  groups: z.array(PublicGroupRow),
+  /** Public users in the viewer's country, ranked by trailing-30d tokens. */
+  userBoard: z.array(CountryBoardRow)
+});
+var GroupStreak = z.object({
+  currentStreak: z.number().int().nonnegative(),
+  /** Yesterday in YYYY-MM-DD UTC. */
+  asOf: z.string()
+});
+var GetGroupStreakResponse = z.object({ groupStreak: GroupStreak });
 var GetMyRoomsResponse = z.object({
   rooms: z.array(Room)
 });
@@ -4234,6 +4764,7 @@ var GetTrendingResponse = z.object({
   range: LeaderboardRange,
   generatedAt: z.number().int().positive()
 });
+var GetReferralResponse = z.object({ referral: ReferralStats });
 var ReportAbuseRequest = z.object({
   targetHandle: z.string().min(1).max(100),
   reason: z.string().min(1).max(500)
@@ -4249,14 +4780,22 @@ var ENDPOINTS = {
   profile: (handle) => `/v1/u/${handle}`,
   autobiography: (handle) => `/v1/u/${handle}/autobiography`,
   profileHeatmap: (handle) => `/v1/u/${handle}/heatmap`,
+  // v1.2 room aggregates — auth optional, accessible to non-members.
+  roomSummary: (code) => `/v1/r/${code}/summary`,
+  roomHeatmap: (code) => `/v1/r/${code}/heatmap`,
+  roomGroupStreak: (code) => `/v1/r/${code}/group-streak`,
+  // v1.2 public country-locked groups list
+  groups: "/v1/groups",
   authGithubStart: "/v1/auth/github/start",
   authGithubCallback: "/v1/auth/github/callback",
+  authLogout: "/v1/auth/logout",
   authCliExchange: "/v1/auth/cli/exchange",
   authCliPoll: "/v1/auth/cli/poll",
   // Phase 2 Track G+H
   meRooms: "/v1/me/rooms",
   leaveRoom: (code) => `/v1/rooms/${code}/leave`,
   renameRoom: (code) => `/v1/rooms/${code}`,
+  pinRoom: (code) => `/v1/rooms/${code}/pin`,
   roomActivity: (code) => `/v1/rooms/${code}/activity`,
   roomStreaks: (code) => `/v1/rooms/${code}/streaks`,
   roomChallenges: (code) => `/v1/rooms/${code}/challenges`,
@@ -4270,6 +4809,16 @@ var ENDPOINTS = {
   patchMe: "/v1/me",
   trending: "/v1/trending",
   reportAbuse: "/v1/abuse/report",
+  // Affiliate / referral tracking
+  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}`,
@@ -4283,7 +4832,10 @@ var ENDPOINTS = {
   // Admin analytics (project-owner only)
   adminSignups: "/v1/admin/signups",
   adminActivity: "/v1/admin/activity",
-  adminReferrers: "/v1/admin/referrers"
+  adminReferrers: "/v1/admin/referrers",
+  // Admin org approval (v1.2)
+  adminOrgsPending: "/v1/admin/orgs/pending",
+  adminOrgApprove: (slug) => `/v1/admin/orgs/${slug}/approve`
 };
 
 // ../contracts/src/errors.ts
@@ -4369,20 +4921,98 @@ var AdminActivityResponse = z.object({
   generatedAt: z.number().int().positive()
 });
 var AdminReferrerRow = z.object({
-  /** A label describing the source of the signal. */
-  label: z.string(),
-  /** Number of users (or events) attributed to this label. */
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  /** Number of users this referrer has brought in. */
   count: z.number().int().nonnegative()
 });
 var AdminReferrersResponse = z.object({
-  /** True iff a real referral attribution column / table exists. */
-  tracked: z.boolean(),
-  /** Description of what `rows` represents (e.g. "First CLI source"). */
-  signal: z.string(),
   rows: z.array(AdminReferrerRow),
   generatedAt: z.number().int().positive()
 });
 
+// ../contracts/src/friends.ts
+var FriendSharedRoom = z.object({
+  code: z.string(),
+  name: z.string()
+});
+var FriendRow = z.object({
+  userId: z.string(),
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  twitterHandle: z.string().nullable().optional(),
+  publicProfile: z.boolean(),
+  sharedRooms: z.array(FriendSharedRoom),
+  tokens: z.number().int().nonnegative(),
+  costUsdCents: z.number().int().nonnegative(),
+  sessions: z.number().int().nonnegative()
+});
+var FriendsResponse = z.object({
+  range: LeaderboardRange,
+  friends: z.array(FriendRow)
+});
+
+// ../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)
+});
+
 // src/lib/api.ts
 var DEFAULT_API_URL = "https://api.tokenrats.com";
 function isTransient(status) {
@@ -4399,33 +5029,40 @@ var ApiError2 = class extends Error {
     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;
-        }
+        if (res.ok || !isTransient(res.status)) return res;
         lastErr = new ApiError2(res.status, await res.text());
       } catch (err) {
         lastErr = err;
@@ -4437,34 +5074,37 @@ var ApiClient = class {
     }
     throw lastErr;
   }
-  async post(path3, body) {
-    const url = `${this.apiUrl}${path3}`;
+  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(path5, body) {
+    const url = `${this.apiUrl}${path5}`;
     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(path3) {
-    const url = `${this.apiUrl}${path3}`;
+  async get(path5) {
+    const url = `${this.apiUrl}${path5}`;
     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, {
@@ -4476,12 +5116,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 */
@@ -4492,106 +5128,18 @@ 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/me/devices */
+  async getDevices() {
+    return this.get(ENDPOINTS.meDevices);
   }
-}
-function deleteToken() {
-  const file = tokenPath();
-  try {
-    fs.unlinkSync(file);
-  } catch {
+  /** 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}
-`);
-      }
-    };
-  }
-  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 = "0.2.0";
 
 // src/commands/login.ts
 async function openBrowser(url) {
@@ -4604,12 +5152,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 {
   }
 }
@@ -4625,7 +5173,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 {
@@ -4673,7 +5226,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();
 }
 
 // src/commands/logout.ts
@@ -4687,68 +5249,7 @@ function logoutCommand() {
 }
 
 // src/commands/sync.ts
-import * as fs3 from "node:fs";
-
-// ../pricing/src/prices.ts
-var prices = {
-  models: {
-    // ── Anthropic / Claude ────────────────────────────────────────────────
-    "claude-opus-4-7": { inputPerMTok: 15, outputPerMTok: 75 },
-    "claude-opus-4-6": { inputPerMTok: 15, outputPerMTok: 75 },
-    "claude-sonnet-4-6": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-sonnet-4-5": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-haiku-4-5": { inputPerMTok: 0.8, outputPerMTok: 4 },
-    "claude-3-5-sonnet-20241022": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-3-5-sonnet-20240620": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-3-5-haiku-20241022": { inputPerMTok: 0.8, outputPerMTok: 4 },
-    "claude-3-opus-20240229": { inputPerMTok: 15, outputPerMTok: 75 },
-    "claude-3-sonnet-20240229": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-3-haiku-20240307": { inputPerMTok: 0.25, outputPerMTok: 1.25 },
-    // ── OpenAI / Codex ────────────────────────────────────────────────────
-    // GPT-5 family. gpt-5-codex is the Codex CLI's public model; OpenAI's
-    // pricing page lists only input ($1.25/MTok). Output uses the same $10
-    // rate the broader GPT-5 base is publicly quoted at — flagged here for
-    // re-verification when OpenAI publishes an explicit output figure.
-    "gpt-5-codex": { inputPerMTok: 1.25, outputPerMTok: 10 },
-    "gpt-5-mini": { inputPerMTok: 0.25, outputPerMTok: 2 },
-    "gpt-5-nano": { inputPerMTok: 0.05, outputPerMTok: 0.4 },
-    "gpt-5-pro": { inputPerMTok: 15, outputPerMTok: 120 },
-    "gpt-5.5": { inputPerMTok: 5, outputPerMTok: 30 },
-    "codex-mini-latest": { inputPerMTok: 1.5, outputPerMTok: 6 },
-    // GPT-4 family.
-    "gpt-4o": { inputPerMTok: 2.5, outputPerMTok: 10 },
-    "gpt-4o-mini": { inputPerMTok: 0.15, outputPerMTok: 0.6 },
-    "gpt-4-turbo": { inputPerMTok: 10, outputPerMTok: 30 },
-    "gpt-4.1": { inputPerMTok: 2, outputPerMTok: 8 },
-    "gpt-4.1-mini": { inputPerMTok: 0.4, outputPerMTok: 1.6 },
-    "gpt-4.1-nano": { inputPerMTok: 0.1, outputPerMTok: 0.4 },
-    // Reasoning models (o-series).
-    o1: { inputPerMTok: 15, outputPerMTok: 60 },
-    "o1-mini": { inputPerMTok: 3, outputPerMTok: 12 },
-    // o3 was repriced in 2026; previously $10/$40, now $2/$8.
-    o3: { inputPerMTok: 2, outputPerMTok: 8 },
-    "o3-mini": { inputPerMTok: 1.1, outputPerMTok: 4.4 },
-    "o4-mini": { inputPerMTok: 1.1, outputPerMTok: 4.4 }
-  }
-};
-
-// ../pricing/src/index.ts
-var TABLE = prices.models;
-function priceOf(model, inTokens, outTokens) {
-  const p = TABLE[model] ?? matchPrefix(model);
-  if (!p) return { costUsdCents: 0, known: false };
-  const dollars = (inTokens * p.inputPerMTok + outTokens * p.outputPerMTok) / 1e6;
-  return { costUsdCents: Math.round(dollars * 100), known: true };
-}
-function matchPrefix(model) {
-  let best;
-  for (const [key, price] of Object.entries(TABLE)) {
-    if (model.startsWith(key) && (!best || key.length > best.key.length)) {
-      best = { key, price };
-    }
-  }
-  return best?.price;
-}
+import * as fs4 from "node:fs";
 
 // ../parsers/src/hash.ts
 var FNV_PRIME = 16777619;
@@ -4811,6 +5312,8 @@ function parseClaudeCode(input) {
         endedAt: timestamp,
         inTokens: 0,
         outTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
         model: ""
       };
       sessions.set(sessionId, acc);
@@ -4829,10 +5332,10 @@ function parseClaudeCode(input) {
     const usage = msg.usage;
     if (typeof usage === "object" && usage !== null) {
       const u = usage;
-      const inputTokens = toNonNegInt(u.input_tokens);
-      const outputTokens = toNonNegInt(u.output_tokens);
-      acc.inTokens += inputTokens;
-      acc.outTokens += outputTokens;
+      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 results = [];
@@ -4841,7 +5344,7 @@ function parseClaudeCode(input) {
     const endedAt = acc.endedAt > 0 ? acc.endedAt : acc.startedAt;
     if (startedAt <= 0 || endedAt <= 0) continue;
     const model = acc.model.length > 0 ? acc.model : "unknown";
-    const { costUsdCents } = priceOf(model, acc.inTokens, acc.outTokens);
+    const costUsdCents = 0;
     const dedupeKey = computeDedupeKey(
       "claude-code",
       model,
@@ -4852,9 +5355,14 @@ function parseClaudeCode(input) {
     results.push({
       id: `claude-code:${acc.sessionId}`,
       source: "claude-code",
+      provider: "anthropic",
+      client: "claude-code",
+      channel: "cli",
       model,
       inTokens: acc.inTokens,
       outTokens: acc.outTokens,
+      cacheReadTokens: acc.cacheReadTokens,
+      cacheWriteTokens: acc.cacheWriteTokens,
       costUsdCents,
       startedAt,
       endedAt,
@@ -4898,6 +5406,9 @@ function parseCodex(input) {
       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 === "cli" ? "cli" : metaSource === "api" ? "api" : "unknown";
+      acc2.client = acc2.channel === "cli" ? "codex-cli" : "codex";
       if (metaTs > 0 && (acc2.startedAt === 0 || metaTs < acc2.startedAt)) {
         acc2.startedAt = metaTs;
       }
@@ -4926,6 +5437,8 @@ function parseCodex(input) {
       const reasoning = toNonNegInt2(t.reasoning_output_tokens);
       acc.inTokens = Math.max(0, inputTotal - cachedInput);
       acc.outTokens = output + reasoning;
+      acc.cacheReadTokens = cachedInput;
+      acc.reasoningTokens = reasoning;
     }
   }
   const results = [];
@@ -4934,14 +5447,19 @@ function parseCodex(input) {
     const endedAt = acc.endedAt > 0 ? acc.endedAt : acc.startedAt;
     if (startedAt <= 0 || endedAt <= 0) continue;
     const model = acc.model.length > 0 ? acc.model : "unknown";
-    const { costUsdCents } = priceOf(model, acc.inTokens, acc.outTokens);
+    const costUsdCents = 0;
     const dedupeKey = computeDedupeKey("codex", model, startedAt, acc.inTokens, acc.outTokens);
     results.push({
       id: `codex:${acc.sessionId}`,
       source: "codex",
+      provider: "openai",
+      client: acc.client || "codex-cli",
+      channel: acc.channel,
       model,
       inTokens: acc.inTokens,
       outTokens: acc.outTokens,
+      cacheReadTokens: acc.cacheReadTokens,
+      reasoningTokens: acc.reasoningTokens,
       costUsdCents,
       startedAt,
       endedAt,
@@ -4959,7 +5477,11 @@ function upsert(map, sessionId) {
       endedAt: 0,
       inTokens: 0,
       outTokens: 0,
-      model: ""
+      cacheReadTokens: 0,
+      reasoningTokens: 0,
+      model: "",
+      client: "codex-cli",
+      channel: "unknown"
     };
     map.set(sessionId, acc);
   }
@@ -4983,12 +5505,6 @@ var ESTIMATES = {
   composer: { inTokens: 1e4, outTokens: 2e3, model: "cursor-composer" }
   // "tab" deliberately omitted — see file header.
 };
-var INPUT_USD_PER_MTOK = 3;
-var OUTPUT_USD_PER_MTOK = 15;
-function estimatedCostCents(inTokens, outTokens) {
-  const dollars = inTokens / 1e6 * INPUT_USD_PER_MTOK + outTokens / 1e6 * OUTPUT_USD_PER_MTOK;
-  return Math.round(dollars * 100);
-}
 function parseCursor(input) {
   let text;
   if (typeof input === "string") {
@@ -5007,20 +5523,23 @@ function parseCursor(input) {
   for (const raw of rows) {
     if (typeof raw !== "object" || raw === null) continue;
     const row = raw;
-    const id = typeof row["id"] === "string" ? row["id"] : null;
+    const id = typeof row.id === "string" ? row.id : null;
     if (!id) continue;
-    const type = typeof row["type"] === "string" ? row["type"] : null;
+    const type = typeof row.type === "string" ? row.type : null;
     if (!type) continue;
-    const unixMs = typeof row["unixMs"] === "number" && isFinite(row["unixMs"]) && row["unixMs"] > 0 ? row["unixMs"] : null;
+    const unixMs = typeof row.unixMs === "number" && Number.isFinite(row.unixMs) && row.unixMs > 0 ? row.unixMs : null;
     if (unixMs === null) continue;
     const estimate = ESTIMATES[type];
     if (!estimate) continue;
     const { inTokens, outTokens, model } = estimate;
-    const costUsdCents = estimatedCostCents(inTokens, outTokens);
+    const costUsdCents = 0;
     const dedupeKey = computeDedupeKey("cursor", model, unixMs, inTokens, outTokens);
     results.push({
       id: `cursor:${id}`,
       source: "cursor",
+      provider: "cursor",
+      client: "cursor",
+      channel: "ide",
       model,
       inTokens,
       outTokens,
@@ -5034,31 +5553,31 @@ function parseCursor(input) {
 }
 
 // src/lib/cursor-extract.ts
-import { existsSync, readdirSync } 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;
 }
@@ -5136,9 +5655,9 @@ async function readGenerationsFromDb(dbPath) {
     for (const item of parsed) {
       if (typeof item !== "object" || item === null) continue;
       const r = item;
-      const id = typeof r["generationUUID"] === "string" ? r["generationUUID"] : null;
-      const type = typeof r["type"] === "string" ? r["type"] : null;
-      const unixMs = typeof r["unixMs"] === "number" && isFinite(r["unixMs"]) && r["unixMs"] > 0 ? r["unixMs"] : null;
+      const id = typeof r.generationUUID === "string" ? r.generationUUID : null;
+      const type = typeof r.type === "string" ? r.type : null;
+      const unixMs = typeof r.unixMs === "number" && Number.isFinite(r.unixMs) && r.unixMs > 0 ? r.unixMs : null;
       if (!id || !type || unixMs === null) continue;
       out.push({ id, type, unixMs });
     }
@@ -5189,15 +5708,15 @@ async function extractCursorGenerations() {
 }
 
 // src/lib/discover.ts
-import * as fs2 from "node:fs";
-import * as os2 from "node:os";
-import * as path2 from "node:path";
+import * as fs3 from "node:fs";
+import * as os3 from "node:os";
+import * as path3 from "node:path";
 function findJsonlFiles(dir) {
   const results = [];
-  if (!fs2.existsSync(dir)) return results;
-  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  if (!fs3.existsSync(dir)) return results;
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path2.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")) {
@@ -5207,32 +5726,32 @@ function findJsonlFiles(dir) {
   return results;
 }
 function claudeCodeProjectsDir() {
-  const home = os2.homedir();
+  const home = os3.homedir();
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
-    return path2.join(profile, ".claude", "projects");
+    return path3.join(profile, ".claude", "projects");
   }
-  return path2.join(home, ".claude", "projects");
+  return path3.join(home, ".claude", "projects");
 }
 function discoverClaudeCodeFiles() {
   const dir = claudeCodeProjectsDir();
   return findJsonlFiles(dir);
 }
 function codexSessionsDirs() {
-  const home = os2.homedir();
+  const home = os3.homedir();
   const candidates = [];
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
-    candidates.push(path2.join(profile, ".codex", "sessions"));
-    const appData = process.env.APPDATA ?? path2.join(profile, "AppData", "Roaming");
-    candidates.push(path2.join(appData, "Codex", "sessions"));
+    candidates.push(path3.join(profile, ".codex", "sessions"));
+    const appData = process.env.APPDATA ?? path3.join(profile, "AppData", "Roaming");
+    candidates.push(path3.join(appData, "Codex", "sessions"));
   } else {
-    candidates.push(path2.join(home, ".codex", "sessions"));
-    const snapRoot = path2.join(home, "snap", "codex");
-    if (fs2.existsSync(snapRoot)) {
-      for (const entry of fs2.readdirSync(snapRoot, { withFileTypes: true })) {
+    candidates.push(path3.join(home, ".codex", "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(path2.join(snapRoot, entry.name, "sessions"));
+          candidates.push(path3.join(snapRoot, entry.name, "sessions"));
         }
       }
     }
@@ -5241,7 +5760,7 @@ function codexSessionsDirs() {
   const dirs = [];
   for (const c2 of candidates) {
     try {
-      const real = fs2.existsSync(c2) ? fs2.realpathSync(c2) : null;
+      const real = fs3.existsSync(c2) ? fs3.realpathSync(c2) : null;
       if (real && !seen2.has(real)) {
         seen2.add(real);
         dirs.push(c2);
@@ -5285,8 +5804,7 @@ function mergeBySessionId(records) {
     }
   }
   for (const rec of byId.values()) {
-    const { costUsdCents } = priceOf(rec.model, rec.inTokens, rec.outTokens);
-    rec.costUsdCents = costUsdCents;
+    rec.costUsdCents = 0;
     rec.dedupeKey = computeDedupeKey(
       rec.source,
       rec.model,
@@ -5303,7 +5821,12 @@ async function syncCommand(opts) {
     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 client = opts.dryRun ? null : new ApiClient({
+    apiUrl: opts.apiUrl,
+    token: token ?? void 0,
+    deviceId: ensureDeviceId(),
+    cliVersion: CLI_VERSION
+  });
   const claudeFiles = discoverClaudeCodeFiles();
   if (opts.verbose) {
     info(`Found ${claudeFiles.length} Claude Code file(s) in ~/.claude/projects/`);
@@ -5313,7 +5836,7 @@ async function syncCommand(opts) {
   for (const file of claudeFiles) {
     let text;
     try {
-      text = fs3.readFileSync(file, "utf8");
+      text = fs4.readFileSync(file, "utf8");
     } catch {
       if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
       continue;
@@ -5335,7 +5858,7 @@ async function syncCommand(opts) {
   for (const file of codexFiles) {
     let text;
     try {
-      text = fs3.readFileSync(file, "utf8");
+      text = fs4.readFileSync(file, "utf8");
     } catch {
       if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
       continue;
@@ -5396,7 +5919,9 @@ async function syncCommand(opts) {
   }
   info(`Discovered ${allSessions.length} session(s) from ${sourceStr}.`);
   if (opts.dryRun) {
-    info(`[dry-run] Would upload ${allSessions.length} session(s) in ${Math.ceil(allSessions.length / BATCH_SIZE)} batch(es).`);
+    info(
+      `[dry-run] Would upload ${allSessions.length} session(s) in ${Math.ceil(allSessions.length / BATCH_SIZE)} batch(es).`
+    );
     if (opts.verbose) {
       for (const s of allSessions.slice(0, 10)) {
         dim(
@@ -5419,6 +5944,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);
@@ -5436,12 +5969,47 @@ async function syncCommand(opts) {
 }
 
 // src/commands/watch.ts
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
+import * as os4 from "node:os";
+import * as path4 from "node:path";
+var HEARTBEAT_MS = 6e4;
 var seen = /* @__PURE__ */ new Set();
+function stateFilePath() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? path4.join(os4.homedir(), ".config");
+  return path4.join(xdgConfig, "token-rats", "watch-state.json");
+}
+function loadWatchState() {
+  try {
+    const raw = fs5.readFileSync(stateFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function saveWatchState(state) {
+  try {
+    const file = stateFilePath();
+    fs5.mkdirSync(path4.dirname(file), { recursive: true });
+    fs5.writeFileSync(file, JSON.stringify(state), { mode: 384 });
+  } catch (err) {
+    if (err instanceof Error) {
+      console.warn(`watch-state write failed: ${err.message}`);
+    }
+  }
+}
+function statFile(p) {
+  try {
+    const s = fs5.statSync(p);
+    return { size: s.size, mtimeMs: s.mtimeMs };
+  } catch {
+    return null;
+  }
+}
 function parseAndFilter(filePath, verbose) {
   let text;
   try {
-    text = fs4.readFileSync(filePath, "utf8");
+    text = fs5.readFileSync(filePath, "utf8");
   } catch {
     if (verbose) warn(`Could not read ${filePath} \u2014 skipping`);
     return [];
@@ -5475,6 +6043,14 @@ async function upload(client, records, verbose) {
       success(`Uploaded ${res.accepted} session(s)`);
     }
   } catch (err) {
+    if (err instanceof DeviceRevokedError) {
+      markDisconnected();
+      deleteToken();
+      error(
+        "This device was disconnected from the Token Rats web UI. Daemon will exit; re-run `token-rats login` to reconnect."
+      );
+      process.exit(0);
+    }
     if (err instanceof ApiError2 && err.status === 401) {
       error("Session expired. Run `token-rats login` to re-authenticate.");
       process.exit(1);
@@ -5484,22 +6060,22 @@ async function upload(client, records, verbose) {
 }
 function makeDebounced(fn, ms) {
   const timers = /* @__PURE__ */ new Map();
-  return (path3) => {
-    const existing = timers.get(path3);
+  return (path5) => {
+    const existing = timers.get(path5);
     if (existing) clearTimeout(existing);
     timers.set(
-      path3,
+      path5,
       setTimeout(() => {
-        timers.delete(path3);
-        fn(path3);
+        timers.delete(path5);
+        fn(path5);
       }, ms)
     );
   };
 }
 function findJsonlFiles2(dir) {
   const results = [];
-  if (!fs4.existsSync(dir)) return results;
-  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  if (!fs5.existsSync(dir)) return results;
+  const entries = fs5.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const full = `${dir}/${entry.name}`;
     if (entry.isDirectory()) {
@@ -5511,40 +6087,89 @@ function findJsonlFiles2(dir) {
   return results;
 }
 async function watchCommand(opts) {
+  if (isDisconnected()) {
+    error(
+      "This device was disconnected from the Token Rats web UI. Run `token-rats login` to reconnect."
+    );
+    process.exit(0);
+  }
   const token = loadToken();
   if (!token) {
     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
+  });
   const debounceMs = opts.interval ?? 2e3;
   const dir = claudeCodeProjectsDir();
-  if (!fs4.existsSync(dir)) {
+  if (!fs5.existsSync(dir)) {
     warn(`Claude Code projects directory not found: ${dir}`);
     warn("No files to watch. Exiting.");
     process.exit(0);
   }
   info(`Watching ${dir} (debounce: ${debounceMs}ms)`);
   info("Press Ctrl-C to stop.\n");
+  const persistedState = loadWatchState();
+  const liveState = /* @__PURE__ */ new Map();
   const initialFiles = findJsonlFiles2(dir);
   for (const f of initialFiles) {
+    const cur = statFile(f);
+    if (!cur) continue;
+    liveState.set(f, cur);
+    const prev = persistedState[f];
+    if (prev && cur.size < prev.size) {
+      warn(`Rotation detected on ${f}: size shrank ${prev.size} \u2192 ${cur.size}.`);
+    }
     parseAndFilter(f, false);
   }
   if (opts.verbose) {
     dim(`Initial snapshot: ${seen.size} session(s) in ${initialFiles.length} file(s)`);
   }
+  saveWatchState(Object.fromEntries(liveState));
   const onChanged = makeDebounced(async (filePath) => {
     if (!filePath.endsWith(".jsonl")) return;
+    const cur = statFile(filePath);
+    if (cur) {
+      const prev = liveState.get(filePath);
+      if (prev && cur.size < prev.size) {
+        warn(`Rotation detected on ${filePath}: size shrank ${prev.size} \u2192 ${cur.size}.`);
+      }
+      liveState.set(filePath, cur);
+      saveWatchState(Object.fromEntries(liveState));
+    }
     const fresh = parseAndFilter(filePath, opts.verbose ?? false);
     if (fresh.length > 0) {
       await upload(client, fresh, opts.verbose ?? false);
     }
   }, debounceMs);
+  const heartbeatTimer = setInterval(async () => {
+    try {
+      await client.heartbeat();
+    } catch (err) {
+      if (err instanceof DeviceRevokedError) {
+        markDisconnected();
+        deleteToken();
+        error(
+          "This device was disconnected from the Token Rats web UI. Daemon exiting; re-run `token-rats login` to reconnect."
+        );
+        cleanup?.();
+        clearInterval(heartbeatTimer);
+        process.exit(0);
+      }
+      if (opts.verbose) {
+        dim(`Heartbeat failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }, HEARTBEAT_MS);
+  client.heartbeat().catch(() => {
+  });
   let cleanup = null;
   try {
-    const chokidar = await new Function("m", "return import(m)")(
-      "chokidar"
-    );
+    const chokidar = await new Function("m", "return import(m)")("chokidar");
     const watcher = chokidar.watch(`${dir}/**/*.jsonl`, {
       ignoreInitial: true,
       persistent: true,
@@ -5552,9 +6177,7 @@ async function watchCommand(opts) {
     });
     watcher.on("add", (p) => onChanged(p));
     watcher.on("change", (p) => onChanged(p));
-    cleanup = () => {
-      watcher.close();
-    };
+    cleanup = () => watcher.close();
     if (opts.verbose) dim("Using chokidar for file watching");
   } catch {
     if (opts.verbose) dim("chokidar not available; using Node built-in fs.watch");
@@ -5562,7 +6185,7 @@ async function watchCommand(opts) {
       let lastMtimes = /* @__PURE__ */ new Map();
       for (const f of initialFiles) {
         try {
-          lastMtimes.set(f, fs4.statSync(f).mtimeMs);
+          lastMtimes.set(f, fs5.statSync(f).mtimeMs);
         } catch {
         }
       }
@@ -5570,7 +6193,7 @@ async function watchCommand(opts) {
         const current = findJsonlFiles2(dir);
         for (const f of current) {
           try {
-            const mtime = fs4.statSync(f).mtimeMs;
+            const mtime = fs5.statSync(f).mtimeMs;
             const prev = lastMtimes.get(f) ?? 0;
             if (mtime > prev) {
               lastMtimes.set(f, mtime);
@@ -5612,6 +6235,7 @@ async function watchCommand(opts) {
   }
   function shutdown() {
     info("Shutting down\u2026");
+    clearInterval(heartbeatTimer);
     if (cleanup) cleanup();
     process.exit(0);
   }
@@ -5626,11 +6250,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);
@@ -5642,7 +6280,7 @@ async function whoamiCommand(opts) {
 
 // src/index.ts
 function getVersion() {
-  return "0.0.4";
+  return CLI_VERSION;
 }
 function printHelp() {
   console.log(`
@@ -5652,14 +6290,17 @@ function printHelp() {
   token-rats <command> [flags]
 
 \x1B[1mCommands:\x1B[0m
-  login           Authenticate with Token Rats (opens browser)
-  sync            Read local Claude Code + Cursor logs and upload counts
-  watch           Watch logs in real-time; upload new sessions as they appear
-  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 + 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)
@@ -5697,6 +6338,7 @@ function parseArgs(argv) {
   let dryRun = false;
   let verbose = false;
   let interval;
+  let noDaemon = false;
   let i = 0;
   while (i < argv.length) {
     const arg = argv[i];
@@ -5712,6 +6354,8 @@ function parseArgs(argv) {
       interval = Number(argv[++i]);
     } else if (arg.startsWith("--interval=")) {
       interval = Number(arg.slice("--interval=".length));
+    } else if (arg === "--no-daemon") {
+      noDaemon = true;
     } else if (arg === "--version" || arg === "-V") {
       console.log(getVersion());
       process.exit(0);
@@ -5724,18 +6368,18 @@ function parseArgs(argv) {
     i++;
   }
   const [command = null, ...rest] = positional;
-  return { command, apiUrl, dryRun, verbose, interval, 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 } = 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 });
@@ -5752,6 +6396,15 @@ async function main() {
     case "install-cursor":
       await installCursorCommand();
       break;
+    case "install-daemon":
+      await installDaemonCommand();
+      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.");