@ai-setting/roy-agent-core 1.5.15-test → 1.5.16-test

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

@@ -0,0 +1,1387 @@
+import {
+  ContextError,
+  ErrorCodes
+} from "./roy-agent-core-ctdhjv68.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-zgypchmt.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  __legacyDecorateClassTS,
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/environment.ts
+init_logger();
+
+// src/utils/id.ts
+function generateId(prefix = "id") {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+function generateDescendingId(prefix = "id") {
+  const timestamp = (Number.MAX_SAFE_INTEGER - Date.now()).toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+
+// src/env/environment.ts
+init_decorator();
+import * as fsSync from "fs";
+import * as path from "path";
+var logger = createLogger("environment");
+
+class BaseEnvironment extends BaseComponent {
+  name;
+  version;
+  components = new Map;
+  constructor(config) {
+    super();
+    this.name = config?.name ?? "base-environment";
+    this.version = config?.version ?? "1.0.0";
+    this.registerDefaultComponents();
+  }
+  registerDefaultComponents() {}
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: true,
+      env: this
+    };
+  }
+  registerComponent(component) {
+    this.components.set(component.name, component);
+    logger.debug(`Component registered: ${component.name}`);
+  }
+  unregisterComponent(name) {
+    const component = this.components.get(name);
+    if (component) {
+      this.components.delete(name);
+      logger.debug(`Component unregistered: ${name}`);
+    }
+  }
+  getComponent(name) {
+    return this.components.get(name);
+  }
+  listComponents() {
+    return Array.from(this.components.values());
+  }
+  async handle_query(query, context) {
+    const agentComponent = this.getComponent("agent");
+    if (!agentComponent) {
+      throw new Error("AgentComponent not found. Please register AgentComponent before calling handle_query.");
+    }
+    let systemPrompt = "You are a helpful assistant.";
+    let promptSource = "fallback";
+    try {
+      const promptComponent = this.getComponent("prompt");
+      if (promptComponent) {
+        const loadedPrompt = await promptComponent.getPrompt("default");
+        if (loadedPrompt) {
+          systemPrompt = loadedPrompt;
+          promptSource = "PromptComponent";
+        }
+      }
+    } catch (err) {
+      logger.warn(`[handle_query] Failed to get prompt from PromptComponent: ${err}`);
+    }
+    logger.info(`[handle_query] Using system prompt from ${promptSource}, length: ${systemPrompt.length}`);
+    let finalSystemPrompt = systemPrompt;
+    if (systemPrompt.includes("{{memory}}")) {
+      try {
+        const memoryComponent = this.getComponent("memory");
+        if (memoryComponent) {
+          const memoryContent = await memoryComponent.recallMemory();
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", memoryContent || "(No memory)");
+          logger.info(`[handle_query] Injected memory content, length: ${memoryContent.length}`);
+        } else {
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Memory component not available)");
+        }
+      } catch (err) {
+        logger.warn(`[handle_query] Failed to load memory content: ${err}`);
+        finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Failed to load memory)");
+      }
+    }
+    if (finalSystemPrompt.includes("{{workspace_dir}}")) {
+      const workspaceDir = process.cwd();
+      finalSystemPrompt = finalSystemPrompt.replace("{{workspace_dir}}", workspaceDir);
+      logger.debug(`[handle_query] Injected workspace_dir: ${workspaceDir}`);
+    }
+    const agentName = context?.agentType && context.agentType !== "default" ? context.agentType : "default";
+    let agent = agentComponent.getAgent(agentName);
+    if (!agent) {
+      if (agentName !== "default") {
+        logger.warn(`[handle_query] Agent "${agentName}" not found, falling back to "default"`);
+      }
+      agent = agentComponent.getAgent("default");
+    }
+    if (!agent) {
+      agent = agentComponent.registerAgent("default", {
+        type: "primary",
+        systemPrompt: finalSystemPrompt
+      });
+    }
+    const result = await agentComponent.run(agent.name, query, context);
+    if (result.error) {
+      const errorMsg = result.error.toLowerCase();
+      if (errorMsg.includes("context") || errorMsg.includes("threshold") || errorMsg.includes("token") || result.error.includes("CTX_001")) {
+        const usageMatch = result.error.match(/(\d+)\/(\d+)\s*\(([\d.]+)%\)/);
+        let usage;
+        let contextWindow;
+        if (usageMatch) {
+          const totalTokens = parseInt(usageMatch[1], 10);
+          usage = {
+            promptTokens: totalTokens,
+            completionTokens: 0,
+            totalTokens
+          };
+          contextWindow = parseInt(usageMatch[2], 10);
+        }
+        const ctxError = new ContextError(result.error, ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, context?.sessionId, usage, contextWindow);
+        throw ctxError;
+      }
+      throw new Error(result.error);
+    }
+    return result.finalText || "";
+  }
+  async handle_action(action, context) {
+    throw new Error("handle_action not implemented. Override in subclass.");
+  }
+  eventHandlers = new Map;
+  wildcardHandlers = new Set;
+  subscribe(handler) {
+    this.wildcardHandlers.add(handler);
+    logger.debug(`EnvEvent handler subscribed (wildcard)`);
+    return () => {
+      this.wildcardHandlers.delete(handler);
+      logger.debug(`EnvEvent handler unsubscribed (wildcard)`);
+    };
+  }
+  subscribeTo(eventType, handler) {
+    const types = Array.isArray(eventType) ? eventType : [eventType];
+    for (const type of types) {
+      if (!this.eventHandlers.has(type)) {
+        this.eventHandlers.set(type, new Set);
+      }
+      this.eventHandlers.get(type).add(handler);
+    }
+    logger.debug(`EnvEvent handler subscribed for types: ${types.join(", ")}`);
+    return () => {
+      for (const type of types) {
+        this.eventHandlers.get(type)?.delete(handler);
+      }
+      logger.debug(`EnvEvent handler unsubscribed for types: ${types.join(", ")}`);
+    };
+  }
+  subscribeAll(handler) {
+    return this.subscribe(handler);
+  }
+  pushEnvEvent(event) {
+    const fullEvent = "id" in event && event.id ? event : {
+      id: event.id ?? generateId(),
+      type: event.type,
+      timestamp: event.timestamp ?? Date.now(),
+      metadata: {
+        ...event.metadata,
+        env_name: event.metadata?.env_name ?? this.name
+      },
+      payload: event.payload ?? {}
+    };
+    for (const handler of this.wildcardHandlers) {
+      try {
+        handler(fullEvent);
+      } catch (error) {
+        logger.error(`Error in EnvEvent handler: ${error}`);
+      }
+    }
+    const handlers = this.eventHandlers.get(fullEvent.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(fullEvent);
+        } catch (error) {
+          logger.error(`Error in EnvEvent handler for ${fullEvent.type}: ${error}`);
+        }
+      }
+    }
+  }
+  emit(type, payload, metadata) {
+    const event = {
+      id: generateId(),
+      type,
+      timestamp: Date.now(),
+      metadata: {
+        env_name: this.name,
+        ...metadata
+      },
+      payload
+    };
+    this.pushEnvEvent(event);
+  }
+  async initializeComponents() {
+    logger.debug(`Starting component initialization, total: ${this.components.size}`);
+    const configComp = this.components.get("config");
+    if (configComp && configComp.getStatus() === "created") {
+      logger.debug(`Initializing ConfigComponent first...`);
+      await configComp.init({
+        name: "config",
+        version: configComp.version,
+        enabled: true,
+        env: this
+      });
+      logger.debug(`ConfigComponent initialized`);
+    } else {
+      logger.debug(`No ConfigComponent found, skipping first stage`);
+    }
+    const otherComponents = Array.from(this.components.values()).filter((c) => c.getStatus() === "created");
+    if (otherComponents.length > 0) {
+      logger.debug(`Initializing ${otherComponents.length} other components...`);
+      for (const component of otherComponents) {
+        logger.debug(`Initializing component: ${component.name}`);
+        await component.init({
+          name: component.name,
+          version: component.version,
+          enabled: true,
+          env: this
+        });
+        logger.debug(`Component initialized: ${component.name}`);
+      }
+    }
+    logger.debug(`All components initialized`);
+  }
+  async startComponents() {
+    const allComponents = Array.from(this.components.values());
+    if (allComponents.length > 0) {
+      logger.debug(`Starting ${allComponents.length} components...`);
+      for (const component of allComponents) {
+        logger.debug(`Starting component: ${component.name} (current status: ${component.getStatus()})`);
+        await component.start();
+        logger.debug(`Component started: ${component.name}`);
+      }
+    }
+  }
+  async stopComponents() {
+    const componentsToStop = Array.from(this.components.values()).filter((c) => c.getStatus() !== "stopped");
+    if (componentsToStop.length > 0) {
+      logger.debug(`Stopping ${componentsToStop.length} components...`);
+      for (const component of componentsToStop) {
+        logger.debug(`Stopping component: ${component.name}`);
+        await component.stop();
+        logger.debug(`Component stopped: ${component.name}`);
+      }
+    }
+  }
+  async onInit() {
+    await this.initializeComponents();
+    logger.info(`Environment "${this.name}" initialized`);
+  }
+  async onStart() {
+    await this.startComponents();
+    logger.info(`Environment "${this.name}" started`);
+  }
+  async onStop() {
+    await this.stopComponents();
+    this.eventHandlers.clear();
+    this.wildcardHandlers.clear();
+    logger.info(`Environment "${this.name}" stopped`);
+  }
+  async init() {
+    Object.defineProperty(this, "env", {
+      value: this,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    this.setStatus("initializing");
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+    logger.info(`Environment "${this.name}" started`);
+  }
+  async stop() {
+    this.setStatus("stopping");
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async loadServiceConfig(configPath) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before loading service config.");
+    }
+    const xdgDataHome = configComponent.getXdgDataHome();
+    const fullPath = path.resolve(xdgDataHome, configPath);
+    if (!fsSync.existsSync(fullPath)) {
+      throw new Error(`Service config file not found: ${fullPath}`);
+    }
+    const content = fsSync.readFileSync(fullPath, "utf-8");
+    let config;
+    try {
+      config = JSON.parse(content);
+    } catch (e) {
+      throw new Error(`Failed to parse service config: ${e}`);
+    }
+    logger.debug(`Service config loaded from: ${fullPath}`);
+    return config;
+  }
+  generateComponentOptions(componentName, configEntry) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before generating component options.");
+    }
+    const options = {
+      configComponent,
+      configPath: configEntry.configPath,
+      envPrefix: configEntry.envPrefix,
+      config: configEntry.config
+    };
+    logger.debug(`Generated options for component: ${componentName}`);
+    return options;
+  }
+  async registerComponentWithConfig(component, configEntry) {
+    if (!this.components.has(component.name)) {
+      this.registerComponent(component);
+    }
+    const options = this.generateComponentOptions(component.name, configEntry);
+    if (component.getStatus() === "running") {
+      logger.debug(`Component ${component.name} already initialized, skipping`);
+      return;
+    }
+    await component.init({
+      name: component.name,
+      version: component.version,
+      enabled: configEntry.enabled ?? true,
+      env: this,
+      options
+    });
+    logger.debug(`Component ${component.name} registered and initialized with config`);
+  }
+  async initFromConfig(configPath) {
+    if (!this.env) {
+      Object.defineProperty(this, "env", {
+        value: this,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    const serviceConfig = await this.loadServiceConfig(configPath);
+    if (serviceConfig.environment) {
+      if (serviceConfig.environment.name) {
+        this.name = serviceConfig.environment.name;
+      }
+      if (serviceConfig.environment.version) {
+        this.version = serviceConfig.environment.version;
+      }
+    }
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before initFromConfig.");
+    }
+    if (configComponent.getStatus() === "created") {
+      await configComponent.init({
+        name: "config",
+        version: configComponent.version,
+        enabled: true,
+        env: this
+      });
+    }
+    const components = serviceConfig.components || {};
+    for (const [componentName, configEntry] of Object.entries(components)) {
+      if (configEntry.enabled === false) {
+        logger.debug(`Component ${componentName} is disabled, skipping`);
+        continue;
+      }
+      const component = this.getComponent(componentName);
+      if (!component) {
+        logger.warn(`Component ${componentName} not registered, skipping`);
+        continue;
+      }
+      if (component.name === "config")
+        continue;
+      await this.registerComponentWithConfig(component, configEntry);
+    }
+    this.setStatus("running");
+    logger.info(`Environment "${this.name}" initialized from config: ${configPath}`);
+  }
+}
+__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();
+
+// 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 execAsyncImpl = promisify(exec);
+function getExecAsync() {
+  return execAsyncImpl;
+}
+var logger2 = createLogger("event-source");
+
+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;
+  configWatcher;
+  async onInit() {
+    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);
+    } 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.processes.clear();
+    this.handlers.clear();
+    this.timers.clear();
+    this.buffers.clear();
+  }
+  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) {
+    logger2.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");
+    logger2.debug(`EventSource registered: ${config.id} (${config.type})`);
+    this.saveConfig().catch((err) => {
+      logger2.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) {
+      logger2.debug(`EventSource unregistered: ${id}`);
+      this.saveConfig().catch((err) => {
+        logger2.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);
+  }
+  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 }
+      });
+      logger2.info(`EventSource started: ${id} (${config.type})`);
+    } catch (error) {
+      this.statuses.set(id, "error");
+      logger2.error(`EventSource failed to start: ${id}`, error);
+      throw error;
+    }
+  }
+  async stopSource(id) {
+    const status = this.statuses.get(id);
+    logger2.info(`[EventSource ${id}] stopSource called, current status: ${status}`);
+    if (status === "stopped" || status === "created") {
+      logger2.info(`[EventSource ${id}] already stopped/created, skipping`);
+      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);
+        }
+      }
+      this.getEnv()?.pushEnvEvent({
+        type: `event-source.event.${config.type}`,
+        payload: event
+      });
+    } 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)}`;
+    }
+  }
+  getConfigFilePath() {
+    if (this.configPath) {
+      return this.configPath;
+    }
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    const dataDir = join(home, ".roy-agent");
+    if (!existsSync2(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");
+      logger2.debug(`Saved ${this.sources.size} event source configurations to ${configPath}`);
+    } catch (error) {
+      logger2.error("Failed to save event source configurations:", error);
+      throw error;
+    }
+  }
+  async loadConfig() {
+    if (!this.persistenceEnabled) {
+      return;
+    }
+    try {
+      const configPath = this.getConfigFilePath();
+      if (!existsSync2(configPath)) {
+        logger2.debug(`No event source config file found at ${configPath}`);
+        return;
+      }
+      const content = readFileSync2(configPath, "utf-8");
+      const config = JSON.parse(content);
+      if (!config.sources || !Array.isArray(config.sources)) {
+        logger2.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++;
+        }
+      }
+      logger2.info(`Loaded ${loadedCount} event source configurations from ${configPath}`);
+    } 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 };