@poco-ai/tokenarena 0.1.2

package/dist/index.js

@@ -0,0 +1,2221 @@
+#!/usr/bin/env node
+
+// src/parsers/claude-code.ts
+import { homedir } from "os";
+import { join as join2, sep as sep2 } from "path";
+
+// src/domain/aggregator.ts
+import { hostname } from "os";
+function roundToHalfHour(date) {
+  const d = new Date(date);
+  d.setMinutes(d.getMinutes() < 30 ? 0 : 30, 0, 0);
+  return d;
+}
+function aggregateToBuckets(entries) {
+  const map = /* @__PURE__ */ new Map();
+  const host = hostname().replace(/\.local$/, "");
+  for (const e of entries) {
+    const bucketStart = roundToHalfHour(e.timestamp).toISOString();
+    const key = `${e.source}|${e.model}|${e.project}|${bucketStart}`;
+    if (!map.has(key)) {
+      map.set(key, {
+        source: e.source,
+        model: e.model,
+        project: e.project,
+        bucketStart,
+        hostname: host,
+        inputTokens: 0,
+        outputTokens: 0,
+        reasoningTokens: 0,
+        cachedTokens: 0,
+        totalTokens: 0
+      });
+    }
+    const b = map.get(key);
+    if (!b) continue;
+    b.inputTokens += e.inputTokens || 0;
+    b.outputTokens += e.outputTokens || 0;
+    b.reasoningTokens += e.reasoningTokens || 0;
+    b.cachedTokens += e.cachedTokens || 0;
+    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0) + (e.reasoningTokens || 0) + (e.cachedTokens || 0);
+  }
+  return Array.from(map.values());
+}
+
+// src/domain/session-extractor.ts
+import { createHash } from "crypto";
+import { hostname as hostname2 } from "os";
+function toEntryTotalTokens(entry) {
+  return entry.inputTokens + entry.outputTokens + entry.reasoningTokens + entry.cachedTokens;
+}
+function buildSessionUsage(entries) {
+  const usageBySession = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.sessionId) {
+      continue;
+    }
+    let byModel = usageBySession.get(entry.sessionId);
+    if (!byModel) {
+      byModel = /* @__PURE__ */ new Map();
+      usageBySession.set(entry.sessionId, byModel);
+    }
+    const existing = byModel.get(entry.model);
+    if (existing) {
+      existing.inputTokens += entry.inputTokens;
+      existing.outputTokens += entry.outputTokens;
+      existing.reasoningTokens += entry.reasoningTokens;
+      existing.cachedTokens += entry.cachedTokens;
+      existing.totalTokens += toEntryTotalTokens(entry);
+      continue;
+    }
+    byModel.set(entry.model, {
+      model: entry.model,
+      inputTokens: entry.inputTokens,
+      outputTokens: entry.outputTokens,
+      reasoningTokens: entry.reasoningTokens,
+      cachedTokens: entry.cachedTokens,
+      totalTokens: toEntryTotalTokens(entry)
+    });
+  }
+  return usageBySession;
+}
+function extractSessions(events, entries = []) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (!groups.has(e.sessionId)) groups.set(e.sessionId, []);
+    groups.get(e.sessionId)?.push(e);
+  }
+  const sessions = [];
+  const host = hostname2().replace(/\.local$/, "");
+  const usageBySession = buildSessionUsage(entries);
+  for (const [sessionId, sessionEvents] of groups) {
+    sessionEvents.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const first = sessionEvents[0];
+    const last = sessionEvents[sessionEvents.length - 1];
+    const durationSeconds = Math.round(
+      (last.timestamp.getTime() - first.timestamp.getTime()) / 1e3
+    );
+    let activeSeconds = 0;
+    let turnStart = null;
+    let turnEnd = null;
+    let waitingForFirstResponse = false;
+    for (const event of sessionEvents) {
+      if (event.role === "user") {
+        if (turnStart !== null && turnEnd !== null && turnEnd > turnStart) {
+          activeSeconds += Math.round(
+            (turnEnd.getTime() - turnStart.getTime()) / 1e3
+          );
+        }
+        turnStart = null;
+        turnEnd = null;
+        waitingForFirstResponse = true;
+      } else if (waitingForFirstResponse) {
+        turnStart = event.timestamp;
+        turnEnd = event.timestamp;
+        waitingForFirstResponse = false;
+      } else if (turnStart !== null) {
+        turnEnd = event.timestamp;
+      }
+    }
+    if (turnStart !== null && turnEnd !== null && turnEnd > turnStart) {
+      activeSeconds += Math.round(
+        (turnEnd.getTime() - turnStart.getTime()) / 1e3
+      );
+    }
+    const userPromptHours = new Array(24).fill(0);
+    let userMessageCount = 0;
+    for (const event of sessionEvents) {
+      if (event.role === "user") {
+        userMessageCount++;
+        userPromptHours[event.timestamp.getUTCHours()]++;
+      }
+    }
+    const modelUsages = Array.from(
+      usageBySession.get(sessionId)?.values() ?? []
+    ).sort((left, right) => {
+      if (right.totalTokens !== left.totalTokens) {
+        return right.totalTokens - left.totalTokens;
+      }
+      return left.model.localeCompare(right.model);
+    });
+    const inputTokens = modelUsages.reduce(
+      (sum, usage) => sum + usage.inputTokens,
+      0
+    );
+    const outputTokens = modelUsages.reduce(
+      (sum, usage) => sum + usage.outputTokens,
+      0
+    );
+    const reasoningTokens = modelUsages.reduce(
+      (sum, usage) => sum + usage.reasoningTokens,
+      0
+    );
+    const cachedTokens = modelUsages.reduce(
+      (sum, usage) => sum + usage.cachedTokens,
+      0
+    );
+    const totalTokens = modelUsages.reduce(
+      (sum, usage) => sum + usage.totalTokens,
+      0
+    );
+    const primaryModel = modelUsages[0]?.model ?? "";
+    const sessionHash = createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+    sessions.push({
+      source: first.source,
+      project: first.project || "unknown",
+      sessionHash,
+      hostname: host,
+      firstMessageAt: first.timestamp.toISOString(),
+      lastMessageAt: last.timestamp.toISOString(),
+      durationSeconds,
+      activeSeconds,
+      messageCount: sessionEvents.length,
+      userMessageCount,
+      userPromptHours,
+      inputTokens,
+      outputTokens,
+      reasoningTokens,
+      cachedTokens,
+      totalTokens,
+      primaryModel,
+      modelUsages
+    });
+  }
+  return sessions;
+}
+
+// src/infrastructure/fs/utils.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { basename, join, sep } from "path";
+function findJsonlFiles(dir) {
+  const results = [];
+  if (!existsSync(dir)) return results;
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findJsonlFiles(fullPath));
+      } else if (entry.name.endsWith(".jsonl")) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function readFileSafe(filePath) {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function extractSessionId(filePath) {
+  return basename(filePath, ".jsonl");
+}
+
+// src/parsers/registry.ts
+import { existsSync as existsSync2 } from "fs";
+var TOOLS = [];
+var parsers = /* @__PURE__ */ new Map();
+function registerParser(parser) {
+  parsers.set(parser.tool.id, parser);
+  if (!TOOLS.find((t) => t.id === parser.tool.id)) {
+    TOOLS.push(parser.tool);
+  }
+}
+function getAllParsers() {
+  return Array.from(parsers.values());
+}
+function detectInstalledTools() {
+  return TOOLS.filter((t) => existsSync2(t.dataDir));
+}
+function getAllTools() {
+  return TOOLS;
+}
+
+// src/parsers/claude-code.ts
+var TOOL = {
+  id: "claude-code",
+  name: "Claude Code",
+  dataDir: join2(homedir(), ".claude", "projects")
+};
+var TRANSCRIPTS_DIR = join2(homedir(), ".claude", "transcripts");
+function extractProject(filePath) {
+  const projectsPrefix = TOOL.dataDir + sep2;
+  if (!filePath.startsWith(projectsPrefix)) return "unknown";
+  const relative = filePath.slice(projectsPrefix.length);
+  const firstSeg = relative.split(sep2)[0];
+  if (!firstSeg) return "unknown";
+  const parts = firstSeg.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : "unknown";
+}
+var ClaudeCodeParser = class {
+  tool = TOOL;
+  async parse() {
+    const entries = [];
+    const sessionEvents = [];
+    const seenUuids = /* @__PURE__ */ new Set();
+    const seenSessionIds = /* @__PURE__ */ new Set();
+    const projectFiles = findJsonlFiles(TOOL.dataDir);
+    for (const filePath of projectFiles) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      const project = extractProject(filePath);
+      const sessionId = extractSessionId(filePath);
+      seenSessionIds.add(sessionId);
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          const timestamp = obj.timestamp;
+          if (!timestamp) continue;
+          const ts = new Date(timestamp);
+          if (Number.isNaN(ts.getTime())) continue;
+          if (obj.type === "user" || obj.type === "assistant") {
+            sessionEvents.push({
+              sessionId,
+              source: "claude-code",
+              project,
+              timestamp: ts,
+              role: obj.type === "user" ? "user" : "assistant"
+            });
+          }
+          if (obj.type !== "assistant") continue;
+          const msg = obj.message;
+          if (!msg || !msg.usage) continue;
+          const usage = msg.usage;
+          if (usage.input_tokens == null && usage.output_tokens == null)
+            continue;
+          const uuid = obj.uuid;
+          if (uuid) {
+            if (seenUuids.has(uuid)) continue;
+            seenUuids.add(uuid);
+          }
+          entries.push({
+            sessionId,
+            source: "claude-code",
+            model: msg.model || "unknown",
+            project,
+            timestamp: ts,
+            inputTokens: usage.input_tokens || 0,
+            outputTokens: usage.output_tokens || 0,
+            reasoningTokens: 0,
+            cachedTokens: usage.cache_read_input_tokens || 0
+          });
+        } catch {
+        }
+      }
+    }
+    const transcriptFiles = findJsonlFiles(TRANSCRIPTS_DIR);
+    for (const filePath of transcriptFiles) {
+      const sessionId = extractSessionId(filePath);
+      if (seenSessionIds.has(sessionId)) continue;
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          const timestamp = obj.timestamp;
+          if (!timestamp) continue;
+          const ts = new Date(timestamp);
+          if (Number.isNaN(ts.getTime())) continue;
+          if (obj.type === "user" || obj.type === "assistant") {
+            sessionEvents.push({
+              sessionId,
+              source: "claude-code",
+              project: "unknown",
+              timestamp: ts,
+              role: obj.type === "user" ? "user" : "assistant"
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+};
+registerParser(new ClaudeCodeParser());
+
+// src/parsers/codex.ts
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var TOOL2 = {
+  id: "codex",
+  name: "Codex CLI",
+  dataDir: join3(homedir2(), ".codex", "sessions")
+};
+var CodexParser = class {
+  tool = TOOL2;
+  async parse() {
+    const entries = [];
+    const sessionEvents = [];
+    const files = findJsonlFiles(TOOL2.dataDir);
+    if (files.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    for (const filePath of files) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      let sessionProject = "unknown";
+      const sessionModel = "unknown";
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === "session_meta" && obj.payload) {
+            const meta = obj.payload;
+            if (meta.cwd) {
+              sessionProject = meta.cwd.split("/").pop() || "unknown";
+            }
+            if (meta.git?.repository_url) {
+              const match = meta.git.repository_url.match(
+                /([^/]+\/[^/]+?)(?:\.git)?$/
+              );
+              if (match) sessionProject = match[1];
+            }
+            break;
+          }
+        } catch {
+          break;
+        }
+      }
+      let turnContextModel = "unknown";
+      const prevTotal = /* @__PURE__ */ new Map();
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === "turn_context" && obj.timestamp) {
+            const evTs = new Date(obj.timestamp);
+            if (!Number.isNaN(evTs.getTime())) {
+              sessionEvents.push({
+                sessionId: filePath,
+                source: "codex",
+                project: sessionProject,
+                timestamp: evTs,
+                role: "user"
+              });
+            }
+          }
+          if (obj.type === "turn_context" && obj.payload?.model) {
+            turnContextModel = obj.payload.model;
+            continue;
+          }
+          if (obj.type !== "event_msg") continue;
+          const payload = obj.payload;
+          if (!payload) continue;
+          if (payload.type !== "token_count") continue;
+          const info = payload.info;
+          if (!info) continue;
+          const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
+          if (!timestamp || Number.isNaN(timestamp.getTime())) continue;
+          sessionEvents.push({
+            sessionId: filePath,
+            source: "codex",
+            project: sessionProject,
+            timestamp,
+            role: "assistant"
+          });
+          let usage = info.last_token_usage;
+          if (!usage && info.total_token_usage) {
+            const totalKey = `${info.model || payload.model || turnContextModel || ""}`;
+            const prev = prevTotal.get(totalKey);
+            const curr = info.total_token_usage;
+            if (prev) {
+              usage = {
+                input_tokens: (curr.input_tokens || 0) - (prev.input_tokens || 0),
+                output_tokens: (curr.output_tokens || 0) - (prev.output_tokens || 0),
+                cached_input_tokens: (curr.cached_input_tokens || 0) - (prev.cached_input_tokens || 0),
+                reasoning_output_tokens: (curr.reasoning_output_tokens || 0) - (prev.reasoning_output_tokens || 0)
+              };
+            } else {
+              usage = curr;
+            }
+            prevTotal.set(totalKey, { ...curr });
+          }
+          if (!usage) continue;
+          const model = info.model || payload.model || turnContextModel || sessionModel;
+          const cachedInput = usage.cached_input_tokens || 0;
+          const reasoningTokens = usage.reasoning_output_tokens || 0;
+          entries.push({
+            sessionId: filePath,
+            source: "codex",
+            model,
+            project: sessionProject,
+            timestamp,
+            inputTokens: (usage.input_tokens || 0) - cachedInput,
+            outputTokens: usage.output_tokens || 0,
+            reasoningTokens,
+            cachedTokens: cachedInput
+          });
+        } catch {
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+};
+registerParser(new CodexParser());
+
+// src/parsers/gemini-cli.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+var TOOL3 = {
+  id: "gemini-cli",
+  name: "Gemini CLI",
+  dataDir: join4(homedir3(), ".gemini", "tmp")
+};
+function findSessionFiles(baseDir) {
+  const results = [];
+  if (!existsSync3(baseDir)) return results;
+  try {
+    for (const entry of readdirSync2(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const chatsDir = join4(baseDir, entry.name, "chats");
+      if (!existsSync3(chatsDir)) continue;
+      try {
+        for (const f of readdirSync2(chatsDir)) {
+          if (f.startsWith("session-") && f.endsWith(".json")) {
+            results.push(join4(chatsDir, f));
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+var GeminiCliParser = class {
+  tool = TOOL3;
+  async parse() {
+    const sessionFiles = findSessionFiles(TOOL3.dataDir);
+    if (sessionFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    for (const filePath of sessionFiles) {
+      let data;
+      try {
+        data = JSON.parse(readFileSync2(filePath, "utf-8"));
+      } catch {
+        continue;
+      }
+      const messages = data.messages || data.history || [];
+      for (const msg of messages) {
+        const timestamp = msg.timestamp || msg.createTime || data.createTime;
+        if (!timestamp) continue;
+        const ts = new Date(timestamp);
+        if (Number.isNaN(ts.getTime())) continue;
+        if (msg.role !== "user" && msg.role !== "assistant") continue;
+        const role = msg.role;
+        sessionEvents.push({
+          sessionId: filePath,
+          source: "gemini-cli",
+          project: "unknown",
+          timestamp: ts,
+          role
+        });
+        const tokens = msg.tokens;
+        const usage = msg.usage || msg.usageMetadata || msg.token_count;
+        if (!tokens && !usage) continue;
+        if (tokens) {
+          const cached = tokens.cached || 0;
+          const thoughts = tokens.thoughts || 0;
+          entries.push({
+            sessionId: filePath,
+            source: "gemini-cli",
+            model: msg.model || data.model || "unknown",
+            project: "unknown",
+            timestamp: ts,
+            inputTokens: (tokens.input || 0) - cached,
+            outputTokens: tokens.output || 0,
+            reasoningTokens: thoughts,
+            cachedTokens: cached
+          });
+        } else if (usage) {
+          const cached = usage.cachedContentTokenCount || 0;
+          const thoughts = usage.thoughtsTokenCount || 0;
+          entries.push({
+            sessionId: filePath,
+            source: "gemini-cli",
+            model: msg.model || data.model || "unknown",
+            project: "unknown",
+            timestamp: ts,
+            inputTokens: (usage.promptTokenCount || usage.input_tokens || 0) - cached,
+            outputTokens: usage.candidatesTokenCount || usage.output_tokens || 0,
+            reasoningTokens: thoughts,
+            cachedTokens: cached
+          });
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+};
+registerParser(new GeminiCliParser());
+
+// src/parsers/copilot-cli.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename2, join as join5 } from "path";
+var TOOL4 = {
+  id: "copilot-cli",
+  name: "GitHub Copilot CLI",
+  dataDir: join5(homedir4(), ".copilot", "session-state")
+};
+function findEventFiles(baseDir) {
+  const results = [];
+  if (!existsSync4(baseDir)) return results;
+  try {
+    for (const entry of readdirSync3(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const eventsFile = join5(baseDir, entry.name, "events.jsonl");
+      if (existsSync4(eventsFile)) {
+        results.push({ filePath: eventsFile, sessionId: entry.name });
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+function getProjectFromContext(context) {
+  const projectPath = context?.gitRoot || context?.cwd;
+  if (!projectPath) return "unknown";
+  return basename2(projectPath) || "unknown";
+}
+var CopilotCliParser = class {
+  tool = TOOL4;
+  async parse() {
+    const eventFiles = findEventFiles(TOOL4.dataDir);
+    if (eventFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    for (const { filePath, sessionId } of eventFiles) {
+      let content;
+      try {
+        content = readFileSync3(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      let currentProject = "unknown";
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
+          const hasTimestamp = timestamp && !Number.isNaN(timestamp.getTime());
+          if (obj.type === "session.start" || obj.type === "session.resume") {
+            currentProject = getProjectFromContext(obj.data?.context);
+          }
+          if (hasTimestamp && timestamp && obj.type === "user.message") {
+            sessionEvents.push({
+              sessionId,
+              source: "copilot-cli",
+              project: currentProject,
+              timestamp,
+              role: "user"
+            });
+          }
+          if (hasTimestamp && timestamp && obj.type === "assistant.message") {
+            sessionEvents.push({
+              sessionId,
+              source: "copilot-cli",
+              project: currentProject,
+              timestamp,
+              role: "assistant"
+            });
+          }
+          if (obj.type !== "session.shutdown" || !hasTimestamp || !timestamp)
+            continue;
+          const modelMetrics = obj.data?.modelMetrics || {};
+          for (const [model, metrics] of Object.entries(modelMetrics)) {
+            const usage = metrics?.usage;
+            if (!usage) continue;
+            const totalInput = usage.inputTokens || 0;
+            const cachedRead = usage.cacheReadTokens || 0;
+            const output = usage.outputTokens || 0;
+            if (totalInput === 0 && cachedRead === 0 && output === 0) {
+              continue;
+            }
+            entries.push({
+              sessionId,
+              source: "copilot-cli",
+              model,
+              project: currentProject,
+              timestamp,
+              inputTokens: Math.max(0, totalInput - cachedRead),
+              outputTokens: output,
+              reasoningTokens: 0,
+              cachedTokens: cachedRead
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+};
+registerParser(new CopilotCliParser());
+
+// src/parsers/opencode.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { basename as basename3, join as join6 } from "path";
+var TOOL5 = {
+  id: "opencode",
+  name: "OpenCode",
+  dataDir: join6(homedir5(), ".local", "share", "opencode")
+};
+var DB_PATH = join6(TOOL5.dataDir, "opencode.db");
+var MESSAGES_DIR = join6(TOOL5.dataDir, "storage", "message");
+var OpenCodeParser = class {
+  tool = TOOL5;
+  async parse() {
+    if (existsSync5(DB_PATH)) {
+      try {
+        return this.parseFromSqlite();
+      } catch (err) {
+        process.stderr.write(
+          `warn: opencode sqlite parse failed (${err.message}), trying legacy json...
+`
+        );
+      }
+    }
+    return this.parseFromJson();
+  }
+  parseFromSqlite() {
+    const query = `SELECT
+      session_id as sessionID,
+      json_extract(data, '$.role') as role,
+      json_extract(data, '$.time.created') as created,
+      json_extract(data, '$.modelID') as modelID,
+      json_extract(data, '$.tokens') as tokens,
+      json_extract(data, '$.path.root') as rootPath
+      FROM message`;
+    let output;
+    try {
+      output = execFileSync("sqlite3", ["-json", DB_PATH, query], {
+        encoding: "utf-8",
+        maxBuffer: 100 * 1024 * 1024,
+        timeout: 3e4
+      });
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.status === 127 || nodeErr.message?.includes("ENOENT")) {
+        throw new Error(
+          "sqlite3 CLI not found. Install sqlite3 to sync opencode data."
+        );
+      }
+      throw err;
+    }
+    output = output.trim();
+    if (!output || output === "[]") return { buckets: [], sessions: [] };
+    let rows;
+    try {
+      rows = JSON.parse(output);
+    } catch {
+      throw new Error("Failed to parse sqlite3 JSON output");
+    }
+    const entries = [];
+    const sessionEvents = [];
+    for (const row of rows) {
+      const timestamp = new Date(row.created);
+      if (Number.isNaN(timestamp.getTime())) continue;
+      const project = row.rootPath ? basename3(row.rootPath) : "unknown";
+      const sessionId = row.sessionID || "unknown";
+      if (row.role !== "user" && row.role !== "assistant") continue;
+      sessionEvents.push({
+        sessionId,
+        source: "opencode",
+        project,
+        timestamp,
+        role: row.role === "user" ? "user" : "assistant"
+      });
+      if (!row.modelID) continue;
+      let tokens;
+      try {
+        tokens = typeof row.tokens === "string" ? JSON.parse(row.tokens) : row.tokens;
+      } catch {
+        continue;
+      }
+      if (!tokens || !tokens.input && !tokens.output) continue;
+      entries.push({
+        sessionId,
+        source: "opencode",
+        model: row.modelID || "unknown",
+        project,
+        timestamp,
+        inputTokens: tokens.input || 0,
+        outputTokens: tokens.output || 0,
+        reasoningTokens: tokens.reasoning || 0,
+        cachedTokens: tokens.cache?.read || 0
+      });
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  parseFromJson() {
+    if (!existsSync5(MESSAGES_DIR)) return { buckets: [], sessions: [] };
+    const entries = [];
+    const sessionEvents = [];
+    let sessionDirs;
+    try {
+      sessionDirs = readdirSync4(MESSAGES_DIR, { withFileTypes: true }).filter(
+        (d) => d.isDirectory() && d.name.startsWith("ses_")
+      );
+    } catch {
+      return { buckets: [], sessions: [] };
+    }
+    for (const sessionDir of sessionDirs) {
+      const sessionPath = join6(MESSAGES_DIR, sessionDir.name);
+      let msgFiles;
+      try {
+        msgFiles = readdirSync4(sessionPath).filter((f) => f.endsWith(".json"));
+      } catch {
+        continue;
+      }
+      for (const file of msgFiles) {
+        const filePath = join6(sessionPath, file);
+        let data;
+        try {
+          data = JSON.parse(readFileSync4(filePath, "utf-8"));
+        } catch {
+          continue;
+        }
+        const timestamp = new Date(data.time?.created || data.created);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        const rootPath = data.path?.root;
+        const project = rootPath ? basename3(rootPath) : "unknown";
+        if (data.role !== "user" && data.role !== "assistant") continue;
+        sessionEvents.push({
+          sessionId: sessionDir.name,
+          source: "opencode",
+          project,
+          timestamp,
+          role: data.role === "user" ? "user" : "assistant"
+        });
+        if (!data.modelID) continue;
+        const tokens = data.tokens;
+        if (!tokens || !tokens.input && !tokens.output) continue;
+        entries.push({
+          sessionId: sessionDir.name,
+          source: "opencode",
+          model: data.modelID || "unknown",
+          project,
+          timestamp,
+          inputTokens: tokens.input || 0,
+          outputTokens: tokens.output || 0,
+          reasoningTokens: tokens.reasoning || 0,
+          cachedTokens: tokens.cache?.read || 0
+        });
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+};
+registerParser(new OpenCodeParser());
+
+// src/parsers/openclaw.ts
+import { existsSync as existsSync6, readdirSync as readdirSync5, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+var POSSIBLE_ROOTS = [
+  join7(homedir6(), ".openclaw"),
+  join7(homedir6(), ".clawdbot"),
+  join7(homedir6(), ".moltbot"),
+  join7(homedir6(), ".moldbot")
+];
+var TOOL6 = {
+  id: "openclaw",
+  name: "OpenClaw",
+  dataDir: POSSIBLE_ROOTS[0]
+  // Primary data dir for detection
+};
+function getTokens(usage, ...keys) {
+  for (const key of keys) {
+    const value = usage[key];
+    if (typeof value === "number" && value > 0) return value;
+  }
+  return 0;
+}
+var OpenClawParser = class {
+  tool = TOOL6;
+  async parse() {
+    const entries = [];
+    const sessionEvents = [];
+    for (const root of POSSIBLE_ROOTS) {
+      const agentsDir = join7(root, "agents");
+      if (!existsSync6(agentsDir)) continue;
+      let agentDirs;
+      try {
+        agentDirs = readdirSync5(agentsDir, { withFileTypes: true }).filter(
+          (d) => d.isDirectory()
+        );
+      } catch {
+        continue;
+      }
+      for (const agentDir of agentDirs) {
+        const project = agentDir.name;
+        const sessionsDir = join7(agentsDir, agentDir.name, "sessions");
+        if (!existsSync6(sessionsDir)) continue;
+        let files;
+        try {
+          files = readdirSync5(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+        } catch {
+          continue;
+        }
+        for (const file of files) {
+          const filePath = join7(sessionsDir, file);
+          let content;
+          try {
+            content = readFileSync5(filePath, "utf-8");
+          } catch {
+            continue;
+          }
+          for (const line of content.split("\n")) {
+            if (!line.trim()) continue;
+            try {
+              const obj = JSON.parse(line);
+              if (obj.type !== "message") continue;
+              const msg = obj.message;
+              if (!msg) continue;
+              const timestamp = obj.timestamp || msg.timestamp;
+              if (!timestamp) continue;
+              const ts = new Date(
+                typeof timestamp === "number" ? timestamp : timestamp
+              );
+              if (Number.isNaN(ts.getTime())) continue;
+              if (msg.role !== "user" && msg.role !== "assistant") continue;
+              sessionEvents.push({
+                sessionId: filePath,
+                source: "openclaw",
+                project,
+                timestamp: ts,
+                role: msg.role === "user" ? "user" : "assistant"
+              });
+              if (msg.role !== "assistant") continue;
+              const usage = msg.usage;
+              if (!usage) continue;
+              entries.push({
+                sessionId: filePath,
+                source: "openclaw",
+                model: msg.model || obj.model || "unknown",
+                project,
+                timestamp: ts,
+                inputTokens: getTokens(
+                  usage,
+                  "input",
+                  "inputTokens",
+                  "input_tokens",
+                  "promptTokens",
+                  "prompt_tokens"
+                ),
+                outputTokens: getTokens(
+                  usage,
+                  "output",
+                  "outputTokens",
+                  "output_tokens",
+                  "completionTokens",
+                  "completion_tokens"
+                ),
+                reasoningTokens: 0,
+                cachedTokens: getTokens(
+                  usage,
+                  "cacheRead",
+                  "cache_read",
+                  "cache_read_input_tokens"
+                )
+              });
+            } catch {
+            }
+          }
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  /** Check if any of the possible roots exist */
+  isInstalled() {
+    return POSSIBLE_ROOTS.some((root) => existsSync6(join7(root, "agents")));
+  }
+};
+registerParser(new OpenClawParser());
+
+// src/cli.ts
+import { Command, Option } from "commander";
+
+// src/infrastructure/config/manager.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync7, mkdirSync, readFileSync as readFileSync6, writeFileSync } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
+var CONFIG_DIR = join8(homedir7(), ".tokenarena");
+var isDev = process.env.TOKEN_ARENA_DEV === "1";
+var CONFIG_FILE = join8(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
+var DEFAULT_API_URL = "http://localhost:3000";
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function loadConfig() {
+  if (!existsSync7(CONFIG_FILE)) return null;
+  try {
+    const raw = readFileSync6(CONFIG_FILE, "utf-8");
+    const config = JSON.parse(raw);
+    if (!config.apiUrl) {
+      config.apiUrl = DEFAULT_API_URL;
+    }
+    return config;
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+}
+function getOrCreateDeviceId(config) {
+  if (config.deviceId) return config.deviceId;
+  const next = randomUUID();
+  saveConfig({ ...config, deviceId: next });
+  return next;
+}
+function validateApiKey(key) {
+  return key.startsWith("vbu_");
+}
+function getDefaultApiUrl() {
+  return process.env.TOKEN_ARENA_API_URL || DEFAULT_API_URL;
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  level;
+  constructor(level = "info") {
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.debug) {
+      process.stderr.write(`[debug] ${msg}
+`);
+    }
+  }
+  info(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.info) {
+      process.stdout.write(`${msg}
+`);
+    }
+  }
+  warn(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.warn) {
+      process.stderr.write(`warn: ${msg}
+`);
+    }
+  }
+  error(msg) {
+    if (LOG_LEVELS[this.level] <= LOG_LEVELS.error) {
+      process.stderr.write(`error: ${msg}
+`);
+    }
+  }
+  log(msg) {
+    this.info(msg);
+  }
+};
+var logger = new Logger();
+
+// src/commands/config.ts
+var VALID_KEYS = ["apiKey", "apiUrl", "syncInterval", "logLevel"];
+function handleConfig(args) {
+  const sub = args[0];
+  switch (sub) {
+    case "get": {
+      const key = args[1];
+      if (!key) {
+        logger.error("Usage: tokenarena config get <key>");
+        process.exit(1);
+      }
+      const config = loadConfig();
+      if (!config || !(key in config)) {
+        process.exit(0);
+      }
+      console.log(config[key] ?? "");
+      break;
+    }
+    case "set": {
+      const key = args[1];
+      let value = args[2];
+      if (!key || value === void 0) {
+        logger.error("Usage: tokenarena config set <key> <value>");
+        process.exit(1);
+      }
+      if (!VALID_KEYS.includes(key)) {
+        logger.error(`Unknown config key: ${key}`);
+        logger.error(`Valid keys: ${VALID_KEYS.join(", ")}`);
+        process.exit(1);
+      }
+      const config = loadConfig() || {
+        apiKey: "",
+        apiUrl: "http://localhost:3000"
+      };
+      if (key === "syncInterval") {
+        value = parseInt(value, 10);
+        if (Number.isNaN(value)) {
+          logger.error("syncInterval must be a number (milliseconds)");
+          process.exit(1);
+        }
+      }
+      config[key] = value;
+      saveConfig(config);
+      logger.info(`Set ${key} = ${value}`);
+      break;
+    }
+    case "show": {
+      const config = loadConfig();
+      if (!config) {
+        console.log("{}");
+      } else {
+        console.log(JSON.stringify(config, null, 2));
+      }
+      break;
+    }
+    default:
+      logger.error(`Unknown config subcommand: ${sub || "(none)"}`);
+      logger.error("Usage: tokenarena config <get|set|show>");
+      process.exit(1);
+  }
+}
+
+// src/services/sync-service.ts
+import { hostname as hostname3 } from "os";
+
+// src/domain/project-identity.ts
+import { createHmac } from "crypto";
+function toProjectIdentity(input) {
+  if (input.mode === "disabled") {
+    return { projectKey: "unknown", projectLabel: "Unknown Project" };
+  }
+  if (input.mode === "raw") {
+    return { projectKey: input.project, projectLabel: input.project };
+  }
+  const projectKey = createHmac("sha256", input.salt).update(input.project).digest("hex").slice(0, 16);
+  return {
+    projectKey,
+    projectLabel: `Project ${projectKey.slice(0, 6)}`
+  };
+}
+
+// src/infrastructure/api/client.ts
+import http from "http";
+import https from "https";
+import { URL } from "url";
+var MAX_RETRIES = 3;
+var INITIAL_DELAY = 1e3;
+var TIMEOUT_MS = 6e4;
+var ApiClient = class {
+  constructor(apiUrl, apiKey) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Ingest buckets and sessions to server
+   */
+  async ingest(device, buckets, sessions, onProgress) {
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        return await this.sendIngest(device, buckets, sessions, onProgress);
+      } catch (err) {
+        lastError = err;
+        const httpErr = err;
+        if (httpErr.message === "UNAUTHORIZED" || httpErr.statusCode && httpErr.statusCode >= 400 && httpErr.statusCode < 500) {
+          throw err;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          const delay = INITIAL_DELAY * 2 ** attempt;
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  sendIngest(device, buckets, sessions, onProgress) {
+    return new Promise((resolve2, reject) => {
+      const url = new URL("/api/usage/ingest", this.apiUrl);
+      const payload = {
+        schemaVersion: 2,
+        device,
+        buckets,
+        sessions: sessions ?? []
+      };
+      const body = Buffer.from(JSON.stringify(payload));
+      const totalBytes = body.length;
+      const mod = url.protocol === "https:" ? https : http;
+      const req = mod.request(
+        url,
+        {
+          method: "POST",
+          timeout: TIMEOUT_MS,
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Length": totalBytes
+          }
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            if (res.statusCode === 401) {
+              reject(new Error("UNAUTHORIZED"));
+              return;
+            }
+            if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+              const err = new Error(
+                `HTTP ${res.statusCode}: ${data}`
+              );
+              err.statusCode = res.statusCode;
+              reject(err);
+              return;
+            }
+            try {
+              const response = JSON.parse(data);
+              resolve2({
+                ingested: response.bucketCount ?? response.ingested,
+                sessions: response.sessionCount ?? response.sessions
+              });
+            } catch {
+              reject(new Error(`Invalid JSON response: ${data}`));
+            }
+          });
+        }
+      );
+      req.on("error", (err) => reject(err));
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Request timed out (60s)"));
+      });
+      const CHUNK = 16 * 1024;
+      let sent = 0;
+      const writeNext = () => {
+        let ok = true;
+        while (ok && sent < totalBytes) {
+          const slice = body.subarray(sent, sent + CHUNK);
+          sent += slice.length;
+          if (onProgress) onProgress(sent, totalBytes);
+          ok = req.write(slice);
+        }
+        if (sent < totalBytes) {
+          req.once("drain", writeNext);
+        } else {
+          req.end();
+        }
+      };
+      writeNext();
+    });
+  }
+  /**
+   * Fetch user settings from server
+   */
+  async fetchSettings() {
+    return new Promise((resolve2, reject) => {
+      const url = new URL("/api/usage/settings", this.apiUrl);
+      const mod = url.protocol === "https:" ? https : http;
+      const req = mod.request(
+        url,
+        {
+          method: "GET",
+          timeout: 1e4,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            if (res.statusCode === 401) {
+              reject(new Error("UNAUTHORIZED"));
+              return;
+            }
+            if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+              resolve2(null);
+              return;
+            }
+            try {
+              const settings = JSON.parse(data);
+              if (settings.schemaVersion !== 2 || !settings.projectMode || !settings.projectHashSalt || !settings.timezone) {
+                resolve2(null);
+                return;
+              }
+              resolve2(settings);
+            } catch {
+              resolve2(null);
+            }
+          });
+        }
+      );
+      req.on("error", () => resolve2(null));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve2(null);
+      });
+      req.end();
+    });
+  }
+  /**
+   * Delete all usage data for the authenticated user
+   */
+  async deleteAllData(opts) {
+    return new Promise((resolve2, reject) => {
+      const url = new URL("/api/usage/ingest", this.apiUrl);
+      if (opts?.hostname) {
+        url.searchParams.set("hostname", opts.hostname);
+      }
+      const mod = url.protocol === "https:" ? https : http;
+      const req = mod.request(
+        url,
+        {
+          method: "DELETE",
+          timeout: TIMEOUT_MS,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`
+          }
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            if (res.statusCode === 401) {
+              reject(new Error("UNAUTHORIZED"));
+              return;
+            }
+            if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+              const err = new Error(
+                `HTTP ${res.statusCode}: ${data}`
+              );
+              err.statusCode = res.statusCode;
+              reject(err);
+              return;
+            }
+            try {
+              resolve2(JSON.parse(data));
+            } catch {
+              reject(new Error(`Invalid JSON response: ${data}`));
+            }
+          });
+        }
+      );
+      req.on("error", (err) => reject(err));
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Request timed out (60s)"));
+      });
+      req.end();
+    });
+  }
+};
+
+// src/infrastructure/runtime/lock.ts
+import {
+  closeSync,
+  existsSync as existsSync8,
+  openSync,
+  readFileSync as readFileSync7,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+
+// src/infrastructure/runtime/paths.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join9 } from "path";
+function getRuntimeDir() {
+  return join9(getConfigDir(), "runtime");
+}
+function getSyncLockPath() {
+  return join9(getRuntimeDir(), "sync.lock");
+}
+function getSyncStatePath() {
+  return join9(getRuntimeDir(), "status.json");
+}
+function ensureAppRuntimeDirs() {
+  mkdirSync2(getRuntimeDir(), { recursive: true });
+}
+
+// src/infrastructure/runtime/lock.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code !== "ESRCH";
+  }
+}
+function readLockMetadata(lockPath) {
+  if (!existsSync8(lockPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync7(lockPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function removeStaleLock(lockPath) {
+  const metadata = readLockMetadata(lockPath);
+  if (!metadata) {
+    rmSync(lockPath, { force: true });
+    return;
+  }
+  if (!isProcessAlive(metadata.pid)) {
+    rmSync(lockPath, { force: true });
+  }
+}
+function tryAcquireSyncLock(source) {
+  ensureAppRuntimeDirs();
+  const lockPath = getSyncLockPath();
+  try {
+    const fd = openSync(lockPath, "wx");
+    const metadata = {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pid: process.pid,
+      source
+    };
+    writeFileSync2(fd, JSON.stringify(metadata, null, 2));
+    closeSync(fd);
+    return {
+      release() {
+        rmSync(lockPath, { force: true });
+      }
+    };
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST") {
+      throw error;
+    }
+  }
+  removeStaleLock(lockPath);
+  try {
+    const fd = openSync(lockPath, "wx");
+    const metadata = {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pid: process.pid,
+      source
+    };
+    writeFileSync2(fd, JSON.stringify(metadata, null, 2));
+    closeSync(fd);
+    return {
+      release() {
+        rmSync(lockPath, { force: true });
+      }
+    };
+  } catch (error) {
+    const code = error.code;
+    if (code === "EEXIST") {
+      return null;
+    }
+    throw error;
+  }
+}
+function describeExistingSyncLock() {
+  const metadata = readLockMetadata(getSyncLockPath());
+  if (!metadata) {
+    return null;
+  }
+  return `pid=${metadata.pid}, source=${metadata.source}, createdAt=${metadata.createdAt}`;
+}
+
+// src/infrastructure/runtime/state.ts
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+function getDefaultState() {
+  return { status: "idle" };
+}
+function loadSyncState() {
+  const path = getSyncStatePath();
+  if (!existsSync9(path)) {
+    return getDefaultState();
+  }
+  try {
+    return {
+      ...getDefaultState(),
+      ...JSON.parse(readFileSync8(path, "utf-8"))
+    };
+  } catch {
+    return getDefaultState();
+  }
+}
+function saveSyncState(next) {
+  ensureAppRuntimeDirs();
+  writeFileSync3(
+    getSyncStatePath(),
+    `${JSON.stringify(next, null, 2)}
+`,
+    "utf-8"
+  );
+}
+function markSyncStarted(source) {
+  const current = loadSyncState();
+  saveSyncState({
+    ...current,
+    pid: process.pid,
+    lastAttemptAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastSource: source,
+    status: "syncing"
+  });
+}
+function markSyncSucceeded(source, result) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const current = loadSyncState();
+  saveSyncState({
+    ...current,
+    lastCompletedAt: now,
+    lastError: void 0,
+    lastFailureAt: void 0,
+    lastResult: result,
+    lastSource: source,
+    lastSuccessAt: now,
+    pid: void 0,
+    status: "idle"
+  });
+}
+function markSyncFailed(source, error, status) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const current = loadSyncState();
+  saveSyncState({
+    ...current,
+    lastCompletedAt: now,
+    lastError: error,
+    lastFailureAt: now,
+    lastSource: source,
+    pid: void 0,
+    status
+  });
+}
+
+// src/services/parser-service.ts
+async function runAllParsers() {
+  const allBuckets = [];
+  const allSessions = [];
+  const parserResults = [];
+  for (const parser of getAllParsers()) {
+    try {
+      const result = await parser.parse();
+      const buckets = result.buckets;
+      const sessions = result.sessions;
+      if (buckets.length > 0) allBuckets.push(...buckets);
+      if (sessions.length > 0) allSessions.push(...sessions);
+      if (buckets.length > 0 || sessions.length > 0) {
+        parserResults.push({
+          source: parser.tool.id,
+          buckets: buckets.length,
+          sessions: sessions.length
+        });
+      }
+    } catch (err) {
+      logger.warn(`${parser.tool.id} parser failed: ${err.message}`);
+    }
+  }
+  return { buckets: allBuckets, sessions: allSessions, parserResults };
+}
+function getDetectedTools() {
+  return detectInstalledTools();
+}
+
+// src/services/sync-service.ts
+var BATCH_SIZE = 100;
+var SESSION_BATCH_SIZE = 500;
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function formatTime(secs) {
+  if (secs < 60) return `${secs}s`;
+  const h = Math.floor(secs / 3600);
+  const m = Math.floor(secs % 3600 / 60);
+  return h > 0 ? m > 0 ? `${h}h ${m}m` : `${h}h` : `${m}m`;
+}
+function toDeviceMetadata(config) {
+  return {
+    deviceId: getOrCreateDeviceId(config),
+    hostname: hostname3().replace(/\.local$/, "")
+  };
+}
+function toUploadBuckets(buckets, settings, device) {
+  const aggregated = /* @__PURE__ */ new Map();
+  for (const bucket of buckets) {
+    const project = toProjectIdentity({
+      project: bucket.project || "unknown",
+      mode: settings.projectMode,
+      salt: settings.projectHashSalt
+    });
+    const key = [
+      bucket.source,
+      bucket.model,
+      project.projectKey,
+      bucket.bucketStart,
+      device.deviceId
+    ].join("|");
+    const existing = aggregated.get(key);
+    if (existing) {
+      existing.inputTokens += bucket.inputTokens;
+      existing.outputTokens += bucket.outputTokens;
+      existing.reasoningTokens += bucket.reasoningTokens || 0;
+      existing.cachedTokens += bucket.cachedTokens || 0;
+      existing.totalTokens += bucket.totalTokens;
+      continue;
+    }
+    aggregated.set(key, {
+      source: bucket.source,
+      model: bucket.model,
+      projectKey: project.projectKey,
+      projectLabel: project.projectLabel,
+      bucketStart: bucket.bucketStart,
+      deviceId: device.deviceId,
+      hostname: device.hostname,
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      reasoningTokens: bucket.reasoningTokens || 0,
+      cachedTokens: bucket.cachedTokens || 0,
+      totalTokens: bucket.totalTokens
+    });
+  }
+  return Array.from(aggregated.values());
+}
+function toUploadSessions(sessions, settings, device) {
+  return sessions.map((session) => {
+    const project = toProjectIdentity({
+      project: session.project || "unknown",
+      mode: settings.projectMode,
+      salt: settings.projectHashSalt
+    });
+    return {
+      source: session.source,
+      projectKey: project.projectKey,
+      projectLabel: project.projectLabel,
+      sessionHash: session.sessionHash,
+      deviceId: device.deviceId,
+      hostname: device.hostname,
+      firstMessageAt: session.firstMessageAt,
+      lastMessageAt: session.lastMessageAt,
+      durationSeconds: session.durationSeconds,
+      activeSeconds: session.activeSeconds,
+      messageCount: session.messageCount,
+      userMessageCount: session.userMessageCount,
+      inputTokens: session.inputTokens,
+      outputTokens: session.outputTokens,
+      reasoningTokens: session.reasoningTokens,
+      cachedTokens: session.cachedTokens,
+      totalTokens: session.totalTokens,
+      primaryModel: session.primaryModel,
+      modelUsages: session.modelUsages
+    };
+  });
+}
+var SyncFailure = class extends Error {
+  constructor(message, kind, causeError) {
+    super(message);
+    this.kind = kind;
+    this.causeError = causeError;
+  }
+};
+async function runSync(config, opts = {}) {
+  const { quiet = false, source = "manual", throws = false } = opts;
+  const lock = tryAcquireSyncLock(source);
+  if (!lock) {
+    const detail = describeExistingSyncLock();
+    const message = detail ? `Another sync is already running (${detail}). Skipping.` : "Another sync is already running. Skipping.";
+    markSyncFailed(source, message, "skipped_locked");
+    logger.info(message);
+    return {
+      buckets: 0,
+      sessions: 0,
+      skipped: "locked"
+    };
+  }
+  markSyncStarted(source);
+  let totalIngested = 0;
+  let totalSessionsSynced = 0;
+  let caughtError = null;
+  try {
+    const {
+      buckets: allBuckets,
+      sessions: allSessions,
+      parserResults
+    } = await runAllParsers();
+    if (allBuckets.length === 0 && allSessions.length === 0) {
+      if (!quiet) {
+        logger.info("No new usage data found.");
+      }
+      markSyncSucceeded(source, { buckets: 0, sessions: 0 });
+      return { buckets: 0, sessions: 0 };
+    }
+    if (!quiet && parserResults.length > 0) {
+      for (const p of parserResults) {
+        const parts = [];
+        if (p.buckets > 0) parts.push(`${p.buckets} buckets`);
+        if (p.sessions > 0) parts.push(`${p.sessions} sessions`);
+        logger.info(`  ${p.source}: ${parts.join(", ")}`);
+      }
+    }
+    const apiUrl = config.apiUrl || "http://localhost:3000";
+    const apiClient = new ApiClient(apiUrl, config.apiKey);
+    let settings;
+    try {
+      settings = await apiClient.fetchSettings();
+    } catch (error) {
+      if (error.message === "UNAUTHORIZED") {
+        throw new SyncFailure(
+          "Invalid API key. Run `tokenarena init` to reconfigure.",
+          "auth_error",
+          error
+        );
+      }
+      settings = null;
+    }
+    if (!settings) {
+      throw new SyncFailure(
+        "Could not fetch usage settings. Check your server URL and API key.",
+        "error"
+      );
+    }
+    const device = toDeviceMetadata(config);
+    const uploadBuckets = toUploadBuckets(allBuckets, settings, device);
+    const uploadSessions = toUploadSessions(allSessions, settings, device);
+    if (!quiet) {
+      const projectModeLabel = {
+        hashed: "\u54C8\u5E0C\u5316",
+        raw: "\u539F\u59CB\u540D\u79F0",
+        disabled: "\u5DF2\u9690\u85CF"
+      };
+      logger.info(`\u{1F4C2} \u9879\u76EE\u6A21\u5F0F: ${projectModeLabel[settings.projectMode]}`);
+    }
+    const bucketBatches = Math.ceil(uploadBuckets.length / BATCH_SIZE);
+    const sessionBatches = Math.ceil(
+      uploadSessions.length / SESSION_BATCH_SIZE
+    );
+    const totalBatches = Math.max(bucketBatches, sessionBatches, 1);
+    if (!quiet) {
+      const parts = [];
+      if (uploadBuckets.length > 0) {
+        parts.push(`${uploadBuckets.length} buckets`);
+      }
+      if (uploadSessions.length > 0) {
+        parts.push(`${uploadSessions.length} sessions`);
+      }
+      logger.info(
+        `Uploading ${parts.join(" + ")} (${totalBatches} batch${totalBatches > 1 ? "es" : ""})...`
+      );
+    }
+    for (let batchIdx = 0; batchIdx < totalBatches; batchIdx++) {
+      const batch = uploadBuckets.slice(
+        batchIdx * BATCH_SIZE,
+        (batchIdx + 1) * BATCH_SIZE
+      );
+      const batchSessions = uploadSessions.slice(
+        batchIdx * SESSION_BATCH_SIZE,
+        (batchIdx + 1) * SESSION_BATCH_SIZE
+      );
+      const batchNum = batchIdx + 1;
+      const prefix = totalBatches > 1 ? `  [${batchNum}/${totalBatches}] ` : "  ";
+      const result = await apiClient.ingest(
+        device,
+        batch,
+        batchSessions.length > 0 ? batchSessions : void 0,
+        quiet ? void 0 : (sent, total) => {
+          const pct = Math.round(sent / total * 100);
+          process.stdout.write(
+            `\r${prefix}${formatBytes(sent)}/${formatBytes(total)} (${pct}%)\x1B[K`
+          );
+        }
+      );
+      totalIngested += result.ingested ?? batch.length;
+      totalSessionsSynced += result.sessions ?? batchSessions.length;
+    }
+    if (!quiet && (totalBatches > 1 || uploadBuckets.length > 0)) {
+      process.stdout.write("\n");
+    }
+    const syncParts = [`${totalIngested} buckets`];
+    if (totalSessionsSynced > 0) {
+      syncParts.push(`${totalSessionsSynced} sessions`);
+    }
+    logger.info(`Synced ${syncParts.join(" + ")}.`);
+    if (!quiet && totalSessionsSynced > 0) {
+      const totalActive = uploadSessions.reduce(
+        (sum, session) => sum + session.activeSeconds,
+        0
+      );
+      const totalDuration = uploadSessions.reduce(
+        (sum, session) => sum + session.durationSeconds,
+        0
+      );
+      const totalMsgs = uploadSessions.reduce(
+        (sum, session) => sum + session.messageCount,
+        0
+      );
+      logger.info(
+        `  active: ${formatTime(totalActive)} / total: ${formatTime(totalDuration)}, ${totalMsgs} messages`
+      );
+    }
+    if (!quiet) {
+      logger.info(`
+View your dashboard at: ${apiUrl}/usage`);
+    }
+    markSyncSucceeded(source, {
+      buckets: totalIngested,
+      sessions: totalSessionsSynced
+    });
+    return {
+      buckets: totalIngested,
+      sessions: totalSessionsSynced
+    };
+  } catch (error) {
+    const httpErr = error;
+    if (httpErr.message === "UNAUTHORIZED") {
+      caughtError = new SyncFailure(
+        "Invalid API key. Run `tokenarena init` to reconfigure.",
+        "auth_error",
+        error
+      );
+    } else if (error instanceof SyncFailure) {
+      caughtError = error;
+    } else if (totalIngested > 0) {
+      caughtError = new SyncFailure(
+        `Sync partially completed (${totalIngested} buckets uploaded). ${httpErr.message}`,
+        "error",
+        error
+      );
+    } else {
+      caughtError = new SyncFailure(
+        `Sync failed: ${httpErr.message}`,
+        "error",
+        error
+      );
+    }
+    markSyncFailed(source, caughtError.message, caughtError.kind);
+  } finally {
+    lock.release();
+  }
+  if (!caughtError) {
+    return {
+      buckets: totalIngested,
+      sessions: totalSessionsSynced
+    };
+  }
+  logger.error(caughtError.message);
+  if (throws) {
+    throw caughtError.causeError ?? caughtError;
+  }
+  process.exit(1);
+}
+
+// src/commands/daemon.ts
+var DEFAULT_INTERVAL = 5 * 6e4;
+function log(msg) {
+  const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+  process.stdout.write(`[${ts}] ${msg}
+`);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function runDaemon(opts = {}) {
+  const config = loadConfig();
+  if (!config?.apiKey) {
+    logger.error("Not configured. Run `tokenarena init` first.");
+    process.exit(1);
+  }
+  const interval = opts.interval || config.syncInterval || DEFAULT_INTERVAL;
+  const intervalMin = Math.round(interval / 6e4);
+  log(`Daemon started (sync every ${intervalMin}m, Ctrl+C to stop)`);
+  while (true) {
+    try {
+      await runSync(config, {
+        quiet: true,
+        source: "daemon",
+        throws: true
+      });
+    } catch (err) {
+      if (err.message === "UNAUTHORIZED") {
+        log("API key invalid. Exiting.");
+        process.exit(1);
+      }
+      log(`Sync error: ${err.message}`);
+    }
+    await sleep(interval);
+  }
+}
+
+// src/commands/init.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync10 } from "fs";
+import { appendFile, readFile } from "fs/promises";
+import { homedir as homedir8, platform } from "os";
+import { createInterface } from "readline";
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function openBrowser(url) {
+  const cmds = {
+    darwin: "open",
+    linux: "xdg-open",
+    win32: "start"
+  };
+  const cmd = cmds[platform()] || cmds.linux;
+  execFile(cmd, [url], () => {
+  });
+}
+async function runInit(opts = {}) {
+  logger.info("\n  tokenarena - Token Usage Tracker\n");
+  const existing = loadConfig();
+  if (existing?.apiKey) {
+    const answer = await prompt("Config already exists. Overwrite? (y/N) ");
+    if (answer.toLowerCase() !== "y") {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  const apiUrl = opts.apiUrl || getDefaultApiUrl();
+  logger.info(`Open ${apiUrl}/usage and create your API key from Settings.
+`);
+  openBrowser(`${apiUrl}/usage`);
+  let apiKey;
+  while (true) {
+    apiKey = await prompt("Paste your API key: ");
+    if (validateApiKey(apiKey)) break;
+    logger.info('Invalid key \u2014 must start with "vbu_". Try again.');
+  }
+  logger.info(`
+Verifying key ${apiKey.slice(0, 8)}...`);
+  try {
+    const client = new ApiClient(apiUrl, apiKey);
+    const settings = await client.fetchSettings();
+    if (!settings) {
+      logger.info(
+        "Could not verify key settings (network error). Saving anyway.\n"
+      );
+    } else {
+      logger.info("Key verified.\n");
+    }
+  } catch (err) {
+    if (err.message === "UNAUTHORIZED") {
+      logger.error("Invalid API key. Please check and try again.");
+      process.exit(1);
+    }
+    logger.info("Could not verify key (network error). Saving anyway.\n");
+  }
+  const config = {
+    apiKey,
+    apiUrl,
+    ...existing?.deviceId ? { deviceId: existing.deviceId } : {}
+  };
+  saveConfig(config);
+  const deviceId = getOrCreateDeviceId(config);
+  config.deviceId = deviceId;
+  logger.info(`Device registered: ${deviceId.slice(0, 8)}...`);
+  const tools = getDetectedTools();
+  if (tools.length > 0) {
+    logger.info(`Detected tools: ${tools.map((t) => t.name).join(", ")}`);
+  } else {
+    logger.info("No AI coding tools detected. Install one and re-run init.");
+  }
+  logger.info("\nRunning initial sync...");
+  await runSync(config, { source: "init" });
+  logger.info(`
+Setup complete! View your dashboard at: ${apiUrl}/usage`);
+  await setupShellAlias();
+}
+async function setupShellAlias() {
+  const shell = process.env.SHELL;
+  if (!shell) {
+    return;
+  }
+  const shellName = shell.split("/").pop() ?? "";
+  const aliasName = "ta";
+  let configFile;
+  let aliasLine;
+  let sourceHint;
+  switch (shellName) {
+    case "zsh":
+      configFile = `${homedir8()}/.zshrc`;
+      aliasLine = `alias ${aliasName}="tokenarena"`;
+      sourceHint = "source ~/.zshrc";
+      break;
+    case "bash":
+      if (platform() === "darwin" && existsSync10(`${homedir8()}/.bash_profile`)) {
+        configFile = `${homedir8()}/.bash_profile`;
+      } else {
+        configFile = `${homedir8()}/.bashrc`;
+      }
+      aliasLine = `alias ${aliasName}="tokenarena"`;
+      sourceHint = `source ${configFile}`;
+      break;
+    case "fish":
+      configFile = `${homedir8()}/.config/fish/config.fish`;
+      aliasLine = `alias ${aliasName} "tokenarena"`;
+      sourceHint = "source ~/.config/fish/config.fish";
+      break;
+    default:
+      return;
+  }
+  const answer = await prompt(
+    `
+Set up shell alias '${aliasName}' for 'tokenarena'? (Y/n) `
+  );
+  if (answer.toLowerCase() === "n") {
+    return;
+  }
+  try {
+    let existingContent = "";
+    if (existsSync10(configFile)) {
+      existingContent = await readFile(configFile, "utf-8");
+    }
+    const aliasPatterns = [
+      `alias ${aliasName}=`,
+      `alias ${aliasName} "`,
+      `alias ${aliasName}=`
+    ];
+    const aliasExists = aliasPatterns.some(
+      (pattern) => existingContent.includes(pattern)
+    );
+    if (aliasExists) {
+      logger.info(
+        `
+Alias '${aliasName}' already exists in ${configFile}. Skipping.`
+      );
+      return;
+    }
+    const aliasWithComment = `
+# TokenArena alias
+${aliasLine}
+`;
+    await appendFile(configFile, aliasWithComment);
+    logger.info(`
+Added alias to ${configFile}`);
+    logger.info(`  Run '${sourceHint}' or restart your terminal to use it.`);
+    logger.info(`  Then you can use: ${aliasName} sync`);
+  } catch (err) {
+    logger.info(
+      `
+Could not write to ${configFile}: ${err.message}`
+    );
+    logger.info(`  Add this line manually: ${aliasLine}`);
+  }
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync11 } from "fs";
+function formatMaybe(value) {
+  return value || "(never)";
+}
+async function runStatus() {
+  const config = loadConfig();
+  logger.info("\ntokenarena status\n");
+  if (!config?.apiKey) {
+    logger.info("  Config: not configured");
+    logger.info(`  Run \`tokenarena init\` to set up.
+`);
+  } else {
+    logger.info(`  Config: ${getConfigPath()}`);
+    logger.info(`  API key: ${config.apiKey.slice(0, 8)}...`);
+    logger.info(`  API URL: ${config.apiUrl || "http://localhost:3000"}`);
+    if (config.syncInterval) {
+      logger.info(
+        `  Sync interval: ${Math.round(config.syncInterval / 6e4)}m`
+      );
+    }
+  }
+  logger.info("\n  Detected tools:");
+  const detected = detectInstalledTools();
+  if (detected.length === 0) {
+    logger.info("    (none)\n");
+  } else {
+    for (const tool of detected) {
+      logger.info(`    ${tool.name}`);
+    }
+    logger.info("");
+  }
+  logger.info("  All supported tools:");
+  for (const tool of getAllTools()) {
+    const installed = existsSync11(tool.dataDir) ? "installed" : "not found";
+    logger.info(`    ${tool.name}: ${installed}`);
+  }
+  const syncState = loadSyncState();
+  logger.info("\n  Sync state:");
+  logger.info(`    Status: ${syncState.status}`);
+  logger.info(`    Last attempt: ${formatMaybe(syncState.lastAttemptAt)}`);
+  logger.info(`    Last success: ${formatMaybe(syncState.lastSuccessAt)}`);
+  if (syncState.lastSource) {
+    logger.info(`    Last source: ${syncState.lastSource}`);
+  }
+  if (syncState.lastError) {
+    logger.info(`    Last error: ${syncState.lastError}`);
+  }
+  if (syncState.lastResult) {
+    logger.info(
+      `    Last result: ${syncState.lastResult.buckets} buckets, ${syncState.lastResult.sessions} sessions`
+    );
+  }
+  logger.info("");
+}
+
+// src/commands/sync.ts
+async function runSyncCommand(opts = {}) {
+  const config = loadConfig();
+  if (!config?.apiKey) {
+    logger.error("Not configured. Run `tokenarena init` first.");
+    process.exit(1);
+  }
+  await runSync(config, {
+    quiet: opts.quiet,
+    source: "manual"
+  });
+}
+
+// src/infrastructure/runtime/cli-version.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { dirname, join as join10 } from "path";
+import { fileURLToPath } from "url";
+var FALLBACK_VERSION = "0.0.0";
+var cachedVersion;
+function getCliVersion(metaUrl = import.meta.url) {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  const packageJsonPath = join10(
+    dirname(fileURLToPath(metaUrl)),
+    "..",
+    "package.json"
+  );
+  try {
+    const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
+    cachedVersion = typeof packageJson.version === "string" ? packageJson.version : FALLBACK_VERSION;
+  } catch {
+    cachedVersion = FALLBACK_VERSION;
+  }
+  return cachedVersion;
+}
+
+// src/cli.ts
+var CLI_VERSION = getCliVersion();
+function createCli() {
+  const program = new Command();
+  program.name("tokenarena").description("Track token burn across AI coding tools").version(CLI_VERSION).showHelpAfterError().showSuggestionAfterError();
+  program.action(async () => {
+    const config = loadConfig();
+    if (!config?.apiKey) {
+      await runInit();
+    } else {
+      await runSync(config, { source: "default" });
+    }
+  });
+  program.command("init").description("Initialize configuration with API key").option("--api-url <url>", "Custom API server URL").action(async (opts) => {
+    await runInit(opts);
+  });
+  program.command("sync").description("Manually sync usage data to server").addOption(new Option("--quiet").hideHelp()).action(async (opts) => {
+    await runSyncCommand(opts);
+  });
+  program.command("daemon").description("Run continuous sync (every 5 minutes by default)").option("--interval <ms>", "Sync interval in milliseconds", parseInt).action(async (opts) => {
+    await runDaemon(opts);
+  });
+  program.command("status").description("Show configuration and detected tools").action(async () => {
+    await runStatus();
+  });
+  program.command("config").description("Manage configuration").argument("<subcommand>", "get|set|show").argument("[key]", "Config key").argument("[value]", "Config value").allowUnknownOption(true).action((_subcommand, _key, _value, cmd) => {
+    const args = cmd.args.slice(1);
+    handleConfig(args);
+  });
+  return program;
+}
+
+// src/infrastructure/runtime/main-module.ts
+import { existsSync as existsSync12, realpathSync } from "fs";
+import { resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
+  if (!argvEntry) {
+    return false;
+  }
+  const currentModulePath = fileURLToPath2(metaUrl);
+  try {
+    return realpathSync(argvEntry) === realpathSync(currentModulePath);
+  } catch {
+    if (!existsSync12(argvEntry)) {
+      return false;
+    }
+    return resolve(argvEntry) === resolve(currentModulePath);
+  }
+}
+
+// src/index.ts
+function normalizeArgv(argv) {
+  return argv.filter((arg, index) => index < 2 || arg !== "--");
+}
+function run(argv = process.argv) {
+  const program = createCli();
+  program.parse(normalizeArgv(argv));
+}
+if (isMainModule()) {
+  run();
+}
+export {
+  normalizeArgv,
+  run
+};
+//# sourceMappingURL=index.js.map