@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

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

@@ -1,1155 +0,0 @@
-/**
- * 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