@ai-setting/roy-agent-core 1.5.17-beta.1 → 1.5.22

package/dist/shared/@ai-setting/{roy-agent-core-gbqcyegm.js → roy-agent-core-rccptwv0.js}

@@ -426,8 +426,6 @@ __legacyDecorateClassTS([
   TracedAs("env.handle_query", { recordParams: true, recordResult: true, log: true })
 ], BaseEnvironment.prototype, "handle_query", null);
 // src/env/event-source/event-source-component.ts
-import { spawn, exec } from "child_process";
-import { promisify } from "util";
 import { join } from "path";
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 init_logger();
@@ -449,11 +447,426 @@ var EVENT_SOURCE_CONFIG_REGISTRATION = {
   ]
 };
 
-// src/env/event-source/event-source-component.ts
-var execAsyncImpl = promisify(exec);
-function getExecAsync() {
-  return execAsyncImpl;
+// src/env/event-source/event-source-handlers.ts
+import { spawn } from "child_process";
+function 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;
+}
+function formatEventMessage(sourceType, rawEvent, eventType) {
+  const event = rawEvent;
+  switch (sourceType) {
+    case "lark-cli": {
+      const larkEvent = event;
+      const larkInnerEvent = larkEvent.event;
+      const larkMessage = larkInnerEvent?.message || larkEvent.message;
+      const larkSender = larkInnerEvent?.sender || larkEvent.sender;
+      const senderId = larkSender?.sender_id;
+      if (larkMessage) {
+        const openId = senderId?.open_id || senderId?.user_id || senderId?.email || senderId?.union_id || "未知用户";
+        let content = "无消息内容";
+        if (larkMessage.content) {
+          try {
+            const contentObj = JSON.parse(larkMessage.content);
+            content = contentObj.text || contentObj.content || larkMessage.content;
+          } catch {
+            content = larkMessage.content;
+          }
+        }
+        return `[飞书消息] ${openId}: ${content}`;
+      }
+      return `[飞书事件] ${eventType || larkEvent.schema || "unknown"}`;
+    }
+    case "timer": {
+      const timerMessage = event.payload?.message || event.message || "tick";
+      return `[定时任务] ${timerMessage}`;
+    }
+    case "websocket":
+      return `[WebSocket] ${JSON.stringify(rawEvent).substring(0, 200)}`;
+    default:
+      return `[${sourceType}] ${JSON.stringify(rawEvent).substring(0, 200)}`;
+  }
+}
+function extractMetadata(sourceType, rawEvent, eventType) {
+  const event = rawEvent;
+  const metadata = {};
+  switch (sourceType) {
+    case "lark-cli": {
+      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;
+      }
+      break;
+    }
+    case "timer":
+      metadata.eventType = "timer.tick";
+      break;
+    case "websocket":
+      metadata.eventType = eventType;
+      break;
+    default:
+      metadata.eventType = eventType;
+  }
+  let recommendedAction;
+  if (sourceType === "lark-cli" && eventType === "im.message.receive_v1") {
+    recommendedAction = {
+      action: "处理飞书消息并回复",
+      replyTo: {
+        appId: metadata.appId,
+        chatId: metadata.chatId,
+        messageId: metadata.messageId
+      }
+    };
+  } else if (sourceType === "timer") {
+    recommendedAction = { action: "执行定时任务" };
+  } else if (sourceType === "websocket") {
+    recommendedAction = { action: "处理 WebSocket 消息" };
+  }
+  let replyChannel;
+  if (sourceType === "lark-cli") {
+    replyChannel = {
+      type: "lark-cli",
+      appId: metadata.appId,
+      chatId: metadata.chatId,
+      messageId: metadata.messageId
+    };
+  } else if (sourceType === "websocket") {
+    replyChannel = { type: "websocket" };
+  }
+  return { metadata, replyChannel, recommendedAction };
+}
+
+class LarkCliInstance {
+  config;
+  status = "created";
+  child;
+  buffer = "";
+  eventHandler;
+  constructor(config) {
+    this.config = config;
+  }
+  async start() {
+    if (this.status === "running")
+      return;
+    const command = this.config.command || "lark-cli event +subscribe";
+    const isWindows = process.platform === "win32";
+    const shell = isWindows ? "cmd.exe" : "sh";
+    const shellArgs = isWindows ? ["/c", command] : ["-c", `exec ${command}`];
+    this.child = spawn(shell, shellArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+      windowsHide: true
+    });
+    this.child.stdout?.on("data", (data) => {
+      this.processStream(data.toString());
+    });
+    this.child.stderr?.on("data", (data) => {
+      const output = data.toString();
+      if (output.includes('"ok": false')) {
+        this.status = "error";
+      }
+    });
+    this.child.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        this.status = "error";
+      }
+    });
+    await new Promise((resolve2) => setTimeout(resolve2, 1000));
+    this.status = "running";
+  }
+  async stop() {
+    if (this.status === "stopped" || this.status === "created")
+      return;
+    this.child?.kill("SIGTERM");
+    this.child = undefined;
+    this.buffer = "";
+    this.status = "stopped";
+  }
+  getStatus() {
+    return this.status;
+  }
+  onEvent(handler) {
+    this.eventHandler = handler;
+  }
+  offEvent() {
+    this.eventHandler = undefined;
+  }
+  processStream(data) {
+    this.buffer += data;
+    const lines = this.buffer.split(`
+`);
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line.trim()) {
+        this.handleEvent(line);
+      }
+    }
+  }
+  handleEvent(rawData) {
+    try {
+      let rawEvent;
+      try {
+        rawEvent = JSON.parse(rawData);
+      } catch {
+        rawEvent = { event: "message", data: { content: { type: "text", body: rawData } } };
+      }
+      const event = rawEvent;
+      let eventType;
+      if (event.header?.event_type) {
+        eventType = event.header.event_type;
+      } else if (event.schema) {
+        eventType = `lark.${event.schema}`;
+      } else if (event.type) {
+        eventType = event.type;
+      } else {
+        eventType = "unknown";
+      }
+      if (this.config.eventTypes?.length && !matchEventType(eventType, this.config.eventTypes)) {
+        return;
+      }
+      const { metadata, replyChannel, recommendedAction } = extractMetadata("lark-cli", rawEvent, eventType);
+      const message = formatEventMessage("lark-cli", rawEvent, eventType);
+      const evt = {
+        sourceId: this.config.id,
+        type: eventType,
+        timestamp: Date.now(),
+        payload: {
+          sourceId: this.config.id,
+          sourceType: "lark-cli",
+          rawEvent,
+          message,
+          metadata,
+          replyChannel,
+          recommendedAction,
+          timestamp: Date.now()
+        }
+      };
+      this.eventHandler?.(evt);
+    } catch (error) {}
+  }
 }
+var larkCliHandler = {
+  type: "lark-cli",
+  validateConfig(config) {
+    const errors = [];
+    if (!config.command) {
+      errors.push("lark-cli command is required");
+    }
+    return errors;
+  },
+  createInstance(config) {
+    return new LarkCliInstance(config);
+  }
+};
+
+class TimerInstance {
+  config;
+  status = "created";
+  timer;
+  eventHandler;
+  constructor(config) {
+    this.config = config;
+  }
+  async start() {
+    if (this.status === "running")
+      return;
+    const interval = this.config.interval || 60000;
+    const message = this.config.options?.message || `Timer event from ${this.config.name}`;
+    this.timer = setInterval(() => {
+      this.emitEvent(message);
+    }, interval);
+    this.emitEvent(message);
+    this.status = "running";
+  }
+  async stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+    this.status = "stopped";
+  }
+  getStatus() {
+    return this.status;
+  }
+  onEvent(handler) {
+    this.eventHandler = handler;
+  }
+  offEvent() {
+    this.eventHandler = undefined;
+  }
+  emitEvent(message) {
+    const rawEvent = {
+      type: "timer.tick",
+      payload: {
+        message,
+        timestamp: Date.now()
+      }
+    };
+    const { metadata, recommendedAction } = extractMetadata("timer", rawEvent, "timer.tick");
+    const evt = {
+      sourceId: this.config.id,
+      type: "timer.tick",
+      timestamp: Date.now(),
+      payload: {
+        sourceId: this.config.id,
+        sourceType: "timer",
+        rawEvent,
+        message: formatEventMessage("timer", rawEvent),
+        metadata,
+        recommendedAction,
+        timestamp: Date.now()
+      }
+    };
+    this.eventHandler?.(evt);
+  }
+}
+var timerHandler = {
+  type: "timer",
+  validateConfig(config) {
+    const errors = [];
+    if (!config.interval || config.interval <= 0) {
+      errors.push("Timer interval must be a positive number");
+    }
+    return errors;
+  },
+  createInstance(config) {
+    return new TimerInstance(config);
+  }
+};
+
+class WebSocketInstance {
+  config;
+  status = "created";
+  ws;
+  buffer = "";
+  eventHandler;
+  constructor(config) {
+    this.config = config;
+  }
+  async start() {
+    if (this.status === "running")
+      return;
+    const url = this.config.url;
+    if (!url) {
+      throw new Error("WebSocket URL is required");
+    }
+    const { WebSocket } = await import("ws");
+    this.ws = new WebSocket(url, { headers: this.config.headers });
+    this.ws.on("open", () => {
+      this.status = "running";
+    });
+    this.ws.on("message", (data) => {
+      this.processStream(data.toString());
+    });
+    this.ws.on("error", () => {
+      this.status = "error";
+    });
+    this.ws.on("close", () => {
+      this.status = "stopped";
+    });
+    await new Promise((resolve2) => setTimeout(resolve2, 5000));
+  }
+  async stop() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = undefined;
+    }
+    this.buffer = "";
+    this.status = "stopped";
+  }
+  getStatus() {
+    return this.status;
+  }
+  onEvent(handler) {
+    this.eventHandler = handler;
+  }
+  offEvent() {
+    this.eventHandler = undefined;
+  }
+  processStream(data) {
+    this.buffer += data;
+    const lines = this.buffer.split(`
+`);
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line.trim()) {
+        this.handleEvent(line);
+      }
+    }
+  }
+  handleEvent(rawData) {
+    try {
+      let rawEvent;
+      try {
+        rawEvent = JSON.parse(rawData);
+      } catch {
+        rawEvent = rawData;
+      }
+      const { metadata, replyChannel, recommendedAction } = extractMetadata("websocket", rawEvent);
+      const evt = {
+        sourceId: this.config.id,
+        type: "websocket.message",
+        timestamp: Date.now(),
+        payload: {
+          sourceId: this.config.id,
+          sourceType: "websocket",
+          rawEvent,
+          message: formatEventMessage("websocket", rawEvent),
+          metadata,
+          replyChannel,
+          recommendedAction,
+          timestamp: Date.now()
+        }
+      };
+      this.eventHandler?.(evt);
+    } catch (error) {}
+  }
+}
+var websocketHandler = {
+  type: "websocket",
+  validateConfig(config) {
+    const errors = [];
+    if (!config.url) {
+      errors.push("WebSocket URL is required");
+    }
+    return errors;
+  },
+  createInstance(config) {
+    return new WebSocketInstance(config);
+  }
+};
+var builtInHandlers = [
+  larkCliHandler,
+  timerHandler,
+  websocketHandler
+];
+
+// src/env/event-source/event-source-component.ts
 var logger2 = createLogger("event-source");
 
 class EventSourceComponent extends BaseComponent {
@@ -461,15 +874,16 @@ class EventSourceComponent extends BaseComponent {
   version = "1.0.0";
   sources = new Map;
   statuses = new Map;
-  processes = new Map;
   handlers = new Map;
-  timers = new Map;
+  instances = new Map;
+  eventHandlers = new Map;
   buffers = new Map;
   configPath = "";
   persistenceEnabled = true;
   configComponent;
   configWatcher;
   async onInit() {
+    await this.executeInitHooks();
     await this.loadConfig();
   }
   async init(options) {
@@ -487,6 +901,9 @@ class EventSourceComponent extends BaseComponent {
     if (opts?.configComponent) {
       this.configComponent = opts.configComponent;
       await this.registerConfig(opts);
+      if (opts.registerBuiltInHandlers !== false) {
+        this.registerBuiltInHandlers();
+      }
     } else {
       throw new Error("ConfigComponent is required for EventSourceComponent initialization");
     }
@@ -503,11 +920,43 @@ class EventSourceComponent extends BaseComponent {
     }
     this.sources.clear();
     this.statuses.clear();
-    this.processes.clear();
+    this.instances.clear();
+    this.eventHandlers.clear();
     this.handlers.clear();
-    this.timers.clear();
     this.buffers.clear();
   }
+  registerBuiltInHandlers() {
+    for (const handler of builtInHandlers) {
+      if (!this.handlers.has(handler.type)) {
+        this.handlers.set(handler.type, handler);
+        logger2.debug(`Registered built-in handler: ${handler.type}`);
+      }
+    }
+  }
+  async executeInitHooks() {
+    const { EventSourceInitHooks } = await import("./roy-agent-core-8jxva565.js");
+    await EventSourceInitHooks.execute(this);
+  }
+  registerHandler(handler) {
+    if (this.handlers.has(handler.type)) {
+      logger2.warn(`Handler already registered for type: ${handler.type}, overwriting`);
+    }
+    this.handlers.set(handler.type, handler);
+    logger2.debug(`Handler registered: ${handler.type}`);
+  }
+  unregisterHandler(type) {
+    const deleted = this.handlers.delete(type);
+    if (deleted) {
+      logger2.debug(`Handler unregistered: ${type}`);
+    }
+    return deleted;
+  }
+  getHandler(type) {
+    return this.handlers.get(type);
+  }
+  listHandlers() {
+    return Array.from(this.handlers.values());
+  }
   async registerConfig(options) {
     const configComponent = options.configComponent;
     if (!configComponent)
@@ -560,11 +1009,7 @@ class EventSourceComponent extends BaseComponent {
   buildConfig() {
     const configComponent = this.configComponent;
     if (!configComponent) {
-      return {
-        enabled: true,
-        persistenceEnabled: true,
-        configPath: ""
-      };
+      return { enabled: true, persistenceEnabled: true, configPath: "" };
     }
     return {
       enabled: configComponent.get("event-source.enabled") ?? true,
@@ -585,9 +1030,8 @@ class EventSourceComponent extends BaseComponent {
     return result;
   }
   registerConfigWatcher(configComponent) {
-    if (typeof configComponent.watch !== "function") {
+    if (typeof configComponent.watch !== "function")
       return;
-    }
     this.configWatcher = configComponent.watch("event-source.*", (event) => {
       this.onConfigChange(event);
     });
@@ -602,6 +1046,14 @@ class EventSourceComponent extends BaseComponent {
     if (this.sources.has(config.id)) {
       throw new Error(`EventSource already exists: ${config.id}`);
     }
+    const handler = this.handlers.get(config.type);
+    if (!handler) {
+      throw new Error(`No handler registered for event source type: ${config.type}`);
+    }
+    const errors = handler.validateConfig(config);
+    if (errors.length > 0) {
+      throw new Error(`Invalid config: ${errors.join(", ")}`);
+    }
     this.sources.set(config.id, config);
     this.statuses.set(config.id, "created");
     logger2.debug(`EventSource registered: ${config.id} (${config.type})`);
@@ -617,7 +1069,8 @@ class EventSourceComponent extends BaseComponent {
     const existed = this.sources.has(id);
     this.sources.delete(id);
     this.statuses.delete(id);
-    this.handlers.delete(id);
+    this.instances.delete(id);
+    this.eventHandlers.delete(id);
     this.buffers.delete(id);
     if (existed) {
       logger2.debug(`EventSource unregistered: ${id}`);
@@ -633,17 +1086,25 @@ class EventSourceComponent extends BaseComponent {
   list() {
     return Array.from(this.sources.values());
   }
-  getEventSourceStatus(id) {
+  getStatus(id) {
     return this.statuses.get(id);
   }
-  getEventSourceStatusById(id) {
-    return this.statuses.get(id);
+  getEventSourceStatus(id) {
+    return this.getStatus(id);
   }
   onEvent(id, handler) {
-    this.handlers.set(id, handler);
+    this.eventHandlers.set(id, handler);
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.onEvent(handler);
+    }
   }
   offEvent(id) {
-    this.handlers.delete(id);
+    this.eventHandlers.delete(id);
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.offEvent();
+    }
   }
   async startSource(id) {
     const config = this.sources.get(id);
@@ -656,19 +1117,17 @@ class EventSourceComponent extends BaseComponent {
     }
     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}`);
+      const handler = this.handlers.get(config.type);
+      if (!handler) {
+        throw new Error(`No handler registered for event source type: ${config.type}`);
       }
+      const instance = handler.createInstance(config);
+      this.instances.set(id, instance);
+      const eventHandler = this.eventHandlers.get(id);
+      if (eventHandler) {
+        instance.onEvent(eventHandler);
+      }
+      await instance.start();
       this.statuses.set(id, "running");
       this.getEnv()?.pushEnvEvent({
         type: "event-source.started",
@@ -689,550 +1148,23 @@ class EventSourceComponent extends BaseComponent {
       return;
     }
     this.statuses.set(id, "stopping");
-    const processInfo = this.processes.get(id);
-    const child = processInfo?.child;
-    logger2.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;
-        }
-      };
-      const pidsToKill = processInfo.pids.length > 0 ? processInfo.pids : processInfo.child.pid ? [processInfo.child.pid] : [];
-      logger2.info(`[EventSource ${id}] sending SIGTERM to ${pidsToKill.length} processes: ${pidsToKill.join(", ")}`);
-      for (const pid of pidsToKill) {
-        killProcess(pid, "SIGTERM");
-      }
-      await new Promise((resolve2) => {
-        const timeout = setTimeout(() => {
-          logger2.warn(`[EventSource ${id}] SIGTERM timeout, sending SIGKILL to ${pidsToKill.length} processes`);
-          for (const pid of pidsToKill) {
-            killProcess(pid, "SIGKILL");
-          }
-          resolve2();
-        }, 3000);
-        try {
-          const onceResult = child.once?.("exit", () => {
-            clearTimeout(timeout);
-            for (const pid of pidsToKill) {
-              if (pid !== processInfo.child.pid) {
-                killProcess(pid, "SIGKILL");
-              }
-            }
-            resolve2();
-          });
-          if (!onceResult || typeof onceResult.once !== "function") {
-            child.on("exit", () => {
-              clearTimeout(timeout);
-              for (const pid of pidsToKill) {
-                if (pid !== processInfo.child.pid) {
-                  killProcess(pid, "SIGKILL");
-                }
-              }
-              resolve2();
-            });
-          }
-        } catch (e) {
-          logger2.warn(`[EventSource ${id}] failed to register exit listener: ${e}`);
-        }
-      });
-      this.processes.delete(id);
-    } else if (child) {
-      child.removeAllListeners("exit");
-      child.removeAllListeners("error");
-      child.stdout?.removeAllListeners("data");
-      child.stderr?.removeAllListeners("data");
-      const pid = child.pid;
-      const pgid = child.pgid;
-      try {
-        if (pgid && pgid > 0 && pgid !== pid) {
-          logger2.info(`[EventSource ${id}] killing process group ${pgid}`);
-          try {
-            process.kill(-pgid, "SIGTERM");
-          } catch (e) {
-            logger2.warn(`[EventSource ${id}] failed to kill process group: ${e}`);
-          }
-        }
-        logger2.info(`[EventSource ${id}] killing main process ${pid}`);
-        child.kill("SIGTERM");
-        await new Promise((resolve2) => {
-          const timeout = setTimeout(() => {
-            logger2.warn(`[EventSource ${id}] SIGTERM timeout, sending SIGKILL`);
-            if (pgid && pgid > 0 && pgid !== pid) {
-              try {
-                process.kill(-pgid, "SIGKILL");
-              } catch (e) {
-                logger2.warn(`[EventSource ${id}] failed to kill process group with SIGKILL: ${e}`);
-              }
-            }
-            child.kill("SIGKILL");
-            resolve2();
-          }, 3000);
-          child.once("exit", () => {
-            clearTimeout(timeout);
-            resolve2();
-          });
-        });
-      } catch (error) {
-        logger2.error(`[EventSource ${id}] Failed to kill process:`, error);
-        try {
-          child.kill("SIGKILL");
-        } catch {}
-      }
-      this.processes.delete(id);
-    } else {
-      logger2.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 }
-    });
-    logger2.info(`EventSource stopped: ${id}`);
-  }
-  async findRelatedProcesses(pattern) {
-    const pids = [];
-    const platform = process.platform;
     try {
-      const exec2 = getExecAsync();
-      if (platform === "win32") {
-        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 exec2(`powershell -Command "${psCommand}"`);
-        const matches = stdout.replace(/\r\n/g, `
-`).match(/\d+/g);
-        if (matches) {
-          for (const match of matches) {
-            const pid = parseInt(match, 10);
-            if (!isNaN(pid) && pid > 0) {
-              pids.push(pid);
-            }
-          }
-        }
-      } else {
-        const { stdout } = await exec2(`pgrep -f "${pattern.replace(/"/g, "\\\"")}"`);
-        const lines = stdout.trim().split(`
-`);
-        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) {
-      logger2.debug(`[EventSource] findRelatedProcesses: no processes found for pattern "${pattern}"`);
-    }
-    return pids;
-  }
-  async trackRelatedProcesses(id) {
-    const processInfo = this.processes.get(id);
-    if (!processInfo)
-      return;
-    const command = processInfo?.command || "";
-    const commandParts = command.split(" ");
-    const baseCommand = commandParts[0];
-    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);
-        }
-      }
-    }
-    const ownPid = process.pid;
-    relatedPids = relatedPids.filter((pid) => pid !== ownPid);
-    for (const pid of relatedPids) {
-      if (!processInfo.pids.includes(pid)) {
-        processInfo.pids.push(pid);
-      }
-    }
-    const mainPid = processInfo.child.pid;
-    if (mainPid && !processInfo.pids.includes(mainPid)) {
-      processInfo.pids.unshift(mainPid);
-    }
-    logger2.info(`[EventSource ${id}] tracked ${processInfo.pids.length} related processes: ${processInfo.pids.join(", ")}`);
-  }
-  startLarkCli(id, config) {
-    return new Promise((resolve2, reject) => {
-      const command = config.command || "lark-cli event +subscribe";
-      logger2.info(`Starting lark-cli event source: ${id}`);
-      logger2.debug(`Executing command: ${command}`);
-      const isWindows = process.platform === "win32";
-      const shell = isWindows ? "cmd.exe" : "sh";
-      const shellArgs = isWindows ? ["/c", command] : ["-c", `exec ${command}`];
-      const child = spawn(shell, shellArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: false,
-        windowsHide: true
-      });
-      this.processes.set(id, {
-        child,
-        pgid: child.pgid,
-        pids: [],
-        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");
-        logger2.info(`[EventSource ${id}] confirmed running`);
-        try {
-          await this.trackRelatedProcesses(id);
-        } catch (e) {
-          logger2.warn(`[EventSource ${id}] failed to track related processes: ${e}`);
-        }
-        resolve2();
-      };
-      startupTimeout = setTimeout(() => {
-        if (!settled && !startupConfirmed) {
-          handleStartupSuccess();
-        }
-      }, 1000);
-      child.stdout?.on("data", (data) => {
-        const output = data.toString();
-        this.processStream(id, output);
-        if (output.includes('"ok": true') || output.includes('"ok":true')) {
-          if (!settled) {
-            handleStartupSuccess();
-          }
-        }
-      });
-      child.stderr?.on("data", (data) => {
-        const output = data.toString();
-        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);
-            logger2.warn(`[EventSource ${id}] exited with code ${code}`);
-            this.statuses.set(id, "error");
-            reject(new Error(`lark-cli exited with code ${code}`));
-          }
-        }
-      });
-      child.on("error", (error) => {
-        if (!settled) {
-          settled = true;
-          clearTimeout(startupTimeout);
-          logger2.error(`[EventSource ${id}] process error:`, error);
-          this.statuses.set(id, "error");
-          reject(error);
-        }
-      });
-    });
-  }
-  async startTimer(id, config) {
-    const interval = config.interval || 60000;
-    logger2.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()
-      }
-    }));
-  }
-  async startWebSocket(id, config) {
-    const url = config.url;
-    if (!url) {
-      throw new Error("WebSocket URL is required");
-    }
-    logger2.info(`Starting WebSocket event source: ${id}, url: ${url}`);
-    try {
-      const { WebSocket } = await import("ws");
-      const ws = new WebSocket(url, {
-        headers: config.headers
-      });
-      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) => {
-        logger2.error(`[EventSource ${id}] WebSocket error:`, error);
-      });
-      ws.on("close", () => {
-        logger2.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;
-    const lines = buffer.split(`
-`);
-    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);
-      let eventType;
-      if (rawEvent.header?.event_type) {
-        eventType = rawEvent.header.event_type;
-      } else if (rawEvent.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) => {
-              logger2.error(`[EventSource ${sourceId}] Handler error:`, error);
-            });
-          }
-        } catch (error) {
-          logger2.error(`[EventSource ${sourceId}] Handler error:`, error);
-        }
+      const instance = this.instances.get(id);
+      if (instance) {
+        await instance.stop();
+        this.instances.delete(id);
       }
+      const config = this.sources.get(id);
+      this.statuses.set(id, "stopped");
       this.getEnv()?.pushEnvEvent({
-        type: `event-source.event.${config.type}`,
-        payload: event
+        type: "event-source.stopped",
+        payload: { sourceId: id, sourceType: config?.type }
       });
+      logger2.info(`EventSource stopped: ${id}`);
     } catch (error) {
-      if (error instanceof SyntaxError) {
-        logger2.debug(`[EventSource ${sourceId}] Non-JSON data: ${rawData.substring(0, 100)}`);
-        const config2 = this.sources.get(sourceId);
-        if (config2) {
-          const event = {
-            sourceId,
-            type: "raw",
-            timestamp: Date.now(),
-            payload: {
-              sourceId,
-              sourceType: config2.type,
-              rawEvent: rawData,
-              message: rawData,
-              metadata: {},
-              timestamp: Date.now()
-            }
-          };
-          const handler = this.handlers.get(sourceId);
-          if (handler) {
-            handler(event);
-          }
-        }
-      } else {
-        logger2.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":
-        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":
-        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": {
-        const larkEvent = event;
-        const larkInnerEvent = larkEvent.event;
-        const larkMessage = larkInnerEvent?.message || larkEvent.message;
-        const larkSender = larkInnerEvent?.sender || larkEvent.sender;
-        if (larkMessage) {
-          const senderId = larkSender?.sender_id;
-          const openId = senderId?.open_id || senderId?.user_id || senderId?.email || senderId?.union_id || "未知用户";
-          let content = "无消息内容";
-          if (larkMessage.content) {
-            try {
-              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)}`;
+      this.statuses.set(id, "error");
+      logger2.error(`EventSource failed to stop: ${id}`, error);
+      throw error;
     }
   }
   getConfigFilePath() {
@@ -1247,27 +1179,24 @@ class EventSourceComponent extends BaseComponent {
     return join(dataDir, "event-sources.json");
   }
   async saveConfig() {
-    if (!this.persistenceEnabled) {
+    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");
-      logger2.debug(`Saved ${this.sources.size} event source configurations to ${configPath}`);
+      writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      logger2.debug(`Saved ${this.sources.size} event source configurations`);
     } catch (error) {
       logger2.error("Failed to save event source configurations:", error);
       throw error;
     }
   }
   async loadConfig() {
-    if (!this.persistenceEnabled) {
+    if (!this.persistenceEnabled)
       return;
-    }
     try {
       const configPath = this.getConfigFilePath();
       if (!existsSync2(configPath)) {
@@ -1288,100 +1217,10 @@ class EventSourceComponent extends BaseComponent {
           loadedCount++;
         }
       }
-      logger2.info(`Loaded ${loadedCount} event source configurations from ${configPath}`);
+      logger2.info(`Loaded ${loadedCount} event source configurations`);
     } catch (error) {
       logger2.error("Failed to load event source configurations:", error);
     }
   }
 }
-// src/env/event-source/event-source-agent-handler.ts
-init_logger();
-var logger3 = createLogger("event-source-agent-handler");
-
-class EventSourceAgentHandler {
-  config;
-  constructor(config = {}) {
-    this.config = {
-      enabled: config.enabled ?? true,
-      prefix: config.prefix ?? "[事件源]",
-      includeRawEvent: config.includeRawEvent ?? false,
-      includeTimestamp: config.includeTimestamp ?? true
-    };
-  }
-  createHandler() {
-    return (event) => {
-      if (!this.config.enabled) {
-        return;
-      }
-      const message = this.formatEventForAgent(event);
-      logger3.debug(`[AgentHandler] Formatted event: ${message.substring(0, 100)}`);
-      return message;
-    };
-  }
-  formatEventForAgent(event) {
-    const parts = [];
-    parts.push(this.config.prefix);
-    if (this.config.includeTimestamp) {
-      const time = new Date(event.timestamp).toLocaleString("zh-CN");
-      parts.push(`[${time}]`);
-    }
-    parts.push(`来源: ${event.payload.sourceType}`);
-    parts.push(`类型: ${event.type}`);
-    parts.push(`内容: ${event.payload.message}`);
-    if (this.config.includeRawEvent) {
-      const rawStr = typeof event.payload.rawEvent === "string" ? event.payload.rawEvent : JSON.stringify(event.payload.rawEvent);
-      parts.push(`原始数据: ${rawStr}`);
-    }
-    return parts.join(" ");
-  }
-  updateConfig(config) {
-    this.config = {
-      ...this.config,
-      ...config
-    };
-  }
-  getConfig() {
-    return { ...this.config };
-  }
-}
-// src/env/event-source/types.ts
-function isValidEventSourceType(type) {
-  return ["lark-cli", "websocket", "timer", "http-webhook", "file-watcher"].includes(type);
-}
-function getDefaultConfigForType(type) {
-  switch (type) {
-    case "timer":
-      return { interval: 60000 };
-    case "lark-cli":
-      return { command: "lark-cli event +subscribe" };
-    case "websocket":
-      return {};
-    default:
-      return {};
-  }
-}
-function validateEventSourceConfig(config) {
-  const errors = [];
-  if (!config.id) {
-    errors.push("EventSource ID is required");
-  }
-  if (!config.name) {
-    errors.push("EventSource name is required");
-  }
-  if (!isValidEventSourceType(config.type)) {
-    errors.push(`Invalid EventSource type: ${config.type}`);
-  }
-  if (config.type === "timer") {
-    if (!config.interval || config.interval <= 0) {
-      errors.push("Timer interval must be a positive number");
-    }
-  }
-  if (config.type === "lark-cli" && !config.command) {
-    errors.push("lark-cli command is required");
-  }
-  if (config.type === "websocket" && !config.url) {
-    errors.push("WebSocket URL is required");
-  }
-  return errors;
-}
-export { generateId, generateDescendingId, BaseEnvironment, EventSourceComponent, EventSourceAgentHandler, isValidEventSourceType, getDefaultConfigForType, validateEventSourceConfig };
+export { generateId, generateDescendingId, BaseEnvironment, larkCliHandler, timerHandler, websocketHandler, builtInHandlers, EventSourceComponent };