@yishiguji/tokenarena 0.10.0 → 0.12.0

package/dist/index.js

@@ -4713,37 +4713,425 @@ var GrokBuildParser = class {
 };
 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/parsers/dsh.ts
+import { existsSync as existsSync25, readdirSync as readdirSync14, readFileSync as readFileSync9 } from "fs";
+import { homedir as homedir26 } from "os";
+import { basename as basename12, join as join27 } from "path";
+import * as zlib from "zlib";
+var TOOL_ID18 = "dsh";
+var TOOL_NAME18 = "DeepSeek Harness";
+var DEFAULT_SESSIONS_DIR7 = join27(homedir26(), ".dsh", "sessions");
+var LOG_BASENAME = "session";
+function getDshSessionsDirs(env = process.env) {
+  const dirs = [
+    env.TOKEN_ARENA_DSH_DIR,
+    env.DSH_HOME ? join27(env.DSH_HOME, "sessions") : void 0,
+    DEFAULT_SESSIONS_DIR7
+  ].filter((value) => Boolean(value));
+  return Array.from(new Set(dirs));
+}
+function toNonNegativeNumber4(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) && numberValue >= 0 ? numberValue : 0;
+}
+function scanZstdFrames(buffer) {
+  const ZSTD_MAGIC = 4247762216;
+  const frames = [];
+  let offset = 0;
+  while (offset < buffer.length) {
+    const start = offset;
+    if (buffer.length - offset < 4) break;
+    if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) break;
+    offset += 4;
+    if (offset === buffer.length) break;
+    const descriptor = buffer.readUInt8(offset);
+    offset += 1;
+    if ((descriptor & 24) !== 0) break;
+    const contentSizeFlag = descriptor >>> 6;
+    const singleSegment = (descriptor & 32) !== 0;
+    const checksum = (descriptor & 4) !== 0;
+    const dictionaryFlag = descriptor & 3;
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+    const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+    if (buffer.length - offset < remainingHeaderBytes) break;
+    offset += remainingHeaderBytes;
+    let complete = true;
+    for (; ; ) {
+      if (buffer.length - offset < 3) {
+        complete = false;
+        break;
+      }
+      const blockHeader = buffer.readUIntLE(offset, 3);
+      offset += 3;
+      const lastBlock = (blockHeader & 1) !== 0;
+      const blockType = blockHeader >>> 1 & 3;
+      const blockSize = blockHeader >>> 3;
+      if (blockType === 3) {
+        complete = false;
+        break;
+      }
+      const payloadBytes = blockType === 1 ? 1 : blockSize;
+      if (buffer.length - offset < payloadBytes) {
+        complete = false;
+        break;
+      }
+      offset += payloadBytes;
+      if (lastBlock) break;
+    }
+    if (!complete) break;
+    if (checksum) {
+      if (buffer.length - offset < 4) break;
+      offset += 4;
+    }
+    frames.push([start, offset]);
+  }
+  return frames;
+}
+function decompressZstdLog(buffer) {
+  if (typeof zlib.zstdDecompressSync !== "function") return null;
+  const chunks = [];
+  for (const [start, end] of scanZstdFrames(buffer)) {
+    try {
+      chunks.push(zlib.zstdDecompressSync(buffer.subarray(start, end)));
+    } catch {
+    }
+  }
+  if (chunks.length === 0) return null;
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function readSessionLog(filePath) {
+  let buffer;
+  try {
+    buffer = readFileSync9(filePath);
+  } catch {
+    return null;
+  }
+  if (filePath.endsWith(".zstd")) {
+    return decompressZstdLog(buffer);
+  }
+  return buffer.toString("utf-8");
+}
+function findSessionLogs(dir) {
+  const results = [];
+  if (!existsSync25(dir)) return results;
+  try {
+    for (const entry of readdirSync14(dir, { withFileTypes: true })) {
+      const fullPath = join27(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findSessionLogs(fullPath));
+      } else if (entry.name === `${LOG_BASENAME}.jsonl` || entry.name === `${LOG_BASENAME}.jsonl.zstd`) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function decodeSegment(segment) {
+  return segment.replace(
+    /~([0-9A-F]{4})/g,
+    (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16))
+  );
+}
+function projectFromDirName(name) {
+  if (name === "_no-cwd") return "unknown";
+  const slug = name.replace(/^-+/, "").replace(/-+$/, "");
+  if (!slug) return "unknown";
+  const parts = slug.split("-").filter(Boolean);
+  const last = parts[parts.length - 1];
+  return last ? decodeSegment(last) || "unknown" : "unknown";
+}
+var DshParser = class {
+  tool;
+  sessionsDirs;
+  constructor(sessionsDir) {
+    this.sessionsDirs = sessionsDir ? [sessionsDir] : getDshSessionsDirs();
+    this.tool = {
+      id: TOOL_ID18,
+      name: TOOL_NAME18,
+      dataDir: this.sessionsDirs[0] ?? DEFAULT_SESSIONS_DIR7
+    };
+  }
+  async parse() {
+    const entries = [];
+    const sessionEvents = [];
+    const seenEntryKeys = /* @__PURE__ */ new Set();
+    for (const sessionsDir of this.sessionsDirs) {
+      for (const filePath of findSessionLogs(sessionsDir)) {
+        const content = readSessionLog(filePath);
+        if (!content) continue;
+        const rows = parseJsonl(content);
+        if (rows.length === 0) continue;
+        const relativeParts = filePath.slice(sessionsDir.length + 1).split(/[\\/]/);
+        const header = rows[0]?.type === "session" ? rows[0] : void 0;
+        const sessionId = (header?.id ?? decodeSegment(relativeParts[1] ?? "")) || "unknown";
+        const project = typeof header?.cwd === "string" && header.cwd ? basename12(header.cwd) || "unknown" : projectFromDirName(relativeParts[0] ?? "");
+        let currentModel = "unknown";
+        for (const row of rows) {
+          if (row.type === "request/context") {
+            const model2 = row.data?.model;
+            if (typeof model2 === "string" && model2) currentModel = model2;
+            continue;
+          }
+          if (row.type === "request/header") {
+            const model2 = row.data?.header?.config?.model;
+            if (typeof model2 === "string" && model2) currentModel = model2;
+            continue;
+          }
+          const timestamp = typeof row.time === "number" && Number.isFinite(row.time) ? new Date(row.time) : null;
+          if (row.type === "user/message") {
+            const sourceKind = row.data?.source?.kind ?? row.data?.message?.source?.kind;
+            if (sourceKind !== "user") continue;
+            if (timestamp) {
+              sessionEvents.push({
+                sessionId,
+                source: TOOL_ID18,
+                project,
+                timestamp,
+                role: "user"
+              });
+            }
+            continue;
+          }
+          const isCompaction = row.type === "compaction/summary";
+          if (row.type !== "assistant/message" && !isCompaction) continue;
+          if (timestamp && !isCompaction) {
+            sessionEvents.push({
+              sessionId,
+              source: TOOL_ID18,
+              project,
+              timestamp,
+              role: "assistant"
+            });
+          }
+          const usage = row.data?.usage;
+          if (!usage || timestamp === null) continue;
+          const model = (isCompaction && typeof row.data?.model === "string" ? row.data.model : "") || currentModel;
+          const inputTokens = toNonNegativeNumber4(usage.inputTokens);
+          const cachedTokens = toNonNegativeNumber4(usage.cacheReadTokens) + toNonNegativeNumber4(usage.cacheWriteTokens);
+          const reasoningTokens = toNonNegativeNumber4(usage.reasoningTokens);
+          const outputTokens = Math.max(
+            0,
+            toNonNegativeNumber4(usage.outputTokens) - reasoningTokens
+          );
+          if (inputTokens + outputTokens + cachedTokens + reasoningTokens === 0)
+            continue;
+          const entryKey = [
+            sessionId,
+            timestamp.toISOString(),
+            model,
+            inputTokens,
+            outputTokens,
+            cachedTokens,
+            reasoningTokens
+          ].join("|");
+          if (seenEntryKeys.has(entryKey)) continue;
+          seenEntryKeys.add(entryKey);
+          entries.push({
+            sessionId,
+            source: TOOL_ID18,
+            model,
+            project,
+            timestamp,
+            inputTokens,
+            outputTokens,
+            reasoningTokens,
+            cachedTokens
+          });
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return this.sessionsDirs.some((dir) => existsSync25(dir));
+  }
+};
+registerParser(new DshParser());
+
 // src/cli.ts
 import { Command, Option } from "commander";
 
 // src/infrastructure/config/manager.ts
 import { randomUUID } from "crypto";
 import {
-  existsSync as existsSync24,
+  existsSync as existsSync26,
   mkdirSync,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   unlinkSync,
   writeFileSync
 } from "fs";
-import { join as join27 } from "path";
+import { join as join29 } from "path";
 
 // src/infrastructure/xdg.ts
-import { homedir as homedir25 } from "os";
-import { join as join26 } from "path";
+import { homedir as homedir27 } from "os";
+import { join as join28 } from "path";
 function getConfigHome() {
-  return process.env.XDG_CONFIG_HOME || join26(homedir25(), ".config");
+  return process.env.XDG_CONFIG_HOME || join28(homedir27(), ".config");
 }
 function getStateHome() {
-  return process.env.XDG_STATE_HOME || join26(homedir25(), ".local", "state");
+  return process.env.XDG_STATE_HOME || join28(homedir27(), ".local", "state");
 }
 function getRuntimeDir() {
   return process.env.XDG_RUNTIME_DIR || getStateHome();
 }
 
 // src/infrastructure/config/manager.ts
-var CONFIG_DIR = join27(getConfigHome(), "tokenarena");
+var CONFIG_DIR = join29(getConfigHome(), "tokenarena");
 var isDev = process.env.TOKEN_ARENA_DEV === "1";
-var CONFIG_FILE = join27(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
+var CONFIG_FILE = join29(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
 var DEFAULT_API_URL = "https://token.guji.uno";
 var VALID_CONFIG_KEYS = [
   "apiKey",
@@ -4759,9 +5147,9 @@ function getConfigDir() {
   return CONFIG_DIR;
 }
 function loadConfig() {
-  if (!existsSync24(CONFIG_FILE)) return null;
+  if (!existsSync26(CONFIG_FILE)) return null;
   try {
-    const raw = readFileSync9(CONFIG_FILE, "utf-8");
+    const raw = readFileSync10(CONFIG_FILE, "utf-8");
     const config = JSON.parse(raw);
     if (!config.apiUrl) {
       config.apiUrl = DEFAULT_API_URL;
@@ -4777,7 +5165,7 @@ function saveConfig(config) {
 `, "utf-8");
 }
 function deleteConfig() {
-  if (existsSync24(CONFIG_FILE)) {
+  if (existsSync26(CONFIG_FILE)) {
     unlinkSync(CONFIG_FILE);
   }
 }
@@ -5639,31 +6027,31 @@ var ApiClient = class {
 // src/infrastructure/runtime/lock.ts
 import {
   closeSync,
-  existsSync as existsSync25,
+  existsSync as existsSync27,
   openSync,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   rmSync as rmSync3,
   writeFileSync as writeFileSync2
 } from "fs";
 
 // src/infrastructure/runtime/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 var APP_NAME = "tokenarena";
 function getRuntimeDirPath() {
-  return join28(getRuntimeDir(), APP_NAME);
+  return join30(getRuntimeDir(), APP_NAME);
 }
 function getStateDir() {
-  return join28(getStateHome(), APP_NAME);
+  return join30(getStateHome(), APP_NAME);
 }
 function getSyncLockPath() {
-  return join28(getRuntimeDirPath(), "sync.lock");
+  return join30(getRuntimeDirPath(), "sync.lock");
 }
 function getSyncStatePath() {
-  return join28(getStateDir(), "status.json");
+  return join30(getStateDir(), "status.json");
 }
 function getUploadManifestPath() {
-  return join28(getStateDir(), "upload-manifest.json");
+  return join30(getStateDir(), "upload-manifest.json");
 }
 function ensureAppDirs() {
   mkdirSync2(getRuntimeDirPath(), { recursive: true });
@@ -5681,11 +6069,11 @@ function isProcessAlive(pid) {
   }
 }
 function readLockMetadata(lockPath) {
-  if (!existsSync25(lockPath)) {
+  if (!existsSync27(lockPath)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync10(lockPath, "utf-8"));
+    return JSON.parse(readFileSync11(lockPath, "utf-8"));
   } catch {
     return null;
   }
@@ -5755,19 +6143,19 @@ function describeExistingSyncLock() {
 }
 
 // src/infrastructure/runtime/state.ts
-import { existsSync as existsSync26, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "fs";
 function getDefaultState() {
   return { status: "idle" };
 }
 function loadSyncState() {
   const path = getSyncStatePath();
-  if (!existsSync26(path)) {
+  if (!existsSync28(path)) {
     return getDefaultState();
   }
   try {
     return {
       ...getDefaultState(),
-      ...JSON.parse(readFileSync11(path, "utf-8"))
+      ...JSON.parse(readFileSync12(path, "utf-8"))
     };
   } catch {
     return getDefaultState();
@@ -5822,7 +6210,7 @@ function markSyncFailed(source, error, status) {
 }
 
 // src/infrastructure/runtime/upload-manifest.ts
-import { existsSync as existsSync27, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
 function isRecordOfStrings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -5838,11 +6226,11 @@ function isUploadManifest(value) {
 }
 function loadUploadManifest() {
   const path = getUploadManifestPath();
-  if (!existsSync27(path)) {
+  if (!existsSync29(path)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync12(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf-8"));
     if (!isUploadManifest(parsed)) {
       return null;
     }
@@ -6378,18 +6766,18 @@ View your dashboard at: ${apiUrl}/usage`);
 
 // src/commands/init.ts
 import { execFileSync as execFileSync7, spawn } from "child_process";
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { appendFile, mkdir, readFile } from "fs/promises";
-import { homedir as homedir28, platform as platform5 } from "os";
-import { dirname as dirname6, join as join29, posix as posix3, win32 } from "path";
+import { homedir as homedir30, platform as platform5 } from "os";
+import { dirname as dirname6, join as join31, 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 existsSync28, mkdirSync as mkdirSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir26, platform as platform2 } from "os";
+import { existsSync as existsSync30, mkdirSync as mkdirSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir28, platform as platform2 } from "os";
 import { posix } from "path";
 
 // src/utils/command.ts
@@ -6458,10 +6846,10 @@ function escapeXml(value) {
 
 // src/infrastructure/service/linux-systemd.ts
 var SYSTEMD_SERVICE_NAME = "tokenarena";
-function getLinuxSystemdServiceDir(homePath = homedir26()) {
+function getLinuxSystemdServiceDir(homePath = homedir28()) {
   return posix.join(homePath, ".config", "systemd", "user");
 }
-function getLinuxSystemdServiceFile(homePath = homedir26()) {
+function getLinuxSystemdServiceFile(homePath = homedir28()) {
   return posix.join(
     getLinuxSystemdServiceDir(homePath),
     `${SYSTEMD_SERVICE_NAME}.service`
@@ -6518,7 +6906,7 @@ function ensureSystemdAvailable() {
 }
 function createLinuxSystemdServiceBackend() {
   function isInstalled() {
-    return existsSync28(getLinuxSystemdServiceFile());
+    return existsSync30(getLinuxSystemdServiceFile());
   }
   async function setup(skipPrompt = false) {
     if (!ensureSystemdAvailable()) {
@@ -6643,7 +7031,7 @@ function createLinuxSystemdServiceBackend() {
   }
   async function uninstall(skipPrompt = false) {
     const serviceFile = getLinuxSystemdServiceFile();
-    if (!existsSync28(serviceFile)) {
+    if (!existsSync30(serviceFile)) {
       logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
       return;
     }
@@ -6704,17 +7092,17 @@ function createLinuxSystemdServiceBackend() {
 
 // src/infrastructure/service/macos-launchd.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir27, platform as platform3 } from "os";
+import { existsSync as existsSync31, mkdirSync as mkdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir29, 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 = homedir27()) {
+function getMacosLaunchAgentDir(homePath = homedir29()) {
   return posix2.join(homePath, "Library", "LaunchAgents");
 }
-function getMacosLaunchAgentFile(homePath = homedir27()) {
+function getMacosLaunchAgentFile(homePath = homedir29()) {
   return posix2.join(
     getMacosLaunchAgentDir(homePath),
     `${MACOS_LAUNCHD_LABEL}.plist`
@@ -6841,7 +7229,7 @@ function writeLaunchAgentPlist() {
     label: MACOS_LAUNCHD_LABEL,
     programArguments: [command.execPath, ...command.args],
     environment: getManagedServiceEnvironment(),
-    workingDirectory: homedir27(),
+    workingDirectory: homedir29(),
     standardOutPath: stdoutPath,
     standardErrorPath: stderrPath
   });
@@ -6866,7 +7254,7 @@ function bootstrapLaunchAgent() {
 }
 function createMacosLaunchdServiceBackend() {
   function isInstalled() {
-    return existsSync29(getMacosLaunchAgentFile());
+    return existsSync31(getMacosLaunchAgentFile());
   }
   async function setup(skipPrompt = false) {
     if (!ensureLaunchctlAvailable()) {
@@ -7007,7 +7395,7 @@ function createMacosLaunchdServiceBackend() {
   }
   async function uninstall(skipPrompt = false) {
     const plistFile = getMacosLaunchAgentFile();
-    if (!existsSync29(plistFile)) {
+    if (!existsSync31(plistFile)) {
       logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
       return;
     }
@@ -7118,7 +7506,7 @@ function resolvePowerShellProfilePath() {
   const systemRoot = process.env.SYSTEMROOT || "C:\\Windows";
   const candidates = [
     "pwsh.exe",
-    join29(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    join31(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   ];
   for (const command of candidates) {
     try {
@@ -7147,8 +7535,8 @@ function resolvePowerShellProfilePath() {
 function resolveShellAliasSetup(options = {}) {
   const currentPlatform = options.currentPlatform ?? platform5();
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir28();
-  const pathExists = options.exists ?? existsSync30;
+  const homeDir = options.homeDir ?? homedir30();
+  const pathExists = options.exists ?? existsSync32;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
   const aliasName = "ta";
@@ -7345,7 +7733,7 @@ async function setupShellAlias() {
   try {
     await mkdir(dirname6(setup.configFile), { recursive: true });
     let existingContent = "";
-    if (existsSync30(setup.configFile)) {
+    if (existsSync32(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
     }
     const normalizedContent = existingContent.toLowerCase();
@@ -7603,8 +7991,8 @@ function buildLocalUsageDashboardData(input2) {
 }
 
 // src/infrastructure/runtime/cli-version.ts
-import { readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname7, join as join30 } from "path";
+import { readFileSync as readFileSync14 } from "fs";
+import { dirname as dirname7, join as join32 } from "path";
 import { fileURLToPath } from "url";
 var FALLBACK_VERSION = "0.0.0";
 var cachedVersion;
@@ -7612,13 +8000,13 @@ function getCliVersion(metaUrl = import.meta.url) {
   if (cachedVersion) {
     return cachedVersion;
   }
-  const packageJsonPath = join30(
+  const packageJsonPath = join32(
     dirname7(fileURLToPath(metaUrl)),
     "..",
     "package.json"
   );
   try {
-    const packageJson = JSON.parse(readFileSync13(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync14(packageJsonPath, "utf-8"));
     cachedVersion = typeof packageJson.version === "string" ? packageJson.version : FALLBACK_VERSION;
   } catch {
     cachedVersion = FALLBACK_VERSION;
@@ -8023,8 +8411,8 @@ async function runSyncCommand(opts = {}) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync31, readFileSync as readFileSync14, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir29, platform as platform6 } from "os";
+import { existsSync as existsSync33, readFileSync as readFileSync15, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir31, platform as platform6 } from "os";
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -8033,24 +8421,24 @@ function removeShellAlias() {
   let configFile;
   switch (shellName) {
     case "zsh":
-      configFile = `${homedir29()}/.zshrc`;
+      configFile = `${homedir31()}/.zshrc`;
       break;
     case "bash":
-      if (platform6() === "darwin" && existsSync31(`${homedir29()}/.bash_profile`)) {
-        configFile = `${homedir29()}/.bash_profile`;
+      if (platform6() === "darwin" && existsSync33(`${homedir31()}/.bash_profile`)) {
+        configFile = `${homedir31()}/.bash_profile`;
       } else {
-        configFile = `${homedir29()}/.bashrc`;
+        configFile = `${homedir31()}/.bashrc`;
       }
       break;
     case "fish":
-      configFile = `${homedir29()}/.config/fish/config.fish`;
+      configFile = `${homedir31()}/.config/fish/config.fish`;
       break;
     default:
       return;
   }
-  if (!existsSync31(configFile)) return;
+  if (!existsSync33(configFile)) return;
   try {
-    let content = readFileSync14(configFile, "utf-8");
+    let content = readFileSync15(configFile, "utf-8");
     const aliasPatterns = [
       // zsh / bash format: alias ta="tokenarena"
       new RegExp(
@@ -8087,7 +8475,7 @@ async function runUninstall() {
   const runtimeDir = getRuntimeDirPath();
   const serviceBackend = getServiceBackend();
   const hasInstalledService = serviceBackend?.isInstalled() ?? false;
-  const hasLocalArtifacts = existsSync31(configPath) || existsSync31(configDir) || existsSync31(stateDir) || existsSync31(runtimeDir) || hasInstalledService;
+  const hasLocalArtifacts = existsSync33(configPath) || existsSync33(configDir) || existsSync33(stateDir) || existsSync33(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"));
@@ -8131,22 +8519,22 @@ async function runUninstall() {
     }
   }
   logger.info(formatSection("\u6267\u884C\u7ED3\u679C"));
-  if (existsSync31(configPath)) {
+  if (existsSync33(configPath)) {
     deleteConfig();
     logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
   }
-  if (existsSync31(configDir)) {
+  if (existsSync33(configDir)) {
     try {
       rmSync6(configDir, { recursive: false, force: true });
       logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u76EE\u5F55\u3002", "success"));
     } catch {
     }
   }
-  if (existsSync31(stateDir)) {
+  if (existsSync33(stateDir)) {
     rmSync6(stateDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u72B6\u6001\u6570\u636E\u3002", "success"));
   }
-  if (existsSync31(runtimeDir)) {
+  if (existsSync33(runtimeDir)) {
     rmSync6(runtimeDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u8FD0\u884C\u65F6\u6570\u636E\u3002", "success"));
   }
@@ -8377,7 +8765,7 @@ function createCli() {
 }
 
 // src/infrastructure/runtime/main-module.ts
-import { existsSync as existsSync32, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync34, 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) {
@@ -8388,7 +8776,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
   try {
     return realpathSync2(argvEntry) === realpathSync2(currentModulePath);
   } catch {
-    if (!existsSync32(argvEntry)) {
+    if (!existsSync34(argvEntry)) {
       return false;
     }
     return resolve3(argvEntry) === resolve3(currentModulePath);