@xiaozhi-client/cli 1.9.4-beta.10

package/src/services/__tests__/DaemonManager.test.ts

@@ -0,0 +1,378 @@
+/**
+ * 守护进程管理服务单元测试
+ */
+
+import { ServiceError } from "@cli/errors/index.js";
+import type { ProcessManager } from "@cli/interfaces/Service.js";
+import consola from "consola";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { DaemonOptions } from "../DaemonManager";
+import { DaemonManagerImpl } from "../DaemonManager";
+
+// Mock 依赖
+const mockProcessManager: ProcessManager = {
+  getServiceStatus: vi.fn(),
+  killProcess: vi.fn(),
+  cleanupPidFile: vi.fn(),
+  isXiaozhiProcess: vi.fn(),
+  savePidInfo: vi.fn(),
+  gracefulKillProcess: vi.fn(),
+  processExists: vi.fn(),
+  cleanupContainerState: vi.fn(),
+  getProcessInfo: vi.fn(),
+  validatePidFile: vi.fn(),
+} as any;
+
+// Mock child_process
+const mockChild = {
+  pid: 1234,
+  stdout: { pipe: vi.fn() },
+  stderr: { pipe: vi.fn() },
+  on: vi.fn(),
+  unref: vi.fn(),
+  kill: vi.fn(),
+};
+
+vi.mock("node:child_process", () => ({
+  spawn: vi.fn(() => mockChild),
+}));
+
+// Mock fs
+vi.mock("node:fs", () => ({
+  default: {
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    createWriteStream: vi.fn(() => ({
+      write: vi.fn(),
+    })),
+  },
+}));
+
+// Mock utils
+vi.mock("@cli/utils/PathUtils.js", () => ({
+  PathUtils: {
+    getWebServerLauncherPath: vi.fn(() => "/path/to/webserver.js"),
+    getConfigDir: vi.fn(() => "/config"),
+    getLogFile: vi.fn(() => "/logs/xiaozhi.log"),
+  },
+}));
+
+vi.mock("@cli/utils/PlatformUtils.js", () => ({
+  PlatformUtils: {
+    getTailCommand: vi.fn(() => ({
+      command: "tail",
+      args: ["-f", "/logs/xiaozhi.log"],
+    })),
+  },
+}));
+
+describe("DaemonManagerImpl", () => {
+  let daemonManager: DaemonManagerImpl;
+  const mockServerFactory = vi.fn();
+
+  beforeEach(() => {
+    daemonManager = new DaemonManagerImpl(mockProcessManager);
+
+    // Mock consola
+    vi.spyOn(consola, "info").mockImplementation(() => consola);
+    vi.spyOn(consola, "warn").mockImplementation(() => consola);
+    vi.spyOn(consola, "error").mockImplementation(() => consola);
+
+    // 重置所有 mock
+    vi.clearAllMocks();
+
+    // 设置默认 mock 返回值
+    (mockProcessManager.getServiceStatus as any).mockReturnValue({
+      running: false,
+    });
+    mockChild.on.mockImplementation((event, callback) => {
+      // 不立即调用回调，让测试控制
+      return mockChild;
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("startDaemon", () => {
+    it("should throw error if daemon is already running", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: true,
+        pid: 1234,
+      });
+
+      await expect(
+        daemonManager.startDaemon(mockServerFactory)
+      ).rejects.toThrow(ServiceError);
+    });
+
+    it("should start daemon successfully", async () => {
+      const { spawn } = await import("node:child_process");
+
+      await daemonManager.startDaemon(mockServerFactory);
+
+      expect(spawn).toHaveBeenCalledWith("node", ["/path/to/webserver.js"], {
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: expect.objectContaining({
+          XIAOZHI_CONFIG_DIR: "/config",
+          XIAOZHI_DAEMON: "true",
+        }),
+        cwd: process.cwd(),
+      });
+
+      expect(mockProcessManager.savePidInfo).toHaveBeenCalledWith(
+        1234,
+        "daemon"
+      );
+      expect(mockChild.unref).toHaveBeenCalled();
+      expect(consola.info).toHaveBeenCalledWith("守护进程已启动 (PID: 1234)");
+    });
+
+    it("should start daemon with options", async () => {
+      const options: DaemonOptions = {
+        openBrowser: true,
+        env: { CUSTOM_VAR: "value" },
+        cwd: "/custom/cwd",
+      };
+
+      const { spawn } = await import("node:child_process");
+
+      await daemonManager.startDaemon(mockServerFactory, options);
+
+      expect(spawn).toHaveBeenCalledWith(
+        "node",
+        ["/path/to/webserver.js", "--open-browser"],
+        {
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: expect.objectContaining({
+            XIAOZHI_CONFIG_DIR: "/config",
+            XIAOZHI_DAEMON: "true",
+            CUSTOM_VAR: "value",
+          }),
+          cwd: "/custom/cwd",
+        }
+      );
+    });
+
+    it("should setup logging", async () => {
+      const fs = await import("node:fs");
+      const mockLogStream = { write: vi.fn() };
+      (fs.default.createWriteStream as any).mockReturnValue(mockLogStream);
+
+      await daemonManager.startDaemon(mockServerFactory);
+
+      expect(fs.default.createWriteStream).toHaveBeenCalledWith(
+        "/logs/xiaozhi.log",
+        { flags: "a" }
+      );
+      expect(mockChild.stdout.pipe).toHaveBeenCalledWith(mockLogStream);
+      expect(mockChild.stderr.pipe).toHaveBeenCalledWith(mockLogStream);
+      expect(mockLogStream.write).toHaveBeenCalledWith(
+        expect.stringContaining("守护进程启动 (PID: 1234)")
+      );
+    });
+
+    it("should setup event handlers", async () => {
+      await daemonManager.startDaemon(mockServerFactory);
+
+      expect(mockChild.on).toHaveBeenCalledWith("exit", expect.any(Function));
+      expect(mockChild.on).toHaveBeenCalledWith("error", expect.any(Function));
+      expect(mockChild.on).toHaveBeenCalledWith(
+        "disconnect",
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe("stopDaemon", () => {
+    it("should throw error if daemon is not running", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: false,
+      });
+
+      await expect(daemonManager.stopDaemon()).rejects.toThrow(ServiceError);
+    });
+
+    it("should stop daemon successfully", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: true,
+        pid: 1234,
+      });
+
+      await daemonManager.stopDaemon();
+
+      expect(mockProcessManager.gracefulKillProcess).toHaveBeenCalledWith(1234);
+      expect(mockProcessManager.cleanupPidFile).toHaveBeenCalled();
+      expect(consola.info).toHaveBeenCalledWith("守护进程已停止");
+    });
+
+    it("should handle stop errors", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: true,
+        pid: 1234,
+      });
+      (mockProcessManager.gracefulKillProcess as any).mockRejectedValue(
+        new Error("Kill failed")
+      );
+
+      await expect(daemonManager.stopDaemon()).rejects.toThrow(ServiceError);
+    });
+  });
+
+  describe("restartDaemon", () => {
+    it("should restart daemon", async () => {
+      // Mock running daemon - restartDaemon() calls getServiceStatus(), then stopDaemon() calls getServiceStatus() again
+      (mockProcessManager.getServiceStatus as any)
+        .mockReturnValueOnce({ running: true, pid: 1234 }) // restartDaemon() check
+        .mockReturnValueOnce({ running: true, pid: 1234 }) // stopDaemon() check
+        .mockReturnValueOnce({ running: false }); // after stop
+
+      // Mock gracefulKillProcess to resolve successfully
+      (mockProcessManager.gracefulKillProcess as any).mockResolvedValue(
+        undefined
+      );
+
+      await daemonManager.restartDaemon(mockServerFactory);
+
+      expect(mockProcessManager.gracefulKillProcess).toHaveBeenCalledWith(1234);
+      expect(mockProcessManager.cleanupPidFile).toHaveBeenCalled();
+      expect(mockProcessManager.savePidInfo).toHaveBeenCalledWith(
+        1234,
+        "daemon"
+      );
+    });
+
+    it("should start daemon if not running", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: false,
+      });
+
+      await daemonManager.restartDaemon(mockServerFactory);
+
+      expect(mockProcessManager.gracefulKillProcess).not.toHaveBeenCalled();
+      expect(mockProcessManager.savePidInfo).toHaveBeenCalledWith(
+        1234,
+        "daemon"
+      );
+    });
+  });
+
+  describe("getDaemonStatus", () => {
+    it("should delegate to process manager", () => {
+      const expectedStatus = { running: true, pid: 1234, uptime: "1分钟" };
+      (mockProcessManager.getServiceStatus as any).mockReturnValue(
+        expectedStatus
+      );
+
+      const status = daemonManager.getDaemonStatus();
+
+      expect(status).toEqual(expectedStatus);
+      expect(mockProcessManager.getServiceStatus).toHaveBeenCalled();
+    });
+  });
+
+  describe("attachToLogs", () => {
+    it("should throw error if log file does not exist", async () => {
+      const fs = await import("node:fs");
+      (fs.default.existsSync as any).mockReturnValue(false);
+
+      await expect(daemonManager.attachToLogs()).rejects.toThrow(ServiceError);
+    });
+
+    it("should attach to logs successfully", async () => {
+      const fs = await import("node:fs");
+      const { spawn } = await import("node:child_process");
+
+      (fs.default.existsSync as any).mockReturnValue(true);
+
+      await daemonManager.attachToLogs();
+
+      expect(spawn).toHaveBeenCalledWith("tail", ["-f", "/logs/xiaozhi.log"], {
+        stdio: "inherit",
+      });
+    });
+  });
+
+  describe("checkHealth", () => {
+    it("should return false if daemon is not running", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: false,
+      });
+
+      const isHealthy = await daemonManager.checkHealth();
+
+      expect(isHealthy).toBe(false);
+    });
+
+    it("should return true if daemon is healthy", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: true,
+        pid: 1234,
+      });
+      (mockProcessManager.getProcessInfo as any).mockReturnValue({
+        exists: true,
+        isXiaozhi: true,
+      });
+
+      const isHealthy = await daemonManager.checkHealth();
+
+      expect(isHealthy).toBe(true);
+    });
+
+    it("should return false if process is not xiaozhi", async () => {
+      (mockProcessManager.getServiceStatus as any).mockReturnValue({
+        running: true,
+        pid: 1234,
+      });
+      (mockProcessManager.getProcessInfo as any).mockReturnValue({
+        exists: true,
+        isXiaozhi: false,
+      });
+
+      const isHealthy = await daemonManager.checkHealth();
+
+      expect(isHealthy).toBe(false);
+    });
+  });
+
+  describe("cleanup", () => {
+    it("should cleanup current daemon", async () => {
+      // Start a daemon first
+      await daemonManager.startDaemon(mockServerFactory);
+
+      daemonManager.cleanup();
+
+      expect(mockChild.kill).toHaveBeenCalledWith("SIGTERM");
+      expect(daemonManager.getCurrentDaemon()).toBeNull();
+    });
+
+    it("should handle cleanup errors gracefully", async () => {
+      await daemonManager.startDaemon(mockServerFactory);
+      mockChild.kill.mockImplementation(() => {
+        throw new Error("Kill failed");
+      });
+
+      expect(() => daemonManager.cleanup()).not.toThrow();
+      expect(consola.warn).toHaveBeenCalled();
+    });
+
+    it("should do nothing if no current daemon", () => {
+      expect(() => daemonManager.cleanup()).not.toThrow();
+      expect(mockChild.kill).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("getCurrentDaemon", () => {
+    it("should return null initially", () => {
+      expect(daemonManager.getCurrentDaemon()).toBeNull();
+    });
+
+    it("should return current daemon after start", async () => {
+      await daemonManager.startDaemon(mockServerFactory);
+      expect(daemonManager.getCurrentDaemon()).toBe(mockChild);
+    });
+  });
+});

package/src/services/__tests__/DaemonMode.integration.test.ts

@@ -0,0 +1,321 @@
+import type { ServiceStartOptions } from "@cli/interfaces/Service.js";
+import { PathUtils } from "@cli/utils/PathUtils.js";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ServiceManagerImpl } from "../ServiceManager";
+
+// Mock external dependencies
+vi.mock("node:child_process", () => ({
+  spawn: vi.fn(),
+}));
+
+vi.mock("node:fs", () => ({
+  default: {
+    existsSync: vi.fn(),
+    createWriteStream: vi.fn(),
+    mkdirSync: vi.fn(),
+  },
+  existsSync: vi.fn(),
+  createWriteStream: vi.fn(),
+  mkdirSync: vi.fn(),
+}));
+
+vi.mock("@cli/utils/PathUtils.js", () => ({
+  PathUtils: {
+    getWebServerLauncherPath: vi.fn(),
+    getExecutablePath: vi.fn(),
+    getConfigDir: vi.fn(),
+    getLogFile: vi.fn(),
+    getMcpServerProxyPath: vi.fn(),
+  },
+}));
+
+// Mock process.exit
+const mockProcessExit = vi.spyOn(process, "exit").mockImplementation((code) => {
+  throw new Error(`process.exit unexpectedly called with "${code}"`);
+});
+
+// Mock console methods
+const mockConsoleLog = vi.spyOn(console, "log").mockImplementation(() => {});
+
+describe("Daemon 模式集成测试", () => {
+  let serviceManager: ServiceManagerImpl;
+  let mockProcessManager: any;
+
+  beforeEach(async () => {
+    // Reset all mocks but preserve implementations
+    mockProcessExit.mockClear();
+    mockConsoleLog.mockClear();
+
+    // Re-setup mock implementations
+    mockProcessExit.mockImplementation((code) => {
+      throw new Error(`process.exit unexpectedly called with "${code}"`);
+    });
+    mockConsoleLog.mockImplementation(() => {});
+
+    // Setup PathUtils mocks
+    vi.mocked(PathUtils.getWebServerLauncherPath).mockReturnValue(
+      "/test/WebServerLauncher.js"
+    );
+    vi.mocked(PathUtils.getExecutablePath).mockImplementation(
+      (name: string) => {
+        return `/test/${name}.js`;
+      }
+    );
+    vi.mocked(PathUtils.getConfigDir).mockReturnValue("/test/config");
+    vi.mocked(PathUtils.getLogFile).mockReturnValue("/test/logs/xiaozhi.log");
+
+    // Setup fs mocks
+    const fs = await import("node:fs");
+    vi.mocked(fs.default.existsSync).mockReturnValue(true);
+
+    // Setup ProcessManager mock
+    mockProcessManager = {
+      savePidInfo: vi.fn(),
+      cleanupPidFile: vi.fn(),
+      isServiceRunning: vi.fn().mockReturnValue(false),
+      getServiceStatus: vi.fn().mockReturnValue({ running: false }),
+      stopService: vi.fn(),
+      cleanupContainerState: vi.fn(),
+      killProcess: vi.fn(),
+      isXiaozhiProcess: vi.fn(),
+      gracefulKillProcess: vi.fn(),
+      processExists: vi.fn(),
+      getProcessInfo: vi.fn(),
+      validatePidFile: vi.fn(),
+    };
+
+    // Setup ConfigManager mock
+    const mockConfigManager = {
+      configExists: vi.fn().mockReturnValue(true),
+      getConfig: vi.fn().mockReturnValue({ webServer: { port: 9999 } }),
+    } as any;
+
+    serviceManager = new ServiceManagerImpl(
+      mockProcessManager,
+      mockConfigManager
+    );
+  });
+
+  afterEach(() => {
+    // Don't restore mocks to preserve spy functionality
+    // vi.restoreAllMocks();
+  });
+
+  describe("WebServer Daemon 模式", () => {
+    it("应完成完整的 daemon 启动工作流程", async () => {
+      const { spawn } = await import("node:child_process");
+      const mockSpawn = vi.mocked(spawn);
+
+      const mockChild = {
+        pid: 12345,
+        unref: vi.fn(),
+        stdout: null,
+        stderr: null,
+      };
+      mockSpawn.mockReturnValue(mockChild as any);
+
+      const options: ServiceStartOptions = {
+        daemon: true,
+        mode: "normal",
+        port: 3000,
+      };
+
+      // Execute daemon start
+      await expect(serviceManager.start(options)).rejects.toThrow(
+        "process.exit unexpectedly called"
+      );
+
+      // Verify complete workflow
+      expect(PathUtils.getWebServerLauncherPath).toHaveBeenCalled();
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "node",
+        ["/test/WebServerLauncher.js"],
+        {
+          detached: true,
+          stdio: ["ignore", "ignore", "ignore"],
+          env: expect.objectContaining({
+            XIAOZHI_CONFIG_DIR: "/test/config",
+            XIAOZHI_DAEMON: "true",
+          }),
+        }
+      );
+      expect(mockProcessManager.savePidInfo).toHaveBeenCalledWith(
+        12345,
+        "daemon"
+      );
+      expect(mockChild.unref).toHaveBeenCalled();
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        "✅ 后台服务已启动 (PID: 12345)"
+      );
+      expect(mockProcessExit).toHaveBeenCalledWith(0);
+    });
+
+    it("应处理默认 daemon 启动", async () => {
+      const { spawn } = await import("node:child_process");
+      const mockSpawn = vi.mocked(spawn);
+
+      const mockChild = {
+        pid: 12346,
+        unref: vi.fn(),
+      };
+      mockSpawn.mockReturnValue(mockChild as any);
+
+      const options: ServiceStartOptions = {
+        daemon: true,
+        mode: "normal",
+        port: 3000,
+      };
+
+      await expect(serviceManager.start(options)).rejects.toThrow(
+        "process.exit unexpectedly called"
+      );
+
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "node",
+        ["/test/WebServerLauncher.js"],
+        {
+          detached: true,
+          stdio: ["ignore", "ignore", "ignore"],
+          env: expect.objectContaining({
+            XIAOZHI_CONFIG_DIR: "/test/config",
+            XIAOZHI_DAEMON: "true",
+          }),
+        }
+      );
+    });
+  });
+
+  describe("MCP Server Daemon 模式", () => {
+    it("应完成完整的 MCP daemon 启动工作流程", async () => {
+      // Re-setup console.log mock for this specific test
+      mockConsoleLog.mockClear();
+      mockConsoleLog.mockImplementation(() => {});
+
+      const { spawn } = await import("node:child_process");
+      const mockSpawn = vi.mocked(spawn);
+
+      const mockChild = {
+        pid: 54321,
+        unref: vi.fn(),
+      };
+      mockSpawn.mockReturnValue(mockChild as any);
+
+      const options: ServiceStartOptions = {
+        daemon: true,
+        mode: "mcp-server",
+        port: 4000,
+      };
+
+      // Execute daemon start
+      await expect(serviceManager.start(options)).rejects.toThrow(
+        "process.exit unexpectedly called"
+      );
+
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "node",
+        ["/test/cli.js", "start", "--server", "4000"],
+        {
+          detached: true,
+          stdio: ["ignore", "ignore", "ignore"],
+          env: expect.objectContaining({
+            XIAOZHI_CONFIG_DIR: "/test/config",
+            XIAOZHI_DAEMON: "true",
+            MCP_SERVER_MODE: "true",
+          }),
+        }
+      );
+      expect(mockProcessManager.savePidInfo).toHaveBeenCalledWith(
+        54321,
+        "daemon"
+      );
+      expect(mockChild.unref).toHaveBeenCalled();
+
+      // Verify console.log was called with the success message
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        "✅ MCP Server 已在后台启动 (PID: 54321, Port: 4000)"
+      );
+    });
+  });
+
+  describe("错误处理", () => {
+    it("应处理缺失的 WebServer 文件", async () => {
+      const fs = await import("node:fs");
+      vi.mocked(fs.default.existsSync).mockReturnValue(false);
+
+      const options: ServiceStartOptions = {
+        daemon: true,
+        mode: "normal",
+        port: 3000,
+      };
+
+      await expect(serviceManager.start(options)).rejects.toThrow(
+        "WebServer 文件不存在: /test/WebServerLauncher.js"
+      );
+
+      // Should not attempt to spawn or exit
+      expect(mockProcessExit).not.toHaveBeenCalled();
+    });
+
+    it("应处理 spawn 错误", async () => {
+      const { spawn } = await import("node:child_process");
+      const mockSpawn = vi.mocked(spawn);
+
+      mockSpawn.mockImplementation(() => {
+        throw new Error("Spawn failed");
+      });
+
+      const options: ServiceStartOptions = {
+        daemon: true,
+        mode: "normal",
+        port: 3000,
+      };
+
+      await expect(serviceManager.start(options)).rejects.toThrow(
+        "Spawn failed"
+      );
+      expect(mockProcessExit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("进程分离", () => {
+    it("应确保完全的进程分离", async () => {
+      const { spawn } = await import("node:child_process");
+      const mockSpawn = vi.mocked(spawn);
+
+      const mockChild = {
+        pid: 99999,
+        unref: vi.fn(),
+        stdout: { pipe: vi.fn() },
+        stderr: { pipe: vi.fn() },
+      };
+      mockSpawn.mockReturnValue(mockChild as any);
+
+      const options: ServiceStartOptions = {
+        daemon: true,
+        mode: "normal",
+        port: 3000,
+      };
+
+      await expect(serviceManager.start(options)).rejects.toThrow(
+        "process.exit unexpectedly called"
+      );
+
+      // Verify stdio is completely ignored (no piping)
+      expect(mockChild.stdout.pipe).not.toHaveBeenCalled();
+      expect(mockChild.stderr.pipe).not.toHaveBeenCalled();
+
+      // Verify process is detached and unreferenced
+      const spawnCall = mockSpawn.mock.calls[0];
+      expect(spawnCall[2]).toEqual(
+        expect.objectContaining({
+          detached: true,
+          stdio: ["ignore", "ignore", "ignore"],
+        })
+      );
+      expect(mockChild.unref).toHaveBeenCalled();
+
+      // Note: process.exit is called but the test catches the error
+      // The fact that we reach this point means the daemon setup worked correctly
+    });
+  });
+});