@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

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

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview EventSourceComponent Process Cleanup Tests
+ *
+ * TDD: 测试进程清理功能 - 确保停止时杀死所有相关进程（包括 fork 的子进程）
+ *
+ * 跨平台方案：启动时记录相关进程 PID 列表，停止时逐个杀死
+ */
+export {};
+//# sourceMappingURL=event-source-component.process-cleanup.test.d.ts.map

package/dist/core/src/env/event-source/event-source-component.process-cleanup.test.js

@@ -0,0 +1,207 @@
+/**
+ * @fileoverview EventSourceComponent Process Cleanup Tests
+ *
+ * TDD: 测试进程清理功能 - 确保停止时杀死所有相关进程（包括 fork 的子进程）
+ *
+ * 跨平台方案：启动时记录相关进程 PID 列表，停止时逐个杀死
+ */
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { EventSourceComponent } from "./event-source-component.js";
+import { ConfigComponent } from "../../config/config-component.js";
+// Mock process.kill
+const mockProcessKill = vi.fn((pid, signal) => {
+    return true;
+});
+// Mock spawn with proper chaining
+const mockSpawnKill = vi.fn((signal) => true);
+const mockExitCallbacks = [];
+vi.mock("child_process", () => ({
+    spawn: vi.fn(() => ({
+        pid: 12345,
+        pgid: 12340,
+        on: vi.fn((event, cb) => {
+            if (event === "exit") {
+                mockExitCallbacks.push(cb);
+            }
+            // 返回支持 once 链式调用的对象
+            return {
+                once: vi.fn((eventName, handler) => {
+                    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 }),
+    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;
+    let mockEnv;
+    let configComponent;
+    let originalKill;
+    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.persistenceEnabled = false;
+        component.sources.clear();
+        component.statuses.clear();
+        component.processes.clear();
+        component.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,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-source",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            await component.startSource("test-source");
+            // 验证进程信息结构
+            const processInfo = component.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,
+                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.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,
+                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,
+                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.findRelatedProcesses("lark-cli event");
+            // 验证返回的是数组
+            expect(Array.isArray(pids)).toBe(true);
+            // 注意：在真实环境中，pgrep 会返回实际的 PID 列表
+            // 在测试环境中，由于 mock，可能返回空数组或模拟值
+        });
+    });
+});
+//# sourceMappingURL=event-source-component.process-cleanup.test.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview EventSourceComponent stopSource Tests
+ *
+ * TDD: 测试 stopSource 方法的进程清理逻辑
+ */
+export {};
+//# sourceMappingURL=event-source-component.stop.test.d.ts.map

package/dist/core/src/env/event-source/event-source-component.stop.test.js

@@ -0,0 +1,293 @@
+/**
+ * @fileoverview EventSourceComponent stopSource Tests
+ *
+ * TDD: 测试 stopSource 方法的进程清理逻辑
+ */
+import { describe, test, expect, beforeEach, vi, afterEach } from "bun:test";
+import { EventSourceComponent, setExecAsync } from "./event-source-component.js";
+import { ConfigComponent } from "../../config/config-component.js";
+// Mock spawn with full control
+const mockKill = vi.fn();
+const mockProcessKill = vi.fn();
+const mockOnce = vi.fn();
+const mockOnceExit = [];
+const mockRemoveAllListeners = vi.fn();
+const mockStdoutRemoveAllListeners = vi.fn();
+const mockStderrRemoveAllListeners = vi.fn();
+vi.mock("child_process", () => ({
+    spawn: vi.fn(() => ({
+        on: vi.fn((event, cb) => {
+            if (event === "exit") {
+                mockOnceExit.push((event, cb) => 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 }),
+    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;
+    let mockEnv;
+    let 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) => {
+            return { stdout: "12345\n67890", stderr: "" };
+        });
+        component = new EventSourceComponent();
+        configComponent = new ConfigComponent();
+        component.persistenceEnabled = false;
+        component.sources.clear();
+        component.statuses.clear();
+        component.processes.clear();
+        component.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,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-source",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            await component.startSource("test-source");
+            // 验证进程已启动
+            expect(component.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,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-source",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            await component.startSource("test-source");
+            // 模拟进程在 SIGTERM 后退出
+            mockOnce.mockImplementation((event, cb) => {
+                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,
+                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, cb) => {
+                // 不调用 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,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-source",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            await component.startSource("test-source");
+            // 验证进程在 map 中
+            expect(component.processes.has("test-source")).toBe(true);
+            // 模拟进程退出
+            mockOnce.mockImplementation((event, cb) => {
+                if (event === "exit") {
+                    setTimeout(() => cb(0), 10);
+                }
+                return { once: mockOnce };
+            });
+            await component.stopSource("test-source");
+            // 验证进程已从 map 中删除
+            expect(component.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,
+                options: { configComponent },
+            });
+            component.register({
+                id: "timer-source",
+                name: "Timer Source",
+                type: "timer",
+                enabled: true,
+                interval: 1000,
+            });
+            await component.startSource("timer-source");
+            // 验证定时器在 map 中
+            expect(component.timers.has("timer-source")).toBe(true);
+            await component.stopSource("timer-source");
+            // 验证定时器已从 map 中删除
+            expect(component.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,
+                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,
+                options: { configComponent },
+            });
+            component.register({
+                id: "stopped-source",
+                name: "Stopped Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            // 先启动
+            mockOnce.mockImplementation((event, cb) => {
+                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();
+        });
+    });
+});
+//# sourceMappingURL=event-source-component.stop.test.js.map

package/dist/core/src/env/event-source/event-source-component.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-source-component.test.d.ts.map