@ai-setting/roy-agent-core 1.7.59 → 1.7.62

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

@@ -0,0 +1,473 @@
+import {
+  builtInHandlers
+} from "./roy-agent-core-nmn853z0.js";
+import {
+  envKeyToConfigKey
+} from "./roy-agent-core-7hh0brvs.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-gtdtzbs7.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-386wa4wy.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-6awgfh3x.js";
+import {
+  __legacyDecorateClassTS,
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/event-source/event-source-component.ts
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+init_logger();
+init_decorator();
+
+// src/env/event-source/event-source-config-registration.ts
+var EVENT_SOURCE_DEFAULTS = {
+  "event-source.enabled": true,
+  "event-source.persistenceEnabled": true
+};
+var EVENT_SOURCE_CONFIG_REGISTRATION = {
+  name: "event-source",
+  sources: [
+    { type: "env", envPrefix: "EVENT_SOURCE", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "event-source.enabled", sources: ["env", "file"] },
+    { key: "event-source.persistenceEnabled", sources: ["env", "file"] },
+    { key: "event-source.configPath", sources: ["env", "file"] }
+  ]
+};
+
+// src/env/event-source/event-source-component.ts
+var logger = createLogger("event-source");
+
+class EventSourceComponent extends BaseComponent {
+  name = "event-source";
+  version = "1.0.0";
+  sources = new Map;
+  statuses = new Map;
+  handlers = new Map;
+  instances = new Map;
+  eventHandlers = new Map;
+  buffers = new Map;
+  configPath = "";
+  persistenceEnabled = true;
+  configComponent;
+  configWatcher;
+  async onInit() {
+    await this.executeInitHooks();
+    await this.loadConfig();
+  }
+  async init(options) {
+    if (options?.env) {
+      this.env = options.env;
+    }
+    this.setStatus("initializing");
+    if (options?.name)
+      Object.defineProperty(this, "name", { value: options.name, writable: false });
+    if (options?.version)
+      Object.defineProperty(this, "version", { value: options.version, writable: false });
+    if (options?.enabled !== undefined)
+      this._enabled = options.enabled;
+    const opts = options?.options;
+    if (opts?.configComponent) {
+      this.configComponent = opts.configComponent;
+      await this.registerConfig(opts);
+      if (opts.registerBuiltInHandlers !== false) {
+        this.registerBuiltInHandlers();
+      }
+    } else {
+      throw new Error("ConfigComponent is required for EventSourceComponent initialization");
+    }
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async onStart() {}
+  async onStop() {
+    this.configWatcher?.();
+    this.configWatcher = undefined;
+    const runningSources = Array.from(this.statuses.entries()).filter(([_, status]) => status === "running").map(([id]) => id);
+    for (const id of runningSources) {
+      await this.stopSource(id);
+    }
+    this.sources.clear();
+    this.statuses.clear();
+    this.instances.clear();
+    this.eventHandlers.clear();
+    this.handlers.clear();
+    this.buffers.clear();
+  }
+  createDefaultEventHandler(sourceId, sourceType) {
+    return (event) => {
+      this.getEnv()?.pushEnvEvent(event);
+    };
+  }
+  registerBuiltInHandlers() {
+    for (const handler of builtInHandlers) {
+      if (!this.handlers.has(handler.type)) {
+        this.handlers.set(handler.type, handler);
+        logger.debug(`Registered built-in handler: ${handler.type}`);
+      }
+    }
+  }
+  async executeInitHooks() {
+    const { EventSourceInitHooks } = await import("./roy-agent-core-99nwgj84.js");
+    await EventSourceInitHooks.execute(this);
+  }
+  registerHandler(handler) {
+    if (this.handlers.has(handler.type)) {
+      logger.warn(`Handler already registered for type: ${handler.type}, overwriting`);
+    }
+    this.handlers.set(handler.type, handler);
+    logger.debug(`Handler registered: ${handler.type}`);
+  }
+  unregisterHandler(type) {
+    const deleted = this.handlers.delete(type);
+    if (deleted) {
+      logger.debug(`Handler unregistered: ${type}`);
+    }
+    return deleted;
+  }
+  getHandler(type) {
+    return this.handlers.get(type);
+  }
+  listHandlers() {
+    return Array.from(this.handlers.values());
+  }
+  async registerConfig(options) {
+    const configComponent = options.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, config } = options;
+    const envPrefix = "EVENT_SOURCE";
+    configComponent.registerComponent(EVENT_SOURCE_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("event-source");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, envPrefix, "event-source");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(EVENT_SOURCE_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (configComponent.get("event-source.configPath") === undefined) {
+      const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+      const dataDir = join(home, ".roy-agent");
+      await configComponent.set("event-source.configPath", join(dataDir, "event-sources.json"));
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+  }
+  buildConfig() {
+    const configComponent = this.configComponent;
+    if (!configComponent) {
+      return { enabled: true, persistenceEnabled: true, configPath: "" };
+    }
+    return {
+      enabled: configComponent.get("event-source.enabled") ?? true,
+      persistenceEnabled: configComponent.get("event-source.persistenceEnabled") ?? true,
+      configPath: configComponent.get("event-source.configPath") ?? ""
+    };
+  }
+  flattenConfig(obj, prefix = "event-source") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function")
+      return;
+    this.configWatcher = configComponent.watch("event-source.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger.info(`EventSource config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+  }
+  register(config) {
+    if (this.sources.has(config.id)) {
+      throw new Error(`EventSource already exists: ${config.id}`);
+    }
+    const handler = this.handlers.get(config.type);
+    if (!handler) {
+      throw new Error(`No handler registered for event source type: ${config.type}`);
+    }
+    const errors = handler.validateConfig(config);
+    if (errors.length > 0) {
+      throw new Error(`Invalid config: ${errors.join(", ")}`);
+    }
+    this.sources.set(config.id, config);
+    this.statuses.set(config.id, "created");
+    logger.debug(`EventSource registered: ${config.id} (${config.type})`);
+    this.saveConfig().catch((err) => {
+      logger.error(`Failed to save config after registering ${config.id}:`, err);
+    });
+  }
+  unregister(id) {
+    const status = this.statuses.get(id);
+    if (status === "running") {
+      this.stopSource(id);
+    }
+    const existed = this.sources.has(id);
+    this.sources.delete(id);
+    this.statuses.delete(id);
+    this.instances.delete(id);
+    this.eventHandlers.delete(id);
+    this.buffers.delete(id);
+    if (existed) {
+      logger.debug(`EventSource unregistered: ${id}`);
+      this.saveConfig().catch((err) => {
+        logger.error(`Failed to save config after unregistering ${id}:`, err);
+      });
+    }
+    return existed;
+  }
+  async update(id, partial) {
+    if (!partial || Object.keys(partial).length === 0) {
+      throw new Error("update() partial must not be empty");
+    }
+    const existing = this.sources.get(id);
+    if (!existing) {
+      throw new Error(`EventSource not found: ${id}`);
+    }
+    if (Object.prototype.hasOwnProperty.call(partial, "type")) {
+      if (partial.type !== existing.type) {
+        throw new Error(`Cannot update event source type: ${existing.type} -> ${partial.type} (use unregister + register instead)`);
+      }
+    }
+    const wasRunning = this.statuses.get(id) === "running";
+    let stopped = false;
+    if (wasRunning) {
+      await this.stopSource(id);
+      stopped = true;
+    }
+    const updated = {
+      ...existing,
+      ...partial,
+      id: existing.id,
+      type: existing.type
+    };
+    const handler = this.handlers.get(existing.type);
+    if (handler) {
+      const errors = handler.validateConfig(updated);
+      if (errors.length > 0) {
+        throw new Error(`Invalid config after update: ${errors.join(", ")}`);
+      }
+    }
+    this.sources.set(id, updated);
+    logger.info(`EventSource updated: ${id}`, {
+      fields: Object.keys(partial)
+    });
+    try {
+      await this.saveConfig();
+    } catch (err) {
+      logger.error(`Failed to save config after updating ${id}:`, err);
+      throw err;
+    }
+    return {
+      id,
+      updated,
+      wasRunning,
+      stopped,
+      restarted: false,
+      fields: Object.keys(partial)
+    };
+  }
+  get(id) {
+    return this.sources.get(id);
+  }
+  list() {
+    return Array.from(this.sources.values());
+  }
+  getStatus(id) {
+    if (id === undefined) {
+      return this._status;
+    }
+    return this.statuses.get(id);
+  }
+  getEventSourceStatus(id) {
+    return this.getStatus(id);
+  }
+  onEvent(id, handler) {
+    this.eventHandlers.set(id, handler);
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.onEvent(handler);
+    }
+  }
+  offEvent(id) {
+    this.eventHandlers.delete(id);
+    const instance = this.instances.get(id);
+    if (instance) {
+      instance.offEvent();
+    }
+  }
+  async startSource(id) {
+    const config = this.sources.get(id);
+    if (!config) {
+      throw new Error(`EventSource not found: ${id}`);
+    }
+    const currentStatus = this.statuses.get(id);
+    if (currentStatus === "running") {
+      return;
+    }
+    this.statuses.set(id, "starting");
+    try {
+      const handler = this.handlers.get(config.type);
+      if (!handler) {
+        throw new Error(`No handler registered for event source type: ${config.type}`);
+      }
+      const instance = handler.createInstance(config);
+      this.instances.set(id, instance);
+      if (typeof instance.setEnvironment === "function") {
+        instance.setEnvironment(this.getEnv());
+      }
+      const eventHandler = this.eventHandlers.get(id) ?? this.createDefaultEventHandler(id, config.type);
+      instance.onEvent(eventHandler);
+      await instance.start();
+      this.statuses.set(id, "running");
+      this.getEnv()?.pushEnvEvent({
+        type: "event-source.started",
+        payload: { sourceId: id, sourceType: config.type }
+      });
+      logger.info(`EventSource started: ${id} (${config.type})`);
+    } catch (error) {
+      this.statuses.set(id, "error");
+      logger.error(`EventSource failed to start: ${id}`, error);
+      throw error;
+    }
+  }
+  async stopSource(id) {
+    const status = this.statuses.get(id);
+    logger.info(`[EventSource ${id}] stopSource called, current status: ${status}`);
+    if (status === "stopped" || status === "created") {
+      logger.info(`[EventSource ${id}] already stopped/created, skipping`);
+      return;
+    }
+    this.statuses.set(id, "stopping");
+    try {
+      const instance = this.instances.get(id);
+      if (instance) {
+        await instance.stop();
+        this.instances.delete(id);
+      }
+      const config = this.sources.get(id);
+      this.statuses.set(id, "stopped");
+      this.getEnv()?.pushEnvEvent({
+        type: "event-source.stopped",
+        payload: { sourceId: id, sourceType: config?.type }
+      });
+      logger.info(`EventSource stopped: ${id}`);
+    } catch (error) {
+      this.statuses.set(id, "error");
+      logger.error(`EventSource failed to stop: ${id}`, error);
+      throw error;
+    }
+  }
+  getConfigFilePath() {
+    if (this.configPath) {
+      return this.configPath;
+    }
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    const dataDir = join(home, ".roy-agent");
+    if (!existsSync(dataDir)) {
+      mkdirSync(dataDir, { recursive: true });
+    }
+    return join(dataDir, "event-sources.json");
+  }
+  async saveConfig() {
+    if (!this.persistenceEnabled)
+      return;
+    try {
+      const configPath = this.getConfigFilePath();
+      const config = {
+        version: "1.0.0",
+        sources: Array.from(this.sources.values())
+      };
+      writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+      logger.debug(`Saved ${this.sources.size} event source configurations`);
+    } catch (error) {
+      logger.error("Failed to save event source configurations:", error);
+      throw error;
+    }
+  }
+  async loadConfig() {
+    if (!this.persistenceEnabled)
+      return;
+    try {
+      const configPath = this.getConfigFilePath();
+      if (!existsSync(configPath)) {
+        logger.debug(`No event source config file found at ${configPath}`);
+        return;
+      }
+      const content = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content);
+      if (!config.sources || !Array.isArray(config.sources)) {
+        logger.warn("Invalid event source config format, skipping load");
+        return;
+      }
+      let loadedCount = 0;
+      for (const source of config.sources) {
+        if (!this.sources.has(source.id)) {
+          this.sources.set(source.id, source);
+          this.statuses.set(source.id, "created");
+          loadedCount++;
+        }
+      }
+      logger.info(`Loaded ${loadedCount} event source configurations`);
+    } catch (error) {
+      logger.error("Failed to load event source configurations:", error);
+    }
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("event-source.update", { recordParams: false, log: false })
+], EventSourceComponent.prototype, "update", null);
+__legacyDecorateClassTS([
+  TracedAs("event_source.start", { recordParams: true, recordResult: false })
+], EventSourceComponent.prototype, "startSource", null);
+__legacyDecorateClassTS([
+  TracedAs("event_source.stop", { recordParams: true, recordResult: false })
+], EventSourceComponent.prototype, "stopSource", null);
+
+export { EventSourceComponent };

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

@@ -1,7 +1,7 @@
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-rt115qfc.js";
+} from "./roy-agent-core-6awgfh3x.js";
 
 // src/utils/temp-file-manager/index.ts
 init_logger();

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

@@ -1,6 +1,6 @@
 import {
   safeParseToolArgs
-} from "./roy-agent-core-e1w17tht.js";
+} from "./roy-agent-core-9qgrc9dy.js";
 
 // src/env/session/session-message-converter.ts
 import { randomUUID } from "crypto";

package/dist/shared/@ai-setting/{roy-agent-core-8bngppw0.js → roy-agent-core-ye4bfzqg.js}

@@ -1,10 +1,10 @@
+import {
+  getSharedEventStore
+} from "./roy-agent-core-a08dpf71.js";
 import {
   createCompatibleDatabase,
   init_sqlite_task_store
-} from "./roy-agent-core-fbjd7bt6.js";
-import {
-  getSharedEventStore
-} from "./roy-agent-core-2ctyjy62.js";
+} from "./roy-agent-core-th92f833.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";
@@ -14,31 +14,31 @@ import {
 import {
   LarkCardPatchNotifier,
   humanizeValue
-} from "./roy-agent-core-c36335nw.js";
+} from "./roy-agent-core-m3w3ytxt.js";
 import {
   validateWorkflowDefinition
-} from "./roy-agent-core-89sxsrc7.js";
+} from "./roy-agent-core-kmvw6b4v.js";
 import {
   enqueueToAddFakeUserMessage
-} from "./roy-agent-core-gksw1gjb.js";
+} from "./roy-agent-core-p8rf4z89.js";
 import {
   BasePlugin
 } from "./roy-agent-core-az13yzmc.js";
 import {
   init_context
-} from "./roy-agent-core-m97jn2ra.js";
+} from "./roy-agent-core-33hn1beg.js";
 import {
   getEnvContextOrEmpty
-} from "./roy-agent-core-syyw58p9.js";
+} from "./roy-agent-core-hfyxv2kx.js";
 import {
   TracedAs,
   init_decorator,
   wrapFunction
-} from "./roy-agent-core-8p63s836.js";
+} from "./roy-agent-core-386wa4wy.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-rt115qfc.js";
+} from "./roy-agent-core-6awgfh3x.js";
 import {
   __legacyDecorateClassTS,
   __require
@@ -303,11 +303,11 @@ ${prompt}`;
     }
     if (!this._workflowRepo) {
       try {
-        const sqlite = await import("./roy-agent-core-4096f575.js");
+        const sqlite = await import("./roy-agent-core-hczj1ryh.js");
         this.ensureDataDir();
         const db = sqlite.getDatabase();
         sqlite.initializeTables();
-        const { WorkflowRepository } = await import("./roy-agent-core-jjhw9am6.js");
+        const { WorkflowRepository } = await import("./roy-agent-core-mkpsz128.js");
         this._workflowRepo = new WorkflowRepository(db);
         return this._workflowRepo;
       } catch {

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

@@ -1,9 +1,9 @@
 import {
   init_hook
-} from "./roy-agent-core-ytd5eztz.js";
+} from "./roy-agent-core-7tce05jt.js";
 import {
   globalHookManager
-} from "./roy-agent-core-yphwdm9x.js";
+} from "./roy-agent-core-v7mwj8eq.js";
 import {
   __esm
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -1,6 +1,6 @@
 import {
   init_workflow_hook_points
-} from "./roy-agent-core-geh6j7bw.js";
+} from "./roy-agent-core-zjgckbdd.js";
 import {
   __esm
 } from "./roy-agent-core-fs0mn2jk.js";

package/dist/test-utils/child-process-mock.js

@@ -0,0 +1,23 @@
+import {
+  __require
+} from "../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
+
+// src/test-utils/child-process-mock.ts
+var CHILD_PROCESS_EXPORT_NAMES = Object.keys(__require("node:child_process")).filter((name) => name !== "default");
+function createChildProcessMockModule(overrides = {}) {
+  const real = __require("node:child_process");
+  const mocked = {};
+  for (const name of CHILD_PROCESS_EXPORT_NAMES) {
+    mocked[name] = overrides[name] ?? real[name];
+  }
+  for (const [name, value] of Object.entries(overrides)) {
+    if (value !== undefined)
+      mocked[name] = value;
+  }
+  mocked.default = { ...mocked };
+  return mocked;
+}
+export {
+  createChildProcessMockModule,
+  CHILD_PROCESS_EXPORT_NAMES
+};

package/dist/utils/temp-file-manager/index.js

@@ -1,7 +1,7 @@
 import {
   TempFileManager
-} from "../../shared/@ai-setting/roy-agent-core-n0p0hwgd.js";
-import"../../shared/@ai-setting/roy-agent-core-rt115qfc.js";
+} from "../../shared/@ai-setting/roy-agent-core-wzp4tbsn.js";
+import"../../shared/@ai-setting/roy-agent-core-6awgfh3x.js";
 import"../../shared/@ai-setting/roy-agent-core-jnszp0jq.js";
 import"../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
 export {