tokelytics 0.1.0

package/bin/tokelytics.mjs

@@ -0,0 +1,2891 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { promises as fs3 } from "node:fs";
+import * as path5 from "node:path";
+
+// src/paths.ts
+import { promises as fs2 } from "node:fs";
+import * as os3 from "node:os";
+import * as path4 from "node:path";
+import { randomUUID } from "node:crypto";
+
+// ../packages/core/dist/types.js
+function emptyScanState() {
+  return { files: {} };
+}
+
+// ../packages/core/dist/model-priority.js
+var MODEL_PRIORITY = {
+  fable: 6,
+  mythos: 6,
+  "gpt-5.5": 5,
+  "gpt-5.4": 4,
+  "gpt-5": 4,
+  opus: 3,
+  sonnet: 2,
+  haiku: 1
+};
+function modelPriority(model) {
+  if (!model)
+    return 0;
+  const m = model.toLowerCase();
+  for (const [keyword, priority] of Object.entries(MODEL_PRIORITY)) {
+    if (m.includes(keyword))
+      return priority;
+  }
+  return 0;
+}
+
+// ../packages/core/dist/util.js
+function projectNameFromCwd(cwd) {
+  if (!cwd)
+    return "unknown";
+  const parts = cwd.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
+  if (parts.length >= 2)
+    return parts.slice(-2).join("/");
+  return parts[parts.length - 1] || "unknown";
+}
+function toCount(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.trunc(v) : 0;
+}
+
+// ../packages/core/dist/aggregate.js
+function dayOf(ts) {
+  return ts && ts.length >= 10 ? ts.slice(0, 10) : "";
+}
+function hourOf(ts) {
+  if (!ts || ts.length < 13)
+    return null;
+  const h = Number.parseInt(ts.slice(11, 13), 10);
+  return Number.isFinite(h) ? h : null;
+}
+function rollupId(provider, day) {
+  return `${provider}_${day}`;
+}
+function aggregateSession(sessionId, turns) {
+  const agg = {
+    sessionId,
+    provider: turns[0]?.provider ?? "claude",
+    project: "unknown",
+    gitBranch: "",
+    firstTs: "",
+    lastTs: "",
+    model: "",
+    turnCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    cachedInputTokens: 0,
+    reasoningTokens: 0
+  };
+  for (const t of turns) {
+    agg.turnCount++;
+    agg.inputTokens += t.inputTokens;
+    agg.outputTokens += t.outputTokens;
+    agg.cacheReadTokens += t.cacheReadTokens;
+    agg.cacheCreationTokens += t.cacheCreationTokens;
+    agg.cachedInputTokens += t.cachedInputTokens;
+    agg.reasoningTokens += t.reasoningTokens;
+    if (t.ts && (!agg.firstTs || t.ts < agg.firstTs))
+      agg.firstTs = t.ts;
+    if (t.ts && (!agg.lastTs || t.ts > agg.lastTs))
+      agg.lastTs = t.ts;
+    if (t.project && agg.project === "unknown")
+      agg.project = t.project;
+    if (t.gitBranch && !agg.gitBranch)
+      agg.gitBranch = t.gitBranch;
+    if (t.model && modelPriority(t.model) > modelPriority(agg.model))
+      agg.model = t.model;
+  }
+  if (!agg.model) {
+    const withModel = turns.find((t) => t.model);
+    if (withModel)
+      agg.model = withModel.model;
+  }
+  return agg;
+}
+function emptyModelTotals(model) {
+  return {
+    model,
+    turns: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0,
+    cachedInputTokens: 0,
+    reasoningTokens: 0
+  };
+}
+function buildRollup(provider, day, turns) {
+  const models = {};
+  const hours = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    const key = t.model || "unknown";
+    const m = models[key] ??= emptyModelTotals(key);
+    m.turns++;
+    m.inputTokens += t.inputTokens;
+    m.outputTokens += t.outputTokens;
+    m.cacheReadTokens += t.cacheReadTokens;
+    m.cacheCreationTokens += t.cacheCreationTokens;
+    m.cachedInputTokens += t.cachedInputTokens;
+    m.reasoningTokens += t.reasoningTokens;
+    const h = hourOf(t.ts);
+    if (h !== null) {
+      const bucket = hours.get(h) ?? { hour: h, output: 0, turns: 0 };
+      bucket.output += t.outputTokens;
+      bucket.turns++;
+      hours.set(h, bucket);
+    }
+  }
+  return {
+    id: rollupId(provider, day),
+    provider,
+    day,
+    models,
+    hourly: [...hours.values()].sort((a, b) => a.hour - b.hour)
+  };
+}
+function affectedKeys(turns) {
+  const sessionIds = /* @__PURE__ */ new Set();
+  const dayBuckets = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    sessionIds.add(t.sessionId);
+    const day = dayOf(t.ts);
+    if (day)
+      dayBuckets.set(rollupId(t.provider, day), { provider: t.provider, day });
+  }
+  return { sessionIds: [...sessionIds], dayBuckets: [...dayBuckets.values()] };
+}
+
+// ../packages/core/dist/providers/claude.js
+import * as os from "node:os";
+import * as path2 from "node:path";
+
+// ../packages/core/dist/fs-scan.js
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+async function walkFiles(root, match) {
+  const out = [];
+  async function recurse(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await recurse(full);
+      } else if (entry.isFile() && match(entry.name)) {
+        out.push(full);
+      }
+    }
+  }
+  await recurse(root);
+  out.sort();
+  return out;
+}
+async function fileMtimeMs(filePath) {
+  try {
+    const st = await fs.stat(filePath);
+    return st.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function readJsonlFrom(filePath, fromLine) {
+  let text;
+  try {
+    text = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return { totalLines: 0, entries: [] };
+  }
+  const lines = text.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "")
+    lines.pop();
+  const entries = [];
+  for (let i = 0; i < lines.length; i++) {
+    const lineNo = i + 1;
+    if (lineNo <= fromLine)
+      continue;
+    const raw = lines[i].trim();
+    if (!raw)
+      continue;
+    let record;
+    try {
+      record = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    entries.push({ lineNo, record });
+  }
+  return { totalLines: lines.length, entries };
+}
+
+// ../packages/core/dist/providers/claude.js
+var MTIME_EPSILON_MS = 1;
+function defaultClaudeDirs(home = os.homedir()) {
+  return [
+    path2.join(home, ".claude", "projects"),
+    // Xcode coding-assistant integration (macOS); silently skipped if absent.
+    path2.join(home, "Library", "Developer", "Xcode", "CodingAssistant", "ClaudeAgentConfig", "projects")
+  ];
+}
+function parseClaudeEntries(entries) {
+  const seen = /* @__PURE__ */ new Map();
+  const noId = [];
+  for (const { lineNo, record } of entries) {
+    const rec = record;
+    const rtype = rec.type;
+    if (rtype !== "assistant" && rtype !== "user")
+      continue;
+    const sessionId = rec.sessionId;
+    if (!sessionId)
+      continue;
+    if (rtype !== "assistant")
+      continue;
+    const msg = rec.message ?? {};
+    const usage = msg.usage ?? {};
+    const inputTokens = toCount(usage.input_tokens);
+    const outputTokens = toCount(usage.output_tokens);
+    const cacheReadTokens = toCount(usage.cache_read_input_tokens);
+    const cacheCreationTokens = toCount(usage.cache_creation_input_tokens);
+    if (inputTokens + outputTokens + cacheReadTokens + cacheCreationTokens === 0)
+      continue;
+    let toolName = null;
+    for (const item of msg.content ?? []) {
+      if (item && typeof item === "object" && item.type === "tool_use") {
+        toolName = item.name ?? null;
+        break;
+      }
+    }
+    const messageId = msg.id ?? "";
+    const cwd = rec.cwd ?? "";
+    const turn = {
+      provider: "claude",
+      turnId: messageId ? `claude:${messageId}` : `claude:noid:${sessionId}:${lineNo}`,
+      sessionId,
+      ts: rec.timestamp ?? "",
+      model: msg.model ?? "",
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheCreationTokens,
+      cachedInputTokens: 0,
+      reasoningTokens: 0,
+      toolName,
+      project: projectNameFromCwd(cwd),
+      cwd,
+      gitBranch: rec.gitBranch ?? ""
+    };
+    if (messageId)
+      seen.set(messageId, turn);
+    else
+      noId.push(turn);
+  }
+  return [...noId, ...seen.values()];
+}
+var ClaudeConnector = class {
+  id = "claude";
+  dirs;
+  constructor(dirs = defaultClaudeDirs()) {
+    this.dirs = dirs;
+  }
+  watchPaths() {
+    return this.dirs;
+  }
+  async collect(state) {
+    const nextFiles = { ...state.files };
+    const turns = [];
+    for (const dir of this.dirs) {
+      const files = await walkFiles(dir, (name) => name.endsWith(".jsonl"));
+      for (const filePath of files) {
+        const mtimeMs = await fileMtimeMs(filePath);
+        if (mtimeMs === null)
+          continue;
+        const cursor = state.files[filePath];
+        if (cursor && Math.abs(cursor.mtimeMs - mtimeMs) < MTIME_EPSILON_MS) {
+          continue;
+        }
+        const fromLine = cursor ? cursor.lines : 0;
+        const { totalLines, entries } = await readJsonlFrom(filePath, fromLine);
+        if (entries.length > 0) {
+          turns.push(...parseClaudeEntries(entries));
+        }
+        nextFiles[filePath] = { mtimeMs, lines: totalLines };
+      }
+    }
+    return { turns, state: { files: nextFiles } };
+  }
+};
+
+// ../packages/core/dist/providers/codex.js
+import * as os2 from "node:os";
+import * as path3 from "node:path";
+var MTIME_EPSILON_MS2 = 1;
+function defaultCodexDirs(home = os2.homedir()) {
+  return [path3.join(home, ".codex", "sessions")];
+}
+function usageFromObj(obj) {
+  if (!obj || typeof obj !== "object")
+    return null;
+  const o = obj;
+  const hasAny = "input_tokens" in o || "output_tokens" in o || "total_tokens" in o || "reasoning_output_tokens" in o;
+  if (!hasAny)
+    return null;
+  const input = toCount(o["input_tokens"]);
+  const cachedInput = toCount(o["cached_input_tokens"]);
+  const output = toCount(o["output_tokens"]);
+  const reasoning = toCount(o["reasoning_output_tokens"]);
+  let total = toCount(o["total_tokens"]);
+  if (total === 0)
+    total = input + output + reasoning;
+  return { input, cachedInput, output, reasoning, total };
+}
+function extractUsageEvent(record) {
+  if (!record || typeof record !== "object")
+    return null;
+  const rec = record;
+  const ts = typeof rec["timestamp"] === "string" ? rec["timestamp"] : "";
+  const payload = rec["payload"] ?? rec;
+  const payloadType = payload["type"];
+  if (typeof payloadType === "string" && payloadType !== "token_count")
+    return null;
+  const info = payload["info"] ?? payload;
+  const model = pickModel(rec) ?? pickModel(payload) ?? pickModel(info) ?? "";
+  const last = usageFromObj(info["last_token_usage"]);
+  if (last)
+    return { kind: "delta", usage: last, ts, model };
+  const totalUsage = usageFromObj(info["total_token_usage"]) ?? usageFromObj(info["usage"]) ?? usageFromObj(info);
+  if (totalUsage)
+    return { kind: "cumulative", usage: totalUsage, ts, model };
+  return null;
+}
+function pickModel(obj) {
+  if (!obj || typeof obj !== "object")
+    return null;
+  const m = obj["model"];
+  return typeof m === "string" && m ? m : null;
+}
+function extractSessionMeta(record) {
+  if (!record || typeof record !== "object")
+    return null;
+  const rec = record;
+  const payload = rec["payload"] ?? rec;
+  const type = payload["type"] ?? rec["type"];
+  const looksLikeMeta = typeof type === "string" && type.toLowerCase().includes("session") || "cwd" in payload || "id" in payload && "instructions" in payload;
+  if (!looksLikeMeta)
+    return null;
+  const cwd = typeof payload["cwd"] === "string" ? payload["cwd"] : "";
+  const git = payload["git"];
+  const out = {};
+  if (typeof payload["id"] === "string")
+    out.sessionId = payload["id"];
+  const model = pickModel(payload);
+  if (model)
+    out.model = model;
+  if (cwd) {
+    out.cwd = cwd;
+    out.project = projectNameFromCwd(cwd);
+  }
+  if (git && typeof git["branch"] === "string")
+    out.gitBranch = git["branch"];
+  if (typeof rec["timestamp"] === "string")
+    out.startTs = rec["timestamp"];
+  return out;
+}
+var clamp0 = (n) => n > 0 ? n : 0;
+function parseCodexEntries(fileId, entries) {
+  const meta = {
+    sessionId: `codex-${fileId}`,
+    model: "",
+    project: "unknown",
+    cwd: "",
+    gitBranch: "",
+    startTs: ""
+  };
+  for (const { record } of entries) {
+    const m = extractSessionMeta(record);
+    if (m)
+      Object.assign(meta, m);
+  }
+  const turns = [];
+  let prevCumulative = null;
+  let seq = 0;
+  let runningModel = meta.model;
+  for (const { record } of entries) {
+    const recModel = pickModel(record?.["payload"]) ?? pickModel(record);
+    if (recModel)
+      runningModel = recModel;
+    const ev = extractUsageEvent(record);
+    if (!ev)
+      continue;
+    if (ev.model)
+      runningModel = ev.model;
+    let delta;
+    if (ev.kind === "delta") {
+      delta = ev.usage;
+    } else {
+      const base = prevCumulative;
+      prevCumulative = ev.usage;
+      delta = base ? {
+        input: clamp0(ev.usage.input - base.input),
+        cachedInput: clamp0(ev.usage.cachedInput - base.cachedInput),
+        output: clamp0(ev.usage.output - base.output),
+        reasoning: clamp0(ev.usage.reasoning - base.reasoning),
+        total: clamp0(ev.usage.total - base.total)
+      } : ev.usage;
+    }
+    if (delta.input + delta.output + delta.reasoning + delta.cachedInput === 0)
+      continue;
+    turns.push({
+      provider: "codex",
+      turnId: `codex:${fileId}#${seq}`,
+      sessionId: meta.sessionId,
+      ts: ev.ts || meta.startTs,
+      model: runningModel,
+      inputTokens: delta.input,
+      outputTokens: delta.output,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      cachedInputTokens: delta.cachedInput,
+      reasoningTokens: delta.reasoning,
+      toolName: null,
+      project: meta.project,
+      cwd: meta.cwd,
+      gitBranch: meta.gitBranch
+    });
+    seq++;
+  }
+  return turns;
+}
+function codexFileId(filePath) {
+  return path3.basename(filePath).replace(/\.jsonl$/i, "");
+}
+var CodexConnector = class {
+  id = "codex";
+  dirs;
+  constructor(dirs = defaultCodexDirs()) {
+    this.dirs = dirs;
+  }
+  watchPaths() {
+    return this.dirs;
+  }
+  async collect(state) {
+    const nextFiles = { ...state.files };
+    const turns = [];
+    for (const dir of this.dirs) {
+      const files = await walkFiles(dir, (name) => name.startsWith("rollout-") && name.endsWith(".jsonl"));
+      for (const filePath of files) {
+        const mtimeMs = await fileMtimeMs(filePath);
+        if (mtimeMs === null)
+          continue;
+        const cursor = state.files[filePath];
+        if (cursor && Math.abs(cursor.mtimeMs - mtimeMs) < MTIME_EPSILON_MS2) {
+          continue;
+        }
+        const { totalLines, entries } = await readJsonlFrom(filePath, 0);
+        if (entries.length > 0) {
+          turns.push(...parseCodexEntries(codexFileId(filePath), entries));
+        }
+        nextFiles[filePath] = { mtimeMs, lines: totalLines };
+      }
+    }
+    return { turns, state: { files: nextFiles } };
+  }
+};
+
+// src/paths.ts
+function configDir() {
+  return process.env.TOKELYTICS_HOME ?? path4.join(os3.homedir(), ".tokelytics");
+}
+var statePath = () => path4.join(configDir(), "state.json");
+var credsPath = () => path4.join(configDir(), "credentials.json");
+async function ensureDir() {
+  await fs2.mkdir(configDir(), { recursive: true });
+}
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs2.readFile(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function writeJson(file, value) {
+  await ensureDir();
+  await fs2.writeFile(file, JSON.stringify(value, null, 2), "utf-8");
+}
+async function loadState() {
+  const s = await readJson(statePath());
+  if (s && s.deviceId && s.scan) return s;
+  const fresh = { deviceId: randomUUID(), scan: emptyScanState() };
+  await writeJson(statePath(), fresh);
+  return fresh;
+}
+async function saveState(state) {
+  await writeJson(statePath(), state);
+}
+async function loadCredentials() {
+  return readJson(credsPath());
+}
+async function saveCredentials(creds) {
+  await writeJson(credsPath(), creds);
+  try {
+    await fs2.chmod(credsPath(), 384);
+  } catch {
+  }
+}
+async function clearCredentials() {
+  try {
+    await fs2.rm(credsPath(), { force: true });
+  } catch {
+  }
+}
+
+// src/config.ts
+var DEFAULT_FIREBASE = {
+  apiKey: "AIzaSyA7j6CYHRIYlOpP94-fyaWqV5w3l0U5Blw",
+  projectId: "tokelytics"
+};
+var DEFAULT_WEB_URL = "https://tokelytics.web.app";
+function fromEnv() {
+  const cfg = {};
+  const apiKey = process.env.TOKELYTICS_FIREBASE_API_KEY;
+  const projectId = process.env.TOKELYTICS_FIREBASE_PROJECT_ID;
+  if (apiKey && projectId) cfg.firebase = { apiKey, projectId };
+  if (process.env.TOKELYTICS_WEB_URL) cfg.webBaseUrl = process.env.TOKELYTICS_WEB_URL;
+  if (process.env.TOKELYTICS_GOOGLE_CLIENT_ID) {
+    cfg.google = {
+      clientId: process.env.TOKELYTICS_GOOGLE_CLIENT_ID,
+      clientSecret: process.env.TOKELYTICS_GOOGLE_CLIENT_SECRET ?? ""
+    };
+  }
+  if (process.env.TOKELYTICS_GITHUB_CLIENT_ID) {
+    cfg.github = {
+      clientId: process.env.TOKELYTICS_GITHUB_CLIENT_ID,
+      clientSecret: process.env.TOKELYTICS_GITHUB_CLIENT_SECRET ?? ""
+    };
+  }
+  const fsHost = process.env.FIRESTORE_EMULATOR_HOST ?? process.env.TOKELYTICS_FIRESTORE_EMULATOR_HOST;
+  if (fsHost) cfg.firestoreEmulatorHost = fsHost;
+  const authHost = process.env.FIREBASE_AUTH_EMULATOR_HOST ?? process.env.TOKELYTICS_AUTH_EMULATOR_HOST;
+  if (authHost) cfg.authEmulatorHost = authHost;
+  return cfg;
+}
+async function fromFile() {
+  try {
+    const raw = await fs3.readFile(path5.join(configDir(), "config.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function loadConfig() {
+  const file = await fromFile();
+  const env = fromEnv();
+  return {
+    firebase: env.firebase ?? file.firebase ?? DEFAULT_FIREBASE,
+    webBaseUrl: (env.webBaseUrl ?? file.webBaseUrl ?? DEFAULT_WEB_URL).replace(/\/+$/, ""),
+    google: env.google ?? file.google,
+    github: env.github ?? file.github,
+    firestoreEmulatorHost: env.firestoreEmulatorHost ?? file.firestoreEmulatorHost,
+    authEmulatorHost: env.authEmulatorHost ?? file.authEmulatorHost
+  };
+}
+
+// src/auth.ts
+import * as http from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+function identityToolkitBase(cfg) {
+  return cfg.authEmulatorHost ? `http://${cfg.authEmulatorHost}/identitytoolkit.googleapis.com` : "https://identitytoolkit.googleapis.com";
+}
+function secureTokenBase(cfg) {
+  return cfg.authEmulatorHost ? `http://${cfg.authEmulatorHost}/securetoken.googleapis.com` : "https://securetoken.googleapis.com";
+}
+function openBrowser(url) {
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY || process.env.TOKELYTICS_NO_BROWSER) {
+    return false;
+  }
+  const platform = process.platform;
+  const [cmd, args] = platform === "win32" ? ["cmd", ["/c", "start", "", url]] : platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+  try {
+    spawn(cmd, args, { detached: true, stdio: "ignore" }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function captureOAuthCode(buildUrl) {
+  return new Promise((resolve3, reject) => {
+    const server = http.createServer((req, res) => {
+      const u = new URL(req.url ?? "/", "http://localhost");
+      const code = u.searchParams.get("code");
+      const error = u.searchParams.get("error");
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        `<html><body style="font-family:system-ui;padding:3rem;text-align:center"><h2>Tokelytics</h2><p>${code ? "You're signed in. You can close this tab." : "Sign-in failed: " + error}</p></body></html>`
+      );
+      server.close();
+      if (code) resolve3({ code });
+      else reject(new Error(`OAuth failed: ${error ?? "no code returned"}`));
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      const redirectUri = `http://127.0.0.1:${port}`;
+      const url = buildUrl(redirectUri);
+      console.log(`
+Opening your browser to sign in. If it doesn't open, visit:
+${url}
+`);
+      openBrowser(url);
+    });
+    server.on("error", reject);
+  });
+}
+async function signInWithIdp(cfg, postBody, requestUri) {
+  const res = await fetch(`${identityToolkitBase(cfg)}/v1/accounts:signInWithIdp?key=${cfg.firebase.apiKey}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ postBody, requestUri, returnSecureToken: true, returnIdpCredential: true })
+  });
+  if (!res.ok) throw new Error(`signInWithIdp failed (${res.status}): ${await res.text()}`);
+  const data = await res.json();
+  return {
+    provider: postBody.includes("github.com") ? "github" : "google",
+    uid: data.localId,
+    email: data.email,
+    refreshToken: data.refreshToken,
+    idToken: data.idToken
+  };
+}
+async function googleLogin(cfg) {
+  if (!cfg.google) throw new Error("Google OAuth client not configured (TOKELYTICS_GOOGLE_CLIENT_ID).");
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  let redirectUri = "";
+  const { code } = await captureOAuthCode((ru) => {
+    redirectUri = ru;
+    const p = new URLSearchParams({
+      client_id: cfg.google.clientId,
+      redirect_uri: ru,
+      response_type: "code",
+      scope: "openid email profile",
+      code_challenge: challenge,
+      code_challenge_method: "S256"
+    });
+    return `https://accounts.google.com/o/oauth2/v2/auth?${p}`;
+  });
+  const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: cfg.google.clientId,
+      client_secret: cfg.google.clientSecret,
+      code,
+      code_verifier: verifier,
+      grant_type: "authorization_code",
+      redirect_uri: redirectUri
+    })
+  });
+  if (!tokenRes.ok) throw new Error(`Google token exchange failed (${tokenRes.status})`);
+  const { id_token } = await tokenRes.json();
+  const creds = await signInWithIdp(cfg, `id_token=${id_token}&providerId=google.com`, redirectUri);
+  return { provider: "google", uid: creds.uid, email: creds.email, refreshToken: creds.refreshToken };
+}
+async function githubLogin(cfg) {
+  if (!cfg.github) throw new Error("GitHub OAuth client not configured (TOKELYTICS_GITHUB_CLIENT_ID).");
+  let redirectUri = "";
+  const { code } = await captureOAuthCode((ru) => {
+    redirectUri = ru;
+    const p = new URLSearchParams({ client_id: cfg.github.clientId, redirect_uri: ru, scope: "read:user user:email" });
+    return `https://github.com/login/oauth/authorize?${p}`;
+  });
+  const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+    body: new URLSearchParams({
+      client_id: cfg.github.clientId,
+      client_secret: cfg.github.clientSecret,
+      code,
+      redirect_uri: redirectUri
+    })
+  });
+  if (!tokenRes.ok) throw new Error(`GitHub token exchange failed (${tokenRes.status})`);
+  const { access_token } = await tokenRes.json();
+  const creds = await signInWithIdp(cfg, `access_token=${access_token}&providerId=github.com`, redirectUri);
+  return { provider: "github", uid: creds.uid, email: creds.email, refreshToken: creds.refreshToken };
+}
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+function readBody(req) {
+  return new Promise((resolve3, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+      if (data.length > 1e6) req.destroy();
+    });
+    req.on("end", () => resolve3(data));
+    req.on("error", reject);
+  });
+}
+async function exchangeRefreshToken(cfg, refreshToken) {
+  const res = await fetch(`${secureTokenBase(cfg)}/v1/token?key=${cfg.firebase.apiKey}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: refreshToken })
+  });
+  if (!res.ok) throw new Error(`Could not validate the browser sign-in (${res.status}).`);
+  const data = await res.json();
+  return { uid: data.user_id };
+}
+async function browserHandoffLogin(cfg) {
+  const nonce = randomBytes(5).toString("hex").toUpperCase();
+  const TIMEOUT_MS = 5 * 6e4;
+  const payload = await new Promise((resolve3, reject) => {
+    let timer;
+    function finish(act) {
+      if (timer) clearTimeout(timer);
+      server.close();
+      act();
+    }
+    const server = http.createServer((req, res) => {
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, CORS_HEADERS);
+        res.end();
+        return;
+      }
+      if (req.method !== "POST") {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<html><body style="font-family:system-ui;padding:3rem;text-align:center"><h2>Tokelytics</h2><p>Waiting for the browser to finish signing in\u2026</p></body></html>`
+        );
+        return;
+      }
+      void readBody(req).then((raw) => {
+        let body;
+        try {
+          body = JSON.parse(raw);
+        } catch {
+        }
+        if (!body || body.nonce !== nonce || !body.refreshToken) {
+          res.writeHead(403, { ...CORS_HEADERS, "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "verification code mismatch" }));
+          return;
+        }
+        res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+        finish(() => resolve3(body));
+      }).catch((err) => finish(() => reject(err)));
+    });
+    timer = setTimeout(
+      () => finish(() => reject(new Error('Timed out waiting for browser sign-in. Run "tokelytics login" again.'))),
+      TIMEOUT_MS
+    );
+    server.on("error", (err) => finish(() => reject(err)));
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      const url = `${cfg.webBaseUrl}/connect#${port}-${nonce}`;
+      console.log(`
+To connect this machine, approve the sign-in in your browser:
+
+  ${url}
+
+Verification code: ${nonce}
+`);
+      console.log(
+        openBrowser(url) ? "Opening your browser\u2026 if nothing opens, click the link above.\n" : "Open the link above in your browser to continue.\n"
+      );
+    });
+  });
+  const provider = payload.provider === "github" ? "github" : "google";
+  const { uid } = await exchangeRefreshToken(cfg, payload.refreshToken);
+  return { provider, uid, email: payload.email, refreshToken: payload.refreshToken };
+}
+function sessionFromRefresh(cfg, creds) {
+  let cached;
+  return {
+    uid: creds.uid,
+    email: creds.email,
+    async getToken() {
+      if (cached && Date.now() < cached.expiresAt - 6e4) return cached.token;
+      const res = await fetch(`${secureTokenBase(cfg)}/v1/token?key=${cfg.firebase.apiKey}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: creds.refreshToken })
+      });
+      if (!res.ok) throw new Error(`Token refresh failed (${res.status}). Run "tokelytics login" again.`);
+      const data = await res.json();
+      cached = { token: data.id_token, expiresAt: Date.now() + Number(data.expires_in) * 1e3 };
+      return cached.token;
+    }
+  };
+}
+async function interactiveLogin(cfg, method = "handoff") {
+  const creds = method === "google" ? await googleLogin(cfg) : method === "github" ? await githubLogin(cfg) : await browserHandoffLogin(cfg);
+  await saveCredentials(creds);
+  console.log(`Signed in as ${creds.email ?? creds.uid} (${creds.provider}).`);
+  return sessionFromRefresh(cfg, creds);
+}
+async function restoreSession(cfg) {
+  const creds = await loadCredentials();
+  if (!creds) return null;
+  return sessionFromRefresh(cfg, creds);
+}
+
+// src/runner.ts
+import * as os4 from "node:os";
+
+// src/connectors.ts
+function buildConnectors() {
+  return [new ClaudeConnector(), new CodexConnector()];
+}
+
+// src/firestore-rest.ts
+function encodeValue(v) {
+  if (v === null || v === void 0) return { nullValue: null };
+  if (typeof v === "string") return { stringValue: v };
+  if (typeof v === "boolean") return { booleanValue: v };
+  if (typeof v === "number") {
+    return Number.isInteger(v) ? { integerValue: String(v) } : { doubleValue: v };
+  }
+  if (Array.isArray(v)) return { arrayValue: { values: v.map(encodeValue) } };
+  if (typeof v === "object") return { mapValue: { fields: encodeFields(v) } };
+  return { stringValue: String(v) };
+}
+function encodeFields(obj) {
+  const out = {};
+  for (const [k, val] of Object.entries(obj)) {
+    if (val === void 0) continue;
+    out[k] = encodeValue(val);
+  }
+  return out;
+}
+function decodeValue(v) {
+  if ("stringValue" in v) return v.stringValue;
+  if ("integerValue" in v) return Number(v.integerValue);
+  if ("doubleValue" in v) return v.doubleValue;
+  if ("booleanValue" in v) return v.booleanValue;
+  if ("nullValue" in v) return null;
+  if ("arrayValue" in v) return (v.arrayValue.values ?? []).map(decodeValue);
+  if ("mapValue" in v) return decodeFields(v.mapValue.fields ?? {});
+  return null;
+}
+function decodeFields(fields) {
+  const out = {};
+  for (const [k, val] of Object.entries(fields)) out[k] = decodeValue(val);
+  return out;
+}
+var FirestoreRest = class {
+  projectId;
+  getToken;
+  origin;
+  constructor(opts) {
+    this.projectId = opts.projectId;
+    this.getToken = opts.getToken;
+    this.origin = opts.emulatorHost ? `http://${opts.emulatorHost}` : "https://firestore.googleapis.com";
+  }
+  docsRoot() {
+    return `projects/${this.projectId}/databases/(default)/documents`;
+  }
+  url(suffix) {
+    return `${this.origin}/v1/${suffix}`;
+  }
+  async headers() {
+    return { "Content-Type": "application/json", Authorization: `Bearer ${await this.getToken()}` };
+  }
+  /** Build a full document resource name from path segments (each URL-encoded). */
+  docName(...segments) {
+    return `${this.docsRoot()}/${segments.map((s) => encodeURIComponent(s)).join("/")}`;
+  }
+  /** Commit a batch of full-document upserts (overwrite semantics). */
+  async upsert(docs) {
+    if (docs.length === 0) return;
+    const writes = docs.map((d) => ({ update: { name: d.name, fields: encodeFields(d.fields) } }));
+    const res = await fetch(this.url(`${this.docsRoot()}:commit`), {
+      method: "POST",
+      headers: await this.headers(),
+      body: JSON.stringify({ writes })
+    });
+    if (!res.ok) throw new Error(`Firestore commit failed (${res.status}): ${await res.text()}`);
+  }
+  /** Run an equality query under a parent path, returning decoded documents. */
+  async queryEqual(parentSegments, collectionId, filters) {
+    const parent = parentSegments.length ? this.docName(...parentSegments) : this.docsRoot();
+    const where = filters.length === 1 ? { fieldFilter: { field: { fieldPath: filters[0].field }, op: filters[0].op, value: encodeValue(filters[0].value) } } : {
+      compositeFilter: {
+        op: "AND",
+        filters: filters.map((f) => ({
+          fieldFilter: { field: { fieldPath: f.field }, op: f.op, value: encodeValue(f.value) }
+        }))
+      }
+    };
+    const res = await fetch(this.url(`${parent}:runQuery`), {
+      method: "POST",
+      headers: await this.headers(),
+      body: JSON.stringify({ structuredQuery: { from: [{ collectionId }], where } })
+    });
+    if (!res.ok) throw new Error(`Firestore query failed (${res.status}): ${await res.text()}`);
+    const rows = await res.json();
+    return rows.filter((r) => r.document?.fields).map((r) => decodeFields(r.document.fields));
+  }
+};
+
+// src/firestore-sink.ts
+var BATCH = 400;
+var FirestoreSink = class {
+  constructor(fs4, uid) {
+    this.fs = fs4;
+    this.uid = uid;
+  }
+  async writeTurns(turns) {
+    for (let i = 0; i < turns.length; i += BATCH) {
+      const slice = turns.slice(i, i + BATCH);
+      await this.fs.upsert(
+        slice.map((t) => ({
+          name: this.fs.docName("users", this.uid, "turns", t.turnId),
+          fields: { ...t, day: dayOf(t.ts) }
+        }))
+      );
+    }
+  }
+  async turnsForSession(sessionId) {
+    const rows = await this.fs.queryEqual(["users", this.uid], "turns", [
+      { field: "sessionId", op: "EQUAL", value: sessionId }
+    ]);
+    return rows;
+  }
+  async turnsForBucket(provider, day) {
+    const rows = await this.fs.queryEqual(["users", this.uid], "turns", [
+      { field: "provider", op: "EQUAL", value: provider },
+      { field: "day", op: "EQUAL", value: day }
+    ]);
+    return rows;
+  }
+  async recomputeSessions(sessionIds) {
+    for (const sid of sessionIds) {
+      const turns = await this.turnsForSession(sid);
+      if (!turns.length) continue;
+      const agg = aggregateSession(sid, turns);
+      await this.fs.upsert([{ name: this.fs.docName("users", this.uid, "sessions", sid), fields: { ...agg } }]);
+    }
+  }
+  async recomputeRollups(buckets) {
+    for (const { provider, day } of buckets) {
+      const turns = await this.turnsForBucket(provider, day);
+      if (!turns.length) continue;
+      const rollup = buildRollup(provider, day, turns);
+      await this.fs.upsert([
+        { name: this.fs.docName("users", this.uid, "rollups", rollupId(provider, day)), fields: { ...rollup } }
+      ]);
+    }
+  }
+  async touchDevice(meta) {
+    await this.fs.upsert([
+      { name: this.fs.docName("users", this.uid, "devices", meta.deviceId), fields: { ...meta } }
+    ]);
+  }
+};
+
+// src/sync.ts
+async function runSync(connectors, sink, state, device) {
+  let st = state;
+  const collected = [];
+  const byProvider = {};
+  for (const c of connectors) {
+    const { turns: turns2, state: next } = await c.collect(st);
+    st = next;
+    for (const t of turns2) {
+      collected.push(t);
+      byProvider[t.provider] = (byProvider[t.provider] ?? 0) + 1;
+    }
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const t of collected) unique.set(t.turnId, t);
+  const turns = [...unique.values()];
+  if (turns.length > 0) {
+    await sink.writeTurns(turns);
+    const { sessionIds, dayBuckets } = affectedKeys(turns);
+    await sink.recomputeSessions(sessionIds);
+    await sink.recomputeRollups(dayBuckets);
+  }
+  await sink.touchDevice({ ...device, lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
+  return { newTurns: turns.length, byProvider, state: st };
+}
+
+// src/runner.ts
+async function createRunner() {
+  const cfg = await loadConfig();
+  const session = await restoreSession(cfg);
+  if (!session) throw new Error('Not signed in. Run "tokelytics login" first.');
+  const connectors = buildConnectors();
+  const rest = new FirestoreRest({
+    projectId: cfg.firebase.projectId,
+    getToken: () => session.getToken(),
+    emulatorHost: cfg.firestoreEmulatorHost
+  });
+  const sink = new FirestoreSink(rest, session.uid);
+  return {
+    connectors,
+    watchPaths() {
+      return connectors.flatMap((c) => c.watchPaths());
+    },
+    async syncOnce() {
+      const state = await loadState();
+      const device = {
+        deviceId: state.deviceId,
+        name: os4.hostname(),
+        lastSyncAt: "",
+        providers: connectors.map((c) => c.id)
+      };
+      const res = await runSync(connectors, sink, state.scan, device);
+      await saveState({ deviceId: state.deviceId, scan: res.state });
+      return { newTurns: res.newTurns, byProvider: res.byProvider };
+    }
+  };
+}
+async function registerDevice(cfg, session) {
+  const rest = new FirestoreRest({
+    projectId: cfg.firebase.projectId,
+    getToken: () => session.getToken(),
+    emulatorHost: cfg.firestoreEmulatorHost
+  });
+  const sink = new FirestoreSink(rest, session.uid);
+  const state = await loadState();
+  const connectors = buildConnectors();
+  await sink.touchDevice({
+    deviceId: state.deviceId,
+    name: os4.hostname(),
+    lastSyncAt: "",
+    providers: connectors.map((c) => c.id)
+  });
+}
+
+// ../node_modules/chokidar/esm/index.js
+import { stat as statcb } from "fs";
+import { stat as stat3, readdir as readdir2 } from "fs/promises";
+import { EventEmitter } from "events";
+import * as sysPath2 from "path";
+
+// ../node_modules/readdirp/esm/index.js
+import { stat, lstat, readdir, realpath } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "node:path";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat;
+    if (wantBigintFsStats) {
+      this._stat = (path6) => statMethod(path6, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth ?? defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path6, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path6));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path6, depth) {
+    let files;
+    try {
+      files = await readdir(path6, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path: path6 };
+  }
+  async _formatEntry(dirent, path6) {
+    let entry;
+    const basename4 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path6, basename4));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// ../node_modules/chokidar/esm/handler.js
+import { watchFile, unwatchFile, watch as fs_watch } from "fs";
+import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
+import * as sysPath from "path";
+import { type as osType } from "os";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat2 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main2, prop, item) => {
+  let container = main2[prop];
+  if (!(container instanceof Set)) {
+    main2[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main2, prop, item) => {
+  const container = main2[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main2[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path6, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path6);
+    emitRaw(rawEvent, evPath, { watchedPath: path6 });
+    if (evPath && path6 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path6, evPath), KEY_LISTENERS, sysPath.join(path6, evPath));
+    }
+  };
+  try {
+    return fs_watch(path6, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path6, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path6, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path6,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path6, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path6, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path6, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path6, listener) {
+    const opts = this.fsw.options;
+    const directory = sysPath.dirname(path6);
+    const basename4 = sysPath.basename(path6);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename4);
+    const absolutePath = sysPath.resolve(path6);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path6, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path6, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname3 = sysPath.dirname(file);
+    const basename4 = sysPath.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname3);
+    let prevStats = stats;
+    if (parent.has(basename4))
+      return;
+    const listener = async (path6, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat2(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path6);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path6, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname3, basename4);
+        }
+      } else if (parent.has(basename4)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path6, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path6);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path6, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path6, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sysPath.join(directory, "");
+    throttler = this.fsw._throttle("readdir", directory, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path6 = sysPath.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path6, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path6 = sysPath.join(dir, sysPath.relative(dir, path6));
+        this._addToNodeFs(path6, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve3, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve3(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+    const tracked = parentDir.has(sysPath.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sysPath.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path6, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path6) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path6);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sysPath.resolve(path6);
+        const targetPath = follow ? await fsrealpath(path6) : path6;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path6) : path6;
+        if (this.fsw.closed)
+          return;
+        const parent = sysPath.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path6, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sysPath.resolve(path6), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path6, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path6;
+      }
+    }
+  }
+};
+
+// ../node_modules/chokidar/esm/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sysPath2.relative(matcher.path, string);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path6) {
+  if (typeof path6 !== "string")
+    throw new Error("string expected");
+  path6 = sysPath2.normalize(path6);
+  path6 = path6.replace(/\\/g, "/");
+  let prepend = false;
+  if (path6.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path6.match(DOUBLE_SLASH_RE2))
+    path6 = path6.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path6 = "/" + path6;
+  return path6;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path6 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path6, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  }
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path6) => toUnix(sysPath2.normalize(toUnix(path6)));
+var normalizeIgnored = (cwd = "") => (path6) => {
+  if (typeof path6 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path6) ? path6 : sysPath2.join(cwd, path6));
+  } else {
+    return path6;
+  }
+};
+var getAbsolutePath = (path6, cwd) => {
+  if (sysPath2.isAbsolute(path6)) {
+    return path6;
+  }
+  return sysPath2.join(cwd, path6);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  constructor(path6, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path6;
+    this.path = path6 = path6.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends EventEmitter {
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path6) => {
+        const absPath = getAbsolutePath(path6, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path6) => {
+      this._removeIgnoredPath(path6);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path6) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path6, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path6) => {
+      if (!sysPath2.isAbsolute(path6) && !this._closers.has(path6)) {
+        if (cwd)
+          path6 = sysPath2.join(cwd, path6);
+        path6 = sysPath2.resolve(path6);
+      }
+      this._closePath(path6);
+      this._addIgnoredPath(path6);
+      if (this._watched.has(path6)) {
+        this._addIgnoredPath({
+          path: path6,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @param stats arguments to be passed with event
+   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  async _emit(event, path6, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path6 = sysPath2.normalize(path6);
+    if (opts.cwd)
+      path6 = sysPath2.relative(opts.cwd, path6);
+    const args = [path6];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path6))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path6, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path7) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path7);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path6)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path6);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path6, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path6, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path6) : path6;
+      let stats2;
+      try {
+        stats2 = await stat3(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path6, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, /* @__PURE__ */ new Map());
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path6);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path6);
+      const count = item ? item.count : 0;
+      action.delete(path6);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path6, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path6, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path6;
+    if (this.options.cwd && !sysPath2.isAbsolute(path6)) {
+      fullPath = sysPath2.join(this.options.cwd, path6);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path6)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path6).lastChange = now2;
+        }
+        const pw = writes.get(path6);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path6);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path6)) {
+      writes.set(path6, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path6);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path6, stats) {
+    if (this.options.atomic && DOT_RE.test(path6))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path6, stats);
+  }
+  _isntIgnored(path6, stat4) {
+    return !this._isIgnored(path6, stat4);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path6) {
+    return new WatchHelper(path6, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sysPath2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path6 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path6);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path6) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path6, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path6);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path6, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path6;
+    if (this.options.cwd)
+      relPath = sysPath2.relative(this.options.cwd, path6);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path6);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path6))
+      this._emit(eventName, path6);
+    this._closePath(path6);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path6) {
+    this._closeFile(path6);
+    const dir = sysPath2.dirname(path6);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path6));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path6) {
+    const closers = this._closers.get(path6);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path6);
+  }
+  _addPathCloser(path6, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path6);
+    if (!list) {
+      list = [];
+      this._closers.set(path6, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+var esm_default = { watch, FSWatcher };
+
+// src/watch.ts
+var DEBOUNCE_MS = 1200;
+async function watch2(runner) {
+  await safeSync(runner, "startup");
+  const paths = runner.watchPaths();
+  const watcher = esm_default.watch(paths, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 400, pollInterval: 100 },
+    ignored: (p) => !(p.endsWith(".jsonl") || !p.includes("."))
+  });
+  let timer;
+  let pending = false;
+  let running = false;
+  const schedule = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(async () => {
+      if (running) {
+        pending = true;
+        return;
+      }
+      running = true;
+      await safeSync(runner, "change");
+      running = false;
+      if (pending) {
+        pending = false;
+        schedule();
+      }
+    }, DEBOUNCE_MS);
+  };
+  watcher.on("add", schedule).on("change", schedule);
+  console.log(`Watching for usage in:
+  ${paths.join("\n  ")}
+Press Ctrl+C to stop.`);
+  await new Promise((resolve3) => {
+    process.on("SIGINT", () => {
+      void watcher.close().then(resolve3);
+    });
+  });
+}
+async function safeSync(runner, reason) {
+  try {
+    const { newTurns, byProvider } = await runner.syncOnce();
+    if (newTurns > 0) {
+      const detail = Object.entries(byProvider).map(([p, n]) => `${p}:${n}`).join(" ");
+      console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] synced ${newTurns} new turn(s) (${detail})`);
+    } else if (reason === "startup") {
+      console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] up to date`);
+    }
+  } catch (err) {
+    console.error(`Sync error: ${err.message}`);
+  }
+}
+
+// src/cli.ts
+var USAGE = `Tokelytics agent
+
+Usage:
+  tokelytics login              Sign in by approving in your browser
+  tokelytics sync               Run one incremental sync to your dashboard
+  tokelytics watch              Stream usage in realtime (filesystem watcher)
+  tokelytics status             Show current sign-in and device
+  tokelytics logout             Forget stored credentials
+`;
+async function main(argv) {
+  const cmd = argv[0];
+  switch (cmd) {
+    case "login": {
+      const cfg = await loadConfig();
+      const method = argv.includes("--google") ? "google" : argv.includes("--github") ? "github" : "handoff";
+      const session = await interactiveLogin(cfg, method);
+      try {
+        await registerDevice(cfg, session);
+      } catch (err) {
+        console.warn(`(Couldn't register device yet \u2014 will retry on first sync: ${err.message})`);
+      }
+      console.log('Done. Now run "tokelytics watch" to stream your usage.');
+      return 0;
+    }
+    case "sync": {
+      const runner = await createRunner();
+      const { newTurns, byProvider } = await runner.syncOnce();
+      const detail = Object.entries(byProvider).map(([p, n]) => `${p}:${n}`).join(" ") || "none";
+      console.log(`Synced ${newTurns} new turn(s) (${detail}).`);
+      return 0;
+    }
+    case "watch": {
+      const runner = await createRunner();
+      await watch2(runner);
+      return 0;
+    }
+    case "status": {
+      const creds = await loadCredentials();
+      const state = await loadState();
+      if (!creds) {
+        console.log('Not signed in. Run "tokelytics login".');
+      } else {
+        console.log(`Signed in as ${creds.email ?? creds.uid} (${creds.provider}).`);
+        console.log(`Device id: ${state.deviceId}`);
+        console.log(`Tracked files: ${Object.keys(state.scan.files).length}`);
+      }
+      try {
+        const cfg = await loadConfig();
+        const session = await restoreSession(cfg);
+        if (session) await session.getToken();
+        console.log(session ? "Session OK." : "No session.");
+      } catch (err) {
+        console.log(`Session needs refresh: ${err.message}`);
+      }
+      return 0;
+    }
+    case "logout": {
+      await clearCredentials();
+      console.log("Logged out.");
+      return 0;
+    }
+    default:
+      console.log(USAGE);
+      return cmd ? 1 : 0;
+  }
+}
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exitCode = 1;
+});
+/*! Bundled license information:
+
+chokidar/esm/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/