@ai-setting/roy-agent-core 1.0.0

package/src/env/event-source/event-source-config-registration.test.ts

@@ -0,0 +1,242 @@
+/**
+ * @fileoverview EventSource Component 配置注册测试
+ * 
+ * TDD: 先写测试，验证配置注册机制
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { ConfigComponent } from "../../config/config-component";
+import { EventSourceComponent } from "./event-source-component";
+import { EVENT_SOURCE_CONFIG_REGISTRATION, EVENT_SOURCE_DEFAULTS } from "./event-source-config-registration";
+
+describe("EventSource Config Registration", () => {
+  let configComponent: ConfigComponent;
+  let component: EventSourceComponent;
+
+  beforeEach(() => {
+    configComponent = new ConfigComponent();
+    component = new EventSourceComponent();
+  });
+
+  describe("EVENT_SOURCE_CONFIG_REGISTRATION", () => {
+    it("应该包含正确的 name", () => {
+      expect(EVENT_SOURCE_CONFIG_REGISTRATION.name).toBe("event-source");
+    });
+
+    it("应该包含 env source 配置", () => {
+      const envSource = EVENT_SOURCE_CONFIG_REGISTRATION.sources.find(
+        (s) => s.type === "env"
+      );
+      expect(envSource).toBeDefined();
+      expect(envSource?.envPrefix).toBe("EVENT_SOURCE");
+      expect(envSource?.priority).toBe(20);
+    });
+
+    it("应该包含所有配置 keys", () => {
+      const keys = EVENT_SOURCE_CONFIG_REGISTRATION.keys;
+      expect(keys).toContainEqual(
+        expect.objectContaining({ key: "event-source.enabled" })
+      );
+      expect(keys).toContainEqual(
+        expect.objectContaining({ key: "event-source.persistenceEnabled" })
+      );
+      expect(keys).toContainEqual(
+        expect.objectContaining({ key: "event-source.configPath" })
+      );
+    });
+  });
+
+  describe("EVENT_SOURCE_DEFAULTS", () => {
+    it("应该包含 enabled 默认值（完整格式）", () => {
+      expect(EVENT_SOURCE_DEFAULTS["event-source.enabled"]).toBe(true);
+    });
+
+    it("应该包含 persistenceEnabled 默认值（完整格式）", () => {
+      expect(EVENT_SOURCE_DEFAULTS["event-source.persistenceEnabled"]).toBe(true);
+    });
+  });
+
+  describe("配置注册到 ConfigComponent", () => {
+    it("应该能够注册 EVENT_SOURCE_CONFIG_REGISTRATION", () => {
+      configComponent.registerComponent(EVENT_SOURCE_CONFIG_REGISTRATION);
+      expect(() => configComponent.registerComponent(EVENT_SOURCE_CONFIG_REGISTRATION)).not.toThrow();
+    });
+
+    it("注册后 defaults 常量应包含正确的默认值", () => {
+      // 默认值通过 DEFAULTS 常量定义，在 registerConfig 中手动设置
+      expect(EVENT_SOURCE_DEFAULTS["event-source.enabled"]).toBe(true);
+      expect(EVENT_SOURCE_DEFAULTS["event-source.persistenceEnabled"]).toBe(true);
+    });
+  });
+
+  describe("Component 集成", () => {
+    it("应该能够通过 options 传入 ConfigComponent", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        options: {
+          configComponent,
+        },
+      } as any);
+      
+      // 验证组件已初始化
+      expect(component.name).toBe("event-source");
+      expect(component.version).toBe("1.0.0");
+    });
+
+    it("应该能够通过 config 对象传入配置", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        options: {
+          configComponent,
+          config: {
+            enabled: false,
+            persistenceEnabled: false,
+          },
+        },
+      } as any);
+      
+      expect(component.name).toBe("event-source");
+    });
+  });
+
+  describe("环境变量覆盖", () => {
+    it("应该能够通过环境变量覆盖配置", async () => {
+      // 设置环境变量
+      const originalValue = process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED;
+      process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED = "false";
+      
+      try {
+        await component.init({
+          name: "event-source",
+          version: "1.0.0",
+          enabled: true,
+          options: {
+            configComponent,
+          },
+        } as any);
+        
+        expect(component.name).toBe("event-source");
+      } finally {
+        // 恢复环境变量
+        if (originalValue !== undefined) {
+          process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED = originalValue;
+        } else {
+          delete process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED;
+        }
+      }
+    });
+  });
+
+  describe("核心验收标准 - registerConfig 方法", () => {
+    /**
+     * 验收标准 1: 使用 registerComponent 注册配置
+     */
+    it("应该使用 registerComponent 注册 EVENT_SOURCE_CONFIG_REGISTRATION", async () => {
+      const registerComponentSpy = vi.spyOn(configComponent, 'registerComponent');
+      
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        options: {
+          configComponent,
+        },
+      } as any);
+      
+      expect(registerComponentSpy).toHaveBeenCalledWith(EVENT_SOURCE_CONFIG_REGISTRATION);
+    });
+
+    /**
+     * 验收标准 2: 调用 load("event-source") 加载配置
+     */
+    it("应该调用 load('event-source') 加载配置", async () => {
+      const loadSpy = vi.spyOn(configComponent, 'load');
+      
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        options: {
+          configComponent,
+        },
+      } as any);
+      
+      expect(loadSpy).toHaveBeenCalledWith("event-source");
+    });
+
+    /**
+     * 验收标准 3: 设置默认值 EVENT_SOURCE_DEFAULTS
+     */
+    it("应该设置默认值 EVENT_SOURCE_DEFAULTS", async () => {
+      // 初始化组件（会调用 registerConfig）
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        options: {
+          configComponent,
+        },
+      } as any);
+      
+      // 验证默认值存在
+      const enabled = configComponent.get("event-source.enabled");
+      const persistenceEnabled = configComponent.get("event-source.persistenceEnabled");
+      
+      expect(enabled).toBe(true);
+      expect(persistenceEnabled).toBe(true);
+    });
+
+    /**
+     * 验收标准 4: 处理环境变量后备方案
+     */
+    it("应该处理环境变量后备方案", async () => {
+      const originalValue = process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED;
+      process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED = "false";
+      
+      try {
+        await component.init({
+          name: "event-source",
+          version: "1.0.0",
+          enabled: true,
+          options: {
+            configComponent,
+          },
+        } as any);
+        
+        // 环境变量应该被处理（具体值取决于实现）
+        expect(configComponent.get("event-source.enabled")).toBeDefined();
+      } finally {
+        if (originalValue !== undefined) {
+          process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED = originalValue;
+        } else {
+          delete process.env.EVENT_SOURCE_EVENT_SOURCE_ENABLED;
+        }
+      }
+    });
+
+    /**
+     * 验收标准 5: 处理 config 对象（最高优先级）
+     */
+    it("应该处理 config 对象（最高优先级）", async () => {
+      await component.init({
+        name: "event-source",
+        version: "1.0.0",
+        enabled: true,
+        options: {
+          configComponent,
+          config: {
+            enabled: false,
+            persistenceEnabled: false,
+          },
+        },
+      } as any);
+      
+      // config 对象应该被处理
+      expect(configComponent.get("event-source.enabled")).toBeDefined();
+    });
+  });
+});

package/src/env/event-source/event-source-config-registration.ts

@@ -0,0 +1,37 @@
+/**
+ * @fileoverview EventSource Component 配置注册
+ * 
+ * 使用 ConfigComponent.registerComponent() 机制统一管理配置
+ */
+
+import type { ComponentRegistration } from "../../config/config-component";
+
+/**
+ * EventSource Component 默认配置值
+ * 
+ * 注意：键使用完整格式（带 "event-source." 前缀），在 registerConfig 中手动设置
+ */
+export const EVENT_SOURCE_DEFAULTS: Record<string, unknown> = {
+  "event-source.enabled": true,
+  "event-source.persistenceEnabled": true,
+};
+
+/**
+ * EventSource Component 配置注册常量
+ * 
+ * 定义了所有 EventSource 相关的配置项和来源
+ */
+export const EVENT_SOURCE_CONFIG_REGISTRATION: ComponentRegistration = {
+  name: "event-source",
+  
+  sources: [
+    { type: "env", envPrefix: "EVENT_SOURCE", priority: 20, watch: false },
+  ],
+  
+  keys: [
+    { key: "event-source.enabled", sources: ["env", "file"] },
+    { key: "event-source.persistenceEnabled", sources: ["env", "file"] },
+    { key: "event-source.configPath", sources: ["env", "file"] },
+  ],
+  // 注意：不使用 defaults 字段，默认值在 registerConfig 中手动 set
+};

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

@@ -0,0 +1,320 @@
+import { describe, test, expect, beforeEach, vi } from "bun:test";
+import { EventSourceComponent } from "./event-source-component";
+import { EventSourceAgentHandler } from "./event-source-agent-handler";
+import { ConfigComponent } from "../../config/config-component";
+import type { EventSourceConfig } from "./types";
+import type { Environment } from "../interface";
+
+describe("EventSource with AgentHandler Integration", () => {
+  let component: EventSourceComponent;
+  let mockEnv: ReturnType<typeof createMockEnv>;
+  let configComponent: ConfigComponent;
+
+  function createMockEnv() {
+    return {
+      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((name: string) => name === "config" ? configComponent : undefined),
+      hasComponent: vi.fn(() => true),
+      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(),
+    };
+  }
+
+  beforeEach(() => {
+    component = new EventSourceComponent();
+    configComponent = new ConfigComponent();
+    (component as any).persistenceEnabled = false;
+    (component as any).sources.clear();
+    (component as any).statuses.clear();
+    mockEnv = createMockEnv();
+  });
+
+  test("should integrate AgentHandler with EventSource", 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: "lark-1",
+      name: "Lark Source",
+      type: "lark-cli",
+      enabled: true,
+      eventTypes: ["*"],
+    };
+    component.register(config);
+
+    // 创建 Agent Handler
+    const agentHandler = new EventSourceAgentHandler({
+      prefix: "[飞书消息]",
+      includeTimestamp: true,
+      includeRawEvent: false,
+    });
+
+    // 设置事件处理器
+    let agentMessage = "";
+    component.onEvent("lark-1", (event) => {
+      agentMessage = agentHandler.formatEventForAgent(event);
+    });
+
+    // 模拟收到飞书消息
+    component["handleEvent"]("lark-1", JSON.stringify({
+      schema: "im.message.receive_v1",
+      message_id: "msg_123",
+      sender: { sender_id: { open_id: "ou_abc" } },
+      text: "Hello, Agent!",
+    }));
+
+    // 验证消息被正确格式化
+    expect(agentMessage).toContain("[飞书消息]");
+    expect(agentMessage).toContain("来源: lark-cli");
+    expect(agentMessage).toContain("ou_abc");
+    expect(agentMessage).toContain("Hello, Agent!");
+  });
+
+  test("should handle timer event with AgentHandler", async () => {
+    await component.init({
+      name: "event-source",
+      version: "1.0.0",
+      enabled: true,
+      env: mockEnv as unknown as Environment,
+      options: { configComponent },
+    });
+
+    // 注册事件源
+    component.register({
+      id: "timer-1",
+      name: "Timer Source",
+      type: "timer",
+      enabled: true,
+      interval: 1000,
+      eventTypes: ["*"],
+    });
+
+    // 创建 Agent Handler
+    const agentHandler = new EventSourceAgentHandler({
+      prefix: "[定时任务]",
+    });
+
+    let agentMessage = "";
+    component.onEvent("timer-1", (event) => {
+      agentMessage = agentHandler.formatEventForAgent(event);
+    });
+
+    // 模拟收到定时任务事件
+    component["handleEvent"]("timer-1", JSON.stringify({
+      type: "timer.tick",
+      payload: {
+        message: "每日健康检查",
+        timestamp: Date.now(),
+      },
+    }));
+
+    expect(agentMessage).toContain("[定时任务]");
+    expect(agentMessage).toContain("来源: timer");
+    expect(agentMessage).toContain("每日健康检查");
+  });
+
+  test("should filter events and only process matching ones", async () => {
+    await component.init({
+      name: "event-source",
+      version: "1.0.0",
+      enabled: true,
+      env: mockEnv as unknown as Environment,
+      options: { configComponent },
+    });
+
+    // 只接收消息事件
+    component.register({
+      id: "lark-1",
+      name: "Lark Source",
+      type: "lark-cli",
+      enabled: true,
+      eventTypes: ["lark.im.message.*"],  // 只接收消息事件
+    });
+
+    const agentHandler = new EventSourceAgentHandler();
+    let messageCount = 0;
+    
+    component.onEvent("lark-1", (event) => {
+      const formatted = agentHandler.formatEventForAgent(event);
+      if (formatted) {
+        messageCount++;
+      }
+    });
+
+    // 发送消息事件 - 应该被处理
+    component["handleEvent"]("lark-1", JSON.stringify({
+      schema: "im.message.receive_v1",
+      text: "Hello",
+    }));
+    expect(messageCount).toBe(1);
+
+    // 发送其他事件 - 应该被过滤
+    component["handleEvent"]("lark-1", JSON.stringify({
+      schema: "contact.user.created",
+    }));
+    expect(messageCount).toBe(1);  // 保持不变
+  });
+
+  test("should use createHandler to get handler function", 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: "lark-cli",
+      enabled: true,
+      eventTypes: ["*"],
+    });
+
+    const agentHandler = new EventSourceAgentHandler({
+      prefix: "[TEST]",
+    });
+
+    // 直接使用 createHandler
+    const handler = agentHandler.createHandler();
+    
+    let result: string | undefined;
+    component.onEvent("test-1", (event) => {
+      result = handler(event);
+    });
+
+    component["handleEvent"]("test-1", JSON.stringify({
+      schema: "im.message.receive_v1",
+      text: "Test message",
+    }));
+
+    expect(result).toContain("[TEST]");
+    expect(result).toContain("Test message");
+  });
+
+  test("should handle disabled handler", 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: "lark-cli",
+      enabled: true,
+    });
+
+    const agentHandler = new EventSourceAgentHandler({ enabled: false });
+    const handler = agentHandler.createHandler();
+    
+    let result: string | undefined;
+    component.onEvent("test-1", (event) => {
+      result = handler(event);
+    });
+
+    component["handleEvent"]("test-1", JSON.stringify({
+      schema: "im.message.receive_v1",
+      text: "Test",
+    }));
+
+    expect(result).toBeUndefined();
+  });
+
+  test("should publish event to env when event received", async () => {
+    await component.init({
+      name: "event-source",
+      version: "1.0.0",
+      enabled: true,
+      env: mockEnv as unknown as Environment,
+      options: { configComponent },
+    });
+
+    component.register({
+      id: "lark-1",
+      name: "Lark Source",
+      type: "lark-cli",
+      enabled: true,
+      eventTypes: ["*"],
+    });
+
+    // 模拟收到事件
+    component["handleEvent"]("lark-1", JSON.stringify({
+      schema: "2.0",
+      header: {
+        event_type: "im.message.receive_v1",
+      },
+      event: {
+        message: {
+          content: '{"text":"Hello"}',
+        },
+        sender: {
+          sender_id: { open_id: "ou_test" },
+        },
+      },
+    }));
+
+    // 验证 pushEnvEvent 被调用
+    expect(mockEnv.pushEnvEvent).toHaveBeenCalled();
+    
+    // 验证发布的事件类型
+    const publishedEvent = (mockEnv.pushEnvEvent as any).mock.calls[0][0];
+    expect(publishedEvent.type).toBe("event-source.event.lark-cli");
+    expect(publishedEvent.payload).toBeDefined();
+    expect(publishedEvent.payload.type).toBe("im.message.receive_v1");
+  });
+
+  test("should publish event with correct payload structure", async () => {
+    await component.init({
+      name: "event-source",
+      version: "1.0.0",
+      enabled: true,
+      env: mockEnv as unknown as Environment,
+      options: { configComponent },
+    });
+
+    component.register({
+      id: "timer-1",
+      name: "Timer Source",
+      type: "timer",
+      enabled: true,
+      eventTypes: ["*"],
+    });
+
+    // 模拟收到定时事件
+    component["handleEvent"]("timer-1", JSON.stringify({
+      type: "timer.tick",
+      payload: {
+        message: "Daily check",
+      },
+    }));
+
+    // 验证 pushEnvEvent 被调用
+    expect(mockEnv.pushEnvEvent).toHaveBeenCalled();
+    
+    const publishedEvent = (mockEnv.pushEnvEvent as any).mock.calls[0][0];
+    expect(publishedEvent.type).toBe("event-source.event.timer");
+    expect(publishedEvent.payload.type).toBe("timer.tick");
+  });
+});