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

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

@@ -1,1387 +0,0 @@
-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 };