@xiaozhi-client/cli 1.9.4-beta.10

package/src/interfaces/Service.ts

@@ -0,0 +1,99 @@
+/**
+ * 服务接口定义
+ */
+
+/**
+ * 服务管理器接口
+ */
+export interface ServiceManager {
+  /** 启动服务 */
+  start(options: ServiceStartOptions): Promise<void>;
+  /** 停止服务 */
+  stop(): Promise<void>;
+  /** 重启服务 */
+  restart(options: ServiceStartOptions): Promise<void>;
+  /** 获取服务状态 */
+  getStatus(): ServiceStatus;
+}
+
+/**
+ * 服务启动选项
+ */
+export interface ServiceStartOptions {
+  /** 是否后台运行 */
+  daemon?: boolean;
+  /** 是否启动 Web UI */
+  ui?: boolean;
+  /** 端口号 */
+  port?: number;
+  /** 运行模式 */
+  mode?: "normal" | "mcp-server" | "stdio";
+}
+
+/**
+ * 服务状态
+ */
+export interface ServiceStatus {
+  /** 是否正在运行 */
+  running: boolean;
+  /** 进程 ID */
+  pid?: number;
+  /** 运行时间 */
+  uptime?: string;
+  /** 运行模式 */
+  mode?: "foreground" | "daemon";
+}
+
+/**
+ * 进程管理器接口
+ */
+export interface ProcessManager {
+  /** 获取服务状态 */
+  getServiceStatus(): ServiceStatus;
+  /** 杀死进程 */
+  killProcess(pid: number): Promise<void>;
+  /** 清理 PID 文件 */
+  cleanupPidFile(): void;
+  /** 检查是否为 xiaozhi 进程 */
+  isXiaozhiProcess(pid: number): boolean;
+  /** 保存进程信息 */
+  savePidInfo(pid: number, mode: "foreground" | "daemon"): void;
+  /** 优雅停止进程 */
+  gracefulKillProcess(pid: number): Promise<void>;
+  /** 检查进程是否存在 */
+  processExists(pid: number): boolean;
+  /** 清理容器环境状态 */
+  cleanupContainerState(): void;
+  /** 获取进程信息 */
+  getProcessInfo(pid: number): { exists: boolean; isXiaozhi: boolean };
+  /** 验证 PID 文件完整性 */
+  validatePidFile(): boolean;
+}
+
+/**
+ * 守护进程管理器接口
+ */
+export interface DaemonManager {
+  /** 启动守护进程 */
+  startDaemon(serverFactory: () => Promise<any>): Promise<void>;
+  /** 停止守护进程 */
+  stopDaemon(): Promise<void>;
+}
+
+/**
+ * 模板管理器接口
+ */
+export interface TemplateManager {
+  /** 获取可用模板列表 */
+  getAvailableTemplates(): Promise<any[]>;
+  /** 复制模板到目标目录 */
+  copyTemplate(templateName: string, targetPath: string): Promise<void>;
+  /** 验证模板是否存在 */
+  validateTemplate(templateName: string): Promise<boolean>;
+  /** 获取模板信息 */
+  getTemplateInfo(templateName: string): Promise<any | null>;
+  /** 创建项目 */
+  createProject(options: any): Promise<void>;
+  /** 清除模板缓存 */
+  clearCache(): void;
+}

package/src/services/DaemonManager.ts

@@ -0,0 +1,318 @@
+/**
+ * 守护进程管理服务
+ */
+
+import type { ChildProcess } from "node:child_process";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import type { WebServer } from "@root/WebServer";
+import consola from "consola";
+import { ProcessError, ServiceError } from "../errors/index";
+import type {
+  DaemonManager as IDaemonManager,
+  ProcessManager,
+} from "../interfaces/Service";
+import { PathUtils } from "../utils/PathUtils";
+import { PlatformUtils } from "../utils/PlatformUtils";
+
+/**
+ * 守护进程选项
+ */
+export interface DaemonOptions {
+  /** 日志文件名 */
+  logFileName?: string;
+  /** 环境变量 */
+  env?: Record<string, string>;
+  /** 是否打开浏览器 */
+  openBrowser?: boolean;
+  /** 工作目录 */
+  cwd?: string;
+}
+
+/**
+ * 守护进程管理器实现
+ */
+export class DaemonManagerImpl implements IDaemonManager {
+  private currentDaemon: ChildProcess | null = null;
+
+  constructor(private processManager: ProcessManager) {}
+
+  /**
+   * 启动守护进程
+   */
+  async startDaemon(
+    serverFactory: () => Promise<WebServer>,
+    options: DaemonOptions = {}
+  ): Promise<void> {
+    try {
+      // 检查是否已有守护进程在运行
+      const status = this.processManager.getServiceStatus();
+      if (status.running) {
+        throw ServiceError.alreadyRunning(status.pid!);
+      }
+
+      // 启动守护进程
+      const child = await this.spawnDaemonProcess(serverFactory, options);
+      this.currentDaemon = child;
+
+      // 保存 PID 信息
+      this.processManager.savePidInfo(child.pid!, "daemon");
+
+      // 设置日志重定向
+      await this.setupLogging(child, options.logFileName || "xiaozhi.log");
+
+      // 设置进程事件监听
+      this.setupEventHandlers(child);
+
+      // 分离进程
+      child.unref();
+
+      consola.info(`守护进程已启动 (PID: ${child.pid})`);
+    } catch (error) {
+      throw new ServiceError(
+        `启动守护进程失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 停止守护进程
+   */
+  async stopDaemon(): Promise<void> {
+    try {
+      const status = this.processManager.getServiceStatus();
+
+      if (!status.running) {
+        throw ServiceError.notRunning();
+      }
+
+      // 优雅停止守护进程
+      await this.processManager.gracefulKillProcess(status.pid!);
+
+      // 清理 PID 文件
+      this.processManager.cleanupPidFile();
+
+      // 清理当前守护进程引用
+      this.currentDaemon = null;
+
+      consola.info("守护进程已停止");
+    } catch (error) {
+      throw new ServiceError(
+        `停止守护进程失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 重启守护进程
+   */
+  async restartDaemon(
+    serverFactory: () => Promise<WebServer>,
+    options: DaemonOptions = {}
+  ): Promise<void> {
+    try {
+      // 先停止现有守护进程
+      const status = this.processManager.getServiceStatus();
+      if (status.running) {
+        await this.stopDaemon();
+        // 等待一下确保完全停止
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+
+      // 重新启动守护进程
+      await this.startDaemon(serverFactory, options);
+    } catch (error) {
+      throw new ServiceError(
+        `重启守护进程失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 获取守护进程状态
+   */
+  getDaemonStatus(): { running: boolean; pid?: number; uptime?: string } {
+    return this.processManager.getServiceStatus();
+  }
+
+  /**
+   * 连接到守护进程日志
+   */
+  async attachToLogs(logFileName = "xiaozhi.log"): Promise<void> {
+    try {
+      const logFilePath = PathUtils.getLogFile();
+
+      if (!fs.existsSync(logFilePath)) {
+        throw new ServiceError("日志文件不存在");
+      }
+
+      // 使用平台相关的 tail 命令
+      const { command, args } = PlatformUtils.getTailCommand(logFilePath);
+      const tail = spawn(command, args, { stdio: "inherit" });
+
+      // 处理中断信号
+      process.on("SIGINT", () => {
+        console.log("\n断开连接，服务继续在后台运行");
+        tail.kill();
+        process.exit(0);
+      });
+
+      tail.on("exit", () => {
+        process.exit(0);
+      });
+
+      tail.on("error", (error) => {
+        throw new ServiceError(`连接日志失败: ${error.message}`);
+      });
+    } catch (error) {
+      throw new ServiceError(
+        `连接日志失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 生成守护进程
+   */
+  private async spawnDaemonProcess(
+    serverFactory: () => Promise<WebServer>,
+    options: DaemonOptions
+  ): Promise<ChildProcess> {
+    // 获取启动脚本路径
+    const scriptPath = PathUtils.getWebServerLauncherPath();
+
+    // 构建启动参数
+    const args = [scriptPath];
+    if (options.openBrowser) {
+      args.push("--open-browser");
+    }
+
+    // 构建环境变量
+    const env = {
+      ...process.env,
+      XIAOZHI_CONFIG_DIR: PathUtils.getConfigDir(),
+      XIAOZHI_DAEMON: "true",
+      ...options.env,
+    };
+
+    // 启动子进程
+    const child = spawn("node", args, {
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      cwd: options.cwd || process.cwd(),
+    });
+
+    if (!child.pid) {
+      throw new ProcessError("无法启动守护进程", 0);
+    }
+
+    return child;
+  }
+
+  /**
+   * 设置日志重定向
+   */
+  private async setupLogging(
+    child: ChildProcess,
+    logFileName: string
+  ): Promise<void> {
+    try {
+      const logFilePath = PathUtils.getLogFile();
+
+      // 确保日志目录存在
+      const path = await import("node:path");
+      const logDir = path.dirname(logFilePath);
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+
+      // 创建日志流
+      const logStream = fs.createWriteStream(logFilePath, { flags: "a" });
+
+      // 重定向标准输出和错误输出
+      child.stdout?.pipe(logStream);
+      child.stderr?.pipe(logStream);
+
+      // 写入启动日志
+      const timestamp = new Date().toISOString();
+      logStream.write(`\n[${timestamp}] 守护进程启动 (PID: ${child.pid})\n`);
+    } catch (error) {
+      consola.warn(
+        `设置日志重定向失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  /**
+   * 设置事件处理器
+   */
+  private setupEventHandlers(child: ChildProcess): void {
+    // 监听进程退出
+    child.on("exit", (code, signal) => {
+      if (code !== 0 && code !== null) {
+        consola.error(`守护进程异常退出 (代码: ${code}, 信号: ${signal})`);
+      } else {
+        consola.info("守护进程正常退出");
+      }
+
+      // 清理 PID 文件
+      this.processManager.cleanupPidFile();
+      this.currentDaemon = null;
+    });
+
+    // 监听进程错误
+    child.on("error", (error) => {
+      consola.error(`守护进程错误: ${error.message}`);
+      this.processManager.cleanupPidFile();
+      this.currentDaemon = null;
+    });
+
+    // 监听进程断开连接
+    child.on("disconnect", () => {
+      consola.info("守护进程断开连接");
+    });
+  }
+
+  /**
+   * 检查守护进程健康状态
+   */
+  async checkHealth(): Promise<boolean> {
+    try {
+      const status = this.getDaemonStatus();
+
+      if (!status.running || !status.pid) {
+        return false;
+      }
+
+      // 检查进程是否真的在运行
+      const processInfo = this.processManager.getProcessInfo(status.pid);
+      return processInfo.exists && processInfo.isXiaozhi;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 获取当前守护进程引用
+   */
+  getCurrentDaemon(): ChildProcess | null {
+    return this.currentDaemon;
+  }
+
+  /**
+   * 清理守护进程资源
+   */
+  cleanup(): void {
+    if (this.currentDaemon) {
+      try {
+        this.currentDaemon.kill("SIGTERM");
+      } catch (error) {
+        consola.warn(
+          `清理守护进程失败: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      this.currentDaemon = null;
+    }
+  }
+}

package/src/services/ProcessManager.ts

@@ -0,0 +1,235 @@
+import { FileError, ProcessError } from "../errors/index";
+import type {
+  ProcessManager as IProcessManager,
+  ServiceStatus,
+} from "../interfaces/Service";
+import { FileUtils } from "../utils/FileUtils";
+import { FormatUtils } from "../utils/FormatUtils";
+import { PathUtils } from "../utils/PathUtils";
+import { PlatformUtils } from "../utils/PlatformUtils";
+
+/**
+ * PID 文件信息接口
+ */
+interface PidFileInfo {
+  pid: number;
+  startTime: number;
+  mode: "foreground" | "daemon";
+}
+
+/**
+ * 进程管理器实现
+ */
+export class ProcessManagerImpl implements IProcessManager {
+  /**
+   * 获取 PID 文件路径
+   */
+  private getPidFilePath(): string {
+    return PathUtils.getPidFile();
+  }
+
+  /**
+   * 读取 PID 文件信息
+   */
+  private readPidFile(): PidFileInfo | null {
+    try {
+      const pidFilePath = this.getPidFilePath();
+
+      if (!FileUtils.exists(pidFilePath)) {
+        return null;
+      }
+
+      const pidContent = FileUtils.readFile(pidFilePath).trim();
+      const [pidStr, startTimeStr, mode] = pidContent.split("|");
+
+      const pid = Number.parseInt(pidStr);
+      const startTime = Number.parseInt(startTimeStr);
+
+      if (Number.isNaN(pid) || Number.isNaN(startTime)) {
+        // PID 文件损坏，删除它
+        this.cleanupPidFile();
+        return null;
+      }
+
+      return {
+        pid,
+        startTime,
+        mode: (mode as "foreground" | "daemon") || "foreground",
+      };
+    } catch (error) {
+      // 读取失败，可能文件损坏
+      this.cleanupPidFile();
+      return null;
+    }
+  }
+
+  /**
+   * 写入 PID 文件信息
+   */
+  private writePidFile(pid: number, mode: "foreground" | "daemon"): void {
+    try {
+      const pidInfo = `${pid}|${Date.now()}|${mode}`;
+      const pidFilePath = this.getPidFilePath();
+      FileUtils.writeFile(pidFilePath, pidInfo, { overwrite: true });
+    } catch (error) {
+      throw new FileError("无法写入 PID 文件", this.getPidFilePath());
+    }
+  }
+
+  /**
+   * 检查是否为 xiaozhi 进程
+   */
+  isXiaozhiProcess(pid: number): boolean {
+    return PlatformUtils.isXiaozhiProcess(pid);
+  }
+
+  /**
+   * 获取服务状态
+   */
+  getServiceStatus(): ServiceStatus {
+    try {
+      const pidInfo = this.readPidFile();
+
+      if (!pidInfo) {
+        return { running: false };
+      }
+
+      // 检查进程是否还在运行且是 xiaozhi 进程
+      if (!this.isXiaozhiProcess(pidInfo.pid)) {
+        // 进程不存在或不是 xiaozhi 进程，删除 PID 文件
+        this.cleanupPidFile();
+        return { running: false };
+      }
+
+      // 计算运行时间
+      const uptime = FormatUtils.formatUptime(Date.now() - pidInfo.startTime);
+
+      return {
+        running: true,
+        pid: pidInfo.pid,
+        uptime,
+        mode: pidInfo.mode,
+      };
+    } catch (error) {
+      return { running: false };
+    }
+  }
+
+  /**
+   * 保存进程信息
+   */
+  savePidInfo(pid: number, mode: "foreground" | "daemon"): void {
+    this.writePidFile(pid, mode);
+  }
+
+  /**
+   * 杀死进程
+   */
+  async killProcess(pid: number): Promise<void> {
+    try {
+      await PlatformUtils.killProcess(pid);
+    } catch (error) {
+      throw new ProcessError(
+        `无法终止进程: ${error instanceof Error ? error.message : String(error)}`,
+        pid
+      );
+    }
+  }
+
+  /**
+   * 优雅停止进程
+   */
+  async gracefulKillProcess(pid: number): Promise<void> {
+    try {
+      // 尝试优雅停止
+      process.kill(pid, "SIGTERM");
+
+      // 等待进程停止
+      let attempts = 0;
+      const maxAttempts = 30; // 3秒超时
+
+      while (attempts < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+
+        try {
+          process.kill(pid, 0);
+          attempts++;
+        } catch {
+          // 进程已停止
+          return;
+        }
+      }
+
+      // 如果还在运行，强制停止
+      try {
+        process.kill(pid, 0);
+        process.kill(pid, "SIGKILL");
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      } catch {
+        // 进程已停止
+      }
+    } catch (error) {
+      throw new ProcessError(
+        `无法停止进程: ${error instanceof Error ? error.message : String(error)}`,
+        pid
+      );
+    }
+  }
+
+  /**
+   * 清理 PID 文件
+   */
+  cleanupPidFile(): void {
+    try {
+      const pidFilePath = this.getPidFilePath();
+      if (FileUtils.exists(pidFilePath)) {
+        FileUtils.deleteFile(pidFilePath);
+      }
+    } catch (error) {
+      // 忽略清理错误，但可以记录日志
+      console.warn("清理 PID 文件失败:", error);
+    }
+  }
+
+  /**
+   * 检查进程是否存在
+   */
+  processExists(pid: number): boolean {
+    return PlatformUtils.processExists(pid);
+  }
+
+  /**
+   * 清理容器环境的旧状态
+   */
+  cleanupContainerState(): void {
+    if (PlatformUtils.isContainerEnvironment()) {
+      try {
+        this.cleanupPidFile();
+      } catch (error) {
+        // 忽略清理错误
+      }
+    }
+  }
+
+  /**
+   * 获取进程信息
+   */
+  getProcessInfo(pid: number): { exists: boolean; isXiaozhi: boolean } {
+    const exists = this.processExists(pid);
+    const isXiaozhi = exists ? this.isXiaozhiProcess(pid) : false;
+
+    return { exists, isXiaozhi };
+  }
+
+  /**
+   * 验证 PID 文件完整性
+   */
+  validatePidFile(): boolean {
+    try {
+      const pidInfo = this.readPidFile();
+      return pidInfo !== null;
+    } catch {
+      return false;
+    }
+  }
+}