@ai-setting/roy-agent-core 1.3.10 → 1.3.11

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

@@ -1,1379 +0,0 @@
-/**
- * EventSourceComponent
- * 
- * 事件源组件，管理所有事件源的注册、配置和生命周期
- */
-
-import { ChildProcess, spawn, exec } from "child_process";
-import { promisify } from "util";
-
-// execAsync 函数，在测试时会被 mock 替换
-let execAsyncImpl: (command: string) => Promise<{ stdout: string; stderr: string }> = 
-  promisify(exec);
-
-/**
- * 设置 execAsync 实现（用于测试）
- */
-export function setExecAsync(fn: (command: string) => Promise<{ stdout: string; stderr: string }>): void {
-  execAsyncImpl = fn;
-}
-
-/**
- * 获取 execAsync 函数
- */
-function getExecAsync(): (command: string) => Promise<{ stdout: string; stderr: string }> {
-  return execAsyncImpl;
-}
-import { join } from "path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { BaseComponent, type ComponentConfig } from "../component";
-import type { ConfigComponent } from "../../config/config-component";
-import { toEnvKey, envKeyToConfigKey } from "../../config/env-key";
-import type { 
-  EventSourceConfig, 
-  EventSourceStatus, 
-  EventSourceEvent,
-  EventSourceEventHandler,
-  EventSourceType,
-  EventSourcePersistenceConfig,
-  ReplyChannel,
-  EventMetadata,
-  RecommendedAction
-} from "./types";
-import { createLogger } from "../log-trace/logger";
-import { EVENT_SOURCE_CONFIG_REGISTRATION, EVENT_SOURCE_DEFAULTS } from "./event-source-config-registration";
-
-const logger = createLogger("event-source");
-
-// ============================================================================
-// EventSourceComponentOptions
-// ============================================================================
-
-/**
- * EventSourceComponent 配置选项
- */
-export interface EventSourceComponentOptions {
-  /** ConfigComponent 实例（必填） */
-  configComponent: ConfigComponent;
-  
-  /** 配置文件相对路径（可选） */
-  configPath?: string;
-  
-  /** 直接传入的配置对象（可选，优先级最高） */
-  config?: Partial<EventSourceConfigOptions>;
-}
-
-/**
- * EventSourceComponent 内部配置
- */
-interface EventSourceConfigOptions {
-  enabled: boolean;
-  persistenceEnabled: boolean;
-  configPath: string;
-}
-
-// ============================================================================
-// EventSourceComponent
-// ============================================================================
-
-/**
- * EventSourceComponent
- * 
- * 事件源组件，管理所有事件源的注册、配置和生命周期
- */
-// ============================================================================
-// ProcessInfo
-// ============================================================================
-
-/**
- * 扩展的进程信息接口
- */
-interface ProcessInfo {
-  /** 基础进程对象 */
-  child: ChildProcess;
-  /** 进程组 ID */
-  pgid?: number;
-  /** 相关进程列表 */
-  pids: number[];
-  /** 执行的命令 */
-  command?: string;
-}
-
-// ============================================================================
-// EventSourceComponent
-// ============================================================================
-
-export class EventSourceComponent extends BaseComponent {
-  readonly name = "event-source";
-  readonly version = "1.0.0";
-
-  // 内部状态
-  private sources: Map<string, EventSourceConfig> = new Map();
-  private statuses: Map<string, EventSourceStatus> = new Map();
-  private processes: Map<string, ProcessInfo> = new Map();
-  private handlers: Map<string, EventSourceEventHandler> = new Map();
-  private timers: Map<string, NodeJS.Timeout> = new Map();
-  private buffers: Map<string, string> = new Map();
-
-  // 持久化配置
-  private configPath: string = "";
-  private persistenceEnabled: boolean = true;
-  
-  /** ConfigComponent 用于配置管理 */
-  private configComponent?: ConfigComponent;
-  
-  /** 配置热更新 watcher 清理函数 */
-  private configWatcher?: () => void;
-
-  // ========================================================================
-  // 组件生命周期
-  // ========================================================================
-
-  /**
-   * 初始化
-   */
-  protected async onInit(): Promise<void> {
-    // 配置注册已在 init() 方法中完成（通过 ComponentConfig.options 获取）
-    // 加载已保存的事件源配置
-    await this.loadConfig();
-  }
-  
-  /**
-   * 公开的初始化方法，用于子类覆盖
-   * 
-   * 这个方法会被 BaseComponent.init() 调用，用于执行子类特有的初始化逻辑。
-   * 它接收 ComponentConfig，并通过 ComponentConfig.options 获取 EventSourceComponentOptions。
-   */
-  async init(options?: ComponentConfig): Promise<void> {
-    // 如果提供了 env，则注入
-    if (options?.env) {
-      this.env = options.env;
-    }
-    
-    this.setStatus("initializing");
-    
-    if (options?.name) Object.defineProperty(this, "name", { value: options.name, writable: false });
-    if (options?.version) Object.defineProperty(this, "version", { value: options.version, writable: false });
-    if (options?.enabled !== undefined) this._enabled = options.enabled;
-    
-    // 从 options 获取 EventSourceComponentOptions
-    const opts = options?.options as unknown as EventSourceComponentOptions | undefined;
-    if (opts?.configComponent) {
-      this.configComponent = opts.configComponent;
-      await this.registerConfig(opts);
-    } else {
-      throw new Error("ConfigComponent is required for EventSourceComponent initialization");
-    }
-    
-    await this.onInit();
-    this.setStatus("running");
-  }
-
-  protected async onStart(): Promise<void> {
-    // onStart 时不再重复加载（已在 onInit 中加载）
-  }
-
-  protected async onStop(): Promise<void> {
-    // 清理配置 watcher
-    this.configWatcher?.();
-    this.configWatcher = undefined;
-    
-    // 停止所有运行中的事件源
-    const runningSources = Array.from(this.statuses.entries())
-      .filter(([_, status]) => status === "running")
-      .map(([id]) => id);
-
-    for (const id of runningSources) {
-      await this.stopSource(id);
-    }
-
-    // 清空所有状态
-    this.sources.clear();
-    this.statuses.clear();
-    this.processes.clear();
-    this.handlers.clear();
-    this.timers.clear();
-    this.buffers.clear();
-  }
-
-  // ========================================================================
-  // 配置注册
-  // ========================================================================
-
-  /**
-   * 注册配置到 ConfigComponent
-   * 
-   * 配置加载顺序（优先级从低到高）：
-   * 1. Defaults - 默认值（最低）
-   * 2. FileSource - 从配置文件加载
-   * 3. EnvSource - 从环境变量加载
-   * 4. config 对象 - 直接传入的配置（最高）
-   */
-  private async registerConfig(options: EventSourceComponentOptions): Promise<void> {
-    const configComponent = options.configComponent;
-    if (!configComponent) return;
-
-    const { configPath, config } = options;
-    const envPrefix = "EVENT_SOURCE";
-
-    // 1. 使用 registerComponent 注册配置结构（keys 和 sources，不含 defaults）
-    configComponent.registerComponent(EVENT_SOURCE_CONFIG_REGISTRATION);
-
-    // 2. 注册 FileSource（如果提供了 configPath）
-    if (configPath) {
-      configComponent.registerSource({
-        type: "file",
-        relativePath: configPath,
-        optional: true,
-        watch: false
-      });
-    }
-
-    // 3. 注册 EnvSource
-    configComponent.registerSource({
-      type: "env",
-      envPrefix: envPrefix,
-      priority: 20,
-      watch: false
-    });
-    
-    // 4. 从 sources 加载配置（FileSource 和 EnvSource）
-    await configComponent.load("event-source");
-    
-    // 5. 后备方案：直接读取环境变量（确保所有环境变量都被处理）
-    for (const envKey of Object.keys(process.env)) {
-      const configKey = envKeyToConfigKey(envKey, envPrefix, "event-source");
-      if (!configKey) continue;
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        await configComponent.set(configKey, value);
-      }
-    }
-
-    // 6. 设置默认值（只有当配置不存在时）
-    for (const [key, value] of Object.entries(EVENT_SOURCE_DEFAULTS)) {
-      if (configComponent.get(key) === undefined) {
-        await configComponent.set(key, value);
-      }
-    }
-
-    // 6.5 特殊处理 configPath 动态默认值
-    if (configComponent.get("event-source.configPath") === undefined) {
-      // 默认路径: ~/.roy-agent/event-sources.json
-      const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-      const dataDir = join(home, ".roy-agent");
-      await configComponent.set("event-source.configPath", join(dataDir, "event-sources.json"));
-    }
-
-    // 7. 直接配置对象（最高优先级）
-    if (config) {
-      const flatConfig = this.flattenConfig(config);
-      for (const [key, value] of Object.entries(flatConfig)) {
-        await configComponent.set(key, value);
-      }
-    }
-
-    // 8. 注册配置热更新监听
-    this.registerConfigWatcher(configComponent);
-  }
-
-  /**
-   * 构建最终配置对象
-   */
-  private buildConfig(): EventSourceConfigOptions {
-    const configComponent = this.configComponent;
-    if (!configComponent) {
-      return {
-        enabled: true,
-        persistenceEnabled: true,
-        configPath: "",
-      };
-    }
-
-    return {
-      enabled: configComponent.get("event-source.enabled") as boolean ?? true,
-      persistenceEnabled: configComponent.get("event-source.persistenceEnabled") as boolean ?? true,
-      configPath: configComponent.get("event-source.configPath") as string ?? "",
-    };
-  }
-
-  /**
-   * 将配置对象展平为点号路径
-   */
-  private flattenConfig(
-    obj: Record<string, unknown>,
-    prefix = "event-source"
-  ): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj)) {
-      const fullKey = `${prefix}.${key}`;
-      if (value && typeof value === "object" && !Array.isArray(value)) {
-        Object.assign(
-          result,
-          this.flattenConfig(value as Record<string, unknown>, fullKey)
-        );
-      } else {
-        result[fullKey] = value;
-      }
-    }
-    return result;
-  }
-
-  /**
-   * 注册配置热更新监听
-   */
-  private registerConfigWatcher(configComponent: ConfigComponent): void {
-    if (typeof configComponent.watch !== "function") {
-      return;
-    }
-    
-    this.configWatcher = configComponent.watch("event-source.*", (event) => {
-      this.onConfigChange(event);
-    });
-  }
-
-  /**
-   * 处理配置变更
-   */
-  protected onConfigChange(event: { key: string; oldValue?: unknown; newValue?: unknown }): void {
-    logger.info(`EventSource config changed: ${event.key}`, {
-      oldValue: event.oldValue,
-      newValue: event.newValue
-    });
-  }
-
-  // ========================================================================
-  // 事件源注册与管理
-  // ========================================================================
-
-  /**
-   * 注册事件源
-   */
-  register(config: EventSourceConfig): void {
-    if (this.sources.has(config.id)) {
-      throw new Error(`EventSource already exists: ${config.id}`);
-    }
-    this.sources.set(config.id, config);
-    this.statuses.set(config.id, "created");
-    logger.debug(`EventSource registered: ${config.id} (${config.type})`);
-    
-    // 自动保存配置
-    this.saveConfig().catch((err) => {
-      logger.error(`Failed to save config after registering ${config.id}:`, err);
-    });
-  }
-
-  /**
-   * 注销事件源
-   */
-  unregister(id: string): boolean {
-    const status = this.statuses.get(id);
-    if (status === "running") {
-      this.stopSource(id);  // 自动停止
-    }
-    
-    const existed = this.sources.has(id);
-    this.sources.delete(id);
-    this.statuses.delete(id);
-    this.handlers.delete(id);
-    this.buffers.delete(id);
-    
-    if (existed) {
-      logger.debug(`EventSource unregistered: ${id}`);
-      // 自动保存配置
-      this.saveConfig().catch((err) => {
-        logger.error(`Failed to save config after unregistering ${id}:`, err);
-      });
-    }
-    return existed;
-  }
-
-  /**
-   * 获取事件源配置
-   */
-  get(id: string): EventSourceConfig | undefined {
-    return this.sources.get(id);
-  }
-
-  /**
-   * 列出所有事件源
-   */
-  list(): EventSourceConfig[] {
-    return Array.from(this.sources.values());
-  }
-
-  /**
-   * 获取事件源状态
-   */
-  getEventSourceStatus(id: string): EventSourceStatus | undefined {
-    return this.statuses.get(id);
-  }
-
-  /**
-   * 获取指定事件源的状态
-   */
-  getEventSourceStatusById(id: string): EventSourceStatus | undefined {
-    return this.statuses.get(id);
-  }
-
-  /**
-   * 设置事件处理器
-   */
-  onEvent(id: string, handler: EventSourceEventHandler): void {
-    this.handlers.set(id, handler);
-  }
-
-  /**
-   * 移除事件处理器
-   */
-  offEvent(id: string): void {
-    this.handlers.delete(id);
-  }
-
-  // ========================================================================
-  // 生命周期控制
-  // ========================================================================
-
-  /**
-   * 启动事件源
-   * 
-   * 注意：方法名为 startSource 而非 start，以避免覆盖 Component 接口的 start() 方法
-   */
-  async startSource(id: string): Promise<void> {
-    const config = this.sources.get(id);
-    if (!config) {
-      throw new Error(`EventSource not found: ${id}`);
-    }
-
-    const currentStatus = this.statuses.get(id);
-    if (currentStatus === "running") {
-      return;  // 已运行
-    }
-
-    this.statuses.set(id, "starting");
-
-    try {
-      switch (config.type) {
-        case "lark-cli":
-          await this.startLarkCli(id, config);
-          break;
-        case "timer":
-          await this.startTimer(id, config);
-          break;
-        case "websocket":
-          await this.startWebSocket(id, config);
-          break;
-        default:
-          throw new Error(`Unsupported event source type: ${config.type}`);
-      }
-
-      this.statuses.set(id, "running");
-      
-      // 发布事件
-      this.getEnv()?.pushEnvEvent({
-        type: "event-source.started",
-        payload: { sourceId: id, sourceType: config.type },
-      });
-
-      logger.info(`EventSource started: ${id} (${config.type})`);
-
-    } catch (error) {
-      this.statuses.set(id, "error");
-      logger.error(`EventSource failed to start: ${id}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * 停止事件源
-   * 
-   * 注意：方法名为 stopSource 而非 stop，以避免覆盖 Component 接口的 stop() 方法
-   */
-  async stopSource(id: string): Promise<void> {
-    const status = this.statuses.get(id);
-    logger.info(`[EventSource ${id}] stopSource called, current status: ${status}`);
-
-    // 停止任意非 stopped 状态的事件源
-    if (status === "stopped" || status === "created") {
-      logger.info(`[EventSource ${id}] already stopped/created, skipping`);
-      return;
-    }
-
-    this.statuses.set(id, "stopping");
-
-    // 停止子进程
-    const processInfo = this.processes.get(id);
-    const child = processInfo?.child;
-    logger.info(`[EventSource ${id}] process info: ${processInfo ? `pid=${processInfo.child.pid}` : "none"}`);
-
-    if (processInfo && child) {
-      // 清理事件监听器，防止内存泄漏
-      child.removeAllListeners("exit");
-      child.removeAllListeners("error");
-      child.stdout?.removeAllListeners("data");
-      child.stderr?.removeAllListeners("data");
-
-      // 杀死所有相关进程的辅助函数
-      const killProcess = (pid: number, signal: string): boolean => {
-        try {
-          process.kill(pid, signal);
-          return true;
-        } catch (e) {
-          return false;
-        }
-      };
-
-      // 尝试 SIGTERM（优雅终止）给所有相关进程
-      const pidsToKill = processInfo.pids.length > 0 ? processInfo.pids : (processInfo.child.pid ? [processInfo.child.pid] : []);
-      logger.info(`[EventSource ${id}] sending SIGTERM to ${pidsToKill.length} processes: ${pidsToKill.join(", ")}`);
-      
-      for (const pid of pidsToKill) {
-        killProcess(pid, "SIGTERM");
-      }
-
-      // 等待进程退出，最多 3 秒
-      await new Promise<void>((resolve) => {
-        const timeout = setTimeout(() => {
-          // SIGTERM 超时，使用 SIGKILL 强制杀死
-          logger.warn(`[EventSource ${id}] SIGTERM timeout, sending SIGKILL to ${pidsToKill.length} processes`);
-          for (const pid of pidsToKill) {
-            killProcess(pid, "SIGKILL");
-          }
-          resolve();
-        }, 3000);
-
-        // 安全地注册退出监听器
-        try {
-          const onceResult = child.once?.("exit", () => {
-            clearTimeout(timeout);
-            // 即使主进程退出，也确保其他相关进程被杀死
-            for (const pid of pidsToKill) {
-              if (pid !== processInfo.child.pid) {
-                killProcess(pid, "SIGKILL");
-              }
-            }
-            resolve();
-          });
-          // 如果 once 不返回支持链式调用的对象，也尝试使用 on
-          if (!onceResult || typeof onceResult.once !== "function") {
-            child.on("exit", () => {
-              clearTimeout(timeout);
-              for (const pid of pidsToKill) {
-                if (pid !== processInfo.child.pid) {
-                  killProcess(pid, "SIGKILL");
-                }
-              }
-              resolve();
-            });
-          }
-        } catch (e) {
-          logger.warn(`[EventSource ${id}] failed to register exit listener: ${e}`);
-          // 继续执行，让超时处理清理
-        }
-      });
-
-      this.processes.delete(id);
-    } else if (child) {
-      // 兼容旧格式：直接存储 ChildProcess
-      // 清理事件监听器，防止内存泄漏
-      child.removeAllListeners("exit");
-      child.removeAllListeners("error");
-      child.stdout?.removeAllListeners("data");
-      child.stderr?.removeAllListeners("data");
-
-      const pid = (child as ChildProcess).pid!;
-      const pgid = (child as any).pgid;
-
-      // 尝试 SIGTERM（优雅终止）
-      try {
-        // 1. 首先尝试杀死整个进程组
-        if (pgid && pgid > 0 && pgid !== pid) {
-          logger.info(`[EventSource ${id}] killing process group ${pgid}`);
-          try {
-            process.kill(-pgid, "SIGTERM");
-          } catch (e) {
-            logger.warn(`[EventSource ${id}] failed to kill process group: ${e}`);
-          }
-        }
-
-        // 2. 同时杀死主进程
-        logger.info(`[EventSource ${id}] killing main process ${pid}`);
-        (child as ChildProcess).kill("SIGTERM");
-
-        // 等待进程退出，最多 3 秒
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(() => {
-            // SIGTERM 超时，使用 SIGKILL 强制杀死
-            logger.warn(`[EventSource ${id}] SIGTERM timeout, sending SIGKILL`);
-            if (pgid && pgid > 0 && pgid !== pid) {
-              try {
-                process.kill(-pgid, "SIGKILL");
-              } catch (e) {
-                logger.warn(`[EventSource ${id}] failed to kill process group with SIGKILL: ${e}`);
-              }
-            }
-            (child as ChildProcess).kill("SIGKILL");
-            resolve();
-          }, 3000);
-
-          (child as ChildProcess).once("exit", () => {
-            clearTimeout(timeout);
-            resolve();
-          });
-        });
-      } catch (error) {
-        logger.error(`[EventSource ${id}] Failed to kill process:`, error);
-        // 确保最终使用 SIGKILL
-        try {
-          (child as ChildProcess).kill("SIGKILL");
-        } catch {
-          // ignore
-        }
-      }
-
-      this.processes.delete(id);
-    } else {
-      logger.warn(`[EventSource ${id}] no child process found in processes map`);
-    }
-
-    // 停止定时器
-    const timer = this.timers.get(id);
-    if (timer) {
-      clearInterval(timer);
-      this.timers.delete(id);
-    }
-
-    // 清理缓冲区
-    this.buffers.delete(id);
-
-    const config = this.sources.get(id);
-    this.statuses.set(id, "stopped");
-
-    // 发布事件
-    this.getEnv()?.pushEnvEvent({
-      type: "event-source.stopped",
-      payload: { sourceId: id, sourceType: config?.type },
-    });
-
-    logger.info(`EventSource stopped: ${id}`);
-  }
-
-  // ========================================================================
-  // 跨平台进程查找
-  // ========================================================================
-
-  /**
-   * 根据命令模式查找所有相关进程 PID
-   * 
-   * @param pattern 命令模式，用于匹配进程
-   * @returns 匹配的 PID 列表
-   */
-  private async findRelatedProcesses(pattern: string): Promise<number[]> {
-    const pids: number[] = [];
-    const platform = process.platform;
-
-    try {
-      const exec = getExecAsync();
-
-      if (platform === "win32") {
-        // Windows: 使用 PowerShell
-        // 使用 -Command 参数执行 PowerShell 命令
-        // Get-Process 获取所有进程，然后用 Where-Object 过滤
-        // 注意：需要处理命令注入，使用 -LiteralPath 或适当转义
-        const escapedPattern = pattern.replace(/'/g, "''").replace(/"/g, '`"');
-        const psCommand = `Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like '*${escapedPattern}*' } | Select-Object -ExpandProperty ProcessId`;
-        const { stdout } = await exec(`powershell -Command "${psCommand}"`);
-        // 解析输出，提取 PID（处理 \r\n）
-        const matches = stdout.replace(/\r\n/g, "\n").match(/\d+/g);
-        if (matches) {
-          for (const match of matches) {
-            const pid = parseInt(match, 10);
-            if (!isNaN(pid) && pid > 0) {
-              pids.push(pid);
-            }
-          }
-        }
-      } else {
-        // Unix (Linux/macOS): 使用 pgrep
-        // 用引号包裹模式，避免注入
-        const { stdout } = await exec(`pgrep -f "${pattern.replace(/"/g, '\\"')}"`);
-        const lines = stdout.trim().split("\n");
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed) {
-            const pid = parseInt(trimmed, 10);
-            if (!isNaN(pid) && pid > 0) {
-              pids.push(pid);
-            }
-          }
-        }
-      }
-    } catch (error) {
-      // pgrep 在没有匹配进程时返回错误，这是正常的
-      logger.debug(`[EventSource] findRelatedProcesses: no processes found for pattern "${pattern}"`);
-    }
-
-    return pids;
-  }
-
-  /**
-   * 查找并记录所有相关进程 PID
-   * 
-   * @param id 事件源 ID
-   */
-  private async trackRelatedProcesses(id: string): Promise<void> {
-    const processInfo = this.processes.get(id);
-    if (!processInfo) return;
-
-    // 查找匹配命令模式的进程
-    // 使用更宽松的模式来匹配所有相关进程
-    const command = processInfo?.command || "";
-    
-    // 提取命令的关键部分用于匹配（如 "lark-cli"）
-    // 这样可以匹配 node lark-cli 和 lark-cli binary 两种进程
-    const commandParts = command.split(" ");
-    const baseCommand = commandParts[0]; // 如 "lark-cli"
-    const eventKeyword = "event"; // 用于进一步匹配事件订阅相关的进程
-
-    // 先用基础命令查找所有相关进程
-    let relatedPids = await this.findRelatedProcesses(baseCommand);
-    
-    // 如果找到的进程太少，再用更完整的模式查找
-    if (relatedPids.length < 2) {
-      const morePids = await this.findRelatedProcesses(eventKeyword);
-      for (const pid of morePids) {
-        if (!relatedPids.includes(pid)) {
-          relatedPids.push(pid);
-        }
-      }
-    }
-
-    // 过滤掉 roy-agent 自身的进程（通过进程名判断）
-    const ownPid = process.pid;
-    relatedPids = relatedPids.filter(pid => pid !== ownPid);
-
-    // 添加到已有的 PID 列表中
-    for (const pid of relatedPids) {
-      if (!processInfo.pids.includes(pid)) {
-        processInfo.pids.push(pid);
-      }
-    }
-
-    // 确保主进程 PID 也在列表中
-    const mainPid = processInfo.child.pid;
-    if (mainPid && !processInfo.pids.includes(mainPid)) {
-      processInfo.pids.unshift(mainPid);
-    }
-
-    logger.info(`[EventSource ${id}] tracked ${processInfo.pids.length} related processes: ${processInfo.pids.join(", ")}`);
-  }
-
-  // ========================================================================
-  // 事件源启动实现
-  // ========================================================================
-
-  /**
-   * 启动 lark-cli 事件源
-   * 返回 Promise，只有在进程真正成功启动后才 resolve
-   */
-  private startLarkCli(id: string, config: EventSourceConfig): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const command = config.command || "lark-cli event +subscribe";
-      
-      logger.info(`Starting lark-cli event source: ${id}`);
-      logger.debug(`Executing command: ${command}`);
-
-      // 启动子进程
-      // 根据平台选择正确的 shell
-      // - Unix (Linux/macOS): 使用 sh
-      // - Windows: 使用 cmd.exe
-      const isWindows = process.platform === "win32";
-      const shell = isWindows ? "cmd.exe" : "sh";
-      const shellArgs = isWindows 
-        ? ["/c", command]           // Windows: /c 执行命令后退出
-        : ["-c", `exec ${command}`]; // Unix: -c 执行命令
-
-      const child = spawn(shell, shellArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: false,
-        windowsHide: true,
-      });
-
-      // 存储进程信息，包括主 PID 和后续查找的相关 PID 列表
-      this.processes.set(id, {
-        child,
-        pgid: (child as any).pgid,
-        pids: [], // 存储所有相关进程 PID
-        command,
-      });
-
-      let startupTimeout: NodeJS.Timeout | null = null;
-      let settled = false;
-      let startupConfirmed = false;
-
-      // 启动成功时的处理：标记状态并追踪所有相关进程
-      const handleStartupSuccess = async () => {
-        if (settled) return;
-        settled = true;
-        startupConfirmed = true;
-        clearTimeout(startupTimeout!);
-        this.statuses.set(id, "running");
-        logger.info(`[EventSource ${id}] confirmed running`);
-        
-        // 追踪所有相关进程（同步，确保启动后立即记录）
-        try {
-          await this.trackRelatedProcesses(id);
-        } catch (e) {
-          logger.warn(`[EventSource ${id}] failed to track related processes: ${e}`);
-        }
-        
-        resolve();
-      };
-
-      // 启动成功确认：1秒内没有退出且没有错误输出，则认为成功
-      startupTimeout = setTimeout(() => {
-        if (!settled && !startupConfirmed) {
-          handleStartupSuccess();
-        }
-      }, 1000);
-
-      // 处理输出流
-      child.stdout?.on("data", (data: Buffer) => {
-        const output = data.toString();
-        
-        // 处理事件流
-        this.processStream(id, output);
-
-        // 检查是否成功订阅（根据 lark-cli 输出 ok: true）
-        if (output.includes('"ok": true') || output.includes('"ok":true')) {
-          if (!settled) {
-            handleStartupSuccess();
-          }
-        }
-      });
-
-      // 处理错误流
-      child.stderr?.on("data", (data: Buffer) => {
-        const output = data.toString();
-        
-        // 检查是否是致命错误（如 "another instance is running"）
-        if (output.includes('"ok": false') || output.includes('"ok":false')) {
-          if (!settled) {
-            settled = true;
-            clearTimeout(startupTimeout!);
-            this.statuses.set(id, "error");
-            child.kill();
-            // 提取错误消息
-            try {
-              const errorObj = JSON.parse(output);
-              reject(new Error(errorObj.error?.message || `lark-cli error: ${output}`));
-            } catch {
-              reject(new Error(`lark-cli error: ${output}`));
-            }
-          }
-        }
-      });
-
-      // 进程退出处理（只有非正常退出才拒绝）
-      child.on("exit", (code) => {
-        if (!settled) {
-          if (code !== 0 && code !== null) {
-            settled = true;
-            clearTimeout(startupTimeout!);
-            logger.warn(`[EventSource ${id}] exited with code ${code}`);
-            this.statuses.set(id, "error");
-            reject(new Error(`lark-cli exited with code ${code}`));
-          }
-          // 如果 code === 0（正常退出但不应该发生），则由 startupTimeout 处理
-        }
-      });
-
-      child.on("error", (error) => {
-        if (!settled) {
-          settled = true;
-          clearTimeout(startupTimeout!);
-          logger.error(`[EventSource ${id}] process error:`, error);
-          this.statuses.set(id, "error");
-          reject(error);
-        }
-      });
-    });
-  }
-
-  /**
-   * 启动定时器事件源
-   */
-  private async startTimer(id: string, config: EventSourceConfig): Promise<void> {
-    const interval = config.interval || 60000;  // 默认 1 分钟
-    
-    logger.info(`Starting timer event source: ${id}, interval: ${interval}ms`);
-
-    // 创建定时器
-    const timer = setInterval(() => {
-      const message = config.options?.message as string || `Timer event from ${config.name}`;
-      this.handleEvent(id, JSON.stringify({
-        type: "timer.tick",
-        payload: {
-          message,
-          timestamp: Date.now(),
-        },
-      }));
-    }, interval);
-
-    this.timers.set(id, timer);
-
-    // 立即触发一次
-    this.handleEvent(id, JSON.stringify({
-      type: "timer.tick",
-      payload: {
-        message: config.options?.message as string || `Timer event from ${config.name}`,
-        timestamp: Date.now(),
-      },
-    }));
-  }
-
-  /**
-   * 启动 WebSocket 事件源
-   */
-  private async startWebSocket(id: string, config: EventSourceConfig): Promise<void> {
-    const url = config.url;
-    if (!url) {
-      throw new Error("WebSocket URL is required");
-    }
-
-    logger.info(`Starting WebSocket event source: ${id}, url: ${url}`);
-
-    // 动态导入 ws 模块
-    try {
-      const { WebSocket } = await import("ws");
-      
-      const ws = new WebSocket(url, {
-        headers: config.headers,
-      });
-
-      // 将 WebSocket 包装为可关闭的进程
-      const wrapper: ProcessInfo = {
-        child: {
-          kill: () => ws.close(),
-          on: (event: string, cb: (...args: unknown[]) => void) => {
-            ws.on(event as any, cb as any);
-          },
-        } as any,
-        pids: [],
-      };
-
-      this.processes.set(id, wrapper);
-
-      ws.on("message", (data: any) => {
-        this.processStream(id, data.toString());
-      });
-
-      ws.on("error", (error) => {
-        logger.error(`[EventSource ${id}] WebSocket error:`, error);
-      });
-
-      ws.on("close", () => {
-        logger.info(`[EventSource ${id}] WebSocket closed`);
-        this.statuses.set(id, "stopped");
-      });
-
-    } catch (error) {
-      throw new Error(`Failed to import ws module: ${error}`);
-    }
-  }
-
-  // ========================================================================
-  // 事件处理
-  // ========================================================================
-
-  /**
-   * 处理数据流
-   */
-  private processStream(sourceId: string, data: string): void {
-    // 获取或创建缓冲区
-    let buffer = this.buffers.get(sourceId) || "";
-    buffer += data;
-    
-    // 按行处理 NDJSON
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";  // 保留未完成行
-    this.buffers.set(sourceId, buffer);
-    
-    for (const line of lines) {
-      if (line.trim()) {
-        this.handleEvent(sourceId, line);
-      }
-    }
-  }
-
-  /**
-   * 处理事件
-   */
-  handleEvent(sourceId: string, rawData: string): void {
-    const config = this.sources.get(sourceId);
-    if (!config) return;
-
-    try {
-      // 解析事件
-      const rawEvent = JSON.parse(rawData);
-      
-      // 提取事件类型（新格式优先使用 header.event_type）
-      let eventType: string;
-      if (rawEvent.header?.event_type) {
-        // 新格式：lark-cli 实际输出格式
-        eventType = rawEvent.header.event_type;
-      } else if (rawEvent.schema) {
-        // 旧格式：直接使用 schema
-        eventType = `lark.${rawEvent.schema}`;
-      } else if (rawEvent.type) {
-        // 其他格式
-        eventType = rawEvent.type;
-      } else {
-        eventType = "unknown";
-      }
-      
-      // 检查事件类型过滤
-      if (config.eventTypes?.length && !this.matchEventType(eventType, config.eventTypes)) {
-        return;
-      }
-
-      // 提取事件元信息、反馈通道和推荐动作
-      const { metadata, replyChannel, recommendedAction } = this.extractMetadata(config.type, rawEvent, eventType);
-
-      // 格式化消息
-      const message = this.formatEventMessage(config.type, rawEvent, eventType);
-
-      // 创建事件对象
-      const event: EventSourceEvent = {
-        sourceId,
-        type: eventType,
-        timestamp: Date.now(),
-        payload: {
-          sourceId,
-          sourceType: config.type,
-          rawEvent,
-          message,
-          metadata,
-          replyChannel,
-          recommendedAction,
-          timestamp: Date.now(),
-        },
-      };
-
-      // 调用处理器
-      const handler = this.handlers.get(sourceId);
-      if (handler) {
-        try {
-          const result = handler(event);
-          if (result instanceof Promise) {
-            result.catch((error) => {
-              logger.error(`[EventSource ${sourceId}] Handler error:`, error);
-            });
-          }
-        } catch (error) {
-          logger.error(`[EventSource ${sourceId}] Handler error:`, error);
-        }
-      }
-
-      // 发布到环境事件总线
-      this.getEnv()?.pushEnvEvent({
-        type: `event-source.event.${config.type}`,
-        payload: event,
-      });
-
-    } catch (error) {
-      // JSON 解析失败，尝试作为普通文本处理
-      if (error instanceof SyntaxError) {
-        logger.debug(`[EventSource ${sourceId}] Non-JSON data: ${rawData.substring(0, 100)}`);
-        
-        // 作为普通消息处理
-        const config = this.sources.get(sourceId);
-        if (config) {
-          const event: EventSourceEvent = {
-            sourceId,
-            type: "raw",
-            timestamp: Date.now(),
-            payload: {
-              sourceId,
-              sourceType: config.type,
-              rawEvent: rawData,
-              message: rawData,
-              metadata: {},
-              timestamp: Date.now(),
-            },
-          };
-
-          const handler = this.handlers.get(sourceId);
-          if (handler) {
-            handler(event);
-          }
-        }
-      } else {
-        logger.error(`[EventSource ${sourceId}] Failed to handle event:`, error);
-      }
-    }
-  }
-
-  /**
-   * 事件类型匹配（支持通配符）
-   */
-  private matchEventType(eventType: string, patterns: string[]): boolean {
-    for (const pattern of patterns) {
-      if (pattern === "*") return true;
-      if (pattern.endsWith(".*")) {
-        const prefix = pattern.slice(0, -2);
-        if (eventType.startsWith(prefix + ".") || eventType === prefix) return true;
-      }
-      if (eventType === pattern) return true;
-    }
-    return false;
-  }
-
-  /**
-   * 提取事件元信息
-   */
-  private extractMetadata(sourceType: EventSourceType, rawEvent: unknown, eventType?: string): { 
-    metadata: EventMetadata; 
-    replyChannel?: ReplyChannel;
-    recommendedAction?: RecommendedAction;
-  } {
-    const event = rawEvent as Record<string, unknown>;
-    const metadata: EventMetadata = {};
-    let replyChannel: ReplyChannel | undefined;
-    let recommendedAction: RecommendedAction | undefined;
-
-    switch (sourceType) {
-      case "lark-cli":
-        // 飞书事件元信息
-        // 消息可能在 event.message（新版）或直接在 message（旧版）
-        const larkInnerEvent = event.event as Record<string, unknown>;
-        const header = event.header as Record<string, unknown>;
-        const message = (larkInnerEvent?.message || event.message) as Record<string, unknown> | undefined;
-        const sender = (larkInnerEvent?.sender || event.sender) as Record<string, unknown> | undefined;
-        const senderId = sender?.sender_id as Record<string, unknown>;
-
-        if (header) {
-          metadata.eventType = header.event_type as string;
-          metadata.appId = header.app_id as string;
-          metadata.tenantKey = header.tenant_key as string;
-        }
-        if (message) {
-          metadata.chatId = message.chat_id as string;
-          metadata.chatType = message.chat_type as string;
-          metadata.messageId = message.message_id as string;
-          metadata.messageType = message.message_type as string;
-        }
-        if (senderId) {
-          metadata.senderId = senderId.open_id as string || senderId.user_id as string || senderId.union_id as string;
-        }
-
-        // 飞书消息的反馈通道和推荐动作
-        if (eventType === "im.message.receive_v1") {
-          replyChannel = {
-            type: "lark-cli",
-            appId: metadata.appId,
-            chatId: metadata.chatId,
-            messageId: metadata.messageId,
-          };
-          recommendedAction = {
-            action: "处理飞书消息并回复",
-            replyTo: {
-              appId: metadata.appId,
-              chatId: metadata.chatId,
-              messageId: metadata.messageId,
-            },
-          };
-        }
-        break;
-
-      case "timer":
-        // 定时器元信息
-        metadata.eventType = "timer.tick";
-        recommendedAction = {
-          action: "执行定时任务",
-        };
-        break;
-
-      case "websocket":
-        // WebSocket 元信息
-        metadata.eventType = eventType;
-        replyChannel = {
-          type: "websocket",
-        };
-        recommendedAction = {
-          action: "处理 WebSocket 消息",
-        };
-        break;
-
-      default:
-        metadata.eventType = eventType;
-        recommendedAction = {
-          action: "处理事件",
-        };
-    }
-
-    return { metadata, replyChannel, recommendedAction };
-  }
-
-  /**
-   * 格式化事件消息
-   */
-  private formatEventMessage(sourceType: EventSourceType, rawEvent: unknown, eventType?: string): string {
-    const event = rawEvent as Record<string, unknown>;
-    
-    switch (sourceType) {
-      case "lark-cli": {
-        // 飞书消息格式：message 和 sender 在 event 字段下（不是直接在顶层）
-        const larkEvent = event as Record<string, unknown>;
-        const larkInnerEvent = larkEvent.event as Record<string, unknown> | undefined;
-        
-        // 尝试从 event.message 获取消息
-        const larkMessage = (larkInnerEvent?.message || larkEvent.message) as Record<string, unknown> | undefined;
-        const larkSender = (larkInnerEvent?.sender || larkEvent.sender) as Record<string, unknown> | undefined;
-        
-        if (larkMessage) {
-          const senderId = larkSender?.sender_id as Record<string, unknown> | undefined;
-          
-          // 提取发送者 ID
-          const openId = senderId?.open_id as string || 
-                        senderId?.user_id as string ||
-                        senderId?.email as string ||
-                        senderId?.union_id as string ||
-                        "未知用户";
-          
-          // 提取消息内容（content 是 JSON 字符串）
-          let content = "无消息内容";
-          if (larkMessage.content) {
-            try {
-              // 尝试解析 JSON 字符串
-              const contentObj = JSON.parse(larkMessage.content as string);
-              content = contentObj.text || contentObj.content || larkMessage.content as string;
-            } catch {
-              // 解析失败，直接使用原始内容
-              content = larkMessage.content as string;
-            }
-          }
-          
-          return `[飞书消息] ${openId}: ${content}`;
-        }
-        
-        // 旧格式处理
-        const larkSenderRecord = larkEvent.sender as Record<string, unknown> | undefined;
-        const senderIdRecord = larkSenderRecord?.sender_id as Record<string, unknown> | undefined;
-        if (larkEvent.message_id || (larkEvent.schema as string)?.includes("message")) {
-          const senderId = senderIdRecord?.open_id as string || 
-                         senderIdRecord?.user_id as string ||
-                         senderIdRecord?.email as string ||
-                         senderIdRecord?.union_id as string ||
-                         "未知用户";
-          const content = larkEvent.text || larkEvent.content || JSON.stringify(larkEvent);
-          return `[飞书消息] ${senderId}: ${content}`;
-        }
-        
-        // 飞书其他事件
-        return `[飞书事件] ${eventType || larkEvent.schema || "unknown"}`;
-      }
-
-      case "timer": {
-        const timerEvent = event as Record<string, unknown>;
-        const timerMessage = (timerEvent.payload as any)?.message || timerEvent.message || "tick";
-        return `[定时任务] ${timerMessage}`;
-      }
-
-      case "websocket":
-        return `[WebSocket] ${JSON.stringify(rawEvent).substring(0, 200)}`;
-
-      default:
-        return `[${sourceType}] ${JSON.stringify(rawEvent).substring(0, 200)}`;
-    }
-  }
-
-  // ========================================================================
-  // 配置持久化
-  // ========================================================================
-
-  /**
-   * 获取配置文件路径
-   */
-  private getConfigFilePath(): string {
-    if (this.configPath) {
-      return this.configPath;
-    }
-
-    // 默认路径: ~/.roy-agent/event-sources.json
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    const dataDir = join(home, ".roy-agent");
-    
-    if (!existsSync(dataDir)) {
-      mkdirSync(dataDir, { recursive: true });
-    }
-
-    return join(dataDir, "event-sources.json");
-  }
-
-  /**
-   * 持久化配置
-   */
-  async saveConfig(): Promise<void> {
-    if (!this.persistenceEnabled) {
-      return;
-    }
-
-    try {
-      const configPath = this.getConfigFilePath();
-      const config: EventSourcePersistenceConfig = {
-        version: "1.0.0",
-        sources: Array.from(this.sources.values()),
-      };
-
-      const content = JSON.stringify(config, null, 2);
-      writeFileSync(configPath, content, "utf-8");
-      
-      logger.debug(`Saved ${this.sources.size} event source configurations to ${configPath}`);
-    } catch (error) {
-      logger.error("Failed to save event source configurations:", error);
-      throw error;
-    }
-  }
-
-  /**
-   * 加载配置
-   */
-  async loadConfig(): Promise<void> {
-    if (!this.persistenceEnabled) {
-      return;
-    }
-
-    try {
-      const configPath = this.getConfigFilePath();
-      
-      if (!existsSync(configPath)) {
-        logger.debug(`No event source config file found at ${configPath}`);
-        return;
-      }
-
-      const content = readFileSync(configPath, "utf-8");
-      const config: EventSourcePersistenceConfig = JSON.parse(content);
-
-      if (!config.sources || !Array.isArray(config.sources)) {
-        logger.warn("Invalid event source config format, skipping load");
-        return;
-      }
-
-      // 加载所有事件源配置（不覆盖已存在的）
-      let loadedCount = 0;
-      for (const source of config.sources) {
-        if (!this.sources.has(source.id)) {
-          this.sources.set(source.id, source);
-          this.statuses.set(source.id, "created");
-          loadedCount++;
-        }
-      }
-
-      logger.info(`Loaded ${loadedCount} event source configurations from ${configPath}`);
-    } catch (error) {
-      logger.error("Failed to load event source configurations:", error);
-      // 不抛出错误，允许组件继续运行
-    }
-  }
-}