@poco-ai/tokenarena 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,4 +1,21 @@
 #!/usr/bin/env node
+import {
+  formatBullet,
+  formatHeader,
+  formatKeyValue,
+  formatMutedPath,
+  formatSection,
+  formatStatusBadge,
+  isCommandAvailable,
+  isInteractiveTerminal,
+  logger,
+  maskSecret,
+  promptConfirm,
+  promptPassword,
+  promptSelect,
+  promptText,
+  runInstallService
+} from "./chunk-XJKRJ3K2.js";
 
 // src/parsers/claude-code.ts
 import { existsSync as existsSync3 } from "fs";
@@ -211,6 +228,17 @@ function readFileSafe(filePath) {
     return null;
   }
 }
+function parseJsonl(content) {
+  const results = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      results.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return results;
+}
 function extractSessionId(filePath) {
   return basename(filePath, ".jsonl");
 }
@@ -1098,37 +1126,657 @@ var OpenClawParser = class {
 };
 registerParser(new OpenClawParser());
 
+// src/parsers/qwen-code.ts
+import { existsSync as existsSync8, readdirSync as readdirSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
+var TOOL_ID = "qwen-code";
+var TOOL_NAME = "Qwen Code";
+var DEFAULT_DATA_DIR2 = join8(homedir7(), ".qwen", "tmp");
+function createToolDefinition(dataDir) {
+  return {
+    id: TOOL_ID,
+    name: TOOL_NAME,
+    dataDir
+  };
+}
+function toSafeNumber(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function getPathLeaf2(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const leaf = normalized.split("/").filter(Boolean).pop();
+  return leaf || "unknown";
+}
+function normalizeForPrefix(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function findSessionFiles2(baseDir) {
+  const results = [];
+  if (!existsSync8(baseDir)) return results;
+  try {
+    for (const entry of readdirSync6(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const chatsDir = join8(baseDir, entry.name, "chats");
+      if (!existsSync8(chatsDir)) continue;
+      try {
+        for (const file of readdirSync6(chatsDir)) {
+          if (file.endsWith(".jsonl")) {
+            results.push(join8(chatsDir, file));
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+function resolveQwenProject(cwd, filePath, dataDir = DEFAULT_DATA_DIR2) {
+  if (cwd) {
+    return getPathLeaf2(cwd);
+  }
+  const normalizedFilePath = normalizeForPrefix(filePath);
+  const normalizedDataDir = normalizeForPrefix(dataDir);
+  const prefix = `${normalizedDataDir}/`;
+  if (!normalizedFilePath.startsWith(prefix)) {
+    return "unknown";
+  }
+  const relativePath = normalizedFilePath.slice(prefix.length);
+  const projectId = relativePath.split("/")[0];
+  return projectId || "unknown";
+}
+var QwenCodeParser = class {
+  constructor(dataDir = DEFAULT_DATA_DIR2) {
+    this.dataDir = dataDir;
+    this.tool = createToolDefinition(dataDir);
+  }
+  tool;
+  async parse() {
+    const sessionFiles = findSessionFiles2(this.dataDir);
+    if (sessionFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    const seenUuids = /* @__PURE__ */ new Set();
+    for (const filePath of sessionFiles) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      const sessionId = filePath;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (!obj.timestamp) continue;
+          const timestamp = new Date(obj.timestamp);
+          if (Number.isNaN(timestamp.getTime())) continue;
+          const project = resolveQwenProject(obj.cwd, filePath, this.dataDir);
+          if (obj.type === "user" || obj.type === "assistant") {
+            sessionEvents.push({
+              sessionId,
+              source: TOOL_ID,
+              project,
+              timestamp,
+              role: obj.type
+            });
+          }
+          if (obj.type !== "assistant") continue;
+          const usage = obj.usageMetadata || obj.usage;
+          if (!usage) continue;
+          const totalInput = toSafeNumber(usage.promptTokenCount) || toSafeNumber(usage.input_tokens);
+          const totalOutput = toSafeNumber(usage.candidatesTokenCount) || toSafeNumber(usage.output_tokens);
+          const cachedTokens = toSafeNumber(usage.cachedContentTokenCount);
+          const reasoningTokens = toSafeNumber(usage.thoughtsTokenCount);
+          if (totalInput === 0 && totalOutput === 0 && cachedTokens === 0 && reasoningTokens === 0) {
+            continue;
+          }
+          if (obj.uuid) {
+            if (seenUuids.has(obj.uuid)) continue;
+            seenUuids.add(obj.uuid);
+          }
+          entries.push({
+            sessionId,
+            source: TOOL_ID,
+            model: obj.model || "unknown",
+            project,
+            timestamp,
+            inputTokens: Math.max(0, totalInput - cachedTokens),
+            outputTokens: Math.max(0, totalOutput - reasoningTokens),
+            reasoningTokens,
+            cachedTokens
+          });
+        } catch {
+        }
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync8(this.dataDir);
+  }
+};
+registerParser(new QwenCodeParser());
+
+// src/parsers/kimi-code.ts
+import { existsSync as existsSync9, readdirSync as readdirSync7 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join9 } from "path";
+var TOOL_ID2 = "kimi-code";
+var TOOL_NAME2 = "Kimi Code";
+var DEFAULT_SESSIONS_DIR = join9(homedir8(), ".kimi", "sessions");
+var DEFAULT_CONFIG_PATH = join9(homedir8(), ".kimi", "kimi.json");
+var USER_EVENT_TYPES = /* @__PURE__ */ new Set(["UserMessage", "user_message", "Input"]);
+var ASSISTANT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "AssistantMessage",
+  "assistant_message",
+  "Output",
+  "ModelOutput",
+  "AssistantOutput"
+]);
+function createToolDefinition2(dataDir) {
+  return {
+    id: TOOL_ID2,
+    name: TOOL_NAME2,
+    dataDir
+  };
+}
+function toSafeNumber2(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function getPathLeaf3(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const leaf = normalized.split("/").filter(Boolean).pop();
+  return leaf || "unknown";
+}
+function findWireFiles(baseDir) {
+  const results = [];
+  if (!existsSync9(baseDir)) return results;
+  try {
+    for (const workDir of readdirSync7(baseDir, { withFileTypes: true })) {
+      if (!workDir.isDirectory()) continue;
+      const workDirPath = join9(baseDir, workDir.name);
+      try {
+        for (const session of readdirSync7(workDirPath, {
+          withFileTypes: true
+        })) {
+          if (!session.isDirectory()) continue;
+          const wireFile = join9(workDirPath, session.name, "wire.jsonl");
+          if (existsSync9(wireFile)) {
+            results.push({ filePath: wireFile, workDirHash: workDir.name });
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+function parseTimestamp(value) {
+  if (value == null) return null;
+  const timestamp = new Date(value);
+  return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+}
+function classifyKimiRole(type, payload) {
+  if (payload?.role === "user" || payload?.role === "assistant") {
+    return payload.role;
+  }
+  if (type && USER_EVENT_TYPES.has(type)) {
+    return "user";
+  }
+  if (type && ASSISTANT_EVENT_TYPES.has(type)) {
+    return "assistant";
+  }
+  if (type?.toLowerCase().includes("assistant")) {
+    return "assistant";
+  }
+  return null;
+}
+function loadProjectMap(configPath) {
+  const projectMap = /* @__PURE__ */ new Map();
+  const content = readFileSafe(configPath);
+  if (!content) return projectMap;
+  try {
+    const config = JSON.parse(content);
+    const workspaces = config.workspaces || config.projects || {};
+    for (const [hash, info] of Object.entries(workspaces)) {
+      const pathValue = typeof info === "string" ? info : info.path || info.dir || void 0;
+      if (!pathValue) continue;
+      projectMap.set(hash, getPathLeaf3(pathValue));
+    }
+  } catch {
+  }
+  return projectMap;
+}
+var KimiCodeParser = class {
+  tool;
+  sessionsDir;
+  configPath;
+  constructor(options = {}) {
+    this.sessionsDir = options.sessionsDir || DEFAULT_SESSIONS_DIR;
+    this.configPath = options.configPath || DEFAULT_CONFIG_PATH;
+    this.tool = createToolDefinition2(this.sessionsDir);
+  }
+  async parse() {
+    const wireFiles = findWireFiles(this.sessionsDir);
+    if (wireFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const projectMap = loadProjectMap(this.configPath);
+    const entries = [];
+    const sessionEvents = [];
+    const seenMessageIds = /* @__PURE__ */ new Set();
+    for (const { filePath, workDirHash } of wireFiles) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      const sessionId = filePath;
+      const project = projectMap.get(workDirHash) || workDirHash;
+      let currentModel = "unknown";
+      let lastTimestampRaw;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const payload = obj.payload;
+        if (!payload) continue;
+        if (payload.model) {
+          currentModel = payload.model;
+        }
+        const timestampValue = payload.timestamp ?? obj.timestamp ?? lastTimestampRaw;
+        const timestamp = parseTimestamp(timestampValue);
+        if (payload.timestamp != null) {
+          lastTimestampRaw = payload.timestamp;
+        } else if (obj.timestamp != null) {
+          lastTimestampRaw = obj.timestamp;
+        }
+        const role = classifyKimiRole(obj.type, payload);
+        if (role && timestamp) {
+          sessionEvents.push({
+            sessionId,
+            source: TOOL_ID2,
+            project,
+            timestamp,
+            role
+          });
+        }
+        if (obj.type !== "StatusUpdate") continue;
+        const tokenUsage = payload.token_usage;
+        if (!tokenUsage || !timestamp) continue;
+        const inputTokens = toSafeNumber2(tokenUsage.input_other);
+        const outputTokens = toSafeNumber2(tokenUsage.output);
+        const cachedTokens = toSafeNumber2(tokenUsage.input_cache_read);
+        const cacheCreateTokens = toSafeNumber2(tokenUsage.input_cache_creation);
+        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && cacheCreateTokens === 0) {
+          continue;
+        }
+        if (payload.message_id) {
+          if (seenMessageIds.has(payload.message_id)) continue;
+          seenMessageIds.add(payload.message_id);
+        }
+        if (!role) {
+          sessionEvents.push({
+            sessionId,
+            source: TOOL_ID2,
+            project,
+            timestamp,
+            role: "assistant"
+          });
+        }
+        entries.push({
+          sessionId,
+          source: TOOL_ID2,
+          model: currentModel,
+          project,
+          timestamp,
+          inputTokens,
+          outputTokens,
+          reasoningTokens: 0,
+          cachedTokens
+        });
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync9(this.sessionsDir);
+  }
+};
+registerParser(new KimiCodeParser());
+
+// src/parsers/droid.ts
+import { existsSync as existsSync10, readdirSync as readdirSync8 } from "fs";
+import { homedir as homedir9 } from "os";
+import { basename as basename4, dirname as dirname2, join as join10 } from "path";
+var TOOL_ID3 = "droid";
+var TOOL_NAME3 = "Droid";
+var DEFAULT_DATA_DIR3 = join10(homedir9(), ".factory", "sessions");
+function createToolDefinition3(dataDir) {
+  return {
+    id: TOOL_ID3,
+    name: TOOL_NAME3,
+    dataDir
+  };
+}
+function findSessionFiles3(dir) {
+  const results = [];
+  if (!existsSync10(dir)) return results;
+  try {
+    for (const entry of readdirSync8(dir, { withFileTypes: true })) {
+      const fullPath = join10(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findSessionFiles3(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl") && !entry.name.endsWith(".settings.json")) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function extractDroidProject(slug) {
+  const parts = slug.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : "unknown";
+}
+function toSafeNumber3(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+var DroidParser = class {
+  constructor(dataDir = DEFAULT_DATA_DIR3) {
+    this.dataDir = dataDir;
+    this.tool = createToolDefinition3(dataDir);
+  }
+  tool;
+  async parse() {
+    const sessionFiles = findSessionFiles3(this.dataDir);
+    if (sessionFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    for (const filePath of sessionFiles) {
+      const sessionId = filePath;
+      const project = extractDroidProject(basename4(dirname2(filePath)));
+      let firstMessageTimestamp = null;
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      for (const line of content.split("\n")) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (obj.type !== "message" || !obj.timestamp) continue;
+        const timestamp = new Date(obj.timestamp);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        const role = obj.message?.role;
+        if (role !== "user" && role !== "assistant") continue;
+        if (firstMessageTimestamp === null) {
+          firstMessageTimestamp = timestamp;
+        }
+        sessionEvents.push({
+          sessionId,
+          source: TOOL_ID3,
+          project,
+          timestamp,
+          role
+        });
+      }
+      const settingsPath = join10(
+        dirname2(filePath),
+        `${basename4(filePath, ".jsonl")}.settings.json`
+      );
+      const settingsContent = readFileSafe(settingsPath);
+      if (!settingsContent || firstMessageTimestamp === null) continue;
+      let settings;
+      try {
+        settings = JSON.parse(settingsContent);
+      } catch {
+        continue;
+      }
+      const tokenUsage = settings.tokenUsage;
+      if (!tokenUsage) continue;
+      const cachedTokens = toSafeNumber3(tokenUsage.cacheReadTokens);
+      const reasoningTokens = toSafeNumber3(tokenUsage.thinkingTokens);
+      const inputTokens = Math.max(
+        0,
+        toSafeNumber3(tokenUsage.inputTokens) - cachedTokens
+      );
+      const outputTokens = Math.max(
+        0,
+        toSafeNumber3(tokenUsage.outputTokens) - reasoningTokens
+      );
+      if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && reasoningTokens === 0) {
+        continue;
+      }
+      entries.push({
+        sessionId,
+        source: TOOL_ID3,
+        model: settings.model || "unknown",
+        project,
+        timestamp: firstMessageTimestamp,
+        inputTokens,
+        outputTokens,
+        reasoningTokens,
+        cachedTokens
+      });
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync10(this.dataDir);
+  }
+};
+registerParser(new DroidParser());
+
+// src/parsers/pi-coding-agent.ts
+import { existsSync as existsSync11 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join11 } from "path";
+var TOOL_ID4 = "pi-coding-agent";
+var TOOL_NAME4 = "pi";
+var DEFAULT_SESSIONS_DIR2 = join11(homedir10(), ".pi", "agent", "sessions");
+function createToolDefinition4(dataDir) {
+  return {
+    id: TOOL_ID4,
+    name: TOOL_NAME4,
+    dataDir
+  };
+}
+function toSafeNumber4(value) {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+function getPathLeaf4(value) {
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const leaf = normalized.split("/").filter(Boolean).pop();
+  return leaf || "unknown";
+}
+function normalizeForPrefix2(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function getUsageNumber(usage, ...keys) {
+  for (const key of keys) {
+    const value = usage[key];
+    const numberValue = toSafeNumber4(value);
+    if (numberValue > 0) {
+      return numberValue;
+    }
+  }
+  return 0;
+}
+function extractPiProjectFromCwd(cwd) {
+  return getPathLeaf4(cwd);
+}
+function extractPiProjectFromDir(filePath, sessionsDir = DEFAULT_SESSIONS_DIR2) {
+  const normalizedFilePath = normalizeForPrefix2(filePath);
+  const normalizedSessionsDir = normalizeForPrefix2(sessionsDir);
+  const prefix = `${normalizedSessionsDir}/`;
+  if (!normalizedFilePath.startsWith(prefix)) {
+    return "unknown";
+  }
+  const relativePath = normalizedFilePath.slice(prefix.length);
+  const firstSegment = relativePath.split("/")[0];
+  if (!firstSegment) {
+    return "unknown";
+  }
+  try {
+    const decoded = decodeURIComponent(firstSegment);
+    if (decoded.includes("/") || decoded.includes("\\")) {
+      return getPathLeaf4(decoded);
+    }
+  } catch {
+  }
+  const slugParts = firstSegment.split("-").filter(Boolean);
+  return slugParts.length > 0 ? slugParts[slugParts.length - 1] : "unknown";
+}
+var PiCodingAgentParser = class {
+  constructor(sessionsDir = DEFAULT_SESSIONS_DIR2) {
+    this.sessionsDir = sessionsDir;
+    this.tool = createToolDefinition4(sessionsDir);
+  }
+  tool;
+  async parse() {
+    const sessionFiles = findJsonlFiles(this.sessionsDir);
+    if (sessionFiles.length === 0) {
+      return { buckets: [], sessions: [] };
+    }
+    const entries = [];
+    const sessionEvents = [];
+    const seenEntryIds = /* @__PURE__ */ new Set();
+    for (const filePath of sessionFiles) {
+      const content = readFileSafe(filePath);
+      if (!content) continue;
+      const rows = parseJsonl(content);
+      if (rows.length === 0) continue;
+      let sessionId = filePath;
+      let project = extractPiProjectFromDir(filePath, this.sessionsDir);
+      for (const row of rows) {
+        if (row.type !== "session") continue;
+        if (row.id) {
+          sessionId = row.id;
+        }
+        if (row.cwd) {
+          project = extractPiProjectFromCwd(row.cwd);
+        }
+        break;
+      }
+      for (const row of rows) {
+        if (row.type !== "message") continue;
+        const message = row.message;
+        if (!message) continue;
+        const rawTimestamp = row.timestamp || message.timestamp;
+        if (!rawTimestamp) continue;
+        const timestamp = new Date(rawTimestamp);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        if (message.role === "user" || message.role === "assistant") {
+          sessionEvents.push({
+            sessionId,
+            source: TOOL_ID4,
+            project,
+            timestamp,
+            role: message.role
+          });
+        }
+        if (message.role !== "assistant") continue;
+        const usage = message.usage;
+        if (!usage) continue;
+        const inputTokens = getUsageNumber(usage, "input", "inputTokens");
+        const outputTokens = getUsageNumber(usage, "output", "outputTokens");
+        const cachedTokens = getUsageNumber(
+          usage,
+          "cacheRead",
+          "cacheReadTokens",
+          "cache_read"
+        );
+        const reasoningTokens = getUsageNumber(
+          usage,
+          "reasoningOutputTokens",
+          "thinkingTokens",
+          "thoughts"
+        );
+        if (inputTokens === 0 && outputTokens === 0 && cachedTokens === 0 && reasoningTokens === 0) {
+          continue;
+        }
+        if (row.id) {
+          if (seenEntryIds.has(row.id)) continue;
+          seenEntryIds.add(row.id);
+        }
+        entries.push({
+          sessionId,
+          source: TOOL_ID4,
+          model: message.model || "unknown",
+          project,
+          timestamp,
+          inputTokens,
+          outputTokens,
+          reasoningTokens,
+          cachedTokens
+        });
+      }
+    }
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: extractSessions(sessionEvents, entries)
+    };
+  }
+  isInstalled() {
+    return existsSync11(this.sessionsDir);
+  }
+};
+registerParser(new PiCodingAgentParser());
+
 // src/cli.ts
 import { Command, Option } from "commander";
 
 // src/infrastructure/config/manager.ts
 import { randomUUID } from "crypto";
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync12,
   mkdirSync,
   readFileSync as readFileSync6,
   unlinkSync,
   writeFileSync
 } from "fs";
-import { join as join9 } from "path";
+import { join as join13 } from "path";
 
 // src/infrastructure/xdg.ts
-import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join12 } from "path";
 function getConfigHome() {
-  return process.env.XDG_CONFIG_HOME || join8(homedir7(), ".config");
+  return process.env.XDG_CONFIG_HOME || join12(homedir11(), ".config");
 }
 function getStateHome() {
-  return process.env.XDG_STATE_HOME || join8(homedir7(), ".local", "state");
+  return process.env.XDG_STATE_HOME || join12(homedir11(), ".local", "state");
 }
 function getRuntimeDir() {
   return process.env.XDG_RUNTIME_DIR || getStateHome();
 }
 
 // src/infrastructure/config/manager.ts
-var CONFIG_DIR = join9(getConfigHome(), "tokenarena");
+var CONFIG_DIR = join13(getConfigHome(), "tokenarena");
 var isDev = process.env.TOKEN_ARENA_DEV === "1";
-var CONFIG_FILE = join9(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
+var CONFIG_FILE = join13(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
 var DEFAULT_API_URL = "https://token.poco-ai.com";
 var VALID_CONFIG_KEYS = [
   "apiKey",
@@ -1144,7 +1792,7 @@ function getConfigDir() {
   return CONFIG_DIR;
 }
 function loadConfig() {
-  if (!existsSync8(CONFIG_FILE)) return null;
+  if (!existsSync12(CONFIG_FILE)) return null;
   try {
     const raw = readFileSync6(CONFIG_FILE, "utf-8");
     const config = JSON.parse(raw);
@@ -1162,7 +1810,7 @@ function saveConfig(config) {
 `, "utf-8");
 }
 function deleteConfig() {
-  if (existsSync8(CONFIG_FILE)) {
+  if (existsSync12(CONFIG_FILE)) {
     unlinkSync(CONFIG_FILE);
   }
 }
@@ -1182,150 +1830,6 @@ function getDefaultApiUrl() {
   return process.env.TOKEN_ARENA_API_URL || DEFAULT_API_URL;
 }
 
-// src/infrastructure/ui/format.ts
-var hasColor = Boolean(process.stdout.isTTY && process.env.NO_COLOR !== "1");
-function withCode(code, value) {
-  if (!hasColor) return value;
-  return `\x1B[${code}m${value}\x1B[0m`;
-}
-function bold(value) {
-  return withCode("1", value);
-}
-function dim(value) {
-  return withCode("2", value);
-}
-function cyan(value) {
-  return withCode("36", value);
-}
-function green(value) {
-  return withCode("32", value);
-}
-function yellow(value) {
-  return withCode("33", value);
-}
-function red(value) {
-  return withCode("31", value);
-}
-function magenta(value) {
-  return withCode("35", value);
-}
-function formatHeader(title, subtitle) {
-  const lines = [`${cyan("\u25C8")} ${bold(title)}`];
-  if (subtitle) {
-    lines.push(dim(subtitle));
-  }
-  return `
-${lines.join("\n")}`;
-}
-function formatSection(title) {
-  return `
-${bold(title)}`;
-}
-function formatKeyValue(label, value) {
-  return `  ${dim(label.padEnd(14, " "))} ${value}`;
-}
-function formatBullet(value, tone = "neutral") {
-  const icon = tone === "success" ? green("\u2714") : tone === "warning" ? yellow("!") : tone === "danger" ? red("\u2716") : cyan("\u2022");
-  return `  ${icon} ${value}`;
-}
-function formatMutedPath(path) {
-  return dim(path);
-}
-function maskSecret(value, visible = 8) {
-  if (!value) return "(empty)";
-  if (value.length <= visible) return value;
-  return `${value.slice(0, visible)}\u2026`;
-}
-function formatStatusBadge(label, tone = "neutral") {
-  if (tone === "success") return green(label);
-  if (tone === "warning") return yellow(label);
-  if (tone === "danger") return red(label);
-  return magenta(label);
-}
-
-// src/infrastructure/ui/prompts.ts
-import {
-  confirm,
-  input,
-  password,
-  select
-} from "@inquirer/prompts";
-function isInteractiveTerminal() {
-  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-}
-async function promptConfirm(options) {
-  return confirm({
-    message: options.message,
-    default: options.defaultValue
-  });
-}
-async function promptText(options) {
-  return input({
-    message: options.message,
-    default: options.defaultValue,
-    validate: options.validate
-  });
-}
-async function promptPassword(options) {
-  return password({
-    message: options.message,
-    mask: options.mask ?? "*",
-    validate: options.validate
-  });
-}
-async function promptSelect(options) {
-  return select({
-    message: options.message,
-    choices: [...options.choices],
-    pageSize: Math.min(Math.max(options.choices.length, 6), 10)
-  });
-}
-
-// 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 isConfigKey(value) {
@@ -1631,14 +2135,14 @@ import { hostname as hostname3 } from "os";
 
 // src/domain/project-identity.ts
 import { createHmac } from "crypto";
-function toProjectIdentity(input2) {
-  if (input2.mode === "disabled") {
+function toProjectIdentity(input) {
+  if (input.mode === "disabled") {
     return { projectKey: "unknown", projectLabel: "Unknown Project" };
   }
-  if (input2.mode === "raw") {
-    return { projectKey: input2.project, projectLabel: input2.project };
+  if (input.mode === "raw") {
+    return { projectKey: input.project, projectLabel: input.project };
   }
-  const projectKey = createHmac("sha256", input2.salt).update(input2.project).digest("hex").slice(0, 16);
+  const projectKey = createHmac("sha256", input.salt).update(input.project).digest("hex").slice(0, 16);
   return {
     projectKey,
     projectLabel: `Project ${projectKey.slice(0, 6)}`
@@ -1654,13 +2158,13 @@ function shortHash(value) {
 function normalizeApiUrl(apiUrl) {
   return apiUrl.replace(/\/+$/, "");
 }
-function buildUploadManifestScope(input2) {
+function buildUploadManifestScope(input) {
   return {
-    apiKeyHash: shortHash(input2.apiKey),
-    apiUrl: normalizeApiUrl(input2.apiUrl),
-    deviceId: input2.deviceId,
-    projectHashSaltHash: shortHash(input2.settings.projectHashSalt),
-    projectMode: input2.settings.projectMode
+    apiKeyHash: shortHash(input.apiKey),
+    apiUrl: normalizeApiUrl(input.apiUrl),
+    deviceId: input.deviceId,
+    projectHashSaltHash: shortHash(input.settings.projectHashSalt),
+    projectMode: input.settings.projectMode
   };
 }
 function describeUploadManifestScopeChanges(previous, current) {
@@ -1730,20 +2234,20 @@ function buildRecordHashes(items, getKey, getHash) {
   }
   return hashes;
 }
-function createUploadManifest(input2) {
+function createUploadManifest(input) {
   return {
     buckets: buildRecordHashes(
-      input2.buckets,
+      input.buckets,
       getUploadBucketManifestKey,
       getUploadBucketContentHash
     ),
-    scope: input2.scope,
+    scope: input.scope,
     sessions: buildRecordHashes(
-      input2.sessions,
+      input.sessions,
       getUploadSessionManifestKey,
       getUploadSessionContentHash
     ),
-    updatedAt: input2.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     version: MANIFEST_VERSION
   };
 }
@@ -1756,21 +2260,21 @@ function countRemovedRecords(previous, current) {
   }
   return removed;
 }
-function diffUploadManifest(input2) {
+function diffUploadManifest(input) {
   const nextManifest = createUploadManifest({
-    buckets: input2.buckets,
-    scope: input2.scope,
-    sessions: input2.sessions,
-    updatedAt: input2.updatedAt
+    buckets: input.buckets,
+    scope: input.scope,
+    sessions: input.sessions,
+    updatedAt: input.updatedAt
   });
-  const scopeChangedReasons = input2.previous ? describeUploadManifestScopeChanges(input2.previous.scope, input2.scope) : [];
-  const previousBuckets = input2.previous && scopeChangedReasons.length === 0 ? input2.previous.buckets : {};
-  const previousSessions = input2.previous && scopeChangedReasons.length === 0 ? input2.previous.sessions : {};
-  const bucketsToUpload = input2.buckets.filter((bucket) => {
+  const scopeChangedReasons = input.previous ? describeUploadManifestScopeChanges(input.previous.scope, input.scope) : [];
+  const previousBuckets = input.previous && scopeChangedReasons.length === 0 ? input.previous.buckets : {};
+  const previousSessions = input.previous && scopeChangedReasons.length === 0 ? input.previous.sessions : {};
+  const bucketsToUpload = input.buckets.filter((bucket) => {
     const key = getUploadBucketManifestKey(bucket);
     return previousBuckets[key] !== nextManifest.buckets[key];
   });
-  const sessionsToUpload = input2.sessions.filter((session) => {
+  const sessionsToUpload = input.sessions.filter((session) => {
     const key = getUploadSessionManifestKey(session);
     return previousSessions[key] !== nextManifest.sessions[key];
   });
@@ -1784,8 +2288,8 @@ function diffUploadManifest(input2) {
     ),
     scopeChangedReasons,
     sessionsToUpload,
-    unchangedBuckets: input2.buckets.length - bucketsToUpload.length,
-    unchangedSessions: input2.sessions.length - sessionsToUpload.length
+    unchangedBuckets: input.buckets.length - bucketsToUpload.length,
+    unchangedSessions: input.sessions.length - sessionsToUpload.length
   };
 }
 
@@ -2019,7 +2523,7 @@ var ApiClient = class {
 // src/infrastructure/runtime/lock.ts
 import {
   closeSync,
-  existsSync as existsSync9,
+  existsSync as existsSync13,
   openSync,
   readFileSync as readFileSync7,
   rmSync,
@@ -2028,22 +2532,22 @@ import {
 
 // src/infrastructure/runtime/paths.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join10 } from "path";
+import { join as join14 } from "path";
 var APP_NAME = "tokenarena";
 function getRuntimeDirPath() {
-  return join10(getRuntimeDir(), APP_NAME);
+  return join14(getRuntimeDir(), APP_NAME);
 }
 function getStateDir() {
-  return join10(getStateHome(), APP_NAME);
+  return join14(getStateHome(), APP_NAME);
 }
 function getSyncLockPath() {
-  return join10(getRuntimeDirPath(), "sync.lock");
+  return join14(getRuntimeDirPath(), "sync.lock");
 }
 function getSyncStatePath() {
-  return join10(getStateDir(), "status.json");
+  return join14(getStateDir(), "status.json");
 }
 function getUploadManifestPath() {
-  return join10(getStateDir(), "upload-manifest.json");
+  return join14(getStateDir(), "upload-manifest.json");
 }
 function ensureAppDirs() {
   mkdirSync2(getRuntimeDirPath(), { recursive: true });
@@ -2061,7 +2565,7 @@ function isProcessAlive(pid) {
   }
 }
 function readLockMetadata(lockPath) {
-  if (!existsSync9(lockPath)) {
+  if (!existsSync13(lockPath)) {
     return null;
   }
   try {
@@ -2135,13 +2639,13 @@ function describeExistingSyncLock() {
 }
 
 // src/infrastructure/runtime/state.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
 function getDefaultState() {
   return { status: "idle" };
 }
 function loadSyncState() {
   const path = getSyncStatePath();
-  if (!existsSync10(path)) {
+  if (!existsSync14(path)) {
     return getDefaultState();
   }
   try {
@@ -2202,7 +2706,7 @@ function markSyncFailed(source, error, status) {
 }
 
 // src/infrastructure/runtime/upload-manifest.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
 function isRecordOfStrings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -2218,7 +2722,7 @@ function isUploadManifest(value) {
 }
 function loadUploadManifest() {
   const path = getUploadManifestPath();
-  if (!existsSync11(path)) {
+  if (!existsSync15(path)) {
     return null;
   }
   try {
@@ -2646,15 +3150,15 @@ View your dashboard at: ${apiUrl}/usage`);
 
 // src/commands/init.ts
 import { execFileSync as execFileSync2, spawn } from "child_process";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { appendFile, mkdir, readFile } from "fs/promises";
-import { homedir as homedir8, platform } from "os";
-import { dirname as dirname2, join as join11, posix, win32 } from "path";
+import { homedir as homedir12, platform } from "os";
+import { dirname as dirname3, join as join15, posix, win32 } from "path";
 function joinForPlatform(currentPlatform, ...parts) {
   return currentPlatform === "win32" ? win32.join(...parts) : posix.join(...parts);
 }
-function basenameLikeShell(input2) {
-  return input2.split(/[\\/]+/).pop()?.replace(/\.exe$/i, "") ?? input2;
+function basenameLikeShell(input) {
+  return input.split(/[\\/]+/).pop()?.replace(/\.exe$/i, "") ?? input;
 }
 function getBrowserLaunchCommand(url, currentPlatform = platform()) {
   switch (currentPlatform) {
@@ -2693,7 +3197,7 @@ function resolvePowerShellProfilePath() {
   const systemRoot = process.env.SYSTEMROOT || "C:\\Windows";
   const candidates = [
     "pwsh.exe",
-    join11(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    join15(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   ];
   for (const command of candidates) {
     try {
@@ -2722,8 +3226,8 @@ function resolvePowerShellProfilePath() {
 function resolveShellAliasSetup(options = {}) {
   const currentPlatform = options.currentPlatform ?? platform();
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir8();
-  const pathExists = options.exists ?? existsSync12;
+  const homeDir = options.homeDir ?? homedir12();
+  const pathExists = options.exists ?? existsSync16;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
   const aliasName = "ta";
@@ -2879,6 +3383,30 @@ async function runInit(opts = {}) {
   logger.info(formatBullet("TokenArena \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002", "success"));
   logger.info(formatKeyValue("\u63A7\u5236\u53F0", `${apiUrl}/usage`));
   await setupShellAlias();
+  await setupSystemdService();
+}
+async function setupSystemdService() {
+  const currentPlatform = platform();
+  if (currentPlatform !== "linux") {
+    return;
+  }
+  if (!isCommandAvailable("systemctl")) {
+    return;
+  }
+  const shouldSetup = await promptConfirm({
+    message: "\u662F\u5426\u8BBE\u7F6E systemd \u670D\u52A1\u4EE5\u81EA\u52A8\u8FD0\u884C daemon\uFF1F",
+    defaultValue: true
+  });
+  if (!shouldSetup) {
+    logger.info(formatBullet("\u5DF2\u8DF3\u8FC7 systemd \u670D\u52A1\u8BBE\u7F6E\u3002"));
+    return;
+  }
+  try {
+    const { runInstallService: runInstallService2 } = await import("./service-4U7K4DKW.js");
+    await runInstallService2({ action: "setup", skipPrompt: true });
+  } catch (err) {
+    logger.warn(`systemd \u670D\u52A1\u8BBE\u7F6E\u5931\u8D25: ${err.message}`);
+  }
 }
 async function setupShellAlias() {
   const setup = resolveShellAliasSetup();
@@ -2894,9 +3422,9 @@ async function setupShellAlias() {
     return;
   }
   try {
-    await mkdir(dirname2(setup.configFile), { recursive: true });
+    await mkdir(dirname3(setup.configFile), { recursive: true });
     let existingContent = "";
-    if (existsSync12(setup.configFile)) {
+    if (existsSync16(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
     }
     const normalizedContent = existingContent.toLowerCase();
@@ -3089,8 +3617,8 @@ async function runSyncCommand(opts = {}) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir9, platform as platform2 } from "os";
+import { existsSync as existsSync17, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir13, platform as platform2 } from "os";
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -3099,22 +3627,22 @@ function removeShellAlias() {
   let configFile;
   switch (shellName) {
     case "zsh":
-      configFile = `${homedir9()}/.zshrc`;
+      configFile = `${homedir13()}/.zshrc`;
       break;
     case "bash":
-      if (platform2() === "darwin" && existsSync13(`${homedir9()}/.bash_profile`)) {
-        configFile = `${homedir9()}/.bash_profile`;
+      if (platform2() === "darwin" && existsSync17(`${homedir13()}/.bash_profile`)) {
+        configFile = `${homedir13()}/.bash_profile`;
       } else {
-        configFile = `${homedir9()}/.bashrc`;
+        configFile = `${homedir13()}/.bashrc`;
       }
       break;
     case "fish":
-      configFile = `${homedir9()}/.config/fish/config.fish`;
+      configFile = `${homedir13()}/.config/fish/config.fish`;
       break;
     default:
       return;
   }
-  if (!existsSync13(configFile)) return;
+  if (!existsSync17(configFile)) return;
   try {
     let content = readFileSync10(configFile, "utf-8");
     const aliasPatterns = [
@@ -3149,7 +3677,7 @@ function removeShellAlias() {
 async function runUninstall() {
   const configPath = getConfigPath();
   const configDir = getConfigDir();
-  if (!existsSync13(configPath)) {
+  if (!existsSync17(configPath)) {
     logger.info(formatHeader("\u5378\u8F7D TokenArena"));
     logger.info(formatBullet("\u672A\u53D1\u73B0\u672C\u5730\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D\u3002"));
     return;
@@ -3178,7 +3706,7 @@ async function runUninstall() {
   deleteConfig();
   logger.info(formatSection("\u6267\u884C\u7ED3\u679C"));
   logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
-  if (existsSync13(configDir)) {
+  if (existsSync17(configDir)) {
     try {
       rmSync2(configDir, { recursive: false, force: true });
       logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u76EE\u5F55\u3002", "success"));
@@ -3186,12 +3714,12 @@ async function runUninstall() {
     }
   }
   const stateDir = getStateDir();
-  if (existsSync13(stateDir)) {
+  if (existsSync17(stateDir)) {
     rmSync2(stateDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u72B6\u6001\u6570\u636E\u3002", "success"));
   }
   const runtimeDir = getRuntimeDirPath();
-  if (existsSync13(runtimeDir)) {
+  if (existsSync17(runtimeDir)) {
     rmSync2(runtimeDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u8FD0\u884C\u65F6\u6570\u636E\u3002", "success"));
   }
@@ -3316,7 +3844,7 @@ async function runHome(program) {
 
 // src/infrastructure/runtime/cli-version.ts
 import { readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname3, join as join12 } from "path";
+import { dirname as dirname4, join as join16 } from "path";
 import { fileURLToPath } from "url";
 var FALLBACK_VERSION = "0.0.0";
 var cachedVersion;
@@ -3324,8 +3852,8 @@ function getCliVersion(metaUrl = import.meta.url) {
   if (cachedVersion) {
     return cachedVersion;
   }
-  const packageJsonPath = join12(
-    dirname3(fileURLToPath(metaUrl)),
+  const packageJsonPath = join16(
+    dirname4(fileURLToPath(metaUrl)),
     "..",
     "package.json"
   );
@@ -3363,6 +3891,11 @@ function createCli() {
   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("service [action]").description(
+    "Manage systemd user service (setup|start|stop|restart|status|uninstall)"
+  ).action(async (action) => {
+    await runInstallService({ action });
+  });
   program.command("status").description("Show configuration and detected tools").action(async () => {
     await runStatus();
   });
@@ -3380,7 +3913,7 @@ function createCli() {
 }
 
 // src/infrastructure/runtime/main-module.ts
-import { existsSync as existsSync14, realpathSync } from "fs";
+import { existsSync as existsSync18, realpathSync } from "fs";
 import { resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
@@ -3391,7 +3924,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
   try {
     return realpathSync(argvEntry) === realpathSync(currentModulePath);
   } catch {
-    if (!existsSync14(argvEntry)) {
+    if (!existsSync18(argvEntry)) {
       return false;
     }
     return resolve(argvEntry) === resolve(currentModulePath);