xiaozhi-client 2.3.0-beta.6 → 2.3.0

package/dist/cli/index.js

@@ -21,10 +21,1922 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/Constants.ts
+// ../config/json5-adapter.ts
+import * as commentJson from "comment-json";
+function createJson5Writer(content) {
+  const parsedData = commentJson.parse(content);
+  return {
+    write(data) {
+      if (parsedData && typeof parsedData === "object" && data) {
+        Object.assign(parsedData, data);
+      }
+    },
+    toSource() {
+      return commentJson.stringify(parsedData, null, 2);
+    }
+  };
+}
+function parseJson5(content) {
+  return commentJson.parse(content);
+}
+var init_json5_adapter = __esm({
+  "../config/json5-adapter.ts"() {
+    "use strict";
+    __name(createJson5Writer, "createJson5Writer");
+    __name(parseJson5, "parseJson5");
+  }
+});
+
+// ../config/resolver.ts
+import { existsSync } from "fs";
+import path from "path";
+var ConfigResolver;
+var init_resolver = __esm({
+  "../config/resolver.ts"() {
+    "use strict";
+    ConfigResolver = class _ConfigResolver {
+      static {
+        __name(this, "ConfigResolver");
+      }
+      /**
+       * 按优先级解析配置文件路径
+       *
+       * 优先级顺序：
+       * 1. 环境变量 XIAOZHI_CONFIG_DIR 指定的目录
+       * 2. 当前工作目录
+       * 3. 用户家目录/.xiaozhi-client/
+       *
+       * @returns 找到的配置文件路径，如果都不存在则返回 null
+       */
+      static resolveConfigPath() {
+        if (process.env.XIAOZHI_CONFIG_DIR) {
+          const configPath = _ConfigResolver.findConfigInDir(
+            process.env.XIAOZHI_CONFIG_DIR
+          );
+          if (configPath) {
+            return configPath;
+          }
+        }
+        const currentDirConfig = _ConfigResolver.findConfigInDir(process.cwd());
+        if (currentDirConfig) {
+          return currentDirConfig;
+        }
+        const homeDir = process.env.HOME || process.env.USERPROFILE;
+        if (homeDir) {
+          const xiaozhiClientDir = path.join(homeDir, ".xiaozhi-client");
+          const homeDirConfig = _ConfigResolver.findConfigInDir(xiaozhiClientDir);
+          if (homeDirConfig) {
+            return homeDirConfig;
+          }
+        }
+        return null;
+      }
+      /**
+       * 在指定目录中查找配置文件
+       *
+       * 按优先级查找：xiaozhi.config.json5 > xiaozhi.config.jsonc > xiaozhi.config.json
+       *
+       * @param dir - 要搜索的目录
+       * @returns 找到的配置文件路径，如果不存在则返回 null
+       */
+      static findConfigInDir(dir) {
+        const configFileNames = [
+          "xiaozhi.config.json5",
+          "xiaozhi.config.jsonc",
+          "xiaozhi.config.json"
+        ];
+        for (const fileName of configFileNames) {
+          const filePath = path.join(dir, fileName);
+          if (existsSync(filePath)) {
+            return filePath;
+          }
+        }
+        return null;
+      }
+      /**
+       * 获取默认配置目录路径
+       *
+       * @returns 用户家目录下的 .xiaozhi-client 目录路径，如果无法获取家目录则返回 null
+       */
+      static getDefaultConfigDir() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE;
+        if (!homeDir) {
+          return null;
+        }
+        return path.join(homeDir, ".xiaozhi-client");
+      }
+    };
+  }
+});
+
+// ../config/manager.ts
+import { copyFileSync, existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import * as commentJson2 from "comment-json";
+import dayjs from "dayjs";
+var __dirname, DEFAULT_CONNECTION_CONFIG, ConfigManager, configManager;
+var init_manager = __esm({
+  "../config/manager.ts"() {
+    "use strict";
+    init_json5_adapter();
+    init_resolver();
+    __dirname = dirname(fileURLToPath(import.meta.url));
+    DEFAULT_CONNECTION_CONFIG = {
+      heartbeatInterval: 3e4,
+      // 30秒心跳间隔
+      heartbeatTimeout: 1e4,
+      // 10秒心跳超时
+      reconnectInterval: 5e3
+      // 5秒重连间隔
+    };
+    ConfigManager = class _ConfigManager {
+      static {
+        __name(this, "ConfigManager");
+      }
+      static instance;
+      defaultConfigPath;
+      config = null;
+      currentConfigPath = null;
+      // 跟踪当前使用的配置文件路径
+      json5Writer = null;
+      // json5-writer 实例，用于保留 JSON5 注释
+      // 统计更新并发控制
+      statsUpdateLocks = /* @__PURE__ */ new Map();
+      statsUpdateLockTimeouts = /* @__PURE__ */ new Map();
+      STATS_UPDATE_TIMEOUT = 5e3;
+      // 5秒超时
+      // 事件回调（用于解耦 EventBus 依赖）
+      eventCallbacks = /* @__PURE__ */ new Map();
+      constructor() {
+        const possiblePaths = [
+          // src/config/ 或 dist/config/ → 项目根 templates/default/xiaozhi.config.json
+          resolve(
+            __dirname,
+            "..",
+            "..",
+            "templates",
+            "default",
+            "xiaozhi.config.json"
+          ),
+          // 从 CWD 查找（兼容各种启动场景）
+          resolve(process.cwd(), "templates", "default", "xiaozhi.config.json")
+        ];
+        this.defaultConfigPath = possiblePaths.find((path9) => existsSync2(path9)) || possiblePaths[0];
+      }
+      /**
+       * 注册事件监听器
+       */
+      on(eventName, callback) {
+        if (!this.eventCallbacks.has(eventName)) {
+          this.eventCallbacks.set(eventName, []);
+        }
+        this.eventCallbacks.get(eventName)?.push(callback);
+      }
+      /**
+       * 发射事件
+       */
+      emitEvent(eventName, data) {
+        const callbacks = this.eventCallbacks.get(eventName);
+        if (callbacks) {
+          for (const callback of callbacks) {
+            try {
+              callback(data);
+            } catch (error) {
+              console.error(`\u4E8B\u4EF6\u56DE\u8C03\u6267\u884C\u5931\u8D25 [${eventName}]:`, error);
+            }
+          }
+        }
+      }
+      /**
+       * 获取配置文件路径（动态计算）
+       * 支持多种配置文件格式：json5 > jsonc > json
+       *
+       * 查找优先级：
+       * 1. 环境变量 XIAOZHI_CONFIG_DIR 指定的目录
+       * 2. 当前工作目录
+       * 3. 用户家目录/.xiaozhi-client/
+       */
+      getConfigFilePath() {
+        const resolvedPath = ConfigResolver.resolveConfigPath();
+        if (resolvedPath) {
+          return resolvedPath;
+        }
+        const defaultDir = ConfigResolver.getDefaultConfigDir();
+        if (defaultDir) {
+          return resolve(defaultDir, "xiaozhi.config.json");
+        }
+        const configDir = process.env.XIAOZHI_CONFIG_DIR || process.cwd();
+        return resolve(configDir, "xiaozhi.config.json");
+      }
+      /**
+       * 获取配置文件格式
+       */
+      getConfigFileFormat(filePath) {
+        if (filePath.endsWith(".json5")) {
+          return "json5";
+        }
+        if (filePath.endsWith(".jsonc")) {
+          return "jsonc";
+        }
+        return "json";
+      }
+      /**
+       * 获取配置管理器单例实例
+       */
+      static getInstance() {
+        if (!_ConfigManager.instance) {
+          _ConfigManager.instance = new _ConfigManager();
+        }
+        return _ConfigManager.instance;
+      }
+      /**
+       * 检查配置文件是否存在
+       *
+       * 按优先级检查配置文件是否存在：
+       * 1. 环境变量 XIAOZHI_CONFIG_DIR 指定的目录
+       * 2. 当前工作目录
+       * 3. 用户家目录/.xiaozhi-client/
+       */
+      configExists() {
+        return ConfigResolver.resolveConfigPath() !== null;
+      }
+      /**
+       * 初始化配置文件
+       * 从 config.default.json 复制到 config.json
+       * @param format 配置文件格式，默认为 json
+       */
+      initConfig(format = "json") {
+        if (!existsSync2(this.defaultConfigPath)) {
+          throw new Error(`\u9ED8\u8BA4\u914D\u7F6E\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${this.defaultConfigPath}`);
+        }
+        if (this.configExists()) {
+          throw new Error("\u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u65E0\u9700\u91CD\u590D\u521D\u59CB\u5316");
+        }
+        const configDir = process.env.XIAOZHI_CONFIG_DIR || process.cwd();
+        const targetFileName = `xiaozhi.config.${format}`;
+        const configPath = resolve(configDir, targetFileName);
+        copyFileSync(this.defaultConfigPath, configPath);
+        this.config = null;
+        this.json5Writer = null;
+      }
+      /**
+       * 加载配置文件
+       */
+      loadConfig() {
+        if (!this.configExists()) {
+          const error = new Error(
+            "\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u8FD0\u884C xiaozhi init \u521D\u59CB\u5316\u914D\u7F6E"
+          );
+          this.emitEvent("config:error", {
+            error,
+            operation: "loadConfig"
+          });
+          throw error;
+        }
+        try {
+          const configPath = this.getConfigFilePath();
+          this.currentConfigPath = configPath;
+          const configFileFormat = this.getConfigFileFormat(configPath);
+          const rawConfigData = readFileSync(configPath, "utf8");
+          const configData = rawConfigData.replace(/^\uFEFF/, "");
+          let config;
+          switch (configFileFormat) {
+            case "json5":
+              config = parseJson5(configData);
+              this.json5Writer = createJson5Writer(configData);
+              break;
+            case "jsonc":
+              config = commentJson2.parse(configData);
+              break;
+            default:
+              config = JSON.parse(configData);
+              break;
+          }
+          this.validateConfig(config);
+          return config;
+        } catch (error) {
+          this.emitEvent("config:error", {
+            error: error instanceof Error ? error : new Error(String(error)),
+            operation: "loadConfig"
+          });
+          if (error instanceof SyntaxError) {
+            throw new Error(`\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF: ${error.message}`);
+          }
+          throw error;
+        }
+      }
+      /**
+       * 验证配置文件结构
+       */
+      validateConfig(config) {
+        if (!config || typeof config !== "object") {
+          throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1A\u6839\u5BF9\u8C61\u65E0\u6548");
+        }
+        const configObj = config;
+        if (configObj.mcpEndpoint === void 0 || configObj.mcpEndpoint === null) {
+          throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1AmcpEndpoint \u5B57\u6BB5\u65E0\u6548");
+        }
+        if (typeof configObj.mcpEndpoint === "string") {
+        } else if (Array.isArray(configObj.mcpEndpoint)) {
+          for (const endpoint of configObj.mcpEndpoint) {
+            if (typeof endpoint !== "string" || endpoint.trim() === "") {
+              throw new Error(
+                "\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1AmcpEndpoint \u6570\u7EC4\u4E2D\u7684\u6BCF\u4E2A\u5143\u7D20\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32"
+              );
+            }
+          }
+        } else {
+          throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1AmcpEndpoint \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6216\u5B57\u7B26\u4E32\u6570\u7EC4");
+        }
+        if (!configObj.mcpServers || typeof configObj.mcpServers !== "object") {
+          throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1AmcpServers \u5B57\u6BB5\u65E0\u6548");
+        }
+        for (const [serverName, serverConfig] of Object.entries(
+          configObj.mcpServers
+        )) {
+          if (!serverConfig || typeof serverConfig !== "object") {
+            throw new Error(`\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF\uFF1AmcpServers.${serverName} \u65E0\u6548`);
+          }
+        }
+      }
+      /**
+       * 获取配置（只读）
+       * 使用缓存机制避免频繁的文件 I/O 操作
+       */
+      getConfig() {
+        if (!this.config) {
+          this.config = this.loadConfig();
+        }
+        return structuredClone(this.config);
+      }
+      /**
+       * 获取可修改的配置对象（内部使用，保留注释信息）
+       */
+      getMutableConfig() {
+        if (!this.config) {
+          this.config = this.loadConfig();
+        }
+        return this.config;
+      }
+      /**
+       * 获取 MCP 端点（向后兼容）
+       * @deprecated 使用 getMcpEndpoints() 获取所有端点
+       */
+      getMcpEndpoint() {
+        const config = this.getConfig();
+        if (Array.isArray(config.mcpEndpoint)) {
+          return config.mcpEndpoint[0] || "";
+        }
+        return config.mcpEndpoint;
+      }
+      /**
+       * 获取所有 MCP 端点
+       */
+      getMcpEndpoints() {
+        const config = this.getConfig();
+        if (Array.isArray(config.mcpEndpoint)) {
+          return [...config.mcpEndpoint];
+        }
+        return config.mcpEndpoint ? [config.mcpEndpoint] : [];
+      }
+      /**
+       * 获取 MCP 服务配置
+       */
+      getMcpServers() {
+        const config = this.getConfig();
+        return config.mcpServers;
+      }
+      /**
+       * 获取 MCP 服务工具配置
+       */
+      getMcpServerConfig() {
+        const config = this.getConfig();
+        return config.mcpServerConfig || {};
+      }
+      /**
+       * 获取指定服务的工具配置
+       */
+      getServerToolsConfig(serverName) {
+        const serverConfig = this.getMcpServerConfig();
+        return serverConfig[serverName]?.tools || {};
+      }
+      /**
+       * 检查工具是否启用
+       */
+      isToolEnabled(serverName, toolName) {
+        const toolsConfig = this.getServerToolsConfig(serverName);
+        const toolConfig = toolsConfig[toolName];
+        return toolConfig?.enable !== false;
+      }
+      /**
+       * 更新 MCP 端点（支持字符串或数组）
+       */
+      updateMcpEndpoint(endpoint) {
+        if (Array.isArray(endpoint)) {
+          for (const ep of endpoint) {
+            if (!ep || typeof ep !== "string") {
+              throw new Error("MCP \u7AEF\u70B9\u6570\u7EC4\u4E2D\u7684\u6BCF\u4E2A\u5143\u7D20\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+            }
+          }
+        }
+        const config = this.getMutableConfig();
+        config.mcpEndpoint = endpoint;
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "endpoint",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      /**
+       * 添加 MCP 端点
+       */
+      addMcpEndpoint(endpoint) {
+        if (!endpoint || typeof endpoint !== "string") {
+          throw new Error("MCP \u7AEF\u70B9\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+        }
+        const config = this.getMutableConfig();
+        const currentEndpoints = this.getMcpEndpoints();
+        if (currentEndpoints.includes(endpoint)) {
+          throw new Error(`MCP \u7AEF\u70B9 ${endpoint} \u5DF2\u5B58\u5728`);
+        }
+        const newEndpoints = [...currentEndpoints, endpoint];
+        config.mcpEndpoint = newEndpoints;
+        this.saveConfig(config);
+      }
+      /**
+       * 移除 MCP 端点
+       */
+      removeMcpEndpoint(endpoint) {
+        if (!endpoint || typeof endpoint !== "string") {
+          throw new Error("MCP \u7AEF\u70B9\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+        }
+        const config = this.getMutableConfig();
+        const currentEndpoints = this.getMcpEndpoints();
+        const index = currentEndpoints.indexOf(endpoint);
+        if (index === -1) {
+          throw new Error(`MCP \u7AEF\u70B9 ${endpoint} \u4E0D\u5B58\u5728`);
+        }
+        const newEndpoints = currentEndpoints.filter((ep) => ep !== endpoint);
+        config.mcpEndpoint = newEndpoints;
+        this.saveConfig(config);
+      }
+      /**
+       * 更新 MCP 服务配置
+       */
+      updateMcpServer(serverName, serverConfig) {
+        if (!serverName || typeof serverName !== "string") {
+          throw new Error("\u670D\u52A1\u540D\u79F0\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+        }
+        const config = this.getMutableConfig();
+        config.mcpServers[serverName] = serverConfig;
+        this.saveConfig(config);
+      }
+      /**
+       * 删除 MCP 服务配置
+       */
+      removeMcpServer(serverName) {
+        if (!serverName || typeof serverName !== "string") {
+          throw new Error("\u670D\u52A1\u540D\u79F0\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+        }
+        const config = this.getMutableConfig();
+        if (!config.mcpServers[serverName]) {
+          throw new Error(`\u670D\u52A1 ${serverName} \u4E0D\u5B58\u5728`);
+        }
+        delete config.mcpServers[serverName];
+        if (config.mcpServerConfig?.[serverName]) {
+          delete config.mcpServerConfig[serverName];
+        }
+        if (config.customMCP?.tools) {
+          const relatedTools = config.customMCP.tools.filter(
+            (tool) => tool.handler?.type === "mcp" && tool.handler.config?.serviceName === serverName
+          );
+          for (const tool of relatedTools) {
+            const toolIndex = config.customMCP.tools.findIndex(
+              (t) => t.name === tool.name
+            );
+            if (toolIndex !== -1) {
+              config.customMCP.tools.splice(toolIndex, 1);
+            }
+          }
+          if (config.customMCP.tools.length === 0) {
+            config.customMCP = void 0;
+          }
+        }
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "customMCP",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        console.log("\u6210\u529F\u79FB\u9664 MCP \u670D\u52A1", { serverName });
+      }
+      /**
+       * 批量更新配置（由 Handler 调用）
+       */
+      updateConfig(newConfig) {
+        const config = this.getMutableConfig();
+        if (newConfig.mcpEndpoint !== void 0) {
+          config.mcpEndpoint = newConfig.mcpEndpoint;
+        }
+        if (newConfig.mcpServers) {
+          const currentServers = { ...config.mcpServers };
+          for (const [name, serverConfig] of Object.entries(newConfig.mcpServers)) {
+            config.mcpServers[name] = serverConfig;
+          }
+          for (const name of Object.keys(currentServers)) {
+            if (!(name in newConfig.mcpServers)) {
+              delete config.mcpServers[name];
+              if (config.mcpServerConfig?.[name]) {
+                delete config.mcpServerConfig[name];
+              }
+            }
+          }
+        }
+        if (newConfig.connection) {
+          if (!config.connection) {
+            config.connection = {};
+          }
+          Object.assign(config.connection, newConfig.connection);
+        }
+        if (newConfig.modelscope) {
+          if (!config.modelscope) {
+            config.modelscope = {};
+          }
+          Object.assign(config.modelscope, newConfig.modelscope);
+        }
+        if (newConfig.webUI) {
+          if (!config.webUI) {
+            config.webUI = {};
+          }
+          Object.assign(config.webUI, newConfig.webUI);
+        }
+        if (newConfig.mcpServerConfig) {
+          for (const [serverName, toolsConfig] of Object.entries(
+            newConfig.mcpServerConfig
+          )) {
+            if (config.mcpServerConfig?.[serverName]) {
+              config.mcpServerConfig[serverName] = toolsConfig;
+            }
+          }
+        }
+        if (newConfig.platforms) {
+          for (const [platformName, platformConfig] of Object.entries(
+            newConfig.platforms
+          )) {
+            if (!config.platforms) {
+              config.platforms = {};
+            }
+            config.platforms[platformName] = platformConfig;
+          }
+        }
+        if ("asr" in newConfig) {
+          config.asr = newConfig.asr;
+        }
+        if ("tts" in newConfig) {
+          config.tts = newConfig.tts;
+        }
+        if ("llm" in newConfig) {
+          config.llm = newConfig.llm;
+        }
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "config",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      /**
+       * 更新服务工具配置
+       */
+      updateServerToolsConfig(serverName, toolsConfig) {
+        const config = this.getMutableConfig();
+        if (!config.mcpServerConfig) {
+          config.mcpServerConfig = {};
+        }
+        if (Object.keys(toolsConfig).length === 0) {
+          delete config.mcpServerConfig[serverName];
+        } else {
+          config.mcpServerConfig[serverName] = {
+            tools: toolsConfig
+          };
+        }
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "serverTools",
+          serviceName: serverName,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      /**
+       * 删除指定服务器的工具配置
+       */
+      removeServerToolsConfig(serverName) {
+        const config = this.getConfig();
+        const newConfig = { ...config };
+        if (newConfig.mcpServerConfig) {
+          delete newConfig.mcpServerConfig[serverName];
+          this.saveConfig(newConfig);
+        }
+      }
+      /**
+       * 清理无效的服务器工具配置
+       * 删除在 mcpServerConfig 中存在但在 mcpServers 中不存在的服务配置
+       */
+      cleanupInvalidServerToolsConfig() {
+        const config = this.getMutableConfig();
+        if (!config.mcpServerConfig) {
+          return;
+        }
+        const validServerNames = Object.keys(config.mcpServers);
+        const configuredServerNames = Object.keys(config.mcpServerConfig);
+        const invalidServerNames = configuredServerNames.filter(
+          (serverName) => !validServerNames.includes(serverName)
+        );
+        if (invalidServerNames.length > 0) {
+          for (const serverName of invalidServerNames) {
+            delete config.mcpServerConfig[serverName];
+          }
+          this.saveConfig(config);
+          console.log("\u5DF2\u6E05\u7406\u65E0\u6548\u7684\u670D\u52A1\u5DE5\u5177\u914D\u7F6E", {
+            count: invalidServerNames.length,
+            serverNames: invalidServerNames
+          });
+        }
+      }
+      /**
+       * 设置工具启用状态
+       */
+      setToolEnabled(serverName, toolName, enabled, description) {
+        const config = this.getMutableConfig();
+        if (!config.mcpServerConfig) {
+          config.mcpServerConfig = {};
+        }
+        if (!config.mcpServerConfig[serverName]) {
+          config.mcpServerConfig[serverName] = { tools: {} };
+        }
+        config.mcpServerConfig[serverName].tools[toolName] = {
+          ...config.mcpServerConfig[serverName].tools[toolName],
+          enable: enabled,
+          ...description && { description }
+        };
+        this.saveConfig(config);
+      }
+      /**
+       * 保存配置到文件
+       * 保存到原始配置文件路径，保持文件格式一致性
+       */
+      saveConfig(config) {
+        try {
+          this.validateConfig(config);
+          let configPath;
+          if (this.currentConfigPath) {
+            configPath = this.currentConfigPath;
+          } else {
+            configPath = this.getConfigFilePath();
+            this.currentConfigPath = configPath;
+          }
+          const configFileFormat = this.getConfigFileFormat(configPath);
+          let configContent;
+          switch (configFileFormat) {
+            case "json5":
+              try {
+                if (this.json5Writer) {
+                  this.json5Writer.write(config);
+                  configContent = this.json5Writer.toSource();
+                } else {
+                  console.warn("\u6CA1\u6709 JSON5 \u9002\u914D\u5668\u5B9E\u4F8B\uFF0C\u4F7F\u7528 comment-json \u5E8F\u5217\u5316");
+                  configContent = commentJson2.stringify(config, null, 2);
+                }
+              } catch (json5Error) {
+                console.warn(
+                  "\u4F7F\u7528 JSON5 \u9002\u914D\u5668\u4FDD\u5B58\u5931\u8D25\uFF0C\u56DE\u9000\u5230 comment-json \u5E8F\u5217\u5316:",
+                  json5Error
+                );
+                configContent = commentJson2.stringify(config, null, 2);
+              }
+              break;
+            case "jsonc":
+              try {
+                configContent = commentJson2.stringify(config, null, 2);
+              } catch (commentJsonError) {
+                console.warn(
+                  "\u4F7F\u7528 comment-json \u4FDD\u5B58\u5931\u8D25\uFF0C\u56DE\u9000\u5230\u6807\u51C6 JSON \u683C\u5F0F:",
+                  commentJsonError
+                );
+                configContent = JSON.stringify(config, null, 2);
+              }
+              break;
+            default:
+              configContent = JSON.stringify(config, null, 2);
+              break;
+          }
+          writeFileSync(configPath, configContent, "utf8");
+          this.config = config;
+          console.log("\u914D\u7F6E\u4FDD\u5B58\u6210\u529F");
+          this.notifyConfigUpdate(config);
+        } catch (error) {
+          this.emitEvent("config:error", {
+            error: error instanceof Error ? error : new Error(String(error)),
+            operation: "saveConfig"
+          });
+          throw new Error(
+            `\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * 重新加载配置（清除缓存）
+       */
+      reloadConfig() {
+        this.config = null;
+        this.currentConfigPath = null;
+        this.json5Writer = null;
+      }
+      /**
+       * 获取配置文件路径
+       */
+      getConfigPath() {
+        return this.getConfigFilePath();
+      }
+      /**
+       * 获取默认配置文件路径
+       */
+      getDefaultConfigPath() {
+        return this.defaultConfigPath;
+      }
+      /**
+       * 获取连接配置（包含默认值）
+       */
+      getConnectionConfig() {
+        const config = this.getConfig();
+        const connectionConfig = config.connection || {};
+        return {
+          heartbeatInterval: connectionConfig.heartbeatInterval ?? DEFAULT_CONNECTION_CONFIG.heartbeatInterval,
+          heartbeatTimeout: connectionConfig.heartbeatTimeout ?? DEFAULT_CONNECTION_CONFIG.heartbeatTimeout,
+          reconnectInterval: connectionConfig.reconnectInterval ?? DEFAULT_CONNECTION_CONFIG.reconnectInterval
+        };
+      }
+      /**
+       * 获取心跳检测间隔（毫秒）
+       */
+      getHeartbeatInterval() {
+        return this.getConnectionConfig().heartbeatInterval;
+      }
+      /**
+       * 获取心跳超时时间（毫秒）
+       */
+      getHeartbeatTimeout() {
+        return this.getConnectionConfig().heartbeatTimeout;
+      }
+      /**
+       * 获取重连间隔（毫秒）
+       */
+      getReconnectInterval() {
+        return this.getConnectionConfig().reconnectInterval;
+      }
+      /**
+       * 更新连接配置
+       */
+      updateConnectionConfig(connectionConfig) {
+        const config = this.getMutableConfig();
+        if (!config.connection) {
+          config.connection = {};
+        }
+        Object.assign(config.connection, connectionConfig);
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "connection",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      /**
+       * 更新工具使用统计信息的实现
+       */
+      async updateToolUsageStats(arg1, arg2, arg3) {
+        try {
+          if (typeof arg2 === "string" && arg3) {
+            const serverName = arg1;
+            const toolName = arg2;
+            const callTime = arg3;
+            await Promise.all([
+              this._updateMCPServerToolStats(serverName, toolName, callTime),
+              this.updateCustomMCPToolStats(serverName, toolName, callTime)
+            ]);
+            console.log("\u5DE5\u5177\u4F7F\u7528\u7EDF\u8BA1\u5DF2\u66F4\u65B0", { serverName, toolName });
+          } else {
+            const toolName = arg1;
+            const incrementUsageCount = arg2;
+            const callTime = (/* @__PURE__ */ new Date()).toISOString();
+            await this.updateCustomMCPToolStats(
+              toolName,
+              callTime,
+              incrementUsageCount
+            );
+            console.log("CustomMCP \u5DE5\u5177\u4F7F\u7528\u7EDF\u8BA1\u5DF2\u66F4\u65B0", { toolName });
+          }
+        } catch (error) {
+          if (typeof arg2 === "string" && arg3) {
+            const serverName = arg1;
+            const toolName = arg2;
+            console.error("\u66F4\u65B0\u5DE5\u5177\u4F7F\u7528\u7EDF\u8BA1\u5931\u8D25", { serverName, toolName, error });
+          } else {
+            const toolName = arg1;
+            console.error("\u66F4\u65B0 CustomMCP \u5DE5\u5177\u4F7F\u7528\u7EDF\u8BA1\u5931\u8D25", { toolName, error });
+          }
+        }
+      }
+      /**
+       * 更新 MCP 服务工具统计信息（重载方法）
+       * @param serviceName 服务名称
+       * @param toolName 工具名称
+       * @param callTime 调用时间（ISO 8601 格式）
+       * @param incrementUsageCount 是否增加使用计数，默认为 true
+       */
+      async updateMCPServerToolStats(serviceName, toolName, callTime, incrementUsageCount = true) {
+        await this._updateMCPServerToolStats(
+          serviceName,
+          toolName,
+          callTime,
+          incrementUsageCount
+        );
+      }
+      /**
+       * 设置心跳检测间隔
+       */
+      setHeartbeatInterval(interval) {
+        if (interval <= 0) {
+          throw new Error("\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694\u5FC5\u987B\u5927\u4E8E0");
+        }
+        this.updateConnectionConfig({ heartbeatInterval: interval });
+      }
+      /**
+       * 设置心跳超时时间
+       */
+      setHeartbeatTimeout(timeout) {
+        if (timeout <= 0) {
+          throw new Error("\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4\u5FC5\u987B\u5927\u4E8E0");
+        }
+        this.updateConnectionConfig({ heartbeatTimeout: timeout });
+      }
+      /**
+       * 设置重连间隔
+       */
+      setReconnectInterval(interval) {
+        if (interval <= 0) {
+          throw new Error("\u91CD\u8FDE\u95F4\u9694\u5FC5\u987B\u5927\u4E8E0");
+        }
+        this.updateConnectionConfig({ reconnectInterval: interval });
+      }
+      /**
+       * 获取 ModelScope 配置
+       */
+      getModelScopeConfig() {
+        const config = this.getConfig();
+        return config.modelscope || {};
+      }
+      /**
+       * 获取 ModelScope API Key
+       * 优先从配置文件读取，其次从环境变量读取
+       */
+      getModelScopeApiKey() {
+        const modelScopeConfig = this.getModelScopeConfig();
+        return modelScopeConfig.apiKey || process.env.MODELSCOPE_API_TOKEN;
+      }
+      /**
+       * 更新 ModelScope 配置
+       */
+      updateModelScopeConfig(modelScopeConfig) {
+        const config = this.getMutableConfig();
+        if (!config.modelscope) {
+          config.modelscope = {};
+        }
+        Object.assign(config.modelscope, modelScopeConfig);
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "modelscope",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      /**
+       * 设置 ModelScope API Key
+       */
+      setModelScopeApiKey(apiKey) {
+        if (!apiKey || typeof apiKey !== "string") {
+          throw new Error("API Key \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+        }
+        this.updateModelScopeConfig({ apiKey });
+      }
+      /**
+       * 获取 customMCP 配置
+       */
+      getCustomMCPConfig() {
+        const config = this.getConfig();
+        return config.customMCP || null;
+      }
+      /**
+       * 获取 customMCP 工具列表
+       */
+      getCustomMCPTools() {
+        const customMCPConfig = this.getCustomMCPConfig();
+        if (!customMCPConfig || !customMCPConfig.tools) {
+          return [];
+        }
+        return customMCPConfig.tools;
+      }
+      /**
+       * 验证 customMCP 工具配置
+       */
+      validateCustomMCPTools(tools) {
+        if (!Array.isArray(tools)) {
+          return false;
+        }
+        for (const tool of tools) {
+          if (!tool.name || typeof tool.name !== "string") {
+            console.warn("CustomMCP \u5DE5\u5177\u7F3A\u5C11\u6709\u6548\u7684 name \u5B57\u6BB5", { tool });
+            return false;
+          }
+          if (!tool.description || typeof tool.description !== "string") {
+            console.warn("CustomMCP \u5DE5\u5177\u7F3A\u5C11\u6709\u6548\u7684 description \u5B57\u6BB5", {
+              toolName: tool.name
+            });
+            return false;
+          }
+          if (!tool.inputSchema || typeof tool.inputSchema !== "object") {
+            console.warn("CustomMCP \u5DE5\u5177\u7F3A\u5C11\u6709\u6548\u7684 inputSchema \u5B57\u6BB5", {
+              toolName: tool.name
+            });
+            return false;
+          }
+          if (!tool.handler || typeof tool.handler !== "object") {
+            console.warn("CustomMCP \u5DE5\u5177\u7F3A\u5C11\u6709\u6548\u7684 handler \u5B57\u6BB5", {
+              toolName: tool.name
+            });
+            return false;
+          }
+          if (!["proxy", "function", "http", "script", "chain", "mcp"].includes(
+            tool.handler.type
+          )) {
+            console.warn("CustomMCP \u5DE5\u5177\u7684 handler.type \u7C7B\u578B\u65E0\u6548", {
+              toolName: tool.name,
+              type: tool.handler.type
+            });
+            return false;
+          }
+          if (!this.validateHandlerConfig(tool.name, tool.handler)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * 验证处理器配置
+       */
+      validateHandlerConfig(toolName, handler) {
+        switch (handler.type) {
+          case "proxy":
+            return this.validateProxyHandler(toolName, handler);
+          case "http":
+            return this.validateHttpHandler(toolName, handler);
+          case "function":
+            return this.validateFunctionHandler(toolName, handler);
+          case "script":
+            return this.validateScriptHandler(toolName, handler);
+          case "chain":
+            return this.validateChainHandler(toolName, handler);
+          case "mcp":
+            return this.validateMCPHandler(toolName, handler);
+          default:
+            console.warn("CustomMCP \u5DE5\u5177\u4F7F\u7528\u4E86\u672A\u77E5\u7684\u5904\u7406\u5668\u7C7B\u578B", {
+              toolName,
+              handlerType: handler.type
+            });
+            return false;
+        }
+      }
+      /**
+       * 验证代理处理器配置
+       */
+      validateProxyHandler(toolName, handler) {
+        if (!handler.platform) {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 proxy \u5904\u7406\u5668\u7F3A\u5C11 platform \u5B57\u6BB5", {
+            toolName
+          });
+          return false;
+        }
+        if (!["coze", "openai", "anthropic", "custom"].includes(handler.platform)) {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 proxy \u5904\u7406\u5668\u4F7F\u7528\u4E86\u4E0D\u652F\u6301\u7684\u5E73\u53F0", {
+            toolName,
+            platform: handler.platform
+          });
+          return false;
+        }
+        if (!handler.config || typeof handler.config !== "object") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 proxy \u5904\u7406\u5668\u7F3A\u5C11 config \u5B57\u6BB5", {
+            toolName
+          });
+          return false;
+        }
+        if (handler.platform === "coze") {
+          if (!handler.config.workflow_id && !handler.config.bot_id) {
+            console.warn(
+              "CustomMCP \u5DE5\u5177\u7684 Coze \u5904\u7406\u5668\u5FC5\u987B\u63D0\u4F9B workflow_id \u6216 bot_id",
+              { toolName }
+            );
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * 验证 HTTP 处理器配置
+       */
+      validateHttpHandler(toolName, handler) {
+        if (!handler.url || typeof handler.url !== "string") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 http \u5904\u7406\u5668\u7F3A\u5C11\u6709\u6548\u7684 url \u5B57\u6BB5", {
+            toolName
+          });
+          return false;
+        }
+        try {
+          new URL(handler.url);
+        } catch {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 http \u5904\u7406\u5668 url \u683C\u5F0F\u65E0\u6548", {
+            toolName,
+            url: handler.url
+          });
+          return false;
+        }
+        if (handler.method && !["GET", "POST", "PUT", "DELETE", "PATCH"].includes(handler.method)) {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 http \u5904\u7406\u5668\u4F7F\u7528\u4E86\u4E0D\u652F\u6301\u7684 HTTP \u65B9\u6CD5", {
+            toolName,
+            method: handler.method
+          });
+          return false;
+        }
+        return true;
+      }
+      /**
+       * 验证函数处理器配置
+       */
+      validateFunctionHandler(toolName, handler) {
+        if (!handler.module || typeof handler.module !== "string") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 function \u5904\u7406\u5668\u7F3A\u5C11\u6709\u6548\u7684 module \u5B57\u6BB5", {
+            toolName
+          });
+          return false;
+        }
+        if (!handler.function || typeof handler.function !== "string") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 function \u5904\u7406\u5668\u7F3A\u5C11\u6709\u6548\u7684 function \u5B57\u6BB5", {
+            toolName
+          });
+          return false;
+        }
+        return true;
+      }
+      /**
+       * 验证脚本处理器配置
+       */
+      validateScriptHandler(toolName, handler) {
+        if (!handler.script || typeof handler.script !== "string") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 script \u5904\u7406\u5668\u7F3A\u5C11\u6709\u6548\u7684 script \u5B57\u6BB5", {
+            toolName
+          });
+          return false;
+        }
+        if (handler.interpreter && !["node", "python", "bash"].includes(handler.interpreter)) {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 script \u5904\u7406\u5668\u4F7F\u7528\u4E86\u4E0D\u652F\u6301\u7684\u89E3\u91CA\u5668", {
+            toolName,
+            interpreter: handler.interpreter
+          });
+          return false;
+        }
+        return true;
+      }
+      /**
+       * 验证链式处理器配置
+       */
+      validateChainHandler(toolName, handler) {
+        if (!handler.tools || !Array.isArray(handler.tools) || handler.tools.length === 0) {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 chain \u5904\u7406\u5668\u7F3A\u5C11\u6709\u6548\u7684 tools \u6570\u7EC4", {
+            toolName
+          });
+          return false;
+        }
+        if (!["sequential", "parallel"].includes(handler.mode)) {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 chain \u5904\u7406\u5668\u4F7F\u7528\u4E86\u4E0D\u652F\u6301\u7684\u6267\u884C\u6A21\u5F0F", {
+            toolName,
+            mode: handler.mode
+          });
+          return false;
+        }
+        if (!["stop", "continue", "retry"].includes(handler.error_handling)) {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 chain \u5904\u7406\u5668\u4F7F\u7528\u4E86\u4E0D\u652F\u6301\u7684\u9519\u8BEF\u5904\u7406\u7B56\u7565", {
+            toolName,
+            errorHandling: handler.error_handling
+          });
+          return false;
+        }
+        return true;
+      }
+      /**
+       * 验证 MCP 处理器配置
+       */
+      validateMCPHandler(toolName, handler) {
+        if (!handler.config || typeof handler.config !== "object") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 mcp \u5904\u7406\u5668\u7F3A\u5C11 config \u5B57\u6BB5", { toolName });
+          return false;
+        }
+        if (!handler.config.serviceName || typeof handler.config.serviceName !== "string") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 mcp \u5904\u7406\u5668\u7F3A\u5C11\u6709\u6548\u7684 serviceName", {
+            toolName
+          });
+          return false;
+        }
+        if (!handler.config.toolName || typeof handler.config.toolName !== "string") {
+          console.warn("CustomMCP \u5DE5\u5177\u7684 mcp \u5904\u7406\u5668\u7F3A\u5C11\u6709\u6548\u7684 toolName", {
+            toolName
+          });
+          return false;
+        }
+        return true;
+      }
+      /**
+       * 检查是否配置了有效的 customMCP 工具
+       */
+      hasValidCustomMCPTools() {
+        try {
+          const tools = this.getCustomMCPTools();
+          if (tools.length === 0) {
+            return false;
+          }
+          return this.validateCustomMCPTools(tools);
+        } catch (error) {
+          console.error("\u68C0\u67E5 customMCP \u5DE5\u5177\u914D\u7F6E\u65F6\u51FA\u9519", { error });
+          return false;
+        }
+      }
+      /**
+       * 添加自定义 MCP 工具
+       */
+      addCustomMCPTool(tool) {
+        if (!tool || typeof tool !== "object") {
+          throw new Error("\u5DE5\u5177\u914D\u7F6E\u4E0D\u80FD\u4E3A\u7A7A");
+        }
+        const config = this.getMutableConfig();
+        if (!config.customMCP) {
+          config.customMCP = { tools: [] };
+        }
+        const existingTool = config.customMCP.tools.find(
+          (t) => t.name === tool.name
+        );
+        if (existingTool) {
+          throw new Error(`\u5DE5\u5177 "${tool.name}" \u5DF2\u5B58\u5728`);
+        }
+        if (!this.validateCustomMCPTools([tool])) {
+          throw new Error("\u5DE5\u5177\u914D\u7F6E\u9A8C\u8BC1\u5931\u8D25");
+        }
+        config.customMCP.tools.unshift(tool);
+        this.saveConfig(config);
+        console.log("\u6210\u529F\u6DFB\u52A0\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177", { toolName: tool.name });
+      }
+      /**
+       * 批量添加自定义 MCP 工具
+       * @param tools 要添加的工具数组
+       */
+      async addCustomMCPTools(tools) {
+        if (!Array.isArray(tools)) {
+          throw new Error("\u5DE5\u5177\u914D\u7F6E\u5FC5\u987B\u662F\u6570\u7EC4");
+        }
+        if (tools.length === 0) {
+          return;
+        }
+        const config = this.getMutableConfig();
+        if (!config.customMCP) {
+          config.customMCP = { tools: [] };
+        }
+        const existingNames = new Set(
+          config.customMCP.tools.map((tool) => tool.name)
+        );
+        const newTools = tools.filter((tool) => !existingNames.has(tool.name));
+        if (newTools.length > 0) {
+          if (!this.validateCustomMCPTools(newTools)) {
+            throw new Error("\u5DE5\u5177\u914D\u7F6E\u9A8C\u8BC1\u5931\u8D25");
+          }
+          config.customMCP.tools.push(...newTools);
+          this.saveConfig(config);
+          this.emitEvent("config:updated", {
+            type: "customMCP",
+            timestamp: /* @__PURE__ */ new Date()
+          });
+          console.log("\u6210\u529F\u6279\u91CF\u6DFB\u52A0\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177", {
+            count: newTools.length,
+            toolNames: newTools.map((t) => t.name)
+          });
+        }
+      }
+      /**
+       * 删除自定义 MCP 工具
+       */
+      removeCustomMCPTool(toolName) {
+        if (!toolName || typeof toolName !== "string") {
+          throw new Error("\u5DE5\u5177\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+        }
+        const config = this.getMutableConfig();
+        if (!config.customMCP || !config.customMCP.tools) {
+          throw new Error("\u672A\u914D\u7F6E\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177");
+        }
+        const toolIndex = config.customMCP.tools.findIndex(
+          (t) => t.name === toolName
+        );
+        if (toolIndex === -1) {
+          throw new Error(`\u5DE5\u5177 "${toolName}" \u4E0D\u5B58\u5728`);
+        }
+        config.customMCP.tools.splice(toolIndex, 1);
+        this.saveConfig(config);
+        console.log("\u6210\u529F\u5220\u9664\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177", { toolName });
+      }
+      /**
+       * 更新单个自定义 MCP 工具配置
+       * @param toolName 工具名称
+       * @param updatedTool 更新后的工具配置
+       */
+      updateCustomMCPTool(toolName, updatedTool) {
+        if (!toolName || typeof toolName !== "string") {
+          throw new Error("\u5DE5\u5177\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+        }
+        if (!updatedTool || typeof updatedTool !== "object") {
+          throw new Error("\u66F4\u65B0\u540E\u7684\u5DE5\u5177\u914D\u7F6E\u4E0D\u80FD\u4E3A\u7A7A");
+        }
+        const config = this.getMutableConfig();
+        if (!config.customMCP || !config.customMCP.tools) {
+          throw new Error("\u672A\u914D\u7F6E\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177");
+        }
+        const toolIndex = config.customMCP.tools.findIndex(
+          (t) => t.name === toolName
+        );
+        if (toolIndex === -1) {
+          throw new Error(`\u5DE5\u5177 "${toolName}" \u4E0D\u5B58\u5728`);
+        }
+        if (!this.validateCustomMCPTools([updatedTool])) {
+          throw new Error("\u66F4\u65B0\u540E\u7684\u5DE5\u5177\u914D\u7F6E\u9A8C\u8BC1\u5931\u8D25");
+        }
+        config.customMCP.tools[toolIndex] = updatedTool;
+        this.saveConfig(config);
+        console.log("\u6210\u529F\u66F4\u65B0\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177", { toolName });
+      }
+      /**
+       * 更新自定义 MCP 工具配置
+       */
+      updateCustomMCPTools(tools) {
+        if (!Array.isArray(tools)) {
+          throw new Error("\u5DE5\u5177\u914D\u7F6E\u5FC5\u987B\u662F\u6570\u7EC4");
+        }
+        if (!this.validateCustomMCPTools(tools)) {
+          throw new Error("\u5DE5\u5177\u914D\u7F6E\u9A8C\u8BC1\u5931\u8D25");
+        }
+        const config = this.getMutableConfig();
+        if (!config.customMCP) {
+          config.customMCP = { tools: [] };
+        }
+        config.customMCP.tools = tools;
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "customMCP",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        console.log("\u6210\u529F\u66F4\u65B0\u81EA\u5B9A\u4E49 MCP \u5DE5\u5177\u914D\u7F6E", { count: tools.length });
+      }
+      /**
+       * 获取 Web UI 配置
+       */
+      getWebUIConfig() {
+        const config = this.getConfig();
+        return config.webUI || {};
+      }
+      /**
+       * 获取 Web UI 端口号
+       */
+      getWebUIPort() {
+        const webUIConfig = this.getWebUIConfig();
+        return webUIConfig.port ?? 9999;
+      }
+      /**
+       * 通知 Web 界面配置已更新
+       * 如果 Web 服务器正在运行，通过 WebSocket 广播配置更新
+       */
+      notifyConfigUpdate(config) {
+        try {
+          const webServer = global.__webServer;
+          if (webServer && typeof webServer.broadcastConfigUpdate === "function") {
+            webServer.broadcastConfigUpdate(config);
+            console.log("\u5DF2\u901A\u8FC7 WebSocket \u5E7F\u64AD\u914D\u7F6E\u66F4\u65B0");
+          }
+        } catch (error) {
+          console.warn(
+            "\u901A\u77E5 Web \u754C\u9762\u914D\u7F6E\u66F4\u65B0\u5931\u8D25:",
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+      /**
+       * 更新 Web UI 配置
+       */
+      updateWebUIConfig(webUIConfig) {
+        const config = this.getMutableConfig();
+        if (!config.webUI) {
+          config.webUI = {};
+        }
+        Object.assign(config.webUI, webUIConfig);
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "webui",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      /**
+       * 设置 Web UI 端口号
+       */
+      setWebUIPort(port) {
+        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+          throw new Error("\u7AEF\u53E3\u53F7\u5FC5\u987B\u662F 1-65535 \u4E4B\u95F4\u7684\u6574\u6570");
+        }
+        this.updateWebUIConfig({ port });
+      }
+      updatePlatformConfig(platformName, platformConfig) {
+        const config = this.getMutableConfig();
+        if (!config.platforms) {
+          config.platforms = {};
+        }
+        config.platforms[platformName] = platformConfig;
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "platform",
+          platformName,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      /**
+       * 获取扣子平台配置
+       */
+      getCozePlatformConfig() {
+        const config = this.getConfig();
+        const cozeConfig = config.platforms?.coze;
+        if (!cozeConfig || !cozeConfig.token) {
+          return null;
+        }
+        return {
+          token: cozeConfig.token
+        };
+      }
+      /**
+       * 获取扣子 API Token
+       */
+      getCozeToken() {
+        const cozeConfig = this.getCozePlatformConfig();
+        return cozeConfig?.token || null;
+      }
+      /**
+       * 设置扣子平台配置
+       */
+      setCozePlatformConfig(config) {
+        if (!config.token || typeof config.token !== "string" || config.token.trim() === "") {
+          throw new Error("\u6263\u5B50 API Token \u4E0D\u80FD\u4E3A\u7A7A");
+        }
+        this.updatePlatformConfig("coze", {
+          token: config.token.trim()
+        });
+      }
+      /**
+       * 检查扣子平台配置是否有效
+       */
+      isCozeConfigValid() {
+        const cozeConfig = this.getCozePlatformConfig();
+        return cozeConfig !== null && typeof cozeConfig.token === "string" && cozeConfig.token.trim() !== "";
+      }
+      /**
+       * 更新 mcpServerConfig 中的工具使用统计信息（内部实现）
+       * @param serverName 服务名称
+       * @param toolName 工具名称
+       * @param callTime 调用时间（ISO 8601 格式）
+       * @param incrementUsageCount 是否增加使用计数
+       * @private
+       */
+      async _updateMCPServerToolStats(serverName, toolName, callTime, incrementUsageCount = true) {
+        const config = this.getMutableConfig();
+        if (!config.mcpServerConfig) {
+          config.mcpServerConfig = {};
+        }
+        if (!config.mcpServerConfig[serverName]) {
+          config.mcpServerConfig[serverName] = { tools: {} };
+        }
+        if (!config.mcpServerConfig[serverName].tools[toolName]) {
+          config.mcpServerConfig[serverName].tools[toolName] = {
+            enable: true
+            // 默认启用
+          };
+        }
+        const toolConfig = config.mcpServerConfig[serverName].tools[toolName];
+        const currentUsageCount = toolConfig.usageCount || 0;
+        const currentLastUsedTime = toolConfig.lastUsedTime;
+        if (incrementUsageCount) {
+          toolConfig.usageCount = currentUsageCount + 1;
+        }
+        if (!currentLastUsedTime || new Date(callTime) > new Date(currentLastUsedTime)) {
+          toolConfig.lastUsedTime = dayjs(callTime).format("YYYY-MM-DD HH:mm:ss");
+        }
+        this.saveConfig(config);
+      }
+      /**
+       * 更新 customMCP 工具使用统计信息的实现
+       * @private
+       */
+      async updateCustomMCPToolStats(arg1, arg2, arg3) {
+        try {
+          let toolName;
+          let callTime;
+          let incrementUsageCount = true;
+          let logPrefix;
+          if (typeof arg3 === "string") {
+            const serverName = arg1;
+            toolName = `${serverName}__${arg2}`;
+            callTime = arg3;
+            logPrefix = `${serverName}/${arg2}`;
+          } else {
+            toolName = arg1;
+            callTime = arg2;
+            incrementUsageCount = arg3 || true;
+            logPrefix = toolName;
+          }
+          const customTools = this.getCustomMCPTools();
+          const toolIndex = customTools.findIndex((tool2) => tool2.name === toolName);
+          if (toolIndex === -1) {
+            return;
+          }
+          const updatedTools = [...customTools];
+          const tool = updatedTools[toolIndex];
+          if (!tool.stats) {
+            tool.stats = {};
+          }
+          const currentUsageCount = tool.stats.usageCount || 0;
+          const currentLastUsedTime = tool.stats.lastUsedTime;
+          if (incrementUsageCount) {
+            tool.stats.usageCount = currentUsageCount + 1;
+          }
+          if (!currentLastUsedTime || new Date(callTime) > new Date(currentLastUsedTime)) {
+            tool.stats.lastUsedTime = dayjs(callTime).format("YYYY-MM-DD HH:mm:ss");
+          }
+          await this.updateCustomMCPTools(updatedTools);
+        } catch (error) {
+          if (typeof arg3 === "string") {
+            const serverName = arg1;
+            const toolName = arg2;
+            console.error("\u66F4\u65B0 customMCP \u5DE5\u5177\u7EDF\u8BA1\u4FE1\u606F\u5931\u8D25", {
+              serverName,
+              toolName,
+              error
+            });
+          } else {
+            const toolName = arg1;
+            console.error("\u66F4\u65B0 customMCP \u5DE5\u5177\u7EDF\u8BA1\u4FE1\u606F\u5931\u8D25", { toolName, error });
+          }
+        }
+      }
+      /**
+       * 获取统计更新锁（确保同一工具的统计更新串行执行）
+       * @param toolKey 工具键
+       * @private
+       */
+      async acquireStatsUpdateLock(toolKey) {
+        if (this.statsUpdateLocks.has(toolKey)) {
+          console.log("\u5DE5\u5177\u7EDF\u8BA1\u66F4\u65B0\u6B63\u5728\u8FDB\u884C\u4E2D\uFF0C\u8DF3\u8FC7\u672C\u6B21\u66F4\u65B0", { toolKey });
+          return false;
+        }
+        const updatePromise = new Promise((resolve4) => {
+        });
+        this.statsUpdateLocks.set(toolKey, updatePromise);
+        const timeout = setTimeout(() => {
+          this.releaseStatsUpdateLock(toolKey);
+        }, this.STATS_UPDATE_TIMEOUT);
+        this.statsUpdateLockTimeouts.set(toolKey, timeout);
+        return true;
+      }
+      /**
+       * 释放统计更新锁
+       * @param toolKey 工具键
+       * @private
+       */
+      releaseStatsUpdateLock(toolKey) {
+        this.statsUpdateLocks.delete(toolKey);
+        const timeout = this.statsUpdateLockTimeouts.get(toolKey);
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        this.statsUpdateLockTimeouts.delete(toolKey);
+        console.log("\u5DF2\u91CA\u653E\u5DE5\u5177\u7684\u7EDF\u8BA1\u66F4\u65B0\u9501", { toolKey });
+      }
+      /**
+       * 带并发控制的工具统计更新（CustomMCP 工具）
+       * @param toolName 工具名称
+       * @param incrementUsageCount 是否增加使用计数
+       */
+      async updateToolUsageStatsWithLock(toolName, incrementUsageCount = true) {
+        const toolKey = `custommcp_${toolName}`;
+        if (!await this.acquireStatsUpdateLock(toolKey)) {
+          return;
+        }
+        try {
+          await this.updateToolUsageStats(toolName, incrementUsageCount);
+          console.log("\u5DE5\u5177\u7EDF\u8BA1\u66F4\u65B0\u5B8C\u6210", { toolName });
+        } catch (error) {
+          console.error("\u5DE5\u5177\u7EDF\u8BA1\u66F4\u65B0\u5931\u8D25", { toolName, error });
+          throw error;
+        } finally {
+          this.releaseStatsUpdateLock(toolKey);
+        }
+      }
+      /**
+       * 带并发控制的工具统计更新（MCP 服务工具）
+       * @param serviceName 服务名称
+       * @param toolName 工具名称
+       * @param callTime 调用时间
+       * @param incrementUsageCount 是否增加使用计数
+       */
+      async updateMCPServerToolStatsWithLock(serviceName, toolName, callTime, incrementUsageCount = true) {
+        const toolKey = `mcpserver_${serviceName}_${toolName}`;
+        if (!await this.acquireStatsUpdateLock(toolKey)) {
+          return;
+        }
+        try {
+          await this.updateMCPServerToolStats(
+            serviceName,
+            toolName,
+            callTime,
+            incrementUsageCount
+          );
+          console.log("MCP \u670D\u52A1\u5DE5\u5177\u7EDF\u8BA1\u66F4\u65B0\u5B8C\u6210", { serviceName, toolName });
+        } catch (error) {
+          console.error("MCP \u670D\u52A1\u5DE5\u5177\u7EDF\u8BA1\u66F4\u65B0\u5931\u8D25", {
+            serviceName,
+            toolName,
+            error
+          });
+          throw error;
+        } finally {
+          this.releaseStatsUpdateLock(toolKey);
+        }
+      }
+      /**
+       * 清理所有统计更新锁（用于异常恢复）
+       */
+      clearAllStatsUpdateLocks() {
+        const lockCount = this.statsUpdateLocks.size;
+        this.statsUpdateLocks.clear();
+        for (const timeout of this.statsUpdateLockTimeouts.values()) {
+          clearTimeout(timeout);
+        }
+        this.statsUpdateLockTimeouts.clear();
+        if (lockCount > 0) {
+          console.log("\u5DF2\u6E05\u7406\u7EDF\u8BA1\u66F4\u65B0\u9501", { count: lockCount });
+        }
+      }
+      /**
+       * 获取统计更新锁状态（用于调试和监控）
+       */
+      getStatsUpdateLocks() {
+        return Array.from(this.statsUpdateLocks.keys());
+      }
+      /**
+       * 获取工具调用日志配置
+       */
+      getToolCallLogConfig() {
+        const config = this.getConfig();
+        return config.toolCallLog || {};
+      }
+      /**
+       * 更新工具调用日志配置
+       */
+      updateToolCallLogConfig(toolCallLogConfig) {
+        const config = this.getMutableConfig();
+        if (!config.toolCallLog) {
+          config.toolCallLog = {};
+        }
+        Object.assign(config.toolCallLog, toolCallLogConfig);
+        this.saveConfig(config);
+      }
+      /**
+       * 获取配置目录路径（与配置文件同级目录）
+       */
+      getConfigDir() {
+        return process.env.XIAOZHI_CONFIG_DIR || process.cwd();
+      }
+      /**
+       * 获取 TTS 配置
+       */
+      getTTSConfig() {
+        const config = this.getConfig();
+        return config.tts || {};
+      }
+      /**
+       * 获取 ASR 配置
+       */
+      getASRConfig() {
+        const config = this.getConfig();
+        return config.asr || {};
+      }
+      /**
+       * 获取 LLM 配置
+       */
+      getLLMConfig() {
+        const config = this.getConfig();
+        return config.llm || null;
+      }
+      /**
+       * 检查 LLM 配置是否有效
+       */
+      isLLMConfigValid() {
+        const llmConfig = this.getLLMConfig();
+        return llmConfig !== null && typeof llmConfig.model === "string" && llmConfig.model.trim() !== "" && typeof llmConfig.apiKey === "string" && llmConfig.apiKey.trim() !== "" && typeof llmConfig.baseURL === "string" && llmConfig.baseURL.trim() !== "";
+      }
+      /**
+       * 更新 TTS 配置
+       */
+      updateTTSConfig(ttsConfig) {
+        const config = this.getMutableConfig();
+        if (!config.tts) {
+          config.tts = {};
+        }
+        Object.assign(config.tts, ttsConfig);
+        this.saveConfig(config);
+        this.emitEvent("config:updated", {
+          type: "tts",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+    };
+    configManager = ConfigManager.getInstance();
+  }
+});
+
+// ../mcp-core/types.ts
+var init_types = __esm({
+  "../mcp-core/types.ts"() {
+    "use strict";
+  }
+});
+
+// ../mcp-core/transport-factory.ts
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { EventSource } from "eventsource";
+var globalThisAny;
+var init_transport_factory = __esm({
+  "../mcp-core/transport-factory.ts"() {
+    "use strict";
+    init_types();
+    globalThisAny = typeof globalThis !== "undefined" ? globalThis : global;
+    if (typeof globalThisAny !== "undefined" && !globalThisAny.EventSource) {
+      globalThisAny.EventSource = EventSource;
+    }
+  }
+});
+
+// ../mcp-core/utils/type-normalizer.ts
+var TypeFieldNormalizer;
+var init_type_normalizer = __esm({
+  "../mcp-core/utils/type-normalizer.ts"() {
+    "use strict";
+    ((TypeFieldNormalizer2) => {
+      function normalizeTypeField2(config) {
+        if (!config || typeof config !== "object") {
+          return config;
+        }
+        if (!("type" in config)) {
+          return config;
+        }
+        const originalType = config.type;
+        if (originalType === "stdio" || originalType === "sse" || originalType === "http") {
+          return config;
+        }
+        const normalizedType = normalizeTypeValue(originalType);
+        if (normalizedType === "stdio" || normalizedType === "sse" || normalizedType === "http") {
+          return {
+            ...config,
+            type: normalizedType
+          };
+        }
+        return config;
+      }
+      TypeFieldNormalizer2.normalizeTypeField = normalizeTypeField2;
+      __name(normalizeTypeField2, "normalizeTypeField");
+      function normalizeTypeValue(type) {
+        if (type === "http" || type === "streamable-http" || type === "streamable_http" || type === "streamableHttp") {
+          return "http";
+        }
+        if (type === "sse" || type === "s_se" || type === "s-se") {
+          return "sse";
+        }
+        if (type === "stdio") {
+          return "stdio";
+        }
+        return convertToStandardFormat(type);
+      }
+      TypeFieldNormalizer2.normalizeTypeValue = normalizeTypeValue;
+      __name(normalizeTypeValue, "normalizeTypeValue");
+      function convertToStandardFormat(str) {
+        const lowered = str.toLowerCase();
+        if (lowered.includes("http") || lowered.includes("streamable")) {
+          return "http";
+        }
+        if (lowered.includes("sse")) {
+          return "sse";
+        }
+        if (lowered.includes("stdio")) {
+          return "stdio";
+        }
+        return str;
+      }
+      __name(convertToStandardFormat, "convertToStandardFormat");
+    })(TypeFieldNormalizer || (TypeFieldNormalizer = {}));
+  }
+});
+
+// ../mcp-core/utils/validators.ts
+var init_validators = __esm({
+  "../mcp-core/utils/validators.ts"() {
+    "use strict";
+    init_types();
+    init_type_normalizer();
+  }
+});
+
+// ../mcp-core/utils/index.ts
+var init_utils = __esm({
+  "../mcp-core/utils/index.ts"() {
+    "use strict";
+    init_type_normalizer();
+    init_validators();
+  }
+});
+
+// ../mcp-core/connection.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+var init_connection = __esm({
+  "../mcp-core/connection.ts"() {
+    "use strict";
+    init_transport_factory();
+    init_types();
+    init_utils();
+  }
+});
+
+// ../mcp-core/manager.ts
+import { EventEmitter } from "events";
+var init_manager2 = __esm({
+  "../mcp-core/manager.ts"() {
+    "use strict";
+    init_connection();
+    init_types();
+  }
+});
+
+// ../mcp-core/index.ts
+var init_mcp_core = __esm({
+  "../mcp-core/index.ts"() {
+    "use strict";
+    init_types();
+    init_types();
+    init_connection();
+    init_manager2();
+    init_transport_factory();
+    init_utils();
+    init_types();
+  }
+});
+
+// ../config/adapter.ts
+import { dirname as dirname2, isAbsolute, resolve as resolve2 } from "path";
+var init_adapter = __esm({
+  "../config/adapter.ts"() {
+    "use strict";
+    init_mcp_core();
+    init_resolver();
+  }
+});
+
+// ../config/initializer.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync3,
+  mkdirSync,
+  readdirSync,
+  statSync
+} from "fs";
+import path2 from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2, ConfigInitializer;
+var init_initializer = __esm({
+  "../config/initializer.ts"() {
+    "use strict";
+    __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+    ConfigInitializer = class _ConfigInitializer {
+      static {
+        __name(this, "ConfigInitializer");
+      }
+      /**
+       * 初始化默认配置
+       *
+       * 复制整个默认模板目录到用户家目录的 .xiaozhi-client
+       * 这包括 mcpServers/ 目录和其他必要文件
+       *
+       * @returns 创建的项目目录路径
+       * @throws 如果无法获取用户家目录或默认配置模板不存在
+       */
+      static async initializeDefaultConfig() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE;
+        if (!homeDir) {
+          throw new Error("\u65E0\u6CD5\u83B7\u53D6\u7528\u6237\u5BB6\u76EE\u5F55");
+        }
+        const xiaozhiClientDir = path2.join(homeDir, ".xiaozhi-client");
+        if (existsSync3(xiaozhiClientDir)) {
+          return xiaozhiClientDir;
+        }
+        mkdirSync(xiaozhiClientDir, { recursive: true });
+        const defaultTemplateDir = _ConfigInitializer.getDefaultTemplateDir();
+        if (!defaultTemplateDir) {
+          throw new Error("\u9ED8\u8BA4\u914D\u7F6E\u6A21\u677F\u4E0D\u5B58\u5728\uFF0C\u8BF7\u68C0\u67E5\u9879\u76EE\u6A21\u677F\u6587\u4EF6\u662F\u5426\u5B58\u5728");
+        }
+        _ConfigInitializer.copyDirectoryRecursive(
+          defaultTemplateDir,
+          xiaozhiClientDir,
+          ["template.json", ".git", "node_modules"]
+        );
+        return xiaozhiClientDir;
+      }
+      /**
+       * 递归复制目录
+       *
+       * @param srcDir 源目录
+       * @param destDir 目标目录
+       * @param exclude 要排除的文件/目录列表
+       */
+      static copyDirectoryRecursive(srcDir, destDir, exclude = []) {
+        const items = readdirSync(srcDir);
+        for (const item of items) {
+          if (exclude.includes(item)) {
+            continue;
+          }
+          const srcPath = path2.join(srcDir, item);
+          const destPath = path2.join(destDir, item);
+          const stat = statSync(srcPath);
+          if (stat.isDirectory()) {
+            mkdirSync(destPath, { recursive: true });
+            _ConfigInitializer.copyDirectoryRecursive(srcPath, destPath, exclude);
+          } else {
+            copyFileSync2(srcPath, destPath);
+          }
+        }
+      }
+      /**
+       * 获取默认模板目录路径
+       *
+       * 在多个可能的路径中查找默认模板目录
+       *
+       * @returns 找到的默认模板目录路径，如果都不存在则返回 null
+       */
+      static getDefaultTemplateDir() {
+        const possiblePaths = [
+          // 迁移后：src/config/ 或 dist/config/ → 项目根 templates/default/
+          resolve3(__dirname2, "..", "..", "templates", "default"),
+          // 从 CWD 查找（兼容各种启动场景）
+          resolve3(process.cwd(), "templates", "default")
+        ];
+        for (const p of possiblePaths) {
+          if (existsSync3(p)) {
+            return p;
+          }
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// ../config/index.ts
+var init_config = __esm({
+  "../config/index.ts"() {
+    "use strict";
+    init_manager();
+    init_adapter();
+    init_resolver();
+    init_initializer();
+  }
+});
+
+// Constants.ts
 var SERVICE_CONSTANTS, CONFIG_CONSTANTS, PATH_CONSTANTS, ERROR_CODES, TIMEOUT_CONSTANTS, RETRY_CONSTANTS;
 var init_Constants = __esm({
-  "src/Constants.ts"() {
+  "Constants.ts"() {
     "use strict";
     SERVICE_CONSTANTS = {
       /** 服务名称 */
@@ -97,10 +2009,10 @@ var init_Constants = __esm({
   }
 });
 
-// src/errors/index.ts
+// errors/index.ts
 var CLIError, ConfigError, ServiceError, ValidationError, FileError, ProcessError;
 var init_errors = __esm({
-  "src/errors/index.ts"() {
+  "errors/index.ts"() {
     "use strict";
     init_Constants();
     CLIError = class _CLIError extends Error {
@@ -236,13 +2148,13 @@ var init_errors = __esm({
   }
 });
 
-// src/utils/FileUtils.ts
-import fs from "fs";
+// utils/FileUtils.ts
+import fs2 from "fs";
 import { tmpdir } from "os";
-import path from "path";
+import path4 from "path";
 var FileUtils;
 var init_FileUtils = __esm({
-  "src/utils/FileUtils.ts"() {
+  "utils/FileUtils.ts"() {
     "use strict";
     init_errors();
     FileUtils = class _FileUtils {
@@ -254,7 +2166,7 @@ var init_FileUtils = __esm({
        */
       static exists(filePath) {
         try {
-          return fs.existsSync(filePath);
+          return fs2.existsSync(filePath);
         } catch {
           return false;
         }
@@ -264,8 +2176,8 @@ var init_FileUtils = __esm({
        */
       static ensureDir(dirPath) {
         try {
-          if (!fs.existsSync(dirPath)) {
-            fs.mkdirSync(dirPath, { recursive: true });
+          if (!fs2.existsSync(dirPath)) {
+            fs2.mkdirSync(dirPath, { recursive: true });
           }
         } catch (error) {
           throw new FileError("\u65E0\u6CD5\u521B\u5EFA\u76EE\u5F55", dirPath);
@@ -279,7 +2191,7 @@ var init_FileUtils = __esm({
           if (!_FileUtils.exists(filePath)) {
             throw FileError.notFound(filePath);
           }
-          return fs.readFileSync(filePath, encoding);
+          return fs2.readFileSync(filePath, encoding);
         } catch (error) {
           if (error instanceof FileError) {
             throw error;
@@ -295,9 +2207,9 @@ var init_FileUtils = __esm({
           if (!options?.overwrite && _FileUtils.exists(filePath)) {
             throw FileError.alreadyExists(filePath);
           }
-          const dir = path.dirname(filePath);
+          const dir = path4.dirname(filePath);
           _FileUtils.ensureDir(dir);
-          fs.writeFileSync(filePath, content, "utf8");
+          fs2.writeFileSync(filePath, content, "utf8");
         } catch (error) {
           if (error instanceof FileError) {
             throw error;
@@ -316,9 +2228,9 @@ var init_FileUtils = __esm({
           if (!options?.overwrite && _FileUtils.exists(destPath)) {
             throw FileError.alreadyExists(destPath);
           }
-          const destDir = path.dirname(destPath);
+          const destDir = path4.dirname(destPath);
           _FileUtils.ensureDir(destDir);
-          fs.copyFileSync(srcPath, destPath);
+          fs2.copyFileSync(srcPath, destPath);
         } catch (error) {
           if (error instanceof FileError) {
             throw error;
@@ -332,7 +2244,7 @@ var init_FileUtils = __esm({
       static deleteFile(filePath) {
         try {
           if (_FileUtils.exists(filePath)) {
-            fs.unlinkSync(filePath);
+            fs2.unlinkSync(filePath);
           }
         } catch (error) {
           throw new FileError("\u65E0\u6CD5\u5220\u9664\u6587\u4EF6", filePath);
@@ -347,14 +2259,14 @@ var init_FileUtils = __esm({
             throw FileError.notFound(srcDir);
           }
           _FileUtils.ensureDir(destDir);
-          const items = fs.readdirSync(srcDir);
+          const items = fs2.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);
+            const srcPath = path4.join(srcDir, item);
+            const destPath = path4.join(destDir, item);
+            const stat = fs2.statSync(srcPath);
             if (stat.isDirectory()) {
               if (options.recursive !== false) {
                 _FileUtils.copyDirectory(srcPath, destPath, options);
@@ -378,7 +2290,7 @@ var init_FileUtils = __esm({
       static deleteDirectory(dirPath, options = {}) {
         try {
           if (_FileUtils.exists(dirPath)) {
-            fs.rmSync(dirPath, {
+            fs2.rmSync(dirPath, {
               recursive: options.recursive ?? true,
               force: true
             });
@@ -395,7 +2307,7 @@ var init_FileUtils = __esm({
           if (!_FileUtils.exists(filePath)) {
             throw FileError.notFound(filePath);
           }
-          const stats = fs.statSync(filePath);
+          const stats = fs2.statSync(filePath);
           return {
             size: stats.size,
             isFile: stats.isFile(),
@@ -418,15 +2330,15 @@ var init_FileUtils = __esm({
           if (!_FileUtils.exists(dirPath)) {
             throw FileError.notFound(dirPath);
           }
-          const items = fs.readdirSync(dirPath);
+          const items = fs2.readdirSync(dirPath);
           let result = [];
           for (const item of items) {
             if (!options.includeHidden && item.startsWith(".")) {
               continue;
             }
-            const itemPath = path.join(dirPath, item);
+            const itemPath = path4.join(dirPath, item);
             result.push(itemPath);
-            if (options.recursive && fs.statSync(itemPath).isDirectory()) {
+            if (options.recursive && fs2.statSync(itemPath).isDirectory()) {
               const subItems = _FileUtils.listDirectory(itemPath, options);
               result = result.concat(subItems);
             }
@@ -447,14 +2359,14 @@ var init_FileUtils = __esm({
         const timestamp = Date.now();
         const random = Math.random().toString(36).substring(2);
         const fileName = `${prefix}${timestamp}-${random}${suffix}`;
-        return path.join(tempDir, fileName);
+        return path4.join(tempDir, fileName);
       }
       /**
        * 检查文件权限
        */
-      static checkPermissions(filePath, mode = fs.constants.R_OK | fs.constants.W_OK) {
+      static checkPermissions(filePath, mode = fs2.constants.R_OK | fs2.constants.W_OK) {
         try {
-          fs.accessSync(filePath, mode);
+          fs2.accessSync(filePath, mode);
           return true;
         } catch {
           return false;
@@ -464,37 +2376,37 @@ var init_FileUtils = __esm({
        * 获取文件扩展名
        */
       static getExtension(filePath) {
-        return path.extname(filePath).toLowerCase();
+        return path4.extname(filePath).toLowerCase();
       }
       /**
        * 获取文件名（不含扩展名）
        */
       static getBaseName(filePath) {
-        return path.basename(filePath, path.extname(filePath));
+        return path4.basename(filePath, path4.extname(filePath));
       }
       /**
        * 规范化路径
        */
       static normalizePath(filePath) {
-        return path.normalize(filePath);
+        return path4.normalize(filePath);
       }
       /**
        * 解析相对路径为绝对路径
        */
       static resolvePath(filePath, basePath) {
         if (basePath) {
-          return path.resolve(basePath, filePath);
+          return path4.resolve(basePath, filePath);
         }
-        return path.resolve(filePath);
+        return path4.resolve(filePath);
       }
     };
   }
 });
 
-// src/utils/FormatUtils.ts
+// utils/FormatUtils.ts
 var FormatUtils;
 var init_FormatUtils = __esm({
-  "src/utils/FormatUtils.ts"() {
+  "utils/FormatUtils.ts"() {
     "use strict";
     FormatUtils = class {
       static {
@@ -561,9 +2473,9 @@ var init_FormatUtils = __esm({
       /**
        * 格式化 URL
        */
-      static formatUrl(protocol, host, port, path6) {
+      static formatUrl(protocol, host, port, path9) {
         const url = `${protocol}://${host}:${port}`;
-        return path6 ? `${url}${path6}` : url;
+        return path9 ? `${url}${path9}` : url;
       }
       /**
        * 格式化配置键值对
@@ -655,14 +2567,14 @@ ${error.stack}`;
   }
 });
 
-// src/utils/PathUtils.ts
+// utils/PathUtils.ts
 import { realpathSync } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import path2 from "path";
-import { fileURLToPath } from "url";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 var PathUtils;
 var init_PathUtils = __esm({
-  "src/utils/PathUtils.ts"() {
+  "utils/PathUtils.ts"() {
     "use strict";
     init_Constants();
     init_FileUtils();
@@ -675,14 +2587,14 @@ var init_PathUtils = __esm({
        */
       static getPidFile() {
         const configDir = process.env[CONFIG_CONSTANTS.DIR_ENV_VAR] || process.cwd();
-        return path2.join(configDir, `.${SERVICE_CONSTANTS.NAME}.pid`);
+        return path5.join(configDir, `.${SERVICE_CONSTANTS.NAME}.pid`);
       }
       /**
        * 获取日志文件路径
        */
       static getLogFile(projectDir) {
         const baseDir = projectDir || process.cwd();
-        return path2.join(baseDir, SERVICE_CONSTANTS.LOG_FILE);
+        return path5.join(baseDir, SERVICE_CONSTANTS.LOG_FILE);
       }
       /**
        * 获取配置目录路径
@@ -695,21 +2607,21 @@ var init_PathUtils = __esm({
        */
       static getWorkDir() {
         const configDir = _PathUtils.getConfigDir();
-        return path2.join(configDir, PATH_CONSTANTS.WORK_DIR);
+        return path5.join(configDir, PATH_CONSTANTS.WORK_DIR);
       }
       /**
        * 获取模板目录路径
        */
       static getTemplatesDir() {
-        const __filename = fileURLToPath(import.meta.url);
-        const scriptDir = path2.dirname(__filename);
+        const __filename = fileURLToPath4(import.meta.url);
+        const scriptDir = path5.dirname(__filename);
         return [
           // 构建后的环境：dist/cli.js -> dist/templates
-          path2.join(scriptDir, PATH_CONSTANTS.TEMPLATES_DIR),
+          path5.join(scriptDir, PATH_CONSTANTS.TEMPLATES_DIR),
           // 构建环境：dist/cli/index.js -> dist/backend/templates
-          path2.join(scriptDir, "..", "backend", PATH_CONSTANTS.TEMPLATES_DIR),
+          path5.join(scriptDir, "..", "backend", PATH_CONSTANTS.TEMPLATES_DIR),
           // npm 全局安装
-          path2.join(
+          path5.join(
             scriptDir,
             "..",
             "..",
@@ -739,36 +2651,36 @@ var init_PathUtils = __esm({
         if (!templatesDir) {
           return null;
         }
-        const templatePath = path2.join(templatesDir, templateName);
+        const templatePath = path5.join(templatesDir, templateName);
         return FileUtils.exists(templatePath) ? templatePath : null;
       }
       /**
        * 获取脚本目录路径
        */
       static getScriptDir() {
-        const __filename = fileURLToPath(import.meta.url);
-        return path2.dirname(__filename);
+        const __filename = fileURLToPath4(import.meta.url);
+        return path5.dirname(__filename);
       }
       /**
        * 获取项目根目录路径
        */
       static getProjectRoot() {
         const scriptDir = _PathUtils.getScriptDir();
-        return path2.join(scriptDir, "..", "..", "..");
+        return path5.join(scriptDir, "..", "..", "..");
       }
       /**
        * 获取构建输出目录路径
        */
       static getDistDir() {
         const projectRoot = _PathUtils.getProjectRoot();
-        return path2.join(projectRoot, "dist");
+        return path5.join(projectRoot, "dist");
       }
       /**
        * 获取相对于项目根目录的路径
        */
       static getRelativePath(filePath) {
         const projectRoot = _PathUtils.getProjectRoot();
-        return path2.relative(projectRoot, filePath);
+        return path5.relative(projectRoot, filePath);
       }
       /**
        * 解析配置文件路径
@@ -776,71 +2688,82 @@ var init_PathUtils = __esm({
       static resolveConfigPath(format) {
         const configDir = _PathUtils.getConfigDir();
         if (format) {
-          return path2.join(configDir, `xiaozhi.config.${format}`);
+          return path5.join(configDir, `xiaozhi.config.${format}`);
         }
         for (const fileName of CONFIG_CONSTANTS.FILE_NAMES) {
-          const filePath = path2.join(configDir, fileName);
+          const filePath = path5.join(configDir, fileName);
           if (FileUtils.exists(filePath)) {
             return filePath;
           }
         }
-        return path2.join(configDir, CONFIG_CONSTANTS.FILE_NAMES[2]);
+        return path5.join(configDir, CONFIG_CONSTANTS.FILE_NAMES[2]);
       }
       /**
        * 获取默认配置文件路径
        */
       static getDefaultConfigPath() {
         const projectRoot = _PathUtils.getProjectRoot();
-        return path2.join(projectRoot, CONFIG_CONSTANTS.DEFAULT_FILE);
+        return path5.join(projectRoot, CONFIG_CONSTANTS.DEFAULT_FILE);
       }
       /**
        * 验证路径安全性（防止路径遍历攻击）
+       * 通过路径段判断是否存在严格等于 ".." 的段，避免误杀包含 ".." 子串的合法文件名
+       * 同时支持 Unix (/) 和 Windows (\) 分隔符
        */
       static validatePath(inputPath) {
-        const normalizedPath = path2.normalize(inputPath);
-        return !normalizedPath.includes("..");
+        const normalizedPath = path5.normalize(inputPath);
+        const segments = normalizedPath.split(/[/\\]/);
+        return !segments.includes("..");
       }
       /**
        * 确保路径在指定目录内
+       * 使用 path.relative 判断，避免前缀匹配被绕过（如 /safe/base2 匹配 /safe/base）
        */
       static ensurePathWithin(inputPath, baseDir) {
-        const resolvedPath = path2.resolve(baseDir, inputPath);
-        const resolvedBase = path2.resolve(baseDir);
-        if (!resolvedPath.startsWith(resolvedBase)) {
+        const resolvedPath = path5.resolve(baseDir, inputPath);
+        const resolvedBase = path5.resolve(baseDir);
+        const relativePath = path5.relative(resolvedBase, resolvedPath);
+        if (relativePath.startsWith("..") || path5.isAbsolute(relativePath)) {
           throw new Error(`\u8DEF\u5F84 ${inputPath} \u8D85\u51FA\u4E86\u5141\u8BB8\u7684\u8303\u56F4`);
         }
         return resolvedPath;
       }
       /**
        * 获取可执行文件路径
+       * 对于 CLI 自身复用，直接返回当前脚本路径；其他名称从项目根目录的 dist 中查找
        */
       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;
+        if (name === "cli") {
+          const cliPath = process.argv[1];
+          if (cliPath) {
+            try {
+              return realpathSync(cliPath);
+            } catch {
+              return cliPath;
+            }
+          }
+          throw new Error("\u65E0\u6CD5\u786E\u5B9A CLI \u811A\u672C\u8DEF\u5F84");
         }
-        const distDir = path2.dirname(realCliPath);
-        return path2.join(distDir, `${name}.js`);
+        const projectRoot = _PathUtils.getProjectRoot();
+        return path5.join(projectRoot, "dist", `${name}.js`);
       }
       /**
        * 获取 Web 服务器启动器路径
+       * 返回项目根目录 dist 下的 WebServerLauncher.js（向后兼容包装脚本）
        */
       static getWebServerLauncherPath() {
-        return _PathUtils.getExecutablePath("WebServerLauncher");
+        const projectRoot = _PathUtils.getProjectRoot();
+        return path5.join(projectRoot, "dist", "WebServerLauncher.js");
       }
       /**
        * 创建安全的文件路径
+       * 通过路径段判断是否存在严格等于 ".." 的段，避免误杀合法文件名
        */
       static createSafePath(...segments) {
-        const joinedPath = path2.join(...segments);
-        const normalizedPath = path2.normalize(joinedPath);
-        if (normalizedPath.includes("..") || normalizedPath.includes("~")) {
+        const joinedPath = path5.join(...segments);
+        const normalizedPath = path5.normalize(joinedPath);
+        const hasTraversal = normalizedPath.split(/[/\\]/).includes("..");
+        if (hasTraversal || normalizedPath.includes("~")) {
           throw new Error(`\u4E0D\u5B89\u5168\u7684\u8DEF\u5F84: ${normalizedPath}`);
         }
         return normalizedPath;
@@ -861,11 +2784,11 @@ var init_PathUtils = __esm({
   }
 });
 
-// src/utils/PlatformUtils.ts
+// utils/PlatformUtils.ts
 import { execSync } from "child_process";
 var PlatformUtils;
 var init_PlatformUtils = __esm({
-  "src/utils/PlatformUtils.ts"() {
+  "utils/PlatformUtils.ts"() {
     "use strict";
     init_Constants();
     init_errors();
@@ -945,7 +2868,7 @@ var init_PlatformUtils = __esm({
           let attempts = 0;
           const maxAttempts = 30;
           while (attempts < maxAttempts) {
-            await new Promise((resolve) => setTimeout(resolve, 100));
+            await new Promise((resolve4) => setTimeout(resolve4, 100));
             try {
               process.kill(pid, 0);
               attempts++;
@@ -956,7 +2879,7 @@ var init_PlatformUtils = __esm({
           try {
             process.kill(pid, 0);
             process.kill(pid, "SIGKILL");
-            await new Promise((resolve) => setTimeout(resolve, 500));
+            await new Promise((resolve4) => setTimeout(resolve4, 500));
           } catch {
           }
         } catch (error) {
@@ -1037,10 +2960,10 @@ var init_PlatformUtils = __esm({
   }
 });
 
-// src/utils/Validation.ts
+// utils/Validation.ts
 var Validation;
 var init_Validation = __esm({
-  "src/utils/Validation.ts"() {
+  "utils/Validation.ts"() {
     "use strict";
     init_errors();
     Validation = class _Validation {
@@ -1260,14 +3183,14 @@ var init_Validation = __esm({
   }
 });
 
-// src/services/ProcessManager.ts
+// services/ProcessManager.ts
 var ProcessManager_exports = {};
 __export(ProcessManager_exports, {
   ProcessManagerImpl: () => ProcessManagerImpl
 });
 var ProcessManagerImpl;
 var init_ProcessManager = __esm({
-  "src/services/ProcessManager.ts"() {
+  "services/ProcessManager.ts"() {
     "use strict";
     init_errors();
     init_FileUtils();
@@ -1438,17 +3361,17 @@ var init_ProcessManager = __esm({
   }
 });
 
-// src/services/DaemonManager.ts
+// services/DaemonManager.ts
 var DaemonManager_exports = {};
 __export(DaemonManager_exports, {
   DaemonManagerImpl: () => DaemonManagerImpl
 });
 import { spawn } from "child_process";
-import fs2 from "fs";
+import fs3 from "fs";
 import consola from "consola";
 var DaemonManagerImpl;
 var init_DaemonManager = __esm({
-  "src/services/DaemonManager.ts"() {
+  "services/DaemonManager.ts"() {
     "use strict";
     init_Constants();
     init_errors();
@@ -1512,7 +3435,7 @@ var init_DaemonManager = __esm({
           if (status.running) {
             await this.stopDaemon();
             await new Promise(
-              (resolve) => setTimeout(resolve, RETRY_CONSTANTS.DEFAULT_INTERVAL)
+              (resolve4) => setTimeout(resolve4, RETRY_CONSTANTS.DEFAULT_INTERVAL)
             );
           }
           await this.startDaemon(serverFactory, options);
@@ -1534,7 +3457,7 @@ var init_DaemonManager = __esm({
       async attachToLogs(logFileName = "xiaozhi.log") {
         try {
           const logFilePath = PathUtils.getLogFile();
-          if (!fs2.existsSync(logFilePath)) {
+          if (!fs3.existsSync(logFilePath)) {
             throw new ServiceError("\u65E5\u5FD7\u6587\u4EF6\u4E0D\u5B58\u5728");
           }
           const { command, args } = PlatformUtils.getTailCommand(logFilePath);
@@ -1588,12 +3511,12 @@ var init_DaemonManager = __esm({
       async setupLogging(child, logFileName) {
         try {
           const logFilePath = PathUtils.getLogFile();
-          const path6 = await import("path");
-          const logDir = path6.dirname(logFilePath);
-          if (!fs2.existsSync(logDir)) {
-            fs2.mkdirSync(logDir, { recursive: true });
+          const path9 = await import("path");
+          const logDir = path9.dirname(logFilePath);
+          if (!fs3.existsSync(logDir)) {
+            fs3.mkdirSync(logDir, { recursive: true });
           }
-          const logStream = fs2.createWriteStream(logFilePath, { flags: "a" });
+          const logStream = fs3.createWriteStream(logFilePath, { flags: "a" });
           child.stdout?.pipe(logStream);
           child.stderr?.pipe(logStream);
           const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -1668,25 +3591,25 @@ var init_DaemonManager = __esm({
   }
 });
 
-// src/services/ServiceManager.ts
+// services/ServiceManager.ts
 var ServiceManager_exports = {};
 __export(ServiceManager_exports, {
   ServiceManagerImpl: () => ServiceManagerImpl
 });
-import { ConfigInitializer } from "@xiaozhi-client/config";
 import consola2 from "consola";
 var ServiceManagerImpl;
 var init_ServiceManager = __esm({
-  "src/services/ServiceManager.ts"() {
+  "services/ServiceManager.ts"() {
     "use strict";
+    init_config();
     init_Constants();
     init_errors();
     init_PathUtils();
     init_Validation();
     ServiceManagerImpl = class {
-      constructor(processManager, configManager3) {
+      constructor(processManager, configManager2) {
         this.processManager = processManager;
-        this.configManager = configManager3;
+        this.configManager = configManager2;
       }
       static {
         __name(this, "ServiceManagerImpl");
@@ -1707,7 +3630,7 @@ var init_ServiceManager = __esm({
               await this.processManager.gracefulKillProcess(status.pid || 0);
               this.processManager.cleanupPidFile();
               await new Promise(
-                (resolve) => setTimeout(resolve, RETRY_CONSTANTS.DEFAULT_INTERVAL)
+                (resolve4) => setTimeout(resolve4, RETRY_CONSTANTS.DEFAULT_INTERVAL)
               );
               consola2.success("\u73B0\u6709\u670D\u52A1\u5DF2\u505C\u6B62\uFF0C\u6B63\u5728\u542F\u52A8\u65B0\u670D\u52A1...");
             } catch (stopError) {
@@ -1769,7 +3692,7 @@ var init_ServiceManager = __esm({
           if (status.running) {
             await this.stop();
             await new Promise(
-              (resolve) => setTimeout(resolve, RETRY_CONSTANTS.DEFAULT_INTERVAL)
+              (resolve4) => setTimeout(resolve4, RETRY_CONSTANTS.DEFAULT_INTERVAL)
             );
           }
           await this.start(options);
@@ -1888,8 +3811,8 @@ var init_ServiceManager = __esm({
       async startWebServerInDaemon() {
         const { spawn: spawn2 } = await import("child_process");
         const webServerPath = PathUtils.getWebServerLauncherPath();
-        const fs4 = await import("fs");
-        if (!fs4.default.existsSync(webServerPath)) {
+        const fs5 = await import("fs");
+        if (!fs5.default.existsSync(webServerPath)) {
           throw new ServiceError(`WebServer \u6587\u4EF6\u4E0D\u5B58\u5728: ${webServerPath}`);
         }
         const args = [webServerPath];
@@ -1930,16 +3853,16 @@ var init_ServiceManager = __esm({
   }
 });
 
-// src/services/TemplateManager.ts
+// services/TemplateManager.ts
 var TemplateManager_exports = {};
 __export(TemplateManager_exports, {
   TemplateManagerImpl: () => TemplateManagerImpl
 });
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path6 from "path";
 var TemplateManagerImpl;
 var init_TemplateManager = __esm({
-  "src/services/TemplateManager.ts"() {
+  "services/TemplateManager.ts"() {
     "use strict";
     init_errors();
     init_FileUtils();
@@ -1960,7 +3883,7 @@ var init_TemplateManager = __esm({
             return [];
           }
           const templates = [];
-          const templateDirs = fs3.readdirSync(templatesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+          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);
@@ -1992,7 +3915,7 @@ var init_TemplateManager = __esm({
           if (!templatePath) {
             return null;
           }
-          const configPath = path3.join(templatePath, "template.json");
+          const configPath = path6.join(templatePath, "template.json");
           let config = {};
           if (FileUtils.exists(configPath)) {
             try {
@@ -2027,27 +3950,32 @@ var init_TemplateManager = __esm({
         await this.createProject({
           templateName,
           targetPath,
-          projectName: path3.basename(targetPath)
+          projectName: path6.basename(targetPath)
         });
       }
       /**
        * 创建项目
+       * 当 templateName 为 undefined 时使用默认模板，为 null 时创建基本项目（仅配置文件）
        */
       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 = path3.resolve(options.targetPath);
+          const targetPath = path6.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);
+          const templateName = options.templateName ?? "default";
+          if (options.templateName === null) {
+            await this.createBasicProjectFiles(targetPath, options);
+          } else {
+            const templateInfo = await this.getTemplateInfo(templateName);
+            if (!templateInfo) {
+              throw new FileError(`\u6A21\u677F\u4E0D\u5B58\u5728: ${templateName}`, "");
+            }
+            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) {
@@ -2070,7 +3998,7 @@ var init_TemplateManager = __esm({
           }
           const requiredFiles = ["package.json"];
           for (const requiredFile of requiredFiles) {
-            const filePath = path3.join(templateInfo.path, requiredFile);
+            const filePath = path6.join(templateInfo.path, requiredFile);
             if (!FileUtils.exists(filePath)) {
               console.warn(`\u6A21\u677F\u7F3A\u5C11\u5FC5\u8981\u6587\u4EF6: ${requiredFile}`);
               return false;
@@ -2097,7 +4025,7 @@ var init_TemplateManager = __esm({
             includeHidden: false
           });
           return files.filter((file) => {
-            const relativePath = path3.relative(templatePath, file);
+            const relativePath = path6.relative(templatePath, file);
             return !relativePath.startsWith(".") && relativePath !== "template.json" && !relativePath.includes("node_modules");
           });
         } catch {
@@ -2111,10 +4039,29 @@ var init_TemplateManager = __esm({
         Validation.validateRequired(options.targetPath, "targetPath");
         Validation.validateRequired(options.projectName, "projectName");
         Validation.validateProjectName(options.projectName);
-        if (options.templateName) {
+        if (options.templateName !== void 0 && options.templateName !== null) {
           Validation.validateTemplateName(options.templateName);
         }
       }
+      /**
+       * 创建基本项目文件（无模板，仅基础配置文件）
+       */
+      async createBasicProjectFiles(targetPath, options) {
+        const configContent = JSON.stringify(
+          {
+            name: options.projectName,
+            version: "1.0.0",
+            description: `${options.projectName} \u9879\u76EE`
+          },
+          null,
+          2
+        );
+        FileUtils.writeFile(
+          path6.join(targetPath, "xiaozhi.config.json"),
+          configContent,
+          { overwrite: true }
+        );
+      }
       /**
        * 复制模板文件
        */
@@ -2168,7 +4115,7 @@ var init_TemplateManager = __esm({
       findFilesByPattern(basePath, pattern) {
         try {
           if (!pattern.includes("*")) {
-            const filePath = path3.join(basePath, pattern);
+            const filePath = path6.join(basePath, pattern);
             return FileUtils.exists(filePath) ? [filePath] : [];
           }
           const files = FileUtils.listDirectory(basePath, { recursive: true });
@@ -2176,7 +4123,7 @@ var init_TemplateManager = __esm({
             pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
           );
           return files.filter((file) => {
-            const relativePath = path3.relative(basePath, file).split(path3.sep).join("/");
+            const relativePath = path6.relative(basePath, file).split(path6.sep).join("/");
             return regex.test(relativePath);
           });
         } catch {
@@ -2210,10 +4157,10 @@ var init_TemplateManager = __esm({
   }
 });
 
-// src/interfaces/Command.ts
+// interfaces/Command.ts
 var BaseCommandHandler;
 var init_Command = __esm({
-  "src/interfaces/Command.ts"() {
+  "interfaces/Command.ts"() {
     "use strict";
     BaseCommandHandler = class {
       constructor(container) {
@@ -2252,7 +4199,7 @@ var init_Command = __esm({
   }
 });
 
-// src/commands/ServiceCommandHandler.ts
+// commands/ServiceCommandHandler.ts
 var ServiceCommandHandler_exports = {};
 __export(ServiceCommandHandler_exports, {
   ServiceCommandHandler: () => ServiceCommandHandler
@@ -2260,7 +4207,7 @@ __export(ServiceCommandHandler_exports, {
 import consola3 from "consola";
 var ServiceCommandHandler;
 var init_ServiceCommandHandler = __esm({
-  "src/commands/ServiceCommandHandler.ts"() {
+  "commands/ServiceCommandHandler.ts"() {
     "use strict";
     init_Command();
     ServiceCommandHandler = class extends BaseCommandHandler {
@@ -2421,17 +4368,17 @@ var init_ServiceCommandHandler = __esm({
   }
 });
 
-// src/commands/ConfigCommandHandler.ts
+// commands/ConfigCommandHandler.ts
 var ConfigCommandHandler_exports = {};
 __export(ConfigCommandHandler_exports, {
   ConfigCommandHandler: () => ConfigCommandHandler
 });
-import path4 from "path";
+import path7 from "path";
 import chalk2 from "chalk";
 import ora from "ora";
 var ConfigCommandHandler;
 var init_ConfigCommandHandler = __esm({
-  "src/commands/ConfigCommandHandler.ts"() {
+  "commands/ConfigCommandHandler.ts"() {
     "use strict";
     init_Command();
     ConfigCommandHandler = class extends BaseCommandHandler {
@@ -2491,17 +4438,17 @@ var init_ConfigCommandHandler = __esm({
           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()) {
+          const configManager2 = this.getService("configManager");
+          if (configManager2.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);
+          configManager2.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 = path4.join(configDir, configFileName);
+          const configPath = path7.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}`));
@@ -2520,8 +4467,8 @@ var init_ConfigCommandHandler = __esm({
        * 确保配置文件存在，如果不存在则显示提示并返回 false
        */
       async ensureConfigExists(spinner) {
-        const configManager3 = this.getService("configManager");
-        if (!configManager3.configExists()) {
+        const configManager2 = this.getService("configManager");
+        if (!configManager2.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')
@@ -2539,12 +4486,12 @@ var init_ConfigCommandHandler = __esm({
           if (!await this.ensureConfigExists(spinner)) {
             return;
           }
-          const configManager3 = this.getService("configManager");
-          const config = configManager3.getConfig();
+          const configManager2 = this.getService("configManager");
+          const config = configManager2.getConfig();
           switch (key) {
             case "mcpEndpoint": {
               spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
-              const endpoints = configManager3.getMcpEndpoints();
+              const endpoints = configManager2.getMcpEndpoints();
               if (endpoints.length === 0) {
                 console.log(chalk2.yellow("\u672A\u914D\u7F6E\u4EFB\u4F55 MCP \u7AEF\u70B9"));
               } else if (endpoints.length === 1) {
@@ -2577,7 +4524,7 @@ var init_ConfigCommandHandler = __esm({
               break;
             case "connection": {
               spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
-              const connectionConfig = configManager3.getConnectionConfig();
+              const connectionConfig = configManager2.getConnectionConfig();
               console.log(chalk2.green("\u8FDE\u63A5\u914D\u7F6E:"));
               console.log(
                 chalk2.gray(
@@ -2596,7 +4543,7 @@ var init_ConfigCommandHandler = __esm({
               spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
               console.log(
                 chalk2.green(
-                  `\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694: ${configManager3.getHeartbeatInterval()}ms`
+                  `\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694: ${configManager2.getHeartbeatInterval()}ms`
                 )
               );
               break;
@@ -2604,14 +4551,14 @@ var init_ConfigCommandHandler = __esm({
               spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
               console.log(
                 chalk2.green(
-                  `\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4: ${configManager3.getHeartbeatTimeout()}ms`
+                  `\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4: ${configManager2.getHeartbeatTimeout()}ms`
                 )
               );
               break;
             case "reconnectInterval":
               spinner.succeed("\u914D\u7F6E\u4FE1\u606F");
               console.log(
-                chalk2.green(`\u91CD\u8FDE\u95F4\u9694: ${configManager3.getReconnectInterval()}ms`)
+                chalk2.green(`\u91CD\u8FDE\u95F4\u9694: ${configManager2.getReconnectInterval()}ms`)
               );
               break;
             default:
@@ -2638,10 +4585,10 @@ var init_ConfigCommandHandler = __esm({
           if (!await this.ensureConfigExists(spinner)) {
             return;
           }
-          const configManager3 = this.getService("configManager");
+          const configManager2 = this.getService("configManager");
           switch (key) {
             case "mcpEndpoint":
-              configManager3.updateMcpEndpoint(value);
+              configManager2.updateMcpEndpoint(value);
               spinner.succeed(`MCP \u7AEF\u70B9\u5DF2\u8BBE\u7F6E\u4E3A: ${value}`);
               break;
             case "heartbeatInterval": {
@@ -2649,7 +4596,7 @@ var init_ConfigCommandHandler = __esm({
               if (Number.isNaN(interval) || interval <= 0) {
                 throw new Error("\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694\u5FC5\u987B\u662F\u6B63\u6574\u6570");
               }
-              configManager3.updateHeartbeatInterval(interval);
+              configManager2.updateHeartbeatInterval(interval);
               spinner.succeed(`\u5FC3\u8DF3\u68C0\u6D4B\u95F4\u9694\u5DF2\u8BBE\u7F6E\u4E3A: ${interval}ms`);
               break;
             }
@@ -2658,7 +4605,7 @@ var init_ConfigCommandHandler = __esm({
               if (Number.isNaN(timeout) || timeout <= 0) {
                 throw new Error("\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4\u5FC5\u987B\u662F\u6B63\u6574\u6570");
               }
-              configManager3.updateHeartbeatTimeout(timeout);
+              configManager2.updateHeartbeatTimeout(timeout);
               spinner.succeed(`\u5FC3\u8DF3\u8D85\u65F6\u65F6\u95F4\u5DF2\u8BBE\u7F6E\u4E3A: ${timeout}ms`);
               break;
             }
@@ -2667,7 +4614,7 @@ var init_ConfigCommandHandler = __esm({
               if (Number.isNaN(interval) || interval <= 0) {
                 throw new Error("\u91CD\u8FDE\u95F4\u9694\u5FC5\u987B\u662F\u6B63\u6574\u6570");
               }
-              configManager3.updateReconnectInterval(interval);
+              configManager2.updateReconnectInterval(interval);
               spinner.succeed(`\u91CD\u8FDE\u95F4\u9694\u5DF2\u8BBE\u7F6E\u4E3A: ${interval}ms`);
               break;
             }
@@ -2690,17 +4637,17 @@ var init_ConfigCommandHandler = __esm({
   }
 });
 
-// src/commands/ProjectCommandHandler.ts
+// commands/ProjectCommandHandler.ts
 var ProjectCommandHandler_exports = {};
 __export(ProjectCommandHandler_exports, {
   ProjectCommandHandler: () => ProjectCommandHandler
 });
-import path5 from "path";
+import path8 from "path";
 import chalk3 from "chalk";
 import ora2 from "ora";
 var ProjectCommandHandler;
 var init_ProjectCommandHandler = __esm({
-  "src/commands/ProjectCommandHandler.ts"() {
+  "commands/ProjectCommandHandler.ts"() {
     "use strict";
     init_Command();
     ProjectCommandHandler = class extends BaseCommandHandler {
@@ -2734,7 +4681,7 @@ var init_ProjectCommandHandler = __esm({
         try {
           const templateManager = this.getService("templateManager");
           const fileUtils = this.getService("fileUtils");
-          const targetPath = path5.join(process.cwd(), projectName);
+          const targetPath = path8.join(process.cwd(), projectName);
           if (await fileUtils.exists(targetPath)) {
             spinner.fail(`\u76EE\u5F55 "${projectName}" \u5DF2\u5B58\u5728`);
             console.log(
@@ -2845,7 +4792,11 @@ var init_ProjectCommandHandler = __esm({
       showAvailableTemplates(templates) {
         console.log(chalk3.yellow("\u53EF\u7528\u7684\u6A21\u677F:"));
         for (const template of templates) {
-          console.log(chalk3.gray(`  - ${template}`));
+          console.log(
+            chalk3.gray(
+              `  - ${template.name}${template.description ? ` - ${template.description}` : ""}`
+            )
+          );
         }
       }
       /**
@@ -2858,11 +4809,11 @@ var init_ProjectCommandHandler = __esm({
         for (const template of templates) {
           const similarity = formatUtils.calculateSimilarity(
             input.toLowerCase(),
-            template.toLowerCase()
+            template.name.toLowerCase()
           );
           if (similarity > bestSimilarity && similarity > 0.6) {
             bestSimilarity = similarity;
-            bestMatch = template;
+            bestMatch = template.name;
           }
         }
         return bestMatch;
@@ -2876,10 +4827,10 @@ var init_ProjectCommandHandler = __esm({
           input: process.stdin,
           output: process.stdout
         });
-        return new Promise((resolve) => {
+        return new Promise((resolve4) => {
           rl.question(prompt, (answer) => {
             rl.close();
-            resolve(
+            resolve4(
               answer.toLowerCase().trim() === "y" || answer.toLowerCase().trim() === "yes"
             );
           });
@@ -2889,32 +4840,32 @@ var init_ProjectCommandHandler = __esm({
   }
 });
 
-// src/interfaces/CommandTypes.ts
+// 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"() {
+  "interfaces/CommandTypes.ts"() {
     "use strict";
     __name(isLocalMCPServerConfig, "isLocalMCPServerConfig");
   }
 });
 
-// src/commands/McpCommandHandler.ts
+// commands/McpCommandHandler.ts
 var McpCommandHandler_exports = {};
 __export(McpCommandHandler_exports, {
   McpCommandHandler: () => McpCommandHandler
 });
-import { configManager as configManager2 } from "@xiaozhi-client/config";
 import chalk4 from "chalk";
 import Table from "cli-table3";
 import consola4 from "consola";
 import ora3 from "ora";
 var McpCommandHandler;
 var init_McpCommandHandler = __esm({
-  "src/commands/McpCommandHandler.ts"() {
+  "commands/McpCommandHandler.ts"() {
     "use strict";
+    init_config();
     init_Command();
     init_CommandTypes();
     init_ProcessManager();
@@ -2928,7 +4879,7 @@ var init_McpCommandHandler = __esm({
         super(...args);
         this.processManager = new ProcessManagerImpl();
         try {
-          const webPort = configManager2.getWebUIPort() ?? 9999;
+          const webPort = configManager.getWebUIPort() ?? 9999;
           this.baseUrl = `http://localhost:${webPort}`;
         } catch {
           this.baseUrl = "http://localhost:9999";
@@ -3230,9 +5181,9 @@ var init_McpCommandHandler = __esm({
       async handleListInternal(options = {}) {
         const spinner = ora3("\u83B7\u53D6 MCP \u670D\u52A1\u5217\u8868...").start();
         try {
-          const mcpServers = configManager2.getMcpServers();
+          const mcpServers = configManager.getMcpServers();
           const serverNames = Object.keys(mcpServers);
-          const customMCPTools = configManager2.getCustomMCPTools();
+          const customMCPTools = configManager.getCustomMCPTools();
           const hasCustomMCP = customMCPTools.length > 0;
           const totalServices = serverNames.length + (hasCustomMCP ? 1 : 0);
           if (totalServices === 0) {
@@ -3254,7 +5205,7 @@ var init_McpCommandHandler = __esm({
             let maxToolNameWidth = 8;
             const allToolNames = [];
             for (const serverName of serverNames) {
-              const toolsConfig = configManager2.getServerToolsConfig(serverName);
+              const toolsConfig = configManager.getServerToolsConfig(serverName);
               const toolNames = Object.keys(toolsConfig);
               allToolNames.push(...toolNames);
             }
@@ -3300,7 +5251,7 @@ var init_McpCommandHandler = __esm({
               }
             }
             for (const serverName of serverNames) {
-              const toolsConfig = configManager2.getServerToolsConfig(serverName);
+              const toolsConfig = configManager.getServerToolsConfig(serverName);
               const toolNames = Object.keys(toolsConfig);
               if (toolNames.length === 0) {
                 table.push([
@@ -3342,7 +5293,7 @@ var init_McpCommandHandler = __esm({
             }
             for (const serverName of serverNames) {
               const serverConfig = mcpServers[serverName];
-              const toolsConfig = configManager2.getServerToolsConfig(serverName);
+              const toolsConfig = configManager.getServerToolsConfig(serverName);
               const toolCount = Object.keys(toolsConfig).length;
               const enabledCount = Object.values(toolsConfig).filter(
                 (t) => t.enable !== false
@@ -3404,7 +5355,7 @@ var init_McpCommandHandler = __esm({
        * @private
        */
       validateServerExists(serverName, spinner) {
-        const mcpServers = configManager2.getMcpServers();
+        const mcpServers = configManager.getMcpServers();
         if (!mcpServers[serverName]) {
           spinner.fail(`\u670D\u52A1 '${serverName}' \u4E0D\u5B58\u5728`);
           console.log(
@@ -3423,7 +5374,7 @@ var init_McpCommandHandler = __esm({
           if (!this.validateServerExists(serverName, spinner)) {
             return;
           }
-          const toolsConfig = configManager2.getServerToolsConfig(serverName);
+          const toolsConfig = configManager.getServerToolsConfig(serverName);
           const toolNames = Object.keys(toolsConfig);
           if (toolNames.length === 0) {
             spinner.warn(`\u670D\u52A1 '${serverName}' \u6682\u65E0\u5DE5\u5177\u4FE1\u606F`);
@@ -3486,7 +5437,7 @@ var init_McpCommandHandler = __esm({
           if (!this.validateServerExists(serverName, spinner)) {
             return;
           }
-          const toolsConfig = configManager2.getServerToolsConfig(serverName);
+          const toolsConfig = configManager.getServerToolsConfig(serverName);
           if (!toolsConfig[toolName]) {
             spinner.fail(`\u5DE5\u5177 '${toolName}' \u5728\u670D\u52A1 '${serverName}' \u4E2D\u4E0D\u5B58\u5728`);
             console.log(
@@ -3496,7 +5447,7 @@ var init_McpCommandHandler = __esm({
             );
             return;
           }
-          configManager2.setToolEnabled(
+          configManager.setToolEnabled(
             serverName,
             toolName,
             enabled,
@@ -3521,7 +5472,7 @@ var init_McpCommandHandler = __esm({
   }
 });
 
-// src/commands/EndpointCommandHandler.ts
+// commands/EndpointCommandHandler.ts
 var EndpointCommandHandler_exports = {};
 __export(EndpointCommandHandler_exports, {
   EndpointCommandHandler: () => EndpointCommandHandler
@@ -3530,7 +5481,7 @@ import chalk5 from "chalk";
 import ora4 from "ora";
 var EndpointCommandHandler;
 var init_EndpointCommandHandler = __esm({
-  "src/commands/EndpointCommandHandler.ts"() {
+  "commands/EndpointCommandHandler.ts"() {
     "use strict";
     init_Command();
     EndpointCommandHandler = class extends BaseCommandHandler {
@@ -3587,8 +5538,8 @@ var init_EndpointCommandHandler = __esm({
       async handleList() {
         const spinner = ora4("\u8BFB\u53D6\u7AEF\u70B9\u914D\u7F6E...").start();
         try {
-          const configManager3 = this.getService("configManager");
-          const endpoints = configManager3.getMcpEndpoints();
+          const configManager2 = this.getService("configManager");
+          const endpoints = configManager2.getMcpEndpoints();
           spinner.succeed("\u7AEF\u70B9\u5217\u8868");
           if (endpoints.length === 0) {
             console.log(chalk5.yellow("\u672A\u914D\u7F6E\u4EFB\u4F55 MCP \u7AEF\u70B9"));
@@ -3611,10 +5562,10 @@ var init_EndpointCommandHandler = __esm({
       async handleAdd(url) {
         const spinner = ora4("\u6DFB\u52A0\u7AEF\u70B9...").start();
         try {
-          const configManager3 = this.getService("configManager");
-          configManager3.addMcpEndpoint(url);
+          const configManager2 = this.getService("configManager");
+          configManager2.addMcpEndpoint(url);
           spinner.succeed(`\u6210\u529F\u6DFB\u52A0\u7AEF\u70B9: ${url}`);
-          const endpoints = configManager3.getMcpEndpoints();
+          const endpoints = configManager2.getMcpEndpoints();
           console.log(chalk5.gray(`\u5F53\u524D\u5171 ${endpoints.length} \u4E2A\u7AEF\u70B9`));
         } catch (error) {
           spinner.fail(
@@ -3629,10 +5580,10 @@ var init_EndpointCommandHandler = __esm({
       async handleRemove(url) {
         const spinner = ora4("\u79FB\u9664\u7AEF\u70B9...").start();
         try {
-          const configManager3 = this.getService("configManager");
-          configManager3.removeMcpEndpoint(url);
+          const configManager2 = this.getService("configManager");
+          configManager2.removeMcpEndpoint(url);
           spinner.succeed(`\u6210\u529F\u79FB\u9664\u7AEF\u70B9: ${url}`);
-          const endpoints = configManager3.getMcpEndpoints();
+          const endpoints = configManager2.getMcpEndpoints();
           console.log(chalk5.gray(`\u5F53\u524D\u5269\u4F59 ${endpoints.length} \u4E2A\u7AEF\u70B9`));
         } catch (error) {
           spinner.fail(
@@ -3647,12 +5598,12 @@ var init_EndpointCommandHandler = __esm({
       async handleSet(urls) {
         const spinner = ora4("\u8BBE\u7F6E\u7AEF\u70B9...").start();
         try {
-          const configManager3 = this.getService("configManager");
+          const configManager2 = this.getService("configManager");
           if (urls.length === 1) {
-            configManager3.updateMcpEndpoint(urls[0]);
+            configManager2.updateMcpEndpoint(urls[0]);
             spinner.succeed(`\u6210\u529F\u8BBE\u7F6E\u7AEF\u70B9: ${urls[0]}`);
           } else {
-            configManager3.updateMcpEndpoint(urls);
+            configManager2.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}`));
@@ -3669,17 +5620,167 @@ var init_EndpointCommandHandler = __esm({
   }
 });
 
-// src/index.ts
+// index.ts
 import { Command } from "commander";
 
-// src/Container.ts
-import { configManager } from "@xiaozhi-client/config";
-import { VersionUtils } from "@xiaozhi-client/version";
+// Container.ts
+init_config();
+
+// ../utils/version.ts
+import fs from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var VERSION = "2.3.0";
+var APP_NAME = "xiaozhi-client";
+var VersionUtils = class _VersionUtils {
+  static {
+    __name(this, "VersionUtils");
+  }
+  static cachedVersion = null;
+  static cachedVersionInfo = null;
+  /**
+   * 获取版本号
+   *
+   * 优先使用构建时注入的版本号常量
+   * 如果是占位符，则运行时从 package.json 读取
+   */
+  static getVersion() {
+    if (VERSION === "__VERSION__") {
+      return _VersionUtils.getRuntimeVersion();
+    }
+    return VERSION;
+  }
+  /**
+   * 获取完整版本信息
+   */
+  static getVersionInfo() {
+    if (_VersionUtils.cachedVersionInfo) {
+      return _VersionUtils.cachedVersionInfo;
+    }
+    if (VERSION === "__VERSION__") {
+      _VersionUtils.cachedVersionInfo = _VersionUtils.getRuntimeVersionInfo();
+      return _VersionUtils.cachedVersionInfo;
+    }
+    _VersionUtils.cachedVersionInfo = {
+      version: VERSION,
+      name: APP_NAME === "__APP_NAME__" ? void 0 : APP_NAME
+    };
+    return _VersionUtils.cachedVersionInfo;
+  }
+  /**
+   * 比较版本号
+   *
+   * @param version1 第一个版本号
+   * @param version2 第二个版本号
+   * @returns 返回值：1 表示 version1 > version2，-1 表示 version1 < version2，0 表示相等
+   */
+  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;
+  }
+  /**
+   * 检查版本是否有效
+   *
+   * @param version 版本号字符串
+   * @returns 是否为有效的语义化版本号
+   */
+  static isValidVersion(version) {
+    const versionRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+    return versionRegex.test(version);
+  }
+  /**
+   * 查找 package.json 文件路径
+   *
+   * 尝试从多个可能的路径中查找 package.json 文件
+   *
+   * @returns package.json 文件路径，如果找不到则返回 null
+   */
+  static findPackageJsonPath() {
+    const __filename = fileURLToPath3(import.meta.url);
+    const currentDir = path3.dirname(__filename);
+    const possiblePaths = [
+      // 从 src/utils/version.js 到项目根目录的 package.json
+      path3.join(currentDir, "..", "..", "package.json"),
+      // 从 dist/utils/version.js 到项目根目录的 package.json
+      path3.join(currentDir, "..", "..", "..", "package.json"),
+      // 全局安装环境
+      path3.join(currentDir, "..", "..", "..", "..", "package.json")
+    ];
+    for (const packagePath of possiblePaths) {
+      if (fs.existsSync(packagePath)) {
+        return packagePath;
+      }
+    }
+    return null;
+  }
+  /**
+   * 运行时从 package.json 读取版本号
+   */
+  static getRuntimeVersion() {
+    if (_VersionUtils.cachedVersion) {
+      return _VersionUtils.cachedVersion;
+    }
+    try {
+      const packagePath = _VersionUtils.findPackageJsonPath();
+      if (packagePath) {
+        const packageJson = JSON.parse(fs.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";
+    }
+  }
+  /**
+   * 运行时从 package.json 读取完整版本信息
+   */
+  static getRuntimeVersionInfo() {
+    try {
+      const packagePath = _VersionUtils.findPackageJsonPath();
+      if (packagePath) {
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+        return {
+          version: packageJson.version || "unknown",
+          name: packageJson.name,
+          description: packageJson.description,
+          author: packageJson.author
+        };
+      }
+      return { version: "unknown" };
+    } catch (error) {
+      console.warn("\u65E0\u6CD5\u8BFB\u53D6\u7248\u672C\u4FE1\u606F:", error);
+      return { version: "unknown" };
+    }
+  }
+  /**
+   * 清除版本缓存
+   *
+   * 主要用于测试场景
+   */
+  static clearCache() {
+    _VersionUtils.cachedVersion = null;
+    _VersionUtils.cachedVersionInfo = null;
+  }
+};
 
-// src/errors/ErrorHandlers.ts
+// errors/ErrorHandlers.ts
 import chalk from "chalk";
 
-// src/errors/ErrorMessages.ts
+// 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',
@@ -3778,7 +5879,7 @@ var ERROR_MESSAGES = class {
   }
 };
 
-// src/errors/ErrorHandlers.ts
+// errors/ErrorHandlers.ts
 init_errors();
 var ErrorHandler = class _ErrorHandler {
   static {
@@ -3890,7 +5991,7 @@ var ErrorHandler = class _ErrorHandler {
   }
 };
 
-// src/Container.ts
+// Container.ts
 init_FileUtils();
 init_FormatUtils();
 init_PathUtils();
@@ -4006,10 +6107,10 @@ var DIContainer = class _DIContainer {
     container.registerSingleton("serviceManager", () => {
       const ServiceManagerModule = (init_ServiceManager(), __toCommonJS(ServiceManager_exports));
       const processManager = container.get("processManager");
-      const configManager3 = container.get("configManager");
+      const configManager2 = container.get("configManager");
       return new ServiceManagerModule.ServiceManagerImpl(
         processManager,
-        configManager3
+        configManager2
       );
     });
     container.registerSingleton("templateManager", () => {
@@ -4020,7 +6121,7 @@ var DIContainer = class _DIContainer {
   }
 };
 
-// src/commands/CommandHandlerFactory.ts
+// commands/CommandHandlerFactory.ts
 var CommandHandlerFactory = class {
   constructor(container) {
     this.container = container;
@@ -4096,7 +6197,7 @@ var CommandHandlerFactory = class {
   }
 };
 
-// src/commands/index.ts
+// commands/index.ts
 var CommandRegistry = class {
   constructor(container) {
     this.container = container;
@@ -4364,7 +6465,7 @@ var CommandRegistry = class {
   // }
 };
 
-// src/index.ts
+// index.ts
 var program = new Command();
 async function initializeCLI() {
   try {