token-rats 0.1.0 → 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: path7, errorMaps, issueData } = params;
-  const fullPath = [...path7, ...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, path7, key) {
+  constructor(parent, value, path5, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path7;
+    this._path = path5;
     this._key = key;
   }
   get path() {
@@ -3948,11 +4321,21 @@ 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 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(),
@@ -3969,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(),
@@ -4002,6 +4391,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 +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,
@@ -4414,6 +4813,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,6 +4952,67 @@ var FriendsResponse = z.object({
   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) {
@@ -4563,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;
@@ -4601,34 +5074,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(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(path7) {
-    const url = `${this.apiUrl}${path7}`;
+  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, {
@@ -4640,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 */
@@ -4656,106 +5128,18 @@ var ApiClient = class {
   async uploadSessions(sessions) {
     return this.post(ENDPOINTS.sessions, { sessions });
   }
+  /** GET /v1/me/devices */
+  async getDevices() {
+    return this.get(ENDPOINTS.meDevices);
+  }
+  /** POST /v1/me/devices/heartbeat */
+  async heartbeat() {
+    return this.post(ENDPOINTS.meDeviceHeartbeat, {});
+  }
 };
 
-// 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;
-  }
-}
-function deleteToken() {
-  const file = tokenPath();
-  try {
-    fs.unlinkSync(file);
-  } catch {
-  }
-}
-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) {
@@ -4768,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 {
   }
 }
@@ -4789,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 {
@@ -4837,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
@@ -4851,8 +5249,7 @@ function logoutCommand() {
 }
 
 // src/commands/sync.ts
-import * as fs7 from "node:fs";
-import * as readline from "node:readline/promises";
+import * as fs4 from "node:fs";
 
 // ../parsers/src/hash.ts
 var FNV_PRIME = 16777619;
@@ -4959,6 +5356,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,
@@ -5007,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;
       }
@@ -5051,6 +5453,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 +5479,9 @@ function upsert(map, sessionId) {
       outTokens: 0,
       cacheReadTokens: 0,
       reasoningTokens: 0,
-      model: ""
+      model: "",
+      client: "codex-cli",
+      channel: "unknown"
     };
     map.set(sessionId, acc);
   }
@@ -5132,6 +5538,8 @@ function parseCursor(input) {
       id: `cursor:${id}`,
       source: "cursor",
       provider: "cursor",
+      client: "cursor",
+      channel: "ide",
       model,
       inTokens,
       outTokens,
@@ -5145,31 +5553,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;
 }
@@ -5298,373 +5706,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,32 +5726,32 @@ function findJsonlFiles(dir) {
   return results;
 }
 function claudeCodeProjectsDir() {
-  const home = os5.homedir();
+  const home = os3.homedir();
   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.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"));
+    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"));
+    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"));
         }
       }
     }
@@ -5708,7 +5760,7 @@ function codexSessionsDirs() {
   const dirs = [];
   for (const c2 of candidates) {
     try {
-      const real = fs6.existsSync(c2) ? fs6.realpathSync(c2) : null;
+      const real = fs3.existsSync(c2) ? fs3.realpathSync(c2) : null;
       if (real && !seen2.has(real)) {
         seen2.add(real);
         dirs.push(c2);
@@ -5726,9 +5778,6 @@ function discoverCodexFiles() {
   return out;
 }
 
-// src/lib/version.ts
-var CLI_VERSION = "0.1.0";
-
 // src/commands/sync.ts
 var BATCH_SIZE = 500;
 function chunk(arr, size) {
@@ -5772,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/`);
@@ -5782,7 +5836,7 @@ async function syncCommand(opts) {
   for (const file of claudeFiles) {
     let text;
     try {
-      text = fs7.readFileSync(file, "utf8");
+      text = fs4.readFileSync(file, "utf8");
     } catch {
       if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
       continue;
@@ -5804,7 +5858,7 @@ async function syncCommand(opts) {
   for (const file of codexFiles) {
     let text;
     try {
-      text = fs7.readFileSync(file, "utf8");
+      text = fs4.readFileSync(file, "utf8");
     } catch {
       if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
       continue;
@@ -5890,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);
@@ -5904,459 +5966,282 @@ 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`.");
-  }
 }
 
 // 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);
-    }
-  };
-}
+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();
-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 });
-    return;
+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 res = await client.uploadSessions(records);
-    health.uploaded += res.accepted;
-    health.duplicates += res.duplicates;
-    log.info("upload", { accepted: res.accepted, duplicates: res.duplicates });
+    const file = stateFilePath();
+    fs5.mkdirSync(path4.dirname(file), { recursive: true });
+    fs5.writeFileSync(file, JSON.stringify(state), { mode: 384 });
   } 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);
+    if (err instanceof Error) {
+      console.warn(`watch-state write failed: ${err.message}`);
     }
-    log.warn(`Upload failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function freshClaudeRecords(filePath, log) {
-  let text;
+function statFile(p) {
   try {
-    text = fs8.readFileSync(filePath, "utf8");
-  } catch {
-    log.debug(`Could not read ${filePath} \u2014 skipping`);
-    return [];
-  }
-  let records;
-  try {
-    records = parseClaudeCode(text);
+    const s = fs5.statSync(p);
+    return { size: s.size, mtimeMs: s.mtimeMs };
   } 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 null;
   }
-  return fresh;
 }
-function freshCodexRecords(filePath, log) {
+function parseAndFilter(filePath, verbose) {
   let text;
   try {
-    text = fs8.readFileSync(filePath, "utf8");
+    text = fs5.readFileSync(filePath, "utf8");
   } catch {
+    if (verbose) warn(`Could not read ${filePath} \u2014 skipping`);
     return [];
   }
   let records;
   try {
-    records = parseCodex(text);
+    records = parseClaudeCode(text);
   } catch {
+    if (verbose) warn(`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 (!seen.has(r.dedupeKey)) {
+      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)`);
+  if (verbose && fresh.length > 0) {
+    dim(`  ${filePath}: ${fresh.length} new session(s)`);
   }
   return fresh;
 }
+async function upload(client, records, verbose) {
+  if (records.length === 0) return;
+  try {
+    const res = await client.uploadSessions(records);
+    if (verbose) {
+      dim(`  Uploaded ${res.accepted} new, ${res.duplicates} duplicate(s)`);
+    } else {
+      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);
+    }
+    warn(`Upload failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 function makeDebounced(fn, ms) {
   const timers = /* @__PURE__ */ new Map();
-  return (p) => {
-    const existing = timers.get(p);
+  return (path5) => {
+    const existing = timers.get(path5);
     if (existing) clearTimeout(existing);
     timers.set(
-      p,
+      path5,
       setTimeout(() => {
-        timers.delete(p);
-        fn(p);
+        timers.delete(path5);
+        fn(path5);
       }, ms)
     );
   };
 }
 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);
+  const results = [];
+  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()) {
+      results.push(...findJsonlFiles2(full));
+    } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      results.push(full);
+    }
   }
-  return out;
+  return results;
 }
-async function watchJsonlDir(dir, debounceMs, onChange, log) {
-  if (!fs8.existsSync(dir)) {
-    log.debug(`Directory missing \u2014 not watching: ${dir}`);
-    return () => {
-    };
+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 debouncedChange = makeDebounced((p) => {
-    if (p.endsWith(".jsonl")) onChange(p);
+  const client = new ApiClient({
+    apiUrl: opts.apiUrl,
+    token,
+    deviceId: ensureDeviceId(),
+    cliVersion: CLI_VERSION
+  });
+  const debounceMs = opts.interval ?? 2e3;
+  const dir = claudeCodeProjectsDir();
+  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 dynImport = new Function("m", "return import(m)");
-    const chokidarMod = await dynImport("chokidar");
-    const watcher = chokidarMod.watch(`${dir}/**/*.jsonl`, {
+    const chokidar = await new Function("m", "return import(m)")("chokidar");
+    const watcher = chokidar.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();
-    };
+    watcher.on("add", (p) => onChanged(p));
+    watcher.on("change", (p) => onChanged(p));
+    cleanup = () => watcher.close();
+    if (opts.verbose) dim("Using chokidar for file watching");
   } catch {
-  }
-  if (process.platform === "linux") {
-    let lastMtimes = /* @__PURE__ */ new Map();
-    for (const f of findJsonlFiles2(dir)) {
-      try {
-        lastMtimes.set(f, fs8.statSync(f).mtimeMs);
-      } catch {
-      }
-    }
-    const handle = setInterval(() => {
-      const current = findJsonlFiles2(dir);
-      for (const f of current) {
+    if (opts.verbose) dim("chokidar not available; using Node built-in fs.watch");
+    if (process.platform === "linux") {
+      let lastMtimes = /* @__PURE__ */ new Map();
+      for (const f of initialFiles) {
         try {
-          const mtime = fs8.statSync(f).mtimeMs;
-          const prev = lastMtimes.get(f) ?? 0;
-          if (mtime > prev) {
-            lastMtimes.set(f, mtime);
-            debouncedChange(f);
-          }
+          lastMtimes.set(f, fs5.statSync(f).mtimeMs);
         } catch {
         }
       }
-      for (const f of current) {
-        if (!lastMtimes.has(f)) {
-          lastMtimes.set(f, Date.now());
-          debouncedChange(f);
+      const pollInterval = setInterval(() => {
+        const current = findJsonlFiles2(dir);
+        for (const f of current) {
+          try {
+            const mtime = fs5.statSync(f).mtimeMs;
+            const prev = lastMtimes.get(f) ?? 0;
+            if (mtime > prev) {
+              lastMtimes.set(f, mtime);
+              onChanged(f);
+            }
+          } catch {
+          }
         }
-      }
-      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));
+        for (const f of current) {
+          if (!lastMtimes.has(f)) {
+            lastMtimes.set(f, Date.now());
+            onChanged(f);
+          }
         }
-      }
-    } 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;
+        lastMtimes = new Map(current.map((f) => [f, lastMtimes.get(f) ?? 0]));
+      }, debounceMs);
+      cleanup = () => clearInterval(pollInterval);
+    } else {
+      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) {
+            const filename = event.filename;
+            if (filename?.endsWith(".jsonl")) {
+              const fullPath = `${dir}/${filename}`;
+              onChanged(fullPath);
+            }
+          }
+        } catch (err) {
+          if (err instanceof Error && err.name !== "AbortError") {
+            warn(`Watcher error: ${err.message}`);
+          }
+        }
+      })();
+      cleanup = () => controller.abort();
     }
-  };
-  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();
+  function shutdown() {
+    info("Shutting down\u2026");
+    clearInterval(heartbeatTimer);
+    if (cleanup) cleanup();
     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."
-      );
-    }
-  } 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)"}`);
-  }
-}
-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 +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);
@@ -6391,19 +6290,17 @@ function printHelp() {
   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 + 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,15 +6308,8 @@ 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)
   --verbose         Print file change events and upload detail
 
@@ -6449,10 +6339,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 +6356,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 +6368,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 +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.");