@poco-ai/tokenarena 0.1.5 → 0.2.0

package/dist/index.js

@@ -1129,7 +1129,14 @@ function getRuntimeDir() {
 var CONFIG_DIR = join9(getConfigHome(), "tokenarena");
 var isDev = process.env.TOKEN_ARENA_DEV === "1";
 var CONFIG_FILE = join9(CONFIG_DIR, isDev ? "config.dev.json" : "config.json");
-var DEFAULT_API_URL = "http://localhost:3000";
+var DEFAULT_API_URL = "https://token.poco-ai.com";
+var VALID_CONFIG_KEYS = [
+  "apiKey",
+  "apiUrl",
+  "deviceId",
+  "syncInterval",
+  "logLevel"
+];
 function getConfigPath() {
   return CONFIG_FILE;
 }
@@ -1168,10 +1175,112 @@ function getOrCreateDeviceId(config) {
 function validateApiKey(key) {
   return key.startsWith("ta_");
 }
+function isValidConfigKey(key) {
+  return VALID_CONFIG_KEYS.includes(key);
+}
 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,
@@ -1219,13 +1328,220 @@ var logger = new Logger();
 
 // src/commands/config.ts
 var VALID_KEYS = ["apiKey", "apiUrl", "syncInterval", "logLevel"];
-function handleConfig(args) {
-  const sub = args[0];
+function isConfigKey(value) {
+  return isValidConfigKey(value) && VALID_KEYS.includes(value);
+}
+function formatConfigValue(key, value) {
+  if (value === void 0 || value === null || value === "") {
+    return "(empty)";
+  }
+  if (key === "apiKey") {
+    return maskSecret(String(value));
+  }
+  if (key === "syncInterval") {
+    const ms = Number(value);
+    const minutes = Math.round(ms / 6e4);
+    return `${minutes} \u5206\u949F (${ms} ms)`;
+  }
+  return String(value);
+}
+async function promptConfigSubcommand() {
+  logger.info(
+    formatHeader("\u914D\u7F6E\u4E2D\u5FC3", "\u901A\u8FC7\u4EA4\u4E92\u5F0F\u83DC\u5355\u67E5\u770B\u6216\u4FEE\u6539 TokenArena CLI \u914D\u7F6E\u3002")
+  );
+  return promptSelect({
+    message: "\u8BF7\u9009\u62E9\u914D\u7F6E\u64CD\u4F5C",
+    choices: [
+      {
+        name: "\u67E5\u770B\u5B8C\u6574\u914D\u7F6E",
+        value: "show",
+        description: "\u4EE5\u66F4\u9002\u5408\u9605\u8BFB\u7684\u65B9\u5F0F\u5C55\u793A\u5F53\u524D\u914D\u7F6E"
+      },
+      {
+        name: "\u8BFB\u53D6\u5355\u4E2A\u914D\u7F6E\u9879",
+        value: "get",
+        description: "\u67E5\u770B\u67D0\u4E2A\u914D\u7F6E\u952E\u5F53\u524D\u4FDD\u5B58\u7684\u503C"
+      },
+      {
+        name: "\u4FEE\u6539\u914D\u7F6E\u9879",
+        value: "set",
+        description: "\u66F4\u65B0 API Key\u3001API \u5730\u5740\u3001\u540C\u6B65\u95F4\u9694\u6216\u65E5\u5FD7\u7EA7\u522B"
+      }
+    ]
+  });
+}
+async function promptConfigKey(message) {
+  return promptSelect({
+    message,
+    choices: [
+      {
+        name: "apiKey",
+        value: "apiKey",
+        description: "\u4E0A\u4F20\u6570\u636E\u65F6\u4F7F\u7528\u7684 CLI API Key"
+      },
+      {
+        name: "apiUrl",
+        value: "apiUrl",
+        description: "TokenArena \u670D\u52A1\u7AEF\u5730\u5740"
+      },
+      {
+        name: "syncInterval",
+        value: "syncInterval",
+        description: "daemon \u9ED8\u8BA4\u540C\u6B65\u95F4\u9694\uFF08\u6BEB\u79D2\uFF09"
+      },
+      {
+        name: "logLevel",
+        value: "logLevel",
+        description: "CLI \u65E5\u5FD7\u7EA7\u522B"
+      }
+    ]
+  });
+}
+async function promptSyncIntervalValue(existingValue) {
+  const preset = await promptSelect({
+    message: "\u8BF7\u9009\u62E9\u9ED8\u8BA4\u540C\u6B65\u95F4\u9694",
+    choices: [
+      {
+        name: "5 \u5206\u949F",
+        value: String(5 * 6e4),
+        description: "\u9002\u5408\u4F5C\u4E3A\u9ED8\u8BA4\u503C"
+      },
+      {
+        name: "10 \u5206\u949F",
+        value: String(10 * 6e4),
+        description: "\u66F4\u7701\u7535\uFF0C\u4ECD\u4FDD\u6301\u8F83\u53CA\u65F6\u540C\u6B65"
+      },
+      {
+        name: "30 \u5206\u949F",
+        value: String(30 * 6e4),
+        description: "\u9002\u5408\u4F4E\u9891\u4F7F\u7528\u573A\u666F"
+      },
+      {
+        name: "60 \u5206\u949F",
+        value: String(60 * 6e4),
+        description: "\u957F\u5468\u671F\u540E\u53F0\u540C\u6B65"
+      },
+      {
+        name: "\u81EA\u5B9A\u4E49\uFF08\u6BEB\u79D2\uFF09",
+        value: "custom",
+        description: "\u8F93\u5165\u4EFB\u610F\u6B63\u6574\u6570\u6BEB\u79D2\u503C"
+      }
+    ]
+  });
+  if (preset !== "custom") {
+    return preset;
+  }
+  return promptText({
+    message: "\u8BF7\u8F93\u5165 syncInterval\uFF08\u6BEB\u79D2\uFF09",
+    defaultValue: existingValue ? String(existingValue) : void 0,
+    validate: (value) => {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isNaN(parsed) || parsed <= 0) {
+        return "\u8BF7\u8F93\u5165\u5927\u4E8E 0 \u7684\u6BEB\u79D2\u6570\uFF0C\u4F8B\u5982 300000\u3002";
+      }
+      return true;
+    }
+  });
+}
+async function promptConfigValue(key, existingValue) {
+  switch (key) {
+    case "apiKey":
+      return promptPassword({
+        message: "\u8BF7\u8F93\u5165\u65B0\u7684 CLI API Key",
+        validate: (value) => validateApiKey(value) || 'API Key \u5FC5\u987B\u4EE5 "ta_" \u5F00\u5934\u3002'
+      });
+    case "apiUrl":
+      return promptText({
+        message: "\u8BF7\u8F93\u5165 API \u670D\u52A1\u5730\u5740",
+        defaultValue: typeof existingValue === "string" && existingValue.length > 0 ? existingValue : getDefaultApiUrl(),
+        validate: (value) => {
+          try {
+            const url = new URL(value);
+            return Boolean(url.protocol && url.host) || "\u8BF7\u8F93\u5165\u5408\u6CD5 URL\u3002";
+          } catch {
+            return "\u8BF7\u8F93\u5165\u5408\u6CD5 URL\u3002";
+          }
+        }
+      });
+    case "syncInterval":
+      return promptSyncIntervalValue(
+        typeof existingValue === "number" ? existingValue : void 0
+      );
+    case "logLevel":
+      return promptSelect({
+        message: "\u8BF7\u9009\u62E9\u65E5\u5FD7\u7EA7\u522B",
+        choices: [
+          {
+            name: "info",
+            value: "info",
+            description: "\u9ED8\u8BA4\uFF0C\u8F93\u51FA\u5E38\u89C4\u8FDB\u5EA6\u4E0E\u63D0\u793A"
+          },
+          {
+            name: "warn",
+            value: "warn",
+            description: "\u4EC5\u8F93\u51FA\u8B66\u544A\u4E0E\u9519\u8BEF"
+          },
+          {
+            name: "error",
+            value: "error",
+            description: "\u53EA\u8F93\u51FA\u9519\u8BEF"
+          },
+          {
+            name: "debug",
+            value: "debug",
+            description: "\u8F93\u51FA\u66F4\u8BE6\u7EC6\u7684\u8C03\u8BD5\u65E5\u5FD7"
+          }
+        ]
+      });
+  }
+}
+function printConfigShow() {
+  const config = loadConfig();
+  if (!config) {
+    logger.info(formatHeader("\u5F53\u524D\u914D\u7F6E", "\u5C1A\u672A\u521B\u5EFA\u672C\u5730\u914D\u7F6E\u6587\u4EF6\u3002"));
+    logger.info(formatBullet("\u8FD0\u884C tokenarena init \u5B8C\u6210\u9996\u6B21\u914D\u7F6E\u3002", "warning"));
+    return;
+  }
+  logger.info(formatHeader("\u5F53\u524D\u914D\u7F6E"));
+  logger.info(formatSection("\u57FA\u7840\u914D\u7F6E"));
+  logger.info(formatKeyValue("API Key", maskSecret(config.apiKey || "")));
+  logger.info(
+    formatKeyValue("API \u5730\u5740", config.apiUrl || "https://token.poco-ai.com")
+  );
+  logger.info(
+    formatKeyValue(
+      "\u540C\u6B65\u95F4\u9694",
+      config.syncInterval ? `${Math.round(config.syncInterval / 6e4)} \u5206\u949F (${config.syncInterval} ms)` : "\u672A\u8BBE\u7F6E\uFF08daemon \u9ED8\u8BA4 5 \u5206\u949F\uFF09"
+    )
+  );
+  logger.info(formatKeyValue("\u65E5\u5FD7\u7EA7\u522B", config.logLevel || "info"));
+  if (config.deviceId) {
+    logger.info(formatKeyValue("\u8BBE\u5907 ID", maskSecret(config.deviceId, 12)));
+  }
+}
+async function handleConfig(args) {
+  const interactive = isInteractiveTerminal();
+  let sub = args[0];
+  if (!sub) {
+    if (!interactive) {
+      logger.error("Usage: tokenarena config <get|set|show>");
+      process.exit(1);
+    }
+    sub = await promptConfigSubcommand();
+  }
   switch (sub) {
     case "get": {
-      const key = args[1];
+      let key = args[1];
       if (!key) {
-        logger.error("Usage: tokenarena config get <key>");
+        if (!interactive) {
+          logger.error("Usage: tokenarena config get <key>");
+          process.exit(1);
+        }
+        key = await promptConfigKey("\u8BF7\u9009\u62E9\u8981\u8BFB\u53D6\u7684\u914D\u7F6E\u9879");
+      }
+      if (!isConfigKey(key)) {
+        logger.error(`Unknown config key: ${key}`);
+        logger.error(`Valid keys: ${VALID_KEYS.join(", ")}`);
         process.exit(1);
       }
       const config = loadConfig();
@@ -1237,40 +1553,69 @@ function handleConfig(args) {
       break;
     }
     case "set": {
-      const key = args[1];
-      let value = args[2];
-      if (!key || value === void 0) {
-        logger.error("Usage: tokenarena config set <key> <value>");
-        process.exit(1);
+      let key = args[1];
+      if (!key) {
+        if (!interactive) {
+          logger.error("Usage: tokenarena config set <key> <value>");
+          process.exit(1);
+        }
+        key = await promptConfigKey("\u8BF7\u9009\u62E9\u8981\u4FEE\u6539\u7684\u914D\u7F6E\u9879");
       }
-      if (!VALID_KEYS.includes(key)) {
+      if (!isConfigKey(key)) {
         logger.error(`Unknown config key: ${key}`);
         logger.error(`Valid keys: ${VALID_KEYS.join(", ")}`);
         process.exit(1);
       }
       const config = loadConfig() || {
         apiKey: "",
-        apiUrl: "http://localhost:3000"
+        apiUrl: getDefaultApiUrl()
       };
+      const record = config;
+      let value = args[2];
+      if (value === void 0) {
+        if (!interactive) {
+          logger.error("Usage: tokenarena config set <key> <value>");
+          process.exit(1);
+        }
+        value = await promptConfigValue(key, record[key]);
+      }
+      let normalized = value;
+      if (key === "apiKey" && !validateApiKey(value)) {
+        logger.error('API Key must start with "ta_"');
+        process.exit(1);
+      }
+      if (key === "apiUrl") {
+        try {
+          const url = new URL(value);
+          normalized = url.toString().replace(/\/$/, "");
+        } catch {
+          logger.error("apiUrl must be a valid URL");
+          process.exit(1);
+        }
+      }
       if (key === "syncInterval") {
-        value = parseInt(value, 10);
-        if (Number.isNaN(value)) {
-          logger.error("syncInterval must be a number (milliseconds)");
+        normalized = Number.parseInt(value, 10);
+        if (Number.isNaN(normalized) || normalized <= 0) {
+          logger.error("syncInterval must be a positive number (milliseconds)");
           process.exit(1);
         }
       }
-      const record = config;
-      record[key] = value;
+      record[key] = normalized;
       saveConfig(config);
-      logger.info(`Set ${key} = ${value}`);
+      if (interactive) {
+        logger.info(formatHeader("\u914D\u7F6E\u5DF2\u66F4\u65B0"));
+        logger.info(formatKeyValue(key, formatConfigValue(key, normalized)));
+      } else {
+        logger.info(`Set ${key} = ${normalized}`);
+      }
       break;
     }
     case "show": {
-      const config = loadConfig();
-      if (!config) {
-        console.log("{}");
+      if (interactive) {
+        printConfigShow();
       } else {
-        console.log(JSON.stringify(config, null, 2));
+        const config = loadConfig();
+        console.log(config ? JSON.stringify(config, null, 2) : "{}");
       }
       break;
     }
@@ -1286,27 +1631,180 @@ import { hostname as hostname3 } from "os";
 
 // src/domain/project-identity.ts
 import { createHmac } from "crypto";
-function toProjectIdentity(input) {
-  if (input.mode === "disabled") {
+function toProjectIdentity(input2) {
+  if (input2.mode === "disabled") {
     return { projectKey: "unknown", projectLabel: "Unknown Project" };
   }
-  if (input.mode === "raw") {
-    return { projectKey: input.project, projectLabel: input.project };
+  if (input2.mode === "raw") {
+    return { projectKey: input2.project, projectLabel: input2.project };
   }
-  const projectKey = createHmac("sha256", input.salt).update(input.project).digest("hex").slice(0, 16);
+  const projectKey = createHmac("sha256", input2.salt).update(input2.project).digest("hex").slice(0, 16);
   return {
     projectKey,
     projectLabel: `Project ${projectKey.slice(0, 6)}`
   };
 }
 
+// src/domain/upload-manifest.ts
+import { createHash as createHash2 } from "crypto";
+var MANIFEST_VERSION = 1;
+function shortHash(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, 16);
+}
+function normalizeApiUrl(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+function buildUploadManifestScope(input2) {
+  return {
+    apiKeyHash: shortHash(input2.apiKey),
+    apiUrl: normalizeApiUrl(input2.apiUrl),
+    deviceId: input2.deviceId,
+    projectHashSaltHash: shortHash(input2.settings.projectHashSalt),
+    projectMode: input2.settings.projectMode
+  };
+}
+function describeUploadManifestScopeChanges(previous, current) {
+  const changes = [];
+  if (previous.apiUrl !== current.apiUrl || previous.apiKeyHash !== current.apiKeyHash) {
+    changes.push("server_or_api_key");
+  }
+  if (previous.deviceId !== current.deviceId) {
+    changes.push("device_id");
+  }
+  if (previous.projectMode !== current.projectMode || previous.projectHashSaltHash !== current.projectHashSaltHash) {
+    changes.push("project_identity");
+  }
+  return changes;
+}
+function getUploadBucketManifestKey(bucket) {
+  return [
+    bucket.deviceId,
+    bucket.source,
+    bucket.model,
+    bucket.projectKey,
+    bucket.bucketStart
+  ].join("|");
+}
+function getUploadSessionManifestKey(session) {
+  return [session.deviceId, session.source, session.sessionHash].join("|");
+}
+function getUploadBucketContentHash(bucket) {
+  return shortHash(
+    JSON.stringify({
+      cachedTokens: bucket.cachedTokens,
+      hostname: bucket.hostname,
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      projectLabel: bucket.projectLabel,
+      reasoningTokens: bucket.reasoningTokens,
+      totalTokens: bucket.totalTokens
+    })
+  );
+}
+function getUploadSessionContentHash(session) {
+  return shortHash(
+    JSON.stringify({
+      activeSeconds: session.activeSeconds,
+      cachedTokens: session.cachedTokens,
+      durationSeconds: session.durationSeconds,
+      firstMessageAt: session.firstMessageAt,
+      hostname: session.hostname,
+      inputTokens: session.inputTokens,
+      lastMessageAt: session.lastMessageAt,
+      messageCount: session.messageCount,
+      modelUsages: session.modelUsages,
+      outputTokens: session.outputTokens,
+      primaryModel: session.primaryModel,
+      projectKey: session.projectKey,
+      projectLabel: session.projectLabel,
+      reasoningTokens: session.reasoningTokens,
+      totalTokens: session.totalTokens,
+      userMessageCount: session.userMessageCount
+    })
+  );
+}
+function buildRecordHashes(items, getKey, getHash) {
+  const hashes = {};
+  for (const item of items) {
+    hashes[getKey(item)] = getHash(item);
+  }
+  return hashes;
+}
+function createUploadManifest(input2) {
+  return {
+    buckets: buildRecordHashes(
+      input2.buckets,
+      getUploadBucketManifestKey,
+      getUploadBucketContentHash
+    ),
+    scope: input2.scope,
+    sessions: buildRecordHashes(
+      input2.sessions,
+      getUploadSessionManifestKey,
+      getUploadSessionContentHash
+    ),
+    updatedAt: input2.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    version: MANIFEST_VERSION
+  };
+}
+function countRemovedRecords(previous, current) {
+  let removed = 0;
+  for (const key of Object.keys(previous)) {
+    if (!(key in current)) {
+      removed++;
+    }
+  }
+  return removed;
+}
+function diffUploadManifest(input2) {
+  const nextManifest = createUploadManifest({
+    buckets: input2.buckets,
+    scope: input2.scope,
+    sessions: input2.sessions,
+    updatedAt: input2.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 key = getUploadBucketManifestKey(bucket);
+    return previousBuckets[key] !== nextManifest.buckets[key];
+  });
+  const sessionsToUpload = input2.sessions.filter((session) => {
+    const key = getUploadSessionManifestKey(session);
+    return previousSessions[key] !== nextManifest.sessions[key];
+  });
+  return {
+    bucketsToUpload,
+    nextManifest,
+    removedBuckets: countRemovedRecords(previousBuckets, nextManifest.buckets),
+    removedSessions: countRemovedRecords(
+      previousSessions,
+      nextManifest.sessions
+    ),
+    scopeChangedReasons,
+    sessionsToUpload,
+    unchangedBuckets: input2.buckets.length - bucketsToUpload.length,
+    unchangedSessions: input2.sessions.length - sessionsToUpload.length
+  };
+}
+
 // src/infrastructure/api/client.ts
 import http from "http";
 import https from "https";
-import { URL } from "url";
+import { URL as URL2 } from "url";
 var MAX_RETRIES = 3;
 var INITIAL_DELAY = 1e3;
 var TIMEOUT_MS = 6e4;
+function getIngestPayloadSize(device, buckets, sessions) {
+  const payload = {
+    schemaVersion: 2,
+    device,
+    buckets,
+    sessions: sessions ?? []
+  };
+  return Buffer.byteLength(JSON.stringify(payload));
+}
 var ApiClient = class {
   constructor(apiUrl, apiKey) {
     this.apiUrl = apiUrl;
@@ -1336,14 +1834,15 @@ var ApiClient = class {
   }
   sendIngest(device, buckets, sessions, onProgress) {
     return new Promise((resolve2, reject) => {
-      const url = new URL("/api/usage/ingest", this.apiUrl);
-      const payload = {
-        schemaVersion: 2,
-        device,
-        buckets,
-        sessions: sessions ?? []
-      };
-      const body = Buffer.from(JSON.stringify(payload));
+      const url = new URL2("/api/usage/ingest", this.apiUrl);
+      const body = Buffer.from(
+        JSON.stringify({
+          schemaVersion: 2,
+          device,
+          buckets,
+          sessions: sessions ?? []
+        })
+      );
       const totalBytes = body.length;
       const mod = url.protocol === "https:" ? https : http;
       const req = mod.request(
@@ -1416,7 +1915,7 @@ var ApiClient = class {
    */
   async fetchSettings() {
     return new Promise((resolve2, reject) => {
-      const url = new URL("/api/usage/settings", this.apiUrl);
+      const url = new URL2("/api/usage/settings", this.apiUrl);
       const mod = url.protocol === "https:" ? https : http;
       const req = mod.request(
         url,
@@ -1467,7 +1966,7 @@ var ApiClient = class {
    */
   async deleteAllData(opts) {
     return new Promise((resolve2, reject) => {
-      const url = new URL("/api/usage/ingest", this.apiUrl);
+      const url = new URL2("/api/usage/ingest", this.apiUrl);
       if (opts?.hostname) {
         url.searchParams.set("hostname", opts.hostname);
       }
@@ -1543,6 +2042,9 @@ function getSyncLockPath() {
 function getSyncStatePath() {
   return join10(getStateDir(), "status.json");
 }
+function getUploadManifestPath() {
+  return join10(getStateDir(), "upload-manifest.json");
+}
 function ensureAppDirs() {
   mkdirSync2(getRuntimeDirPath(), { recursive: true });
   mkdirSync2(getStateDir(), { recursive: true });
@@ -1699,6 +2201,43 @@ function markSyncFailed(source, error, status) {
   });
 }
 
+// src/infrastructure/runtime/upload-manifest.ts
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+function isRecordOfStrings(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return Object.values(value).every((entry) => typeof entry === "string");
+}
+function isUploadManifest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const manifest = value;
+  return manifest.version === 1 && !!manifest.scope && typeof manifest.scope === "object" && typeof manifest.scope.apiUrl === "string" && typeof manifest.scope.apiKeyHash === "string" && typeof manifest.scope.deviceId === "string" && typeof manifest.scope.projectMode === "string" && typeof manifest.scope.projectHashSaltHash === "string" && typeof manifest.updatedAt === "string" && isRecordOfStrings(manifest.buckets) && isRecordOfStrings(manifest.sessions);
+}
+function loadUploadManifest() {
+  const path = getUploadManifestPath();
+  if (!existsSync11(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
+    return isUploadManifest(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function saveUploadManifest(manifest) {
+  ensureAppDirs();
+  writeFileSync4(
+    getUploadManifestPath(),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf-8"
+  );
+}
+
 // src/services/parser-service.ts
 async function runAllParsers() {
   const allBuckets = [];
@@ -1731,16 +2270,45 @@ function getDetectedTools() {
 // src/services/sync-service.ts
 var BATCH_SIZE = 100;
 var SESSION_BATCH_SIZE = 500;
+var PROGRESS_BAR_WIDTH = 28;
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
-function formatTime(secs) {
-  if (secs < 60) return `${secs}s`;
-  const h = Math.floor(secs / 3600);
-  const m = Math.floor(secs % 3600 / 60);
-  return h > 0 ? m > 0 ? `${h}h ${m}m` : `${h}h` : `${m}m`;
+function renderProgressBar(progress) {
+  const safeProgress = Math.max(0, Math.min(progress, 1));
+  const filled = Math.round(safeProgress * PROGRESS_BAR_WIDTH);
+  return `${"\u2588".repeat(filled)}${"\u2591".repeat(PROGRESS_BAR_WIDTH - filled)}`;
+}
+function writeUploadProgress(sent, total, batchNum, totalBatches) {
+  const pct = total > 0 ? Math.round(sent / total * 100) : 100;
+  const progressBar = renderProgressBar(total > 0 ? sent / total : 1);
+  const batchLabel = totalBatches > 1 ? ` \xB7 batch ${batchNum}/${totalBatches}` : "";
+  process.stdout.write(
+    `\r  Uploading ${progressBar} ${String(pct).padStart(3, " ")}% \xB7 ${formatBytes(sent)}/${formatBytes(total)}${batchLabel}\x1B[K`
+  );
+}
+function formatScopeChangeReason(reason) {
+  switch (reason) {
+    case "server_or_api_key":
+      return "server/API key";
+    case "device_id":
+      return "device ID";
+    case "project_identity":
+      return "project identity settings";
+  }
+}
+function persistUploadManifest(manifest, quiet) {
+  try {
+    saveUploadManifest(manifest);
+  } catch (error) {
+    if (!quiet) {
+      logger.warn(
+        `Uploaded data, but failed to update the local sync manifest: ${error.message}`
+      );
+    }
+  }
 }
 function toDeviceMetadata(config) {
   return {
@@ -1887,59 +2455,135 @@ async function runSync(config, opts = {}) {
       );
     }
     const device = toDeviceMetadata(config);
+    const manifestScope = buildUploadManifestScope({
+      apiKey: config.apiKey,
+      apiUrl,
+      deviceId: device.deviceId,
+      settings
+    });
     const uploadBuckets = toUploadBuckets(allBuckets, settings, device);
     const uploadSessions = toUploadSessions(allSessions, settings, device);
-    if (!quiet) {
-      const projectModeLabel = {
-        hashed: "\u54C8\u5E0C\u5316",
-        raw: "\u539F\u59CB\u540D\u79F0",
-        disabled: "\u5DF2\u9690\u85CF"
-      };
-      logger.info(`\u{1F4C2} \u9879\u76EE\u6A21\u5F0F: ${projectModeLabel[settings.projectMode]}`);
+    const uploadDiff = diffUploadManifest({
+      buckets: uploadBuckets,
+      previous: loadUploadManifest(),
+      scope: manifestScope,
+      sessions: uploadSessions
+    });
+    const changedBuckets = uploadDiff.bucketsToUpload;
+    const changedSessions = uploadDiff.sessionsToUpload;
+    if (!quiet && uploadDiff.scopeChangedReasons.length > 0) {
+      logger.warn(
+        `Upload scope changed (${uploadDiff.scopeChangedReasons.map(formatScopeChangeReason).join(", ")}). TokenArena will upload the current snapshot again, but existing remote records from the previous scope will not be deleted automatically.`
+      );
+    }
+    if (!quiet && (uploadDiff.removedBuckets > 0 || uploadDiff.removedSessions > 0)) {
+      const parts = [];
+      if (uploadDiff.removedBuckets > 0) {
+        parts.push(`${uploadDiff.removedBuckets} buckets`);
+      }
+      if (uploadDiff.removedSessions > 0) {
+        parts.push(`${uploadDiff.removedSessions} sessions`);
+      }
+      logger.warn(
+        `Detected ${parts.join(" + ")} that were present in the previous local snapshot but are missing now. Remote deletions are not supported yet, so renamed projects or removed local logs may leave stale data online.`
+      );
     }
-    const bucketBatches = Math.ceil(uploadBuckets.length / BATCH_SIZE);
+    if (changedBuckets.length === 0 && changedSessions.length === 0) {
+      if (!quiet) {
+        const skippedParts = [];
+        if (uploadDiff.unchangedBuckets > 0) {
+          skippedParts.push(`${uploadDiff.unchangedBuckets} unchanged buckets`);
+        }
+        if (uploadDiff.unchangedSessions > 0) {
+          skippedParts.push(
+            `${uploadDiff.unchangedSessions} unchanged sessions`
+          );
+        }
+        logger.info(
+          skippedParts.length > 0 ? `No new or updated usage data to upload. Skipped ${skippedParts.join(" + ")}.` : "No new or updated usage data to upload."
+        );
+      }
+      persistUploadManifest(uploadDiff.nextManifest, quiet);
+      markSyncSucceeded(source, { buckets: 0, sessions: 0 });
+      return { buckets: 0, sessions: 0 };
+    }
+    const bucketBatches = Math.ceil(changedBuckets.length / BATCH_SIZE);
     const sessionBatches = Math.ceil(
-      uploadSessions.length / SESSION_BATCH_SIZE
+      changedSessions.length / SESSION_BATCH_SIZE
     );
     const totalBatches = Math.max(bucketBatches, sessionBatches, 1);
+    const batchPayloadSizes = Array.from(
+      { length: totalBatches },
+      (_, batchIdx) => getIngestPayloadSize(
+        device,
+        changedBuckets.slice(
+          batchIdx * BATCH_SIZE,
+          (batchIdx + 1) * BATCH_SIZE
+        ),
+        changedSessions.slice(
+          batchIdx * SESSION_BATCH_SIZE,
+          (batchIdx + 1) * SESSION_BATCH_SIZE
+        )
+      )
+    );
+    const totalPayloadBytes = batchPayloadSizes.reduce(
+      (sum, size) => sum + size,
+      0
+    );
+    let uploadedBytesBeforeBatch = 0;
     if (!quiet) {
       const parts = [];
-      if (uploadBuckets.length > 0) {
-        parts.push(`${uploadBuckets.length} buckets`);
+      if (changedBuckets.length > 0) {
+        parts.push(`${changedBuckets.length} buckets`);
       }
-      if (uploadSessions.length > 0) {
-        parts.push(`${uploadSessions.length} sessions`);
+      if (changedSessions.length > 0) {
+        parts.push(`${changedSessions.length} sessions`);
+      }
+      const skippedParts = [];
+      if (uploadDiff.unchangedBuckets > 0) {
+        skippedParts.push(`${uploadDiff.unchangedBuckets} unchanged buckets`);
+      }
+      if (uploadDiff.unchangedSessions > 0) {
+        skippedParts.push(`${uploadDiff.unchangedSessions} unchanged sessions`);
       }
       logger.info(
-        `Uploading ${parts.join(" + ")} (${totalBatches} batch${totalBatches > 1 ? "es" : ""})...`
+        `Uploading ${parts.join(" + ")} (${totalBatches} batch${totalBatches > 1 ? "es" : ""}${skippedParts.length > 0 ? `, skipped ${skippedParts.join(" + ")}` : ""})...`
       );
     }
     for (let batchIdx = 0; batchIdx < totalBatches; batchIdx++) {
-      const batch = uploadBuckets.slice(
+      const batch = changedBuckets.slice(
         batchIdx * BATCH_SIZE,
         (batchIdx + 1) * BATCH_SIZE
       );
-      const batchSessions = uploadSessions.slice(
+      const batchSessions = changedSessions.slice(
         batchIdx * SESSION_BATCH_SIZE,
         (batchIdx + 1) * SESSION_BATCH_SIZE
       );
       const batchNum = batchIdx + 1;
-      const prefix = totalBatches > 1 ? `  [${batchNum}/${totalBatches}] ` : "  ";
       const result = await apiClient.ingest(
         device,
         batch,
         batchSessions.length > 0 ? batchSessions : void 0,
         quiet ? void 0 : (sent, total) => {
-          const pct = Math.round(sent / total * 100);
-          process.stdout.write(
-            `\r${prefix}${formatBytes(sent)}/${formatBytes(total)} (${pct}%)\x1B[K`
+          writeUploadProgress(
+            uploadedBytesBeforeBatch + sent,
+            totalPayloadBytes || total,
+            batchNum,
+            totalBatches
           );
         }
       );
       totalIngested += result.ingested ?? batch.length;
       totalSessionsSynced += result.sessions ?? batchSessions.length;
-    }
-    if (!quiet && (totalBatches > 1 || uploadBuckets.length > 0)) {
+      uploadedBytesBeforeBatch += batchPayloadSizes[batchIdx] ?? 0;
+    }
+    if (!quiet && (totalBatches > 1 || changedBuckets.length > 0)) {
+      writeUploadProgress(
+        totalPayloadBytes,
+        totalPayloadBytes,
+        totalBatches,
+        totalBatches
+      );
       process.stdout.write("\n");
     }
     const syncParts = [`${totalIngested} buckets`];
@@ -1947,27 +2591,11 @@ async function runSync(config, opts = {}) {
       syncParts.push(`${totalSessionsSynced} sessions`);
     }
     logger.info(`Synced ${syncParts.join(" + ")}.`);
-    if (!quiet && totalSessionsSynced > 0) {
-      const totalActive = uploadSessions.reduce(
-        (sum, session) => sum + session.activeSeconds,
-        0
-      );
-      const totalDuration = uploadSessions.reduce(
-        (sum, session) => sum + session.durationSeconds,
-        0
-      );
-      const totalMsgs = uploadSessions.reduce(
-        (sum, session) => sum + session.messageCount,
-        0
-      );
-      logger.info(
-        `  active: ${formatTime(totalActive)} / total: ${formatTime(totalDuration)}, ${totalMsgs} messages`
-      );
-    }
     if (!quiet) {
       logger.info(`
 View your dashboard at: ${apiUrl}/usage`);
     }
+    persistUploadManifest(uploadDiff.nextManifest, quiet);
     markSyncSucceeded(source, {
       buckets: totalIngested,
       sessions: totalSessionsSynced
@@ -2016,64 +2644,17 @@ View your dashboard at: ${apiUrl}/usage`);
   process.exit(1);
 }
 
-// src/commands/daemon.ts
-var DEFAULT_INTERVAL = 5 * 6e4;
-function log(msg) {
-  const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
-  process.stdout.write(`[${ts}] ${msg}
-`);
-}
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function runDaemon(opts = {}) {
-  const config = loadConfig();
-  if (!config?.apiKey) {
-    logger.error("Not configured. Run `tokenarena init` first.");
-    process.exit(1);
-  }
-  const interval = opts.interval || config.syncInterval || DEFAULT_INTERVAL;
-  const intervalMin = Math.round(interval / 6e4);
-  log(`Daemon started (sync every ${intervalMin}m, Ctrl+C to stop)`);
-  while (true) {
-    try {
-      await runSync(config, {
-        quiet: true,
-        source: "daemon",
-        throws: true
-      });
-    } catch (err) {
-      if (err.message === "UNAUTHORIZED") {
-        log("API key invalid. Exiting.");
-        process.exit(1);
-      }
-      log(`Sync error: ${err.message}`);
-    }
-    await sleep(interval);
-  }
-}
-
 // src/commands/init.ts
 import { execFileSync as execFileSync2, spawn } from "child_process";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } 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 { createInterface } from "readline";
 function joinForPlatform(currentPlatform, ...parts) {
   return currentPlatform === "win32" ? win32.join(...parts) : posix.join(...parts);
 }
-function prompt(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve2(answer.trim());
-    });
-  });
-}
-function basenameLikeShell(input) {
-  return input.split(/[\\/]+/).pop()?.replace(/\.exe$/i, "") ?? input;
+function basenameLikeShell(input2) {
+  return input2.split(/[\\/]+/).pop()?.replace(/\.exe$/i, "") ?? input2;
 }
 function getBrowserLaunchCommand(url, currentPlatform = platform()) {
   switch (currentPlatform) {
@@ -2142,7 +2723,7 @@ function resolveShellAliasSetup(options = {}) {
   const currentPlatform = options.currentPlatform ?? platform();
   const env = options.env ?? process.env;
   const homeDir = options.homeDir ?? homedir8();
-  const pathExists = options.exists ?? existsSync11;
+  const pathExists = options.exists ?? existsSync12;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
   const aliasName = "ta";
@@ -2210,43 +2791,62 @@ function resolveShellAliasSetup(options = {}) {
   }
 }
 async function runInit(opts = {}) {
-  logger.info("\n  tokenarena - Token Usage Tracker\n");
+  logger.info(formatHeader("TokenArena \u521D\u59CB\u5316"));
   const existing = loadConfig();
   if (existing?.apiKey) {
-    const answer = await prompt("Config already exists. Overwrite? (y/N) ");
-    if (answer.toLowerCase() !== "y") {
-      logger.info("Cancelled.");
+    logger.info(formatSection("\u68C0\u6D4B\u5230\u5DF2\u6709\u914D\u7F6E"));
+    logger.info(formatKeyValue("\u5F53\u524D API Key", maskSecret(existing.apiKey)));
+    logger.info(
+      formatKeyValue(
+        "\u5F53\u524D API \u5730\u5740",
+        existing.apiUrl || "https://token.poco-ai.com"
+      )
+    );
+    const shouldOverwrite = await promptConfirm({
+      message: "\u5DF2\u7ECF\u5B58\u5728\u672C\u5730\u914D\u7F6E\uFF0C\u662F\u5426\u8986\u76D6\u5E76\u91CD\u65B0\u521D\u59CB\u5316\uFF1F",
+      defaultValue: false
+    });
+    if (!shouldOverwrite) {
+      logger.info(formatBullet("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316\u3002", "warning"));
       return;
     }
   }
   const apiUrl = opts.apiUrl || getDefaultApiUrl();
-  logger.info(`Open ${apiUrl}/usage and create your API key from Settings.
-`);
-  openBrowser(`${apiUrl}/usage`);
-  let apiKey;
-  while (true) {
-    apiKey = await prompt("Paste your API key: ");
-    if (validateApiKey(apiKey)) break;
-    logger.info('Invalid key - must start with "ta_". Try again.');
-  }
-  logger.info(`
-Verifying key ${apiKey.slice(0, 8)}...`);
+  const cliKeysUrl = `${apiUrl}/zh/settings/cli-keys`;
+  logger.info(formatSection("\u7B2C 1 \u6B65\uFF1A\u51C6\u5907 API Key"));
+  logger.info(formatBullet("\u6D4F\u89C8\u5668\u5C06\u5C1D\u8BD5\u81EA\u52A8\u6253\u5F00 CLI Key \u9875\u9762\u3002"));
+  logger.info(formatKeyValue("Key \u9875\u9762", formatMutedPath(cliKeysUrl)));
+  openBrowser(cliKeysUrl);
+  const apiKey = await promptPassword({
+    message: "\u8BF7\u7C98\u8D34\u4F60\u7684 CLI API Key",
+    validate: (value) => validateApiKey(value) || 'API Key \u5FC5\u987B\u4EE5 "ta_" \u5F00\u5934\u3002'
+  });
+  logger.info(formatSection("\u7B2C 2 \u6B65\uFF1A\u9A8C\u8BC1 API Key"));
+  logger.info(formatKeyValue("\u5F85\u9A8C\u8BC1 Key", maskSecret(apiKey)));
   try {
     const client = new ApiClient(apiUrl, apiKey);
     const settings = await client.fetchSettings();
     if (!settings) {
       logger.info(
-        "Could not verify key settings (network error). Saving anyway.\n"
+        formatBullet(
+          "\u65E0\u6CD5\u5728\u7EBF\u9A8C\u8BC1 Key\uFF08\u53EF\u80FD\u662F\u7F51\u7EDC\u539F\u56E0\uFF09\uFF0C\u5C06\u7EE7\u7EED\u4FDD\u5B58\u3002",
+          "warning"
+        )
       );
     } else {
-      logger.info("Key verified.\n");
+      logger.info(formatBullet("API Key \u9A8C\u8BC1\u6210\u529F\u3002", "success"));
     }
   } catch (err) {
     if (err.message === "UNAUTHORIZED") {
       logger.error("Invalid API key. Please check and try again.");
       process.exit(1);
     }
-    logger.info("Could not verify key (network error). Saving anyway.\n");
+    logger.info(
+      formatBullet(
+        "\u65E0\u6CD5\u5B8C\u6210\u5728\u7EBF\u9A8C\u8BC1\uFF08\u53EF\u80FD\u662F\u7F51\u7EDC\u539F\u56E0\uFF09\uFF0C\u5C06\u7EE7\u7EED\u4FDD\u5B58\u3002",
+        "warning"
+      )
+    );
   }
   const config = {
     apiKey,
@@ -2256,17 +2856,28 @@ Verifying key ${apiKey.slice(0, 8)}...`);
   saveConfig(config);
   const deviceId = getOrCreateDeviceId(config);
   config.deviceId = deviceId;
-  logger.info(`Device registered: ${deviceId.slice(0, 8)}...`);
+  logger.info(formatSection("\u7B2C 3 \u6B65\uFF1A\u5B8C\u6210\u672C\u5730\u6CE8\u518C"));
   const tools = getDetectedTools();
   if (tools.length > 0) {
-    logger.info(`Detected tools: ${tools.map((tool) => tool.name).join(", ")}`);
+    logger.info(formatSection("\u68C0\u6D4B\u5230\u7684 AI CLI"));
+    for (const tool of tools) {
+      logger.info(formatBullet(tool.name, "success"));
+    }
   } else {
-    logger.info("No AI coding tools detected. Install one and re-run init.");
+    logger.info(formatSection("\u68C0\u6D4B\u5230\u7684 AI CLI"));
+    logger.info(
+      formatBullet(
+        "\u5F53\u524D\u672A\u68C0\u6D4B\u5230\u5DF2\u5B89\u88C5\u5DE5\u5177\uFF0C\u7A0D\u540E\u5B89\u88C5\u540E\u4E5F\u53EF\u4EE5\u76F4\u63A5\u6267\u884C sync\u3002",
+        "warning"
+      )
+    );
   }
-  logger.info("\nRunning initial sync...");
+  logger.info(formatSection("\u9996\u6B21\u540C\u6B65"));
+  logger.info(formatBullet("\u6B63\u5728\u4E0A\u4F20\u672C\u5730\u5DF2\u6709\u7684\u4F7F\u7528\u6570\u636E\u3002"));
   await runSync(config, { source: "init" });
-  logger.info(`
-Setup complete! View your dashboard at: ${apiUrl}/usage`);
+  logger.info(formatSection("\u521D\u59CB\u5316\u5B8C\u6210"));
+  logger.info(formatBullet("TokenArena \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002", "success"));
+  logger.info(formatKeyValue("\u63A7\u5236\u53F0", `${apiUrl}/usage`));
   await setupShellAlias();
 }
 async function setupShellAlias() {
@@ -2274,17 +2885,18 @@ async function setupShellAlias() {
   if (!setup) {
     return;
   }
-  const answer = await prompt(
-    `
-Set up ${setup.shellLabel} alias 'ta' for 'tokenarena'? (Y/n) `
-  );
-  if (answer.toLowerCase() === "n") {
+  const shouldCreateAlias = await promptConfirm({
+    message: `\u662F\u5426\u4E3A ${setup.shellLabel} \u81EA\u52A8\u6DFB\u52A0 ta \u522B\u540D\uFF1F`,
+    defaultValue: true
+  });
+  if (!shouldCreateAlias) {
+    logger.info(formatBullet("\u5DF2\u8DF3\u8FC7 shell alias \u8BBE\u7F6E\u3002"));
     return;
   }
   try {
     await mkdir(dirname2(setup.configFile), { recursive: true });
     let existingContent = "";
-    if (existsSync11(setup.configFile)) {
+    if (existsSync12(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
     }
     const normalizedContent = existingContent.toLowerCase();
@@ -2292,10 +2904,7 @@ Set up ${setup.shellLabel} alias 'ta' for 'tokenarena'? (Y/n) `
       (pattern) => normalizedContent.includes(pattern.toLowerCase())
     );
     if (aliasExists) {
-      logger.info(
-        `
-Alias 'ta' already exists in ${setup.configFile}. Skipping.`
-      );
+      logger.info(formatBullet(`\u522B\u540D ta \u5DF2\u5B58\u5728\uFF1A${setup.configFile}`));
       return;
     }
     const aliasWithComment = `
@@ -2303,18 +2912,76 @@ Alias 'ta' already exists in ${setup.configFile}. Skipping.`
 ${setup.aliasLine}
 `;
     await appendFile(setup.configFile, aliasWithComment, "utf-8");
-    logger.info(`
-Added alias to ${setup.configFile}`);
+    logger.info(formatSection("Shell alias"));
+    logger.info(formatBullet(`\u5DF2\u5199\u5165 ${setup.configFile}`, "success"));
     logger.info(
-      `  Run '${setup.sourceHint}' or restart your terminal to use it.`
+      formatKeyValue("\u751F\u6548\u65B9\u5F0F", `\u6267\u884C '${setup.sourceHint}' \u6216\u91CD\u542F\u7EC8\u7AEF`)
     );
-    logger.info("  Then you can use: ta sync");
+    logger.info(formatKeyValue("\u4E4B\u540E\u53EF\u7528", "ta sync"));
   } catch (err) {
+    logger.info(formatSection("Shell alias"));
     logger.info(
-      `
-Could not write to ${setup.configFile}: ${err.message}`
+      formatBullet(
+        `\u65E0\u6CD5\u5199\u5165 ${setup.configFile}: ${err.message}`,
+        "warning"
+      )
     );
-    logger.info(`  Add this line manually: ${setup.aliasLine}`);
+    logger.info(formatKeyValue("\u8BF7\u624B\u52A8\u6DFB\u52A0", setup.aliasLine));
+  }
+}
+
+// src/commands/daemon.ts
+var DEFAULT_INTERVAL = 5 * 6e4;
+function log(msg) {
+  const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+  process.stdout.write(`[${ts}] ${msg}
+`);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function runDaemon(opts = {}) {
+  const config = loadConfig();
+  if (!config?.apiKey) {
+    if (isInteractiveTerminal()) {
+      logger.info(
+        formatHeader(
+          "\u5C1A\u672A\u5B8C\u6210\u521D\u59CB\u5316",
+          "\u542F\u52A8 daemon \u524D\u9700\u8981\u5148\u914D\u7F6E\u6709\u6548\u7684 API Key\u3002"
+        )
+      );
+      const shouldInit = await promptConfirm({
+        message: "\u662F\u5426\u5148\u8FDB\u5165\u521D\u59CB\u5316\u6D41\u7A0B\uFF1F",
+        defaultValue: true
+      });
+      if (shouldInit) {
+        await runInit();
+        return;
+      }
+      logger.info(formatBullet("\u5DF2\u53D6\u6D88\u542F\u52A8 daemon\u3002", "warning"));
+      return;
+    }
+    logger.error("Not configured. Run `tokenarena init` first.");
+    process.exit(1);
+  }
+  const interval = opts.interval || config.syncInterval || DEFAULT_INTERVAL;
+  const intervalMin = Math.round(interval / 6e4);
+  log(`Daemon started (sync every ${intervalMin}m, Ctrl+C to stop)`);
+  while (true) {
+    try {
+      await runSync(config, {
+        quiet: true,
+        source: "daemon",
+        throws: true
+      });
+    } catch (err) {
+      if (err.message === "UNAUTHORIZED") {
+        log("API key invalid. Exiting.");
+        process.exit(1);
+      }
+      log(`Sync error: ${err.message}`);
+    }
+    await sleep(interval);
   }
 }
 
@@ -2324,58 +2991,94 @@ function formatMaybe(value) {
 }
 async function runStatus() {
   const config = loadConfig();
-  logger.info("\ntokenarena status\n");
+  logger.info(
+    formatHeader(
+      "TokenArena \u72B6\u6001",
+      "\u67E5\u770B\u5F53\u524D\u914D\u7F6E\u3001\u5DF2\u68C0\u6D4B\u5DE5\u5177\u4EE5\u53CA\u6700\u8FD1\u4E00\u6B21\u540C\u6B65\u60C5\u51B5\u3002"
+    )
+  );
+  logger.info(formatSection("\u914D\u7F6E"));
   if (!config?.apiKey) {
-    logger.info("  Config: not configured");
-    logger.info("  Run `tokenarena init` to set up.\n");
+    logger.info(formatKeyValue("\u72B6\u6001", formatStatusBadge("\u672A\u914D\u7F6E", "warning")));
+    logger.info(formatBullet("\u8FD0\u884C tokenarena init \u5B8C\u6210\u9996\u6B21\u8BBE\u7F6E\u3002", "warning"));
   } else {
-    logger.info(`  Config: ${getConfigPath()}`);
-    logger.info(`  API key: ${config.apiKey.slice(0, 8)}...`);
-    logger.info(`  API URL: ${config.apiUrl || "http://localhost:3000"}`);
+    logger.info(formatKeyValue("\u72B6\u6001", formatStatusBadge("\u5DF2\u914D\u7F6E", "success")));
+    logger.info(formatKeyValue("\u914D\u7F6E\u6587\u4EF6", getConfigPath()));
+    logger.info(formatKeyValue("API Key", maskSecret(config.apiKey)));
+    logger.info(
+      formatKeyValue("API URL", config.apiUrl || "https://token.poco-ai.com")
+    );
     if (config.syncInterval) {
       logger.info(
-        `  Sync interval: ${Math.round(config.syncInterval / 6e4)}m`
+        formatKeyValue(
+          "\u540C\u6B65\u95F4\u9694",
+          `${Math.round(config.syncInterval / 6e4)} \u5206\u949F`
+        )
       );
     }
   }
-  logger.info("\n  Detected tools:");
+  logger.info(formatSection("\u5DF2\u68C0\u6D4B\u5DE5\u5177"));
   const detected = detectInstalledTools();
   if (detected.length === 0) {
-    logger.info("    (none)\n");
+    logger.info(formatBullet("\u672A\u68C0\u6D4B\u5230\u5DF2\u5B89\u88C5\u7684 AI CLI\u3002", "warning"));
   } else {
     for (const tool of detected) {
-      logger.info(`    ${tool.name}`);
+      logger.info(formatBullet(tool.name, "success"));
     }
-    logger.info("");
   }
-  logger.info("  All supported tools:");
+  logger.info(formatSection("\u652F\u6301\u7684\u5DE5\u5177"));
   for (const tool of getAllTools()) {
-    const installed = isToolInstalled(tool.id) ? "installed" : "not found";
-    logger.info(`    ${tool.name}: ${installed}`);
+    const installed = isToolInstalled(tool.id);
+    logger.info(
+      formatBullet(
+        `${tool.name} \xB7 ${installed ? "\u5DF2\u5B89\u88C5" : "\u672A\u53D1\u73B0"}`,
+        installed ? "success" : "neutral"
+      )
+    );
   }
   const syncState = loadSyncState();
-  logger.info("\n  Sync state:");
-  logger.info(`    Status: ${syncState.status}`);
-  logger.info(`    Last attempt: ${formatMaybe(syncState.lastAttemptAt)}`);
-  logger.info(`    Last success: ${formatMaybe(syncState.lastSuccessAt)}`);
+  logger.info(formatSection("\u540C\u6B65\u72B6\u6001"));
+  const statusTone = syncState.status === "idle" ? "success" : syncState.status === "syncing" ? "warning" : "danger";
+  logger.info(
+    formatKeyValue("\u72B6\u6001", formatStatusBadge(syncState.status, statusTone))
+  );
+  logger.info(formatKeyValue("\u4E0A\u6B21\u5C1D\u8BD5", formatMaybe(syncState.lastAttemptAt)));
+  logger.info(formatKeyValue("\u4E0A\u6B21\u6210\u529F", formatMaybe(syncState.lastSuccessAt)));
   if (syncState.lastSource) {
-    logger.info(`    Last source: ${syncState.lastSource}`);
+    logger.info(formatKeyValue("\u89E6\u53D1\u6765\u6E90", syncState.lastSource));
   }
   if (syncState.lastError) {
-    logger.info(`    Last error: ${syncState.lastError}`);
+    logger.info(formatKeyValue("\u9519\u8BEF\u4FE1\u606F", syncState.lastError));
   }
   if (syncState.lastResult) {
     logger.info(
-      `    Last result: ${syncState.lastResult.buckets} buckets, ${syncState.lastResult.sessions} sessions`
+      formatKeyValue(
+        "\u6700\u8FD1\u7ED3\u679C",
+        `${syncState.lastResult.buckets} buckets, ${syncState.lastResult.sessions} sessions`
+      )
     );
   }
-  logger.info("");
 }
 
 // src/commands/sync.ts
 async function runSyncCommand(opts = {}) {
   const config = loadConfig();
   if (!config?.apiKey) {
+    if (isInteractiveTerminal()) {
+      logger.info(
+        formatHeader("\u5C1A\u672A\u5B8C\u6210\u521D\u59CB\u5316", "\u540C\u6B65\u524D\u9700\u8981\u5148\u914D\u7F6E\u6709\u6548\u7684 API Key\u3002")
+      );
+      const shouldInit = await promptConfirm({
+        message: "\u662F\u5426\u73B0\u5728\u8FDB\u5165\u521D\u59CB\u5316\u6D41\u7A0B\uFF1F",
+        defaultValue: true
+      });
+      if (shouldInit) {
+        await runInit();
+        return;
+      }
+      logger.info(formatBullet("\u5DF2\u53D6\u6D88\u540C\u6B65\u3002", "warning"));
+      return;
+    }
     logger.error("Not configured. Run `tokenarena init` first.");
     process.exit(1);
   }
@@ -2386,18 +3089,8 @@ async function runSyncCommand(opts = {}) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+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 { createInterface as createInterface2 } from "readline";
-function prompt2(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve2(answer.trim());
-    });
-  });
-}
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -2409,7 +3102,7 @@ function removeShellAlias() {
       configFile = `${homedir9()}/.zshrc`;
       break;
     case "bash":
-      if (platform2() === "darwin" && existsSync12(`${homedir9()}/.bash_profile`)) {
+      if (platform2() === "darwin" && existsSync13(`${homedir9()}/.bash_profile`)) {
         configFile = `${homedir9()}/.bash_profile`;
       } else {
         configFile = `${homedir9()}/.bashrc`;
@@ -2421,9 +3114,9 @@ function removeShellAlias() {
     default:
       return;
   }
-  if (!existsSync12(configFile)) return;
+  if (!existsSync13(configFile)) return;
   try {
-    let content = readFileSync9(configFile, "utf-8");
+    let content = readFileSync10(configFile, "utf-8");
     const aliasPatterns = [
       // zsh / bash format: alias ta="tokenarena"
       new RegExp(
@@ -2445,7 +3138,7 @@ function removeShellAlias() {
         content = next;
       }
     }
-    writeFileSync4(configFile, content, "utf-8");
+    writeFileSync5(configFile, content, "utf-8");
     logger.info(`Removed shell alias from ${configFile}`);
   } catch (err) {
     logger.warn(
@@ -2456,47 +3149,173 @@ function removeShellAlias() {
 async function runUninstall() {
   const configPath = getConfigPath();
   const configDir = getConfigDir();
-  if (!existsSync12(configPath)) {
-    logger.info("No configuration found. Nothing to uninstall.");
+  if (!existsSync13(configPath)) {
+    logger.info(formatHeader("\u5378\u8F7D TokenArena"));
+    logger.info(formatBullet("\u672A\u53D1\u73B0\u672C\u5730\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D\u3002"));
     return;
   }
   const config = loadConfig();
-  if (config?.apiKey) {
-    logger.info(`API key: ${config.apiKey.slice(0, 8)}...`);
-  }
-  logger.info(`Config directory: ${configDir}`);
-  const answer = await prompt2(
-    "\nAre you sure you want to uninstall? This will delete all local data. (y/N) "
+  logger.info(
+    formatHeader(
+      "\u5378\u8F7D TokenArena",
+      "\u8BE5\u64CD\u4F5C\u4F1A\u5220\u9664\u672C\u5730\u914D\u7F6E\u3001\u540C\u6B65\u72B6\u6001\u4E0E\u8FD0\u884C\u65F6\u6587\u4EF6\u3002"
+    )
   );
-  if (answer.toLowerCase() !== "y") {
-    logger.info("Cancelled.");
+  if (config?.apiKey) {
+    logger.info(formatKeyValue("API Key", maskSecret(config.apiKey)));
+  }
+  logger.info(formatKeyValue("\u914D\u7F6E\u76EE\u5F55", configDir));
+  logger.info(formatKeyValue("\u72B6\u6001\u76EE\u5F55", getStateDir()));
+  logger.info(formatKeyValue("\u8FD0\u884C\u76EE\u5F55", getRuntimeDirPath()));
+  const shouldUninstall = await promptConfirm({
+    message: "\u786E\u8BA4\u7EE7\u7EED\u5378\u8F7D\u672C\u5730 TokenArena \u6570\u636E\uFF1F",
+    defaultValue: false
+  });
+  if (!shouldUninstall) {
+    logger.info(formatBullet("\u5DF2\u53D6\u6D88\u5378\u8F7D\u3002", "warning"));
     return;
   }
   deleteConfig();
-  logger.info("Deleted configuration file.");
-  if (existsSync12(configDir)) {
+  logger.info(formatSection("\u6267\u884C\u7ED3\u679C"));
+  logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
+  if (existsSync13(configDir)) {
     try {
       rmSync2(configDir, { recursive: false, force: true });
-      logger.info("Deleted config directory.");
+      logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u76EE\u5F55\u3002", "success"));
     } catch {
     }
   }
   const stateDir = getStateDir();
-  if (existsSync12(stateDir)) {
+  if (existsSync13(stateDir)) {
     rmSync2(stateDir, { recursive: true, force: true });
-    logger.info("Deleted state data.");
+    logger.info(formatBullet("\u5DF2\u5220\u9664\u72B6\u6001\u6570\u636E\u3002", "success"));
   }
   const runtimeDir = getRuntimeDirPath();
-  if (existsSync12(runtimeDir)) {
+  if (existsSync13(runtimeDir)) {
     rmSync2(runtimeDir, { recursive: true, force: true });
-    logger.info("Deleted runtime data.");
+    logger.info(formatBullet("\u5DF2\u5220\u9664\u8FD0\u884C\u65F6\u6570\u636E\u3002", "success"));
   }
   removeShellAlias();
-  logger.info("\nTokenArena has been uninstalled successfully.");
+  logger.info(formatSection("\u5B8C\u6210"));
+  logger.info(formatBullet("TokenArena \u5DF2\u4ECE\u672C\u5730\u5378\u8F7D\u5B8C\u6210\u3002", "success"));
+}
+
+// src/commands/home.ts
+function logHomeSummary() {
+  const config = loadConfig();
+  const configured = Boolean(config?.apiKey);
+  logger.info(
+    formatHeader(
+      "TokenArena CLI",
+      "\u901A\u8FC7\u66F4\u53CB\u597D\u7684\u4EA4\u4E92\u5B8C\u6210\u521D\u59CB\u5316\u3001\u540C\u6B65\u3001\u914D\u7F6E\u4E0E\u6E05\u7406\u3002"
+    )
+  );
+  logger.info(
+    formatKeyValue(
+      "\u914D\u7F6E\u72B6\u6001",
+      configured ? formatStatusBadge("\u5DF2\u914D\u7F6E", "success") : formatStatusBadge("\u672A\u914D\u7F6E", "warning")
+    )
+  );
+  if (configured && config) {
+    logger.info(formatKeyValue("API Key", maskSecret(config.apiKey)));
+    logger.info(
+      formatKeyValue("API \u5730\u5740", config.apiUrl || "https://token.poco-ai.com")
+    );
+  } else {
+    logger.info(formatBullet("\u5EFA\u8BAE\u5148\u8FD0\u884C\u521D\u59CB\u5316\u6D41\u7A0B\u7ED1\u5B9A API Key\u3002", "warning"));
+  }
+}
+async function pickHomeAction() {
+  return promptSelect({
+    message: "\u8BF7\u9009\u62E9\u8981\u6267\u884C\u7684\u64CD\u4F5C",
+    choices: [
+      {
+        name: "\u521D\u59CB\u5316 TokenArena",
+        value: "init",
+        description: "\u914D\u7F6E API Key\u3001\u68C0\u6D4B\u5DE5\u5177\u5E76\u6267\u884C\u9996\u6B21\u540C\u6B65"
+      },
+      {
+        name: "\u67E5\u770B\u5F53\u524D\u72B6\u6001",
+        value: "status",
+        description: "\u67E5\u770B\u914D\u7F6E\u3001\u5DE5\u5177\u68C0\u6D4B\u7ED3\u679C\u4E0E\u6700\u8FD1\u540C\u6B65\u72B6\u6001"
+      },
+      {
+        name: "\u7ACB\u5373\u540C\u6B65",
+        value: "sync",
+        description: "\u624B\u52A8\u4E0A\u4F20\u672C\u5730\u6700\u65B0 token \u4F7F\u7528\u6570\u636E"
+      },
+      {
+        name: "\u7BA1\u7406\u914D\u7F6E",
+        value: "config",
+        description: "\u67E5\u770B\u6216\u4FEE\u6539 API Key\u3001API \u5730\u5740\u3001\u540C\u6B65\u95F4\u9694\u7B49\u914D\u7F6E"
+      },
+      {
+        name: "\u542F\u52A8\u5B88\u62A4\u540C\u6B65",
+        value: "daemon",
+        description: "\u6301\u7EED\u540E\u53F0\u540C\u6B65\uFF0C\u9002\u5408\u957F\u671F\u8FD0\u884C"
+      },
+      {
+        name: "\u5378\u8F7D\u672C\u5730\u914D\u7F6E",
+        value: "uninstall",
+        description: "\u5220\u9664\u672C\u5730\u914D\u7F6E\u3001\u72B6\u6001\u4E0E\u8FD0\u884C\u65F6\u6587\u4EF6"
+      },
+      {
+        name: "\u67E5\u770B\u5E2E\u52A9",
+        value: "help",
+        description: "\u5C55\u793A\u5B8C\u6574\u547D\u4EE4\u5E2E\u52A9"
+      },
+      {
+        name: "\u9000\u51FA",
+        value: "exit",
+        description: "\u7ED3\u675F\u5F53\u524D\u4EA4\u4E92"
+      }
+    ]
+  });
+}
+async function runHome(program) {
+  while (true) {
+    logHomeSummary();
+    const action = await pickHomeAction();
+    logger.info("");
+    switch (action) {
+      case "init":
+        await runInit();
+        break;
+      case "status":
+        await runStatus();
+        break;
+      case "sync":
+        await runSyncCommand();
+        break;
+      case "config":
+        await handleConfig([]);
+        break;
+      case "daemon":
+        await runDaemon();
+        return;
+      case "uninstall":
+        await runUninstall();
+        break;
+      case "help":
+        program.outputHelp();
+        break;
+      case "exit":
+        logger.info(formatBullet("\u5DF2\u9000\u51FA\u4EA4\u4E92\u5F0F\u4E3B\u9875\u3002", "neutral"));
+        return;
+    }
+    const continueAnswer = await promptConfirm({
+      message: "\u662F\u5426\u7EE7\u7EED\u6267\u884C\u5176\u4ED6\u64CD\u4F5C\uFF1F",
+      defaultValue: true
+    });
+    if (!continueAnswer) {
+      logger.info(formatBullet("\u4E0B\u6B21\u53EF\u76F4\u63A5\u8FD0\u884C tokenarena \u7EE7\u7EED\u3002", "neutral"));
+      return;
+    }
+  }
 }
 
 // src/infrastructure/runtime/cli-version.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import { dirname as dirname3, join as join12 } from "path";
 import { fileURLToPath } from "url";
 var FALLBACK_VERSION = "0.0.0";
@@ -2511,7 +3330,7 @@ function getCliVersion(metaUrl = import.meta.url) {
     "package.json"
   );
   try {
-    const packageJson = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
     cachedVersion = typeof packageJson.version === "string" ? packageJson.version : FALLBACK_VERSION;
   } catch {
     cachedVersion = FALLBACK_VERSION;
@@ -2524,11 +3343,15 @@ var CLI_VERSION = getCliVersion();
 function createCli() {
   const program = new Command();
   program.name("tokenarena").description("Track token burn across AI coding tools").version(CLI_VERSION).showHelpAfterError().showSuggestionAfterError().helpCommand("help [command]", "Display help for command");
-  program.action(() => {
+  program.action(async () => {
     const userArgs = process.argv.slice(2).filter((a) => !a.startsWith("-"));
     if (userArgs.length > 0) {
       program.error(`unknown command '${userArgs[0]}'`);
     }
+    if (isInteractiveTerminal()) {
+      await runHome(program);
+      return;
+    }
     program.help();
   });
   program.command("init").description("Initialize configuration with API key").option("--api-url <url>", "Custom API server URL").action(async (opts) => {
@@ -2543,9 +3366,12 @@ function createCli() {
   program.command("status").description("Show configuration and detected tools").action(async () => {
     await runStatus();
   });
-  program.command("config").description("Manage configuration").argument("<subcommand>", "get|set|show").argument("[key]", "Config key").argument("[value]", "Config value").allowUnknownOption(true).action((_subcommand, _key, _value, cmd) => {
-    const args = cmd.args.slice(1);
-    handleConfig(args);
+  program.command("config").description("Manage configuration").argument("[subcommand]", "get|set|show").argument("[key]", "Config key").argument("[value]", "Config value").allowUnknownOption(true).action(async (subcommand, key, value) => {
+    await handleConfig(
+      [subcommand, key, value].filter(
+        (item) => typeof item === "string"
+      )
+    );
   });
   program.command("uninstall").description("Remove all local configuration and data").action(async () => {
     await runUninstall();
@@ -2554,7 +3380,7 @@ function createCli() {
 }
 
 // src/infrastructure/runtime/main-module.ts
-import { existsSync as existsSync13, realpathSync } from "fs";
+import { existsSync as existsSync14, realpathSync } from "fs";
 import { resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
@@ -2565,7 +3391,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
   try {
     return realpathSync(argvEntry) === realpathSync(currentModulePath);
   } catch {
-    if (!existsSync13(argvEntry)) {
+    if (!existsSync14(argvEntry)) {
       return false;
     }
     return resolve(argvEntry) === resolve(currentModulePath);
@@ -2576,12 +3402,12 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
 function normalizeArgv(argv) {
   return argv.filter((arg, index) => index < 2 || arg !== "--");
 }
-function run(argv = process.argv) {
+async function run(argv = process.argv) {
   const program = createCli();
-  program.parse(normalizeArgv(argv));
+  await program.parseAsync(normalizeArgv(argv));
 }
 if (isMainModule()) {
-  run();
+  void run();
 }
 export {
   normalizeArgv,