@yishiguji/tokenarena 0.9.0 → 0.11.0

package/dist/index.js

@@ -4282,37 +4282,616 @@ var ZCodeParser = class {
 };
 registerParser(new ZCodeParser());
 
+// src/parsers/qodercli.ts
+import { existsSync as existsSync22, readdirSync as readdirSync12 } from "fs";
+import { homedir as homedir23 } from "os";
+import { basename as basename9, join as join24 } from "path";
+var TOOL_ID15 = "qodercli";
+var TOOL_NAME15 = "Qoder CLI";
+var DEFAULT_PROJECTS_DIR = join24(homedir23(), ".qoder", "projects");
+var DEFAULT_LOGS_DIR = join24(homedir23(), ".qoder", "logs", "sessions");
+var DEFAULT_RUNS_DIR = join24(homedir23(), ".qoder", "logs", "runs");
+var CLI_ENTRYPOINT = "cli";
+var IDE_ENTRYPOINT = "acp";
+var CREDIT_MODEL_FALLBACK = "credits";
+function createToolDefinition12(projectsDir) {
+  return {
+    id: TOOL_ID15,
+    name: TOOL_NAME15,
+    dataDir: projectsDir
+  };
+}
+function toSafeNumber12(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function normalizeForPrefix5(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function extractQoderProject(filePath, projectsDir) {
+  const normalizedFilePath = normalizeForPrefix5(filePath);
+  const normalizedProjectsDir = normalizeForPrefix5(projectsDir);
+  const prefix = `${normalizedProjectsDir}/`;
+  if (!normalizedFilePath.startsWith(prefix)) return "unknown";
+  const relative = normalizedFilePath.slice(prefix.length);
+  const firstSeg = relative.split("/")[0];
+  if (!firstSeg) return "unknown";
+  const parts = firstSeg.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] ?? "unknown" : "unknown";
+}
+function classifyQoderEntrypoint(content) {
+  let hasCli = false;
+  let hasAcp = false;
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.entrypoint === CLI_ENTRYPOINT) hasCli = true;
+      else if (obj.entrypoint === IDE_ENTRYPOINT) hasAcp = true;
+    } catch {
+    }
+    if (hasCli) return "cli";
+  }
+  if (hasAcp) return "acp";
+  return "unknown";
+}
+function isQodercliBinaryPresent() {
+  const home = homedir23();
+  const candidates = [
+    join24(home, ".local", "bin", "qodercli"),
+    join24(home, ".qoder", "bin", "qodercli"),
+    join24(home, ".qoder-cli")
+  ];
+  return candidates.some((path) => existsSync22(path));
+}
+function projectFromEncodedSlug(slug) {
+  const parts = slug.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] ?? "unknown" : "unknown";
+}
+function projectFromCwd(cwd) {
+  if (!cwd) return "unknown";
+  const leaf = basename9(cwd.replace(/[\\/]+$/, ""));
+  return leaf || "unknown";
+}
+function totalCreditsUsed(quota) {
+  return toSafeNumber12(quota.userQuota?.used) + toSafeNumber12(quota.orgResourcePackage?.used) + toSafeNumber12(quota.addOnQuota?.used);
+}
+function parseRunManifest(content) {
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function extractCreditSnapshotsFromLog(logContent, meta) {
+  const snapshots = [];
+  let sessionId = meta.defaultSessionId || meta.runId;
+  let model = meta.defaultModel || CREDIT_MODEL_FALLBACK;
+  for (const line of logContent.split("\n")) {
+    if (!line.trim()) continue;
+    if (line.includes("session.config.loaded")) {
+      const sessionMatch = line.match(/session=([^\s\]]+)/);
+      if (sessionMatch?.[1]) sessionId = sessionMatch[1];
+      const modelMatch = line.match(/model="([^"]+)"/);
+      if (modelMatch?.[1]) model = modelMatch[1];
+    }
+    if (!line.includes("quota/usage response:")) continue;
+    const tsMatch = line.match(/^(\d{4}-\d{2}-\d{2}T[^\s]+)/);
+    const jsonMatch = line.match(/response:\s+(\{.*\})\s*$/);
+    if (!tsMatch?.[1] || !jsonMatch?.[1]) continue;
+    let quota;
+    try {
+      quota = JSON.parse(jsonMatch[1]);
+    } catch {
+      continue;
+    }
+    const timestamp = new Date(tsMatch[1]);
+    if (Number.isNaN(timestamp.getTime())) continue;
+    snapshots.push({
+      timestamp,
+      // credits, not tokens
+      totalUsed: totalCreditsUsed(quota),
+      project: meta.project,
+      sessionId,
+      model,
+      runId: meta.runId
+    });
+  }
+  return snapshots;
+}
+function creditSnapshotsToEntries(snapshots) {
+  if (snapshots.length === 0) return [];
+  const sorted = [...snapshots].sort(
+    (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
+  );
+  const entries = [];
+  let previousUsed = null;
+  for (const snap of sorted) {
+    if (previousUsed !== null) {
+      const creditDelta = snap.totalUsed - previousUsed;
+      if (creditDelta > 0) {
+        entries.push({
+          sessionId: snap.sessionId,
+          source: TOOL_ID15,
+          model: snap.model || CREDIT_MODEL_FALLBACK,
+          project: snap.project,
+          timestamp: snap.timestamp,
+          // CREDIT counts (not tokens) — see file header.
+          inputTokens: creditDelta,
+          outputTokens: 0,
+          reasoningTokens: 0,
+          cachedTokens: 0
+        });
+      }
+    }
+    previousUsed = snap.totalUsed;
+  }
+  return entries;
+}
+var QoderCliParser = class {
+  constructor(projectsDir = DEFAULT_PROJECTS_DIR, logsDir = DEFAULT_LOGS_DIR, runsDir = DEFAULT_RUNS_DIR) {
+    this.projectsDir = projectsDir;
+    this.logsDir = logsDir;
+    this.runsDir = runsDir;
+    this.tool = createToolDefinition12(projectsDir);
+  }
+  projectsDir;
+  logsDir;
+  runsDir;
+  tool;
+  async parse() {
+    const entries = [];
+    const sessionEvents = [];
+    this.parseProjectSessions(sessionEvents);
+    entries.push(...this.parseCreditDeltas());
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  parseProjectSessions(sessionEvents) {
+    if (!existsSync22(this.projectsDir)) return;
+    for (const filePath of findJsonlFiles(this.projectsDir)) {
+      if (basename9(filePath).startsWith("verified-")) continue;
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      if (classifyQoderEntrypoint(content) !== CLI_ENTRYPOINT) continue;
+      const project = extractQoderProject(filePath, this.projectsDir);
+      const sessionId = extractSessionId(filePath);
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.entrypoint === IDE_ENTRYPOINT) continue;
+          if (obj.type !== "user" && obj.type !== "assistant") continue;
+          const timestamp = obj.timestamp;
+          if (timestamp == null) continue;
+          const ts = new Date(
+            typeof timestamp === "number" && timestamp < 1e12 ? timestamp * 1e3 : timestamp
+          );
+          if (Number.isNaN(ts.getTime())) continue;
+          sessionEvents.push({
+            sessionId,
+            source: TOOL_ID15,
+            project,
+            timestamp: ts,
+            role: obj.type === "user" ? "user" : "assistant"
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Parse credit consumption from run logs.
+   * There is no token data here — only quota/usage credit totals.
+   */
+  parseCreditDeltas() {
+    if (!existsSync22(this.runsDir)) return [];
+    let runDirs;
+    try {
+      runDirs = readdirSync12(this.runsDir, { withFileTypes: true }).filter(
+        (d) => d.isDirectory()
+      );
+    } catch {
+      return [];
+    }
+    const allSnapshots = [];
+    for (const dir of runDirs) {
+      const runPath = join24(this.runsDir, dir.name);
+      const logPath = join24(runPath, "qodercli.log");
+      if (!existsSync22(logPath)) continue;
+      const logContent = readFileSafe(logPath);
+      if (!logContent?.includes("quota/usage response:")) {
+        continue;
+      }
+      const manifest = parseRunManifest(
+        readFileSafe(join24(runPath, "manifest.json"))
+      );
+      const project = manifest?.project_id ? projectFromEncodedSlug(manifest.project_id) : projectFromCwd(manifest?.cwd);
+      const snapshots = extractCreditSnapshotsFromLog(logContent, {
+        project,
+        runId: manifest?.run_id || dir.name
+      });
+      allSnapshots.push(...snapshots);
+    }
+    return creditSnapshotsToEntries(allSnapshots);
+  }
+  isInstalled() {
+    return isQodercliBinaryPresent() || existsSync22(this.runsDir) || existsSync22(this.logsDir) || existsSync22(this.projectsDir);
+  }
+};
+registerParser(new QoderCliParser());
+
+// src/parsers/grok-build.ts
+import { existsSync as existsSync23, readdirSync as readdirSync13 } from "fs";
+import { homedir as homedir24 } from "os";
+import { basename as basename10, join as join25 } from "path";
+var TOOL_ID16 = "grok-build";
+var TOOL_NAME16 = "Grok Build";
+var DEFAULT_DATA_DIR7 = join25(homedir24(), ".grok", "sessions");
+function createToolDefinition13(dataDir) {
+  return {
+    id: TOOL_ID16,
+    name: TOOL_NAME16,
+    dataDir
+  };
+}
+function toSafeNumber13(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function projectFromEncodedCwd(encoded) {
+  try {
+    const decoded = decodeURIComponent(encoded);
+    const leaf = basename10(decoded.replace(/[\\/]+$/, ""));
+    return leaf || "unknown";
+  } catch {
+    const leaf = basename10(encoded);
+    return leaf || "unknown";
+  }
+}
+function resolveTimestamp(obj) {
+  const ms = obj._meta?.agentTimestampMs ?? obj.params?.update?._meta?.agentTimestampMs;
+  if (typeof ms === "number" && Number.isFinite(ms)) {
+    return new Date(ms);
+  }
+  const raw = obj.timestamp;
+  if (raw == null) return null;
+  if (typeof raw === "number") {
+    return new Date(raw < 1e12 ? raw * 1e3 : raw);
+  }
+  const ts = new Date(raw);
+  return Number.isNaN(ts.getTime()) ? null : ts;
+}
+function pushUsageEntries(entries, args) {
+  const { sessionId, project, timestamp, usage, fallbackModel } = args;
+  const modelUsage = usage.modelUsage;
+  const models = modelUsage && Object.keys(modelUsage).length > 0 ? Object.entries(modelUsage) : [[fallbackModel, usage]];
+  for (const [model, mu] of models) {
+    const cached = toSafeNumber13(mu.cachedReadTokens);
+    const reasoning = toSafeNumber13(mu.reasoningTokens);
+    const rawInput = toSafeNumber13(mu.inputTokens);
+    const rawOutput = toSafeNumber13(mu.outputTokens);
+    const inputTokens = Math.max(0, rawInput - cached);
+    const outputTokens = Math.max(0, rawOutput - reasoning);
+    if (inputTokens === 0 && outputTokens === 0 && cached === 0 && reasoning === 0) {
+      continue;
+    }
+    entries.push({
+      sessionId,
+      source: TOOL_ID16,
+      model: model || fallbackModel || "unknown",
+      project,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      reasoningTokens: reasoning,
+      cachedTokens: cached
+    });
+  }
+}
+function findSessionDirs(dataDir) {
+  const results = [];
+  if (!existsSync23(dataDir)) return results;
+  let projectDirs;
+  try {
+    projectDirs = readdirSync13(dataDir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const projectEntry of projectDirs) {
+    if (!projectEntry.isDirectory()) continue;
+    if (projectEntry.name.endsWith(".sqlite")) continue;
+    const projectDir = join25(dataDir, projectEntry.name);
+    const project = projectFromEncodedCwd(projectEntry.name);
+    let sessionEntries;
+    try {
+      sessionEntries = readdirSync13(projectDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const sessionEntry of sessionEntries) {
+      if (!sessionEntry.isDirectory()) continue;
+      const sessionDir = join25(projectDir, sessionEntry.name);
+      if (!existsSync23(join25(sessionDir, "updates.jsonl"))) continue;
+      results.push({
+        sessionDir,
+        project,
+        sessionId: sessionEntry.name
+      });
+    }
+  }
+  return results;
+}
+function readFallbackModel(sessionDir) {
+  const summaryPath = join25(sessionDir, "summary.json");
+  const content = readFileSafe(summaryPath);
+  if (!content) return "unknown";
+  try {
+    const summary = JSON.parse(content);
+    return summary.current_model_id || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var GrokBuildParser = class {
+  constructor(dataDir = DEFAULT_DATA_DIR7) {
+    this.dataDir = dataDir;
+    this.tool = createToolDefinition13(dataDir);
+  }
+  dataDir;
+  tool;
+  async parse() {
+    const entries = [];
+    const sessionEvents = [];
+    const sessions = findSessionDirs(this.dataDir);
+    for (const { sessionDir, project, sessionId } of sessions) {
+      const updatesPath = join25(sessionDir, "updates.jsonl");
+      const content = readFileSafe(updatesPath);
+      if (!content) continue;
+      const fallbackModel = readFallbackModel(sessionDir);
+      const seenUserPrompts = /* @__PURE__ */ new Set();
+      const ANON_USER_OPEN = "__anon_user_open";
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const update = obj.params?.update;
+        if (!update?.sessionUpdate) continue;
+        const ts = resolveTimestamp(obj);
+        if (!ts) continue;
+        const sid = obj.params?.sessionId || sessionId;
+        const updateType = update.sessionUpdate;
+        const promptId = update.prompt_id || update._meta?.promptId || null;
+        if (updateType === "user_message_chunk") {
+          const key = promptId ?? ANON_USER_OPEN;
+          if (seenUserPrompts.has(key)) continue;
+          seenUserPrompts.add(key);
+          sessionEvents.push({
+            sessionId: sid,
+            source: TOOL_ID16,
+            project,
+            timestamp: ts,
+            role: "user"
+          });
+          continue;
+        }
+        if (updateType !== "turn_completed") continue;
+        seenUserPrompts.delete(ANON_USER_OPEN);
+        sessionEvents.push({
+          sessionId: sid,
+          source: TOOL_ID16,
+          project,
+          timestamp: ts,
+          role: "assistant"
+        });
+        const usage = update.usage;
+        if (!usage) continue;
+        pushUsageEntries(entries, {
+          sessionId: sid,
+          project,
+          timestamp: ts,
+          usage,
+          fallbackModel: update.model_id || fallbackModel
+        });
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync23(this.dataDir) || existsSync23(join25(homedir24(), ".grok")) || existsSync23(join25(homedir24(), ".local", "bin", "grok"));
+  }
+};
+registerParser(new GrokBuildParser());
+
+// src/parsers/atomcode.ts
+import { existsSync as existsSync24 } from "fs";
+import { homedir as homedir25 } from "os";
+import { basename as basename11, join as join26 } from "path";
+var TOOL_ID17 = "atomcode";
+var TOOL_NAME17 = "AtomCode";
+var DEFAULT_SESSIONS_DIR6 = join26(homedir25(), ".atomcode", "sessions");
+function getAtomCodeSessionsDirs(env = process.env) {
+  const dirs = [
+    env.TOKEN_ARENA_ATOMCODE_DIR,
+    env.ATOMCODE_HOME ? join26(env.ATOMCODE_HOME, "sessions") : void 0,
+    DEFAULT_SESSIONS_DIR6
+  ].filter((value) => Boolean(value));
+  return Array.from(new Set(dirs));
+}
+function toNonNegativeNumber3(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) && numberValue >= 0 ? numberValue : 0;
+}
+function parseTimestamp3(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const timestamp = new Date(value);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const asNumber = Number(value);
+    if (Number.isFinite(asNumber)) {
+      const timestamp2 = new Date(asNumber);
+      if (!Number.isNaN(timestamp2.getTime())) {
+        return timestamp2;
+      }
+    }
+    const timestamp = new Date(value);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+  }
+  return null;
+}
+function parseMeta(content) {
+  if (!content) return null;
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function getMetaModel(meta) {
+  for (const turn of meta?.turn_stats ?? []) {
+    for (const usage of turn.model_usage ?? []) {
+      if (typeof usage.model_id === "string" && usage.model_id) {
+        return usage.model_id;
+      }
+    }
+  }
+  return "unknown";
+}
+function getMetaProject(meta) {
+  if (typeof meta?.working_dir === "string" && meta.working_dir) {
+    return basename11(meta.working_dir) || "unknown";
+  }
+  return "unknown";
+}
+var AtomCodeParser = class {
+  tool;
+  sessionsDirs;
+  constructor(sessionsDir) {
+    this.sessionsDirs = sessionsDir ? [sessionsDir] : getAtomCodeSessionsDirs();
+    this.tool = {
+      id: TOOL_ID17,
+      name: TOOL_NAME17,
+      dataDir: this.sessionsDirs[0] ?? DEFAULT_SESSIONS_DIR6
+    };
+  }
+  async parse() {
+    const entries = [];
+    const sessionEvents = [];
+    const seenEntryKeys = /* @__PURE__ */ new Set();
+    for (const sessionsDir of this.sessionsDirs) {
+      for (const filePath of findJsonlFiles(sessionsDir)) {
+        const content = readFileSafe(filePath);
+        if (!content) continue;
+        const rows = parseJsonl(content);
+        if (rows.length === 0) continue;
+        const fallbackSessionId = extractSessionId(filePath);
+        const meta = parseMeta(
+          readFileSafe(filePath.replace(/\.jsonl$/, ".meta"))
+        );
+        const project = getMetaProject(meta);
+        const model = getMetaModel(meta);
+        for (const row of rows) {
+          const sessionId = typeof row.session_id === "string" && row.session_id ? row.session_id : fallbackSessionId;
+          const timestamp = parseTimestamp3(row.ts);
+          if (!timestamp) continue;
+          if (row.user !== void 0 || row.assistant !== void 0) {
+            sessionEvents.push({
+              sessionId,
+              source: TOOL_ID17,
+              project,
+              timestamp,
+              role: row.user !== void 0 ? "user" : "assistant"
+            });
+          }
+          const usage = row.usage;
+          if (!usage) continue;
+          const prompt = toNonNegativeNumber3(usage.prompt);
+          const completion = toNonNegativeNumber3(usage.completion);
+          const cached = toNonNegativeNumber3(usage.cached);
+          const inputTokens = Math.max(0, prompt - cached);
+          if (inputTokens + completion + cached === 0) {
+            continue;
+          }
+          const entryKey = [
+            sessionId,
+            timestamp.toISOString(),
+            model,
+            inputTokens,
+            completion,
+            cached
+          ].join("|");
+          if (seenEntryKeys.has(entryKey)) {
+            continue;
+          }
+          seenEntryKeys.add(entryKey);
+          entries.push({
+            sessionId,
+            source: TOOL_ID17,
+            model,
+            project,
+            timestamp,
+            inputTokens,
+            outputTokens: completion,
+            reasoningTokens: 0,
+            cachedTokens: cached
+          });
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return this.sessionsDirs.some((dir) => existsSync24(dir));
+  }
+};
+registerParser(new AtomCodeParser());
+
 // src/cli.ts
 import { Command, Option } from "commander";
 
 // src/infrastructure/config/manager.ts
 import { randomUUID } from "crypto";
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync25,
   mkdirSync,
   readFileSync as readFileSync9,
   unlinkSync,
   writeFileSync
 } from "fs";
-import { join as join25 } from "path";
+import { join as join28 } from "path";
 
 // src/infrastructure/xdg.ts
-import { homedir as homedir23 } from "os";
-import { join as join24 } from "path";
+import { homedir as homedir26 } from "os";
+import { join as join27 } from "path";
 function getConfigHome() {
-  return process.env.XDG_CONFIG_HOME || join24(homedir23(), ".config");
+  return process.env.XDG_CONFIG_HOME || join27(homedir26(), ".config");
 }
 function getStateHome() {
-  return process.env.XDG_STATE_HOME || join24(homedir23(), ".local", "state");
+  return process.env.XDG_STATE_HOME || join27(homedir26(), ".local", "state");
 }
 function getRuntimeDir() {
   return process.env.XDG_RUNTIME_DIR || getStateHome();
 }
 
 // src/infrastructure/config/manager.ts
-var CONFIG_DIR = join25(getConfigHome(), "tokenarena");
+var CONFIG_DIR = join28(getConfigHome(), "tokenarena");
 var isDev = process.env.TOKEN_ARENA_DEV === "1";
-var CONFIG_FILE = join25(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
+var CONFIG_FILE = join28(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
 var DEFAULT_API_URL = "https://token.guji.uno";
 var VALID_CONFIG_KEYS = [
   "apiKey",
@@ -4328,7 +4907,7 @@ function getConfigDir() {
   return CONFIG_DIR;
 }
 function loadConfig() {
-  if (!existsSync22(CONFIG_FILE)) return null;
+  if (!existsSync25(CONFIG_FILE)) return null;
   try {
     const raw = readFileSync9(CONFIG_FILE, "utf-8");
     const config = JSON.parse(raw);
@@ -4346,7 +4925,7 @@ function saveConfig(config) {
 `, "utf-8");
 }
 function deleteConfig() {
-  if (existsSync22(CONFIG_FILE)) {
+  if (existsSync25(CONFIG_FILE)) {
     unlinkSync(CONFIG_FILE);
   }
 }
@@ -5208,7 +5787,7 @@ var ApiClient = class {
 // src/infrastructure/runtime/lock.ts
 import {
   closeSync,
-  existsSync as existsSync23,
+  existsSync as existsSync26,
   openSync,
   readFileSync as readFileSync10,
   rmSync as rmSync3,
@@ -5217,22 +5796,22 @@ import {
 
 // src/infrastructure/runtime/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join26 } from "path";
+import { join as join29 } from "path";
 var APP_NAME = "tokenarena";
 function getRuntimeDirPath() {
-  return join26(getRuntimeDir(), APP_NAME);
+  return join29(getRuntimeDir(), APP_NAME);
 }
 function getStateDir() {
-  return join26(getStateHome(), APP_NAME);
+  return join29(getStateHome(), APP_NAME);
 }
 function getSyncLockPath() {
-  return join26(getRuntimeDirPath(), "sync.lock");
+  return join29(getRuntimeDirPath(), "sync.lock");
 }
 function getSyncStatePath() {
-  return join26(getStateDir(), "status.json");
+  return join29(getStateDir(), "status.json");
 }
 function getUploadManifestPath() {
-  return join26(getStateDir(), "upload-manifest.json");
+  return join29(getStateDir(), "upload-manifest.json");
 }
 function ensureAppDirs() {
   mkdirSync2(getRuntimeDirPath(), { recursive: true });
@@ -5250,7 +5829,7 @@ function isProcessAlive(pid) {
   }
 }
 function readLockMetadata(lockPath) {
-  if (!existsSync23(lockPath)) {
+  if (!existsSync26(lockPath)) {
     return null;
   }
   try {
@@ -5324,13 +5903,13 @@ function describeExistingSyncLock() {
 }
 
 // src/infrastructure/runtime/state.ts
-import { existsSync as existsSync24, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
 function getDefaultState() {
   return { status: "idle" };
 }
 function loadSyncState() {
   const path = getSyncStatePath();
-  if (!existsSync24(path)) {
+  if (!existsSync27(path)) {
     return getDefaultState();
   }
   try {
@@ -5391,7 +5970,7 @@ function markSyncFailed(source, error, status) {
 }
 
 // src/infrastructure/runtime/upload-manifest.ts
-import { existsSync as existsSync25, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
 function isRecordOfStrings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -5407,7 +5986,7 @@ function isUploadManifest(value) {
 }
 function loadUploadManifest() {
   const path = getUploadManifestPath();
-  if (!existsSync25(path)) {
+  if (!existsSync28(path)) {
     return null;
   }
   try {
@@ -5947,18 +6526,18 @@ View your dashboard at: ${apiUrl}/usage`);
 
 // src/commands/init.ts
 import { execFileSync as execFileSync7, spawn } from "child_process";
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { appendFile, mkdir, readFile } from "fs/promises";
-import { homedir as homedir26, platform as platform5 } from "os";
-import { dirname as dirname6, join as join27, posix as posix3, win32 } from "path";
+import { homedir as homedir29, platform as platform5 } from "os";
+import { dirname as dirname6, join as join30, posix as posix3, win32 } from "path";
 
 // src/infrastructure/service/index.ts
 import { platform as platform4 } from "os";
 
 // src/infrastructure/service/linux-systemd.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync26, mkdirSync as mkdirSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir24, platform as platform2 } from "os";
+import { existsSync as existsSync29, mkdirSync as mkdirSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir27, platform as platform2 } from "os";
 import { posix } from "path";
 
 // src/utils/command.ts
@@ -6027,10 +6606,10 @@ function escapeXml(value) {
 
 // src/infrastructure/service/linux-systemd.ts
 var SYSTEMD_SERVICE_NAME = "tokenarena";
-function getLinuxSystemdServiceDir(homePath = homedir24()) {
+function getLinuxSystemdServiceDir(homePath = homedir27()) {
   return posix.join(homePath, ".config", "systemd", "user");
 }
-function getLinuxSystemdServiceFile(homePath = homedir24()) {
+function getLinuxSystemdServiceFile(homePath = homedir27()) {
   return posix.join(
     getLinuxSystemdServiceDir(homePath),
     `${SYSTEMD_SERVICE_NAME}.service`
@@ -6087,7 +6666,7 @@ function ensureSystemdAvailable() {
 }
 function createLinuxSystemdServiceBackend() {
   function isInstalled() {
-    return existsSync26(getLinuxSystemdServiceFile());
+    return existsSync29(getLinuxSystemdServiceFile());
   }
   async function setup(skipPrompt = false) {
     if (!ensureSystemdAvailable()) {
@@ -6212,7 +6791,7 @@ function createLinuxSystemdServiceBackend() {
   }
   async function uninstall(skipPrompt = false) {
     const serviceFile = getLinuxSystemdServiceFile();
-    if (!existsSync26(serviceFile)) {
+    if (!existsSync29(serviceFile)) {
       logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
       return;
     }
@@ -6273,17 +6852,17 @@ function createLinuxSystemdServiceBackend() {
 
 // src/infrastructure/service/macos-launchd.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync27, mkdirSync as mkdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir25, platform as platform3 } from "os";
+import { existsSync as existsSync30, mkdirSync as mkdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir28, platform as platform3 } from "os";
 import { posix as posix2 } from "path";
 var MACOS_LAUNCHD_LABEL = "com.guji.tokenarena";
 function getCurrentUid() {
   return typeof process.getuid === "function" ? process.getuid() : null;
 }
-function getMacosLaunchAgentDir(homePath = homedir25()) {
+function getMacosLaunchAgentDir(homePath = homedir28()) {
   return posix2.join(homePath, "Library", "LaunchAgents");
 }
-function getMacosLaunchAgentFile(homePath = homedir25()) {
+function getMacosLaunchAgentFile(homePath = homedir28()) {
   return posix2.join(
     getMacosLaunchAgentDir(homePath),
     `${MACOS_LAUNCHD_LABEL}.plist`
@@ -6410,7 +6989,7 @@ function writeLaunchAgentPlist() {
     label: MACOS_LAUNCHD_LABEL,
     programArguments: [command.execPath, ...command.args],
     environment: getManagedServiceEnvironment(),
-    workingDirectory: homedir25(),
+    workingDirectory: homedir28(),
     standardOutPath: stdoutPath,
     standardErrorPath: stderrPath
   });
@@ -6435,7 +7014,7 @@ function bootstrapLaunchAgent() {
 }
 function createMacosLaunchdServiceBackend() {
   function isInstalled() {
-    return existsSync27(getMacosLaunchAgentFile());
+    return existsSync30(getMacosLaunchAgentFile());
   }
   async function setup(skipPrompt = false) {
     if (!ensureLaunchctlAvailable()) {
@@ -6576,7 +7155,7 @@ function createMacosLaunchdServiceBackend() {
   }
   async function uninstall(skipPrompt = false) {
     const plistFile = getMacosLaunchAgentFile();
-    if (!existsSync27(plistFile)) {
+    if (!existsSync30(plistFile)) {
       logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
       return;
     }
@@ -6687,7 +7266,7 @@ function resolvePowerShellProfilePath() {
   const systemRoot = process.env.SYSTEMROOT || "C:\\Windows";
   const candidates = [
     "pwsh.exe",
-    join27(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    join30(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   ];
   for (const command of candidates) {
     try {
@@ -6716,8 +7295,8 @@ function resolvePowerShellProfilePath() {
 function resolveShellAliasSetup(options = {}) {
   const currentPlatform = options.currentPlatform ?? platform5();
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir26();
-  const pathExists = options.exists ?? existsSync28;
+  const homeDir = options.homeDir ?? homedir29();
+  const pathExists = options.exists ?? existsSync31;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
   const aliasName = "ta";
@@ -6914,7 +7493,7 @@ async function setupShellAlias() {
   try {
     await mkdir(dirname6(setup.configFile), { recursive: true });
     let existingContent = "";
-    if (existsSync28(setup.configFile)) {
+    if (existsSync31(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
     }
     const normalizedContent = existingContent.toLowerCase();
@@ -7173,7 +7752,7 @@ function buildLocalUsageDashboardData(input2) {
 
 // src/infrastructure/runtime/cli-version.ts
 import { readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname7, join as join28 } from "path";
+import { dirname as dirname7, join as join31 } from "path";
 import { fileURLToPath } from "url";
 var FALLBACK_VERSION = "0.0.0";
 var cachedVersion;
@@ -7181,7 +7760,7 @@ function getCliVersion(metaUrl = import.meta.url) {
   if (cachedVersion) {
     return cachedVersion;
   }
-  const packageJsonPath = join28(
+  const packageJsonPath = join31(
     dirname7(fileURLToPath(metaUrl)),
     "..",
     "package.json"
@@ -7592,8 +8171,8 @@ async function runSyncCommand(opts = {}) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync29, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir27, platform as platform6 } from "os";
+import { existsSync as existsSync32, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir30, platform as platform6 } from "os";
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -7602,22 +8181,22 @@ function removeShellAlias() {
   let configFile;
   switch (shellName) {
     case "zsh":
-      configFile = `${homedir27()}/.zshrc`;
+      configFile = `${homedir30()}/.zshrc`;
       break;
     case "bash":
-      if (platform6() === "darwin" && existsSync29(`${homedir27()}/.bash_profile`)) {
-        configFile = `${homedir27()}/.bash_profile`;
+      if (platform6() === "darwin" && existsSync32(`${homedir30()}/.bash_profile`)) {
+        configFile = `${homedir30()}/.bash_profile`;
       } else {
-        configFile = `${homedir27()}/.bashrc`;
+        configFile = `${homedir30()}/.bashrc`;
       }
       break;
     case "fish":
-      configFile = `${homedir27()}/.config/fish/config.fish`;
+      configFile = `${homedir30()}/.config/fish/config.fish`;
       break;
     default:
       return;
   }
-  if (!existsSync29(configFile)) return;
+  if (!existsSync32(configFile)) return;
   try {
     let content = readFileSync14(configFile, "utf-8");
     const aliasPatterns = [
@@ -7656,7 +8235,7 @@ async function runUninstall() {
   const runtimeDir = getRuntimeDirPath();
   const serviceBackend = getServiceBackend();
   const hasInstalledService = serviceBackend?.isInstalled() ?? false;
-  const hasLocalArtifacts = existsSync29(configPath) || existsSync29(configDir) || existsSync29(stateDir) || existsSync29(runtimeDir) || hasInstalledService;
+  const hasLocalArtifacts = existsSync32(configPath) || existsSync32(configDir) || existsSync32(stateDir) || existsSync32(runtimeDir) || hasInstalledService;
   if (!hasLocalArtifacts) {
     logger.info(formatHeader("\u5378\u8F7D TokenArena"));
     logger.info(formatBullet("\u672A\u53D1\u73B0\u672C\u5730\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D\u3002"));
@@ -7700,22 +8279,22 @@ async function runUninstall() {
     }
   }
   logger.info(formatSection("\u6267\u884C\u7ED3\u679C"));
-  if (existsSync29(configPath)) {
+  if (existsSync32(configPath)) {
     deleteConfig();
     logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
   }
-  if (existsSync29(configDir)) {
+  if (existsSync32(configDir)) {
     try {
       rmSync6(configDir, { recursive: false, force: true });
       logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u76EE\u5F55\u3002", "success"));
     } catch {
     }
   }
-  if (existsSync29(stateDir)) {
+  if (existsSync32(stateDir)) {
     rmSync6(stateDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u72B6\u6001\u6570\u636E\u3002", "success"));
   }
-  if (existsSync29(runtimeDir)) {
+  if (existsSync32(runtimeDir)) {
     rmSync6(runtimeDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u8FD0\u884C\u65F6\u6570\u636E\u3002", "success"));
   }
@@ -7946,7 +8525,7 @@ function createCli() {
 }
 
 // src/infrastructure/runtime/main-module.ts
-import { existsSync as existsSync30, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync33, realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
@@ -7957,7 +8536,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
   try {
     return realpathSync2(argvEntry) === realpathSync2(currentModulePath);
   } catch {
-    if (!existsSync30(argvEntry)) {
+    if (!existsSync33(argvEntry)) {
       return false;
     }
     return resolve3(argvEntry) === resolve3(currentModulePath);