xiaozhi-client 1.9.4-beta.1 → 1.9.4-beta.3

package/dist/cli/index.js

@@ -0,0 +1,4473 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Constants.ts
+var SERVICE_CONSTANTS, CONFIG_CONSTANTS, PATH_CONSTANTS, ERROR_CODES, TIMEOUT_CONSTANTS;
+var init_Constants = __esm({
+  "src/Constants.ts"() {
+    SERVICE_CONSTANTS = {
+      /** 服务名称 */
+      NAME: "xiaozhi-mcp-service",
+      /** 默认端口 */
+      DEFAULT_PORT: 3e3,
+      /** Web UI 默认端口 */
+      DEFAULT_WEB_UI_PORT: 9999,
+      /** PID 文件名 */
+      PID_FILE: "xiaozhi.pid",
+      /** 日志文件名 */
+      LOG_FILE: "xiaozhi.log"
+    };
+    CONFIG_CONSTANTS = {
+      /** 配置文件名（按优先级排序） */
+      FILE_NAMES: [
+        "xiaozhi.config.json5",
+        "xiaozhi.config.jsonc",
+        "xiaozhi.config.json"
+      ],
+      /** 默认配置文件名 */
+      DEFAULT_FILE: "xiaozhi.config.default.json",
+      /** 配置目录环境变量 */
+      DIR_ENV_VAR: "XIAOZHI_CONFIG_DIR"
+    };
+    PATH_CONSTANTS = {
+      /** 工作目录名 */
+      WORK_DIR: ".xiaozhi",
+      /** 模板目录名 */
+      TEMPLATES_DIR: "templates",
+      /** 日志目录名 */
+      LOGS_DIR: "logs"
+    };
+    ERROR_CODES = {
+      /** 通用错误 */
+      GENERAL_ERROR: "GENERAL_ERROR",
+      /** 配置错误 */
+      CONFIG_ERROR: "CONFIG_ERROR",
+      /** 服务错误 */
+      SERVICE_ERROR: "SERVICE_ERROR",
+      /** 验证错误 */
+      VALIDATION_ERROR: "VALIDATION_ERROR",
+      /** 文件操作错误 */
+      FILE_ERROR: "FILE_ERROR",
+      /** 进程错误 */
+      PROCESS_ERROR: "PROCESS_ERROR",
+      /** 网络错误 */
+      NETWORK_ERROR: "NETWORK_ERROR",
+      /** 权限错误 */
+      PERMISSION_ERROR: "PERMISSION_ERROR"
+    };
+    TIMEOUT_CONSTANTS = {
+      /** 进程停止超时 */
+      PROCESS_STOP: 3e3,
+      /** 服务启动超时 */
+      SERVICE_START: 1e4,
+      /** 网络请求超时 */
+      NETWORK_REQUEST: 5e3,
+      /** 文件操作超时 */
+      FILE_OPERATION: 2e3
+    };
+  }
+});
+
+// src/errors/index.ts
+var CLIError, ConfigError, ServiceError, ValidationError, FileError, ProcessError;
+var init_errors = __esm({
+  "src/errors/index.ts"() {
+    init_Constants();
+    CLIError = class _CLIError extends Error {
+      constructor(message, code, exitCode = 1, suggestions) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.suggestions = suggestions;
+        this.name = "CLIError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _CLIError);
+        }
+      }
+      static {
+        __name(this, "CLIError");
+      }
+      /**
+       * 创建带建议的错误
+       */
+      static withSuggestions(message, code, suggestions) {
+        return new _CLIError(message, code, 1, suggestions);
+      }
+    };
+    ConfigError = class _ConfigError extends CLIError {
+      static {
+        __name(this, "ConfigError");
+      }
+      constructor(message, suggestions) {
+        super(message, ERROR_CODES.CONFIG_ERROR, 1, suggestions);
+        this.name = "ConfigError";
+      }
+      static configNotFound() {
+        return new _ConfigError("\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728", [
+          '\u8BF7\u8FD0\u884C "xiaozhi init" \u521D\u59CB\u5316\u914D\u7F6E\u6587\u4EF6'
+        ]);
+      }
+      static invalidFormat(format) {
+        return new _ConfigError(`\u65E0\u6548\u7684\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F: ${format}`, [
+          "\u652F\u6301\u7684\u683C\u5F0F: json, json5, jsonc"
+        ]);
+      }
+    };
+    ServiceError = class _ServiceError extends CLIError {
+      static {
+        __name(this, "ServiceError");
+      }
+      constructor(message, suggestions) {
+        super(message, ERROR_CODES.SERVICE_ERROR, 1, suggestions);
+        this.name = "ServiceError";
+      }
+      static alreadyRunning(pid) {
+        return new _ServiceError(`\u670D\u52A1\u5DF2\u7ECF\u5728\u8FD0\u884C (PID: ${pid})`, [
+          '\u8BF7\u5148\u8FD0\u884C "xiaozhi stop" \u505C\u6B62\u73B0\u6709\u670D\u52A1',
+          '\u6216\u8005\u4F7F\u7528 "xiaozhi restart" \u91CD\u542F\u670D\u52A1'
+        ]);
+      }
+      static autoRestarting(pid) {
+        return new _ServiceError(
+          `\u68C0\u6D4B\u5230\u670D\u52A1\u5DF2\u5728\u8FD0\u884C (PID: ${pid})\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u542F...`,
+          ["\u5982\u679C\u4E0D\u5E0C\u671B\u81EA\u52A8\u91CD\u542F\uFF0C\u8BF7\u4F7F\u7528 xiaozhi stop \u624B\u52A8\u505C\u6B62\u670D\u52A1"]
+        );
+      }
+      static notRunning() {
+        return new _ServiceError("\u670D\u52A1\u672A\u8FD0\u884C", ['\u8BF7\u8FD0\u884C "xiaozhi start" \u542F\u52A8\u670D\u52A1']);
+      }
+      static startFailed(reason) {
+        return new _ServiceError(`\u670D\u52A1\u542F\u52A8\u5931\u8D25: ${reason}`, [
+          "\u68C0\u67E5\u914D\u7F6E\u6587\u4EF6\u662F\u5426\u6B63\u786E",
+          "\u786E\u4FDD\u7AEF\u53E3\u672A\u88AB\u5360\u7528",
+          "\u67E5\u770B\u65E5\u5FD7\u6587\u4EF6\u83B7\u53D6\u8BE6\u7EC6\u4FE1\u606F"
+        ]);
+      }
+    };
+    ValidationError = class _ValidationError extends CLIError {
+      static {
+        __name(this, "ValidationError");
+      }
+      constructor(message, field) {
+        super(`\u9A8C\u8BC1\u5931\u8D25: ${field} - ${message}`, ERROR_CODES.VALIDATION_ERROR, 1);
+        this.name = "ValidationError";
+      }
+      static invalidPort(port) {
+        return new _ValidationError(
+          `\u7AEF\u53E3\u53F7\u5FC5\u987B\u5728 1-65535 \u8303\u56F4\u5185\uFF0C\u5F53\u524D\u503C: ${port}`,
+          "port"
+        );
+      }
+      static requiredField(field) {
+        return new _ValidationError("\u5FC5\u586B\u5B57\u6BB5\u4E0D\u80FD\u4E3A\u7A7A", field);
+      }
+    };
+    FileError = class _FileError extends CLIError {
+      static {
+        __name(this, "FileError");
+      }
+      constructor(message, filePath, suggestions) {
+        const fullMessage = filePath ? `${message}: ${filePath}` : message;
+        super(fullMessage, ERROR_CODES.FILE_ERROR, 1, suggestions);
+        this.name = "FileError";
+      }
+      static notFound(filePath) {
+        return new _FileError("\u6587\u4EF6\u4E0D\u5B58\u5728", filePath, ["\u68C0\u67E5\u6587\u4EF6\u8DEF\u5F84\u662F\u5426\u6B63\u786E"]);
+      }
+      static permissionDenied(filePath) {
+        return new _FileError("\u6743\u9650\u4E0D\u8DB3", filePath, [
+          "\u68C0\u67E5\u6587\u4EF6\u6743\u9650\u6216\u4F7F\u7528\u7BA1\u7406\u5458\u6743\u9650\u8FD0\u884C"
+        ]);
+      }
+      static alreadyExists(filePath) {
+        return new _FileError("\u6587\u4EF6\u5DF2\u5B58\u5728", filePath, [
+          "\u4F7F\u7528\u4E0D\u540C\u7684\u6587\u4EF6\u540D\u6216\u5220\u9664\u73B0\u6709\u6587\u4EF6"
+        ]);
+      }
+    };
+    ProcessError = class _ProcessError extends CLIError {
+      static {
+        __name(this, "ProcessError");
+      }
+      constructor(message, pid, suggestions) {
+        const fullMessage = pid ? `${message} (PID: ${pid})` : message;
+        super(fullMessage, ERROR_CODES.PROCESS_ERROR, 1, suggestions);
+        this.name = "ProcessError";
+      }
+      static killFailed(pid) {
+        return new _ProcessError("\u65E0\u6CD5\u7EC8\u6B62\u8FDB\u7A0B", pid, [
+          "\u8FDB\u7A0B\u53EF\u80FD\u5DF2\u7ECF\u505C\u6B62\u6216\u6743\u9650\u4E0D\u8DB3"
+        ]);
+      }
+      static notFound(pid) {
+        return new _ProcessError("\u8FDB\u7A0B\u4E0D\u5B58\u5728", pid);
+      }
+    };
+  }
+});
+
+// src/utils/FileUtils.ts
+import fs from "fs";
+import { tmpdir } from "os";
+import path from "path";
+var FileUtils;
+var init_FileUtils = __esm({
+  "src/utils/FileUtils.ts"() {
+    init_errors();
+    FileUtils = class _FileUtils {
+      static {
+        __name(this, "FileUtils");
+      }
+      /**
+       * 检查文件是否存在
+       */
+      static exists(filePath) {
+        try {
+          return fs.existsSync(filePath);
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * 确保目录存在
+       */
+      static ensureDir(dirPath) {
+        try {
+          if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+          }
+        } catch (error) {
+          throw new FileError("\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55", dirPath);
+        }
+      }
+      /**
+       * 读取文件内容
+       */
+      static readFile(filePath, encoding = "utf8") {
+        try {
+          if (!_FileUtils.exists(filePath)) {
+            throw FileError.notFound(filePath);
+          }
+          return fs.readFileSync(filePath, encoding);
+        } catch (error) {
+          if (error instanceof FileError) {
+            throw error;
+          }
+          throw new FileError("\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6", filePath);
+        }
+      }
+      /**
+       * 写入文件内容
+       */
+      static writeFile(filePath, content, options) {
+        try {
+          if (!options?.overwrite && _FileUtils.exists(filePath)) {
+            throw FileError.alreadyExists(filePath);
+          }
+          const dir = path.dirname(filePath);
+          _FileUtils.ensureDir(dir);
+          fs.writeFileSync(filePath, content, "utf8");
+        } catch (error) {
+          if (error instanceof FileError) {
+            throw error;
+          }
+          throw new FileError("\u65E0\u6CD5\u5199\u5165\u6587\u4EF6", filePath);
+        }
+      }
+      /**
+       * 复制文件
+       */
+      static copyFile(srcPath, destPath, options) {
+        try {
+          if (!_FileUtils.exists(srcPath)) {
+            throw FileError.notFound(srcPath);
+          }
+          if (!options?.overwrite && _FileUtils.exists(destPath)) {
+            throw FileError.alreadyExists(destPath);
+          }
+          const destDir = path.dirname(destPath);
+          _FileUtils.ensureDir(destDir);
+          fs.copyFileSync(srcPath, destPath);
+        } catch (error) {
+          if (error instanceof FileError) {
+            throw error;
+          }
+          throw new FileError("\u65E0\u6CD5\u590D\u5236\u6587\u4EF6", srcPath);
+        }
+      }
+      /**
+       * 删除文件
+       */
+      static deleteFile(filePath) {
+        try {
+          if (_FileUtils.exists(filePath)) {
+            fs.unlinkSync(filePath);
+          }
+        } catch (error) {
+          throw new FileError("\u65E0\u6CD5\u5220\u9664\u6587\u4EF6", filePath);
+        }
+      }
+      /**
+       * 复制目录
+       */
+      static copyDirectory(srcDir, destDir, options = {}) {
+        try {
+          if (!_FileUtils.exists(srcDir)) {
+            throw FileError.notFound(srcDir);
+          }
+          _FileUtils.ensureDir(destDir);
+          const items = fs.readdirSync(srcDir);
+          for (const item of items) {
+            if (options.exclude?.includes(item)) {
+              continue;
+            }
+            const srcPath = path.join(srcDir, item);
+            const destPath = path.join(destDir, item);
+            const stat = fs.statSync(srcPath);
+            if (stat.isDirectory()) {
+              if (options.recursive !== false) {
+                _FileUtils.copyDirectory(srcPath, destPath, options);
+              }
+            } else {
+              _FileUtils.copyFile(srcPath, destPath, {
+                overwrite: options.overwrite
+              });
+            }
+          }
+        } catch (error) {
+          if (error instanceof FileError) {
+            throw error;
+          }
+          throw new FileError("\u65E0\u6CD5\u590D\u5236\u76EE\u5F55", srcDir);
+        }
+      }
+      /**
+       * 删除目录
+       */
+      static deleteDirectory(dirPath, options = {}) {
+        try {
+          if (_FileUtils.exists(dirPath)) {
+            fs.rmSync(dirPath, {
+              recursive: options.recursive ?? true,
+              force: true
+            });
+          }
+        } catch (error) {
+          throw new FileError("\u65E0\u6CD5\u5220\u9664\u76EE\u5F55", dirPath);
+        }
+      }
+      /**
+       * 获取文件信息
+       */
+      static getFileInfo(filePath) {
+        try {
+          if (!_FileUtils.exists(filePath)) {
+            throw FileError.notFound(filePath);
+          }
+          const stats = fs.statSync(filePath);
+          return {
+            size: stats.size,
+            isFile: stats.isFile(),
+            isDirectory: stats.isDirectory(),
+            mtime: stats.mtime,
+            ctime: stats.ctime
+          };
+        } catch (error) {
+          if (error instanceof FileError) {
+            throw error;
+          }
+          throw new FileError("\u65E0\u6CD5\u83B7\u53D6\u6587\u4EF6\u4FE1\u606F", filePath);
+        }
+      }
+      /**
+       * 列出目录内容
+       */
+      static listDirectory(dirPath, options = {}) {
+        try {
+          if (!_FileUtils.exists(dirPath)) {
+            throw FileError.notFound(dirPath);
+          }
+          const items = fs.readdirSync(dirPath);
+          let result = [];
+          for (const item of items) {
+            if (!options.includeHidden && item.startsWith(".")) {
+              continue;
+            }
+            const itemPath = path.join(dirPath, item);
+            result.push(itemPath);
+            if (options.recursive && fs.statSync(itemPath).isDirectory()) {
+              const subItems = _FileUtils.listDirectory(itemPath, options);
+              result = result.concat(subItems);
+            }
+          }
+          return result;
+        } catch (error) {
+          if (error instanceof FileError) {
+            throw error;
+          }
+          throw new FileError("\u65E0\u6CD5\u5217\u51FA\u76EE\u5F55\u5185\u5BB9", dirPath);
+        }
+      }
+      /**
+       * 创建临时文件
+       */
+      static createTempFile(prefix = "xiaozhi-", suffix = ".tmp") {
+        const tempDir = process.env.TMPDIR || process.env.TEMP || tmpdir();
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2);
+        const fileName = `${prefix}${timestamp}-${random}${suffix}`;
+        return path.join(tempDir, fileName);
+      }
+      /**
+       * 检查文件权限
+       */
+      static checkPermissions(filePath, mode = fs.constants.R_OK | fs.constants.W_OK) {
+        try {
+          fs.accessSync(filePath, mode);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * 获取文件扩展名
+       */
+      static getExtension(filePath) {
+        return path.extname(filePath).toLowerCase();
+      }
+      /**
+       * 获取文件名（不含扩展名）
+       */
+      static getBaseName(filePath) {
+        return path.basename(filePath, path.extname(filePath));
+      }
+      /**
+       * 规范化路径
+       */
+      static normalizePath(filePath) {
+        return path.normalize(filePath);
+      }
+      /**
+       * 解析相对路径为绝对路径
+       */
+      static resolvePath(filePath, basePath) {
+        if (basePath) {
+          return path.resolve(basePath, filePath);
+        }
+        return path.resolve(filePath);
+      }
+    };
+  }
+});
+
+// src/utils/FormatUtils.ts
+var FormatUtils;
+var init_FormatUtils = __esm({
+  "src/utils/FormatUtils.ts"() {
+    FormatUtils = class {
+      static {
+        __name(this, "FormatUtils");
+      }
+      /**
+       * 格式化运行时间
+       */
+      static formatUptime(ms) {
+        const seconds = Math.floor(ms / 1e3);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+          return `${days}\u5929 ${hours % 24}\u5C0F\u65F6 ${minutes % 60}\u5206\u949F`;
+        }
+        if (hours > 0) {
+          return `${hours}\u5C0F\u65F6 ${minutes % 60}\u5206\u949F`;
+        }
+        if (minutes > 0) {
+          return `${minutes}\u5206\u949F ${seconds % 60}\u79D2`;
+        }
+        return `${seconds}\u79D2`;
+      }
+      /**
+       * 格式化文件大小
+       */
+      static formatFileSize(bytes) {
+        const units = ["B", "KB", "MB", "GB", "TB"];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+          size /= 1024;
+          unitIndex++;
+        }
+        return `${size.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+      }
+      /**
+       * 格式化时间戳
+       */
+      static formatTimestamp(timestamp, format = "full") {
+        const date = new Date(timestamp);
+        switch (format) {
+          case "date":
+            return date.toLocaleDateString("zh-CN");
+          case "time":
+            return date.toLocaleTimeString("zh-CN");
+          default:
+            return date.toLocaleString("zh-CN");
+        }
+      }
+      /**
+       * 格式化进程 ID
+       */
+      static formatPid(pid) {
+        return `PID: ${pid}`;
+      }
+      /**
+       * 格式化端口号
+       */
+      static formatPort(port) {
+        return `\u7AEF\u53E3: ${port}`;
+      }
+      /**
+       * 格式化 URL
+       */
+      static formatUrl(protocol, host, port, path7) {
+        const url = `${protocol}://${host}:${port}`;
+        return path7 ? `${url}${path7}` : url;
+      }
+      /**
+       * 格式化配置键值对
+       */
+      static formatConfigPair(key, value) {
+        if (typeof value === "object") {
+          return `${key}: ${JSON.stringify(value, null, 2)}`;
+        }
+        return `${key}: ${value}`;
+      }
+      /**
+       * 格式化错误消息
+       */
+      static formatError(error, includeStack = false) {
+        let message = `\u9519\u8BEF: ${error.message}`;
+        if (includeStack && error.stack) {
+          message += `
+\u5806\u6808\u4FE1\u606F:
+${error.stack}`;
+        }
+        return message;
+      }
+      /**
+       * 格式化列表
+       */
+      static formatList(items, bullet = "\u2022") {
+        return items.map((item) => `${bullet} ${item}`).join("\n");
+      }
+      /**
+       * 格式化表格数据
+       */
+      static formatTable(data) {
+        if (data.length === 0) return "";
+        const keys = Object.keys(data[0]);
+        const maxWidths = keys.map(
+          (key) => Math.max(key.length, ...data.map((row) => String(row[key]).length))
+        );
+        const header = keys.map((key, i) => key.padEnd(maxWidths[i])).join(" | ");
+        const separator = maxWidths.map((width) => "-".repeat(width)).join("-|-");
+        const rows = data.map(
+          (row) => keys.map((key, i) => String(row[key]).padEnd(maxWidths[i])).join(" | ")
+        );
+        return [header, separator, ...rows].join("\n");
+      }
+      /**
+       * 格式化进度条
+       */
+      static formatProgressBar(current, total, width = 20) {
+        const percentage = Math.min(current / total, 1);
+        const filled = Math.floor(percentage * width);
+        const empty = width - filled;
+        const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+        const percent = Math.floor(percentage * 100);
+        return `[${bar}] ${percent}% (${current}/${total})`;
+      }
+      /**
+       * 格式化命令行参数
+       */
+      static formatCommandArgs(command, args) {
+        const quotedArgs = args.map(
+          (arg) => arg.includes(" ") ? `"${arg}"` : arg
+        );
+        return `${command} ${quotedArgs.join(" ")}`;
+      }
+      /**
+       * 截断长文本
+       */
+      static truncateText(text, maxLength, suffix = "...") {
+        if (text.length <= maxLength) return text;
+        return text.substring(0, maxLength - suffix.length) + suffix;
+      }
+      /**
+       * 格式化 JSON
+       */
+      static formatJson(obj, indent = 2) {
+        try {
+          return JSON.stringify(obj, null, indent);
+        } catch (error) {
+          return String(obj);
+        }
+      }
+      /**
+       * 格式化布尔值
+       */
+      static formatBoolean(value, trueText = "\u662F", falseText = "\u5426") {
+        return value ? trueText : falseText;
+      }
+    };
+  }
+});
+
+// src/utils/PathUtils.ts
+import { realpathSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var PathUtils;
+var init_PathUtils = __esm({
+  "src/utils/PathUtils.ts"() {
+    init_Constants();
+    init_FileUtils();
+    PathUtils = class _PathUtils {
+      static {
+        __name(this, "PathUtils");
+      }
+      /**
+       * 获取 PID 文件路径
+       */
+      static getPidFile() {
+        const configDir = process.env[CONFIG_CONSTANTS.DIR_ENV_VAR] || process.cwd();
+        return path2.join(configDir, `.${SERVICE_CONSTANTS.NAME}.pid`);
+      }
+      /**
+       * 获取日志文件路径
+       */
+      static getLogFile(projectDir) {
+        const baseDir = projectDir || process.cwd();
+        return path2.join(baseDir, SERVICE_CONSTANTS.LOG_FILE);
+      }
+      /**
+       * 获取配置目录路径
+       */
+      static getConfigDir() {
+        return process.env[CONFIG_CONSTANTS.DIR_ENV_VAR] || process.cwd();
+      }
+      /**
+       * 获取工作目录路径
+       */
+      static getWorkDir() {
+        const configDir = _PathUtils.getConfigDir();
+        return path2.join(configDir, PATH_CONSTANTS.WORK_DIR);
+      }
+      /**
+       * 获取模板目录路径
+       */
+      static getTemplatesDir() {
+        const __filename = fileURLToPath(import.meta.url);
+        const scriptDir = path2.dirname(__filename);
+        return [
+          // 构建后的环境：dist/cli.js -> dist/templates
+          path2.join(scriptDir, PATH_CONSTANTS.TEMPLATES_DIR),
+          // 构建环境：dist/cli/index.js -> dist/backend/templates
+          path2.join(scriptDir, "..", "backend", PATH_CONSTANTS.TEMPLATES_DIR),
+          // npm 全局安装
+          path2.join(
+            scriptDir,
+            "..",
+            "..",
+            "..",
+            "..",
+            PATH_CONSTANTS.TEMPLATES_DIR
+          )
+        ];
+      }
+      /**
+       * 查找模板目录
+       */
+      static findTemplatesDir() {
+        const possiblePaths = _PathUtils.getTemplatesDir();
+        for (const templatesDir of possiblePaths) {
+          if (FileUtils.exists(templatesDir)) {
+            return templatesDir;
+          }
+        }
+        return null;
+      }
+      /**
+       * 获取模板路径
+       */
+      static getTemplatePath(templateName) {
+        const templatesDir = _PathUtils.findTemplatesDir();
+        if (!templatesDir) {
+          return null;
+        }
+        const templatePath = path2.join(templatesDir, templateName);
+        return FileUtils.exists(templatePath) ? templatePath : null;
+      }
+      /**
+       * 获取脚本目录路径
+       */
+      static getScriptDir() {
+        const __filename = fileURLToPath(import.meta.url);
+        return path2.dirname(__filename);
+      }
+      /**
+       * 获取项目根目录路径
+       */
+      static getProjectRoot() {
+        const scriptDir = _PathUtils.getScriptDir();
+        return path2.join(scriptDir, "..", "..", "..");
+      }
+      /**
+       * 获取构建输出目录路径
+       */
+      static getDistDir() {
+        const projectRoot = _PathUtils.getProjectRoot();
+        return path2.join(projectRoot, "dist");
+      }
+      /**
+       * 获取相对于项目根目录的路径
+       */
+      static getRelativePath(filePath) {
+        const projectRoot = _PathUtils.getProjectRoot();
+        return path2.relative(projectRoot, filePath);
+      }
+      /**
+       * 解析配置文件路径
+       */
+      static resolveConfigPath(format) {
+        const configDir = _PathUtils.getConfigDir();
+        if (format) {
+          return path2.join(configDir, `xiaozhi.config.${format}`);
+        }
+        for (const fileName of CONFIG_CONSTANTS.FILE_NAMES) {
+          const filePath = path2.join(configDir, fileName);
+          if (FileUtils.exists(filePath)) {
+            return filePath;
+          }
+        }
+        return path2.join(configDir, CONFIG_CONSTANTS.FILE_NAMES[2]);
+      }
+      /**
+       * 获取默认配置文件路径
+       */
+      static getDefaultConfigPath() {
+        const projectRoot = _PathUtils.getProjectRoot();
+        return path2.join(projectRoot, CONFIG_CONSTANTS.DEFAULT_FILE);
+      }
+      /**
+       * 验证路径安全性（防止路径遍历攻击）
+       */
+      static validatePath(inputPath) {
+        const normalizedPath = path2.normalize(inputPath);
+        return !normalizedPath.includes("..");
+      }
+      /**
+       * 确保路径在指定目录内
+       */
+      static ensurePathWithin(inputPath, baseDir) {
+        const resolvedPath = path2.resolve(baseDir, inputPath);
+        const resolvedBase = path2.resolve(baseDir);
+        if (!resolvedPath.startsWith(resolvedBase)) {
+          throw new Error(`\u8DEF\u5F84 ${inputPath} \u8D85\u51FA\u4E86\u5141\u8BB8\u7684\u8303\u56F4`);
+        }
+        return resolvedPath;
+      }
+      /**
+       * 获取可执行文件路径
+       */
+      static getExecutablePath(name) {
+        const cliPath = process.argv[1];
+        if (!cliPath) {
+          return path2.join(process.cwd(), `${name}.js`);
+        }
+        let realCliPath;
+        try {
+          realCliPath = realpathSync(cliPath);
+        } catch (error) {
+          realCliPath = cliPath;
+        }
+        const distDir = path2.dirname(realCliPath);
+        return path2.join(distDir, `${name}.js`);
+      }
+      /**
+       * 获取 Web 服务器启动器路径
+       */
+      static getWebServerLauncherPath() {
+        return _PathUtils.getExecutablePath("WebServerLauncher");
+      }
+      /**
+       * 创建安全的文件路径
+       */
+      static createSafePath(...segments) {
+        const joinedPath = path2.join(...segments);
+        const normalizedPath = path2.normalize(joinedPath);
+        if (normalizedPath.includes("..") || normalizedPath.includes("~")) {
+          throw new Error(`\u4E0D\u5B89\u5168\u7684\u8DEF\u5F84: ${normalizedPath}`);
+        }
+        return normalizedPath;
+      }
+      /**
+       * 获取临时目录路径
+       */
+      static getTempDir() {
+        return process.env.TMPDIR || process.env.TEMP || tmpdir2();
+      }
+      /**
+       * 获取用户主目录路径
+       */
+      static getHomeDir() {
+        return process.env.HOME || process.env.USERPROFILE || "";
+      }
+    };
+  }
+});
+
+// src/utils/PlatformUtils.ts
+import { execSync } from "child_process";
+var PlatformUtils;
+var init_PlatformUtils = __esm({
+  "src/utils/PlatformUtils.ts"() {
+    init_Constants();
+    init_errors();
+    PlatformUtils = class _PlatformUtils {
+      static {
+        __name(this, "PlatformUtils");
+      }
+      /**
+       * 获取当前平台
+       */
+      static getCurrentPlatform() {
+        return process.platform;
+      }
+      /**
+       * 检查是否为 Windows 平台
+       */
+      static isWindows() {
+        return process.platform === "win32";
+      }
+      /**
+       * 检查是否为 macOS 平台
+       */
+      static isMacOS() {
+        return process.platform === "darwin";
+      }
+      /**
+       * 检查是否为 Linux 平台
+       */
+      static isLinux() {
+        return process.platform === "linux";
+      }
+      /**
+       * 检查是否为类 Unix 系统
+       */
+      static isUnixLike() {
+        return !_PlatformUtils.isWindows();
+      }
+      /**
+       * 检查进程是否为 xiaozhi-client 进程
+       */
+      static isXiaozhiProcess(pid) {
+        try {
+          if (process.env.XIAOZHI_CONTAINER === "true" || process.env.NODE_ENV === "test") {
+            process.kill(pid, 0);
+            return true;
+          }
+          try {
+            let cmdline = "";
+            if (_PlatformUtils.isWindows()) {
+              const result = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, {
+                encoding: "utf8",
+                timeout: TIMEOUT_CONSTANTS.PROCESS_STOP
+              });
+              cmdline = result.toLowerCase();
+            } else {
+              const result = execSync(`ps -p ${pid} -o comm=`, {
+                encoding: "utf8",
+                timeout: TIMEOUT_CONSTANTS.PROCESS_STOP
+              });
+              cmdline = result.toLowerCase();
+            }
+            return cmdline.includes("node") || cmdline.includes("xiaozhi");
+          } catch (error) {
+            process.kill(pid, 0);
+            return true;
+          }
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * 杀死进程
+       */
+      static async killProcess(pid, signal = "SIGTERM") {
+        try {
+          process.kill(pid, signal);
+          let attempts = 0;
+          const maxAttempts = 30;
+          while (attempts < maxAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            try {
+              process.kill(pid, 0);
+              attempts++;
+            } catch {
+              return;
+            }
+          }
+          try {
+            process.kill(pid, 0);
+            process.kill(pid, "SIGKILL");
+            await new Promise((resolve) => setTimeout(resolve, 500));
+          } catch {
+          }
+        } catch (error) {
+          throw new ProcessError(
+            `\u65E0\u6CD5\u7EC8\u6B62\u8FDB\u7A0B: ${error instanceof Error ? error.message : String(error)}`,
+            pid
+          );
+        }
+      }
+      /**
+       * 检查进程是否存在
+       */
+      static processExists(pid) {
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * 获取系统信息
+       */
+      static getSystemInfo() {
+        return {
+          platform: _PlatformUtils.getCurrentPlatform(),
+          arch: process.arch,
+          nodeVersion: process.version,
+          isContainer: process.env.XIAOZHI_CONTAINER === "true"
+        };
+      }
+      /**
+       * 获取环境变量
+       */
+      static getEnvVar(name, defaultValue) {
+        return process.env[name] || defaultValue;
+      }
+      /**
+       * 设置环境变量
+       */
+      static setEnvVar(name, value) {
+        process.env[name] = value;
+      }
+      /**
+       * 检查是否在容器环境中运行
+       */
+      static isContainerEnvironment() {
+        return process.env.XIAOZHI_CONTAINER === "true";
+      }
+      /**
+       * 检查是否在测试环境中运行
+       */
+      static isTestEnvironment() {
+        return process.env.NODE_ENV === "test";
+      }
+      /**
+       * 检查是否在开发环境中运行
+       */
+      static isDevelopmentEnvironment() {
+        return process.env.NODE_ENV === "development";
+      }
+      /**
+       * 获取合适的 tail 命令
+       */
+      static getTailCommand(filePath) {
+        if (_PlatformUtils.isWindows()) {
+          return {
+            command: "powershell",
+            args: ["-Command", `Get-Content -Path "${filePath}" -Wait`]
+          };
+        }
+        return {
+          command: "tail",
+          args: ["-f", filePath]
+        };
+      }
+    };
+  }
+});
+
+// src/utils/Validation.ts
+var Validation;
+var init_Validation = __esm({
+  "src/utils/Validation.ts"() {
+    init_errors();
+    Validation = class _Validation {
+      static {
+        __name(this, "Validation");
+      }
+      /**
+       * 验证端口号
+       */
+      static validatePort(port) {
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+          throw ValidationError.invalidPort(port);
+        }
+      }
+      /**
+       * 验证配置文件格式
+       */
+      static validateConfigFormat(format) {
+        const validFormats = ["json", "json5", "jsonc"];
+        if (!validFormats.includes(format)) {
+          throw new ValidationError(
+            `\u65E0\u6548\u7684\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F: ${format}\uFF0C\u652F\u6301\u7684\u683C\u5F0F: ${validFormats.join(", ")}`,
+            "format"
+          );
+        }
+        return format;
+      }
+      /**
+       * 验证必填字段
+       */
+      static validateRequired(value, fieldName) {
+        if (value === void 0 || value === null || value === "") {
+          throw ValidationError.requiredField(fieldName);
+        }
+      }
+      /**
+       * 验证字符串长度
+       */
+      static validateStringLength(value, fieldName, options = {}) {
+        if (options.min !== void 0 && value.length < options.min) {
+          throw new ValidationError(
+            `\u957F\u5EA6\u4E0D\u80FD\u5C11\u4E8E ${options.min} \u4E2A\u5B57\u7B26\uFF0C\u5F53\u524D\u957F\u5EA6: ${value.length}`,
+            fieldName
+          );
+        }
+        if (options.max !== void 0 && value.length > options.max) {
+          throw new ValidationError(
+            `\u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7 ${options.max} \u4E2A\u5B57\u7B26\uFF0C\u5F53\u524D\u957F\u5EA6: ${value.length}`,
+            fieldName
+          );
+        }
+      }
+      /**
+       * 验证 URL 格式
+       */
+      static validateUrl(url, fieldName = "url") {
+        try {
+          new URL(url);
+        } catch {
+          throw new ValidationError(`\u65E0\u6548\u7684 URL \u683C\u5F0F: ${url}`, fieldName);
+        }
+      }
+      /**
+       * 验证 WebSocket URL 格式
+       */
+      static validateWebSocketUrl(url, fieldName = "websocket_url") {
+        _Validation.validateUrl(url, fieldName);
+        const parsedUrl = new URL(url);
+        if (!["ws:", "wss:"].includes(parsedUrl.protocol)) {
+          throw new ValidationError(
+            `WebSocket URL \u5FC5\u987B\u4F7F\u7528 ws:// \u6216 wss:// \u534F\u8BAE\uFF0C\u5F53\u524D\u534F\u8BAE: ${parsedUrl.protocol}`,
+            fieldName
+          );
+        }
+      }
+      /**
+       * 验证 HTTP URL 格式
+       */
+      static validateHttpUrl(url, fieldName = "http_url") {
+        _Validation.validateUrl(url, fieldName);
+        const parsedUrl = new URL(url);
+        if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+          throw new ValidationError(
+            `HTTP URL \u5FC5\u987B\u4F7F\u7528 http:// \u6216 https:// \u534F\u8BAE\uFF0C\u5F53\u524D\u534F\u8BAE: ${parsedUrl.protocol}`,
+            fieldName
+          );
+        }
+      }
+      /**
+       * 验证项目名称
+       */
+      static validateProjectName(name) {
+        _Validation.validateRequired(name, "projectName");
+        _Validation.validateStringLength(name, "projectName", { min: 1, max: 100 });
+        const invalidChars = /[<>:"/\\|?*]/;
+        const hasControlChars = name.split("").some((char) => char.charCodeAt(0) < 32);
+        if (invalidChars.test(name) || hasControlChars) {
+          throw new ValidationError(
+            '\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u5305\u542B\u4EE5\u4E0B\u5B57\u7B26: < > : " / \\ | ? * \u4EE5\u53CA\u63A7\u5236\u5B57\u7B26',
+            "projectName"
+          );
+        }
+        if (name.startsWith(".")) {
+          throw new ValidationError("\u9879\u76EE\u540D\u79F0\u4E0D\u80FD\u4EE5\u70B9\u5F00\u5934", "projectName");
+        }
+      }
+      /**
+       * 验证模板名称
+       */
+      static validateTemplateName(name) {
+        _Validation.validateRequired(name, "templateName");
+        _Validation.validateStringLength(name, "templateName", { min: 1, max: 50 });
+        const validPattern = /^[a-zA-Z0-9_-]+$/;
+        if (!validPattern.test(name)) {
+          throw new ValidationError(
+            "\u6A21\u677F\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u8FDE\u5B57\u7B26\u548C\u4E0B\u5212\u7EBF",
+            "templateName"
+          );
+        }
+      }
+      /**
+       * 验证环境变量名称
+       */
+      static validateEnvVarName(name) {
+        _Validation.validateRequired(name, "envVarName");
+        const validPattern = /^[A-Z_][A-Z0-9_]*$/;
+        if (!validPattern.test(name)) {
+          throw new ValidationError(
+            "\u73AF\u5883\u53D8\u91CF\u540D\u79F0\u53EA\u80FD\u5305\u542B\u5927\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E0B\u5212\u7EBF\uFF0C\u4E14\u4E0D\u80FD\u4EE5\u6570\u5B57\u5F00\u5934",
+            "envVarName"
+          );
+        }
+      }
+      /**
+       * 验证 JSON 格式
+       */
+      static validateJson(jsonString, fieldName = "json") {
+        try {
+          return JSON.parse(jsonString);
+        } catch (error) {
+          throw new ValidationError(
+            `\u65E0\u6548\u7684 JSON \u683C\u5F0F: ${error instanceof Error ? error.message : String(error)}`,
+            fieldName
+          );
+        }
+      }
+      /**
+       * 验证数字范围
+       */
+      static validateNumberRange(value, fieldName, options = {}) {
+        if (options.min !== void 0 && value < options.min) {
+          throw new ValidationError(
+            `\u503C\u4E0D\u80FD\u5C0F\u4E8E ${options.min}\uFF0C\u5F53\u524D\u503C: ${value}`,
+            fieldName
+          );
+        }
+        if (options.max !== void 0 && value > options.max) {
+          throw new ValidationError(
+            `\u503C\u4E0D\u80FD\u5927\u4E8E ${options.max}\uFF0C\u5F53\u524D\u503C: ${value}`,
+            fieldName
+          );
+        }
+      }
+      /**
+       * 验证数组长度
+       */
+      static validateArrayLength(array, fieldName, options = {}) {
+        if (options.min !== void 0 && array.length < options.min) {
+          throw new ValidationError(
+            `\u6570\u7EC4\u957F\u5EA6\u4E0D\u80FD\u5C11\u4E8E ${options.min}\uFF0C\u5F53\u524D\u957F\u5EA6: ${array.length}`,
+            fieldName
+          );
+        }
+        if (options.max !== void 0 && array.length > options.max) {
+          throw new ValidationError(
+            `\u6570\u7EC4\u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7 ${options.max}\uFF0C\u5F53\u524D\u957F\u5EA6: ${array.length}`,
+            fieldName
+          );
+        }
+      }
+      /**
+       * 验证对象属性
+       */
+      static validateObjectProperties(obj, requiredProps, fieldName = "object") {
+        for (const prop of requiredProps) {
+          if (!(prop in obj)) {
+            throw new ValidationError(`\u7F3A\u5C11\u5FC5\u9700\u7684\u5C5E\u6027: ${prop}`, fieldName);
+          }
+        }
+      }
+      /**
+       * 验证枚举值
+       */
+      static validateEnum(value, validValues, fieldName) {
+        if (!validValues.includes(value)) {
+          throw new ValidationError(
+            `\u65E0\u6548\u7684\u503C: ${value}\uFF0C\u6709\u6548\u503C: ${validValues.join(", ")}`,
+            fieldName
+          );
+        }
+        return value;
+      }
+      /**
+       * 验证正则表达式
+       */
+      static validateRegex(pattern, fieldName = "regex") {
+        try {
+          return new RegExp(pattern);
+        } catch (error) {
+          throw new ValidationError(
+            `\u65E0\u6548\u7684\u6B63\u5219\u8868\u8FBE\u5F0F: ${error instanceof Error ? error.message : String(error)}`,
+            fieldName
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/services/ProcessManager.ts
+var ProcessManager_exports = {};
+__export(ProcessManager_exports, {
+  ProcessManagerImpl: () => ProcessManagerImpl
+});
+var ProcessManagerImpl;
+var init_ProcessManager = __esm({
+  "src/services/ProcessManager.ts"() {
+    init_errors();
+    init_FileUtils();
+    init_FormatUtils();
+    init_PathUtils();
+    init_PlatformUtils();
+    ProcessManagerImpl = class {
+      static {
+        __name(this, "ProcessManagerImpl");
+      }
+      /**
+       * 获取 PID 文件路径
+       */
+      getPidFilePath() {
+        return PathUtils.getPidFile();
+      }
+      /**
+       * 读取 PID 文件信息
+       */
+      readPidFile() {
+        try {
+          const pidFilePath = this.getPidFilePath();
+          if (!FileUtils.exists(pidFilePath)) {
+            return null;
+          }
+          const pidContent = FileUtils.readFile(pidFilePath).trim();
+          const [pidStr, startTimeStr, mode] = pidContent.split("|");
+          const pid = Number.parseInt(pidStr);
+          const startTime = Number.parseInt(startTimeStr);
+          if (Number.isNaN(pid) || Number.isNaN(startTime)) {
+            this.cleanupPidFile();
+            return null;
+          }
+          return {
+            pid,
+            startTime,
+            mode: mode || "foreground"
+          };
+        } catch (error) {
+          this.cleanupPidFile();
+          return null;
+        }
+      }
+      /**
+       * 写入 PID 文件信息
+       */
+      writePidFile(pid, mode) {
+        try {
+          const pidInfo = `${pid}|${Date.now()}|${mode}`;
+          const pidFilePath = this.getPidFilePath();
+          FileUtils.writeFile(pidFilePath, pidInfo, { overwrite: true });
+        } catch (error) {
+          throw new FileError("\u65E0\u6CD5\u5199\u5165 PID \u6587\u4EF6", this.getPidFilePath());
+        }
+      }
+      /**
+       * 检查是否为 xiaozhi 进程
+       */
+      isXiaozhiProcess(pid) {
+        return PlatformUtils.isXiaozhiProcess(pid);
+      }
+      /**
+       * 获取服务状态
+       */
+      getServiceStatus() {
+        try {
+          const pidInfo = this.readPidFile();
+          if (!pidInfo) {
+            return { running: false };
+          }
+          if (!this.isXiaozhiProcess(pidInfo.pid)) {
+            this.cleanupPidFile();
+            return { running: false };
+          }
+          const uptime = FormatUtils.formatUptime(Date.now() - pidInfo.startTime);
+          return {
+            running: true,
+            pid: pidInfo.pid,
+            uptime,
+            mode: pidInfo.mode
+          };
+        } catch (error) {
+          return { running: false };
+        }
+      }
+      /**
+       * 保存进程信息
+       */
+      savePidInfo(pid, mode) {
+        this.writePidFile(pid, mode);
+      }
+      /**
+       * 杀死进程
+       */
+      async killProcess(pid) {
+        try {
+          await PlatformUtils.killProcess(pid);
+        } catch (error) {
+          throw new ProcessError(
+            `\u65E0\u6CD5\u7EC8\u6B62\u8FDB\u7A0B: ${error instanceof Error ? error.message : String(error)}`,
+            pid
+          );
+        }
+      }
+      /**
+       * 优雅停止进程
+       */
+      async gracefulKillProcess(pid) {
+        try {
+          process.kill(pid, "SIGTERM");
+          let attempts = 0;
+          const maxAttempts = 30;
+          while (attempts < maxAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            try {
+              process.kill(pid, 0);
+              attempts++;
+            } catch {
+              return;
+            }
+          }
+          try {
+            process.kill(pid, 0);
+            process.kill(pid, "SIGKILL");
+            await new Promise((resolve) => setTimeout(resolve, 500));
+          } catch {
+          }
+        } catch (error) {
+          throw new ProcessError(
+            `\u65E0\u6CD5\u505C\u6B62\u8FDB\u7A0B: ${error instanceof Error ? error.message : String(error)}`,
+            pid
+          );
+        }
+      }
+      /**
+       * 清理 PID 文件
+       */
+      cleanupPidFile() {
+        try {
+          const pidFilePath = this.getPidFilePath();
+          if (FileUtils.exists(pidFilePath)) {
+            FileUtils.deleteFile(pidFilePath);
+          }
+        } catch (error) {
+          console.warn("\u6E05\u7406 PID \u6587\u4EF6\u5931\u8D25:", error);
+        }
+      }
+      /**
+       * 检查进程是否存在
+       */
+      processExists(pid) {
+        return PlatformUtils.processExists(pid);
+      }
+      /**
+       * 清理容器环境的旧状态
+       */
+      cleanupContainerState() {
+        if (PlatformUtils.isContainerEnvironment()) {
+          try {
+            this.cleanupPidFile();
+          } catch (error) {
+          }
+        }
+      }
+      /**
+       * 获取进程信息
+       */
+      getProcessInfo(pid) {
+        const exists = this.processExists(pid);
+        const isXiaozhi = exists ? this.isXiaozhiProcess(pid) : false;
+        return { exists, isXiaozhi };
+      }
+      /**
+       * 验证 PID 文件完整性
+       */
+      validatePidFile() {
+        try {
+          const pidInfo = this.readPidFile();
+          return pidInfo !== null;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/services/DaemonManager.ts
+var DaemonManager_exports = {};
+__export(DaemonManager_exports, {
+  DaemonManagerImpl: () => DaemonManagerImpl
+});
+import { spawn } from "child_process";
+import fs3 from "fs";
+var DaemonManagerImpl;
+var init_DaemonManager = __esm({
+  "src/services/DaemonManager.ts"() {
+    init_errors();
+    init_PathUtils();
+    init_PlatformUtils();
+    DaemonManagerImpl = class {
+      constructor(processManager, logger3) {
+        this.processManager = processManager;
+        this.logger = logger3;
+      }
+      static {
+        __name(this, "DaemonManagerImpl");
+      }
+      currentDaemon = null;
+      /**
+       * 启动守护进程
+       */
+      async startDaemon(serverFactory, options = {}) {
+        try {
+          const status = this.processManager.getServiceStatus();
+          if (status.running) {
+            throw ServiceError.alreadyRunning(status.pid);
+          }
+          const child = await this.spawnDaemonProcess(serverFactory, options);
+          this.currentDaemon = child;
+          this.processManager.savePidInfo(child.pid, "daemon");
+          await this.setupLogging(child, options.logFileName || "xiaozhi.log");
+          this.setupEventHandlers(child);
+          child.unref();
+          this.logger.info(`\u5B88\u62A4\u8FDB\u7A0B\u5DF2\u542F\u52A8 (PID: ${child.pid})`);
+        } catch (error) {
+          throw new ServiceError(
+            `\u542F\u52A8\u5B88\u62A4\u8FDB\u7A0B\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 停止守护进程
+       */
+      async stopDaemon() {
+        try {
+          const status = this.processManager.getServiceStatus();
+          if (!status.running) {
+            throw ServiceError.notRunning();
+          }
+          await this.processManager.gracefulKillProcess(status.pid);
+          this.processManager.cleanupPidFile();
+          this.currentDaemon = null;
+          this.logger.info("\u5B88\u62A4\u8FDB\u7A0B\u5DF2\u505C\u6B62");
+        } catch (error) {
+          throw new ServiceError(
+            `\u505C\u6B62\u5B88\u62A4\u8FDB\u7A0B\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 重启守护进程
+       */
+      async restartDaemon(serverFactory, options = {}) {
+        try {
+          const status = this.processManager.getServiceStatus();
+          if (status.running) {
+            await this.stopDaemon();
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+          }
+          await this.startDaemon(serverFactory, options);
+        } catch (error) {
+          throw new ServiceError(
+            `\u91CD\u542F\u5B88\u62A4\u8FDB\u7A0B\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 获取守护进程状态
+       */
+      getDaemonStatus() {
+        return this.processManager.getServiceStatus();
+      }
+      /**
+       * 连接到守护进程日志
+       */
+      async attachToLogs(logFileName = "xiaozhi.log") {
+        try {
+          const logFilePath = PathUtils.getLogFile();
+          if (!fs3.existsSync(logFilePath)) {
+            throw new ServiceError("\u65E5\u5FD7\u6587\u4EF6\u4E0D\u5B58\u5728");
+          }
+          const { command, args } = PlatformUtils.getTailCommand(logFilePath);
+          const tail = spawn(command, args, { stdio: "inherit" });
+          process.on("SIGINT", () => {
+            console.log("\n\u65AD\u5F00\u8FDE\u63A5\uFF0C\u670D\u52A1\u7EE7\u7EED\u5728\u540E\u53F0\u8FD0\u884C");
+            tail.kill();
+            process.exit(0);
+          });
+          tail.on("exit", () => {
+            process.exit(0);
+          });
+          tail.on("error", (error) => {
+            throw new ServiceError(`\u8FDE\u63A5\u65E5\u5FD7\u5931\u8D25: ${error.message}`);
+          });
+        } catch (error) {
+          throw new ServiceError(
+            `\u8FDE\u63A5\u65E5\u5FD7\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 生成守护进程
+       */
+      async spawnDaemonProcess(serverFactory, options) {
+        const scriptPath2 = PathUtils.getWebServerLauncherPath();
+        const args = [scriptPath2];
+        if (options.openBrowser) {
+          args.push("--open-browser");
+        }
+        const env = {
+          ...process.env,
+          XIAOZHI_CONFIG_DIR: PathUtils.getConfigDir(),
+          XIAOZHI_DAEMON: "true",
+          ...options.env
+        };
+        const child = spawn("node", args, {
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"],
+          env,
+          cwd: options.cwd || process.cwd()
+        });
+        if (!child.pid) {
+          throw new ProcessError("\u65E0\u6CD5\u542F\u52A8\u5B88\u62A4\u8FDB\u7A0B", 0);
+        }
+        return child;
+      }
+      /**
+       * 设置日志重定向
+       */
+      async setupLogging(child, logFileName) {
+        try {
+          const logFilePath = PathUtils.getLogFile();
+          const path7 = await import("path");
+          const logDir = path7.dirname(logFilePath);
+          if (!fs3.existsSync(logDir)) {
+            fs3.mkdirSync(logDir, { recursive: true });
+          }
+          const logStream = fs3.createWriteStream(logFilePath, { flags: "a" });
+          child.stdout?.pipe(logStream);
+          child.stderr?.pipe(logStream);
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          logStream.write(`
+[${timestamp}] \u5B88\u62A4\u8FDB\u7A0B\u542F\u52A8 (PID: ${child.pid})
+`);
+        } catch (error) {
+          this.logger.warn(
+            `\u8BBE\u7F6E\u65E5\u5FD7\u91CD\u5B9A\u5411\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 设置事件处理器
+       */
+      setupEventHandlers(child) {
+        child.on("exit", (code, signal) => {
+          if (code !== 0 && code !== null) {
+            this.logger.error(`\u5B88\u62A4\u8FDB\u7A0B\u5F02\u5E38\u9000\u51FA (\u4EE3\u7801: ${code}, \u4FE1\u53F7: ${signal})`);
+          } else {
+            this.logger.info("\u5B88\u62A4\u8FDB\u7A0B\u6B63\u5E38\u9000\u51FA");
+          }
+          this.processManager.cleanupPidFile();
+          this.currentDaemon = null;
+        });
+        child.on("error", (error) => {
+          this.logger.error(`\u5B88\u62A4\u8FDB\u7A0B\u9519\u8BEF: ${error.message}`);
+          this.processManager.cleanupPidFile();
+          this.currentDaemon = null;
+        });
+        child.on("disconnect", () => {
+          this.logger.info("\u5B88\u62A4\u8FDB\u7A0B\u65AD\u5F00\u8FDE\u63A5");
+        });
+      }
+      /**
+       * 检查守护进程健康状态
+       */
+      async checkHealth() {
+        try {
+          const status = this.getDaemonStatus();
+          if (!status.running || !status.pid) {
+            return false;
+          }
+          const processInfo = this.processManager.getProcessInfo(status.pid);
+          return processInfo.exists && processInfo.isXiaozhi;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * 获取当前守护进程引用
+       */
+      getCurrentDaemon() {
+        return this.currentDaemon;
+      }
+      /**
+       * 清理守护进程资源
+       */
+      cleanup() {
+        if (this.currentDaemon) {
+          try {
+            this.currentDaemon.kill("SIGTERM");
+          } catch (error) {
+            this.logger.warn(
+              `\u6E05\u7406\u5B88\u62A4\u8FDB\u7A0B\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          this.currentDaemon = null;
+        }
+      }
+    };
+  }
+});
+
+// src/services/ServiceManager.ts
+var ServiceManager_exports = {};
+__export(ServiceManager_exports, {
+  ServiceManagerImpl: () => ServiceManagerImpl
+});
+var ServiceManagerImpl;
+var init_ServiceManager = __esm({
+  "src/services/ServiceManager.ts"() {
+    init_errors();
+    init_PathUtils();
+    init_Validation();
+    ServiceManagerImpl = class {
+      constructor(processManager, configManager3) {
+        this.processManager = processManager;
+        this.configManager = configManager3;
+      }
+      static {
+        __name(this, "ServiceManagerImpl");
+      }
+      /**
+       * 启动服务
+       */
+      async start(options) {
+        try {
+          this.validateStartOptions(options);
+          this.processManager.cleanupContainerState();
+          const status = this.getStatus();
+          if (status.running) {
+            console.log(`\u68C0\u6D4B\u5230\u670D\u52A1\u5DF2\u5728\u8FD0\u884C (PID: ${status.pid})\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u542F...`);
+            try {
+              await this.processManager.gracefulKillProcess(status.pid || 0);
+              this.processManager.cleanupPidFile();
+              await new Promise((resolve) => setTimeout(resolve, 1e3));
+              console.log("\u73B0\u6709\u670D\u52A1\u5DF2\u505C\u6B62\uFF0C\u6B63\u5728\u542F\u52A8\u65B0\u670D\u52A1...");
+            } catch (stopError) {
+              console.warn(
+                `\u505C\u6B62\u73B0\u6709\u670D\u52A1\u65F6\u51FA\u73B0\u8B66\u544A: ${stopError instanceof Error ? stopError.message : String(stopError)}`
+              );
+            }
+          }
+          this.checkEnvironment();
+          switch (options.mode) {
+            case "mcp-server":
+              await this.startMcpServerMode(options);
+              break;
+            case "stdio":
+              await this.startNormalMode(options);
+              break;
+            case "normal":
+              await this.startNormalMode(options);
+              break;
+            default:
+              await this.startNormalMode(options);
+              break;
+          }
+        } catch (error) {
+          if (error instanceof ServiceError) {
+            throw error;
+          }
+          throw ServiceError.startFailed(
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+      /**
+       * 停止服务
+       */
+      async stop() {
+        try {
+          const status = this.getStatus();
+          if (!status.running) {
+            throw ServiceError.notRunning();
+          }
+          await this.processManager.gracefulKillProcess(status.pid || 0);
+          this.processManager.cleanupPidFile();
+        } catch (error) {
+          if (error instanceof ServiceError) {
+            throw error;
+          }
+          throw new ServiceError(
+            `\u505C\u6B62\u670D\u52A1\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 重启服务
+       */
+      async restart(options) {
+        try {
+          const status = this.getStatus();
+          if (status.running) {
+            await this.stop();
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+          }
+          await this.start(options);
+        } catch (error) {
+          throw new ServiceError(
+            `\u91CD\u542F\u670D\u52A1\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 获取服务状态
+       */
+      getStatus() {
+        return this.processManager.getServiceStatus();
+      }
+      /**
+       * 验证启动选项
+       */
+      validateStartOptions(options) {
+        if (options.port !== void 0) {
+          Validation.validatePort(options.port);
+        }
+        if (options.mode && !["normal", "mcp-server", "stdio"].includes(options.mode)) {
+          throw new ServiceError(`\u65E0\u6548\u7684\u8FD0\u884C\u6A21\u5F0F: ${options.mode}`);
+        }
+      }
+      /**
+       * 检查环境配置
+       */
+      checkEnvironment() {
+        if (!this.configManager.configExists()) {
+          throw ConfigError.configNotFound();
+        }
+        try {
+          const config = this.configManager.getConfig();
+          if (!config) {
+            throw new ConfigError("\u914D\u7F6E\u6587\u4EF6\u65E0\u6548");
+          }
+        } catch (error) {
+          if (error instanceof ConfigError) {
+            throw error;
+          }
+          throw new ConfigError(
+            `\u914D\u7F6E\u6587\u4EF6\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 启动普通模式
+       */
+      async startNormalMode(options) {
+        if (options.daemon) {
+          await this.startWebServerInDaemon();
+        } else {
+          await this.startWebServerInForeground();
+        }
+      }
+      /**
+       * 启动 MCP Server 模式
+       */
+      async startMcpServerMode(options) {
+        const port = options.port || 3e3;
+        const { spawn: spawn2 } = await import("child_process");
+        if (options.daemon) {
+          const scriptPath2 = PathUtils.getExecutablePath("cli");
+          const child = spawn2(
+            "node",
+            [scriptPath2, "start", "--server", port.toString()],
+            {
+              detached: true,
+              stdio: ["ignore", "ignore", "ignore"],
+              // 完全忽略所有 stdio，避免阻塞
+              env: {
+                ...process.env,
+                XIAOZHI_CONFIG_DIR: PathUtils.getConfigDir(),
+                XIAOZHI_DAEMON: "true",
+                MCP_SERVER_MODE: "true"
+              }
+            }
+          );
+          this.processManager.savePidInfo(child.pid || 0, "daemon");
+          child.unref();
+          console.log(
+            `\u2705 MCP Server \u5DF2\u5728\u540E\u53F0\u542F\u52A8 (PID: ${child.pid}, Port: ${port})`
+          );
+          console.log(`\u{1F4A1} \u4F7F\u7528 'xiaozhi status' \u67E5\u770B\u72B6\u6001`);
+          process.exit(0);
+        } else {
+          const { WebServer } = await import("../backend/WebServer.js");
+          const server = new WebServer(port);
+          const cleanup = /* @__PURE__ */ __name(async () => {
+            await server.stop();
+            process.exit(0);
+          }, "cleanup");
+          process.on("SIGINT", cleanup);
+          process.on("SIGTERM", cleanup);
+          await server.start();
+        }
+      }
+      /**
+       * 后台模式启动 WebServer
+       */
+      async startWebServerInDaemon() {
+        const { spawn: spawn2 } = await import("child_process");
+        const webServerPath = PathUtils.getWebServerLauncherPath();
+        const fs5 = await import("fs");
+        if (!fs5.default.existsSync(webServerPath)) {
+          throw new ServiceError(`WebServer \u6587\u4EF6\u4E0D\u5B58\u5728: ${webServerPath}`);
+        }
+        const args = [webServerPath];
+        const child = spawn2("node", args, {
+          detached: true,
+          stdio: ["ignore", "ignore", "ignore"],
+          // 完全忽略所有 stdio，避免阻塞
+          env: {
+            ...process.env,
+            XIAOZHI_CONFIG_DIR: PathUtils.getConfigDir(),
+            XIAOZHI_DAEMON: "true"
+          }
+        });
+        this.processManager.savePidInfo(child.pid || 0, "daemon");
+        child.unref();
+        console.log(`\u2705 \u540E\u53F0\u670D\u52A1\u5DF2\u542F\u52A8 (PID: ${child.pid})`);
+        console.log(`\u{1F4A1} \u4F7F\u7528 'xiaozhi status' \u67E5\u770B\u72B6\u6001`);
+        console.log(`\u{1F4A1} \u4F7F\u7528 'xiaozhi attach' \u67E5\u770B\u65E5\u5FD7`);
+        process.exit(0);
+      }
+      /**
+       * 前台模式启动 WebServer
+       */
+      async startWebServerInForeground() {
+        const { WebServer } = await import("../backend/WebServer.js");
+        const server = new WebServer();
+        const cleanup = /* @__PURE__ */ __name(async () => {
+          await server.stop();
+          this.processManager.cleanupPidFile();
+          process.exit(0);
+        }, "cleanup");
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        this.processManager.savePidInfo(process.pid, "foreground");
+        await server.start();
+      }
+    };
+  }
+});
+
+// src/services/TemplateManager.ts
+var TemplateManager_exports = {};
+__export(TemplateManager_exports, {
+  TemplateManagerImpl: () => TemplateManagerImpl
+});
+import fs4 from "fs";
+import path4 from "path";
+var TemplateManagerImpl;
+var init_TemplateManager = __esm({
+  "src/services/TemplateManager.ts"() {
+    init_errors();
+    init_FileUtils();
+    init_PathUtils();
+    init_Validation();
+    TemplateManagerImpl = class {
+      static {
+        __name(this, "TemplateManagerImpl");
+      }
+      templateCache = /* @__PURE__ */ new Map();
+      /**
+       * 获取可用模板列表
+       */
+      async getAvailableTemplates() {
+        try {
+          const templatesDir = PathUtils.findTemplatesDir();
+          if (!templatesDir) {
+            return [];
+          }
+          const templates = [];
+          const templateDirs = fs4.readdirSync(templatesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+          for (const templateName of templateDirs) {
+            try {
+              const templateInfo = await this.getTemplateInfo(templateName);
+              if (templateInfo) {
+                templates.push(templateInfo);
+              }
+            } catch (error) {
+              console.warn(`\u8DF3\u8FC7\u65E0\u6548\u6A21\u677F: ${templateName}`);
+            }
+          }
+          return templates;
+        } catch (error) {
+          throw new FileError(
+            "\u65E0\u6CD5\u8BFB\u53D6\u6A21\u677F\u76EE\u5F55",
+            PathUtils.findTemplatesDir() || ""
+          );
+        }
+      }
+      /**
+       * 获取模板信息
+       */
+      async getTemplateInfo(templateName) {
+        try {
+          Validation.validateTemplateName(templateName);
+          if (this.templateCache.has(templateName)) {
+            return this.templateCache.get(templateName);
+          }
+          const templatePath = PathUtils.getTemplatePath(templateName);
+          if (!templatePath) {
+            return null;
+          }
+          const configPath = path4.join(templatePath, "template.json");
+          let config = {};
+          if (FileUtils.exists(configPath)) {
+            try {
+              const configContent = FileUtils.readFile(configPath);
+              config = JSON.parse(configContent);
+            } catch (error) {
+              console.warn(`\u6A21\u677F\u914D\u7F6E\u6587\u4EF6\u89E3\u6790\u5931\u8D25: ${templateName}`);
+            }
+          }
+          const files = this.getTemplateFiles(templatePath);
+          const templateInfo = {
+            name: templateName,
+            path: templatePath,
+            description: config.description || `${templateName} \u6A21\u677F`,
+            version: config.version || "1.0.0",
+            author: config.author,
+            files
+          };
+          this.templateCache.set(templateName, templateInfo);
+          return templateInfo;
+        } catch (error) {
+          if (error instanceof ValidationError) {
+            throw error;
+          }
+          throw new FileError(`\u65E0\u6CD5\u83B7\u53D6\u6A21\u677F\u4FE1\u606F: ${templateName}`, "");
+        }
+      }
+      /**
+       * 复制模板到目标目录
+       */
+      async copyTemplate(templateName, targetPath) {
+        await this.createProject({
+          templateName,
+          targetPath,
+          projectName: path4.basename(targetPath)
+        });
+      }
+      /**
+       * 创建项目
+       */
+      async createProject(options) {
+        try {
+          this.validateCreateOptions(options);
+          const templateName = options.templateName || "default";
+          const templateInfo = await this.getTemplateInfo(templateName);
+          if (!templateInfo) {
+            throw new FileError(`\u6A21\u677F\u4E0D\u5B58\u5728: ${templateName}`, "");
+          }
+          const targetPath = path4.resolve(options.targetPath);
+          if (FileUtils.exists(targetPath)) {
+            throw FileError.alreadyExists(targetPath);
+          }
+          FileUtils.ensureDir(targetPath);
+          await this.copyTemplateFiles(templateInfo, targetPath, options);
+          await this.processTemplateVariables(targetPath, options);
+          console.log(`\u2705 \u9879\u76EE\u521B\u5EFA\u6210\u529F: ${targetPath}`);
+        } catch (error) {
+          if (error instanceof FileError || error instanceof ValidationError) {
+            throw error;
+          }
+          throw new FileError(
+            `\u521B\u5EFA\u9879\u76EE\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`,
+            options.targetPath
+          );
+        }
+      }
+      /**
+       * 验证模板
+       */
+      async validateTemplate(templateName) {
+        try {
+          const templateInfo = await this.getTemplateInfo(templateName);
+          if (!templateInfo) {
+            return false;
+          }
+          const requiredFiles = ["package.json"];
+          for (const requiredFile of requiredFiles) {
+            const filePath = path4.join(templateInfo.path, requiredFile);
+            if (!FileUtils.exists(filePath)) {
+              console.warn(`\u6A21\u677F\u7F3A\u5C11\u5FC5\u8981\u6587\u4EF6: ${requiredFile}`);
+              return false;
+            }
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * 清除模板缓存
+       */
+      clearCache() {
+        this.templateCache.clear();
+      }
+      /**
+       * 获取模板文件列表
+       */
+      getTemplateFiles(templatePath) {
+        try {
+          const files = FileUtils.listDirectory(templatePath, {
+            recursive: true,
+            includeHidden: false
+          });
+          return files.filter((file) => {
+            const relativePath = path4.relative(templatePath, file);
+            return !relativePath.startsWith(".") && relativePath !== "template.json" && !relativePath.includes("node_modules");
+          });
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * 验证创建选项
+       */
+      validateCreateOptions(options) {
+        Validation.validateRequired(options.targetPath, "targetPath");
+        Validation.validateRequired(options.projectName, "projectName");
+        Validation.validateProjectName(options.projectName);
+        if (options.templateName) {
+          Validation.validateTemplateName(options.templateName);
+        }
+      }
+      /**
+       * 复制模板文件
+       */
+      async copyTemplateFiles(templateInfo, targetPath, options) {
+        try {
+          FileUtils.copyDirectory(templateInfo.path, targetPath, {
+            exclude: ["template.json", ".git", "node_modules"],
+            overwrite: false,
+            recursive: true
+          });
+        } catch (error) {
+          throw new FileError(
+            `\u590D\u5236\u6A21\u677F\u6587\u4EF6\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`,
+            templateInfo.path
+          );
+        }
+      }
+      /**
+       * 处理模板变量替换
+       */
+      async processTemplateVariables(targetPath, options) {
+        try {
+          const variables = {
+            PROJECT_NAME: options.projectName,
+            PROJECT_NAME_LOWER: options.projectName.toLowerCase(),
+            PROJECT_NAME_UPPER: options.projectName.toUpperCase(),
+            ...options.variables
+          };
+          const filesToProcess = [
+            "package.json",
+            "README.md",
+            "src/**/*.ts",
+            "src/**/*.js",
+            "src/**/*.json"
+          ];
+          for (const pattern of filesToProcess) {
+            const files = this.findFilesByPattern(targetPath, pattern);
+            for (const filePath of files) {
+              await this.replaceVariablesInFile(filePath, variables);
+            }
+          }
+        } catch (error) {
+          console.warn(
+            `\u5904\u7406\u6A21\u677F\u53D8\u91CF\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 根据模式查找文件
+       */
+      findFilesByPattern(basePath, pattern) {
+        try {
+          if (!pattern.includes("*")) {
+            const filePath = path4.join(basePath, pattern);
+            return FileUtils.exists(filePath) ? [filePath] : [];
+          }
+          const files = FileUtils.listDirectory(basePath, { recursive: true });
+          const regex = new RegExp(
+            pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
+          );
+          return files.filter((file) => {
+            const relativePath = path4.relative(basePath, file).split(path4.sep).join("/");
+            return regex.test(relativePath);
+          });
+        } catch {
+          return [];
+        }
+      }
+      /**
+       * 替换文件中的变量
+       */
+      async replaceVariablesInFile(filePath, variables) {
+        try {
+          let content = FileUtils.readFile(filePath);
+          let hasChanges = false;
+          for (const [key, value] of Object.entries(variables)) {
+            const regex = new RegExp(`{{\\s*${key}\\s*}}`, "g");
+            if (regex.test(content)) {
+              content = content.replace(regex, value);
+              hasChanges = true;
+            }
+          }
+          if (hasChanges) {
+            FileUtils.writeFile(filePath, content, { overwrite: true });
+          }
+        } catch (error) {
+          console.warn(
+            `\u66FF\u6362\u6587\u4EF6\u53D8\u91CF\u5931\u8D25 ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/interfaces/Command.ts
+var BaseCommandHandler;
+var init_Command = __esm({
+  "src/interfaces/Command.ts"() {
+    BaseCommandHandler = class {
+      constructor(container) {
+        this.container = container;
+      }
+      static {
+        __name(this, "BaseCommandHandler");
+      }
+      options;
+      subcommands;
+      /**
+       * 获取服务实例
+       */
+      getService(serviceName) {
+        return this.container.get(serviceName);
+      }
+      /**
+       * 处理错误
+       */
+      handleError(error) {
+        const errorHandler = this.getService("errorHandler");
+        const handler = errorHandler;
+        handler.handle(error);
+      }
+      /**
+       * 验证参数
+       */
+      validateArgs(args, expectedCount) {
+        if (args.length < expectedCount) {
+          throw new Error(
+            `\u547D\u4EE4\u9700\u8981\u81F3\u5C11 ${expectedCount} \u4E2A\u53C2\u6570\uFF0C\u4F46\u53EA\u63D0\u4F9B\u4E86 ${args.length} \u4E2A`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/commands/ServiceCommandHandler.ts
+var ServiceCommandHandler_exports = {};
+__export(ServiceCommandHandler_exports, {
+  ServiceCommandHandler: () => ServiceCommandHandler
+});
+import { setGlobalLogLevel } from "../backend/Logger.js";
+var ServiceCommandHandler;
+var init_ServiceCommandHandler = __esm({
+  "src/commands/ServiceCommandHandler.ts"() {
+    init_Command();
+    ServiceCommandHandler = class extends BaseCommandHandler {
+      static {
+        __name(this, "ServiceCommandHandler");
+      }
+      name = "service";
+      description = "\u670D\u52A1\u7BA1\u7406\u547D\u4EE4";
+      subcommands = [
+        {
+          name: "start",
+          description: "\u542F\u52A8\u670D\u52A1",
+          options: [
+            { flags: "-d, --daemon", description: "\u5728\u540E\u53F0\u8FD0\u884C\u670D\u52A1" },
+            { flags: "--debug", description: "\u542F\u7528\u8C03\u8BD5\u6A21\u5F0F (\u8F93\u51FADEBUG\u7EA7\u522B\u65E5\u5FD7)" },
+            {
+              flags: "--stdio",
+              description: "\u4EE5 stdio \u6A21\u5F0F\u8FD0\u884C MCP Server (\u7528\u4E8E Cursor \u7B49\u5BA2\u6237\u7AEF)"
+            }
+          ],
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleStart(options);
+          }, "execute")
+        },
+        {
+          name: "stop",
+          description: "\u505C\u6B62\u670D\u52A1",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleStop();
+          }, "execute")
+        },
+        {
+          name: "status",
+          description: "\u68C0\u67E5\u670D\u52A1\u72B6\u6001",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleStatus();
+          }, "execute")
+        },
+        {
+          name: "restart",
+          description: "\u91CD\u542F\u670D\u52A1",
+          options: [{ flags: "-d, --daemon", description: "\u5728\u540E\u53F0\u8FD0\u884C\u670D\u52A1" }],
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleRestart(options);
+          }, "execute")
+        },
+        {
+          name: "attach",
+          description: "\u8FDE\u63A5\u5230\u540E\u53F0\u670D\u52A1\u67E5\u770B\u65E5\u5FD7",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleAttach();
+          }, "execute")
+        }
+      ];
+      constructor(container) {
+        super(container);
+      }
+      /**
+       * 主命令执行（显示帮助）
+       */
+      async execute(args, options) {
+        console.log("\u670D\u52A1\u7BA1\u7406\u547D\u4EE4\u3002\u4F7F\u7528 --help \u67E5\u770B\u53EF\u7528\u7684\u5B50\u547D\u4EE4\u3002");
+      }
+      /**
+       * 处理启动命令
+       */
+      async handleStart(options) {
+        try {
+          if (options.debug) {
+            setGlobalLogLevel("debug");
+          }
+          const serviceManager = this.getService("serviceManager");
+          if (options.stdio) {
+            this.showStdioMigrationGuide();
+            return;
+          }
+          await serviceManager.start({
+            daemon: options.daemon || false
+          });
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理停止命令
+       */
+      async handleStop() {
+        try {
+          const serviceManager = this.getService("serviceManager");
+          await serviceManager.stop();
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理状态检查命令
+       */
+      async handleStatus() {
+        try {
+          const serviceManager = this.getService("serviceManager");
+          const status = await serviceManager.getStatus();
+          if (status.running) {
+            console.log(`\u2705 \u670D\u52A1\u6B63\u5728\u8FD0\u884C (PID: ${status.pid})`);
+            if (status.uptime) {
+              console.log(`\u23F1\uFE0F  \u8FD0\u884C\u65F6\u95F4: ${status.uptime}`);
+            }
+            if (status.mode) {
+              console.log(`\u{1F527} \u8FD0\u884C\u6A21\u5F0F: ${status.mode}`);
+            }
+          } else {
+            console.log("\u274C \u670D\u52A1\u672A\u8FD0\u884C");
+          }
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理重启命令
+       */
+      async handleRestart(options) {
+        try {
+          const serviceManager = this.getService("serviceManager");
+          await serviceManager.restart({
+            daemon: options.daemon || false
+          });
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理附加命令
+       */
+      async handleAttach() {
+        try {
+          const daemonManager = this.getService("daemonManager");
+          await daemonManager.attachToLogs();
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 显示 stdio 模式迁移指南
+       */
+      showStdioMigrationGuide() {
+        console.log("\n\u274C stdio \u6A21\u5F0F\u5DF2\u5E9F\u5F03\n");
+        console.log("\u5C0F\u667A\u5BA2\u6237\u7AEF\u5DF2\u8FC1\u79FB\u5230\u7EAF HTTP \u67B6\u6784\uFF0C\u8BF7\u4F7F\u7528\u4EE5\u4E0B\u65B9\u5F0F\uFF1A\n");
+        console.log("1. \u542F\u52A8 Web \u670D\u52A1\uFF1A");
+        console.log("   xiaozhi start\n");
+        console.log("2. \u5728 Cursor \u4E2D\u914D\u7F6E HTTP \u7AEF\u70B9\uFF1A");
+        console.log('   "mcpServers": {');
+        console.log('     "xiaozhi-client": {');
+        console.log('       "type": "streamableHttp",');
+        console.log('       "url": "http://localhost:9999/mcp"');
+        console.log("     }");
+        console.log("   }\n");
+      }
+    };
+  }
+});
+
+// src/commands/ConfigCommandHandler.ts
+var ConfigCommandHandler_exports = {};
+__export(ConfigCommandHandler_exports, {
+  ConfigCommandHandler: () => ConfigCommandHandler
+});
+import path5 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+var ConfigCommandHandler;
+var init_ConfigCommandHandler = __esm({
+  "src/commands/ConfigCommandHandler.ts"() {
+    init_Command();
+    ConfigCommandHandler = class extends BaseCommandHandler {
+      static {
+        __name(this, "ConfigCommandHandler");
+      }
+      name = "config";
+      description = "\u914D\u7F6E\u7BA1\u7406\u547D\u4EE4";
+      subcommands = [
+        {
+          name: "init",
+          description: "\u521D\u59CB\u5316\u914D\u7F6E\u6587\u4EF6",
+          options: [
+            {
+              flags: "-f, --format <format>",
+              description: "\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F (json, json5, jsonc)",
+              defaultValue: "json"
+            }
+          ],
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleInit(options);
+          }, "execute")
+        },
+        {
+          name: "get",
+          description: "\u67E5\u770B\u914D\u7F6E\u503C",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 1);
+            await this.handleGet(args[0]);
+          }, "execute")
+        },
+        {
+          name: "set",
+          description: "\u8BBE\u7F6E\u914D\u7F6E\u503C",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 2);
+            await this.handleSet(args[0], args[1]);
+          }, "execute")
+        }
+      ];
+      constructor(container) {
+        super(container);
+      }
+      /**
+       * 主命令执行（显示帮助）
+       */
+      async execute(args, options) {
+        console.log("\u914D\u7F6E\u7BA1\u7406\u547D\u4EE4\u3002\u4F7F\u7528 --help \u67E5\u770B\u53EF\u7528\u7684\u5B50\u547D\u4EE4\u3002");
+      }
+      /**
+       * 处理初始化命令
+       */
+      async handleInit(options) {
+        const spinner = ora("\u521D\u59CB\u5316\u914D\u7F6E...").start();
+        try {
+          const format = options.format;
+          if (format !== "json" && format !== "json5" && format !== "jsonc") {
+            throw new Error("\u683C\u5F0F\u5FC5\u987B\u662F json, json5 \u6216 jsonc");
+          }
+          const configManager3 = this.getService("configManager");
+          if (configManager3.configExists()) {
+            spinner.warn("\u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728");
+            console.log(chalk2.yellow("\u5982\u9700\u91CD\u65B0\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u5220\u9664\u73B0\u6709\u7684\u914D\u7F6E\u6587\u4EF6"));
+            return;
+          }
+          configManager3.initConfig(format);
+          spinner.succeed("\u914D\u7F6E\u6587\u4EF6\u521D\u59CB\u5316\u6210\u529F");
+          const configDir = process.env.XIAOZHI_CONFIG_DIR || process.cwd();
+          const configFileName = `xiaozhi.config.${format}`;
+          const configPath = path5.join(configDir, configFileName);
+          console.log(chalk2.green(`\u2705 \u914D\u7F6E\u6587\u4EF6\u5DF2\u521B\u5EFA: ${configFileName}`));
+          console.log(chalk2.yellow("\u{1F4DD} \u8BF7\u7F16\u8F91\u914D\u7F6E\u6587\u4EF6\u8BBE\u7F6E\u4F60\u7684 MCP \u7AEF\u70B9:"));
+          console.log(chalk2.gray(`   \u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84: ${configPath}`));
+          console.log(chalk2.yellow("\u{1F4A1} \u6216\u8005\u4F7F\u7528\u547D\u4EE4\u8BBE\u7F6E:"));
+          console.log(
+            chalk2.gray("   xiaozhi config set mcpEndpoint <your-endpoint-url>")
+          );
+        } catch (error) {
+          spinner.fail(
+            `\u521D\u59CB\u5316\u914D\u7F6E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理获取配置命令
+       */
+      async handleGet(key) {
+        const spinner = ora("\u8BFB\u53D6\u914D\u7F6E...").start();
+        try {
+          const configManager3 = this.getService("configManager");
+          if (!configManager3.configExists()) {
+            spinner.fail("\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728");
+            console.log(
+              chalk2.yellow('\u{1F4A1} \u63D0\u793A: \u8BF7\u5148\u8FD0\u884C "xiaozhi config init" \u521D\u59CB\u5316\u914D\u7F6E')
+            );
+            return;
+          }
+          const config = configManager3.getConfig();
+          switch (key) {
+            case "mcpEndpoint": {
+              spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
+              const endpoints = configManager3.getMcpEndpoints();
+              if (endpoints.length === 0) {
+                console.log(chalk2.yellow("\u672A\u914D\u7F6E\u4EFB\u4F55 MCP \u7AEF\u70B9"));
+              } else if (endpoints.length === 1) {
+                console.log(chalk2.green(`MCP \u7AEF\u70B9: ${endpoints[0]}`));
+              } else {
+                console.log(chalk2.green(`MCP \u7AEF\u70B9 (${endpoints.length} \u4E2A):`));
+                endpoints.forEach((ep, index) => {
+                  console.log(chalk2.gray(`  ${index + 1}. ${ep}`));
+                });
+              }
+              break;
+            }
+            case "mcpServers":
+              spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
+              console.log(chalk2.green("MCP \u670D\u52A1:"));
+              for (const [name, serverConfig] of Object.entries(
+                config.mcpServers
+              )) {
+                const server = serverConfig;
+                if ("type" in server && server.type === "sse") {
+                  console.log(chalk2.gray(`  ${name}: [SSE] ${server.url}`));
+                } else {
+                  console.log(
+                    chalk2.gray(
+                      `  ${name}: ${server.command} ${server.args.join(" ")}`
+                    )
+                  );
+                }
+              }
+              break;
+            case "connection": {
+              spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
+              const connectionConfig = configManager3.getConnectionConfig();
+              console.log(chalk2.green("\u8FDE\u63A5\u914D\u7F6E:"));
+              console.log(
+                chalk2.gray(
+                  `  \u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694: ${connectionConfig.heartbeatInterval}ms`
+                )
+              );
+              console.log(
+                chalk2.gray(`  \u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4: ${connectionConfig.heartbeatTimeout}ms`)
+              );
+              console.log(
+                chalk2.gray(`  \u91CD\u8FDE\u95F4\u9694: ${connectionConfig.reconnectInterval}ms`)
+              );
+              break;
+            }
+            case "heartbeatInterval":
+              spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
+              console.log(
+                chalk2.green(
+                  `\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694: ${configManager3.getHeartbeatInterval()}ms`
+                )
+              );
+              break;
+            case "heartbeatTimeout":
+              spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
+              console.log(
+                chalk2.green(
+                  `\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4: ${configManager3.getHeartbeatTimeout()}ms`
+                )
+              );
+              break;
+            case "reconnectInterval":
+              spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
+              console.log(
+                chalk2.green(`\u91CD\u8FDE\u95F4\u9694: ${configManager3.getReconnectInterval()}ms`)
+              );
+              break;
+            default:
+              spinner.fail(`\u672A\u77E5\u7684\u914D\u7F6E\u9879: ${key}`);
+              console.log(
+                chalk2.yellow(
+                  "\u652F\u6301\u7684\u914D\u7F6E\u9879: mcpEndpoint, mcpServers, connection, heartbeatInterval, heartbeatTimeout, reconnectInterval"
+                )
+              );
+          }
+        } catch (error) {
+          spinner.fail(
+            `\u8BFB\u53D6\u914D\u7F6E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理设置配置命令
+       */
+      async handleSet(key, value) {
+        const spinner = ora("\u66F4\u65B0\u914D\u7F6E...").start();
+        try {
+          const configManager3 = this.getService("configManager");
+          if (!configManager3.configExists()) {
+            spinner.fail("\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728");
+            console.log(
+              chalk2.yellow('\u{1F4A1} \u63D0\u793A: \u8BF7\u5148\u8FD0\u884C "xiaozhi config init" \u521D\u59CB\u5316\u914D\u7F6E')
+            );
+            return;
+          }
+          switch (key) {
+            case "mcpEndpoint":
+              configManager3.updateMcpEndpoint(value);
+              spinner.succeed(`MCP \u7AEF\u70B9\u5DF2\u8BBE\u7F6E\u4E3A: ${value}`);
+              break;
+            case "heartbeatInterval": {
+              const interval = Number.parseInt(value);
+              if (Number.isNaN(interval) || interval <= 0) {
+                throw new Error("\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694\u5FC5\u987B\u662F\u6B63\u6574\u6570");
+              }
+              configManager3.updateHeartbeatInterval(interval);
+              spinner.succeed(`\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694\u5DF2\u8BBE\u7F6E\u4E3A: ${interval}ms`);
+              break;
+            }
+            case "heartbeatTimeout": {
+              const timeout = Number.parseInt(value);
+              if (Number.isNaN(timeout) || timeout <= 0) {
+                throw new Error("\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4\u5FC5\u987B\u662F\u6B63\u6574\u6570");
+              }
+              configManager3.updateHeartbeatTimeout(timeout);
+              spinner.succeed(`\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4\u5DF2\u8BBE\u7F6E\u4E3A: ${timeout}ms`);
+              break;
+            }
+            case "reconnectInterval": {
+              const interval = Number.parseInt(value);
+              if (Number.isNaN(interval) || interval <= 0) {
+                throw new Error("\u91CD\u8FDE\u95F4\u9694\u5FC5\u987B\u662F\u6B63\u6574\u6570");
+              }
+              configManager3.updateReconnectInterval(interval);
+              spinner.succeed(`\u91CD\u8FDE\u95F4\u9694\u5DF2\u8BBE\u7F6E\u4E3A: ${interval}ms`);
+              break;
+            }
+            default:
+              spinner.fail(`\u4E0D\u652F\u6301\u8BBE\u7F6E\u7684\u914D\u7F6E\u9879: ${key}`);
+              console.log(
+                chalk2.yellow(
+                  "\u652F\u6301\u8BBE\u7F6E\u7684\u914D\u7F6E\u9879: mcpEndpoint, heartbeatInterval, heartbeatTimeout, reconnectInterval"
+                )
+              );
+          }
+        } catch (error) {
+          spinner.fail(
+            `\u8BBE\u7F6E\u914D\u7F6E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/ProjectCommandHandler.ts
+var ProjectCommandHandler_exports = {};
+__export(ProjectCommandHandler_exports, {
+  ProjectCommandHandler: () => ProjectCommandHandler
+});
+import path6 from "path";
+import chalk3 from "chalk";
+import ora2 from "ora";
+var ProjectCommandHandler;
+var init_ProjectCommandHandler = __esm({
+  "src/commands/ProjectCommandHandler.ts"() {
+    init_Command();
+    ProjectCommandHandler = class extends BaseCommandHandler {
+      static {
+        __name(this, "ProjectCommandHandler");
+      }
+      name = "create";
+      description = "\u521B\u5EFA\u9879\u76EE";
+      options = [
+        {
+          flags: "-t, --template <templateName>",
+          description: "\u4F7F\u7528\u6307\u5B9A\u6A21\u677F\u521B\u5EFA\u9879\u76EE"
+        }
+      ];
+      constructor(container) {
+        super(container);
+      }
+      /**
+       * 执行创建项目命令
+       */
+      async execute(args, options) {
+        this.validateArgs(args, 1);
+        const projectName = args[0];
+        await this.handleCreate(projectName, options);
+      }
+      /**
+       * 处理创建项目命令
+       */
+      async handleCreate(projectName, options) {
+        const spinner = ora2("\u521D\u59CB\u5316\u9879\u76EE...").start();
+        try {
+          const templateManager = this.getService("templateManager");
+          const fileUtils = this.getService("fileUtils");
+          const targetPath = path6.join(process.cwd(), projectName);
+          if (await fileUtils.exists(targetPath)) {
+            spinner.fail(`\u76EE\u5F55 "${projectName}" \u5DF2\u5B58\u5728`);
+            console.log(
+              chalk3.yellow("\u{1F4A1} \u63D0\u793A: \u8BF7\u9009\u62E9\u4E0D\u540C\u7684\u9879\u76EE\u540D\u79F0\u6216\u5220\u9664\u73B0\u6709\u76EE\u5F55")
+            );
+            return;
+          }
+          if (options.template) {
+            await this.createFromTemplate(
+              projectName,
+              options.template,
+              targetPath,
+              spinner,
+              templateManager
+            );
+          } else {
+            await this.createBasicProject(
+              projectName,
+              targetPath,
+              spinner,
+              templateManager
+            );
+          }
+        } catch (error) {
+          spinner.fail(
+            `\u521B\u5EFA\u9879\u76EE\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+      /**
+       * 从模板创建项目
+       */
+      async createFromTemplate(projectName, templateName, targetPath, spinner, templateManager) {
+        spinner.text = "\u68C0\u67E5\u6A21\u677F...";
+        const availableTemplates = await templateManager.getAvailableTemplates();
+        if (availableTemplates.length === 0) {
+          spinner.fail("\u627E\u4E0D\u5230\u53EF\u7528\u6A21\u677F");
+          console.log(chalk3.yellow("\u{1F4A1} \u63D0\u793A: \u8BF7\u786E\u4FDD xiaozhi-client \u6B63\u786E\u5B89\u88C5"));
+          return;
+        }
+        let actualTemplateName = templateName;
+        const isValidTemplate = await templateManager.validateTemplate(actualTemplateName);
+        if (!isValidTemplate) {
+          spinner.fail(`\u6A21\u677F "${actualTemplateName}" \u4E0D\u5B58\u5728`);
+          const similarTemplate = this.findSimilarTemplate(
+            actualTemplateName,
+            availableTemplates
+          );
+          if (similarTemplate) {
+            console.log(
+              chalk3.yellow(`\u{1F4A1} \u4F60\u662F\u60F3\u4F7F\u7528\u6A21\u677F "${similarTemplate}" \u5417\uFF1F`)
+            );
+            const confirmed = await this.askUserConfirmation(
+              chalk3.cyan("\u786E\u8BA4\u4F7F\u7528\u6B64\u6A21\u677F\uFF1F(y/n): ")
+            );
+            if (confirmed) {
+              actualTemplateName = similarTemplate;
+            } else {
+              this.showAvailableTemplates(availableTemplates);
+              return;
+            }
+          } else {
+            this.showAvailableTemplates(availableTemplates);
+            return;
+          }
+        }
+        spinner.text = `\u4ECE\u6A21\u677F "${actualTemplateName}" \u521B\u5EFA\u9879\u76EE "${projectName}"...`;
+        await templateManager.createProject({
+          templateName: actualTemplateName,
+          targetPath,
+          projectName
+        });
+        spinner.succeed(`\u9879\u76EE "${projectName}" \u521B\u5EFA\u6210\u529F`);
+        console.log(chalk3.green("\u2705 \u9879\u76EE\u521B\u5EFA\u5B8C\u6210!"));
+        console.log(chalk3.yellow("\u{1F4DD} \u63A5\u4E0B\u6765\u7684\u6B65\u9AA4:"));
+        console.log(chalk3.gray(`   cd ${projectName}`));
+        console.log(chalk3.gray("   pnpm install  # \u5B89\u88C5\u4F9D\u8D56"));
+        console.log(chalk3.gray("   # \u7F16\u8F91 xiaozhi.config.json \u8BBE\u7F6E\u4F60\u7684 MCP \u7AEF\u70B9"));
+        console.log(chalk3.gray("   xiaozhi start  # \u542F\u52A8\u670D\u52A1"));
+      }
+      /**
+       * 创建基本项目
+       */
+      async createBasicProject(projectName, targetPath, spinner, templateManager) {
+        spinner.text = `\u521B\u5EFA\u57FA\u672C\u9879\u76EE "${projectName}"...`;
+        await templateManager.createProject({
+          templateName: null,
+          // 表示创建基本项目
+          targetPath,
+          projectName
+        });
+        spinner.succeed(`\u9879\u76EE "${projectName}" \u521B\u5EFA\u6210\u529F`);
+        console.log(chalk3.green("\u2705 \u57FA\u672C\u9879\u76EE\u521B\u5EFA\u5B8C\u6210!"));
+        console.log(chalk3.yellow("\u{1F4DD} \u63A5\u4E0B\u6765\u7684\u6B65\u9AA4:"));
+        console.log(chalk3.gray(`   cd ${projectName}`));
+        console.log(
+          chalk3.gray("   # \u7F16\u8F91 xiaozhi.config.json \u8BBE\u7F6E\u4F60\u7684 MCP \u7AEF\u70B9\u548C\u670D\u52A1")
+        );
+        console.log(chalk3.gray("   xiaozhi start  # \u542F\u52A8\u670D\u52A1"));
+        console.log(
+          chalk3.yellow("\u{1F4A1} \u63D0\u793A: \u4F7F\u7528 --template \u9009\u9879\u53EF\u4EE5\u4ECE\u6A21\u677F\u521B\u5EFA\u9879\u76EE")
+        );
+      }
+      /**
+       * 显示可用模板
+       */
+      showAvailableTemplates(templates) {
+        console.log(chalk3.yellow("\u53EF\u7528\u7684\u6A21\u677F:"));
+        for (const template of templates) {
+          console.log(chalk3.gray(`  - ${template}`));
+        }
+      }
+      /**
+       * 查找相似模板
+       */
+      findSimilarTemplate(input, templates) {
+        const formatUtils = this.getService("formatUtils");
+        let bestMatch = null;
+        let bestSimilarity = 0;
+        for (const template of templates) {
+          const similarity = formatUtils.calculateSimilarity(
+            input.toLowerCase(),
+            template.toLowerCase()
+          );
+          if (similarity > bestSimilarity && similarity > 0.6) {
+            bestSimilarity = similarity;
+            bestMatch = template;
+          }
+        }
+        return bestMatch;
+      }
+      /**
+       * 询问用户确认
+       */
+      async askUserConfirmation(prompt) {
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        return new Promise((resolve) => {
+          rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(
+              answer.toLowerCase().trim() === "y" || answer.toLowerCase().trim() === "yes"
+            );
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/interfaces/CommandTypes.ts
+function isLocalMCPServerConfig(obj) {
+  const config = obj;
+  return typeof config === "object" && config !== null && "command" in config && "args" in config && typeof config.command === "string" && Array.isArray(config.args) && config.args.every((arg) => typeof arg === "string");
+}
+var init_CommandTypes = __esm({
+  "src/interfaces/CommandTypes.ts"() {
+    __name(isLocalMCPServerConfig, "isLocalMCPServerConfig");
+  }
+});
+
+// src/commands/McpCommandHandler.ts
+var McpCommandHandler_exports = {};
+__export(McpCommandHandler_exports, {
+  McpCommandHandler: () => McpCommandHandler
+});
+import { configManager as configManager2 } from "../backend/lib/config/manager.js";
+import { logger as logger2 } from "../backend/Logger.js";
+import chalk4 from "chalk";
+import Table from "cli-table3";
+import ora3 from "ora";
+var McpCommandHandler;
+var init_McpCommandHandler = __esm({
+  "src/commands/McpCommandHandler.ts"() {
+    init_Command();
+    init_CommandTypes();
+    init_ProcessManager();
+    McpCommandHandler = class _McpCommandHandler extends BaseCommandHandler {
+      static {
+        __name(this, "McpCommandHandler");
+      }
+      logger;
+      processManager;
+      baseUrl;
+      constructor(...args) {
+        super(...args);
+        this.logger = logger2;
+        this.processManager = new ProcessManagerImpl();
+        try {
+          const webPort = configManager2.getWebUIPort() ?? 9999;
+          this.baseUrl = `http://localhost:${webPort}`;
+        } catch {
+          this.baseUrl = "http://localhost:9999";
+        }
+      }
+      /**
+       * 中文字符正则表达式
+       *
+       * Unicode 范围说明：
+       * - \u4e00-\u9fff: CJK 统一汉字（基本汉字）
+       * - \u3400-\u4dbf: CJK 扩展 A（扩展汉字）
+       * - \uff00-\uffef: 全角字符和半角片假名（包括中文标点符号）
+       *
+       * 注意：此范围可能不完全覆盖所有中日韩字符（如 CJK 扩展 B-F 等），
+       * 但已覆盖绝大多数常用中文场景。
+       */
+      static CHINESE_CHAR_REGEX = /[\u4e00-\u9fff\u3400-\u4dbf\uff00-\uffef]/;
+      /**
+       * 计算字符串的显示宽度（中文字符占2个宽度，英文字符占1个宽度）
+       */
+      static getDisplayWidth(str) {
+        let width = 0;
+        for (const char of str) {
+          if (_McpCommandHandler.CHINESE_CHAR_REGEX.test(char)) {
+            width += 2;
+          } else {
+            width += 1;
+          }
+        }
+        return width;
+      }
+      /**
+       * 截断字符串到指定的显示宽度
+       */
+      static truncateToWidth(str, maxWidth) {
+        if (_McpCommandHandler.getDisplayWidth(str) <= maxWidth) {
+          return str;
+        }
+        if (maxWidth <= 3) {
+          return "";
+        }
+        let result = "";
+        let currentWidth = 0;
+        let hasAddedChar = false;
+        for (const char of str) {
+          const charWidth = _McpCommandHandler.CHINESE_CHAR_REGEX.test(char) ? 2 : 1;
+          if (currentWidth + charWidth > maxWidth - 3) {
+            if (!hasAddedChar) {
+              return "";
+            }
+            result += "...";
+            break;
+          }
+          result += char;
+          currentWidth += charWidth;
+          hasAddedChar = true;
+        }
+        return result;
+      }
+      /**
+       * 解析 JSON 参数
+       * @param argsString JSON 字符串
+       * @returns 解析后的参数对象
+       */
+      static parseJsonArgs(argsString) {
+        try {
+          return JSON.parse(argsString);
+        } catch (error) {
+          throw new Error(
+            `\u53C2\u6570\u683C\u5F0F\u9519\u8BEF\uFF0C\u8BF7\u4F7F\u7528\u6709\u6548\u7684 JSON \u683C\u5F0F\u3002\u9519\u8BEF\u8BE6\u60C5: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 格式化工具调用结果输出
+       * @param result 工具调用结果
+       * @returns 格式化后的字符串
+       */
+      static formatToolCallResult(result) {
+        return JSON.stringify(result);
+      }
+      name = "mcp";
+      description = "MCP \u670D\u52A1\u548C\u5DE5\u5177\u7BA1\u7406";
+      subcommands = [
+        {
+          name: "list",
+          description: "\u5217\u51FA MCP \u670D\u52A1",
+          options: [{ flags: "--tools", description: "\u663E\u793A\u6240\u6709\u670D\u52A1\u7684\u5DE5\u5177\u5217\u8868" }],
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleList(options);
+          }, "execute")
+        },
+        {
+          name: "server",
+          description: "\u7BA1\u7406\u6307\u5B9A\u7684 MCP \u670D\u52A1",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 1);
+            await this.handleServer(args[0]);
+          }, "execute")
+        },
+        {
+          name: "tool",
+          description: "\u542F\u7528\u6216\u7981\u7528\u6307\u5B9A\u670D\u52A1\u7684\u5DE5\u5177",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 3);
+            const [serverName, toolName, action] = args;
+            if (action !== "enable" && action !== "disable") {
+              console.error(chalk4.red("\u9519\u8BEF: \u64CD\u4F5C\u5FC5\u987B\u662F 'enable' \u6216 'disable'"));
+              process.exit(1);
+            }
+            const enabled = action === "enable";
+            await this.handleTool(serverName, toolName, enabled);
+          }, "execute")
+        },
+        {
+          name: "call",
+          description: "\u8C03\u7528\u6307\u5B9A\u670D\u52A1\u7684\u5DE5\u5177",
+          options: [
+            {
+              flags: "--args <json>",
+              description: "\u5DE5\u5177\u53C2\u6570 (JSON \u683C\u5F0F)",
+              defaultValue: "{}"
+            }
+          ],
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 2);
+            const [serviceName, toolName] = args;
+            await this.handleCall(
+              serviceName,
+              toolName,
+              options.args ?? "{}"
+            );
+          }, "execute")
+        }
+      ];
+      /**
+       * 主命令执行（显示帮助）
+       */
+      async execute(args, options) {
+        console.log("MCP \u670D\u52A1\u548C\u5DE5\u5177\u7BA1\u7406\u547D\u4EE4\u3002\u4F7F\u7528 --help \u67E5\u770B\u53EF\u7528\u7684\u5B50\u547D\u4EE4\u3002");
+      }
+      /**
+       * 处理列出服务命令
+       */
+      async handleList(options) {
+        try {
+          await this.handleListInternal(options);
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理服务管理命令
+       */
+      async handleServer(serverName) {
+        try {
+          await this.handleServerInternal(serverName);
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理工具管理命令
+       */
+      async handleTool(serverName, toolName, enabled) {
+        try {
+          await this.handleToolInternal(serverName, toolName, enabled);
+        } catch (error) {
+          this.handleError(error);
+        }
+      }
+      /**
+       * 验证服务状态
+       * @private
+       */
+      async validateServiceStatus() {
+        const processStatus = this.processManager.getServiceStatus();
+        if (!processStatus.running) {
+          throw new Error(
+            "xiaozhi \u670D\u52A1\u672A\u542F\u52A8\u3002\u8BF7\u5148\u8FD0\u884C 'xiaozhi start' \u6216 'xiaozhi start -d' \u542F\u52A8\u670D\u52A1\u3002"
+          );
+        }
+        try {
+          const response = await fetch(`${this.baseUrl}/api/status`, {
+            method: "GET",
+            signal: AbortSignal.timeout(5e3)
+            // 5秒超时
+          });
+          if (!response.ok) {
+            throw new Error(`Web \u670D\u52A1\u5668\u54CD\u5E94\u9519\u8BEF: ${response.status}`);
+          }
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            throw new Error("\u8FDE\u63A5 xiaozhi \u670D\u52A1\u8D85\u65F6\u3002\u8BF7\u68C0\u67E5\u670D\u52A1\u662F\u5426\u6B63\u5E38\u8FD0\u884C\u3002");
+          }
+          if (error instanceof Error) {
+            const isNetworkError = error instanceof TypeError && /fetch|network|failed/i.test(error.message);
+            if (isNetworkError) {
+              throw new Error(
+                `\u65E0\u6CD5\u8FDE\u63A5\u5230 xiaozhi \u670D\u52A1\uFF08\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF09\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u6216\u670D\u52A1\u5730\u5740\u662F\u5426\u6B63\u786E\u3002\u539F\u59CB\u9519\u8BEF: ${error.message}`
+              );
+            }
+            throw new Error(
+              `\u65E0\u6CD5\u8FDE\u63A5\u5230 xiaozhi \u670D\u52A1\u3002\u8BF7\u68C0\u67E5\u670D\u52A1\u72B6\u6001\u3002\u539F\u59CB\u9519\u8BEF: ${error.message}`
+            );
+          }
+          let detail;
+          try {
+            detail = JSON.stringify(error);
+          } catch {
+            detail = String(error);
+          }
+          throw new Error(
+            `\u65E0\u6CD5\u8FDE\u63A5\u5230 xiaozhi \u670D\u52A1\u3002\u8BF7\u68C0\u67E5\u670D\u52A1\u72B6\u6001\u3002\u9519\u8BEF\u8BE6\u60C5: ${detail}`
+          );
+        }
+      }
+      /**
+       * 调用 MCP 工具的内部实现
+       * @param serviceName 服务名称
+       * @param toolName 工具名称
+       * @param args 工具参数
+       * @returns 工具调用结果
+       */
+      async callToolInternal(serviceName, toolName, args) {
+        await this.validateServiceStatus();
+        try {
+          const response = await fetch(`${this.baseUrl}/api/tools/call`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              serviceName,
+              toolName,
+              args
+            })
+          });
+          if (!response.ok) {
+            let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+            try {
+              const errorData = await response.json();
+              const detailedMessage = errorData?.error?.message ?? errorData?.message;
+              if (typeof detailedMessage === "string" && detailedMessage.trim()) {
+                errorMessage = detailedMessage;
+              }
+            } catch {
+            }
+            throw new Error(errorMessage);
+          }
+          const responseData = await response.json();
+          if (!responseData.success) {
+            throw new Error(responseData.error?.message || "\u5DE5\u5177\u8C03\u7528\u5931\u8D25");
+          }
+          return responseData.data;
+        } catch (error) {
+          this.logger.error(
+            `\u5DE5\u5177\u8C03\u7528\u5931\u8D25: ${serviceName}/${toolName}`,
+            error instanceof Error ? error.message : String(error)
+          );
+          throw error;
+        }
+      }
+      /**
+       * 处理工具调用命令
+       */
+      async handleCall(serviceName, toolName, argsString) {
+        try {
+          const args = _McpCommandHandler.parseJsonArgs(argsString);
+          const result = await this.callToolInternal(serviceName, toolName, args);
+          console.log(_McpCommandHandler.formatToolCallResult(result));
+        } catch (error) {
+          console.log(`\u5DE5\u5177\u8C03\u7528\u5931\u8D25: ${serviceName}/${toolName}`);
+          console.error(chalk4.red("\u9519\u8BEF:"), error.message);
+          const errorMessage = error.message;
+          if (errorMessage.includes("\u670D\u52A1\u672A\u542F\u52A8")) {
+            console.log();
+            console.log(chalk4.yellow("\u{1F4A1} \u8BF7\u5148\u542F\u52A8\u670D\u52A1:"));
+            console.log(chalk4.gray("  xiaozhi start        # \u524D\u53F0\u542F\u52A8"));
+            console.log(chalk4.gray("  xiaozhi start -d     # \u540E\u53F0\u542F\u52A8"));
+          } else if (errorMessage.includes("\u53C2\u6570\u683C\u5F0F\u9519\u8BEF")) {
+            console.log();
+            console.log(chalk4.yellow("\u{1F4A1} \u6B63\u786E\u683C\u5F0F\u793A\u4F8B:"));
+            console.log(
+              chalk4.gray(
+                `  xiaozhi mcp call ${serviceName} ${toolName} --args '{"param": "value"}'`
+              )
+            );
+          }
+          if (process.env.NODE_ENV === "test") {
+            throw new Error("process.exit called");
+          }
+          process.exit(1);
+        }
+      }
+      /**
+       * 列出所有 MCP 服务
+       */
+      async handleListInternal(options = {}) {
+        const spinner = ora3("\u83B7\u53D6 MCP \u670D\u52A1\u5217\u8868...").start();
+        try {
+          const mcpServers = configManager2.getMcpServers();
+          const serverNames = Object.keys(mcpServers);
+          const customMCPTools = configManager2.getCustomMCPTools();
+          const hasCustomMCP = customMCPTools.length > 0;
+          const totalServices = serverNames.length + (hasCustomMCP ? 1 : 0);
+          if (totalServices === 0) {
+            spinner.warn("\u672A\u914D\u7F6E\u4EFB\u4F55 MCP \u670D\u52A1\u6216 customMCP \u5DE5\u5177");
+            console.log(
+              chalk4.yellow(
+                "\u{1F4A1} \u63D0\u793A: \u4F7F\u7528 'xiaozhi config' \u547D\u4EE4\u914D\u7F6E MCP \u670D\u52A1\u6216\u5728 xiaozhi.config.json \u4E2D\u914D\u7F6E customMCP \u5DE5\u5177"
+              )
+            );
+            return;
+          }
+          spinner.succeed(
+            `\u627E\u5230 ${totalServices} \u4E2A MCP \u670D\u52A1${hasCustomMCP ? " (\u5305\u62EC customMCP)" : ""}`
+          );
+          if (options.tools) {
+            console.log();
+            console.log(chalk4.bold("MCP \u670D\u52A1\u5DE5\u5177\u5217\u8868:"));
+            console.log();
+            let maxToolNameWidth = 8;
+            const allToolNames = [];
+            for (const serverName of serverNames) {
+              const toolsConfig = configManager2.getServerToolsConfig(serverName);
+              const toolNames = Object.keys(toolsConfig);
+              allToolNames.push(...toolNames);
+            }
+            if (hasCustomMCP) {
+              const customToolNames = customMCPTools.map((tool) => tool.name);
+              allToolNames.push(...customToolNames);
+            }
+            for (const toolName of allToolNames) {
+              const width = _McpCommandHandler.getDisplayWidth(toolName);
+              if (width > maxToolNameWidth) {
+                maxToolNameWidth = width;
+              }
+            }
+            maxToolNameWidth = Math.max(10, Math.min(maxToolNameWidth + 2, 30));
+            const table = new Table({
+              head: [
+                chalk4.bold("MCP"),
+                chalk4.bold("\u5DE5\u5177\u540D\u79F0"),
+                chalk4.bold("\u72B6\u6001"),
+                chalk4.bold("\u63CF\u8FF0")
+              ],
+              colWidths: [15, maxToolNameWidth, 8, 40],
+              // MCP | 工具名称 | 状态 | 描述
+              wordWrap: true,
+              style: {
+                head: [],
+                border: []
+              }
+            });
+            if (hasCustomMCP) {
+              for (const customTool of customMCPTools) {
+                const description = _McpCommandHandler.truncateToWidth(
+                  customTool.description || "",
+                  32
+                );
+                table.push([
+                  "customMCP",
+                  customTool.name,
+                  chalk4.green("\u542F\u7528"),
+                  // customMCP 工具默认启用
+                  description
+                ]);
+              }
+            }
+            for (const serverName of serverNames) {
+              const toolsConfig = configManager2.getServerToolsConfig(serverName);
+              const toolNames = Object.keys(toolsConfig);
+              if (toolNames.length === 0) {
+                table.push([
+                  chalk4.gray(serverName),
+                  chalk4.gray("-"),
+                  chalk4.gray("-"),
+                  chalk4.gray("\u6682\u672A\u8BC6\u522B\u5230\u76F8\u5173\u5DE5\u5177")
+                ]);
+              } else {
+                if (table.length > 0) {
+                  table.push([{ colSpan: 4, content: "" }]);
+                }
+                for (const toolName of toolNames) {
+                  const toolConfig = toolsConfig[toolName];
+                  const status = toolConfig.enable ? chalk4.green("\u542F\u7528") : chalk4.red("\u7981\u7528");
+                  const description = _McpCommandHandler.truncateToWidth(
+                    toolConfig.description || "",
+                    32
+                  );
+                  table.push([serverName, toolName, status, description]);
+                }
+              }
+            }
+            console.log(table.toString());
+          } else {
+            console.log();
+            console.log(chalk4.bold("MCP \u670D\u52A1\u5217\u8868:"));
+            console.log();
+            if (hasCustomMCP) {
+              console.log(`${chalk4.cyan("\u2022")} ${chalk4.bold("customMCP")}`);
+              console.log(`  \u7C7B\u578B: ${chalk4.gray("\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177")}`);
+              console.log(`  \u914D\u7F6E: ${chalk4.gray("xiaozhi.config.json")}`);
+              console.log(
+                `  \u5DE5\u5177: ${chalk4.green(customMCPTools.length)} \u542F\u7528 / ${chalk4.yellow(
+                  customMCPTools.length
+                )} \u603B\u8BA1`
+              );
+              console.log();
+            }
+            for (const serverName of serverNames) {
+              const serverConfig = mcpServers[serverName];
+              const toolsConfig = configManager2.getServerToolsConfig(serverName);
+              const toolCount = Object.keys(toolsConfig).length;
+              const enabledCount = Object.values(toolsConfig).filter(
+                (t) => t.enable !== false
+              ).length;
+              console.log(`${chalk4.cyan("\u2022")} ${chalk4.bold(serverName)}`);
+              if ("url" in serverConfig) {
+                if ("type" in serverConfig && serverConfig.type === "sse") {
+                  console.log(`  \u7C7B\u578B: ${chalk4.gray("SSE")}`);
+                } else {
+                  console.log(`  \u7C7B\u578B: ${chalk4.gray("Streamable HTTP")}`);
+                }
+                console.log(`  URL: ${chalk4.gray(serverConfig.url)}`);
+              } else if (isLocalMCPServerConfig(serverConfig)) {
+                console.log(
+                  `  \u547D\u4EE4: ${chalk4.gray(serverConfig.command)} ${chalk4.gray(
+                    serverConfig.args.join(" ")
+                  )}`
+                );
+              }
+              if (toolCount > 0) {
+                console.log(
+                  `  \u5DE5\u5177: ${chalk4.green(enabledCount)} \u542F\u7528 / ${chalk4.yellow(
+                    toolCount
+                  )} \u603B\u8BA1`
+                );
+              } else {
+                console.log(`  \u5DE5\u5177: ${chalk4.gray("\u672A\u626B\u63CF (\u8BF7\u5148\u542F\u52A8\u670D\u52A1)")}`);
+              }
+              console.log();
+            }
+          }
+          console.log(chalk4.gray("\u{1F4A1} \u63D0\u793A:"));
+          console.log(
+            chalk4.gray("  - \u4F7F\u7528 'xiaozhi mcp list --tools' \u67E5\u770B\u6240\u6709\u5DE5\u5177")
+          );
+          console.log(
+            chalk4.gray("  - \u4F7F\u7528 'xiaozhi mcp <\u670D\u52A1\u540D> list' \u67E5\u770B\u6307\u5B9A\u670D\u52A1\u7684\u5DE5\u5177")
+          );
+          console.log(
+            chalk4.gray(
+              "  - \u4F7F\u7528 'xiaozhi mcp <\u670D\u52A1\u540D> <\u5DE5\u5177\u540D> enable/disable' \u542F\u7528/\u7981\u7528\u5DE5\u5177"
+            )
+          );
+        } catch (error) {
+          spinner.fail("\u83B7\u53D6 MCP \u670D\u52A1\u5217\u8868\u5931\u8D25");
+          console.error(
+            chalk4.red(
+              `\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+          process.exit(1);
+        }
+      }
+      /**
+       * 列出指定服务的工具
+       */
+      async handleServerInternal(serverName) {
+        const spinner = ora3(`\u83B7\u53D6 ${serverName} \u670D\u52A1\u7684\u5DE5\u5177\u5217\u8868...`).start();
+        try {
+          const mcpServers = configManager2.getMcpServers();
+          if (!mcpServers[serverName]) {
+            spinner.fail(`\u670D\u52A1 '${serverName}' \u4E0D\u5B58\u5728`);
+            console.log(
+              chalk4.yellow("\u{1F4A1} \u63D0\u793A: \u4F7F\u7528 'xiaozhi mcp list' \u67E5\u770B\u6240\u6709\u53EF\u7528\u670D\u52A1")
+            );
+            return;
+          }
+          const toolsConfig = configManager2.getServerToolsConfig(serverName);
+          const toolNames = Object.keys(toolsConfig);
+          if (toolNames.length === 0) {
+            spinner.warn(`\u670D\u52A1 '${serverName}' \u6682\u65E0\u5DE5\u5177\u4FE1\u606F`);
+            console.log(chalk4.yellow("\u{1F4A1} \u63D0\u793A: \u8BF7\u5148\u542F\u52A8\u670D\u52A1\u4EE5\u626B\u63CF\u5DE5\u5177\u5217\u8868"));
+            return;
+          }
+          spinner.succeed(`\u670D\u52A1 '${serverName}' \u5171\u6709 ${toolNames.length} \u4E2A\u5DE5\u5177`);
+          console.log();
+          console.log(chalk4.bold(`${serverName} \u670D\u52A1\u5DE5\u5177\u5217\u8868:`));
+          console.log();
+          const table = new Table({
+            head: [chalk4.bold("\u5DE5\u5177\u540D\u79F0"), chalk4.bold("\u72B6\u6001"), chalk4.bold("\u63CF\u8FF0")],
+            colWidths: [30, 8, 50],
+            // 工具名称 | 状态 | 描述
+            wordWrap: true,
+            style: {
+              head: [],
+              border: []
+            }
+          });
+          for (const toolName of toolNames) {
+            const toolConfig = toolsConfig[toolName];
+            const status = toolConfig.enable ? chalk4.green("\u542F\u7528") : chalk4.red("\u7981\u7528");
+            const description = _McpCommandHandler.truncateToWidth(
+              toolConfig.description || "",
+              40
+            );
+            table.push([toolName, status, description]);
+          }
+          console.log(table.toString());
+          console.log();
+          console.log(chalk4.gray("\u{1F4A1} \u63D0\u793A:"));
+          console.log(
+            chalk4.gray(
+              `  - \u4F7F\u7528 'xiaozhi mcp ${serverName} <\u5DE5\u5177\u540D> enable' \u542F\u7528\u5DE5\u5177`
+            )
+          );
+          console.log(
+            chalk4.gray(
+              `  - \u4F7F\u7528 'xiaozhi mcp ${serverName} <\u5DE5\u5177\u540D> disable' \u7981\u7528\u5DE5\u5177`
+            )
+          );
+        } catch (error) {
+          spinner.fail("\u83B7\u53D6\u5DE5\u5177\u5217\u8868\u5931\u8D25");
+          console.error(
+            chalk4.red(
+              `\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+          process.exit(1);
+        }
+      }
+      /**
+       * 启用或禁用工具
+       */
+      async handleToolInternal(serverName, toolName, enabled) {
+        const action = enabled ? "\u542F\u7528" : "\u7981\u7528";
+        const spinner = ora3(`${action}\u5DE5\u5177 ${serverName}/${toolName}...`).start();
+        try {
+          const mcpServers = configManager2.getMcpServers();
+          if (!mcpServers[serverName]) {
+            spinner.fail(`\u670D\u52A1 '${serverName}' \u4E0D\u5B58\u5728`);
+            console.log(
+              chalk4.yellow("\u{1F4A1} \u63D0\u793A: \u4F7F\u7528 'xiaozhi mcp list' \u67E5\u770B\u6240\u6709\u53EF\u7528\u670D\u52A1")
+            );
+            return;
+          }
+          const toolsConfig = configManager2.getServerToolsConfig(serverName);
+          if (!toolsConfig[toolName]) {
+            spinner.fail(`\u5DE5\u5177 '${toolName}' \u5728\u670D\u52A1 '${serverName}' \u4E2D\u4E0D\u5B58\u5728`);
+            console.log(
+              chalk4.yellow(
+                `\u{1F4A1} \u63D0\u793A: \u4F7F\u7528 'xiaozhi mcp ${serverName} list' \u67E5\u770B\u8BE5\u670D\u52A1\u7684\u6240\u6709\u5DE5\u5177`
+              )
+            );
+            return;
+          }
+          configManager2.setToolEnabled(
+            serverName,
+            toolName,
+            enabled,
+            toolsConfig[toolName].description
+          );
+          spinner.succeed(
+            `\u6210\u529F${action}\u5DE5\u5177 ${chalk4.cyan(serverName)}/${chalk4.cyan(toolName)}`
+          );
+          console.log();
+          console.log(chalk4.gray("\u{1F4A1} \u63D0\u793A: \u5DE5\u5177\u72B6\u6001\u66F4\u6539\u5C06\u5728\u4E0B\u6B21\u542F\u52A8\u670D\u52A1\u65F6\u751F\u6548"));
+        } catch (error) {
+          spinner.fail(`${action}\u5DE5\u5177\u5931\u8D25`);
+          console.error(
+            chalk4.red(
+              `\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+          process.exit(1);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/EndpointCommandHandler.ts
+var EndpointCommandHandler_exports = {};
+__export(EndpointCommandHandler_exports, {
+  EndpointCommandHandler: () => EndpointCommandHandler
+});
+import chalk5 from "chalk";
+import ora4 from "ora";
+var EndpointCommandHandler;
+var init_EndpointCommandHandler = __esm({
+  "src/commands/EndpointCommandHandler.ts"() {
+    init_Command();
+    EndpointCommandHandler = class extends BaseCommandHandler {
+      static {
+        __name(this, "EndpointCommandHandler");
+      }
+      name = "endpoint";
+      description = "\u7BA1\u7406 MCP \u7AEF\u70B9";
+      subcommands = [
+        {
+          name: "list",
+          description: "\u5217\u51FA\u6240\u6709 MCP \u7AEF\u70B9",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            await this.handleList();
+          }, "execute")
+        },
+        {
+          name: "add",
+          description: "\u6DFB\u52A0\u65B0\u7684 MCP \u7AEF\u70B9",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 1);
+            await this.handleAdd(args[0]);
+          }, "execute")
+        },
+        {
+          name: "remove",
+          description: "\u79FB\u9664\u6307\u5B9A\u7684 MCP \u7AEF\u70B9",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 1);
+            await this.handleRemove(args[0]);
+          }, "execute")
+        },
+        {
+          name: "set",
+          description: "\u8BBE\u7F6E MCP \u7AEF\u70B9\uFF08\u53EF\u4EE5\u662F\u5355\u4E2A\u6216\u591A\u4E2A\uFF09",
+          execute: /* @__PURE__ */ __name(async (args, options) => {
+            this.validateArgs(args, 1);
+            await this.handleSet(args);
+          }, "execute")
+        }
+      ];
+      constructor(container) {
+        super(container);
+      }
+      /**
+       * 主命令执行（显示帮助）
+       */
+      async execute(args, options) {
+        console.log("MCP \u7AEF\u70B9\u7BA1\u7406\u547D\u4EE4\u3002\u4F7F\u7528 --help \u67E5\u770B\u53EF\u7528\u7684\u5B50\u547D\u4EE4\u3002");
+      }
+      /**
+       * 处理列出端点命令
+       */
+      async handleList() {
+        const spinner = ora4("\u8BFB\u53D6\u7AEF\u70B9\u914D\u7F6E...").start();
+        try {
+          const configManager3 = this.getService("configManager");
+          const endpoints = configManager3.getMcpEndpoints();
+          spinner.succeed("\u7AEF\u70B9\u5217\u8868");
+          if (endpoints.length === 0) {
+            console.log(chalk5.yellow("\u672A\u914D\u7F6E\u4EFB\u4F55 MCP \u7AEF\u70B9"));
+          } else {
+            console.log(chalk5.green(`\u5171 ${endpoints.length} \u4E2A\u7AEF\u70B9:`));
+            endpoints.forEach((ep, index) => {
+              console.log(chalk5.gray(`  ${index + 1}. ${ep}`));
+            });
+          }
+        } catch (error) {
+          spinner.fail(
+            `\u8BFB\u53D6\u7AEF\u70B9\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理添加端点命令
+       */
+      async handleAdd(url) {
+        const spinner = ora4("\u6DFB\u52A0\u7AEF\u70B9...").start();
+        try {
+          const configManager3 = this.getService("configManager");
+          configManager3.addMcpEndpoint(url);
+          spinner.succeed(`\u6210\u529F\u6DFB\u52A0\u7AEF\u70B9: ${url}`);
+          const endpoints = configManager3.getMcpEndpoints();
+          console.log(chalk5.gray(`\u5F53\u524D\u5171 ${endpoints.length} \u4E2A\u7AEF\u70B9`));
+        } catch (error) {
+          spinner.fail(
+            `\u6DFB\u52A0\u7AEF\u70B9\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理移除端点命令
+       */
+      async handleRemove(url) {
+        const spinner = ora4("\u79FB\u9664\u7AEF\u70B9...").start();
+        try {
+          const configManager3 = this.getService("configManager");
+          configManager3.removeMcpEndpoint(url);
+          spinner.succeed(`\u6210\u529F\u79FB\u9664\u7AEF\u70B9: ${url}`);
+          const endpoints = configManager3.getMcpEndpoints();
+          console.log(chalk5.gray(`\u5F53\u524D\u5269\u4F59 ${endpoints.length} \u4E2A\u7AEF\u70B9`));
+        } catch (error) {
+          spinner.fail(
+            `\u79FB\u9664\u7AEF\u70B9\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+      /**
+       * 处理设置端点命令
+       */
+      async handleSet(urls) {
+        const spinner = ora4("\u8BBE\u7F6E\u7AEF\u70B9...").start();
+        try {
+          const configManager3 = this.getService("configManager");
+          if (urls.length === 1) {
+            configManager3.updateMcpEndpoint(urls[0]);
+            spinner.succeed(`\u6210\u529F\u8BBE\u7F6E\u7AEF\u70B9: ${urls[0]}`);
+          } else {
+            configManager3.updateMcpEndpoint(urls);
+            spinner.succeed(`\u6210\u529F\u8BBE\u7F6E ${urls.length} \u4E2A\u7AEF\u70B9`);
+            for (const [index, url] of urls.entries()) {
+              console.log(chalk5.gray(`  ${index + 1}. ${url}`));
+            }
+          }
+        } catch (error) {
+          spinner.fail(
+            `\u8BBE\u7F6E\u7AEF\u70B9\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+          this.handleError(error);
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/Container.ts
+import { configManager } from "../backend/lib/config/manager.js";
+import { logger } from "../backend/Logger.js";
+
+// src/errors/ErrorHandlers.ts
+import chalk from "chalk";
+
+// src/errors/ErrorMessages.ts
+init_Constants();
+var ERROR_HELP_MESSAGES = {
+  [ERROR_CODES.CONFIG_ERROR]: '\u8FD0\u884C "xiaozhi --help" \u67E5\u770B\u914D\u7F6E\u76F8\u5173\u547D\u4EE4',
+  [ERROR_CODES.SERVICE_ERROR]: '\u8FD0\u884C "xiaozhi status" \u68C0\u67E5\u670D\u52A1\u72B6\u6001',
+  [ERROR_CODES.VALIDATION_ERROR]: "\u68C0\u67E5\u8F93\u5165\u53C2\u6570\u662F\u5426\u6B63\u786E",
+  [ERROR_CODES.FILE_ERROR]: "\u68C0\u67E5\u6587\u4EF6\u8DEF\u5F84\u548C\u6743\u9650",
+  [ERROR_CODES.PROCESS_ERROR]: "\u68C0\u67E5\u8FDB\u7A0B\u72B6\u6001\u548C\u6743\u9650",
+  [ERROR_CODES.NETWORK_ERROR]: "\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u548C\u9632\u706B\u5899\u8BBE\u7F6E",
+  [ERROR_CODES.PERMISSION_ERROR]: "\u5C1D\u8BD5\u4F7F\u7528\u7BA1\u7406\u5458\u6743\u9650\u8FD0\u884C"
+};
+var COMMON_SOLUTIONS = {
+  config_not_found: [
+    '\u8FD0\u884C "xiaozhi init" \u521D\u59CB\u5316\u914D\u7F6E\u6587\u4EF6',
+    "\u68C0\u67E5\u5F53\u524D\u76EE\u5F55\u662F\u5426\u4E3A\u9879\u76EE\u6839\u76EE\u5F55",
+    "\u8BBE\u7F6E XIAOZHI_CONFIG_DIR \u73AF\u5883\u53D8\u91CF\u6307\u5B9A\u914D\u7F6E\u76EE\u5F55"
+  ],
+  service_port_occupied: [
+    "\u68C0\u67E5\u7AEF\u53E3\u662F\u5426\u88AB\u5176\u4ED6\u7A0B\u5E8F\u5360\u7528",
+    '\u4F7F\u7528 "lsof -i :\u7AEF\u53E3\u53F7" \u67E5\u770B\u7AEF\u53E3\u4F7F\u7528\u60C5\u51B5',
+    "\u66F4\u6539\u914D\u7F6E\u6587\u4EF6\u4E2D\u7684\u7AEF\u53E3\u8BBE\u7F6E"
+  ],
+  permission_denied: [
+    "\u68C0\u67E5\u6587\u4EF6\u548C\u76EE\u5F55\u6743\u9650",
+    "\u4F7F\u7528 sudo \u6216\u7BA1\u7406\u5458\u6743\u9650\u8FD0\u884C",
+    "\u786E\u4FDD\u5F53\u524D\u7528\u6237\u6709\u8DB3\u591F\u7684\u6743\u9650"
+  ],
+  service_start_failed: [
+    "\u68C0\u67E5\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u662F\u5426\u6B63\u786E",
+    "\u67E5\u770B\u65E5\u5FD7\u6587\u4EF6\u83B7\u53D6\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F",
+    "\u786E\u4FDD\u6240\u6709\u4F9D\u8D56\u670D\u52A1\u6B63\u5E38\u8FD0\u884C"
+  ]
+};
+var ERROR_MESSAGES = class {
+  static {
+    __name(this, "ERROR_MESSAGES");
+  }
+  /**
+   * 获取错误码对应的帮助信息
+   */
+  static getHelpMessage(errorCode) {
+    return ERROR_HELP_MESSAGES[errorCode];
+  }
+  /**
+   * 获取常见问题的解决方案
+   */
+  static getSolutions(problemKey) {
+    return COMMON_SOLUTIONS[problemKey] || [];
+  }
+  /**
+   * 格式化错误消息
+   */
+  static formatError(error, context) {
+    const contextPrefix = context ? `[${context}] ` : "";
+    return `${contextPrefix}${error.message}`;
+  }
+  /**
+   * 获取友好的错误描述
+   */
+  static getFriendlyMessage(errorCode) {
+    const friendlyMessages = {
+      [ERROR_CODES.CONFIG_ERROR]: "\u914D\u7F6E\u6587\u4EF6\u76F8\u5173\u9519\u8BEF",
+      [ERROR_CODES.SERVICE_ERROR]: "\u670D\u52A1\u8FD0\u884C\u76F8\u5173\u9519\u8BEF",
+      [ERROR_CODES.VALIDATION_ERROR]: "\u8F93\u5165\u9A8C\u8BC1\u9519\u8BEF",
+      [ERROR_CODES.FILE_ERROR]: "\u6587\u4EF6\u64CD\u4F5C\u9519\u8BEF",
+      [ERROR_CODES.PROCESS_ERROR]: "\u8FDB\u7A0B\u7BA1\u7406\u9519\u8BEF",
+      [ERROR_CODES.NETWORK_ERROR]: "\u7F51\u7EDC\u8FDE\u63A5\u9519\u8BEF",
+      [ERROR_CODES.PERMISSION_ERROR]: "\u6743\u9650\u4E0D\u8DB3\u9519\u8BEF"
+    };
+    return friendlyMessages[errorCode] || "\u672A\u77E5\u9519\u8BEF";
+  }
+  /**
+   * 检查是否为可恢复错误
+   */
+  static isRecoverable(errorCode) {
+    const recoverableErrors = [
+      ERROR_CODES.NETWORK_ERROR,
+      ERROR_CODES.FILE_ERROR,
+      ERROR_CODES.SERVICE_ERROR
+    ];
+    return recoverableErrors.includes(errorCode);
+  }
+  /**
+   * 获取错误的严重程度
+   */
+  static getSeverity(errorCode) {
+    const severityMap = {
+      [ERROR_CODES.VALIDATION_ERROR]: "low",
+      [ERROR_CODES.FILE_ERROR]: "medium",
+      [ERROR_CODES.CONFIG_ERROR]: "medium",
+      [ERROR_CODES.NETWORK_ERROR]: "medium",
+      [ERROR_CODES.SERVICE_ERROR]: "high",
+      [ERROR_CODES.PROCESS_ERROR]: "high",
+      [ERROR_CODES.PERMISSION_ERROR]: "critical"
+    };
+    return severityMap[errorCode] || "medium";
+  }
+};
+
+// src/errors/ErrorHandlers.ts
+init_errors();
+var ErrorHandler = class _ErrorHandler {
+  static {
+    __name(this, "ErrorHandler");
+  }
+  /**
+   * 处理错误并退出程序
+   */
+  static handle(error) {
+    if (error instanceof CLIError) {
+      _ErrorHandler.handleCLIError(error);
+    } else {
+      _ErrorHandler.handleUnknownError(error);
+    }
+    process.exit(1);
+  }
+  /**
+   * 处理 CLI 错误
+   */
+  static handleCLIError(error) {
+    console.error(chalk.red(`\u274C \u9519\u8BEF: ${error.message}`));
+    if (process.env.DEBUG) {
+      console.error(chalk.gray(`\u9519\u8BEF\u7801: ${error.code}`));
+    }
+    if (error.suggestions && error.suggestions.length > 0) {
+      console.log(chalk.yellow("\u{1F4A1} \u5EFA\u8BAE:"));
+      for (const suggestion of error.suggestions) {
+        console.log(chalk.gray(`   ${suggestion}`));
+      }
+    }
+    const helpMessage = ERROR_MESSAGES.getHelpMessage(error.code);
+    if (helpMessage) {
+      console.log(chalk.blue(`\u2139\uFE0F  ${helpMessage}`));
+    }
+  }
+  /**
+   * 处理未知错误
+   */
+  static handleUnknownError(error) {
+    console.error(chalk.red(`\u274C \u672A\u77E5\u9519\u8BEF: ${error.message}`));
+    if (process.env.DEBUG || process.env.NODE_ENV === "development") {
+      console.error(chalk.gray("\u5806\u6808\u4FE1\u606F:"));
+      console.error(chalk.gray(error.stack));
+    } else {
+      console.log(
+        chalk.yellow("\u{1F4A1} \u63D0\u793A: \u8BBE\u7F6E DEBUG=1 \u73AF\u5883\u53D8\u91CF\u67E5\u770B\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F")
+      );
+    }
+  }
+  /**
+   * 异步操作错误处理包装器
+   */
+  static async handleAsync(operation, context) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error instanceof CLIError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        throw new CLIError(
+          `${context}\u5931\u8D25: ${error.message}`,
+          "OPERATION_FAILED",
+          1
+        );
+      }
+      throw new CLIError(`${context}\u5931\u8D25: \u672A\u77E5\u9519\u8BEF`, "OPERATION_FAILED", 1);
+    }
+  }
+  /**
+   * 同步操作错误处理包装器
+   */
+  static handleSync(operation, context) {
+    try {
+      return operation();
+    } catch (error) {
+      if (error instanceof CLIError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        throw new CLIError(
+          `${context}\u5931\u8D25: ${error.message}`,
+          "OPERATION_FAILED",
+          1
+        );
+      }
+      throw new CLIError(`${context}\u5931\u8D25: \u672A\u77E5\u9519\u8BEF`, "OPERATION_FAILED", 1);
+    }
+  }
+  /**
+   * 警告处理
+   */
+  static warn(message, suggestions) {
+    console.warn(chalk.yellow(`\u26A0\uFE0F  \u8B66\u544A: ${message}`));
+    if (suggestions && suggestions.length > 0) {
+      console.log(chalk.yellow("\u{1F4A1} \u5EFA\u8BAE:"));
+      for (const suggestion of suggestions) {
+        console.log(chalk.gray(`   ${suggestion}`));
+      }
+    }
+  }
+  /**
+   * 信息提示
+   */
+  static info(message) {
+    console.log(chalk.blue(`\u2139\uFE0F  ${message}`));
+  }
+  /**
+   * 成功提示
+   */
+  static success(message) {
+    console.log(chalk.green(`\u2705 ${message}`));
+  }
+};
+
+// src/Container.ts
+init_FileUtils();
+init_FormatUtils();
+init_PathUtils();
+init_PlatformUtils();
+init_Validation();
+
+// src/utils/VersionUtils.ts
+init_errors();
+import fs2 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var VersionUtils = class _VersionUtils {
+  static {
+    __name(this, "VersionUtils");
+  }
+  static cachedVersion = null;
+  /**
+   * 获取版本号
+   */
+  static getVersion() {
+    if (_VersionUtils.cachedVersion) {
+      return _VersionUtils.cachedVersion;
+    }
+    try {
+      const __filename = fileURLToPath2(import.meta.url);
+      const currentDir = path3.dirname(__filename);
+      const possiblePaths = [
+        // 构建后环境：dist/cli.js -> dist/package.json (优先)
+        path3.join(currentDir, "package.json"),
+        // 构建后环境：dist/cli.js -> package.json
+        path3.join(currentDir, "..", "package.json"),
+        // 开发环境：src/cli/utils/VersionUtils.ts -> package.json
+        path3.join(currentDir, "..", "..", "..", "package.json"),
+        // 全局安装环境
+        path3.join(currentDir, "..", "..", "..", "..", "package.json")
+      ];
+      for (const packagePath of possiblePaths) {
+        if (fs2.existsSync(packagePath)) {
+          const packageJson = JSON.parse(fs2.readFileSync(packagePath, "utf8"));
+          if (packageJson.version) {
+            _VersionUtils.cachedVersion = packageJson.version;
+            return packageJson.version;
+          }
+        }
+      }
+      _VersionUtils.cachedVersion = "unknown";
+      return "unknown";
+    } catch (error) {
+      console.warn("\u65E0\u6CD5\u4ECE package.json \u8BFB\u53D6\u7248\u672C\u4FE1\u606F:", error);
+      _VersionUtils.cachedVersion = "unknown";
+      return "unknown";
+    }
+  }
+  /**
+   * 获取完整版本信息
+   */
+  static getVersionInfo() {
+    try {
+      const __filename = fileURLToPath2(import.meta.url);
+      const currentDir = path3.dirname(__filename);
+      const possiblePaths = [
+        // 构建后环境：dist/cli.js -> dist/package.json (优先)
+        path3.join(currentDir, "package.json"),
+        // 构建后环境：dist/cli.js -> package.json
+        path3.join(currentDir, "..", "package.json"),
+        // 开发环境：src/cli/utils/VersionUtils.ts -> package.json
+        path3.join(currentDir, "..", "..", "..", "package.json"),
+        // 全局安装环境
+        path3.join(currentDir, "..", "..", "..", "..", "package.json")
+      ];
+      for (const packagePath of possiblePaths) {
+        if (fs2.existsSync(packagePath)) {
+          const packageJson = JSON.parse(fs2.readFileSync(packagePath, "utf8"));
+          return {
+            version: packageJson.version || "unknown",
+            name: packageJson.name,
+            description: packageJson.description,
+            author: packageJson.author
+          };
+        }
+      }
+      return { version: "unknown" };
+    } catch (error) {
+      throw new FileError("\u65E0\u6CD5\u8BFB\u53D6\u7248\u672C\u4FE1\u606F", "package.json");
+    }
+  }
+  /**
+   * 比较版本号
+   */
+  static compareVersions(version1, version2) {
+    const v1Parts = version1.split(".").map(Number);
+    const v2Parts = version2.split(".").map(Number);
+    const maxLength = Math.max(v1Parts.length, v2Parts.length);
+    for (let i = 0; i < maxLength; i++) {
+      const v1Part = v1Parts[i] || 0;
+      const v2Part = v2Parts[i] || 0;
+      if (v1Part > v2Part) return 1;
+      if (v1Part < v2Part) return -1;
+    }
+    return 0;
+  }
+  /**
+   * 检查版本是否有效
+   */
+  static isValidVersion(version) {
+    const versionRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+    return versionRegex.test(version);
+  }
+  /**
+   * 清除版本缓存
+   */
+  static clearCache() {
+    _VersionUtils.cachedVersion = null;
+  }
+};
+
+// src/Container.ts
+var DIContainer = class _DIContainer {
+  static {
+    __name(this, "DIContainer");
+  }
+  instances = /* @__PURE__ */ new Map();
+  factories = /* @__PURE__ */ new Map();
+  asyncFactories = /* @__PURE__ */ new Map();
+  singletons = /* @__PURE__ */ new Set();
+  /**
+   * 注册服务工厂
+   */
+  register(key, factory, singleton = false) {
+    this.factories.set(key, factory);
+    if (singleton) {
+      this.singletons.add(key);
+    }
+  }
+  /**
+   * 注册单例服务
+   */
+  registerSingleton(key, factory) {
+    this.register(key, factory, true);
+  }
+  /**
+   * 注册实例
+   */
+  registerInstance(key, instance) {
+    this.instances.set(key, instance);
+    this.singletons.add(key);
+  }
+  /**
+   * 获取服务实例
+   */
+  get(key) {
+    if (this.singletons.has(key) && this.instances.has(key)) {
+      return this.instances.get(key);
+    }
+    const factory = this.factories.get(key);
+    if (!factory) {
+      throw new Error(`Service ${key} not registered`);
+    }
+    const instance = factory();
+    if (this.singletons.has(key)) {
+      this.instances.set(key, instance);
+    }
+    return instance;
+  }
+  /**
+   * 检查服务是否已注册
+   */
+  has(key) {
+    return this.factories.has(key) || this.instances.has(key);
+  }
+  /**
+   * 清除所有注册的服务
+   */
+  clear() {
+    this.instances.clear();
+    this.factories.clear();
+    this.singletons.clear();
+  }
+  /**
+   * 获取所有已注册的服务键
+   */
+  getRegisteredKeys() {
+    const factoryKeys = Array.from(this.factories.keys());
+    const instanceKeys = Array.from(this.instances.keys());
+    return [.../* @__PURE__ */ new Set([...factoryKeys, ...instanceKeys])];
+  }
+  /**
+   * 创建默认容器实例
+   */
+  static create() {
+    const container = new _DIContainer();
+    container.registerSingleton("versionUtils", () => {
+      return VersionUtils;
+    });
+    container.registerSingleton("platformUtils", () => {
+      return PlatformUtils;
+    });
+    container.registerSingleton("formatUtils", () => {
+      return FormatUtils;
+    });
+    container.registerSingleton("fileUtils", () => {
+      return FileUtils;
+    });
+    container.registerSingleton("pathUtils", () => {
+      return PathUtils;
+    });
+    container.registerSingleton("validation", () => {
+      return Validation;
+    });
+    container.registerSingleton("configManager", () => {
+      return configManager;
+    });
+    container.registerSingleton("logger", () => {
+      return logger;
+    });
+    container.registerSingleton("errorHandler", () => {
+      return ErrorHandler;
+    });
+    container.registerSingleton("processManager", () => {
+      const ProcessManagerModule = (init_ProcessManager(), __toCommonJS(ProcessManager_exports));
+      return new ProcessManagerModule.ProcessManagerImpl();
+    });
+    container.registerSingleton("daemonManager", () => {
+      const DaemonManagerModule = (init_DaemonManager(), __toCommonJS(DaemonManager_exports));
+      const processManager = container.get("processManager");
+      const logger3 = container.get("logger");
+      return new DaemonManagerModule.DaemonManagerImpl(processManager, logger3);
+    });
+    container.registerSingleton("serviceManager", () => {
+      const ServiceManagerModule = (init_ServiceManager(), __toCommonJS(ServiceManager_exports));
+      const processManager = container.get("processManager");
+      const configManager3 = container.get("configManager");
+      const logger3 = container.get("logger");
+      return new ServiceManagerModule.ServiceManagerImpl(
+        processManager,
+        configManager3,
+        logger3
+      );
+    });
+    container.registerSingleton("templateManager", () => {
+      const TemplateManagerModule = (init_TemplateManager(), __toCommonJS(TemplateManager_exports));
+      return new TemplateManagerModule.TemplateManagerImpl();
+    });
+    return container;
+  }
+};
+
+// src/commands/CommandHandlerFactory.ts
+var CommandHandlerFactory = class {
+  constructor(container) {
+    this.container = container;
+  }
+  static {
+    __name(this, "CommandHandlerFactory");
+  }
+  /**
+   * 创建所有命令处理器
+   */
+  createHandlers() {
+    return [
+      this.createHandler("service"),
+      this.createHandler("config"),
+      this.createHandler("project"),
+      this.createHandler("mcp"),
+      this.createHandler("endpoint")
+    ];
+  }
+  /**
+   * 创建指定类型的命令处理器
+   */
+  createHandler(type) {
+    switch (type) {
+      case "service":
+        return this.createServiceCommandHandler();
+      case "config":
+        return this.createConfigCommandHandler();
+      case "project":
+        return this.createProjectCommandHandler();
+      case "mcp":
+        return this.createMcpCommandHandler();
+      case "endpoint":
+        return this.createEndpointCommandHandler();
+      default:
+        throw new Error(`\u672A\u77E5\u7684\u547D\u4EE4\u5904\u7406\u5668\u7C7B\u578B: ${type}`);
+    }
+  }
+  /**
+   * 创建服务命令处理器
+   */
+  createServiceCommandHandler() {
+    const {
+      ServiceCommandHandler: ServiceCommandHandler2
+    } = (init_ServiceCommandHandler(), __toCommonJS(ServiceCommandHandler_exports));
+    return new ServiceCommandHandler2(this.container);
+  }
+  /**
+   * 创建配置命令处理器
+   */
+  createConfigCommandHandler() {
+    const {
+      ConfigCommandHandler: ConfigCommandHandler2
+    } = (init_ConfigCommandHandler(), __toCommonJS(ConfigCommandHandler_exports));
+    return new ConfigCommandHandler2(this.container);
+  }
+  /**
+   * 创建项目命令处理器
+   */
+  createProjectCommandHandler() {
+    const {
+      ProjectCommandHandler: ProjectCommandHandler2
+    } = (init_ProjectCommandHandler(), __toCommonJS(ProjectCommandHandler_exports));
+    return new ProjectCommandHandler2(this.container);
+  }
+  /**
+   * 创建MCP命令处理器
+   */
+  createMcpCommandHandler() {
+    const { McpCommandHandler: McpCommandHandler2 } = (init_McpCommandHandler(), __toCommonJS(McpCommandHandler_exports));
+    return new McpCommandHandler2(this.container);
+  }
+  /**
+   * 创建端点命令处理器
+   */
+  createEndpointCommandHandler() {
+    const {
+      EndpointCommandHandler: EndpointCommandHandler2
+    } = (init_EndpointCommandHandler(), __toCommonJS(EndpointCommandHandler_exports));
+    return new EndpointCommandHandler2(this.container);
+  }
+};
+
+// src/commands/index.ts
+var CommandRegistry = class {
+  constructor(container) {
+    this.container = container;
+    this.handlerFactory = new CommandHandlerFactory(container);
+  }
+  static {
+    __name(this, "CommandRegistry");
+  }
+  handlers = [];
+  handlerFactory;
+  /**
+   * 注册所有命令到 Commander 程序
+   */
+  async registerCommands(program2) {
+    try {
+      this.registerVersionCommand(program2);
+      this.registerHelpCommand(program2);
+      const handlers = this.handlerFactory.createHandlers();
+      for (const handler of handlers) {
+        this.registerHandler(handler);
+        this.registerCommand(program2, handler);
+      }
+      this.registerLegacyServiceCommands(program2, handlers);
+    } catch (error) {
+      ErrorHandler.handle(error);
+    }
+  }
+  /**
+   * 注册命令处理器
+   */
+  registerHandler(handler) {
+    this.handlers.push(handler);
+  }
+  /**
+   * 注册单个命令
+   */
+  registerCommand(program2, handler) {
+    if (handler.subcommands && handler.subcommands.length > 0) {
+      const commandGroup = program2.command(handler.name).description(handler.description);
+      for (const subcommand of handler.subcommands) {
+        let subcommandName = subcommand.name;
+        if (subcommand.name === "get") {
+          subcommandName = "get <key>";
+        } else if (subcommand.name === "set") {
+          subcommandName = "set <key> <value>";
+        } else if (subcommand.name === "call") {
+          subcommandName = "call <serviceName> <toolName>";
+        }
+        const cmd = commandGroup.command(subcommandName).description(subcommand.description);
+        if (subcommand.options) {
+          for (const option of subcommand.options) {
+            cmd.option(option.flags, option.description, option.defaultValue);
+          }
+        }
+        cmd.action(async (...args) => {
+          try {
+            const command = args[args.length - 1];
+            const options = command.opts();
+            await subcommand.execute(args.slice(0, -1), options);
+          } catch (error) {
+            ErrorHandler.handle(error);
+          }
+        });
+      }
+      commandGroup.action(async (...args) => {
+        try {
+          const command = args[args.length - 1];
+          const options = command.opts();
+          await handler.execute(args.slice(0, -1), options);
+        } catch (error) {
+          ErrorHandler.handle(error);
+        }
+      });
+    } else {
+      let commandName = handler.name;
+      if (handler.name === "create") {
+        commandName = "create <projectName>";
+      }
+      const command = program2.command(commandName).description(handler.description);
+      if (handler.options) {
+        for (const option of handler.options) {
+          command.option(option.flags, option.description, option.defaultValue);
+        }
+      }
+      command.action(async (...args) => {
+        try {
+          const command2 = args[args.length - 1];
+          const options = command2.opts();
+          await handler.execute(args.slice(0, -1), options);
+        } catch (error) {
+          ErrorHandler.handle(error);
+        }
+      });
+    }
+  }
+  /**
+   * 注册版本命令
+   */
+  registerVersionCommand(program2) {
+    const versionUtils = this.container.get("versionUtils");
+    program2.version(versionUtils.getVersion(), "-v, --version", "\u663E\u793A\u7248\u672C\u4FE1\u606F");
+    program2.option("--info", "\u663E\u793A\u8BE6\u7EC6\u4FE1\u606F");
+    program2.option("--version-info", "\u663E\u793A\u8BE6\u7EC6\u7248\u672C\u4FE1\u606F");
+  }
+  /**
+   * 注册帮助命令
+   */
+  registerHelpCommand(program2) {
+    program2.helpOption("-h, --help", "\u663E\u793A\u5E2E\u52A9\u4FE1\u606F").addHelpText(
+      "after",
+      `
+\u793A\u4F8B:
+  xiaozhi init                     # \u521D\u59CB\u5316\u914D\u7F6E\u6587\u4EF6
+  xiaozhi start                    # \u542F\u52A8\u670D\u52A1\uFF08\u5305\u542B Web UI\uFF09
+  xiaozhi start -d                 # \u540E\u53F0\u542F\u52A8\u670D\u52A1
+  xiaozhi start -s 3000            # \u4EE5 MCP Server \u6A21\u5F0F\u542F\u52A8
+  xiaozhi stop                     # \u505C\u6B62\u670D\u52A1
+  xiaozhi status                   # \u68C0\u67E5\u670D\u52A1\u72B6\u6001
+  xiaozhi restart -d               # \u91CD\u542F\u670D\u52A1\uFF08\u540E\u53F0\u6A21\u5F0F\uFF09
+  xiaozhi config mcpEndpoint <url> # \u8BBE\u7F6E MCP \u7AEF\u70B9
+  xiaozhi create my-project        # \u521B\u5EFA\u9879\u76EE
+  xiaozhi mcp list                 # \u5217\u51FA MCP \u670D\u52A1
+
+\u66F4\u591A\u4FE1\u606F\u8BF7\u8BBF\u95EE: https://github.com/your-org/xiaozhi-client
+`
+    );
+  }
+  /**
+   * 注册向后兼容的顶级服务命令
+   */
+  registerLegacyServiceCommands(program2, handlers) {
+    const serviceHandler = handlers.find((h) => h.name === "service");
+    if (!serviceHandler || !serviceHandler.subcommands) {
+      return;
+    }
+    for (const subcommand of serviceHandler.subcommands) {
+      const command = program2.command(subcommand.name).description(subcommand.description);
+      if (subcommand.options) {
+        for (const option of subcommand.options) {
+          command.option(option.flags, option.description, option.defaultValue);
+        }
+      }
+      command.action(async (...args) => {
+        try {
+          const command2 = args[args.length - 1];
+          const options = command2.opts();
+          await subcommand.execute(args.slice(0, -1), options);
+        } catch (error) {
+          ErrorHandler.handle(error);
+        }
+      });
+    }
+  }
+  /**
+   * 注册服务管理命令（稍后实现）
+   */
+  // private async registerServiceCommands(program: Command): Promise<void> {
+  //   const serviceCommand = this.container.get('serviceCommand');
+  //   // start 命令
+  //   program
+  //     .command('start')
+  //     .description('启动服务')
+  //     .option('-d, --daemon', '在后台运行服务')
+  //     .option('-u, --ui', '同时启动 Web UI 服务')
+  //     .option('-s, --server [port]', '以 MCP Server 模式启动 (可选指定端口，默认 3000)')
+  //     .option('--stdio', '以 stdio 模式运行 MCP Server (用于 Cursor 等客户端)')
+  //     .action(async (options) => {
+  //       await serviceCommand.start(options);
+  //     });
+  //   // stop 命令
+  //   program
+  //     .command('stop')
+  //     .description('停止服务')
+  //     .action(async () => {
+  //       await serviceCommand.stop();
+  //     });
+  //   // status 命令
+  //   program
+  //     .command('status')
+  //     .description('检查服务状态')
+  //     .action(async () => {
+  //       await serviceCommand.status();
+  //     });
+  //   // restart 命令
+  //   program
+  //     .command('restart')
+  //     .description('重启服务')
+  //     .option('-d, --daemon', '在后台运行服务')
+  //     .option('-u, --ui', '同时启动 Web UI 服务')
+  //     .action(async (options) => {
+  //       await serviceCommand.restart(options);
+  //     });
+  //   // attach 命令
+  //   program
+  //     .command('attach')
+  //     .description('连接到后台服务查看日志')
+  //     .action(async () => {
+  //       await serviceCommand.attach();
+  //     });
+  // }
+  /**
+   * 注册配置管理命令（稍后实现）
+   */
+  // private async registerConfigCommands(program: Command): Promise<void> {
+  //   const configCommand = this.container.get('configCommand');
+  //   // init 命令
+  //   program
+  //     .command('init')
+  //     .description('初始化配置文件')
+  //     .option('-f, --format <format>', '配置文件格式 (json, json5, jsonc)', 'json')
+  //     .action(async (options) => {
+  //       await configCommand.init(options);
+  //     });
+  //   // config 命令
+  //   program
+  //     .command('config <key> [value]')
+  //     .description('查看或设置配置')
+  //     .action(async (key, value) => {
+  //       await configCommand.manage(key, value);
+  //     });
+  // }
+  /**
+   * 注册项目管理命令（稍后实现）
+   */
+  // private async registerProjectCommands(program: Command): Promise<void> {
+  //   const projectCommand = this.container.get('projectCommand');
+  //   // create 命令
+  //   program
+  //     .command('create <projectName>')
+  //     .description('创建项目')
+  //     .option('-t, --template <templateName>', '使用指定模板创建项目')
+  //     .action(async (projectName, options) => {
+  //       await projectCommand.create(projectName, options);
+  //     });
+  // }
+  /**
+   * 注册 MCP 管理命令（稍后实现）
+   */
+  // private async registerMcpCommands(program: Command): Promise<void> {
+  //   const mcpCommand = this.container.get('mcpCommand');
+  //   // mcp 命令组
+  //   const mcpGroup = program.command('mcp').description('MCP 服务和工具管理');
+  //   // mcp list 命令
+  //   mcpGroup
+  //     .command('list')
+  //     .description('列出 MCP 服务')
+  //     .option('--tools', '显示所有服务的工具列表')
+  //     .action(async (options) => {
+  //       await mcpCommand.list(options);
+  //     });
+  //   // mcp server 命令
+  //   mcpGroup
+  //     .command('server <serverName>')
+  //     .description('管理指定的 MCP 服务')
+  //     .action(async (serverName) => {
+  //       await mcpCommand.server(serverName);
+  //     });
+  //   // mcp tool 命令
+  //   mcpGroup
+  //     .command('tool <serverName> <toolName> <action>')
+  //     .description('管理 MCP 工具 (enable/disable)')
+  //     .action(async (serverName, toolName, action) => {
+  //       await mcpCommand.tool(serverName, toolName, action);
+  //     });
+  // }
+};
+
+// src/index.ts
+var program = new Command();
+async function initializeCLI() {
+  try {
+    const container = DIContainer.create();
+    const commandRegistry = new CommandRegistry(container);
+    await commandRegistry.registerCommands(program);
+    program.name("xiaozhi").description("\u5C0F\u667A MCP \u5BA2\u6237\u7AEF").helpOption("-h, --help", "\u663E\u793A\u5E2E\u52A9\u4FE1\u606F");
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    ErrorHandler.handle(error);
+  }
+}
+__name(initializeCLI, "initializeCLI");
+var scriptPath = process.argv[1].replace(/\\/g, "/");
+var isMainModule = import.meta.url === `file:///${scriptPath}` || import.meta.url === `file://${scriptPath}`;
+if (isMainModule) {
+  initializeCLI();
+}
+export {
+  initializeCLI
+};
+//# sourceMappingURL=index.js.map