@ai-setting/roy-agent-core 1.0.0

package/src/env/event-source/event-source-component.process-cleanup.test.ts

@@ -0,0 +1,236 @@
+/**
+ * @fileoverview EventSourceComponent Process Cleanup Tests
+ * 
+ * TDD: 测试进程清理功能 - 确保停止时杀死所有相关进程（包括 fork 的子进程）
+ * 
+ * 跨平台方案：启动时记录相关进程 PID 列表，停止时逐个杀死
+ */
+
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { EventSourceComponent } from "./event-source-component";
+import { ConfigComponent } from "../../config/config-component";
+import type { Environment } from "../interface";
+
+// Mock process.kill
+const mockProcessKill = vi.fn((pid: number | string, signal?: string) => {
+  return true;
+});
+
+// Mock spawn with proper chaining
+const mockSpawnKill = vi.fn((signal?: string) => true);
+const mockExitCallbacks: Function[] = [];
+
+vi.mock("child_process", () => ({
+  spawn: vi.fn(() => ({
+    pid: 12345,
+    pgid: 12340,
+    on: vi.fn((event: string, cb: Function) => {
+      if (event === "exit") {
+        mockExitCallbacks.push(cb);
+      }
+      // 返回支持 once 链式调用的对象
+      return {
+        once: vi.fn((eventName: string, handler: Function) => {
+          return { once: vi.fn() };
+        }),
+      };
+    }),
+    stdout: { on: vi.fn(), removeAllListeners: vi.fn() },
+    stderr: { on: vi.fn(), removeAllListeners: vi.fn() },
+    removeAllListeners: vi.fn(),
+    kill: mockSpawnKill,
+  })),
+  exec: vi.fn(),
+}));
+
+// 创建 Mock Environment
+const createMockEnv = () => ({
+  name: "mock-env",
+  version: "1.0.0",
+  getConfig: () => ({ name: "mock-env", version: "1.0.0", enabled: true, env: null as any }),
+  registerComponent: () => {},
+  unregisterComponent: () => {},
+  getComponent: vi.fn(() => undefined),
+  hasComponent: vi.fn(() => false),
+  listComponents: () => [],
+  handle_query: async () => "",
+  handle_action: async () => ({ success: true, output: "" }),
+  subscribe: vi.fn(() => () => {}),
+  subscribeTo: vi.fn(() => () => {}),
+  subscribeAll: vi.fn(() => () => {}),
+  pushEnvEvent: vi.fn(),
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+  trace: vi.fn(),
+});
+
+describe("EventSourceComponent Process Cleanup - TDD (精确 PID 方案)", () => {
+  let component: EventSourceComponent;
+  let mockEnv: ReturnType<typeof createMockEnv>;
+  let configComponent: ConfigComponent;
+  let originalKill: typeof process.kill;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockProcessKill.mockClear();
+    mockSpawnKill.mockClear();
+    mockExitCallbacks.length = 0;
+    
+    originalKill = process.kill.bind(process);
+    Object.defineProperty(process, "kill", {
+      value: mockProcessKill,
+      writable: true,
+      configurable: true,
+    });
+    
+    component = new EventSourceComponent();
+    configComponent = new ConfigComponent();
+    (component as any).persistenceEnabled = false;
+    (component as any).sources.clear();
+    (component as any).statuses.clear();
+    (component as any).processes.clear();
+    (component as any).timers.clear();
+    mockEnv = createMockEnv();
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, "kill", {
+      value: originalKill,
+      writable: true,
+      configurable: true,
+    });
+    vi.restoreAllMocks();
+  });
+
+  describe("进程信息存储结构", () => {
+    test("GREEN: 启动时应存储进程信息包含 pid, pgid, pids 数组", async () => {
+      /**
+       * GREEN: 验证进程信息结构正确
+       */
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      await component.startSource("test-source");
+
+      // 验证进程信息结构
+      const processInfo = (component as any).processes.get("test-source");
+      expect(processInfo).toBeDefined();
+      // child 对象包含 pid
+      expect(processInfo.child).toBeDefined();
+      expect(processInfo.child.pid).toBe(12345);
+      expect(processInfo.pgid).toBe(12340);
+      expect(processInfo.pids).toBeDefined();
+      expect(Array.isArray(processInfo.pids)).toBe(true);
+    });
+
+    test("GREEN: 应存储 command 用于后续查找相关进程", async () => {
+      /**
+       * GREEN: 验证 command 被存储
+       */
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+        command: "lark-cli event +subscribe --quiet",
+      });
+
+      await component.startSource("test-source");
+
+      const processInfo = (component as any).processes.get("test-source");
+      expect(processInfo.command).toBe("lark-cli event +subscribe --quiet");
+    });
+  });
+
+  describe("错误处理", () => {
+    test("GREEN: stopSource 不应抛出错误即使 kill 失败", async () => {
+      /**
+       * GREEN: 即使 kill 失败，状态也应设置为 stopped
+       */
+      mockProcessKill.mockImplementation(() => {
+        throw new Error("Process not found");
+      });
+
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      await component.startSource("test-source");
+
+      // stopSource 不应抛出错误
+      await component.stopSource("test-source");
+      
+      expect(component.getEventSourceStatusById("test-source")).toBe("stopped");
+    });
+  });
+
+  describe("跨平台命令验证", () => {
+    test("RED: findRelatedProcesses 应根据平台使用不同命令", async () => {
+      /**
+       * RED: 验证 findRelatedProcesses 使用平台适配的命令
+       * 
+       * 实现应该在非 Windows 平台使用 pgrep
+       * 在 Windows 平台使用 PowerShell (Get-CimInstance)
+       */
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+        command: "lark-cli event +subscribe --quiet",
+      });
+
+      // 调用 findRelatedProcesses
+      const pids = await (component as any).findRelatedProcesses("lark-cli event");
+
+      // 验证返回的是数组
+      expect(Array.isArray(pids)).toBe(true);
+      
+      // 注意：在真实环境中，pgrep 会返回实际的 PID 列表
+      // 在测试环境中，由于 mock，可能返回空数组或模拟值
+    });
+  });
+});

package/src/env/event-source/event-source-component.stop.test.ts

@@ -0,0 +1,346 @@
+/**
+ * @fileoverview EventSourceComponent stopSource Tests
+ * 
+ * TDD: 测试 stopSource 方法的进程清理逻辑
+ */
+
+import { describe, test, expect, beforeEach, vi, afterEach } from "bun:test";
+import { EventSourceComponent, setExecAsync } from "./event-source-component";
+import { ConfigComponent } from "../../config/config-component";
+import type { Environment } from "../interface";
+
+// Mock spawn with full control
+const mockKill = vi.fn();
+const mockProcessKill = vi.fn();
+const mockOnce = vi.fn();
+const mockOnceExit: ((event: string, cb: Function) => any)[] = [];
+const mockRemoveAllListeners = vi.fn();
+const mockStdoutRemoveAllListeners = vi.fn();
+const mockStderrRemoveAllListeners = vi.fn();
+
+vi.mock("child_process", () => ({
+  spawn: vi.fn(() => ({
+    on: vi.fn((event: string, cb: Function) => {
+      if (event === "exit") {
+        mockOnceExit.push((event: string, cb: Function) => cb(0));
+        return { once: mockOnce };
+      }
+      return {};
+    }),
+    stdout: { 
+      on: vi.fn(),
+      removeAllListeners: mockStdoutRemoveAllListeners 
+    },
+    stderr: { 
+      on: vi.fn(),
+      removeAllListeners: mockStderrRemoveAllListeners 
+    },
+    removeAllListeners: mockRemoveAllListeners,
+    kill: mockKill,
+  })),
+}));
+
+// 创建 Mock Environment
+const createMockEnv = () => ({
+  name: "mock-env",
+  version: "1.0.0",
+  getConfig: () => ({ name: "mock-env", version: "1.0.0", enabled: true, env: null as any }),
+  registerComponent: () => {},
+  unregisterComponent: () => {},
+  getComponent: vi.fn(() => undefined),
+  hasComponent: vi.fn(() => false),
+  listComponents: () => [],
+  handle_query: async () => "",
+  handle_action: async () => ({ success: true, output: "" }),
+  subscribe: vi.fn(() => () => {}),
+  subscribeTo: vi.fn(() => () => {}),
+  subscribeAll: vi.fn(() => () => {}),
+  pushEnvEvent: vi.fn(),
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+  trace: vi.fn(),
+});
+
+describe("EventSourceComponent stopSource", () => {
+  let component: EventSourceComponent;
+  let mockEnv: ReturnType<typeof createMockEnv>;
+  let configComponent: ConfigComponent;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockOnceExit.length = 0;
+    mockProcessKill.mockClear();
+    
+    // Mock process.kill
+    Object.defineProperty(process, "kill", {
+      value: mockProcessKill,
+      writable: true,
+      configurable: true,
+    });
+    
+    // Mock execAsync to return process IDs
+    setExecAsync(async (cmd: string) => {
+      return { stdout: "12345\n67890", stderr: "" };
+    });
+    
+    component = new EventSourceComponent();
+    configComponent = new ConfigComponent();
+    (component as any).persistenceEnabled = false;
+    (component as any).sources.clear();
+    (component as any).statuses.clear();
+    (component as any).processes.clear();
+    (component as any).timers.clear();
+    mockEnv = createMockEnv();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("should clean up event listeners", () => {
+    test("should remove all listeners from child process on stop", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      await component.startSource("test-source");
+      
+      // 验证进程已启动
+      expect((component as any).processes.has("test-source")).toBe(true);
+      
+      // 停止
+      await component.stopSource("test-source");
+      
+      // 验证 removeAllListeners 被调用（清理事件监听器）
+      expect(mockRemoveAllListeners).toHaveBeenCalledWith("exit");
+      expect(mockRemoveAllListeners).toHaveBeenCalledWith("error");
+      expect(mockStdoutRemoveAllListeners).toHaveBeenCalledWith("data");
+      expect(mockStderrRemoveAllListeners).toHaveBeenCalledWith("data");
+    });
+  });
+
+  describe("should send SIGTERM first for graceful shutdown", () => {
+    test("should send SIGTERM signal for graceful termination", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      await component.startSource("test-source");
+      
+      // 模拟进程在 SIGTERM 后退出
+      mockOnce.mockImplementation((event: string, cb: Function) => {
+        if (event === "exit") {
+          // 模拟进程收到 SIGTERM 后退出
+          setTimeout(() => cb(0), 10);
+        }
+        return { once: mockOnce };
+      });
+      
+      // 停止
+      await component.stopSource("test-source");
+      
+      // 验证先发送 SIGTERM（通过 process.kill）
+      expect(mockProcessKill).toHaveBeenCalled();
+      // 验证状态为 stopped
+      expect(component.getEventSourceStatusById("test-source")).toBe("stopped");
+    });
+  });
+
+  describe("should send SIGKILL after timeout if process doesn't exit", () => {
+    test("should send SIGKILL after 3 seconds if process doesn't exit gracefully", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      await component.startSource("test-source");
+      
+      // 模拟进程不响应 SIGTERM（never exits）
+      mockOnce.mockImplementation((event: string, cb: Function) => {
+        // 不调用 cb，模拟进程卡住
+        return { once: mockOnce };
+      });
+      
+      // 停止（应该等待 3 秒后发送 SIGKILL）
+      const stopPromise = component.stopSource("test-source");
+      
+      // 等待足够长的时间让超时触发（减少到 1 秒以避免测试框架超时）
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      await stopPromise;
+      
+      // 验证发送了 SIGTERM 和 SIGKILL（通过 process.kill）
+      expect(mockProcessKill).toHaveBeenCalled();
+      // 验证状态为 stopped
+      expect(component.getEventSourceStatusById("test-source")).toBe("stopped");
+    });
+  });
+
+  describe("should clean up all resources", () => {
+    test("should delete process from processes map after stop", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "test-source",
+        name: "Test Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      await component.startSource("test-source");
+      
+      // 验证进程在 map 中
+      expect((component as any).processes.has("test-source")).toBe(true);
+      
+      // 模拟进程退出
+      mockOnce.mockImplementation((event: string, cb: Function) => {
+        if (event === "exit") {
+          setTimeout(() => cb(0), 10);
+        }
+        return { once: mockOnce };
+      });
+      
+      await component.stopSource("test-source");
+      
+      // 验证进程已从 map 中删除
+      expect((component as any).processes.has("test-source")).toBe(false);
+    });
+
+    test("should clear timer for timer sources", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "timer-source",
+        name: "Timer Source",
+        type: "timer",
+        enabled: true,
+        interval: 1000,
+      });
+
+      await component.startSource("timer-source");
+      
+      // 验证定时器在 map 中
+      expect((component as any).timers.has("timer-source")).toBe(true);
+      
+      await component.stopSource("timer-source");
+      
+      // 验证定时器已从 map 中删除
+      expect((component as any).timers.has("timer-source")).toBe(false);
+      // 验证状态为 stopped
+      expect(component.getEventSourceStatusById("timer-source")).toBe("stopped");
+    });
+  });
+
+  describe("should handle non-running sources", () => {
+    test("should do nothing when source is not running", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "not-running",
+        name: "Not Running Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      // 状态是 created，没有启动过
+      await component.stopSource("not-running");
+      
+      // 验证没有调用 kill
+      expect(mockKill).not.toHaveBeenCalled();
+      // 验证状态仍是 created
+      expect(component.getEventSourceStatusById("not-running")).toBe("created");
+    });
+
+    test("should do nothing when source is already stopped", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        env: mockEnv as unknown as Environment,
+        options: { configComponent },
+      });
+
+      component.register({
+        id: "stopped-source",
+        name: "Stopped Source",
+        type: "lark-cli",
+        enabled: true,
+      });
+
+      // 先启动
+      mockOnce.mockImplementation((event: string, cb: Function) => {
+        if (event === "exit") {
+          setTimeout(() => cb(0), 10);
+        }
+        return { once: mockOnce };
+      });
+      await component.startSource("stopped-source");
+      
+      // 再停止
+      await component.stopSource("stopped-source");
+      expect(component.getEventSourceStatusById("stopped-source")).toBe("stopped");
+      
+      // 重置 mock
+      vi.clearAllMocks();
+      
+      // 再次停止（已经是 stopped）
+      await component.stopSource("stopped-source");
+      
+      // 验证 kill 没有被调用（因为已经是 stopped）
+      expect(mockKill).not.toHaveBeenCalled();
+    });
+  });
+});