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

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

@@ -0,0 +1,1155 @@
+/**
+ * EventSourceComponent
+ *
+ * 事件源组件，管理所有事件源的注册、配置和生命周期
+ */
+import { spawn, exec } from "child_process";
+import { promisify } from "util";
+// execAsync 函数，在测试时会被 mock 替换
+let execAsyncImpl = promisify(exec);
+/**
+ * 设置 execAsync 实现（用于测试）
+ */
+export function setExecAsync(fn) {
+    execAsyncImpl = fn;
+}
+/**
+ * 获取 execAsync 函数
+ */
+function getExecAsync() {
+    return execAsyncImpl;
+}
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { BaseComponent } from "../component.js";
+import { envKeyToConfigKey } from "../../config/env-key.js";
+import { createLogger } from "../log-trace/logger.js";
+import { EVENT_SOURCE_CONFIG_REGISTRATION, EVENT_SOURCE_DEFAULTS } from "./event-source-config-registration.js";
+const logger = createLogger("event-source");
+// ============================================================================
+// EventSourceComponent
+// ============================================================================
+export class EventSourceComponent extends BaseComponent {
+    name = "event-source";
+    version = "1.0.0";
+    // 内部状态
+    sources = new Map();
+    statuses = new Map();
+    processes = new Map();
+    handlers = new Map();
+    timers = new Map();
+    buffers = new Map();
+    // 持久化配置
+    configPath = "";
+    persistenceEnabled = true;
+    /** ConfigComponent 用于配置管理 */
+    configComponent;
+    /** 配置热更新 watcher 清理函数 */
+    configWatcher;
+    // ========================================================================
+    // 组件生命周期
+    // ========================================================================
+    /**
+     * 初始化
+     */
+    async onInit() {
+        // 配置注册已在 init() 方法中完成（通过 ComponentConfig.options 获取）
+        // 加载已保存的事件源配置
+        await this.loadConfig();
+    }
+    /**
+     * 公开的初始化方法，用于子类覆盖
+     *
+     * 这个方法会被 BaseComponent.init() 调用，用于执行子类特有的初始化逻辑。
+     * 它接收 ComponentConfig，并通过 ComponentConfig.options 获取 EventSourceComponentOptions。
+     */
+    async init(options) {
+        // 如果提供了 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;
+        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");
+    }
+    async onStart() {
+        // onStart 时不再重复加载（已在 onInit 中加载）
+    }
+    async onStop() {
+        // 清理配置 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 对象 - 直接传入的配置（最高）
+     */
+    async registerConfig(options) {
+        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);
+    }
+    /**
+     * 构建最终配置对象
+     */
+    buildConfig() {
+        const configComponent = this.configComponent;
+        if (!configComponent) {
+            return {
+                enabled: true,
+                persistenceEnabled: true,
+                configPath: "",
+            };
+        }
+        return {
+            enabled: configComponent.get("event-source.enabled") ?? true,
+            persistenceEnabled: configComponent.get("event-source.persistenceEnabled") ?? true,
+            configPath: configComponent.get("event-source.configPath") ?? "",
+        };
+    }
+    /**
+     * 将配置对象展平为点号路径
+     */
+    flattenConfig(obj, prefix = "event-source") {
+        const result = {};
+        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, fullKey));
+            }
+            else {
+                result[fullKey] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * 注册配置热更新监听
+     */
+    registerConfigWatcher(configComponent) {
+        if (typeof configComponent.watch !== "function") {
+            return;
+        }
+        this.configWatcher = configComponent.watch("event-source.*", (event) => {
+            this.onConfigChange(event);
+        });
+    }
+    /**
+     * 处理配置变更
+     */
+    onConfigChange(event) {
+        logger.info(`EventSource config changed: ${event.key}`, {
+            oldValue: event.oldValue,
+            newValue: event.newValue
+        });
+    }
+    // ========================================================================
+    // 事件源注册与管理
+    // ========================================================================
+    /**
+     * 注册事件源
+     */
+    register(config) {
+        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) {
+        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) {
+        return this.sources.get(id);
+    }
+    /**
+     * 列出所有事件源
+     */
+    list() {
+        return Array.from(this.sources.values());
+    }
+    /**
+     * 获取事件源状态
+     */
+    getEventSourceStatus(id) {
+        return this.statuses.get(id);
+    }
+    /**
+     * 获取指定事件源的状态
+     */
+    getEventSourceStatusById(id) {
+        return this.statuses.get(id);
+    }
+    /**
+     * 设置事件处理器
+     */
+    onEvent(id, handler) {
+        this.handlers.set(id, handler);
+    }
+    /**
+     * 移除事件处理器
+     */
+    offEvent(id) {
+        this.handlers.delete(id);
+    }
+    // ========================================================================
+    // 生命周期控制
+    // ========================================================================
+    /**
+     * 启动事件源
+     *
+     * 注意：方法名为 startSource 而非 start，以避免覆盖 Component 接口的 start() 方法
+     */
+    async startSource(id) {
+        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) {
+        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, signal) => {
+                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((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.pid;
+            const pgid = child.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.kill("SIGTERM");
+                // 等待进程退出，最多 3 秒
+                await new Promise((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.kill("SIGKILL");
+                        resolve();
+                    }, 3000);
+                    child.once("exit", () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                });
+            }
+            catch (error) {
+                logger.error(`[EventSource ${id}] Failed to kill process:`, error);
+                // 确保最终使用 SIGKILL
+                try {
+                    child.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 列表
+     */
+    async findRelatedProcesses(pattern) {
+        const pids = [];
+        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
+     */
+    async trackRelatedProcesses(id) {
+        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
+     */
+    startLarkCli(id, config) {
+        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.pgid,
+                pids: [], // 存储所有相关进程 PID
+                command,
+            });
+            let startupTimeout = 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) => {
+                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) => {
+                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);
+                }
+            });
+        });
+    }
+    /**
+     * 启动定时器事件源
+     */
+    async startTimer(id, config) {
+        const interval = config.interval || 60000; // 默认 1 分钟
+        logger.info(`Starting timer event source: ${id}, interval: ${interval}ms`);
+        // 创建定时器
+        const timer = setInterval(() => {
+            const message = config.options?.message || `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 || `Timer event from ${config.name}`,
+                timestamp: Date.now(),
+            },
+        }));
+    }
+    /**
+     * 启动 WebSocket 事件源
+     */
+    async startWebSocket(id, config) {
+        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 = {
+                child: {
+                    kill: () => ws.close(),
+                    on: (event, cb) => {
+                        ws.on(event, cb);
+                    },
+                },
+                pids: [],
+            };
+            this.processes.set(id, wrapper);
+            ws.on("message", (data) => {
+                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}`);
+        }
+    }
+    // ========================================================================
+    // 事件处理
+    // ========================================================================
+    /**
+     * 处理数据流
+     */
+    processStream(sourceId, data) {
+        // 获取或创建缓冲区
+        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, rawData) {
+        const config = this.sources.get(sourceId);
+        if (!config)
+            return;
+        try {
+            // 解析事件
+            const rawEvent = JSON.parse(rawData);
+            // 提取事件类型（新格式优先使用 header.event_type）
+            let eventType;
+            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 = {
+                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 = {
+                        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);
+            }
+        }
+    }
+    /**
+     * 事件类型匹配（支持通配符）
+     */
+    matchEventType(eventType, patterns) {
+        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;
+    }
+    /**
+     * 提取事件元信息
+     */
+    extractMetadata(sourceType, rawEvent, eventType) {
+        const event = rawEvent;
+        const metadata = {};
+        let replyChannel;
+        let recommendedAction;
+        switch (sourceType) {
+            case "lark-cli":
+                // 飞书事件元信息
+                // 消息可能在 event.message（新版）或直接在 message（旧版）
+                const larkInnerEvent = event.event;
+                const header = event.header;
+                const message = (larkInnerEvent?.message || event.message);
+                const sender = (larkInnerEvent?.sender || event.sender);
+                const senderId = sender?.sender_id;
+                if (header) {
+                    metadata.eventType = header.event_type;
+                    metadata.appId = header.app_id;
+                    metadata.tenantKey = header.tenant_key;
+                }
+                if (message) {
+                    metadata.chatId = message.chat_id;
+                    metadata.chatType = message.chat_type;
+                    metadata.messageId = message.message_id;
+                    metadata.messageType = message.message_type;
+                }
+                if (senderId) {
+                    metadata.senderId = senderId.open_id || senderId.user_id || senderId.union_id;
+                }
+                // 飞书消息的反馈通道和推荐动作
+                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 };
+    }
+    /**
+     * 格式化事件消息
+     */
+    formatEventMessage(sourceType, rawEvent, eventType) {
+        const event = rawEvent;
+        switch (sourceType) {
+            case "lark-cli": {
+                // 飞书消息格式：message 和 sender 在 event 字段下（不是直接在顶层）
+                const larkEvent = event;
+                const larkInnerEvent = larkEvent.event;
+                // 尝试从 event.message 获取消息
+                const larkMessage = (larkInnerEvent?.message || larkEvent.message);
+                const larkSender = (larkInnerEvent?.sender || larkEvent.sender);
+                if (larkMessage) {
+                    const senderId = larkSender?.sender_id;
+                    // 提取发送者 ID
+                    const openId = senderId?.open_id ||
+                        senderId?.user_id ||
+                        senderId?.email ||
+                        senderId?.union_id ||
+                        "未知用户";
+                    // 提取消息内容（content 是 JSON 字符串）
+                    let content = "无消息内容";
+                    if (larkMessage.content) {
+                        try {
+                            // 尝试解析 JSON 字符串
+                            const contentObj = JSON.parse(larkMessage.content);
+                            content = contentObj.text || contentObj.content || larkMessage.content;
+                        }
+                        catch {
+                            // 解析失败，直接使用原始内容
+                            content = larkMessage.content;
+                        }
+                    }
+                    return `[飞书消息] ${openId}: ${content}`;
+                }
+                // 旧格式处理
+                const larkSenderRecord = larkEvent.sender;
+                const senderIdRecord = larkSenderRecord?.sender_id;
+                if (larkEvent.message_id || larkEvent.schema?.includes("message")) {
+                    const senderId = senderIdRecord?.open_id ||
+                        senderIdRecord?.user_id ||
+                        senderIdRecord?.email ||
+                        senderIdRecord?.union_id ||
+                        "未知用户";
+                    const content = larkEvent.text || larkEvent.content || JSON.stringify(larkEvent);
+                    return `[飞书消息] ${senderId}: ${content}`;
+                }
+                // 飞书其他事件
+                return `[飞书事件] ${eventType || larkEvent.schema || "unknown"}`;
+            }
+            case "timer": {
+                const timerEvent = event;
+                const timerMessage = timerEvent.payload?.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)}`;
+        }
+    }
+    // ========================================================================
+    // 配置持久化
+    // ========================================================================
+    /**
+     * 获取配置文件路径
+     */
+    getConfigFilePath() {
+        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() {
+        if (!this.persistenceEnabled) {
+            return;
+        }
+        try {
+            const configPath = this.getConfigFilePath();
+            const config = {
+                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() {
+        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 = 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);
+            // 不抛出错误，允许组件继续运行
+        }
+    }
+}
+//# sourceMappingURL=event-source-component.js.map