@poco-ai/tokenarena 0.2.3 → 0.2.4

package/dist/index.js

@@ -1,21 +1,4 @@
 #!/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";
@@ -1830,6 +1813,150 @@ 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) {
@@ -2135,14 +2262,14 @@ 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)}`
@@ -2158,13 +2285,13 @@ function shortHash(value) {
 function normalizeApiUrl(apiUrl) {
   return apiUrl.replace(/\/+$/, "");
 }
-function buildUploadManifestScope(input) {
+function buildUploadManifestScope(input2) {
   return {
-    apiKeyHash: shortHash(input.apiKey),
-    apiUrl: normalizeApiUrl(input.apiUrl),
-    deviceId: input.deviceId,
-    projectHashSaltHash: shortHash(input.settings.projectHashSalt),
-    projectMode: input.settings.projectMode
+    apiKeyHash: shortHash(input2.apiKey),
+    apiUrl: normalizeApiUrl(input2.apiUrl),
+    deviceId: input2.deviceId,
+    projectHashSaltHash: shortHash(input2.settings.projectHashSalt),
+    projectMode: input2.settings.projectMode
   };
 }
 function describeUploadManifestScopeChanges(previous, current) {
@@ -2234,20 +2361,20 @@ function buildRecordHashes(items, getKey, getHash) {
   }
   return hashes;
 }
-function createUploadManifest(input) {
+function createUploadManifest(input2) {
   return {
     buckets: buildRecordHashes(
-      input.buckets,
+      input2.buckets,
       getUploadBucketManifestKey,
       getUploadBucketContentHash
     ),
-    scope: input.scope,
+    scope: input2.scope,
     sessions: buildRecordHashes(
-      input.sessions,
+      input2.sessions,
       getUploadSessionManifestKey,
       getUploadSessionContentHash
     ),
-    updatedAt: input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: input2.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     version: MANIFEST_VERSION
   };
 }
@@ -2260,21 +2387,21 @@ function countRemovedRecords(previous, current) {
   }
   return removed;
 }
-function diffUploadManifest(input) {
+function diffUploadManifest(input2) {
   const nextManifest = createUploadManifest({
-    buckets: input.buckets,
-    scope: input.scope,
-    sessions: input.sessions,
-    updatedAt: input.updatedAt
+    buckets: input2.buckets,
+    scope: input2.scope,
+    sessions: input2.sessions,
+    updatedAt: input2.updatedAt
   });
-  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 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 = input.sessions.filter((session) => {
+  const sessionsToUpload = input2.sessions.filter((session) => {
     const key = getUploadSessionManifestKey(session);
     return previousSessions[key] !== nextManifest.sessions[key];
   });
@@ -2288,8 +2415,8 @@ function diffUploadManifest(input) {
     ),
     scopeChangedReasons,
     sessionsToUpload,
-    unchangedBuckets: input.buckets.length - bucketsToUpload.length,
-    unchangedSessions: input.sessions.length - sessionsToUpload.length
+    unchangedBuckets: input2.buckets.length - bucketsToUpload.length,
+    unchangedSessions: input2.sessions.length - sessionsToUpload.length
   };
 }
 
@@ -3149,18 +3276,706 @@ View your dashboard at: ${apiUrl}/usage`);
 }
 
 // src/commands/init.ts
-import { execFileSync as execFileSync2, spawn } from "child_process";
-import { existsSync as existsSync16 } from "fs";
+import { execFileSync as execFileSync4, spawn } from "child_process";
+import { existsSync as existsSync18 } from "fs";
 import { appendFile, mkdir, readFile } from "fs/promises";
+import { homedir as homedir14, platform as platform4 } from "os";
+import { dirname as dirname3, join as join17, posix, win32 } from "path";
+
+// src/infrastructure/service/index.ts
+import { platform as platform3 } from "os";
+
+// src/infrastructure/service/linux-systemd.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync16, mkdirSync as mkdirSync3, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir12, platform } from "os";
-import { dirname as dirname3, join as join15, posix, win32 } from "path";
+import { join as join15 } from "path";
+
+// src/utils/command.ts
+import { execSync } from "child_process";
+function isCommandAvailable(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/infrastructure/service/utils.ts
+var SERVICE_PATH_FALLBACKS = [
+  "/opt/homebrew/bin",
+  "/usr/local/bin",
+  "/usr/bin",
+  "/bin",
+  "/usr/sbin",
+  "/sbin"
+];
+var SERVICE_ENV_KEYS = [
+  "TOKEN_ARENA_DEV",
+  "XDG_CONFIG_HOME",
+  "XDG_STATE_HOME",
+  "XDG_RUNTIME_DIR"
+];
+function dedupePaths(paths) {
+  return [...new Set(paths.filter(Boolean))];
+}
+function getManagedServiceEnvironment(env = process.env) {
+  const pathEntries = dedupePaths([
+    ...env.PATH?.split(":") ?? [],
+    ...SERVICE_PATH_FALLBACKS
+  ]);
+  const next = {
+    PATH: pathEntries.join(":")
+  };
+  for (const key of SERVICE_ENV_KEYS) {
+    const value = env[key];
+    if (value) {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+function resolveManagedDaemonCommand(execPath = process.execPath, argv = process.argv) {
+  const scriptPath = argv[1];
+  if (!scriptPath) {
+    throw new Error("\u65E0\u6CD5\u89E3\u6790 CLI \u5165\u53E3\u8DEF\u5F84\uFF0C\u8BF7\u901A\u8FC7 tokenarena \u547D\u4EE4\u91CD\u65B0\u6267\u884C\u3002");
+  }
+  return {
+    execPath,
+    args: [scriptPath, "daemon", "--service"]
+  };
+}
+function escapeDoubleQuotedValue(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+
+// src/infrastructure/service/linux-systemd.ts
+var SYSTEMD_SERVICE_NAME = "tokenarena";
+function getLinuxSystemdServiceDir(homePath = homedir12()) {
+  return join15(homePath, ".config/systemd/user");
+}
+function getLinuxSystemdServiceFile(homePath = homedir12()) {
+  return join15(
+    getLinuxSystemdServiceDir(homePath),
+    `${SYSTEMD_SERVICE_NAME}.service`
+  );
+}
+function buildSystemdServiceContent(options) {
+  const envLines = Object.entries(options.environment).map(
+    ([key, value]) => `Environment="${escapeDoubleQuotedValue(key)}=${escapeDoubleQuotedValue(value)}"`
+  ).join("\n");
+  const execArgs = [options.execPath, ...options.args].map((value) => `"${escapeDoubleQuotedValue(value)}"`).join(" ");
+  return `[Unit]
+Description=TokenArena Daemon - AI Usage Tracker
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execArgs}
+Restart=on-failure
+RestartSec=10
+${envLines}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function getSystemdSupport() {
+  if (platform() !== "linux") {
+    return {
+      ok: false,
+      reason: "systemd \u4EC5\u5728 Linux \u4E0A\u53EF\u7528\u3002"
+    };
+  }
+  if (!isCommandAvailable("systemctl")) {
+    return {
+      ok: false,
+      reason: "\u672A\u68C0\u6D4B\u5230 systemctl\u3002"
+    };
+  }
+  return { ok: true };
+}
+function execSystemctl(args) {
+  execFileSync2("systemctl", ["--user", ...args], {
+    stdio: "inherit"
+  });
+}
+function ensureSystemdAvailable() {
+  const support = getSystemdSupport();
+  if (support.ok) {
+    return true;
+  }
+  logger.info(formatBullet(`systemd \u4E0D\u53EF\u7528\u3002${support.reason}`, "warning"));
+  return false;
+}
+function createLinuxSystemdServiceBackend() {
+  function isInstalled() {
+    return existsSync16(getLinuxSystemdServiceFile());
+  }
+  async function setup(skipPrompt = false) {
+    if (!ensureSystemdAvailable()) {
+      return;
+    }
+    const serviceDir = getLinuxSystemdServiceDir();
+    const serviceFile = getLinuxSystemdServiceFile();
+    logger.info(formatHeader("\u8BBE\u7F6E systemd \u670D\u52A1", "TokenArena daemon"));
+    if (!skipPrompt) {
+      const shouldSetup = await promptConfirm({
+        message: "\u662F\u5426\u521B\u5EFA\u5E76\u542F\u7528 systemd \u7528\u6237\u670D\u52A1\uFF1F",
+        defaultValue: true
+      });
+      if (!shouldSetup) {
+        logger.info(formatBullet("\u5DF2\u53D6\u6D88\u670D\u52A1\u8BBE\u7F6E\u3002"));
+        return;
+      }
+    }
+    try {
+      const command = resolveManagedDaemonCommand();
+      const content = buildSystemdServiceContent({
+        environment: getManagedServiceEnvironment(),
+        execPath: command.execPath,
+        args: command.args
+      });
+      mkdirSync3(serviceDir, { recursive: true });
+      writeFileSync5(serviceFile, content, "utf-8");
+      execSystemctl(["daemon-reload"]);
+      execSystemctl(["enable", SYSTEMD_SERVICE_NAME]);
+      execSystemctl(["start", SYSTEMD_SERVICE_NAME]);
+      logger.info(formatSection("\u670D\u52A1\u5DF2\u8BBE\u7F6E"));
+      logger.info(formatBullet(`\u670D\u52A1\u6587\u4EF6: ${serviceFile}`, "success"));
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u542F\u7528\u5E76\u542F\u52A8", "success"));
+      logger.info(
+        formatKeyValue("\u67E5\u770B\u72B6\u6001", "systemctl --user status tokenarena")
+      );
+    } catch (err) {
+      logger.error(`\u8BBE\u7F6E\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function start() {
+    if (!ensureSystemdAvailable()) {
+      return;
+    }
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    try {
+      execSystemctl(["start", SYSTEMD_SERVICE_NAME]);
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u542F\u52A8", "success"));
+    } catch (err) {
+      logger.error(`\u542F\u52A8\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function stop() {
+    if (!ensureSystemdAvailable()) {
+      return;
+    }
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    try {
+      execSystemctl(["stop", SYSTEMD_SERVICE_NAME]);
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u505C\u6B62", "success"));
+    } catch (err) {
+      logger.error(`\u505C\u6B62\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function restart() {
+    if (!ensureSystemdAvailable()) {
+      return;
+    }
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    try {
+      execSystemctl(["restart", SYSTEMD_SERVICE_NAME]);
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u91CD\u542F", "success"));
+    } catch (err) {
+      logger.error(`\u91CD\u542F\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function status() {
+    if (!ensureSystemdAvailable()) {
+      return;
+    }
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    try {
+      execSystemctl(["status", SYSTEMD_SERVICE_NAME]);
+    } catch {
+    }
+  }
+  async function uninstall(skipPrompt = false) {
+    const serviceFile = getLinuxSystemdServiceFile();
+    if (!existsSync16(serviceFile)) {
+      logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
+      return;
+    }
+    if (!skipPrompt) {
+      const shouldUninstall = await promptConfirm({
+        message: "\u662F\u5426\u5378\u8F7D systemd \u670D\u52A1\uFF1F",
+        defaultValue: false
+      });
+      if (!shouldUninstall) {
+        logger.info(formatBullet("\u5DF2\u53D6\u6D88\u5378\u8F7D\u3002"));
+        return;
+      }
+    }
+    const support = getSystemdSupport();
+    if (support.ok) {
+      try {
+        execSystemctl(["stop", SYSTEMD_SERVICE_NAME]);
+      } catch {
+      }
+      try {
+        execSystemctl(["disable", SYSTEMD_SERVICE_NAME]);
+      } catch {
+      }
+    } else {
+      logger.info(
+        formatBullet(
+          `\u5F53\u524D\u65E0\u6CD5\u8BBF\u95EE systemd\uFF0C\u5C06\u53EA\u5220\u9664\u670D\u52A1\u6587\u4EF6\u3002${support.reason}`,
+          "warning"
+        )
+      );
+    }
+    try {
+      rmSync2(serviceFile);
+      if (support.ok) {
+        execSystemctl(["daemon-reload"]);
+      }
+      logger.info(formatSection("\u670D\u52A1\u5DF2\u5378\u8F7D"));
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u505C\u7528\u5E76\u5220\u9664", "success"));
+    } catch (err) {
+      logger.error(`\u5378\u8F7D\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  return {
+    displayName: "systemd \u7528\u6237\u670D\u52A1",
+    canSetup: getSystemdSupport,
+    isInstalled,
+    getDefinitionPath: getLinuxSystemdServiceFile,
+    getStatusHint: () => "systemctl --user status tokenarena",
+    setup,
+    start,
+    stop,
+    restart,
+    status,
+    uninstall
+  };
+}
+
+// src/infrastructure/service/macos-launchd.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync17, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir13, platform as platform2 } from "os";
+import { join as join16 } from "path";
+var MACOS_LAUNCHD_LABEL = "com.poco-ai.tokenarena";
+function getCurrentUid() {
+  return typeof process.getuid === "function" ? process.getuid() : null;
+}
+function getMacosLaunchAgentDir(homePath = homedir13()) {
+  return join16(homePath, "Library/LaunchAgents");
+}
+function getMacosLaunchAgentFile(homePath = homedir13()) {
+  return join16(getMacosLaunchAgentDir(homePath), `${MACOS_LAUNCHD_LABEL}.plist`);
+}
+function getMacosLaunchdDomain(uid = getCurrentUid()) {
+  if (uid == null) {
+    throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5F53\u524D\u7528\u6237 UID\u3002");
+  }
+  return `gui/${uid}`;
+}
+function getMacosLaunchdServiceTarget(uid = getCurrentUid()) {
+  return `${getMacosLaunchdDomain(uid)}/${MACOS_LAUNCHD_LABEL}`;
+}
+function getMacosLaunchdLogPaths(stateDir = getStateDir()) {
+  return {
+    stdoutPath: join16(stateDir, "launchd.stdout.log"),
+    stderrPath: join16(stateDir, "launchd.stderr.log")
+  };
+}
+function renderPlistArray(values) {
+  return values.map((value) => `      <string>${escapeXml(value)}</string>`).join("\n");
+}
+function renderPlistDict(entries) {
+  return Object.entries(entries).map(
+    ([key, value]) => `      <key>${escapeXml(key)}</key>
+      <string>${escapeXml(value)}</string>`
+  ).join("\n");
+}
+function buildLaunchdPlist(options) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>${escapeXml(options.label)}</string>
+    <key>ProgramArguments</key>
+    <array>
+${renderPlistArray(options.programArguments)}
+    </array>
+    <key>WorkingDirectory</key>
+    <string>${escapeXml(options.workingDirectory)}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+${renderPlistDict(options.environment)}
+    </dict>
+    <key>KeepAlive</key>
+    <dict>
+      <key>SuccessfulExit</key>
+      <false/>
+    </dict>
+    <key>ProcessType</key>
+    <string>Background</string>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+    <key>ExitTimeOut</key>
+    <integer>15</integer>
+    <key>StandardOutPath</key>
+    <string>${escapeXml(options.standardOutPath)}</string>
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(options.standardErrorPath)}</string>
+  </dict>
+</plist>
+`;
+}
+function getLaunchctlSupport() {
+  if (platform2() !== "darwin") {
+    return {
+      ok: false,
+      reason: "launchd \u4EC5\u5728 macOS \u4E0A\u53EF\u7528\u3002"
+    };
+  }
+  if (!isCommandAvailable("launchctl")) {
+    return {
+      ok: false,
+      reason: "\u672A\u68C0\u6D4B\u5230 launchctl\u3002"
+    };
+  }
+  const uid = getCurrentUid();
+  if (uid == null) {
+    return {
+      ok: false,
+      reason: "\u65E0\u6CD5\u83B7\u53D6\u5F53\u524D\u7528\u6237 UID\u3002"
+    };
+  }
+  try {
+    execFileSync3("launchctl", ["print", getMacosLaunchdDomain(uid)], {
+      stdio: "ignore"
+    });
+    return { ok: true };
+  } catch {
+    return {
+      ok: false,
+      reason: "\u5F53\u524D\u672A\u68C0\u6D4B\u5230\u56FE\u5F62\u5316\u767B\u5F55\u4F1A\u8BDD\uFF0C\u8BF7\u5728\u684C\u9762\u7EC8\u7AEF\u4E2D\u6267\u884C\u3002"
+    };
+  }
+}
+function execLaunchctl(args, inherit = true) {
+  execFileSync3("launchctl", args, {
+    stdio: inherit ? "inherit" : "ignore"
+  });
+}
+function isLoaded() {
+  try {
+    execLaunchctl(["print", getMacosLaunchdServiceTarget()], false);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureLaunchctlAvailable() {
+  const support = getLaunchctlSupport();
+  if (support.ok) {
+    return true;
+  }
+  logger.info(formatBullet(`launchd \u4E0D\u53EF\u7528\u3002${support.reason}`, "warning"));
+  return false;
+}
+function writeLaunchAgentPlist() {
+  const plistFile = getMacosLaunchAgentFile();
+  const { stdoutPath, stderrPath } = getMacosLaunchdLogPaths();
+  const command = resolveManagedDaemonCommand();
+  const plist = buildLaunchdPlist({
+    label: MACOS_LAUNCHD_LABEL,
+    programArguments: [command.execPath, ...command.args],
+    environment: getManagedServiceEnvironment(),
+    workingDirectory: homedir13(),
+    standardOutPath: stdoutPath,
+    standardErrorPath: stderrPath
+  });
+  ensureAppDirs();
+  mkdirSync4(getMacosLaunchAgentDir(), { recursive: true });
+  writeFileSync6(plistFile, plist, "utf-8");
+  return plistFile;
+}
+function bootstrapLaunchAgent() {
+  const domain = getMacosLaunchdDomain();
+  const serviceTarget = getMacosLaunchdServiceTarget();
+  const plistFile = getMacosLaunchAgentFile();
+  if (isLoaded()) {
+    try {
+      execLaunchctl(["bootout", serviceTarget]);
+    } catch {
+    }
+  }
+  execLaunchctl(["bootstrap", domain, plistFile]);
+  execLaunchctl(["enable", serviceTarget]);
+  execLaunchctl(["kickstart", "-k", serviceTarget]);
+}
+function createMacosLaunchdServiceBackend() {
+  function isInstalled() {
+    return existsSync17(getMacosLaunchAgentFile());
+  }
+  async function setup(skipPrompt = false) {
+    if (!ensureLaunchctlAvailable()) {
+      return;
+    }
+    logger.info(formatHeader("\u8BBE\u7F6E launchd \u670D\u52A1", "TokenArena daemon"));
+    if (!skipPrompt) {
+      const shouldSetup = await promptConfirm({
+        message: "\u662F\u5426\u521B\u5EFA\u5E76\u542F\u7528 launchd \u7528\u6237\u670D\u52A1\uFF1F",
+        defaultValue: true
+      });
+      if (!shouldSetup) {
+        logger.info(formatBullet("\u5DF2\u53D6\u6D88\u670D\u52A1\u8BBE\u7F6E\u3002"));
+        return;
+      }
+    }
+    try {
+      const plistFile = writeLaunchAgentPlist();
+      bootstrapLaunchAgent();
+      logger.info(formatSection("\u670D\u52A1\u5DF2\u8BBE\u7F6E"));
+      logger.info(formatBullet(`\u670D\u52A1\u6587\u4EF6: ${plistFile}`, "success"));
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u542F\u7528\u5E76\u542F\u52A8", "success"));
+      logger.info(
+        formatKeyValue(
+          "\u67E5\u770B\u72B6\u6001",
+          `launchctl print ${getMacosLaunchdServiceTarget()}`
+        )
+      );
+    } catch (err) {
+      logger.error(`\u8BBE\u7F6E\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function start() {
+    if (!ensureLaunchctlAvailable()) {
+      return;
+    }
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    try {
+      if (!isLoaded()) {
+        execLaunchctl([
+          "bootstrap",
+          getMacosLaunchdDomain(),
+          getMacosLaunchAgentFile()
+        ]);
+      }
+      execLaunchctl(["enable", getMacosLaunchdServiceTarget()]);
+      execLaunchctl(["kickstart", "-k", getMacosLaunchdServiceTarget()]);
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u542F\u52A8", "success"));
+    } catch (err) {
+      logger.error(`\u542F\u52A8\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function stop() {
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    if (!ensureLaunchctlAvailable()) {
+      return;
+    }
+    if (!isLoaded()) {
+      logger.info(formatBullet("\u670D\u52A1\u5F53\u524D\u672A\u8FD0\u884C\u3002", "warning"));
+      return;
+    }
+    try {
+      execLaunchctl(["bootout", getMacosLaunchdServiceTarget()]);
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u505C\u6B62", "success"));
+    } catch (err) {
+      logger.error(`\u505C\u6B62\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function restart() {
+    if (!ensureLaunchctlAvailable()) {
+      return;
+    }
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    try {
+      if (isLoaded()) {
+        execLaunchctl(["kickstart", "-k", getMacosLaunchdServiceTarget()]);
+      } else {
+        execLaunchctl([
+          "bootstrap",
+          getMacosLaunchdDomain(),
+          getMacosLaunchAgentFile()
+        ]);
+        execLaunchctl(["enable", getMacosLaunchdServiceTarget()]);
+        execLaunchctl(["kickstart", "-k", getMacosLaunchdServiceTarget()]);
+      }
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u91CD\u542F", "success"));
+    } catch (err) {
+      logger.error(`\u91CD\u542F\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  async function status() {
+    if (!isInstalled()) {
+      logger.info(
+        formatBullet(
+          "\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002\u8BF7\u5148\u8FD0\u884C 'tokenarena service setup'\u3002",
+          "warning"
+        )
+      );
+      return;
+    }
+    if (!ensureLaunchctlAvailable()) {
+      return;
+    }
+    try {
+      execLaunchctl(["print", getMacosLaunchdServiceTarget()]);
+    } catch {
+      logger.info(formatBullet("\u670D\u52A1\u5F53\u524D\u672A\u52A0\u8F7D\u3002", "warning"));
+      logger.info(formatKeyValue("\u670D\u52A1\u6587\u4EF6", getMacosLaunchAgentFile()));
+    }
+  }
+  async function uninstall(skipPrompt = false) {
+    const plistFile = getMacosLaunchAgentFile();
+    if (!existsSync17(plistFile)) {
+      logger.info(formatBullet("\u670D\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728\u3002", "warning"));
+      return;
+    }
+    if (!skipPrompt) {
+      const shouldUninstall = await promptConfirm({
+        message: "\u662F\u5426\u5378\u8F7D launchd \u670D\u52A1\uFF1F",
+        defaultValue: false
+      });
+      if (!shouldUninstall) {
+        logger.info(formatBullet("\u5DF2\u53D6\u6D88\u5378\u8F7D\u3002"));
+        return;
+      }
+    }
+    const support = getLaunchctlSupport();
+    if (support.ok && isLoaded()) {
+      try {
+        execLaunchctl(["bootout", getMacosLaunchdServiceTarget()]);
+      } catch {
+      }
+    } else if (!support.ok) {
+      logger.info(
+        formatBullet(
+          `\u5F53\u524D\u65E0\u6CD5\u8BBF\u95EE launchd\uFF0C\u4F1A\u76F4\u63A5\u5220\u9664\u672C\u5730 plist \u6587\u4EF6\u3002${support.reason}`,
+          "warning"
+        )
+      );
+    }
+    try {
+      const { stdoutPath, stderrPath } = getMacosLaunchdLogPaths();
+      rmSync3(plistFile);
+      rmSync3(stdoutPath, { force: true });
+      rmSync3(stderrPath, { force: true });
+      logger.info(formatSection("\u670D\u52A1\u5DF2\u5378\u8F7D"));
+      logger.info(formatBullet("\u670D\u52A1\u5DF2\u505C\u7528\u5E76\u5220\u9664", "success"));
+    } catch (err) {
+      logger.error(`\u5378\u8F7D\u670D\u52A1\u5931\u8D25: ${err.message}`);
+      throw err;
+    }
+  }
+  return {
+    displayName: "launchd \u7528\u6237\u670D\u52A1",
+    canSetup: getLaunchctlSupport,
+    isInstalled,
+    getDefinitionPath: getMacosLaunchAgentFile,
+    getStatusHint: () => `launchctl print ${getMacosLaunchdServiceTarget()}`,
+    setup,
+    start,
+    stop,
+    restart,
+    status,
+    uninstall
+  };
+}
+
+// src/infrastructure/service/index.ts
+function getServiceBackend(currentPlatform = platform3()) {
+  switch (currentPlatform) {
+    case "linux":
+      return createLinuxSystemdServiceBackend();
+    case "darwin":
+      return createMacosLaunchdServiceBackend();
+    default:
+      return null;
+  }
+}
+
+// src/commands/init.ts
 function joinForPlatform(currentPlatform, ...parts) {
   return currentPlatform === "win32" ? win32.join(...parts) : posix.join(...parts);
 }
-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()) {
+function getBrowserLaunchCommand(url, currentPlatform = platform4()) {
   switch (currentPlatform) {
     case "darwin":
       return {
@@ -3197,11 +4012,11 @@ function resolvePowerShellProfilePath() {
   const systemRoot = process.env.SYSTEMROOT || "C:\\Windows";
   const candidates = [
     "pwsh.exe",
-    join15(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    join17(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
   ];
   for (const command of candidates) {
     try {
-      const output = execFileSync2(
+      const output = execFileSync4(
         command,
         [
           "-NoLogo",
@@ -3224,10 +4039,10 @@ function resolvePowerShellProfilePath() {
   return null;
 }
 function resolveShellAliasSetup(options = {}) {
-  const currentPlatform = options.currentPlatform ?? platform();
+  const currentPlatform = options.currentPlatform ?? platform4();
   const env = options.env ?? process.env;
-  const homeDir = options.homeDir ?? homedir12();
-  const pathExists = options.exists ?? existsSync16;
+  const homeDir = options.homeDir ?? homedir14();
+  const pathExists = options.exists ?? existsSync18;
   const shellFromEnv = env.SHELL ? basenameLikeShell(env.SHELL).toLowerCase() : "";
   const shellName = shellFromEnv || (currentPlatform === "win32" ? "powershell" : "");
   const aliasName = "ta";
@@ -3383,29 +4198,29 @@ 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();
+  await setupBackgroundService();
 }
-async function setupSystemdService() {
-  const currentPlatform = platform();
-  if (currentPlatform !== "linux") {
+async function setupBackgroundService() {
+  const backend = getServiceBackend();
+  if (!backend) {
     return;
   }
-  if (!isCommandAvailable("systemctl")) {
+  const support = backend.canSetup();
+  if (!support.ok) {
     return;
   }
   const shouldSetup = await promptConfirm({
-    message: "\u662F\u5426\u8BBE\u7F6E systemd \u670D\u52A1\u4EE5\u81EA\u52A8\u8FD0\u884C daemon\uFF1F",
+    message: `\u662F\u5426\u8BBE\u7F6E ${backend.displayName} \u4EE5\u81EA\u52A8\u8FD0\u884C daemon\uFF1F`,
     defaultValue: true
   });
   if (!shouldSetup) {
-    logger.info(formatBullet("\u5DF2\u8DF3\u8FC7 systemd \u670D\u52A1\u8BBE\u7F6E\u3002"));
+    logger.info(formatBullet("\u5DF2\u8DF3\u8FC7\u540E\u53F0\u670D\u52A1\u8BBE\u7F6E\u3002"));
     return;
   }
   try {
-    const { runInstallService: runInstallService2 } = await import("./service-4U7K4DKW.js");
-    await runInstallService2({ action: "setup", skipPrompt: true });
+    await backend.setup(true);
   } catch (err) {
-    logger.warn(`systemd \u670D\u52A1\u8BBE\u7F6E\u5931\u8D25: ${err.message}`);
+    logger.warn(`${backend.displayName} \u8BBE\u7F6E\u5931\u8D25: ${err.message}`);
   }
 }
 async function setupShellAlias() {
@@ -3424,7 +4239,7 @@ async function setupShellAlias() {
   try {
     await mkdir(dirname3(setup.configFile), { recursive: true });
     let existingContent = "";
-    if (existsSync16(setup.configFile)) {
+    if (existsSync18(setup.configFile)) {
       existingContent = await readFile(setup.configFile, "utf-8");
     }
     const normalizedContent = existingContent.toLowerCase();
@@ -3468,6 +4283,9 @@ function log(msg) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+function getDaemonExitCode(opts = {}) {
+  return opts.service ? 0 : 1;
+}
 async function runDaemon(opts = {}) {
   const config = loadConfig();
   if (!config?.apiKey) {
@@ -3489,12 +4307,14 @@ async function runDaemon(opts = {}) {
       logger.info(formatBullet("\u5DF2\u53D6\u6D88\u542F\u52A8 daemon\u3002", "warning"));
       return;
     }
-    logger.error("Not configured. Run `tokenarena init` first.");
-    process.exit(1);
+    const message = opts.service ? "Not configured. Exiting service mode." : "Not configured. Run `tokenarena init` first.";
+    logger.error(message);
+    process.exit(getDaemonExitCode(opts));
   }
   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)`);
+  const stopHint = opts.service ? "service mode" : "Ctrl+C to stop";
+  log(`Daemon started (sync every ${intervalMin}m, ${stopHint})`);
   while (true) {
     try {
       await runSync(config, {
@@ -3504,8 +4324,9 @@ async function runDaemon(opts = {}) {
       });
     } catch (err) {
       if (err.message === "UNAUTHORIZED") {
-        log("API key invalid. Exiting.");
-        process.exit(1);
+        const message = opts.service ? "API key invalid. Exiting service mode." : "API key invalid. Exiting.";
+        log(message);
+        process.exit(getDaemonExitCode(opts));
       }
       log(`Sync error: ${err.message}`);
     }
@@ -3617,8 +4438,8 @@ async function runSyncCommand(opts = {}) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync17, readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir13, platform as platform2 } from "os";
+import { existsSync as existsSync19, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir15, platform as platform5 } from "os";
 function removeShellAlias() {
   const shell = process.env.SHELL;
   if (!shell) return;
@@ -3627,22 +4448,22 @@ function removeShellAlias() {
   let configFile;
   switch (shellName) {
     case "zsh":
-      configFile = `${homedir13()}/.zshrc`;
+      configFile = `${homedir15()}/.zshrc`;
       break;
     case "bash":
-      if (platform2() === "darwin" && existsSync17(`${homedir13()}/.bash_profile`)) {
-        configFile = `${homedir13()}/.bash_profile`;
+      if (platform5() === "darwin" && existsSync19(`${homedir15()}/.bash_profile`)) {
+        configFile = `${homedir15()}/.bash_profile`;
       } else {
-        configFile = `${homedir13()}/.bashrc`;
+        configFile = `${homedir15()}/.bashrc`;
       }
       break;
     case "fish":
-      configFile = `${homedir13()}/.config/fish/config.fish`;
+      configFile = `${homedir15()}/.config/fish/config.fish`;
       break;
     default:
       return;
   }
-  if (!existsSync17(configFile)) return;
+  if (!existsSync19(configFile)) return;
   try {
     let content = readFileSync10(configFile, "utf-8");
     const aliasPatterns = [
@@ -3666,7 +4487,7 @@ function removeShellAlias() {
         content = next;
       }
     }
-    writeFileSync5(configFile, content, "utf-8");
+    writeFileSync7(configFile, content, "utf-8");
     logger.info(`Removed shell alias from ${configFile}`);
   } catch (err) {
     logger.warn(
@@ -3677,7 +4498,12 @@ function removeShellAlias() {
 async function runUninstall() {
   const configPath = getConfigPath();
   const configDir = getConfigDir();
-  if (!existsSync17(configPath)) {
+  const stateDir = getStateDir();
+  const runtimeDir = getRuntimeDirPath();
+  const serviceBackend = getServiceBackend();
+  const hasInstalledService = serviceBackend?.isInstalled() ?? false;
+  const hasLocalArtifacts = existsSync19(configPath) || existsSync19(configDir) || existsSync19(stateDir) || existsSync19(runtimeDir) || hasInstalledService;
+  if (!hasLocalArtifacts) {
     logger.info(formatHeader("\u5378\u8F7D TokenArena"));
     logger.info(formatBullet("\u672A\u53D1\u73B0\u672C\u5730\u914D\u7F6E\uFF0C\u65E0\u9700\u5378\u8F7D\u3002"));
     return;
@@ -3693,8 +4519,11 @@ async function runUninstall() {
     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()));
+  logger.info(formatKeyValue("\u72B6\u6001\u76EE\u5F55", stateDir));
+  logger.info(formatKeyValue("\u8FD0\u884C\u76EE\u5F55", runtimeDir));
+  if (hasInstalledService && serviceBackend) {
+    logger.info(formatKeyValue("\u540E\u53F0\u670D\u52A1", serviceBackend.getDefinitionPath()));
+  }
   const shouldUninstall = await promptConfirm({
     message: "\u786E\u8BA4\u7EE7\u7EED\u5378\u8F7D\u672C\u5730 TokenArena \u6570\u636E\uFF1F",
     defaultValue: false
@@ -3703,24 +4532,37 @@ async function runUninstall() {
     logger.info(formatBullet("\u5DF2\u53D6\u6D88\u5378\u8F7D\u3002", "warning"));
     return;
   }
-  deleteConfig();
+  if (hasInstalledService && serviceBackend) {
+    const shouldRemoveService = await promptConfirm({
+      message: `\u68C0\u6D4B\u5230\u5DF2\u5B89\u88C5 ${serviceBackend.displayName}\uFF0C\u662F\u5426\u4E00\u5E76\u5378\u8F7D\uFF1F`,
+      defaultValue: true
+    });
+    if (shouldRemoveService) {
+      try {
+        await serviceBackend.uninstall(true);
+      } catch (err) {
+        logger.warn(`\u540E\u53F0\u670D\u52A1\u5378\u8F7D\u5931\u8D25: ${err.message}`);
+      }
+    }
+  }
   logger.info(formatSection("\u6267\u884C\u7ED3\u679C"));
-  logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
-  if (existsSync17(configDir)) {
+  if (existsSync19(configPath)) {
+    deleteConfig();
+    logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\u3002", "success"));
+  }
+  if (existsSync19(configDir)) {
     try {
-      rmSync2(configDir, { recursive: false, force: true });
+      rmSync4(configDir, { recursive: false, force: true });
       logger.info(formatBullet("\u5DF2\u5220\u9664\u914D\u7F6E\u76EE\u5F55\u3002", "success"));
     } catch {
     }
   }
-  const stateDir = getStateDir();
-  if (existsSync17(stateDir)) {
-    rmSync2(stateDir, { recursive: true, force: true });
+  if (existsSync19(stateDir)) {
+    rmSync4(stateDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u72B6\u6001\u6570\u636E\u3002", "success"));
   }
-  const runtimeDir = getRuntimeDirPath();
-  if (existsSync17(runtimeDir)) {
-    rmSync2(runtimeDir, { recursive: true, force: true });
+  if (existsSync19(runtimeDir)) {
+    rmSync4(runtimeDir, { recursive: true, force: true });
     logger.info(formatBullet("\u5DF2\u5220\u9664\u8FD0\u884C\u65F6\u6570\u636E\u3002", "success"));
   }
   removeShellAlias();
@@ -3842,9 +4684,70 @@ async function runHome(program) {
   }
 }
 
+// src/commands/service.ts
+function printUsage(backendName) {
+  logger.info(formatHeader("TokenArena \u540E\u53F0\u670D\u52A1\u7BA1\u7406"));
+  if (backendName) {
+    logger.info(formatKeyValue("\u5F53\u524D\u5B9E\u73B0", backendName));
+  }
+  logger.info(formatSection("\u53EF\u7528\u64CD\u4F5C"));
+  logger.info(formatBullet("setup     - \u521B\u5EFA\u5E76\u542F\u7528\u670D\u52A1"));
+  logger.info(formatBullet("start     - \u542F\u52A8\u670D\u52A1"));
+  logger.info(formatBullet("stop      - \u505C\u6B62\u670D\u52A1"));
+  logger.info(formatBullet("restart   - \u91CD\u542F\u670D\u52A1"));
+  logger.info(formatBullet("status    - \u67E5\u770B\u670D\u52A1\u72B6\u6001"));
+  logger.info(formatBullet("uninstall - \u5378\u8F7D\u670D\u52A1"));
+}
+async function runServiceCommand(opts) {
+  const backend = getServiceBackend();
+  if (!backend) {
+    logger.info(
+      formatBullet(
+        "\u540E\u53F0\u670D\u52A1\u4EC5\u5728 Linux(systemd) \u548C macOS(launchd) \u4E0A\u652F\u6301\u3002",
+        "warning"
+      )
+    );
+    return;
+  }
+  const action = opts.action?.toLowerCase();
+  if (!action) {
+    printUsage(backend.displayName);
+    const support = backend.canSetup();
+    if (!support.ok && support.reason) {
+      logger.info(
+        formatBullet(`\u5F53\u524D\u73AF\u5883\u6682\u4E0D\u53EF\u7BA1\u7406\u670D\u52A1\u3002${support.reason}`, "warning")
+      );
+    }
+    return;
+  }
+  switch (action) {
+    case "setup":
+      await backend.setup(opts.skipPrompt);
+      break;
+    case "start":
+      await backend.start();
+      break;
+    case "stop":
+      await backend.stop();
+      break;
+    case "restart":
+      await backend.restart();
+      break;
+    case "status":
+      await backend.status();
+      break;
+    case "uninstall":
+      await backend.uninstall(opts.skipPrompt);
+      break;
+    default:
+      logger.error(`\u672A\u77E5\u64CD\u4F5C: ${action}`);
+      process.exit(1);
+  }
+}
+
 // src/infrastructure/runtime/cli-version.ts
 import { readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname4, join as join16 } from "path";
+import { dirname as dirname4, join as join18 } from "path";
 import { fileURLToPath } from "url";
 var FALLBACK_VERSION = "0.0.0";
 var cachedVersion;
@@ -3852,7 +4755,7 @@ function getCliVersion(metaUrl = import.meta.url) {
   if (cachedVersion) {
     return cachedVersion;
   }
-  const packageJsonPath = join16(
+  const packageJsonPath = join18(
     dirname4(fileURLToPath(metaUrl)),
     "..",
     "package.json"
@@ -3888,13 +4791,13 @@ function createCli() {
   program.command("sync").description("Manually sync usage data to server").addOption(new Option("--quiet").hideHelp()).action(async (opts) => {
     await runSyncCommand(opts);
   });
-  program.command("daemon").description("Run continuous sync (every 5 minutes by default)").option("--interval <ms>", "Sync interval in milliseconds", parseInt).action(async (opts) => {
+  program.command("daemon").description("Run continuous sync (every 5 minutes by default)").option("--interval <ms>", "Sync interval in milliseconds", parseInt).addOption(new Option("--service").hideHelp()).action(async (opts) => {
     await runDaemon(opts);
   });
   program.command("service [action]").description(
-    "Manage systemd user service (setup|start|stop|restart|status|uninstall)"
+    "Manage background service (setup|start|stop|restart|status|uninstall)"
   ).action(async (action) => {
-    await runInstallService({ action });
+    await runServiceCommand({ action });
   });
   program.command("status").description("Show configuration and detected tools").action(async () => {
     await runStatus();
@@ -3913,7 +4816,7 @@ function createCli() {
 }
 
 // src/infrastructure/runtime/main-module.ts
-import { existsSync as existsSync18, realpathSync } from "fs";
+import { existsSync as existsSync20, realpathSync } from "fs";
 import { resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
@@ -3924,7 +4827,7 @@ function isMainModule(argvEntry = process.argv[1], metaUrl = import.meta.url) {
   try {
     return realpathSync(argvEntry) === realpathSync(currentModulePath);
   } catch {
-    if (!existsSync18(argvEntry)) {
+    if (!existsSync20(argvEntry)) {
       return false;
     }
     return resolve(argvEntry) === resolve(currentModulePath);