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

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

@@ -0,0 +1,1036 @@
+import { describe, test, expect, beforeEach, vi } from "bun:test";
+import { EventSourceComponent } from "./event-source-component.js";
+import { ConfigComponent } from "../../config/config-component.js";
+// Mock spawn
+vi.mock("child_process", () => ({
+    spawn: vi.fn(() => ({
+        on: vi.fn((event, cb) => {
+            if (event === "exit") {
+                // 模拟子进程退出
+            }
+        }),
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        kill: vi.fn(),
+    })),
+}));
+// 创建 Mock Environment（参考 tool-component.test.ts 的模式）
+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: vi.fn(),
+    trace: vi.fn(),
+});
+describe("EventSourceComponent", () => {
+    let component;
+    let mockEnv;
+    let configComponent;
+    beforeEach(() => {
+        component = new EventSourceComponent();
+        configComponent = new ConfigComponent();
+        // 禁用持久化，避免测试之间的干扰
+        component.persistenceEnabled = false;
+        component.sources.clear();
+        component.statuses.clear();
+        mockEnv = createMockEnv();
+    });
+    describe("constructor", () => {
+        test("should create instance with correct name and version", () => {
+            expect(component.name).toBe("event-source");
+            expect(component.version).toBe("1.0.0");
+        });
+    });
+    describe("init", () => {
+        test("should initialize and enable event handling", async () => {
+            // 初始化组件
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            // 注册事件源
+            component.register({
+                id: "test-1",
+                name: "Test Source",
+                type: "timer",
+                enabled: true,
+                eventTypes: ["*"],
+            });
+            // 验证可以设置处理器并接收事件
+            let eventReceived = false;
+            component.onEvent("test-1", () => {
+                eventReceived = true;
+            });
+            // 手动触发事件
+            component["handleEvent"]("test-1", JSON.stringify({
+                type: "test.event",
+                payload: { message: "hello" },
+            }));
+            expect(eventReceived).toBe(true);
+            expect(component.getEventSourceStatusById("test-1")).toBe("created");
+        });
+    });
+    describe("register", () => {
+        test("should register a new event source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "timer",
+                enabled: true,
+                interval: 1000,
+            };
+            component.register(config);
+            const retrieved = component.get("test-1");
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.name).toBe("Test Source");
+            expect(retrieved?.type).toBe("timer");
+        });
+        test("should throw error when registering duplicate id", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "timer",
+                enabled: true,
+            };
+            component.register(config);
+            expect(() => component.register(config)).toThrow("EventSource already exists: test-1");
+        });
+        test("should set initial status to created", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+            };
+            component.register(config);
+            expect(component.getEventSourceStatusById("test-1")).toBe("created");
+        });
+    });
+    describe("unregister", () => {
+        test("should unregister an existing event source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "timer",
+                enabled: true,
+            };
+            component.register(config);
+            const result = component.unregister("test-1");
+            expect(result).toBe(true);
+            expect(component.get("test-1")).toBeUndefined();
+        });
+        test("should return false for non-existent event source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const result = component.unregister("non-existent");
+            expect(result).toBe(false);
+        });
+    });
+    describe("list", () => {
+        test("should list all registered event sources", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-1",
+                name: "Source 1",
+                type: "timer",
+                enabled: true,
+            });
+            component.register({
+                id: "test-2",
+                name: "Source 2",
+                type: "lark-cli",
+                enabled: true,
+            });
+            const sources = component.list();
+            expect(sources).toHaveLength(2);
+        });
+        test("should return empty array when no sources registered", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const sources = component.list();
+            expect(sources).toHaveLength(0);
+        });
+    });
+    describe("getStatus", () => {
+        test("should return status for registered source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-1",
+                name: "Test Source",
+                type: "timer",
+                enabled: true,
+            });
+            expect(component.getEventSourceStatusById("test-1")).toBe("created");
+        });
+        test("should return undefined for non-existent source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            expect(component.getEventSourceStatusById("non-existent")).toBeUndefined();
+        });
+    });
+    describe("start", () => {
+        test("should start a timer event source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "timer-1",
+                name: "Timer Source",
+                type: "timer",
+                enabled: true,
+                interval: 100,
+            });
+            await component.startSource("timer-1");
+            // 等待一小段时间让定时器触发
+            await new Promise(resolve => setTimeout(resolve, 150));
+            expect(component.getEventSourceStatusById("timer-1")).toBe("running");
+        });
+        test("should throw error for non-existent source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            await expect(component.startSource("non-existent")).rejects.toThrow("EventSource not found: non-existent");
+        });
+        test("should not restart already running source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "timer-1",
+                name: "Timer Source",
+                type: "timer",
+                enabled: true,
+                interval: 10000,
+            });
+            await component.startSource("timer-1");
+            await component.startSource("timer-1"); // 重复启动
+            expect(component.getEventSourceStatusById("timer-1")).toBe("running");
+        });
+    });
+    describe("stop", () => {
+        test("should stop a running timer source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "timer-1",
+                name: "Timer Source",
+                type: "timer",
+                enabled: true,
+                interval: 10000,
+            });
+            await component.startSource("timer-1");
+            expect(component.getEventSourceStatusById("timer-1")).toBe("running");
+            await component.stopSource("timer-1");
+            expect(component.getEventSourceStatusById("timer-1")).toBe("stopped");
+        });
+        test("should do nothing when stopping non-running source", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "timer-1",
+                name: "Timer Source",
+                type: "timer",
+                enabled: true,
+                interval: 10000,
+            });
+            await component.stopSource("timer-1");
+            expect(component.getEventSourceStatusById("timer-1")).toBe("created");
+        });
+    });
+    describe("onEvent", () => {
+        test("should register event handler and receive events", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            // 先注册事件源
+            component.register({
+                id: "test-1",
+                name: "Test Source",
+                type: "timer",
+                enabled: true,
+                eventTypes: ["*"], // 接收所有事件
+            });
+            const handler = vi.fn();
+            component.onEvent("test-1", handler);
+            // 触发事件
+            component["handleEvent"]("test-1", JSON.stringify({
+                type: "test.event",
+                payload: { message: "hello" },
+            }));
+            expect(handler).toHaveBeenCalled();
+        });
+    });
+    describe("event type matching", () => {
+        test("should match exact event type", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+                eventTypes: ["lark.im.message.receive_v1"],
+            };
+            component.register(config);
+            let handlerCalled = false;
+            component.onEvent("test-1", () => {
+                handlerCalled = true;
+            });
+            // 匹配的事件（schema 会被转换为 lark.xxx 格式）
+            component["handleEvent"]("test-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                text: "hello",
+            }));
+            expect(handlerCalled).toBe(true);
+        });
+        test("should match wildcard event type", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+                eventTypes: ["lark.im.message.*"], // 通配符模式（schema 会被转换为 lark.xxx）
+            };
+            component.register(config);
+            let handlerCalled = false;
+            component.onEvent("test-1", () => {
+                handlerCalled = true;
+            });
+            // 匹配通配符（schema: "im.message.receive_v1" → type: "lark.im.message.receive_v1"）
+            component["handleEvent"]("test-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                text: "hello",
+            }));
+            expect(handlerCalled).toBe(true);
+        });
+        test("should not match non-matching event type", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+                eventTypes: ["im.message.receive_v1"],
+            };
+            component.register(config);
+            let handlerCalled = false;
+            component.onEvent("test-1", () => {
+                handlerCalled = true;
+            });
+            // 不匹配的事件
+            component["handleEvent"]("test-1", JSON.stringify({
+                schema: "contact.user.created",
+                text: "hello",
+            }));
+            expect(handlerCalled).toBe(false);
+        });
+        test("should match wildcard * for all events", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const config = {
+                id: "test-1",
+                name: "Test Source",
+                type: "timer",
+                enabled: true,
+                eventTypes: ["*"],
+            };
+            component.register(config);
+            let handlerCalled = false;
+            component.onEvent("test-1", () => {
+                handlerCalled = true;
+            });
+            component["handleEvent"]("test-1", JSON.stringify({
+                type: "any.event",
+            }));
+            expect(handlerCalled).toBe(true);
+        });
+    });
+    describe("message formatting", () => {
+        test("should format lark-cli event message", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedMessage = "";
+            component.onEvent("lark-1", (event) => {
+                receivedMessage = event.payload.message;
+            });
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                sender: { sender_id: { open_id: "user123" } },
+                text: "Hello, World!",
+            }));
+            expect(receivedMessage).toContain("飞书消息");
+            expect(receivedMessage).toContain("user123");
+            expect(receivedMessage).toContain("Hello, World!");
+        });
+        test("should format timer event message", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "timer-1",
+                name: "Timer Source",
+                type: "timer",
+                enabled: true,
+                interval: 10000,
+                options: { message: "每日检查" },
+            });
+            let receivedMessage = "";
+            component.onEvent("timer-1", (event) => {
+                receivedMessage = event.payload.message;
+            });
+            component["handleEvent"]("timer-1", JSON.stringify({
+                type: "timer.tick",
+                payload: {
+                    message: "每日检查",
+                    timestamp: Date.now(),
+                },
+            }));
+            expect(receivedMessage).toContain("定时任务");
+            expect(receivedMessage).toContain("每日检查");
+        });
+        test("should format lark-cli event with new format (header.event_type)", async () => {
+            // 测试 lark-cli 实际输出的新格式
+            // schema: "2.0", header.event_type: "im.message.receive_v1"
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedMessage = "";
+            component.onEvent("lark-1", (event) => {
+                receivedMessage = event.payload.message;
+            });
+            // 模拟 lark-cli 实际输出的格式
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "2.0",
+                header: {
+                    event_id: "1fcb02757b134ff3aa2764b38ae5405e",
+                    event_type: "im.message.receive_v1",
+                    app_id: "cli_a92ca77188f8dbc9",
+                },
+                event: {
+                    message: {
+                        chat_id: "oc_20ea15b1276eb336a60757bfabdd43f9",
+                        chat_type: "p2p",
+                        content: '{"text":"Hello from Lark!"}',
+                        message_id: "om_x100b5277c7f6c8a0c422a7984156e0e",
+                        message_type: "text",
+                    },
+                    sender: {
+                        sender_id: {
+                            open_id: "ou_b9924f48dc122c3dad0ff4f37851c09b",
+                            union_id: "on_b4bf71136108db21547443d6554776b4",
+                            user_id: null,
+                        },
+                        sender_type: "user",
+                    },
+                },
+            }));
+            expect(receivedMessage).toContain("飞书消息");
+            expect(receivedMessage).toContain("ou_b9924f48dc122c3dad0ff4f37851c09b");
+            expect(receivedMessage).toContain("Hello from Lark!");
+        });
+        test("should extract event type from header.event_type", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+                eventTypes: ["im.message.*"],
+            });
+            let receivedEvent = null;
+            component.onEvent("lark-1", (event) => {
+                receivedEvent = event;
+            });
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "2.0",
+                header: {
+                    event_type: "im.message.receive_v1",
+                },
+                event: {
+                    message: {
+                        content: '{"text":"Test"}',
+                    },
+                    sender: {
+                        sender_id: { open_id: "ou_test" },
+                    },
+                },
+            }));
+            expect(receivedEvent).not.toBeNull();
+            expect(receivedEvent.type).toBe("im.message.receive_v1");
+        });
+    });
+    describe("lark-cli event parsing", () => {
+        test("should parse lark message event with open_id", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedEvent = null;
+            component.onEvent("lark-1", (event) => {
+                receivedEvent = event;
+            });
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                message_id: "msg_abc123",
+                sender: {
+                    sender_id: {
+                        open_id: "ou_123456",
+                        user_id: "user_456",
+                    },
+                },
+                message_type: "text",
+                text: "测试消息内容",
+            }));
+            expect(receivedEvent).not.toBeNull();
+            expect(receivedEvent.type).toBe("lark.im.message.receive_v1");
+            expect(receivedEvent.payload.sourceType).toBe("lark-cli");
+        });
+        test("should parse lark message event with email", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedEvent = null;
+            component.onEvent("lark-1", (event) => {
+                receivedEvent = event;
+            });
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                sender: {
+                    sender_id: {
+                        email: "test@example.com",
+                    },
+                },
+                text: "Hello",
+            }));
+            expect(receivedEvent).not.toBeNull();
+            expect(receivedEvent.payload.message).toContain("test@example.com");
+        });
+        test("should parse lark bot message", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedEvent = null;
+            component.onEvent("lark-1", (event) => {
+                receivedEvent = event;
+            });
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                sender: {
+                    sender_type: "user",
+                    sender_id: {},
+                },
+                text: "Bot message",
+            }));
+            expect(receivedEvent).not.toBeNull();
+            expect(receivedEvent.type).toBe("lark.im.message.receive_v1");
+        });
+        test("should handle non-text message content", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedMessage = "";
+            component.onEvent("lark-1", (event) => {
+                receivedMessage = event.payload.message;
+            });
+            // Post message event with card content
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                content: '{"type":"card","data":{"text":"Card content"}}',
+            }));
+            expect(receivedMessage).toContain("飞书消息");
+        });
+        test("should handle event without schema", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedEvent = null;
+            component.onEvent("lark-1", (event) => {
+                receivedEvent = event;
+            });
+            // Event without schema field
+            component["handleEvent"]("lark-1", JSON.stringify({
+                type: "custom.event",
+                data: "test",
+            }));
+            expect(receivedEvent).not.toBeNull();
+            expect(receivedEvent.type).toBe("custom.event");
+        });
+        test("should filter events by eventTypes", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-1",
+                name: "Lark Source",
+                type: "lark-cli",
+                enabled: true,
+                eventTypes: ["lark.im.message.*"], // 只接收消息事件
+            });
+            let handlerCalled = false;
+            component.onEvent("lark-1", () => {
+                handlerCalled = true;
+            });
+            // 匹配的事件
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "im.message.receive_v1",
+                text: "Hello",
+            }));
+            expect(handlerCalled).toBe(true);
+            handlerCalled = false;
+            // 不匹配的事件（不在过滤列表中）
+            component["handleEvent"]("lark-1", JSON.stringify({
+                schema: "contact.user.created",
+                text: "New user",
+            }));
+            expect(handlerCalled).toBe(false);
+        });
+    });
+    describe("processStream", () => {
+        test("should handle NDJSON lines", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-1",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+                eventTypes: ["*"],
+            });
+            let eventsReceived = 0;
+            component.onEvent("test-1", () => {
+                eventsReceived++;
+            });
+            // 模拟 NDJSON 流（多个 JSON 行）
+            const ndjsonData = '{"schema":"im.message.receive_v1","text":"Hello"}\n' +
+                '{"schema":"im.message.receive_v1","text":"World"}\n' +
+                '{"schema":"contact.user.created"}\n';
+            component["processStream"]("test-1", ndjsonData);
+            expect(eventsReceived).toBe(3);
+        });
+        test("should handle incomplete JSON line", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-1",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+                eventTypes: ["*"],
+            });
+            let eventsReceived = 0;
+            component.onEvent("test-1", () => {
+                eventsReceived++;
+            });
+            // 第一行完整，第二行不完整
+            // 缓冲区会保留不完整的数据
+            const data1 = '{"schema":"im.message.receive_v1"}\n{"incomplete":';
+            component["processStream"]("test-1", data1);
+            expect(eventsReceived).toBe(1);
+            // 完成不完整的行
+            // 加上第三行完整数据
+            const data2 = '"complete"}\n{"schema":"im.message.receive_v1"}\n';
+            component["processStream"]("test-1", data2);
+            expect(eventsReceived).toBe(3);
+        });
+    });
+    describe("extractMetadata", () => {
+        test("should extract metadata from lark-cli message event", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            const rawEvent = {
+                schema: "2.0",
+                header: {
+                    event_id: "edb989d37c1793b9f7bf4cb0aedf2816",
+                    event_type: "im.message.receive_v1",
+                    app_id: "cli_a92ca77188f8dbc9",
+                    tenant_key: "2db7908f4d0f575e",
+                },
+                event: {
+                    message: {
+                        chat_id: "oc_20ea15b1276eb336a60757bfabdd43f9",
+                        chat_type: "p2p",
+                        content: '{"text":"阿斯蒂芬"}',
+                        message_id: "om_x100b527e90903084c4925f230b3af4b",
+                        message_type: "text",
+                    },
+                    sender: {
+                        sender_id: {
+                            open_id: "ou_b9924f48dc122c3dad0ff4f37851c09b",
+                            union_id: "on_b4bf71136108db21547443d6554776b4",
+                            user_id: null,
+                        },
+                        sender_type: "user",
+                        tenant_key: "2db7908f4d0f575e",
+                    },
+                },
+            };
+            const result = component["extractMetadata"]("lark-cli", rawEvent, "im.message.receive_v1");
+            // 验证元信息提取
+            expect(result.metadata.eventType).toBe("im.message.receive_v1");
+            expect(result.metadata.appId).toBe("cli_a92ca77188f8dbc9");
+            expect(result.metadata.tenantKey).toBe("2db7908f4d0f575e");
+            expect(result.metadata.chatId).toBe("oc_20ea15b1276eb336a60757bfabdd43f9");
+            expect(result.metadata.chatType).toBe("p2p");
+            expect(result.metadata.messageId).toBe("om_x100b527e90903084c4925f230b3af4b");
+            expect(result.metadata.messageType).toBe("text");
+            expect(result.metadata.senderId).toBe("ou_b9924f48dc122c3dad0ff4f37851c09b");
+            // 验证推荐动作
+            expect(result.recommendedAction).toBeDefined();
+            expect(result.recommendedAction?.action).toBe("处理飞书消息并回复");
+            expect(result.recommendedAction?.replyTo?.appId).toBe("cli_a92ca77188f8dbc9");
+            expect(result.recommendedAction?.replyTo?.chatId).toBe("oc_20ea15b1276eb336a60757bfabdd43f9");
+            expect(result.recommendedAction?.replyTo?.messageId).toBe("om_x100b527e90903084c4925f230b3af4b");
+        });
+        test("should format message with content correctly", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "lark-test",
+                name: "Lark Test",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedMessage = "";
+            component.onEvent("lark-test", (event) => {
+                receivedMessage = event.payload.message;
+            });
+            // 用户实际发送的消息格式（包含 content）
+            component["handleEvent"]("lark-test", JSON.stringify({
+                schema: "2.0",
+                header: {
+                    event_id: "edb989d37c1793b9f7bf4cb0aedf2816",
+                    event_type: "im.message.receive_v1",
+                    app_id: "cli_a92ca77188f8dbc9",
+                    tenant_key: "2db7908f4d0f575e",
+                },
+                event: {
+                    message: {
+                        chat_id: "oc_20ea15b1276eb336a60757bfabdd43f9",
+                        chat_type: "p2p",
+                        content: '{"text":"阿斯蒂芬"}',
+                        message_id: "om_x100b527e90903084c4925f230b3af4b",
+                        message_type: "text",
+                    },
+                    sender: {
+                        sender_id: {
+                            open_id: "ou_b9924f48dc122c3dad0ff4f37851c09b",
+                        },
+                        sender_type: "user",
+                    },
+                },
+            }));
+            // 应该正确解析消息内容
+            expect(receivedMessage).toContain("飞书消息");
+            expect(receivedMessage).toContain("阿斯蒂芬");
+            expect(receivedMessage).not.toContain("not matched");
+        });
+        test("should extract metadata from timer event", async () => {
+            const result = component["extractMetadata"]("timer", {}, "timer.tick");
+            expect(result.metadata.eventType).toBe("timer.tick");
+            expect(result.recommendedAction).toBeDefined();
+            expect(result.recommendedAction?.action).toBe("执行定时任务");
+        });
+        test("should extract metadata from websocket event", async () => {
+            const result = component["extractMetadata"]("websocket", {}, "ws.message");
+            expect(result.metadata.eventType).toBe("ws.message");
+            expect(result.recommendedAction).toBeDefined();
+            expect(result.recommendedAction?.action).toBe("处理 WebSocket 消息");
+        });
+        test("should extract metadata with null sender_id values", async () => {
+            const rawEvent = {
+                header: {
+                    event_type: "im.message.receive_v1",
+                    app_id: "cli_test",
+                },
+                event: {
+                    message: {
+                        chat_id: "oc_test",
+                        message_type: "text",
+                    },
+                    sender: {
+                        sender_id: {
+                            open_id: null,
+                            user_id: null,
+                            email: null,
+                            union_id: null,
+                        },
+                    },
+                },
+            };
+            const result = component["extractMetadata"]("lark-cli", rawEvent, "im.message.receive_v1");
+            // senderId 应该为空字符串（因为所有值都是 null）
+            expect(result.metadata.senderId).toBeDefined();
+        });
+    });
+    describe("EventSourceEvent payload structure", () => {
+        test("should include metadata and recommendedAction in event payload", async () => {
+            await component.init({
+                name: "event-source",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent },
+            });
+            component.register({
+                id: "test-metadata",
+                name: "Test Source",
+                type: "lark-cli",
+                enabled: true,
+            });
+            let receivedEvent = null;
+            component.onEvent("test-metadata", (event) => {
+                receivedEvent = event;
+            });
+            component["handleEvent"]("test-metadata", JSON.stringify({
+                schema: "2.0",
+                header: {
+                    event_type: "im.message.receive_v1",
+                    app_id: "cli_test",
+                },
+                event: {
+                    message: {
+                        chat_id: "oc_test",
+                        content: '{"text":"Hello"}',
+                        message_type: "text",
+                    },
+                    sender: {
+                        sender_id: {
+                            open_id: "ou_test",
+                        },
+                    },
+                },
+            }));
+            expect(receivedEvent).toBeDefined();
+            expect(receivedEvent.payload.metadata).toBeDefined();
+            expect(receivedEvent.payload.metadata.appId).toBe("cli_test");
+            expect(receivedEvent.payload.metadata.chatId).toBe("oc_test");
+            expect(receivedEvent.payload.metadata.eventType).toBe("im.message.receive_v1");
+            expect(receivedEvent.payload.recommendedAction).toBeDefined();
+            expect(receivedEvent.payload.recommendedAction?.action).toBe("处理飞书消息并回复");
+            expect(receivedEvent.payload.recommendedAction?.replyTo?.appId).toBe("cli_test");
+        });
+    });
+});
+//# sourceMappingURL=event-source-component.test.js.map