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

package/dist/shared/@ai-setting/roy-agent-core-5ex3za0m.js

@@ -0,0 +1,817 @@
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// 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((resolve) => setTimeout(resolve, 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((resolve) => setTimeout(resolve, 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
+];
+function getBuiltInHandler(type) {
+  return builtInHandlers.find((h) => h.type === type);
+}
+
+// src/env/event-source/event-source-component.ts
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+init_logger();
+
+// src/env/event-source/event-source-config-registration.ts
+var EVENT_SOURCE_DEFAULTS = {
+  "event-source.enabled": true,
+  "event-source.persistenceEnabled": true
+};
+var EVENT_SOURCE_CONFIG_REGISTRATION = {
+  name: "event-source",
+  sources: [
+    { type: "env", envPrefix: "EVENT_SOURCE", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "event-source.enabled", sources: ["env", "file"] },
+    { key: "event-source.persistenceEnabled", sources: ["env", "file"] },
+    { key: "event-source.configPath", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/event-source/event-source-component.ts
+var logger = createLogger("event-source");
+
+class EventSourceComponent extends BaseComponent {
+  name = "event-source";
+  version = "1.0.0";
+  sources = new Map;
+  statuses = new Map;
+  handlers = 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) {
+    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;
+    const opts = options?.options;
+    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");
+    }
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async onStart() {}
+  async onStop() {
+    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.instances.clear();
+    this.eventHandlers.clear();
+    this.handlers.clear();
+    this.buffers.clear();
+  }
+  registerBuiltInHandlers() {
+    for (const handler of builtInHandlers) {
+      if (!this.handlers.has(handler.type)) {
+        this.handlers.set(handler.type, handler);
+        logger.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)) {
+      logger.warn(`Handler already registered for type: ${handler.type}, overwriting`);
+    }
+    this.handlers.set(handler.type, handler);
+    logger.debug(`Handler registered: ${handler.type}`);
+  }
+  unregisterHandler(type) {
+    const deleted = this.handlers.delete(type);
+    if (deleted) {
+      logger.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)
+      return;
+    const { configPath, config } = options;
+    const envPrefix = "EVENT_SOURCE";
+    configComponent.registerComponent(EVENT_SOURCE_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("event-source");
+    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);
+      }
+    }
+    for (const [key, value] of Object.entries(EVENT_SOURCE_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (configComponent.get("event-source.configPath") === undefined) {
+      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"));
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    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}`);
+    }
+    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");
+    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.instances.delete(id);
+    this.eventHandlers.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());
+  }
+  getStatus(id) {
+    return this.statuses.get(id);
+  }
+  getEventSourceStatus(id) {
+    return this.getStatus(id);
+  }
+  onEvent(id, handler) {
+    this.eventHandlers.set(id, handler);
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.onEvent(handler);
+    }
+  }
+  offEvent(id) {
+    this.eventHandlers.delete(id);
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.offEvent();
+    }
+  }
+  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 {
+      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",
+        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;
+    }
+  }
+  async stopSource(id) {
+    const status = this.statuses.get(id);
+    logger.info(`[EventSource ${id}] stopSource called, current status: ${status}`);
+    if (status === "stopped" || status === "created") {
+      logger.info(`[EventSource ${id}] already stopped/created, skipping`);
+      return;
+    }
+    this.statuses.set(id, "stopping");
+    try {
+      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.stopped",
+        payload: { sourceId: id, sourceType: config?.type }
+      });
+      logger.info(`EventSource stopped: ${id}`);
+    } catch (error) {
+      this.statuses.set(id, "error");
+      logger.error(`EventSource failed to stop: ${id}`, error);
+      throw error;
+    }
+  }
+  getConfigFilePath() {
+    if (this.configPath) {
+      return this.configPath;
+    }
+    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())
+      };
+      writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      logger.debug(`Saved ${this.sources.size} event source configurations`);
+    } 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`);
+    } catch (error) {
+      logger.error("Failed to load event source configurations:", error);
+    }
+  }
+}
+
+export { larkCliHandler, timerHandler, websocketHandler, builtInHandlers, getBuiltInHandler, EventSourceComponent };