@aion0/forge 0.5.24 → 0.5.26

package/.forge/worktrees/pipeline-d6a6ef23/lib/plugins/executor.ts

@@ -0,0 +1,347 @@
+/**
+ * Plugin Executor — runs plugin actions (http, poll, shell, script).
+ *
+ * Resolves templates ({{config.x}}, {{params.x}}) and executes the action.
+ */
+
+import { spawn } from 'node:child_process';
+import type { PluginAction, PluginActionResult, InstalledPlugin } from './types';
+
+// ─── Template Resolution ─────────────────────────────────
+
+function resolveTemplate(template: string, ctx: Record<string, any>): string {
+  return template.replace(/\{\{(\w+)\.(\w+)\}\}/g, (_, scope, key) => {
+    return ctx[scope]?.[key] ?? '';
+  }).replace(/\{\{(\w+)\s*\|\s*json\}\}/g, (_, scope) => {
+    return JSON.stringify(ctx[scope] || {});
+  });
+}
+
+function resolveObject(obj: Record<string, string> | undefined, ctx: Record<string, any>): Record<string, string> {
+  if (!obj) return {};
+  const result: Record<string, string> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    result[k] = resolveTemplate(v, ctx);
+  }
+  return result;
+}
+
+// ─── JSONPath-like extraction ────────────────────────────
+
+function extractValue(data: any, path: string): any {
+  if (path === '$body' || path === '$stdout') return typeof data === 'string' ? data : JSON.stringify(data);
+  if (path.startsWith('$.')) {
+    const keys = path.slice(2).split('.');
+    let current = data;
+    for (const key of keys) {
+      if (current == null) return undefined;
+      current = current[key];
+    }
+    return current;
+  }
+  return data;
+}
+
+function extractOutputs(data: any, outputSpec: Record<string, string> | undefined): Record<string, any> {
+  if (!outputSpec) return { result: data };
+  const result: Record<string, any> = {};
+  for (const [name, path] of Object.entries(outputSpec)) {
+    result[name] = extractValue(data, path);
+  }
+  return result;
+}
+
+// ─── Executors ───────────────────────────────────────────
+
+async function executeHttp(action: PluginAction, ctx: Record<string, any>): Promise<PluginActionResult> {
+  const url = resolveTemplate(action.url || '', ctx);
+  const method = (action.method || 'GET').toUpperCase();
+  const headers = resolveObject(action.headers, ctx);
+  const body = action.body ? resolveTemplate(action.body, ctx) : undefined;
+
+  const startTime = Date.now();
+  try {
+    const res = await fetch(url, {
+      method,
+      headers: { 'Content-Type': 'application/json', ...headers },
+      body: method !== 'GET' ? body : undefined,
+    });
+
+    let data: any;
+    const contentType = res.headers.get('content-type') || '';
+    if (contentType.includes('json')) {
+      data = await res.json();
+    } else {
+      data = await res.text();
+    }
+
+    return {
+      ok: res.ok,
+      output: extractOutputs(data, action.output),
+      rawResponse: typeof data === 'string' ? data : JSON.stringify(data),
+      duration: Date.now() - startTime,
+    };
+  } catch (err: any) {
+    return { ok: false, output: {}, error: err.message, duration: Date.now() - startTime };
+  }
+}
+
+async function executePoll(action: PluginAction, ctx: Record<string, any>): Promise<PluginActionResult> {
+  const url = resolveTemplate(action.url || '', ctx);
+  const headers = resolveObject(action.headers, ctx);
+  const interval = (action.interval || 30) * 1000;
+  const timeout = (action.timeout || 1800) * 1000;
+  const untilExpr = action.until || '$.result != null';
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeout) {
+    try {
+      const res = await fetch(url, { headers });
+      const data = await res.json();
+
+      // Evaluate condition
+      const conditionMet = evaluateCondition(data, untilExpr);
+      if (conditionMet) {
+        return {
+          ok: true,
+          output: extractOutputs(data, action.output),
+          rawResponse: JSON.stringify(data),
+          duration: Date.now() - startTime,
+        };
+      }
+    } catch {}
+
+    // Wait before next poll
+    await new Promise(r => setTimeout(r, interval));
+  }
+
+  return { ok: false, output: {}, error: 'Poll timeout', duration: Date.now() - startTime };
+}
+
+function evaluateCondition(data: any, expr: string): boolean {
+  // Simple condition parser: "$.field != null", "$.field == value"
+  const match = expr.match(/^(\$\.[.\w]+)\s*(==|!=|>|<)\s*(.+)$/);
+  if (!match) return false;
+  const [, path, op, expected] = match;
+  const actual = extractValue(data, path);
+  const exp = expected === 'null' ? null : expected === 'true' ? true : expected === 'false' ? false : expected;
+
+  switch (op) {
+    case '==': return actual == exp;
+    case '!=': return actual != exp;
+    case '>': return Number(actual) > Number(exp);
+    case '<': return Number(actual) < Number(exp);
+    default: return false;
+  }
+}
+
+async function executeShell(action: PluginAction, ctx: Record<string, any>): Promise<PluginActionResult> {
+  const command = resolveTemplate(action.command || '', ctx);
+  const rawCwd = action.cwd ? resolveTemplate(action.cwd, ctx) : '';
+  const cwd = rawCwd || undefined;
+
+  const startTime = Date.now();
+  const timeout = (action.timeout || 300) * 1000;
+
+  return new Promise((resolve) => {
+    let resolved = false;
+    const done = (result: PluginActionResult) => {
+      if (resolved) return;
+      resolved = true;
+      resolve(result);
+    };
+
+    try {
+      // Use spawn with detached: true so the child gets its own process group.
+      // This prevents crashes/signals in the child (e.g., Playwright browser crash)
+      // from propagating to Forge's process group and killing sibling services.
+      const child = spawn('/bin/sh', ['-c', command], {
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, FORCE_COLOR: '0' },
+        detached: true,
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout?.on('data', (chunk: Buffer) => {
+        stdout += chunk.toString('utf-8');
+        // Cap buffer to prevent memory issues
+        if (stdout.length > 10 * 1024 * 1024) {
+          stdout = stdout.slice(-5 * 1024 * 1024);
+        }
+      });
+      child.stderr?.on('data', (chunk: Buffer) => {
+        stderr += chunk.toString('utf-8');
+        if (stderr.length > 10 * 1024 * 1024) {
+          stderr = stderr.slice(-5 * 1024 * 1024);
+        }
+      });
+
+      console.log(`[plugin-shell] pid=${child.pid} pgid=new command=${command.slice(0, 80)}`);
+
+      child.on('error', (e) => {
+        console.log(`[plugin-shell] pid=${child.pid} error: ${e.message}`);
+        done({
+          ok: false,
+          output: {},
+          error: `Process error: ${e.message}`,
+          duration: Date.now() - startTime,
+        });
+      });
+
+      // Use 'close' instead of 'exit' to ensure all stdout/stderr data is collected
+      child.on('close', (code, signal) => {
+        child.unref();
+        console.log(`[plugin-shell] pid=${child.pid} closed code=${code} signal=${signal} stdout=${stdout.length}b stderr=${stderr.length}b`);
+        const combined = (stdout || stderr || '').trim();
+        // Treat SIGTERM (143) with output as a normal completion — many test runners
+        // and complex commands send SIGTERM to their process group during cleanup,
+        // which kills the shell wrapper but doesn't indicate a real failure.
+        const killedBySignal = code === null || code === 143 || code === 130;
+        const hasOutput = combined.length > 0;
+        const effectiveOk = code === 0 || (killedBySignal && hasOutput);
+
+        done({
+          ok: effectiveOk,
+          output: extractOutputs(combined, action.output),
+          error: effectiveOk ? undefined : (signal ? `Killed by ${signal}` : `Exit code ${code}`),
+          rawResponse: combined.slice(0, 5000),
+          duration: Date.now() - startTime,
+        });
+      });
+
+      // Timeout: kill the child's process group
+      const timer = setTimeout(() => {
+        try { process.kill(-child.pid!, 'SIGTERM'); } catch {}
+        setTimeout(() => {
+          try { process.kill(-child.pid!, 'SIGKILL'); } catch {}
+        }, 3000);
+        done({
+          ok: false,
+          output: {},
+          error: `Command timed out after ${timeout / 1000}s`,
+          rawResponse: (stderr || stdout || '').slice(0, 5000),
+          duration: Date.now() - startTime,
+        });
+      }, timeout);
+      // Don't let the timer keep the process alive
+      timer.unref();
+
+      child.on('exit', () => clearTimeout(timer));
+    } catch (e: any) {
+      done({
+        ok: false,
+        output: {},
+        error: `Failed to spawn: ${e.message}`,
+        duration: Date.now() - startTime,
+      });
+    }
+  });
+}
+
+// ─── Public API ──────────────────────────────────────────
+
+/**
+ * Execute a plugin action.
+ * @param plugin - Installed plugin instance
+ * @param actionName - Action to execute (e.g., 'trigger', 'wait')
+ * @param params - Per-use parameters
+ */
+export async function executePluginAction(
+  plugin: InstalledPlugin,
+  actionName: string,
+  params: Record<string, any> = {},
+): Promise<PluginActionResult> {
+  // Auto-resolve action by config.mode prefix: "test" → "docker_test" if mode=docker
+  let action = plugin.definition.actions[actionName];
+  if (!action && plugin.config.mode) {
+    const modeAction = `${plugin.config.mode}_${actionName}`;
+    action = plugin.definition.actions[modeAction];
+  }
+  if (!action) {
+    return { ok: false, output: {}, error: `Action "${actionName}" not found in plugin "${plugin.id}"` };
+  }
+
+  // Fill missing config values with definition defaults (handles plugins installed before defaults were added)
+  const configWithDefaults = { ...plugin.config };
+  if (plugin.definition.config) {
+    for (const [k, fieldDef] of Object.entries(plugin.definition.config)) {
+      if (configWithDefaults[k] == null && (fieldDef as any).default != null) {
+        configWithDefaults[k] = (fieldDef as any).default;
+      }
+    }
+  }
+
+  // params can override config values — supports multi-instance scenarios
+  // e.g., different Jenkins URLs per pipeline node via params.jenkins_url
+  const mergedConfig = { ...configWithDefaults };
+  const remainingParams = { ...params };
+  for (const k of Object.keys(params)) {
+    if (k in plugin.definition.config && params[k] != null) {
+      mergedConfig[k] = params[k];
+      delete remainingParams[k];
+    }
+  }
+
+  // Config fields named "default_xxx" provide fallback for params.xxx
+  for (const [k, v] of Object.entries(mergedConfig)) {
+    if (k.startsWith('default_')) {
+      const paramKey = k.slice(8); // "default_job" → "job"
+      if (remainingParams[paramKey] == null && v != null) {
+        remainingParams[paramKey] = v;
+      }
+    }
+  }
+
+  const ctx = {
+    config: mergedConfig,
+    params: remainingParams,
+  };
+
+  console.log(`[plugin] ${plugin.id}.${actionName}: executing (${action.run})`);
+
+  switch (action.run) {
+    case 'http':
+      return executeHttp(action, ctx);
+    case 'poll':
+      return executePoll(action, ctx);
+    case 'shell':
+      return executeShell(action, ctx);
+    case 'script':
+      // TODO: implement script execution
+      return { ok: false, output: {}, error: 'Script execution not yet implemented' };
+    default:
+      return { ok: false, output: {}, error: `Unknown action type: ${action.run}` };
+  }
+}
+
+/**
+ * Execute a plugin with auto-wait.
+ * Runs the specified action, then if wait=true, runs the 'wait' action.
+ */
+export async function executePluginWithWait(
+  plugin: InstalledPlugin,
+  actionName: string,
+  params: Record<string, any> = {},
+  wait: boolean = false,
+): Promise<PluginActionResult> {
+  const result = await executePluginAction(plugin, actionName, params);
+  if (!result.ok || !wait) return result;
+
+  // Auto-wait: if plugin has a 'wait' action, run it
+  if (plugin.definition.actions['wait']) {
+    const waitResult = await executePluginAction(plugin, 'wait', params);
+    return {
+      ok: waitResult.ok,
+      output: { ...result.output, ...waitResult.output },
+      rawResponse: waitResult.rawResponse,
+      duration: (result.duration || 0) + (waitResult.duration || 0),
+      error: waitResult.error,
+    };
+  }
+
+  return result;
+}

package/.forge/worktrees/pipeline-d6a6ef23/lib/plugins/registry.ts

@@ -0,0 +1,228 @@
+/**
+ * Plugin Registry — load, install, uninstall, list plugins.
+ *
+ * Plugins are stored as YAML files:
+ * - Built-in: lib/builtin-plugins/*.yaml
+ * - User-installed: ~/.forge/plugins/<id>/plugin.yaml
+ *
+ * Installed plugin configs are stored in:
+ * - ~/.forge/data/plugin-configs.json
+ */
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import type { PluginDefinition, InstalledPlugin, PluginSource } from './types';
+
+const _filename = typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url);
+const _dirname = typeof __dirname !== 'undefined' ? __dirname : dirname(_filename);
+
+const BUILTIN_DIR_COMPILED = join(_dirname, '..', 'builtin-plugins');
+const BUILTIN_DIR_SOURCE = join(process.cwd(), 'lib', 'builtin-plugins');
+const BUILTIN_DIR = existsSync(BUILTIN_DIR_COMPILED) ? BUILTIN_DIR_COMPILED : BUILTIN_DIR_SOURCE;
+const USER_PLUGINS_DIR = join(homedir(), '.forge', 'plugins');
+const CONFIGS_FILE = join(homedir(), '.forge', 'data', 'plugin-configs.json');
+
+// ─── Load Plugin Definition ──────────────────────────────
+
+function loadPluginYaml(filePath: string): PluginDefinition | null {
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    const def = YAML.parse(raw) as PluginDefinition;
+    if (!def.id || !def.name || !def.actions) return null;
+    // Defaults
+    if (!def.config) def.config = {};
+    if (!def.params) def.params = {};
+    if (!def.icon) def.icon = '🔌';
+    if (!def.version) def.version = '0.0.1';
+    return def;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Config Storage ──────────────────────────────────────
+
+function loadConfigs(): Record<string, { config: Record<string, any>; installedAt: string; enabled: boolean }> {
+  try {
+    if (existsSync(CONFIGS_FILE)) {
+      return JSON.parse(readFileSync(CONFIGS_FILE, 'utf-8'));
+    }
+  } catch {}
+  return {};
+}
+
+function saveConfigs(configs: Record<string, any>): void {
+  const dir = dirname(CONFIGS_FILE);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(CONFIGS_FILE, JSON.stringify(configs, null, 2));
+}
+
+// ─── Public API ──────────────────────────────────────────
+
+/** List all available plugins (built-in + user-installed) */
+export function listPlugins(): PluginSource[] {
+  const sources: PluginSource[] = [];
+  const configs = loadConfigs();
+
+  // Check if any config entry references this plugin (base install or instance)
+  const isInstalledOrHasInstance = (id: string) =>
+    Object.entries(configs).some(([key, cfg]) => key === id || (cfg as any).source === id);
+
+  // Built-in plugins
+  if (existsSync(BUILTIN_DIR)) {
+    for (const file of readdirSync(BUILTIN_DIR).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
+      const def = loadPluginYaml(join(BUILTIN_DIR, file));
+      if (def) {
+        sources.push({
+          id: def.id,
+          name: def.name,
+          icon: def.icon,
+          version: def.version,
+          author: def.author || 'forge',
+          description: def.description || '',
+          source: 'builtin',
+          installed: isInstalledOrHasInstance(def.id),
+          configCount: Object.keys(def.config).length,
+        });
+      }
+    }
+  }
+
+  // User-installed plugins
+  mkdirSync(USER_PLUGINS_DIR, { recursive: true });
+  for (const dir of readdirSync(USER_PLUGINS_DIR, { withFileTypes: true })) {
+    if (!dir.isDirectory()) continue;
+    const yamlPath = join(USER_PLUGINS_DIR, dir.name, 'plugin.yaml');
+    const ymlPath = join(USER_PLUGINS_DIR, dir.name, 'plugin.yml');
+    const filePath = existsSync(yamlPath) ? yamlPath : existsSync(ymlPath) ? ymlPath : null;
+    if (!filePath) continue;
+    const def = loadPluginYaml(filePath);
+    if (def) {
+      // Don't duplicate if also built-in
+      if (sources.some(s => s.id === def.id)) continue;
+      sources.push({
+        id: def.id,
+        name: def.name,
+        icon: def.icon,
+        version: def.version,
+        author: def.author || 'local',
+        description: def.description || '',
+        source: 'local',
+        installed: isInstalledOrHasInstance(def.id),
+        configCount: Object.keys(def.config).length,
+      });
+    }
+  }
+
+  return sources;
+}
+
+/** Get a plugin definition by ID */
+export function getPlugin(id: string): PluginDefinition | null {
+  // Check built-in first
+  if (existsSync(BUILTIN_DIR)) {
+    for (const file of readdirSync(BUILTIN_DIR).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
+      const def = loadPluginYaml(join(BUILTIN_DIR, file));
+      if (def?.id === id) return def;
+    }
+  }
+
+  // Check user plugins
+  const yamlPath = join(USER_PLUGINS_DIR, id, 'plugin.yaml');
+  const ymlPath = join(USER_PLUGINS_DIR, id, 'plugin.yml');
+  if (existsSync(yamlPath)) return loadPluginYaml(yamlPath);
+  if (existsSync(ymlPath)) return loadPluginYaml(ymlPath);
+
+  return null;
+}
+
+/** Get an installed plugin with its config */
+export function getInstalledPlugin(id: string): InstalledPlugin | null {
+  const configs = loadConfigs();
+  const cfg = configs[id] as any;
+  if (!cfg) return null;
+  // Resolve definition: use source field for instances, fallback to id
+  const sourceId = cfg.source || id;
+  const def = getPlugin(sourceId);
+  if (!def) return null;
+  return {
+    id,
+    definition: def,
+    config: cfg.config || {},
+    installedAt: cfg.installedAt || new Date().toISOString(),
+    enabled: cfg.enabled !== false,
+    instanceName: cfg.name,
+    source: sourceId !== id ? sourceId : undefined,
+  };
+}
+
+/** List all installed plugins (including instances) */
+export function listInstalledPlugins(): InstalledPlugin[] {
+  const configs = loadConfigs();
+  const installed: InstalledPlugin[] = [];
+  for (const [id, cfg] of Object.entries(configs)) {
+    const sourceId = (cfg as any).source || id;
+    const def = getPlugin(sourceId);
+    if (def) {
+      installed.push({
+        id,
+        definition: def,
+        config: (cfg as any).config || {},
+        installedAt: (cfg as any).installedAt || '',
+        enabled: (cfg as any).enabled !== false,
+        instanceName: (cfg as any).name,
+        source: sourceId !== id ? sourceId : undefined,
+      });
+    }
+  }
+  return installed;
+}
+
+/** Install a plugin or create an instance */
+export function installPlugin(id: string, config: Record<string, any>, opts?: { source?: string; name?: string }): boolean {
+  const sourceId = opts?.source || id;
+  const def = getPlugin(sourceId);
+  if (!def) return false;
+  const configs = loadConfigs();
+  configs[id] = {
+    config,
+    installedAt: new Date().toISOString(),
+    enabled: true,
+    ...(opts?.source ? { source: opts.source } : {}),
+    ...(opts?.name ? { name: opts.name } : {}),
+  };
+  saveConfigs(configs);
+  console.log(`[plugins] Installed: ${opts?.name || def.name} (${id}${opts?.source ? ' ← ' + opts.source : ''})`);
+  return true;
+}
+
+/** Uninstall a plugin or instance */
+export function uninstallPlugin(id: string): boolean {
+  const configs = loadConfigs();
+  if (!configs[id]) return false;
+  delete configs[id];
+  saveConfigs(configs);
+  console.log(`[plugins] Uninstalled: ${id}`);
+  return true;
+}
+
+/** Update plugin config */
+export function updatePluginConfig(id: string, config: Record<string, any>): boolean {
+  const configs = loadConfigs();
+  if (!configs[id]) return false;
+  (configs[id] as any).config = config;
+  saveConfigs(configs);
+  return true;
+}
+
+/** Enable/disable a plugin */
+export function setPluginEnabled(id: string, enabled: boolean): boolean {
+  const configs = loadConfigs();
+  if (!configs[id]) return false;
+  (configs[id] as any).enabled = enabled;
+  saveConfigs(configs);
+  return true;
+}

package/.forge/worktrees/pipeline-d6a6ef23/lib/plugins/types.ts

@@ -0,0 +1,103 @@
+/**
+ * Plugin Types — defines the plugin system for pipeline node extensions.
+ *
+ * A plugin is a reusable, configurable capability that can be used as a
+ * pipeline node. Plugins are declarative YAML files with config schema,
+ * params schema, and actions.
+ */
+
+/** Plugin action execution type */
+export type PluginActionType = 'http' | 'poll' | 'shell' | 'script';
+
+/** Schema field definition for config/params */
+export interface PluginFieldSchema {
+  type: 'string' | 'number' | 'boolean' | 'secret' | 'json' | 'select';
+  label?: string;
+  description?: string;
+  required?: boolean;
+  default?: any;
+  options?: string[];  // for select type
+}
+
+/** A single action a plugin can perform */
+export interface PluginAction {
+  /** Execution type */
+  run: PluginActionType;
+
+  // HTTP action fields
+  method?: string;            // GET, POST, PUT, DELETE
+  url?: string;               // URL template (supports {{config.x}}, {{params.x}})
+  headers?: Record<string, string>;
+  body?: string;              // body template
+
+  // Poll action fields (extends HTTP)
+  interval?: number;          // poll interval in seconds
+  until?: string;             // JSONPath condition: "$.result != null"
+  timeout?: number;           // max wait in seconds
+
+  // Shell action fields
+  command?: string;           // shell command template
+  cwd?: string;               // working directory
+
+  // Script action fields
+  script?: string;            // path to JS/Python script
+  runtime?: 'node' | 'python';
+
+  // Output extraction
+  output?: Record<string, string>;  // { fieldName: "$.json.path" or "$body" or "$stdout" }
+}
+
+/** Plugin definition (loaded from plugin.yaml) */
+export interface PluginDefinition {
+  id: string;
+  name: string;
+  icon: string;
+  version: string;
+  author?: string;
+  description?: string;
+
+  /** Global config — set once when installing the plugin */
+  config: Record<string, PluginFieldSchema>;
+
+  /** Per-use params — set each time the plugin is used in a pipeline node */
+  params: Record<string, PluginFieldSchema>;
+
+  /** Named actions this plugin can perform */
+  actions: Record<string, PluginAction>;
+
+  /** Default action to run if none specified */
+  defaultAction?: string;
+}
+
+/** Installed plugin instance (definition + user config values) */
+export interface InstalledPlugin {
+  id: string;                   // instance ID (e.g., 'jenkins-backend')
+  definition: PluginDefinition;
+  config: Record<string, any>;  // user-provided config values
+  installedAt: string;
+  enabled: boolean;
+  instanceName?: string;        // display name (e.g., 'Jenkins Backend')
+  source?: string;              // source plugin ID if this is an instance (e.g., 'jenkins')
+}
+
+/** Result of executing a plugin action */
+export interface PluginActionResult {
+  ok: boolean;
+  output: Record<string, any>;
+  rawResponse?: string;
+  error?: string;
+  duration?: number;
+}
+
+/** Plugin source for marketplace */
+export interface PluginSource {
+  id: string;
+  name: string;
+  icon: string;
+  version: string;
+  author: string;
+  description: string;
+  source: 'builtin' | 'local' | 'registry';
+  installed: boolean;
+  configCount: number;  // number of config fields — 0 means no config needed
+}