@ai-setting/roy-agent-core 1.0.0

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

@@ -0,0 +1,1207 @@
+import { describe, test, expect, beforeEach, vi } from "bun:test";
+import { EventSourceComponent } from "./event-source-component";
+import { EventSourceStatus, EventSourceType, type EventSourceConfig } from "./types";
+import type { Environment } from "../interface";
+import { ConfigComponent } from "../../config/config-component";
+
+// Mock spawn
+vi.mock("child_process", () => ({
+  spawn: vi.fn(() => ({
+    on: vi.fn((event: string, cb: (code: number | null) => void) => {
+      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 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: vi.fn(),
+  trace: vi.fn(),
+});
+
+describe("EventSourceComponent", () => {
+  let component: EventSourceComponent;
+  let mockEnv: ReturnType<typeof createMockEnv>;
+  let configComponent: ConfigComponent;
+
+  beforeEach(() => {
+    component = new EventSourceComponent();
+    configComponent = new ConfigComponent();
+    // 禁用持久化，避免测试之间的干扰
+    (component as any).persistenceEnabled = false;
+    (component as any).sources.clear();
+    (component as any).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 as unknown as Environment,
+        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: EventSourceConfig = {
+        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: EventSourceConfig = {
+        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: EventSourceConfig = {
+        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: EventSourceConfig = {
+        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: EventSourceConfig = {
+        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 as unknown as Environment,
+        options: { configComponent },
+      });
+
+      const config: EventSourceConfig = {
+        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: EventSourceConfig = {
+        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: EventSourceConfig = {
+        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: any = 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: any = 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: any = 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: any = 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: any = 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: any = 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");
+    });
+  });
+});