@xiaozhi-client/cli 1.9.4-beta.5

package/src/services/ServiceManager.ts

@@ -0,0 +1,319 @@
+/**
+ * 服务管理服务
+ */
+
+import type { ConfigManager } from "@xiaozhi-client/config";
+import { ConfigError, ServiceError } from "../errors/index";
+import type {
+  ServiceManager as IServiceManager,
+  ProcessManager,
+  ServiceStartOptions,
+  ServiceStatus,
+} from "../interfaces/Service";
+import { PathUtils } from "../utils/PathUtils";
+import { Validation } from "../utils/Validation";
+
+/**
+ * 服务管理器实现
+ */
+export class ServiceManagerImpl implements IServiceManager {
+  constructor(
+    private processManager: ProcessManager,
+    private configManager: ConfigManager
+  ) {}
+
+  /**
+   * 启动服务
+   */
+  async start(options: ServiceStartOptions): Promise<void> {
+    try {
+      // 验证启动选项
+      this.validateStartOptions(options);
+
+      // 清理容器环境状态
+      this.processManager.cleanupContainerState();
+
+      // 检查服务是否已经在运行
+      const status = this.getStatus();
+      if (status.running) {
+        // 自动停止现有服务并重新启动
+        console.log(`检测到服务已在运行 (PID: ${status.pid})，正在自动重启...`);
+
+        try {
+          // 优雅停止现有进程
+          await this.processManager.gracefulKillProcess(status.pid || 0);
+
+          // 清理 PID 文件
+          this.processManager.cleanupPidFile();
+
+          // 等待一下确保完全停止
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+
+          console.log("现有服务已停止，正在启动新服务...");
+        } catch (stopError) {
+          console.warn(
+            `停止现有服务时出现警告: ${stopError instanceof Error ? stopError.message : String(stopError)}`
+          );
+          // 继续尝试启动新服务，因为旧进程可能已经不存在了
+        }
+      }
+
+      // 检查环境配置
+      this.checkEnvironment();
+
+      // 根据模式启动服务
+      switch (options.mode) {
+        case "mcp-server":
+          await this.startMcpServerMode(options);
+          break;
+        case "stdio":
+          // stdio 模式已废弃，改为启动 Web 服务
+          await this.startNormalMode(options);
+          break;
+        case "normal":
+          await this.startNormalMode(options);
+          break;
+        default:
+          await this.startNormalMode(options);
+          break;
+      }
+    } catch (error) {
+      if (error instanceof ServiceError) {
+        throw error;
+      }
+      throw ServiceError.startFailed(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+
+  /**
+   * 停止服务
+   */
+  async stop(): Promise<void> {
+    try {
+      const status = this.getStatus();
+
+      if (!status.running) {
+        throw ServiceError.notRunning();
+      }
+
+      // 优雅停止进程
+      await this.processManager.gracefulKillProcess(status.pid || 0);
+
+      // 清理 PID 文件
+      this.processManager.cleanupPidFile();
+    } catch (error) {
+      if (error instanceof ServiceError) {
+        throw error;
+      }
+      throw new ServiceError(
+        `停止服务失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 重启服务
+   */
+  async restart(options: ServiceStartOptions): Promise<void> {
+    try {
+      // 先停止服务
+      const status = this.getStatus();
+      if (status.running) {
+        await this.stop();
+        // 等待一下确保完全停止
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+
+      // 重新启动服务
+      await this.start(options);
+    } catch (error) {
+      throw new ServiceError(
+        `重启服务失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 获取服务状态
+   */
+  getStatus(): ServiceStatus {
+    return this.processManager.getServiceStatus();
+  }
+
+  /**
+   * 验证启动选项
+   */
+  private validateStartOptions(options: ServiceStartOptions): void {
+    if (options.port !== undefined) {
+      Validation.validatePort(options.port);
+    }
+
+    if (
+      options.mode &&
+      !["normal", "mcp-server", "stdio"].includes(options.mode)
+    ) {
+      throw new ServiceError(`无效的运行模式: ${options.mode}`);
+    }
+  }
+
+  /**
+   * 检查环境配置
+   */
+  private checkEnvironment(): void {
+    // 检查配置文件是否存在
+    if (!this.configManager.configExists()) {
+      throw ConfigError.configNotFound();
+    }
+
+    // 可以添加更多环境检查
+    try {
+      const config = this.configManager.getConfig();
+      if (!config) {
+        throw new ConfigError("配置文件无效");
+      }
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        throw error;
+      }
+      throw new ConfigError(
+        `配置文件错误: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 启动普通模式
+   */
+  private async startNormalMode(options: ServiceStartOptions): Promise<void> {
+    if (options.daemon) {
+      // 后台模式 - 默认启动 WebUI
+      await this.startWebServerInDaemon();
+    } else {
+      // 前台模式 - 默认启动 WebUI
+      await this.startWebServerInForeground();
+    }
+  }
+
+  /**
+   * 启动 MCP Server 模式
+   */
+  private async startMcpServerMode(
+    options: ServiceStartOptions
+  ): Promise<void> {
+    const port = options.port || 3000;
+    const { spawn } = await import("node:child_process");
+
+    if (options.daemon) {
+      // 后台模式
+      const scriptPath = PathUtils.getExecutablePath("cli");
+      const child = spawn(
+        "node",
+        [scriptPath, "start", "--server", port.toString()],
+        {
+          detached: true,
+          stdio: ["ignore", "ignore", "ignore"], // 完全忽略所有 stdio，避免阻塞
+          env: {
+            ...process.env,
+            XIAOZHI_CONFIG_DIR: PathUtils.getConfigDir(),
+            XIAOZHI_DAEMON: "true",
+            MCP_SERVER_MODE: "true",
+          },
+        }
+      );
+
+      // 保存 PID 信息
+      this.processManager.savePidInfo(child.pid || 0, "daemon");
+
+      // 完全分离子进程
+      child.unref();
+
+      // 输出启动信息后立即退出父进程
+      console.log(
+        `✅ MCP Server 已在后台启动 (PID: ${child.pid}, Port: ${port})`
+      );
+      console.log(`💡 使用 'xiaozhi status' 查看状态`);
+
+      // 立即退出父进程，释放终端控制权
+      process.exit(0);
+    } else {
+      // 前台模式 - 直接启动 Web Server
+      const { WebServer } = await import("@root/WebServer.js");
+      const server = new WebServer(port);
+
+      // 处理退出信号
+      const cleanup = async () => {
+        await server.stop();
+        process.exit(0);
+      };
+
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+
+      await server.start();
+    }
+  }
+
+  /**
+   * 后台模式启动 WebServer
+   */
+  private async startWebServerInDaemon(): Promise<void> {
+    const { spawn } = await import("node:child_process");
+    const webServerPath = PathUtils.getWebServerLauncherPath();
+
+    const fs = await import("node:fs");
+    if (!fs.default.existsSync(webServerPath)) {
+      throw new ServiceError(`WebServer 文件不存在: ${webServerPath}`);
+    }
+
+    const args = [webServerPath];
+
+    const child = spawn("node", args, {
+      detached: true,
+      stdio: ["ignore", "ignore", "ignore"], // 完全忽略所有 stdio，避免阻塞
+      env: {
+        ...process.env,
+        XIAOZHI_CONFIG_DIR: PathUtils.getConfigDir(),
+        XIAOZHI_DAEMON: "true",
+      },
+    });
+
+    // 保存 PID 信息
+    this.processManager.savePidInfo(child.pid || 0, "daemon");
+
+    // 完全分离子进程
+    child.unref();
+
+    // 输出启动信息后立即退出父进程
+    console.log(`✅ 后台服务已启动 (PID: ${child.pid})`);
+    console.log(`💡 使用 'xiaozhi status' 查看状态`);
+    console.log(`💡 使用 'xiaozhi attach' 查看日志`);
+
+    // 立即退出父进程，释放终端控制权
+    process.exit(0);
+  }
+
+  /**
+   * 前台模式启动 WebServer
+   */
+  private async startWebServerInForeground(): Promise<void> {
+    const { WebServer } = await import("@root/WebServer.js");
+    const server = new WebServer();
+
+    // 处理退出信号
+    const cleanup = async () => {
+      await server.stop();
+      this.processManager.cleanupPidFile();
+      process.exit(0);
+    };
+
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+
+    // 保存 PID 信息
+    this.processManager.savePidInfo(process.pid, "foreground");
+
+    await server.start();
+  }
+}

package/src/services/TemplateManager.ts

@@ -0,0 +1,382 @@
+/**
+ * 模板管理服务
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { FileError, ValidationError } from "../errors/index";
+import type { TemplateManager as ITemplateManager } from "../interfaces/Service";
+import { FileUtils } from "../utils/FileUtils";
+import { PathUtils } from "../utils/PathUtils";
+import { Validation } from "../utils/Validation";
+
+/**
+ * 模板信息接口
+ */
+export interface TemplateInfo {
+  name: string;
+  path: string;
+  description?: string;
+  version?: string;
+  author?: string;
+  files: string[];
+}
+
+/**
+ * 模板创建选项
+ */
+export interface TemplateCreateOptions {
+  templateName?: string;
+  targetPath: string;
+  projectName: string;
+  variables?: Record<string, string>;
+}
+
+/**
+ * 模板管理器实现
+ */
+export class TemplateManagerImpl implements ITemplateManager {
+  private templateCache = new Map<string, TemplateInfo>();
+
+  /**
+   * 获取可用模板列表
+   */
+  async getAvailableTemplates(): Promise<TemplateInfo[]> {
+    try {
+      const templatesDir = PathUtils.findTemplatesDir();
+
+      if (!templatesDir) {
+        return [];
+      }
+
+      const templates: TemplateInfo[] = [];
+      const templateDirs = fs
+        .readdirSync(templatesDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+
+      for (const templateName of templateDirs) {
+        try {
+          const templateInfo = await this.getTemplateInfo(templateName);
+          if (templateInfo) {
+            templates.push(templateInfo);
+          }
+        } catch (error) {
+          // 跳过无效的模板目录
+          console.warn(`跳过无效模板: ${templateName}`);
+        }
+      }
+
+      return templates;
+    } catch (error) {
+      throw new FileError(
+        "无法读取模板目录",
+        PathUtils.findTemplatesDir() || ""
+      );
+    }
+  }
+
+  /**
+   * 获取模板信息
+   */
+  async getTemplateInfo(templateName: string): Promise<TemplateInfo | null> {
+    try {
+      // 验证模板名称
+      Validation.validateTemplateName(templateName);
+
+      // 检查缓存
+      if (this.templateCache.has(templateName)) {
+        return this.templateCache.get(templateName)!;
+      }
+
+      const templatePath = PathUtils.getTemplatePath(templateName);
+      if (!templatePath) {
+        return null;
+      }
+
+      // 读取模板配置文件
+      const configPath = path.join(templatePath, "template.json");
+      let config: any = {};
+
+      if (FileUtils.exists(configPath)) {
+        try {
+          const configContent = FileUtils.readFile(configPath);
+          config = JSON.parse(configContent);
+        } catch (error) {
+          console.warn(`模板配置文件解析失败: ${templateName}`);
+        }
+      }
+
+      // 获取模板文件列表
+      const files = this.getTemplateFiles(templatePath);
+
+      const templateInfo: TemplateInfo = {
+        name: templateName,
+        path: templatePath,
+        description: config.description || `${templateName} 模板`,
+        version: config.version || "1.0.0",
+        author: config.author,
+        files,
+      };
+
+      // 缓存模板信息
+      this.templateCache.set(templateName, templateInfo);
+
+      return templateInfo;
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      throw new FileError(`无法获取模板信息: ${templateName}`, "");
+    }
+  }
+
+  /**
+   * 复制模板到目标目录
+   */
+  async copyTemplate(templateName: string, targetPath: string): Promise<void> {
+    await this.createProject({
+      templateName,
+      targetPath,
+      projectName: path.basename(targetPath),
+    });
+  }
+
+  /**
+   * 创建项目
+   */
+  async createProject(options: TemplateCreateOptions): Promise<void> {
+    try {
+      // 验证输入参数
+      this.validateCreateOptions(options);
+
+      // 获取模板信息
+      const templateName = options.templateName || "default";
+      const templateInfo = await this.getTemplateInfo(templateName);
+
+      if (!templateInfo) {
+        throw new FileError(`模板不存在: ${templateName}`, "");
+      }
+
+      // 检查目标路径
+      const targetPath = path.resolve(options.targetPath);
+      if (FileUtils.exists(targetPath)) {
+        throw FileError.alreadyExists(targetPath);
+      }
+
+      // 创建项目目录
+      FileUtils.ensureDir(targetPath);
+
+      // 复制模板文件
+      await this.copyTemplateFiles(templateInfo, targetPath, options);
+
+      // 处理模板变量替换
+      await this.processTemplateVariables(targetPath, options);
+
+      console.log(`✅ 项目创建成功: ${targetPath}`);
+    } catch (error) {
+      if (error instanceof FileError || error instanceof ValidationError) {
+        throw error;
+      }
+      throw new FileError(
+        `创建项目失败: ${error instanceof Error ? error.message : String(error)}`,
+        options.targetPath
+      );
+    }
+  }
+
+  /**
+   * 验证模板
+   */
+  async validateTemplate(templateName: string): Promise<boolean> {
+    try {
+      const templateInfo = await this.getTemplateInfo(templateName);
+
+      if (!templateInfo) {
+        return false;
+      }
+
+      // 检查必要文件是否存在
+      const requiredFiles = ["package.json"]; // 可以根据需要调整
+
+      for (const requiredFile of requiredFiles) {
+        const filePath = path.join(templateInfo.path, requiredFile);
+        if (!FileUtils.exists(filePath)) {
+          console.warn(`模板缺少必要文件: ${requiredFile}`);
+          return false;
+        }
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 清除模板缓存
+   */
+  clearCache(): void {
+    this.templateCache.clear();
+  }
+
+  /**
+   * 获取模板文件列表
+   */
+  private getTemplateFiles(templatePath: string): string[] {
+    try {
+      const files = FileUtils.listDirectory(templatePath, {
+        recursive: true,
+        includeHidden: false,
+      });
+
+      // 过滤掉模板配置文件和其他不需要的文件
+      return files.filter((file) => {
+        const relativePath = path.relative(templatePath, file);
+        return (
+          !relativePath.startsWith(".") &&
+          relativePath !== "template.json" &&
+          !relativePath.includes("node_modules")
+        );
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * 验证创建选项
+   */
+  private validateCreateOptions(options: TemplateCreateOptions): void {
+    Validation.validateRequired(options.targetPath, "targetPath");
+    Validation.validateRequired(options.projectName, "projectName");
+    Validation.validateProjectName(options.projectName);
+
+    if (options.templateName) {
+      Validation.validateTemplateName(options.templateName);
+    }
+  }
+
+  /**
+   * 复制模板文件
+   */
+  private async copyTemplateFiles(
+    templateInfo: TemplateInfo,
+    targetPath: string,
+    options: TemplateCreateOptions
+  ): Promise<void> {
+    try {
+      // 复制所有模板文件
+      FileUtils.copyDirectory(templateInfo.path, targetPath, {
+        exclude: ["template.json", ".git", "node_modules"],
+        overwrite: false,
+        recursive: true,
+      });
+    } catch (error) {
+      throw new FileError(
+        `复制模板文件失败: ${error instanceof Error ? error.message : String(error)}`,
+        templateInfo.path
+      );
+    }
+  }
+
+  /**
+   * 处理模板变量替换
+   */
+  private async processTemplateVariables(
+    targetPath: string,
+    options: TemplateCreateOptions
+  ): Promise<void> {
+    try {
+      // 默认变量
+      const variables = {
+        PROJECT_NAME: options.projectName,
+        PROJECT_NAME_LOWER: options.projectName.toLowerCase(),
+        PROJECT_NAME_UPPER: options.projectName.toUpperCase(),
+        ...options.variables,
+      };
+
+      // 获取需要处理的文件
+      const filesToProcess = [
+        "package.json",
+        "README.md",
+        "src/**/*.ts",
+        "src/**/*.js",
+        "src/**/*.json",
+      ];
+
+      for (const pattern of filesToProcess) {
+        const files = this.findFilesByPattern(targetPath, pattern);
+
+        for (const filePath of files) {
+          await this.replaceVariablesInFile(filePath, variables);
+        }
+      }
+    } catch (error) {
+      console.warn(
+        `处理模板变量失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 根据模式查找文件
+   */
+  private findFilesByPattern(basePath: string, pattern: string): string[] {
+    try {
+      if (!pattern.includes("*")) {
+        // 简单文件路径
+        const filePath = path.join(basePath, pattern);
+        return FileUtils.exists(filePath) ? [filePath] : [];
+      }
+
+      // 简单的通配符支持
+      const files = FileUtils.listDirectory(basePath, { recursive: true });
+      const regex = new RegExp(
+        pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
+      );
+
+      return files.filter((file) => {
+        // 将路径分隔符统一为 /，确保在 Windows 上也能正确匹配
+        const relativePath = path
+          .relative(basePath, file)
+          .split(path.sep)
+          .join("/");
+        return regex.test(relativePath);
+      });
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * 替换文件中的变量
+   */
+  private async replaceVariablesInFile(
+    filePath: string,
+    variables: Record<string, string>
+  ): Promise<void> {
+    try {
+      let content = FileUtils.readFile(filePath);
+      let hasChanges = false;
+
+      // 替换变量 {{VARIABLE_NAME}}
+      for (const [key, value] of Object.entries(variables)) {
+        const regex = new RegExp(`{{\\s*${key}\\s*}}`, "g");
+        if (regex.test(content)) {
+          content = content.replace(regex, value);
+          hasChanges = true;
+        }
+      }
+
+      // 如果有变更，写回文件
+      if (hasChanges) {
+        FileUtils.writeFile(filePath, content, { overwrite: true });
+      }
+    } catch (error) {
+      console.warn(
+        `替换文件变量失败 ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}