@h-rig/runtime 0.0.6-alpha.3 → 0.0.6-alpha.30

package/dist/src/plugins.js

@@ -1,329 +0,0 @@
-// @bun
-// packages/runtime/src/plugins.ts
-import { existsSync, readdirSync } from "fs";
-import { basename, resolve } from "path";
-
-// packages/runtime/src/binary-run.ts
-import { spawn as nodeSpawn } from "child_process";
-var runtimeBinaryBuildQueue = Promise.resolve();
-async function launchRuntimeBinary(request) {
-  const options = {
-    cwd: request.cwd,
-    env: request.env ? { ...process.env, ...request.env } : process.env
-  };
-  if (request.timeoutMs !== undefined) {
-    options.timeoutMs = request.timeoutMs;
-  }
-  return spawnProcess(request.binaryPath, request.args, options);
-}
-async function spawnProcess(command, args, options) {
-  const child = nodeSpawn(command, args, {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  let stdout = "";
-  let stderr = "";
-  child.stdout?.setEncoding("utf8");
-  child.stderr?.setEncoding("utf8");
-  child.stdout?.on("data", (chunk) => {
-    stdout += chunk;
-  });
-  child.stderr?.on("data", (chunk) => {
-    stderr += chunk;
-  });
-  let timedOut = false;
-  let timer;
-  const exitCode = await new Promise((resolveExit, rejectExit) => {
-    if (options.timeoutMs && options.timeoutMs > 0) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        child.kill();
-      }, options.timeoutMs);
-    }
-    child.once("error", rejectExit);
-    child.once("close", (code) => resolveExit(code ?? (timedOut ? 1 : 0)));
-  }).finally(() => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  });
-  return { exitCode, stdout, stderr, timedOut };
-}
-
-// packages/runtime/src/control-plane/runtime/plugin-mode.ts
-var LEGACY_PLUGIN_SCAN_ENV = "RIG_LEGACY_PLUGIN_SCAN";
-function isLegacyPluginScanEnabled(env = process.env) {
-  const value = env[LEGACY_PLUGIN_SCAN_ENV]?.trim().toLowerCase();
-  return value === "1" || value === "true" || value === "yes" || value === "on";
-}
-
-// packages/runtime/src/plugins.ts
-var runtimeHookPhases = ["beforeCommand", "afterCommand", "onEvent"];
-var PLUGIN_SOURCE_PATTERN = /\.plugin\.(ts|js|mjs|cjs)$/;
-function inferRuntimePluginName(fileName) {
-  return fileName.replace(PLUGIN_SOURCE_PATTERN, "");
-}
-function describeRuntimePluginFiles(filePaths) {
-  return filePaths.filter((filePath) => PLUGIN_SOURCE_PATTERN.test(filePath)).map((filePath) => {
-    const fileName = filePath.split(/[\\/]/).at(-1) ?? filePath;
-    const name = inferRuntimePluginName(fileName);
-    return { name, sourcePath: filePath, binaryName: name };
-  });
-}
-
-class PluginManager {
-  eventBus;
-  context;
-  pluginDir;
-  pluginFiles;
-  pluginNames;
-  localBinDir;
-  imageBinDir;
-  pluginsRequireBinaries;
-  ensureImageBinDir;
-  plugins = null;
-  loadPromise = null;
-  constructor(options) {
-    this.eventBus = options.eventBus;
-    this.context = options.context;
-    this.pluginDir = options.pluginDir;
-    this.pluginFiles = options.pluginFiles;
-    this.pluginNames = options.pluginNames;
-    this.localBinDir = options.localBinDir;
-    this.imageBinDir = options.imageBinDir;
-    this.pluginsRequireBinaries = options.pluginsRequireBinaries;
-    this.ensureImageBinDir = options.ensureImageBinDir;
-  }
-  static async load(options) {
-    const pluginDir = options.pluginDir ?? resolve(options.projectRoot, "rig", "plugins");
-    const localBinDir = options.localBinDir ?? resolve(options.projectRoot, "rig", "plugins");
-    const imageBinDir = options.imageBinDir ?? (options.runtimeContext ? resolve(options.runtimeContext.binDir, "plugins") : "");
-    const legacyPluginScan = options.legacyPluginScan ?? isLegacyPluginScanEnabled(options.env);
-    const pluginFiles = legacyPluginScan ? safeReadDir(pluginDir).filter((entry) => PLUGIN_SOURCE_PATTERN.test(entry)) : [];
-    const pluginNames = pluginFiles.map((file) => inferRuntimePluginName(basename(file)));
-    const context = {
-      projectRoot: options.projectRoot,
-      runId: options.runId,
-      eventBus: options.eventBus
-    };
-    return new PluginManager({
-      eventBus: options.eventBus,
-      context,
-      pluginDir,
-      pluginFiles,
-      pluginNames,
-      localBinDir,
-      imageBinDir,
-      pluginsRequireBinaries: options.pluginsRequireBinaries ?? true,
-      ensureImageBinDir: options.ensureImageBinDir
-    });
-  }
-  list() {
-    if (this.plugins) {
-      return this.plugins.map((plugin) => ({
-        name: plugin.name,
-        validators: plugin.validators?.map((validator) => validator.id) ?? []
-      }));
-    }
-    return this.pluginNames.map((name) => ({ name, validators: [] }));
-  }
-  async beforeCommand(ctx) {
-    const plugins = await this.ensureLoaded();
-    for (const plugin of plugins) {
-      if (!plugin.beforeCommand)
-        continue;
-      await this.safeInvoke(plugin.name, "beforeCommand", () => plugin.beforeCommand?.(ctx, this.context));
-    }
-  }
-  async afterCommand(result) {
-    const plugins = await this.ensureLoaded();
-    for (const plugin of plugins) {
-      if (!plugin.afterCommand)
-        continue;
-      await this.safeInvoke(plugin.name, "afterCommand", () => plugin.afterCommand?.(result, this.context));
-    }
-  }
-  async onEvent(event) {
-    const plugins = this.plugins;
-    if (!plugins)
-      return;
-    for (const plugin of plugins) {
-      if (!plugin.onEvent)
-        continue;
-      await this.safeInvoke(plugin.name, "onEvent", () => plugin.onEvent?.(event, this.context));
-    }
-  }
-  async runValidators(taskId) {
-    const plugins = await this.ensureLoaded();
-    const results = [];
-    for (const plugin of plugins) {
-      for (const validator of plugin.validators ?? []) {
-        await this.eventBus.emit("validator.started", {
-          plugin: plugin.name,
-          validator: validator.id,
-          taskId
-        });
-        try {
-          const result = await validator.run({ taskId, projectRoot: this.context.projectRoot }, this.context);
-          results.push(result);
-          await this.eventBus.emit("validator.finished", {
-            plugin: plugin.name,
-            validator: validator.id,
-            taskId,
-            passed: result.passed,
-            summary: result.summary
-          });
-        } catch (error) {
-          const failed = {
-            id: validator.id,
-            passed: false,
-            summary: `${plugin.name}/${validator.id} failed unexpectedly`,
-            details: `${error}`
-          };
-          results.push(failed);
-          await this.eventBus.emit("validator.finished", {
-            plugin: plugin.name,
-            validator: validator.id,
-            taskId,
-            passed: false,
-            summary: failed.summary,
-            details: failed.details
-          });
-        }
-      }
-    }
-    return results;
-  }
-  async ensureLoaded() {
-    if (this.plugins)
-      return this.plugins;
-    if (this.loadPromise)
-      return this.loadPromise;
-    this.loadPromise = this.loadCompiledPlugins();
-    try {
-      this.plugins = await this.loadPromise;
-      return this.plugins;
-    } finally {
-      this.loadPromise = null;
-    }
-  }
-  resolveBinPath(binName) {
-    const candidates = [this.imageBinDir, this.localBinDir].filter(Boolean).map((dir) => resolve(dir, binName));
-    return candidates.find((candidate) => existsSync(candidate));
-  }
-  async loadCompiledPlugins() {
-    const plugins = [];
-    for (const file of this.pluginFiles) {
-      const binName = inferRuntimePluginName(basename(file));
-      let binPath = this.resolveBinPath(binName);
-      if (!binPath && !this.imageBinDir && this.pluginsRequireBinaries && this.ensureImageBinDir) {
-        try {
-          this.imageBinDir = await this.ensureImageBinDir(this.context.projectRoot);
-          binPath = this.resolveBinPath(binName);
-        } catch {}
-      }
-      if (!binPath) {
-        const triedPaths = [this.imageBinDir, this.localBinDir].filter(Boolean).map((dir) => resolve(dir, binName));
-        const missingError = `Compiled plugin binary not found for '${binName}'. Tried: ${triedPaths.join(", ")}`;
-        await this.eventBus.emit("plugin.error", {
-          file: resolve(this.pluginDir, file),
-          phase: "load",
-          error: missingError
-        });
-        if (this.pluginsRequireBinaries) {
-          throw new Error(missingError);
-        }
-        plugins.push({ name: binName, validators: [] });
-        await this.eventBus.emit("plugin.loaded", {
-          plugin: binName,
-          file: resolve(this.pluginDir, file),
-          source: "metadata-only"
-        });
-        continue;
-      }
-      const wrapper = createBinaryPluginWrapper(binName, binPath, this.context.projectRoot);
-      plugins.push(wrapper);
-      await this.eventBus.emit("plugin.loaded", {
-        plugin: wrapper.name,
-        file: binPath,
-        source: "compiled-binary"
-      });
-    }
-    return plugins;
-  }
-  async safeInvoke(pluginName, hook, call) {
-    try {
-      await call();
-    } catch (error) {
-      await this.eventBus.emit("plugin.error", {
-        plugin: pluginName,
-        phase: hook,
-        error: `${error}`
-      });
-    }
-  }
-}
-function createBinaryPluginWrapper(name, binPath, projectRoot) {
-  return {
-    name,
-    validators: [
-      {
-        id: `${name}:compiled`,
-        async run(ctx) {
-          const { exitCode, stdout, stderr } = await launchRuntimeBinary({
-            binaryPath: binPath,
-            args: ["--validate", ctx.taskId, ctx.projectRoot],
-            cwd: projectRoot
-          });
-          if (exitCode !== 0) {
-            return {
-              id: `${name}:compiled`,
-              passed: false,
-              summary: `Plugin binary ${name} exited with code ${exitCode}`,
-              details: stderr || stdout
-            };
-          }
-          try {
-            const results = JSON.parse(stdout.trim());
-            const failed = results.filter((result) => !result.passed);
-            if (failed.length > 0) {
-              return {
-                id: `${name}:compiled`,
-                passed: false,
-                summary: `${failed.length} of ${results.length} validator(s) failed`,
-                details: failed.map((result) => `${result.id}: ${result.summary}`).join(`
-`)
-              };
-            }
-            return {
-              id: `${name}:compiled`,
-              passed: true,
-              summary: `All ${results.length} validator(s) passed`
-            };
-          } catch {
-            return {
-              id: `${name}:compiled`,
-              passed: false,
-              summary: `Failed to parse output from compiled plugin ${name}`,
-              details: stdout.slice(0, 500)
-            };
-          }
-        }
-      }
-    ]
-  };
-}
-function safeReadDir(path) {
-  try {
-    return readdirSync(path, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
-  } catch {
-    return [];
-  }
-}
-export {
-  runtimeHookPhases,
-  inferRuntimePluginName,
-  describeRuntimePluginFiles,
-  PluginManager
-};