token-rats 0.2.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Token Rats contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -86,3 +86,19 @@ Authentication uses a device-code flow:
 Token Rats is open source. The CLI source is in [`packages/cli/`](.) and the parsers are in [`packages/parsers/`](../parsers/). You can inspect exactly what is read from your disk and what is sent to the server.
 
 **Privacy posture:** Token Rats reads usage counts only — never prompts or completions. The parser source is in `packages/parsers/`. We literally can't read what you typed.
+
+
+## Automatic tracking
+
+`token-rats login` installs the background tracker. It reads Claude Code,
+Codex, and Cursor records on startup, then checks for changes every 30 seconds.
+Failed uploads are retried. Use `login --no-daemon` to use manual sync only.
+Use `daemon-status` and `uninstall-daemon` to manage automatic tracking.
+After an upgrade, run `install-daemon` to copy the new runtime into place.
+Custom `--api-url` settings are passed to the installed tracker.
+
+Open `/app/compare` on your Token Rats server to enter a subscription amount
+for a month. Cursor counts are estimates. API estimates are not provider bills.
+See the [counting method](https://github.com/hsalberti/token-rats/blob/main/docs/counting.md).
+
+The CLI and its documentation are MIT licensed. The npm package includes LICENSE.

package/dist/index.js

@@ -11,12 +11,12 @@ async function installCursorCommand(opts = {}) {
   const args = ["install", "-g", "better-sqlite3@^9.4.3"];
   console.log(`\x1B[2m$ ${pm} ${args.join(" ")}\x1B[0m
 `);
-  const exitCode = await new Promise((resolve) => {
+  const exitCode = await new Promise((resolve2) => {
     const child = spawn(pm, args, { stdio: "inherit" });
-    child.on("close", (code) => resolve(code ?? 1));
+    child.on("close", (code) => resolve2(code ?? 1));
     child.on("error", (err) => {
       console.error(`\x1B[31mFailed to launch ${pm}: ${err.message}\x1B[0m`);
-      resolve(1);
+      resolve2(1);
     });
   });
   if (exitCode === 0) {
@@ -35,6 +35,7 @@ async function installCursorCommand(opts = {}) {
 // src/commands/install-daemon.ts
 import { execFile } from "node:child_process";
 import * as fs2 from "node:fs";
+import { createRequire } from "node:module";
 import * as os2 from "node:os";
 import * as path2 from "node:path";
 import { promisify } from "node:util";
@@ -150,6 +151,9 @@ function error(msg) {
 function dim(msg) {
   console.log(color(c.dim, `  ${msg}`));
 }
+function bold(msg) {
+  console.log(isTTY() ? `${c.bold}${msg}${c.reset}` : msg);
+}
 function spinner(label) {
   if (!isTTY()) {
     process.stdout.write(`  ${label}...
@@ -181,8 +185,38 @@ 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 };
+  const entry = path2.resolve(process.argv[1] ?? "");
+  if (!entry.endsWith(".js")) throw new Error("Build the CLI before installing the daemon.");
+  const config = process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+  const runtime = path2.join(config, "token-rats", "runtime");
+  fs2.mkdirSync(runtime, { recursive: true });
+  const script = path2.join(runtime, "index.js");
+  if (entry !== script) fs2.copyFileSync(entry, script);
+  fs2.writeFileSync(path2.join(runtime, "package.json"), '{"type":"module"}\n');
+  const require2 = createRequire(import.meta.url);
+  const sqlPackage = path2.dirname(require2.resolve("sql.js/package.json"));
+  const destination = path2.join(runtime, "node_modules", "sql.js");
+  if (sqlPackage !== destination) fs2.cpSync(sqlPackage, destination, { recursive: true });
+  const runner = path2.join(runtime, "runner.mjs");
+  const settings = Object.fromEntries(
+    ["XDG_CONFIG_HOME", "CLAUDE_CONFIG_DIR", "CODEX_HOME", "APPDATA"].flatMap(
+      (key) => process.env[key] ? [[key, process.env[key]]] : []
+    )
+  );
+  fs2.writeFileSync(
+    runner,
+    `Object.assign(process.env, ${JSON.stringify(settings)});
+await import("./index.js");
+`
+  );
+  return { node: process.execPath, script: runner };
+}
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function systemdArg(value) {
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("$", "$$");
+  return `"${escaped}"`;
 }
 function darwinPlistPath() {
   return path2.join(os2.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
@@ -190,7 +224,7 @@ function darwinPlistPath() {
 function darwinLogDir() {
   return path2.join(os2.homedir(), "Library", "Logs", "token-rats");
 }
-function darwinPlist(node, script) {
+function darwinPlist(node, script, apiUrl) {
   const logDir = darwinLogDir();
   const stdout = path2.join(logDir, "watch.out.log");
   const stderr = path2.join(logDir, "watch.err.log");
@@ -202,28 +236,32 @@ function darwinPlist(node, script) {
   <string>${LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${node}</string>
-    <string>${script}</string>
+    <string>${xml(node)}</string>
+    <string>${xml(script)}</string>
     <string>watch</string>
+    ${apiUrl ? `<string>--api-url</string><string>${xml(apiUrl)}</string>` : ""}
   </array>
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
   <true/>
   <key>StandardOutPath</key>
-  <string>${stdout}</string>
+  <string>${xml(stdout)}</string>
   <key>StandardErrorPath</key>
-  <string>${stderr}</string>
+  <string>${xml(stderr)}</string>
 </dict>
 </plist>
 `;
 }
-async function darwinInstall() {
+async function darwinInstall(apiUrl) {
   const { node, script } = resolveCliPath();
   fs2.mkdirSync(darwinLogDir(), { recursive: true });
   const plistPath = darwinPlistPath();
   fs2.mkdirSync(path2.dirname(plistPath), { recursive: true });
-  fs2.writeFileSync(plistPath, darwinPlist(node, script), { mode: 420 });
+  fs2.writeFileSync(plistPath, darwinPlist(node, script, apiUrl), { mode: 420 });
+  await exec("launchctl", ["bootout", `gui/${process.getuid?.() ?? 0}/${LABEL}`]).catch(
+    () => void 0
+  );
   try {
     await exec("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 0}`, plistPath]);
   } catch {
@@ -255,7 +293,8 @@ 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";
+    if (stdout.split("\n").some((line) => line.endsWith(LABEL) && /^\d+\s/.test(line)))
+      return "running";
     return "stopped";
   } catch {
     return "stopped";
@@ -265,7 +304,7 @@ 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) {
+function linuxUnit(node, script, apiUrl) {
   return `[Unit]
 Description=Token Rats watcher \u2014 live AI usage sync
 After=network-online.target
@@ -273,7 +312,7 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart=${node} ${script} watch
+ExecStart=${systemdArg(node)} ${systemdArg(script)} watch${apiUrl ? ` --api-url ${systemdArg(apiUrl)}` : ""}
 Restart=on-failure
 RestartSec=10s
 Environment=NODE_ENV=production
@@ -282,14 +321,15 @@ Environment=NODE_ENV=production
 WantedBy=default.target
 `;
 }
-async function linuxInstall() {
+async function linuxInstall(apiUrl) {
   const { node, script } = resolveCliPath();
   const unitPath = linuxUnitPath();
   fs2.mkdirSync(path2.dirname(unitPath), { recursive: true });
-  fs2.writeFileSync(unitPath, linuxUnit(node, script), { mode: 420 });
+  fs2.writeFileSync(unitPath, linuxUnit(node, script, apiUrl), { mode: 420 });
   try {
     await exec("systemctl", ["--user", "daemon-reload"]);
     await exec("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
+    await exec("systemctl", ["--user", "restart", LINUX_UNIT]);
   } catch (err) {
     throw new Error(
       `Wrote ${unitPath} but failed to enable+start it: ${err instanceof Error ? err.message : String(err)}`
@@ -319,7 +359,7 @@ async function linuxStatus() {
     return "stopped";
   }
 }
-async function windowsInstall() {
+async function windowsInstall(apiUrl) {
   const { node, script } = resolveCliPath();
   await exec("schtasks", [
     "/Create",
@@ -328,7 +368,7 @@ async function windowsInstall() {
     "/TN",
     WINDOWS_TASK,
     "/TR",
-    `"${node}" "${script}" watch`,
+    `"${node}" "${script}" watch${apiUrl ? ` --api-url "${apiUrl}"` : ""}`,
     "/RL",
     "LIMITED",
     "/F"
@@ -357,21 +397,21 @@ async function windowsStatus() {
     return "not-installed";
   }
 }
-async function installDaemonCommand() {
+async function installDaemonCommand(apiUrl) {
   clearDisconnected();
   try {
     if (process.platform === "darwin") {
-      await darwinInstall();
+      await darwinInstall(apiUrl);
     } else if (process.platform === "linux") {
-      await linuxInstall();
+      await linuxInstall(apiUrl);
     } else if (process.platform === "win32") {
-      await windowsInstall();
+      await windowsInstall(apiUrl);
     } else {
       warn(`No daemon installer for platform ${process.platform}; skipping.`);
       return;
     }
     success("Background watcher installed and running.");
-    dim("It will pick up new sessions from Claude Code logs in real time.");
+    dim("It will pick up sessions from Claude Code, Codex, and Cursor every 30 seconds.");
     dim("Manage it with `token-rats daemon-status` and `token-rats uninstall-daemon`.");
   } catch (err) {
     error(`Failed to install daemon: ${err instanceof Error ? err.message : String(err)}`);
@@ -758,8 +798,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data, path: path5, errorMaps, issueData } = params;
-  const fullPath = [...path5, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -881,11 +921,11 @@ var errorUtil;
 var _ZodEnum_cache;
 var _ZodNativeEnum_cache;
 var ParseInputLazyPath = class {
-  constructor(parent, value, path5, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path5;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -4320,7 +4360,7 @@ var z = /* @__PURE__ */ Object.freeze({
 });
 
 // ../contracts/src/session.ts
-var Source = z.enum(["claude-code", "cursor", "codex"]);
+var Source = z.enum(["claude-code", "cursor", "codex", "openrouter", "openai"]);
 var Provider = z.enum([
   "anthropic",
   "openai",
@@ -4330,13 +4370,18 @@ var Provider = z.enum([
   "unknown"
 ]);
 var SessionChannel = z.enum(["cli", "ide", "api", "proxy", "local", "unknown"]);
+var ID_RE = /^[A-Za-z0-9._:/+ -]+$/;
+var MODEL_RE = /^[A-Za-z0-9._:/+ -]+$/;
+var DEDUPE_KEY_RE = /^[A-Za-z0-9._:-]+$/;
+var CLIENT_RE = /^[A-Za-z0-9._-]+$/;
 var SessionRecord = z.object({
-  id: z.string().min(1),
+  accountingVersion: z.literal(2).optional(),
+  id: z.string().min(1).max(256).regex(ID_RE),
   source: Source,
   provider: Provider.optional(),
-  client: z.string().min(1).max(64).optional(),
+  client: z.string().min(1).max(64).regex(CLIENT_RE).optional(),
   channel: SessionChannel.optional(),
-  model: z.string().min(1),
+  model: z.string().min(1).max(128).regex(MODEL_RE),
   inTokens: z.number().int().nonnegative(),
   outTokens: z.number().int().nonnegative(),
   /** Anthropic cache reads / OpenAI `cached_input_tokens`. Billed cheap-or-free. */
@@ -4348,7 +4393,7 @@ var SessionRecord = z.object({
   costUsdCents: z.number().int().nonnegative(),
   startedAt: z.number().int().positive(),
   endedAt: z.number().int().positive(),
-  dedupeKey: z.string().min(1)
+  dedupeKey: z.string().min(1).max(128).regex(DEDUPE_KEY_RE)
 });
 
 // ../contracts/src/user.ts
@@ -4358,6 +4403,27 @@ var ProfileAttributionEntry = z.object({
   costUsdCents: z.number().int().nonnegative(),
   sessions: z.number().int().nonnegative()
 });
+var GithubProject = z.object({
+  name: z.string().min(1).max(100),
+  fullName: z.string().min(3).max(201).regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/),
+  url: z.string().url().startsWith("https://github.com/"),
+  description: z.string().max(500).nullable()
+}).superRefine((project, context) => {
+  const repositoryName = project.fullName.split("/")[1];
+  const canonicalUrl = `https://github.com/${project.fullName}`;
+  if (repositoryName?.toLowerCase() !== project.name.toLowerCase()) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "GitHub project name is invalid" });
+  }
+  if (project.url.toLowerCase() !== canonicalUrl.toLowerCase()) {
+    context.addIssue({ code: z.ZodIssueCode.custom, message: "GitHub project URL is invalid" });
+  }
+});
+var GithubProjects = z.array(GithubProject).max(3).refine(
+  (projects) => new Set(projects.map((project) => project.fullName.toLowerCase())).size === projects.length,
+  {
+    message: "GitHub projects must be unique"
+  }
+);
 var User = z.object({
   id: z.string(),
   handle: z.string(),
@@ -4377,13 +4443,20 @@ var User = z.object({
    * (other readers never see this field). `null` when GitHub didn't return a
    * verified email — the user sees a banner asking them to add one.
    */
-  email: z.string().email().nullable().optional()
+  email: z.string().email().nullable().optional(),
+  /** Full text is self-only; public profiles receive agentInstructionsPreview instead. */
+  agentInstructions: z.string().max(2e4).nullable().optional(),
+  githubProjects: GithubProjects.optional()
 });
 var PublicProfileSettings = z.object({
   publicProfile: z.boolean().optional(),
-  bio: z.string().max(200).nullable().optional()
+  bio: z.string().max(200).nullable().optional(),
+  agentInstructions: z.string().max(2e4).nullable().optional(),
+  githubProjects: GithubProjects.optional()
 });
 var Profile = User.extend({
+  /** The first ten lines of the owner's saved agent instructions. */
+  agentInstructionsPreview: z.string().max(4e3).nullable().optional(),
   totals: z.object({
     today: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() }),
     week: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() }),
@@ -5013,13 +5086,43 @@ var CliVersionResponse = z.object({
   upgradeCommand: z.string().min(1)
 });
 
+// ../contracts/src/community.ts
+var PostKind = z.enum(["idea", "agents-md", "showcase", "question"]);
+var CreatePostRequest = z.object({
+  kind: PostKind,
+  title: z.string().trim().min(3).max(160),
+  body: z.string().trim().min(1).max(3e4)
+});
+var CreateReplyRequest = z.object({ body: z.string().trim().min(1).max(1e4) });
+var CommunityPost = CreatePostRequest.extend({
+  id: z.string(),
+  handle: z.string(),
+  createdAt: z.number(),
+  replies: z.number()
+});
+var CommunityReply = z.object({
+  id: z.string(),
+  body: z.string(),
+  handle: z.string(),
+  createdAt: z.number()
+});
+
+// ../contracts/src/comparison.ts
+var UsageMonth = z.string().regex(/^20\d{2}-(0[1-9]|1[0-2])$/);
+var SubscriptionSpendRequest = z.object({
+  month: UsageMonth,
+  source: z.enum(["claude-code", "codex", "cursor"]),
+  label: z.string().trim().min(1).max(80),
+  paidUsdCents: z.number().int().min(0).max(1e8)
+});
+
 // src/lib/api.ts
 var DEFAULT_API_URL = "https://api.tokenrats.com";
 function isTransient(status) {
   return status >= 500 || status === 408 || status === 429;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 var ApiError2 = class extends Error {
   constructor(status, body) {
@@ -5061,7 +5164,7 @@ var ApiClient = class {
     let lastErr;
     while (attempt <= maxRetries) {
       try {
-        const res = await fetch(url, init);
+        const res = await fetch(url, { ...init, signal: AbortSignal.timeout(3e4) });
         if (res.ok || !isTransient(res.status)) return res;
         lastErr = new ApiError2(res.status, await res.text());
       } catch (err) {
@@ -5081,8 +5184,8 @@ var ApiClient = class {
     }
     return new ApiError2(res.status, body);
   }
-  async post(path5, body) {
-    const url = `${this.apiUrl}${path5}`;
+  async post(path4, body) {
+    const url = `${this.apiUrl}${path4}`;
     const res = await this.fetchWithRetry(url, {
       method: "POST",
       headers: this.headers(),
@@ -5091,8 +5194,8 @@ var ApiClient = class {
     if (!res.ok) throw await this.failedResponseToError(res);
     return res.json();
   }
-  async get(path5) {
-    const url = `${this.apiUrl}${path5}`;
+  async get(path4) {
+    const url = `${this.apiUrl}${path4}`;
     const res = await this.fetchWithRetry(url, {
       method: "GET",
       headers: this.headers()
@@ -5128,6 +5231,18 @@ var ApiClient = class {
   async uploadSessions(sessions) {
     return this.post(ENDPOINTS.sessions, { sessions });
   }
+  /** GET /v1/u/:handle */
+  async getProfile(handle) {
+    return this.get(ENDPOINTS.profile(handle));
+  }
+  /** GET /v1/u/:handle/heatmap?range=30d — used to derive the current streak. */
+  async getHeatmap(handle) {
+    return this.get(ENDPOINTS.profileHeatmap(handle));
+  }
+  /** GET /v1/trending?range — global public leaderboard, used to derive rank. */
+  async getTrending(range = "30d") {
+    return this.get(`${ENDPOINTS.trending}?range=${range}`);
+  }
   /** GET /v1/me/devices */
   async getDevices() {
     return this.get(ENDPOINTS.meDevices);
@@ -5138,8 +5253,56 @@ var ApiClient = class {
   }
 };
 
+// package.json
+var package_default = {
+  name: "token-rats",
+  version: "0.3.0",
+  description: "Track Claude Code, Codex, and Cursor usage and compare AI subscriptions.",
+  license: "MIT",
+  type: "module",
+  bin: {
+    "token-rats": "./dist/index.js"
+  },
+  files: ["dist", "README.md", "LICENSE"],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hsalberti/token-rats.git",
+    directory: "packages/cli"
+  },
+  homepage: "https://tokenrats.com",
+  keywords: ["claude", "claude-code", "cursor", "tokens", "leaderboard", "ai-usage"],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsc --noEmit -p tsconfig.json && node build.mjs",
+    typecheck: "tsc --noEmit",
+    dev: "tsx src/index.ts",
+    test: "vitest run",
+    prepublishOnly: "node build.mjs"
+  },
+  optionalDependencies: {
+    clipboardy: "^4.0.0",
+    open: "^10.1.0"
+  },
+  devDependencies: {
+    "@token-rats/contracts": "workspace:*",
+    "@token-rats/parsers": "workspace:*",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "22.10.2",
+    "@types/sql.js": "^1.4.11",
+    esbuild: "^0.24.2",
+    tsx: "4.19.2",
+    typescript: "5.7.2",
+    vitest: "2.1.8"
+  },
+  dependencies: {
+    "sql.js": "^1.14.1"
+  }
+};
+
 // src/lib/cli-version.ts
-var CLI_VERSION = "0.2.0";
+var CLI_VERSION = package_default.version;
 
 // src/commands/login.ts
 async function openBrowser(url) {
@@ -5235,7 +5398,7 @@ async function loginCommand(opts) {
     return;
   }
   info("Installing background watcher so usage uploads automatically\u2026");
-  await installDaemonCommand();
+  await installDaemonCommand(opts.apiUrl);
 }
 
 // src/commands/logout.ts
@@ -5248,7 +5411,8 @@ function logoutCommand() {
   info("Logged out. Your local token has been removed.");
 }
 
-// src/commands/sync.ts
+// src/lib/collect.ts
+import { createHash } from "node:crypto";
 import * as fs4 from "node:fs";
 
 // ../parsers/src/hash.ts
@@ -5281,6 +5445,7 @@ function parseClaudeCode(input) {
     text = new TextDecoder().decode(input instanceof ArrayBuffer ? new Uint8Array(input) : input);
   }
   const sessions = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
   for (const rawLine of text.split("\n")) {
     const line = rawLine.trim();
     if (line.length === 0) continue;
@@ -5314,7 +5479,8 @@ function parseClaudeCode(input) {
         outTokens: 0,
         cacheReadTokens: 0,
         cacheWriteTokens: 0,
-        model: ""
+        model: "",
+        modelAt: 0
       };
       sessions.set(sessionId, acc);
     }
@@ -5326,16 +5492,32 @@ function parseClaudeCode(input) {
     const message = ev.message;
     if (typeof message !== "object" || message === null) continue;
     const msg = message;
-    if (typeof msg.model === "string" && msg.model.length > 0) {
+    if (typeof msg.model === "string" && msg.model.length > 0 && timestamp >= acc.modelAt) {
       acc.model = msg.model;
+      acc.modelAt = timestamp;
     }
     const usage = msg.usage;
     if (typeof usage === "object" && usage !== null) {
       const u = usage;
-      acc.inTokens += toNonNegInt(u.input_tokens);
-      acc.outTokens += toNonNegInt(u.output_tokens);
-      acc.cacheReadTokens += toNonNegInt(u.cache_read_input_tokens);
-      acc.cacheWriteTokens += toNonNegInt(u.cache_creation_input_tokens);
+      const counts = {
+        input: toNonNegInt(u.input_tokens),
+        output: toNonNegInt(u.output_tokens),
+        read: toNonNegInt(u.cache_read_input_tokens),
+        write: toNonNegInt(u.cache_creation_input_tokens)
+      };
+      const key = typeof msg.id === "string" ? `${sessionId}:${msg.id}` : null;
+      const old = key ? messages.get(key) : void 0;
+      const next = {
+        input: Math.max(old?.input ?? 0, counts.input),
+        output: Math.max(old?.output ?? 0, counts.output),
+        read: Math.max(old?.read ?? 0, counts.read),
+        write: Math.max(old?.write ?? 0, counts.write)
+      };
+      acc.inTokens += next.input - (old?.input ?? 0);
+      acc.outTokens += next.output - (old?.output ?? 0);
+      acc.cacheReadTokens += next.read - (old?.read ?? 0);
+      acc.cacheWriteTokens += next.write - (old?.write ?? 0);
+      if (key) messages.set(key, next);
     }
   }
   const results = [];
@@ -5402,12 +5584,15 @@ function parseCodex(input) {
     const payload = typeof ev.payload === "object" && ev.payload !== null ? ev.payload : null;
     if (type === "session_meta" && payload) {
       const id = typeof payload.id === "string" ? payload.id : null;
-      if (!id) continue;
+      if (!id) {
+        currentSessionId = null;
+        continue;
+      }
       currentSessionId = id;
       const metaTs = parseTimestamp(payload.timestamp) || ts;
       const acc2 = upsert(sessions, id);
       const metaSource = typeof payload.source === "string" ? payload.source : null;
-      acc2.channel = metaSource === "cli" ? "cli" : metaSource === "api" ? "api" : "unknown";
+      acc2.channel = metaSource === "api" ? "api" : metaSource ? "cli" : "unknown";
       acc2.client = acc2.channel === "cli" ? "codex-cli" : "codex";
       if (metaTs > 0 && (acc2.startedAt === 0 || metaTs < acc2.startedAt)) {
         acc2.startedAt = metaTs;
@@ -5422,7 +5607,10 @@ function parseCodex(input) {
       if (ts > acc.endedAt) acc.endedAt = ts;
     }
     if (type === "turn_context" && payload && typeof payload.model === "string") {
-      acc.model = payload.model;
+      if (ts >= acc.modelAt) {
+        acc.model = payload.model;
+        acc.modelAt = ts;
+      }
       continue;
     }
     if (type === "event_msg" && payload && payload.type === "token_count") {
@@ -5435,8 +5623,10 @@ function parseCodex(input) {
       const cachedInput = toNonNegInt2(t.cached_input_tokens);
       const output = toNonNegInt2(t.output_tokens);
       const reasoning = toNonNegInt2(t.reasoning_output_tokens);
+      if (ts < acc.usageAt) continue;
+      acc.usageAt = ts;
       acc.inTokens = Math.max(0, inputTotal - cachedInput);
-      acc.outTokens = output + reasoning;
+      acc.outTokens = output;
       acc.cacheReadTokens = cachedInput;
       acc.reasoningTokens = reasoning;
     }
@@ -5480,6 +5670,8 @@ function upsert(map, sessionId) {
       cacheReadTokens: 0,
       reasoningTokens: 0,
       model: "",
+      usageAt: 0,
+      modelAt: 0,
       client: "codex-cli",
       channel: "unknown"
     };
@@ -5680,7 +5872,7 @@ async function extractCursorGenerations() {
       dbCount: 0
     };
   }
-  const seen2 = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
   const rows = [];
   let openFailures = 0;
   for (const p of dbPaths) {
@@ -5692,8 +5884,8 @@ async function extractCursorGenerations() {
       continue;
     }
     for (const r of perDb) {
-      if (seen2.has(r.id)) continue;
-      seen2.add(r.id);
+      if (seen.has(r.id)) continue;
+      seen.add(r.id);
       rows.push(r);
     }
   }
@@ -5727,6 +5919,7 @@ function findJsonlFiles(dir) {
 }
 function claudeCodeProjectsDir() {
   const home = os3.homedir();
+  if (process.env.CLAUDE_CONFIG_DIR) return path3.join(process.env.CLAUDE_CONFIG_DIR, "projects");
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
     return path3.join(profile, ".claude", "projects");
@@ -5740,13 +5933,19 @@ function discoverClaudeCodeFiles() {
 function codexSessionsDirs() {
   const home = os3.homedir();
   const candidates = [];
+  if (process.env.CODEX_HOME) {
+    candidates.push(path3.join(process.env.CODEX_HOME, "sessions"));
+    candidates.push(path3.join(process.env.CODEX_HOME, "archived_sessions"));
+  }
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
     candidates.push(path3.join(profile, ".codex", "sessions"));
+    candidates.push(path3.join(profile, ".codex", "archived_sessions"));
     const appData = process.env.APPDATA ?? path3.join(profile, "AppData", "Roaming");
     candidates.push(path3.join(appData, "Codex", "sessions"));
   } else {
     candidates.push(path3.join(home, ".codex", "sessions"));
+    candidates.push(path3.join(home, ".codex", "archived_sessions"));
     const snapRoot = path3.join(home, "snap", "codex");
     if (fs3.existsSync(snapRoot)) {
       for (const entry of fs3.readdirSync(snapRoot, { withFileTypes: true })) {
@@ -5756,13 +5955,13 @@ function codexSessionsDirs() {
       }
     }
   }
-  const seen2 = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
   const dirs = [];
   for (const c2 of candidates) {
     try {
       const real = fs3.existsSync(c2) ? fs3.realpathSync(c2) : null;
-      if (real && !seen2.has(real)) {
-        seen2.add(real);
+      if (real && !seen.has(real)) {
+        seen.add(real);
         dirs.push(c2);
       }
     } catch {
@@ -5778,8 +5977,126 @@ function discoverCodexFiles() {
   return out;
 }
 
+// src/lib/collect.ts
+async function collectSessions() {
+  function read(files) {
+    return files.map((file) => fs4.readFileSync(file, "utf8")).join("\n");
+  }
+  const claude = parseClaudeCode(read(discoverClaudeCodeFiles()));
+  const codex = parseCodex(read(discoverCodexFiles()));
+  const { rows } = await extractCursorGenerations();
+  const cursor = parseCursor(JSON.stringify(rows));
+  return [...claude, ...codex, ...cursor].map((record) => ({
+    ...record,
+    accountingVersion: 2,
+    dedupeKey: createHash("sha256").update(
+      JSON.stringify([
+        record.id,
+        record.source,
+        record.model,
+        record.startedAt,
+        record.inTokens,
+        record.outTokens,
+        record.cacheReadTokens ?? 0,
+        record.cacheWriteTokens ?? 0,
+        record.reasoningTokens ?? 0
+      ])
+    ).digest("hex")
+  }));
+}
+var SyncQueue = class {
+  acknowledged = /* @__PURE__ */ new Map();
+  async flush(records, upload) {
+    const fresh = records.filter((r) => this.acknowledged.get(r.id) !== JSON.stringify(r));
+    for (let i = 0; i < fresh.length; i += 90) {
+      const batch = fresh.slice(i, i + 90);
+      await upload(batch);
+      for (const record of batch) this.acknowledged.set(record.id, JSON.stringify(record));
+    }
+    return fresh.length;
+  }
+};
+function createCollector() {
+  let signature = "";
+  let records = [];
+  return async () => {
+    const files = [
+      ...discoverClaudeCodeFiles(),
+      ...discoverCodexFiles(),
+      ...discoverWorkspaceDbs().flatMap((file) => [file, `${file}-wal`])
+    ].sort();
+    const next = JSON.stringify(
+      files.map((file) => {
+        try {
+          const stat = fs4.statSync(file);
+          return [file, stat.size, stat.mtimeMs];
+        } catch {
+          return [file, null];
+        }
+      })
+    );
+    if (next !== signature) {
+      records = await collectSessions();
+      signature = next;
+    }
+    return records;
+  };
+}
+
 // src/commands/sync.ts
-var BATCH_SIZE = 500;
+var BATCH_SIZE = 90;
+var WEB_ORIGIN = "https://tokenrats.com";
+function currentStreakFromDays(days, todayUtc) {
+  const active = days.slice().sort();
+  if (active.length === 0) return 0;
+  const last = active[active.length - 1];
+  const yesterday = (() => {
+    const d = /* @__PURE__ */ new Date(`${todayUtc}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() - 1);
+    return d.toISOString().slice(0, 10);
+  })();
+  if (last !== todayUtc && last !== yesterday) return 0;
+  let streak = 1;
+  for (let i = active.length - 1; i >= 1; i--) {
+    const prev = (/* @__PURE__ */ new Date(`${active[i - 1]}T00:00:00Z`)).getTime();
+    const curr = (/* @__PURE__ */ new Date(`${active[i]}T00:00:00Z`)).getTime();
+    if (Math.round((curr - prev) / 864e5) === 1) streak++;
+    else break;
+  }
+  return streak;
+}
+async function printSyncHero(client) {
+  let handle;
+  try {
+    const me = await client.getMe();
+    handle = me.user.handle;
+  } catch {
+    return;
+  }
+  const todayUtc = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const [trending, heatmap] = await Promise.all([
+    client.getTrending("30d").catch(() => null),
+    client.getHeatmap(handle).catch(() => null)
+  ]);
+  const rank = trending?.rows.find((r) => r.handle === handle)?.rank ?? null;
+  const streak = heatmap === null ? 0 : currentStreakFromDays(
+    heatmap.heatmap.days.filter((d) => d.sessions > 0).map((d) => d.day),
+    todayUtc
+  );
+  const profileUrl = `${WEB_ORIGIN}/u/${handle}`;
+  console.log("");
+  bold("\u{1F400} Your Token Rats standing");
+  if (rank !== null) info(`Global rank: #${rank}`);
+  if (streak > 0) info(`Current streak: ${streak} day${streak === 1 ? "" : "s"} \u{1F525}`);
+  info(`Profile: ${profileUrl}`);
+  const rankPart = rank !== null ? `ranked #${rank} globally` : "on the board";
+  const streakPart = streak > 0 ? ` on a ${streak}-day streak` : "";
+  const tweet = `I'm ${rankPart}${streakPart} on @tokenrats \u2014 tracking my AI coding tokens. \u{1F400}`;
+  const intent = `https://x.com/intent/tweet?text=${encodeURIComponent(tweet)}&url=${encodeURIComponent(profileUrl)}`;
+  console.log("");
+  dim("Brag about it \u2014 Post to X:");
+  console.log(`  ${process.stdout.isTTY ? `${c.cyan}${intent}${c.reset}` : intent}`);
+}
 function chunk(arr, size) {
   const chunks = [];
   for (let i = 0; i < arr.length; i += size) {
@@ -5787,34 +6104,6 @@ function chunk(arr, size) {
   }
   return chunks;
 }
-function mergeBySessionId(records) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const r of records) {
-    const existing = byId.get(r.id);
-    if (!existing) {
-      byId.set(r.id, { ...r });
-      continue;
-    }
-    existing.inTokens += r.inTokens;
-    existing.outTokens += r.outTokens;
-    if (r.startedAt < existing.startedAt) existing.startedAt = r.startedAt;
-    if (r.endedAt > existing.endedAt) {
-      existing.endedAt = r.endedAt;
-      existing.model = r.model;
-    }
-  }
-  for (const rec of byId.values()) {
-    rec.costUsdCents = 0;
-    rec.dedupeKey = computeDedupeKey(
-      rec.source,
-      rec.model,
-      rec.startedAt,
-      rec.inTokens,
-      rec.outTokens
-    );
-  }
-  return Array.from(byId.values());
-}
 async function syncCommand(opts) {
   const token = loadToken();
   if (!token && !opts.dryRun) {
@@ -5827,92 +6116,8 @@ async function syncCommand(opts) {
     deviceId: ensureDeviceId(),
     cliVersion: CLI_VERSION
   });
-  const claudeFiles = discoverClaudeCodeFiles();
-  if (opts.verbose) {
-    info(`Found ${claudeFiles.length} Claude Code file(s) in ~/.claude/projects/`);
-    for (const f of claudeFiles) dim(`  ${f}`);
-  }
-  const claudeSessions = [];
-  for (const file of claudeFiles) {
-    let text;
-    try {
-      text = fs4.readFileSync(file, "utf8");
-    } catch {
-      if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
-      continue;
-    }
-    try {
-      const records = parseClaudeCode(text);
-      claudeSessions.push(...records);
-      if (opts.verbose) dim(`  ${file}: ${records.length} session(s)`);
-    } catch {
-      if (opts.verbose) warn(`Failed to parse ${file} \u2014 skipping`);
-    }
-  }
-  const codexFiles = discoverCodexFiles();
-  if (opts.verbose) {
-    info(`Found ${codexFiles.length} Codex rollout file(s)`);
-    for (const f of codexFiles) dim(`  ${f}`);
-  }
-  const codexSessions = [];
-  for (const file of codexFiles) {
-    let text;
-    try {
-      text = fs4.readFileSync(file, "utf8");
-    } catch {
-      if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
-      continue;
-    }
-    try {
-      const records = parseCodex(text);
-      codexSessions.push(...records);
-      if (opts.verbose) dim(`  ${file}: ${records.length} session(s)`);
-    } catch {
-      if (opts.verbose) warn(`Failed to parse ${file} \u2014 skipping`);
-    }
-  }
-  const cursorSessions = [];
-  const { rows, skipped, dbCount } = await extractCursorGenerations();
-  if (skipped) {
-    warn(skipped);
-  } else if (dbCount === 0) {
-    if (opts.verbose) info("No Cursor workspace storage found \u2014 skipping Cursor source");
-  } else if (rows.length > 0) {
-    if (opts.verbose) info(`Scanned ${dbCount} Cursor workspace DB(s)`);
-    try {
-      const records = parseCursor(JSON.stringify(rows));
-      cursorSessions.push(...records);
-      if (opts.verbose) {
-        dim(
-          `  Cursor: ${rows.length} generation event(s) \u2192 ${records.length} session(s) (tokens estimated, see help)`
-        );
-      }
-    } catch {
-      if (opts.verbose) warn("Failed to parse Cursor rows \u2014 skipping");
-    }
-  } else if (opts.verbose) {
-    dim(`  Scanned ${dbCount} Cursor workspace DB(s): no AI generations found`);
-  }
-  const mergedClaude = mergeBySessionId(claudeSessions);
-  if (opts.verbose && mergedClaude.length !== claudeSessions.length) {
-    dim(
-      `  Merged ${claudeSessions.length} Claude Code records into ${mergedClaude.length} sessions (subagent files folded into parents)`
-    );
-  }
-  const mergedCodex = mergeBySessionId(codexSessions);
-  const seen2 = /* @__PURE__ */ new Set();
-  const allSessions = [];
-  for (const s of [...mergedClaude, ...mergedCodex, ...cursorSessions]) {
-    if (!seen2.has(s.dedupeKey)) {
-      seen2.add(s.dedupeKey);
-      allSessions.push(s);
-    }
-  }
-  const sources = [];
-  if (claudeSessions.length > 0) sources.push("Claude Code");
-  if (codexSessions.length > 0) sources.push("Codex");
-  if (cursorSessions.length > 0) sources.push("Cursor");
-  const sourceStr = sources.length > 0 ? sources.join(" + ") : "no sources";
+  const allSessions = await collectSessions();
+  const sourceStr = [...new Set(allSessions.map((record) => record.source))].join(" + ") || "no sources";
   if (allSessions.length === 0) {
     info(`No sessions found from ${sourceStr}.`);
     return;
@@ -5966,137 +6171,25 @@ async function syncCommand(opts) {
   success(
     `Synced ${allSessions.length} sessions (${totalAccepted} new, ${totalDuplicates} already on server) from ${sourceStr}`
   );
-}
-
-// src/commands/watch.ts
-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 : {};
+    await printSyncHero(client);
   } 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 = fs5.readFileSync(filePath, "utf8");
-  } catch {
-    if (verbose) warn(`Could not read ${filePath} \u2014 skipping`);
-    return [];
-  }
-  let records;
-  try {
-    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)) {
-      seen.add(r.dedupeKey);
-      fresh.push(r);
-    }
-  }
-  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 (path5) => {
-    const existing = timers.get(path5);
-    if (existing) clearTimeout(existing);
-    timers.set(
-      path5,
-      setTimeout(() => {
-        timers.delete(path5);
-        fn(path5);
-      }, ms)
-    );
-  };
-}
-function findJsonlFiles2(dir) {
-  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 results;
-}
+
+// src/commands/watch.ts
 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);
+  if (!token || isDisconnected()) {
+    error("Run `token-rats login` before you start the tracker.");
+    process.exitCode = 1;
+    return;
+  }
+  const interval = opts.interval ?? 3e4;
+  if (!Number.isFinite(interval) || interval < 1e3) {
+    error("The interval must be at least 1000 milliseconds.");
+    process.exitCode = 1;
+    return;
   }
   const client = new ApiClient({
     apiUrl: opts.apiUrl,
@@ -6104,143 +6197,53 @@ async function watchCommand(opts) {
     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;
+  const queue = new SyncQueue();
+  const collect = createCollector();
+  let stopped = false;
+  let wake;
+  const stop = () => {
+    stopped = true;
+    wake?.();
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  info("Tracking Claude Code, Codex, and Cursor. Press Ctrl-C to stop.");
   try {
-    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) => onChanged(p));
-    watcher.on("change", (p) => onChanged(p));
-    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");
-    if (process.platform === "linux") {
-      let lastMtimes = /* @__PURE__ */ new Map();
-      for (const f of initialFiles) {
-        try {
-          lastMtimes.set(f, fs5.statSync(f).mtimeMs);
-        } catch {
-        }
-      }
-      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 {
-          }
+    while (!stopped) {
+      try {
+        const count = await queue.flush(await collect(), (batch) => client.uploadSessions(batch));
+        if (count === 0) await client.uploadSessions([]);
+        await client.heartbeat();
+        if (count > 0) success(`Synced ${count} changed record(s).`);
+      } catch (err) {
+        if (err instanceof DeviceRevokedError) {
+          markDisconnected();
+          deleteToken();
+          error("Device disconnected. Run `token-rats login` to reconnect.");
+          break;
         }
-        for (const f of current) {
-          if (!lastMtimes.has(f)) {
-            lastMtimes.set(f, Date.now());
-            onChanged(f);
-          }
+        if (err instanceof ApiError2 && err.status === 401) {
+          error("Session expired. Run `token-rats login` again.");
+          process.exitCode = 1;
+          break;
         }
-        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();
+        warn(
+          `Sync failed. The next scan will retry: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      if (stopped) break;
+      await new Promise((resolve2) => {
+        const timer = setTimeout(resolve2, interval);
+        wake = () => {
+          clearTimeout(timer);
+          resolve2();
+        };
+      });
     }
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
   }
-  function shutdown() {
-    info("Shutting down\u2026");
-    clearInterval(heartbeatTimer);
-    if (cleanup) cleanup();
-    process.exit(0);
-  }
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
 }
 
 // src/commands/whoami.ts
@@ -6284,14 +6287,14 @@ function getVersion() {
 }
 function printHelp() {
   console.log(`
-\x1B[1mtoken-rats\x1B[0m \u2014 Strava for AI token burn  \x1B[2mv${getVersion()}\x1B[0m
+\x1B[1mtoken-rats\x1B[0m \u2014 AI usage tracker and community  \x1B[2mv${getVersion()}\x1B[0m
 
 \x1B[1mUsage:\x1B[0m
   token-rats <command> [flags]
 
 \x1B[1mCommands:\x1B[0m
   login              Authenticate with Token Rats (opens browser); installs the background watcher by default
-  sync               Read local Claude Code + Cursor logs and upload counts
+  sync               Read local Claude Code, Codex + Cursor logs and upload counts
   watch              Watch logs in real-time; upload new sessions as they appear
   whoami             Show the currently signed-in account + device id
   logout             Clear your stored credentials
@@ -6310,7 +6313,7 @@ function printHelp() {
   --verbose         Print discovered files and per-file record counts
 
 \x1B[1mFlags (watch only):\x1B[0m
-  --interval <ms>   Debounce window in ms before uploading (default: 2000)
+  --interval <ms>   Scan interval in ms (default: 30000, minimum: 1000)
   --verbose         Print file change events and upload detail
 
 \x1B[1mPrivacy:\x1B[0m
@@ -6397,7 +6400,7 @@ async function main() {
       await installCursorCommand();
       break;
     case "install-daemon":
-      await installDaemonCommand();
+      await installDaemonCommand(apiUrl);
       break;
     case "uninstall-daemon":
       await uninstallDaemonCommand();

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "token-rats",
-  "version": "0.2.0",
-  "description": "Sync your Claude Code + Cursor token usage to your Token Rats leaderboard.",
-  "license": "UNLICENSED",
+  "version": "0.3.0",
+  "description": "Track Claude Code, Codex, and Cursor usage and compare AI subscriptions.",
+  "license": "MIT",
   "type": "module",
   "bin": {
     "token-rats": "./dist/index.js"
   },
-  "files": ["dist", "README.md"],
+  "files": ["dist", "README.md", "LICENSE"],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hsalberti/token-rats.git",
@@ -26,7 +26,6 @@
     "prepublishOnly": "node build.mjs"
   },
   "optionalDependencies": {
-    "chokidar": "^3.6.0",
     "clipboardy": "^4.0.0",
     "open": "^10.1.0"
   },