@xiaozhi-client/cli 1.9.4-beta.5

package/src/commands/CommandHandlerFactory.ts

@@ -0,0 +1,98 @@
+/**
+ * 命令处理器工厂
+ */
+
+import type {
+  CommandHandler,
+  ICommandHandlerFactory,
+} from "../interfaces/Command";
+import type { IDIContainer } from "../interfaces/Config";
+
+/**
+ * 命令处理器工厂实现
+ */
+export class CommandHandlerFactory implements ICommandHandlerFactory {
+  constructor(private container: IDIContainer) {}
+
+  /**
+   * 创建所有命令处理器
+   */
+  createHandlers(): CommandHandler[] {
+    return [
+      this.createHandler("service"),
+      this.createHandler("config"),
+      this.createHandler("project"),
+      this.createHandler("mcp"),
+      this.createHandler("endpoint"),
+    ];
+  }
+
+  /**
+   * 创建指定类型的命令处理器
+   */
+  createHandler(type: string): CommandHandler {
+    switch (type) {
+      case "service":
+        return this.createServiceCommandHandler();
+      case "config":
+        return this.createConfigCommandHandler();
+      case "project":
+        return this.createProjectCommandHandler();
+      case "mcp":
+        return this.createMcpCommandHandler();
+      case "endpoint":
+        return this.createEndpointCommandHandler();
+      default:
+        throw new Error(`未知的命令处理器类型: ${type}`);
+    }
+  }
+
+  /**
+   * 创建服务命令处理器
+   */
+  private createServiceCommandHandler(): CommandHandler {
+    // 动态导入以避免循环依赖
+    const {
+      ServiceCommandHandler,
+    } = require("@cli/commands/ServiceCommandHandler.js");
+    return new ServiceCommandHandler(this.container);
+  }
+
+  /**
+   * 创建配置命令处理器
+   */
+  private createConfigCommandHandler(): CommandHandler {
+    const {
+      ConfigCommandHandler,
+    } = require("@cli/commands/ConfigCommandHandler.js");
+    return new ConfigCommandHandler(this.container);
+  }
+
+  /**
+   * 创建项目命令处理器
+   */
+  private createProjectCommandHandler(): CommandHandler {
+    const {
+      ProjectCommandHandler,
+    } = require("@cli/commands/ProjectCommandHandler.js");
+    return new ProjectCommandHandler(this.container);
+  }
+
+  /**
+   * 创建MCP命令处理器
+   */
+  private createMcpCommandHandler(): CommandHandler {
+    const { McpCommandHandler } = require("@cli/commands/McpCommandHandler.js");
+    return new McpCommandHandler(this.container);
+  }
+
+  /**
+   * 创建端点命令处理器
+   */
+  private createEndpointCommandHandler(): CommandHandler {
+    const {
+      EndpointCommandHandler,
+    } = require("@cli/commands/EndpointCommandHandler.js");
+    return new EndpointCommandHandler(this.container);
+  }
+}

package/src/commands/ConfigCommandHandler.ts

@@ -0,0 +1,279 @@
+/**
+ * 配置管理命令处理器
+ */
+
+import path from "node:path";
+import chalk from "chalk";
+import ora from "ora";
+import type { SubCommand } from "../interfaces/Command";
+import { BaseCommandHandler } from "../interfaces/Command";
+import type { IDIContainer } from "../interfaces/Config";
+
+/**
+ * 配置管理命令处理器
+ */
+export class ConfigCommandHandler extends BaseCommandHandler {
+  override name = "config";
+  override description = "配置管理命令";
+
+  override subcommands: SubCommand[] = [
+    {
+      name: "init",
+      description: "初始化配置文件",
+      options: [
+        {
+          flags: "-f, --format <format>",
+          description: "配置文件格式 (json, json5, jsonc)",
+          defaultValue: "json",
+        },
+      ],
+      execute: async (args: any[], options: any) => {
+        await this.handleInit(options);
+      },
+    },
+    {
+      name: "get",
+      description: "查看配置值",
+      execute: async (args: any[], options: any) => {
+        this.validateArgs(args, 1);
+        await this.handleGet(args[0]);
+      },
+    },
+    {
+      name: "set",
+      description: "设置配置值",
+      execute: async (args: any[], options: any) => {
+        this.validateArgs(args, 2);
+        await this.handleSet(args[0], args[1]);
+      },
+    },
+  ];
+
+  constructor(container: IDIContainer) {
+    super(container);
+  }
+
+  /**
+   * 主命令执行（显示帮助）
+   */
+  async execute(args: any[], options: any): Promise<void> {
+    console.log("配置管理命令。使用 --help 查看可用的子命令。");
+  }
+
+  /**
+   * 处理初始化命令
+   */
+  private async handleInit(options: any): Promise<void> {
+    const spinner = ora("初始化配置...").start();
+
+    try {
+      const format = options.format as "json" | "json5" | "jsonc";
+      if (format !== "json" && format !== "json5" && format !== "jsonc") {
+        throw new Error("格式必须是 json, json5 或 jsonc");
+      }
+
+      const configManager = this.getService<any>("configManager");
+
+      if (configManager.configExists()) {
+        spinner.warn("配置文件已存在");
+        console.log(chalk.yellow("如需重新初始化，请先删除现有的配置文件"));
+        return;
+      }
+
+      configManager.initConfig(format);
+      spinner.succeed("配置文件初始化成功");
+
+      // 获取实际创建的配置文件路径
+      const configDir = process.env.XIAOZHI_CONFIG_DIR || process.cwd();
+      const configFileName = `xiaozhi.config.${format}`;
+      const configPath = path.join(configDir, configFileName);
+
+      console.log(chalk.green(`✅ 配置文件已创建: ${configFileName}`));
+      console.log(chalk.yellow("📝 请编辑配置文件设置你的 MCP 端点:"));
+      console.log(chalk.gray(`   配置文件路径: ${configPath}`));
+      console.log(chalk.yellow("💡 或者使用命令设置:"));
+      console.log(
+        chalk.gray("   xiaozhi config set mcpEndpoint <your-endpoint-url>")
+      );
+    } catch (error) {
+      spinner.fail(
+        `初始化配置失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * 处理获取配置命令
+   */
+  private async handleGet(key: string): Promise<void> {
+    const spinner = ora("读取配置...").start();
+
+    try {
+      const configManager = this.getService<any>("configManager");
+
+      if (!configManager.configExists()) {
+        spinner.fail("配置文件不存在");
+        console.log(
+          chalk.yellow('💡 提示: 请先运行 "xiaozhi config init" 初始化配置')
+        );
+        return;
+      }
+
+      const config = configManager.getConfig();
+
+      switch (key) {
+        case "mcpEndpoint": {
+          spinner.succeed("配置信息");
+          const endpoints = configManager.getMcpEndpoints();
+          if (endpoints.length === 0) {
+            console.log(chalk.yellow("未配置任何 MCP 端点"));
+          } else if (endpoints.length === 1) {
+            console.log(chalk.green(`MCP 端点: ${endpoints[0]}`));
+          } else {
+            console.log(chalk.green(`MCP 端点 (${endpoints.length} 个):`));
+            endpoints.forEach((ep: string, index: number) => {
+              console.log(chalk.gray(`  ${index + 1}. ${ep}`));
+            });
+          }
+          break;
+        }
+        case "mcpServers":
+          spinner.succeed("配置信息");
+          console.log(chalk.green("MCP 服务:"));
+          for (const [name, serverConfig] of Object.entries(
+            config.mcpServers
+          )) {
+            const server = serverConfig as any;
+            // 检查是否是 SSE 类型
+            if ("type" in server && server.type === "sse") {
+              console.log(chalk.gray(`  ${name}: [SSE] ${server.url}`));
+            } else {
+              console.log(
+                chalk.gray(
+                  `  ${name}: ${server.command} ${server.args.join(" ")}`
+                )
+              );
+            }
+          }
+          break;
+        case "connection": {
+          spinner.succeed("配置信息");
+          const connectionConfig = configManager.getConnectionConfig();
+          console.log(chalk.green("连接配置:"));
+          console.log(
+            chalk.gray(
+              `  心跳检测间隔: ${connectionConfig.heartbeatInterval}ms`
+            )
+          );
+          console.log(
+            chalk.gray(`  心跳超时时间: ${connectionConfig.heartbeatTimeout}ms`)
+          );
+          console.log(
+            chalk.gray(`  重连间隔: ${connectionConfig.reconnectInterval}ms`)
+          );
+          break;
+        }
+        case "heartbeatInterval":
+          spinner.succeed("配置信息");
+          console.log(
+            chalk.green(
+              `心跳检测间隔: ${configManager.getHeartbeatInterval()}ms`
+            )
+          );
+          break;
+        case "heartbeatTimeout":
+          spinner.succeed("配置信息");
+          console.log(
+            chalk.green(
+              `心跳超时时间: ${configManager.getHeartbeatTimeout()}ms`
+            )
+          );
+          break;
+        case "reconnectInterval":
+          spinner.succeed("配置信息");
+          console.log(
+            chalk.green(`重连间隔: ${configManager.getReconnectInterval()}ms`)
+          );
+          break;
+        default:
+          spinner.fail(`未知的配置项: ${key}`);
+          console.log(
+            chalk.yellow(
+              "支持的配置项: mcpEndpoint, mcpServers, connection, heartbeatInterval, heartbeatTimeout, reconnectInterval"
+            )
+          );
+      }
+    } catch (error) {
+      spinner.fail(
+        `读取配置失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * 处理设置配置命令
+   */
+  private async handleSet(key: string, value: string): Promise<void> {
+    const spinner = ora("更新配置...").start();
+
+    try {
+      const configManager = this.getService<any>("configManager");
+
+      if (!configManager.configExists()) {
+        spinner.fail("配置文件不存在");
+        console.log(
+          chalk.yellow('💡 提示: 请先运行 "xiaozhi config init" 初始化配置')
+        );
+        return;
+      }
+
+      switch (key) {
+        case "mcpEndpoint":
+          configManager.updateMcpEndpoint(value);
+          spinner.succeed(`MCP 端点已设置为: ${value}`);
+          break;
+        case "heartbeatInterval": {
+          const interval = Number.parseInt(value);
+          if (Number.isNaN(interval) || interval <= 0) {
+            throw new Error("心跳检测间隔必须是正整数");
+          }
+          configManager.updateHeartbeatInterval(interval);
+          spinner.succeed(`心跳检测间隔已设置为: ${interval}ms`);
+          break;
+        }
+        case "heartbeatTimeout": {
+          const timeout = Number.parseInt(value);
+          if (Number.isNaN(timeout) || timeout <= 0) {
+            throw new Error("心跳超时时间必须是正整数");
+          }
+          configManager.updateHeartbeatTimeout(timeout);
+          spinner.succeed(`心跳超时时间已设置为: ${timeout}ms`);
+          break;
+        }
+        case "reconnectInterval": {
+          const interval = Number.parseInt(value);
+          if (Number.isNaN(interval) || interval <= 0) {
+            throw new Error("重连间隔必须是正整数");
+          }
+          configManager.updateReconnectInterval(interval);
+          spinner.succeed(`重连间隔已设置为: ${interval}ms`);
+          break;
+        }
+        default:
+          spinner.fail(`不支持设置的配置项: ${key}`);
+          console.log(
+            chalk.yellow(
+              "支持设置的配置项: mcpEndpoint, heartbeatInterval, heartbeatTimeout, reconnectInterval"
+            )
+          );
+      }
+    } catch (error) {
+      spinner.fail(
+        `设置配置失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.handleError(error as Error);
+    }
+  }
+}

package/src/commands/EndpointCommandHandler.ts

@@ -0,0 +1,158 @@
+/**
+ * 端点管理命令处理器
+ */
+
+import chalk from "chalk";
+import ora from "ora";
+import type { SubCommand } from "../interfaces/Command";
+import { BaseCommandHandler } from "../interfaces/Command";
+import type { IDIContainer } from "../interfaces/Config";
+
+/**
+ * 端点管理命令处理器
+ */
+export class EndpointCommandHandler extends BaseCommandHandler {
+  override name = "endpoint";
+  override description = "管理 MCP 端点";
+
+  override subcommands: SubCommand[] = [
+    {
+      name: "list",
+      description: "列出所有 MCP 端点",
+      execute: async (args: any[], options: any) => {
+        await this.handleList();
+      },
+    },
+    {
+      name: "add",
+      description: "添加新的 MCP 端点",
+      execute: async (args: any[], options: any) => {
+        this.validateArgs(args, 1);
+        await this.handleAdd(args[0]);
+      },
+    },
+    {
+      name: "remove",
+      description: "移除指定的 MCP 端点",
+      execute: async (args: any[], options: any) => {
+        this.validateArgs(args, 1);
+        await this.handleRemove(args[0]);
+      },
+    },
+    {
+      name: "set",
+      description: "设置 MCP 端点（可以是单个或多个）",
+      execute: async (args: any[], options: any) => {
+        this.validateArgs(args, 1);
+        await this.handleSet(args);
+      },
+    },
+  ];
+
+  constructor(container: IDIContainer) {
+    super(container);
+  }
+
+  /**
+   * 主命令执行（显示帮助）
+   */
+  async execute(args: any[], options: any): Promise<void> {
+    console.log("MCP 端点管理命令。使用 --help 查看可用的子命令。");
+  }
+
+  /**
+   * 处理列出端点命令
+   */
+  protected async handleList(): Promise<void> {
+    const spinner = ora("读取端点配置...").start();
+
+    try {
+      const configManager = this.getService<any>("configManager");
+      const endpoints = configManager.getMcpEndpoints();
+      spinner.succeed("端点列表");
+
+      if (endpoints.length === 0) {
+        console.log(chalk.yellow("未配置任何 MCP 端点"));
+      } else {
+        console.log(chalk.green(`共 ${endpoints.length} 个端点:`));
+        endpoints.forEach((ep: string, index: number) => {
+          console.log(chalk.gray(`  ${index + 1}. ${ep}`));
+        });
+      }
+    } catch (error) {
+      spinner.fail(
+        `读取端点失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * 处理添加端点命令
+   */
+  protected async handleAdd(url: string): Promise<void> {
+    const spinner = ora("添加端点...").start();
+
+    try {
+      const configManager = this.getService<any>("configManager");
+      configManager.addMcpEndpoint(url);
+      spinner.succeed(`成功添加端点: ${url}`);
+
+      const endpoints = configManager.getMcpEndpoints();
+      console.log(chalk.gray(`当前共 ${endpoints.length} 个端点`));
+    } catch (error) {
+      spinner.fail(
+        `添加端点失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * 处理移除端点命令
+   */
+  protected async handleRemove(url: string): Promise<void> {
+    const spinner = ora("移除端点...").start();
+
+    try {
+      const configManager = this.getService<any>("configManager");
+      configManager.removeMcpEndpoint(url);
+      spinner.succeed(`成功移除端点: ${url}`);
+
+      const endpoints = configManager.getMcpEndpoints();
+      console.log(chalk.gray(`当前剩余 ${endpoints.length} 个端点`));
+    } catch (error) {
+      spinner.fail(
+        `移除端点失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.handleError(error as Error);
+    }
+  }
+
+  /**
+   * 处理设置端点命令
+   */
+  protected async handleSet(urls: string[]): Promise<void> {
+    const spinner = ora("设置端点...").start();
+
+    try {
+      const configManager = this.getService<any>("configManager");
+
+      if (urls.length === 1) {
+        configManager.updateMcpEndpoint(urls[0]);
+        spinner.succeed(`成功设置端点: ${urls[0]}`);
+      } else {
+        configManager.updateMcpEndpoint(urls);
+        spinner.succeed(`成功设置 ${urls.length} 个端点`);
+        for (const [index, url] of urls.entries()) {
+          console.log(chalk.gray(`  ${index + 1}. ${url}`));
+        }
+      }
+    } catch (error) {
+      spinner.fail(
+        `设置端点失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      this.handleError(error as Error);
+    }
+  }
+}