@xiaozhi-client/cli 1.9.4-beta.10

package/README.md

@@ -0,0 +1,98 @@
+# @xiaozhi-client/cli
+
+小智客户端 CLI 包，提供命令行界面用于管理 MCP 服务和配置。
+
+## 包说明
+
+此包是 xiaozhi-client 项目的 CLI 入口点，作为独立 npm 包发布。它与 xiaozhi-client 主包共享相同的代码库和版本号。
+
+## 目录结构
+
+```
+packages/cli/
+├── src/
+│   ├── index.ts              # 主入口
+│   ├── Container.ts          # DI 容器
+│   ├── Types.ts              # 类型定义
+│   ├── Constants.ts          # 常量定义
+│   ├── commands/             # 命令处理器
+│   │   ├── index.ts
+│   │   ├── CommandRegistry.ts
+│   │   ├── CommandHandlerFactory.ts
+│   │   ├── ConfigCommandHandler.ts
+│   │   ├── EndpointCommandHandler.ts
+│   │   ├── McpCommandHandler.ts
+│   │   ├── ProjectCommandHandler.ts
+│   │   └── ServiceCommandHandler.ts
+│   ├── services/             # 服务管理器
+│   │   ├── ProcessManager.ts
+│   │   ├── DaemonManager.ts
+│   │   ├── ServiceManager.ts
+│   │   └── TemplateManager.ts
+│   ├── utils/                # 工具类
+│   ├── interfaces/           # 接口定义
+│   └── errors/               # 错误处理
+├── package.json
+├── project.json              # Nx 项目配置
+├── tsconfig.json
+└── tsup.config.ts            # 构建配置
+```
+
+## 构建配置
+
+- **入口点**：`src/index.ts` → `../../dist/cli/index.js`
+- **格式**：ESM (ES Modules)
+- **目标**：Node.js 18+
+- **打包工具**：tsup (esbuild)
+
+## 外部依赖
+
+CLI 包通过 external 配置引用 backend 模块：
+
+- `@root/WebServer` → `dist/backend/WebServer.js` (通过 WebServerLauncher)
+- `@/lib/config/manager` → `dist/backend/lib/config/manager.js`
+
+## 导入方式
+
+### 内部导入（使用相对路径）
+
+```typescript
+// CLI 包内部使用相对路径
+import { DIContainer } from "./Container";
+import { CommandRegistry } from "./commands/index";
+```
+
+### 外部依赖（使用路径别名）
+
+```typescript
+// 引用 backend 模块
+import { configManager } from "@/lib/config/manager";
+```
+
+## 开发命令
+
+```bash
+# 构建
+pnpm build
+
+# 类型检查
+pnpm type-check
+
+# 运行测试
+pnpm test
+
+# 代码检查
+pnpm lint
+```
+
+## 依赖关系
+
+```
+packages/cli
+  ↓ (implicitDependencies)
+apps/backend
+  ↓ (implicitDependencies)
+packages/shared-types
+```
+
+构建顺序：shared-types → backend → cli

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@xiaozhi-client/cli",
+  "version": "1.9.4-beta.10",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shenjingnan/xiaozhi-client.git",
+    "directory": "packages/shared-types"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "../../dist/cli/index.js",
+  "bin": {
+    "xiaozhi": "../../dist/cli/index.js",
+    "xiaozhi-client": "../../dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@xiaozhi-client/config": "workspace:*",
+    "consola": "^3.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "typescript": "^5.9.2"
+  }
+}

package/project.json

@@ -0,0 +1,75 @@
+{
+  "name": "cli",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/cli/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "tsup",
+        "cwd": "packages/cli"
+      },
+      "outputs": ["{workspaceRoot}/dist/cli"],
+      "dependsOn": ["backend:build", "config:build"]
+    },
+    "test": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "vitest run --coverage.enabled=false",
+        "cwd": "packages/cli"
+      },
+      "outputs": ["{workspaceRoot}/coverage"]
+    },
+    "test:watch": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "vitest",
+        "cwd": "packages/cli"
+      }
+    },
+    "test:coverage": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "vitest run --coverage",
+        "cwd": "packages/cli"
+      },
+      "outputs": ["{workspaceRoot}/coverage"]
+    },
+    "lint": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "biome check packages/cli"
+      }
+    },
+    "lint:fix": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "biome check --write packages/cli"
+      }
+    },
+    "type-check": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "echo 'CLI type-check skipped: bundled by tsup which strips types'"
+      }
+    },
+    "dev": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "tsup --watch",
+        "cwd": "packages/cli"
+      },
+      "dependsOn": ["backend:build"]
+    },
+    "nx-release-publish": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "pnpm publish --access public --no-git-checks",
+        "cwd": "packages/cli"
+      }
+    }
+  },
+  "tags": ["type:lib", "scope:cli"],
+  "implicitDependencies": ["backend", "shared-types"]
+}

package/src/Constants.ts

@@ -0,0 +1,105 @@
+/**
+ * CLI 常量定义
+ */
+
+/**
+ * 服务相关常量
+ */
+export const SERVICE_CONSTANTS = {
+  /** 服务名称 */
+  NAME: "xiaozhi-mcp-service",
+  /** 默认端口 */
+  DEFAULT_PORT: 3000,
+  /** Web UI 默认端口 */
+  DEFAULT_WEB_UI_PORT: 9999,
+  /** PID 文件名 */
+  PID_FILE: "xiaozhi.pid",
+  /** 日志文件名 */
+  LOG_FILE: "xiaozhi.log",
+} as const;
+
+/**
+ * 配置相关常量
+ */
+export const CONFIG_CONSTANTS = {
+  /** 配置文件名（按优先级排序） */
+  FILE_NAMES: [
+    "xiaozhi.config.json5",
+    "xiaozhi.config.jsonc",
+    "xiaozhi.config.json",
+  ],
+  /** 默认配置文件名 */
+  DEFAULT_FILE: "xiaozhi.config.default.json",
+  /** 配置目录环境变量 */
+  DIR_ENV_VAR: "XIAOZHI_CONFIG_DIR",
+} as const;
+
+/**
+ * 路径相关常量
+ */
+export const PATH_CONSTANTS = {
+  /** 工作目录名 */
+  WORK_DIR: ".xiaozhi",
+  /** 模板目录名 */
+  TEMPLATES_DIR: "templates",
+  /** 日志目录名 */
+  LOGS_DIR: "logs",
+} as const;
+
+/**
+ * 错误码常量
+ */
+export const ERROR_CODES = {
+  /** 通用错误 */
+  GENERAL_ERROR: "GENERAL_ERROR",
+  /** 配置错误 */
+  CONFIG_ERROR: "CONFIG_ERROR",
+  /** 服务错误 */
+  SERVICE_ERROR: "SERVICE_ERROR",
+  /** 验证错误 */
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  /** 文件操作错误 */
+  FILE_ERROR: "FILE_ERROR",
+  /** 进程错误 */
+  PROCESS_ERROR: "PROCESS_ERROR",
+  /** 网络错误 */
+  NETWORK_ERROR: "NETWORK_ERROR",
+  /** 权限错误 */
+  PERMISSION_ERROR: "PERMISSION_ERROR",
+} as const;
+
+/**
+ * 超时常量（毫秒）
+ */
+export const TIMEOUT_CONSTANTS = {
+  /** 进程停止超时 */
+  PROCESS_STOP: 3000,
+  /** 服务启动超时 */
+  SERVICE_START: 10000,
+  /** 网络请求超时 */
+  NETWORK_REQUEST: 5000,
+  /** 文件操作超时 */
+  FILE_OPERATION: 2000,
+} as const;
+
+/**
+ * 分页相关常量
+ */
+export const PAGINATION_CONSTANTS = {
+  /** 默认每页记录数 */
+  DEFAULT_LIMIT: 50,
+  /** 最大每页记录数 */
+  MAX_LIMIT: 200,
+} as const;
+
+/**
+ * 重试常量
+ */
+export const RETRY_CONSTANTS = {
+  /** 默认重试次数 */
+  DEFAULT_ATTEMPTS: 3,
+  /** 重试间隔（毫秒） */
+  DEFAULT_INTERVAL: 1000,
+  /** 最大重试间隔（毫秒） */
+  MAX_INTERVAL: 5000,
+} as const;

package/src/Container.ts

@@ -0,0 +1,212 @@
+/**
+ * 依赖注入容器
+ */
+
+import { configManager } from "@xiaozhi-client/config";
+import { ErrorHandler } from "./errors/ErrorHandlers";
+import type { IDIContainer } from "./interfaces/Config";
+import { FileUtils } from "./utils/FileUtils";
+import { FormatUtils } from "./utils/FormatUtils";
+import { PathUtils } from "./utils/PathUtils";
+import { PlatformUtils } from "./utils/PlatformUtils";
+import { Validation } from "./utils/Validation";
+import { VersionUtils } from "./utils/VersionUtils";
+
+/**
+ * 依赖注入容器实现
+ */
+export class DIContainer implements IDIContainer {
+  private instances = new Map<string, any>();
+  private factories = new Map<string, () => any>();
+  private asyncFactories = new Map<string, () => Promise<any>>();
+  private singletons = new Set<string>();
+
+  /**
+   * 注册服务工厂
+   */
+  register<T>(key: string, factory: () => T, singleton = false): void {
+    this.factories.set(key, factory);
+    if (singleton) {
+      this.singletons.add(key);
+    }
+  }
+
+  /**
+   * 注册单例服务
+   */
+  registerSingleton<T>(key: string, factory: () => T): void {
+    this.register(key, factory, true);
+  }
+
+  /**
+   * 注册实例
+   */
+  registerInstance<T>(key: string, instance: T): void {
+    this.instances.set(key, instance);
+    this.singletons.add(key);
+  }
+
+  /**
+   * 获取服务实例
+   */
+  get<T>(key: string): T {
+    // 如果是单例且已经创建过实例，直接返回
+    if (this.singletons.has(key) && this.instances.has(key)) {
+      return this.instances.get(key);
+    }
+
+    // 获取工厂函数
+    const factory = this.factories.get(key);
+    if (!factory) {
+      throw new Error(`Service ${key} not registered`);
+    }
+
+    // 创建实例
+    const instance = factory();
+
+    // 如果是单例，缓存实例
+    if (this.singletons.has(key)) {
+      this.instances.set(key, instance);
+    }
+
+    return instance;
+  }
+
+  /**
+   * 检查服务是否已注册
+   */
+  has(key: string): boolean {
+    return this.factories.has(key) || this.instances.has(key);
+  }
+
+  /**
+   * 清除所有注册的服务
+   */
+  clear(): void {
+    this.instances.clear();
+    this.factories.clear();
+    this.singletons.clear();
+  }
+
+  /**
+   * 获取所有已注册的服务键
+   */
+  getRegisteredKeys(): string[] {
+    const factoryKeys = Array.from(this.factories.keys());
+    const instanceKeys = Array.from(this.instances.keys());
+    return [...new Set([...factoryKeys, ...instanceKeys])];
+  }
+
+  /**
+   * 创建默认容器实例
+   */
+  static create(): DIContainer {
+    const container = new DIContainer();
+
+    // 注册工具类（单例）
+    container.registerSingleton("versionUtils", () => {
+      return VersionUtils;
+    });
+
+    container.registerSingleton("platformUtils", () => {
+      return PlatformUtils;
+    });
+
+    container.registerSingleton("formatUtils", () => {
+      return FormatUtils;
+    });
+
+    container.registerSingleton("fileUtils", () => {
+      return FileUtils;
+    });
+
+    container.registerSingleton("pathUtils", () => {
+      return PathUtils;
+    });
+
+    container.registerSingleton("validation", () => {
+      return Validation;
+    });
+
+    // 注册配置管理器（单例）
+    container.registerSingleton("configManager", () => {
+      return configManager;
+    });
+
+    // 注册错误处理器（单例）
+    container.registerSingleton("errorHandler", () => {
+      return ErrorHandler;
+    });
+
+    // 注册服务层
+    container.registerSingleton("processManager", () => {
+      const ProcessManagerModule = require("@cli/services/ProcessManager.js");
+      return new ProcessManagerModule.ProcessManagerImpl();
+    });
+
+    container.registerSingleton("daemonManager", () => {
+      const DaemonManagerModule = require("@cli/services/DaemonManager.js");
+      const processManager = container.get("processManager") as any;
+      return new DaemonManagerModule.DaemonManagerImpl(processManager);
+    });
+
+    container.registerSingleton("serviceManager", () => {
+      const ServiceManagerModule = require("@cli/services/ServiceManager.js");
+      const processManager = container.get("processManager") as any;
+      const configManager = container.get("configManager") as any;
+      return new ServiceManagerModule.ServiceManagerImpl(
+        processManager,
+        configManager
+      );
+    });
+
+    container.registerSingleton("templateManager", () => {
+      // 使用动态导入的同步版本
+      const TemplateManagerModule = require("@cli/services/TemplateManager.js");
+      return new TemplateManagerModule.TemplateManagerImpl();
+    });
+
+    // 注册命令层（稍后在命令层实现时添加）
+    // container.register('serviceCommand', () => {
+    //   const { ServiceCommand } = require('./commands/ServiceCommand.js');
+    //   const serviceManager = container.get('serviceManager');
+    //   const processManager = container.get('processManager');
+    //   return new ServiceCommand(serviceManager, processManager);
+    // });
+
+    // container.register('configCommand', () => {
+    //   const { ConfigCommand } = require('./commands/ConfigCommand.js');
+    //   const configManager = container.get('configManager');
+    //   const validation = container.get('validation');
+    //   return new ConfigCommand(configManager, validation);
+    // });
+
+    // container.register('projectCommand', () => {
+    //   const { ProjectCommand } = require('./commands/ProjectCommand.js');
+    //   const templateManager = container.get('templateManager');
+    //   const fileUtils = container.get('fileUtils');
+    //   return new ProjectCommand(templateManager, fileUtils);
+    // });
+
+    // container.register('mcpCommand', () => {
+    //   const { McpCommand } = require('./commands/McpCommand.js');
+    //   return new McpCommand();
+    // });
+
+    // container.register('infoCommand', () => {
+    //   const { InfoCommand } = require('./commands/InfoCommand.js');
+    //   const versionUtils = container.get('versionUtils');
+    //   const platformUtils = container.get('platformUtils');
+    //   return new InfoCommand(versionUtils, platformUtils);
+    // });
+
+    return container;
+  }
+}
+
+/**
+ * 创建并配置 DI 容器
+ */
+export async function createContainer(): Promise<IDIContainer> {
+  return DIContainer.create();
+}

package/src/Types.ts

@@ -0,0 +1,79 @@
+/**
+ * CLI 核心类型定义
+ */
+
+/**
+ * 平台类型
+ */
+export type Platform =
+  | "win32"
+  | "darwin"
+  | "linux"
+  | "freebsd"
+  | "openbsd"
+  | "sunos"
+  | "aix";
+
+/**
+ * 日志级别
+ */
+export type LogLevel = "error" | "warn" | "info" | "debug";
+
+/**
+ * 配置文件格式
+ */
+export type ConfigFormat = "json" | "json5" | "jsonc";
+
+/**
+ * 命令执行结果
+ */
+export interface CommandResult {
+  /** 是否成功 */
+  success: boolean;
+  /** 结果消息 */
+  message?: string;
+  /** 错误信息 */
+  error?: Error;
+  /** 退出码 */
+  exitCode?: number;
+}
+
+/**
+ * 文件操作选项
+ */
+export interface FileOperationOptions {
+  /** 是否递归 */
+  recursive?: boolean;
+  /** 排除的文件/目录 */
+  exclude?: string[];
+  /** 是否覆盖现有文件 */
+  overwrite?: boolean;
+}
+
+/**
+ * 进程信息
+ */
+export interface ProcessInfo {
+  /** 进程 ID */
+  pid: number;
+  /** 进程名称 */
+  name: string;
+  /** 启动时间 */
+  startTime: number;
+  /** 命令行参数 */
+  args: string[];
+}
+
+/**
+ * 模板信息
+ */
+export interface TemplateInfo {
+  /** 模板名称 */
+  name: string;
+  /** 模板描述 */
+  description: string;
+  /** 模板路径 */
+  path: string;
+  /** 是否有效 */
+  valid: boolean;
+}

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);
+  }
+}