@aion0/forge 0.5.20 → 0.5.22

package/lib/forge-mcp-server.ts

@@ -288,6 +288,119 @@ function createForgeMcpServer(sessionId: string): McpServer {
     }
   );
 
+  // ── trigger_pipeline ──────────────────────────
+  server.tool(
+    'trigger_pipeline',
+    'Trigger a pipeline workflow. Lists available workflows if called without arguments.',
+    {
+      workflow: z.string().optional().describe('Workflow name to trigger. Omit to list available workflows.'),
+      input: z.record(z.string(), z.string()).optional().describe('Input variables for the pipeline (e.g., { project: "my-app" })'),
+    },
+    async (params) => {
+      try {
+        if (!params.workflow) {
+          // List available workflows
+          const { listWorkflows } = await import('./pipeline');
+          const workflows = listWorkflows();
+          if (workflows.length === 0) {
+            return { content: [{ type: 'text', text: 'No workflows found. Create .yaml files in ~/.forge/flows/' }] };
+          }
+          const list = workflows.map((w: any) => `• ${w.name}${w.description ? ' — ' + w.description : ''} (${Object.keys(w.nodes || {}).length} nodes)`).join('\n');
+          return { content: [{ type: 'text', text: `Available workflows:\n${list}` }] };
+        }
+
+        const { startPipeline } = await import('./pipeline');
+        const pipeline = startPipeline(params.workflow, (params.input || {}) as Record<string, string>);
+        return { content: [{ type: 'text', text: `Pipeline started: ${pipeline.id} (workflow: ${params.workflow}, status: ${pipeline.status})` }] };
+      } catch (err: any) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
+      }
+    }
+  );
+
+  // ── run_plugin ──────────────────────────────────
+  server.tool(
+    'run_plugin',
+    'Run an installed plugin action directly. Lists installed plugins if called without arguments.',
+    {
+      plugin: z.string().optional().describe('Plugin ID (e.g., "jenkins", "shell-command", "docker"). Omit to list installed plugins.'),
+      action: z.string().optional().describe('Action name (e.g., "trigger", "run", "build"). Uses default action if omitted.'),
+      params: z.record(z.string(), z.string()).optional().describe('Parameters for the action. Keys matching plugin config fields will override config values.'),
+      wait: z.boolean().optional().describe('Auto-run "wait" action after main action (for async operations like Jenkins builds)'),
+    },
+    async (params) => {
+      try {
+        const { listInstalledPlugins, getInstalledPlugin } = await import('./plugins/registry');
+
+        if (!params.plugin) {
+          const installed = listInstalledPlugins();
+          if (installed.length === 0) {
+            return { content: [{ type: 'text', text: 'No plugins installed. Install from the Plugins page.' }] };
+          }
+          const list = installed.map((p: any) => {
+            const actions = Object.keys(p.definition.actions).join(', ');
+            return `• ${p.definition.icon} ${p.id} — ${p.definition.description || p.definition.name}\n  actions: ${actions}`;
+          }).join('\n');
+          return { content: [{ type: 'text', text: `Installed plugins:\n${list}` }] };
+        }
+
+        const inst = getInstalledPlugin(params.plugin);
+        if (!inst) return { content: [{ type: 'text', text: `Plugin "${params.plugin}" not installed.` }] };
+        if (!inst.enabled) return { content: [{ type: 'text', text: `Plugin "${params.plugin}" is disabled.` }] };
+
+        const { executePluginWithWait } = await import('./plugins/executor');
+        const actionName = params.action || inst.definition.defaultAction || Object.keys(inst.definition.actions)[0];
+
+        if (!inst.definition.actions[actionName]) {
+          const available = Object.keys(inst.definition.actions).join(', ');
+          return { content: [{ type: 'text', text: `Action "${actionName}" not found. Available: ${available}` }] };
+        }
+
+        const result = await executePluginWithWait(inst, actionName, params.params || {}, params.wait || false);
+
+        const output = JSON.stringify(result.output, null, 2);
+        const status = result.ok ? 'OK' : 'FAILED';
+        const duration = result.duration ? ` (${result.duration}ms)` : '';
+        const error = result.error ? `\nError: ${result.error}` : '';
+
+        return { content: [{ type: 'text', text: `${status}${duration}${error}\n${output}` }] };
+      } catch (err: any) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
+      }
+    }
+  );
+
+  // ── get_pipeline_status ────────────────────────
+  server.tool(
+    'get_pipeline_status',
+    'Check the status and results of a running or completed pipeline.',
+    {
+      pipeline_id: z.string().describe('Pipeline ID to check'),
+    },
+    async (params) => {
+      try {
+        const { getPipeline } = await import('./pipeline');
+        const pipeline = getPipeline(params.pipeline_id);
+        if (!pipeline) return { content: [{ type: 'text', text: `Pipeline "${params.pipeline_id}" not found.` }] };
+
+        const nodes = Object.entries(pipeline.nodes).map(([id, n]: [string, any]) => {
+          let line = `  ${id}: ${n.status}`;
+          if (n.error) line += ` — ${n.error}`;
+          if (n.outputs && Object.keys(n.outputs).length > 0) {
+            for (const [k, v] of Object.entries(n.outputs)) {
+              line += `\n    ${k}: ${String(v).slice(0, 200)}`;
+            }
+          }
+          return line;
+        }).join('\n');
+
+        return { content: [{ type: 'text', text: `Pipeline ${pipeline.id} [${pipeline.status}] (${pipeline.workflowName})\n${nodes}` }] };
+      } catch (err: any) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
+      }
+    }
+  );
+
   return server;
 }
 
@@ -325,8 +438,9 @@ export async function startMcpServer(port: number): Promise<void> {
       // Each session gets its own MCP server with context
       const server = createForgeMcpServer(sessionId);
       await server.connect(transport);
-      const agentLabel = workspaceId ? (getOrch(workspaceId)?.getSnapshot()?.agents?.find((a: any) => a.id === agentId)?.label || agentId) : 'unknown';
-      console.log(`[forge-mcp] Client connected: ${agentLabel} (ws=${workspaceId.slice(0, 8)}, session=${sessionId})`);
+      let agentLabel = 'unknown';
+      try { agentLabel = workspaceId ? (getOrch(workspaceId)?.getSnapshot()?.agents?.find((a: any) => a.id === agentId)?.label || agentId) : 'unknown'; } catch {}
+      console.log(`[forge-mcp] Client connected: ${agentLabel} (ws=${workspaceId?.slice(0, 8) || '?'}, session=${sessionId})`);
       return;
     }
 

package/lib/pipeline.ts

@@ -31,11 +31,16 @@ export interface WorkflowNode {
   id: string;
   project: string;
   prompt: string;
-  mode?: 'claude' | 'shell';  // default: 'claude' (agent -p), 'shell' runs raw shell command
+  mode?: 'claude' | 'shell' | 'plugin';  // default: 'claude', 'shell' runs command, 'plugin' runs plugin action
   agent?: string;              // agent ID (default: from settings)
   branch?: string;             // auto checkout this branch before running (supports templates)
+  // Plugin mode fields
+  plugin?: string;             // plugin ID (e.g., 'jenkins', 'docker')
+  pluginAction?: string;       // action name (e.g., 'trigger', 'build'), defaults to plugin's defaultAction
+  pluginParams?: Record<string, any>;  // per-use parameters
+  pluginWait?: boolean;        // auto-run 'wait' action after main action
   dependsOn: string[];
-  outputs: { name: string; extract: 'result' | 'git_diff' | 'stdout' }[];
+  outputs: { name: string; extract: 'result' | 'git_diff' | 'stdout' | 'plugin' }[];
   routes: { condition: string; next: string }[];
   maxIterations: number;
 }
@@ -302,9 +307,13 @@ function parseWorkflow(raw: string): Workflow {
       id,
       project: n.project || '',
       prompt: n.prompt || '',
-      mode: n.mode || 'claude',
+      mode: n.mode || (n.plugin ? 'plugin' : 'claude'),
       agent: n.agent || undefined,
       branch: n.branch || undefined,
+      plugin: n.plugin || undefined,
+      pluginAction: n.plugin_action || n.pluginAction || undefined,
+      pluginParams: n.plugin_params || n.pluginParams || n.params || undefined,
+      pluginWait: n.plugin_wait || n.pluginWait || n.wait || false,
       dependsOn: n.depends_on || n.dependsOn || [],
       outputs: (n.outputs || []).map((o: any) => ({
         name: o.name,
@@ -1024,7 +1033,7 @@ export function cancelPipeline(id: string): boolean {
 
 // ─── Node Scheduling ──────────────────────────────────────
 
-function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
+async function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
   const ctx = { input: pipeline.input, vars: pipeline.vars, nodes: pipeline.nodes };
 
   for (const nodeId of pipeline.nodeOrder) {
@@ -1089,7 +1098,55 @@ function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
       }
     }
 
-    // Create task — mode: 'shell' runs raw command, 'claude' runs claude -p
+    // ── Plugin mode: execute plugin action directly ──
+    if (nodeDef.mode === 'plugin' && nodeDef.plugin) {
+      nodeState.status = 'running';
+      nodeState.startedAt = new Date().toISOString();
+      savePipeline(pipeline);
+      notifyStep(pipeline, nodeId, 'running');
+
+      try {
+        const { getInstalledPlugin } = await import('./plugins/registry');
+        const { executePluginWithWait } = await import('./plugins/executor');
+
+        const inst = getInstalledPlugin(nodeDef.plugin);
+        if (!inst) throw new Error(`Plugin "${nodeDef.plugin}" not installed`);
+        if (!inst.enabled) throw new Error(`Plugin "${nodeDef.plugin}" is disabled`);
+
+        // Resolve template params
+        const resolvedParams: Record<string, any> = {};
+        for (const [k, v] of Object.entries(nodeDef.pluginParams || {})) {
+          resolvedParams[k] = typeof v === 'string' ? resolveTemplate(v, ctx) : v;
+        }
+
+        const actionName = nodeDef.pluginAction || inst.definition.defaultAction || Object.keys(inst.definition.actions)[0];
+        const result = await executePluginWithWait(inst, actionName, resolvedParams, nodeDef.pluginWait);
+
+        if (result.ok) {
+          nodeState.status = 'done';
+          nodeState.completedAt = new Date().toISOString();
+          // Store plugin outputs
+          for (const [name, value] of Object.entries(result.output)) {
+            nodeState.outputs[name] = typeof value === 'string' ? value : JSON.stringify(value);
+          }
+          savePipeline(pipeline);
+          notifyStep(pipeline, nodeId, 'done');
+          console.log(`[pipeline] Plugin ${nodeDef.plugin}.${actionName}: done (${result.duration}ms)`);
+        } else {
+          throw new Error(result.error || 'Plugin action failed');
+        }
+      } catch (err: any) {
+        nodeState.status = 'failed';
+        nodeState.error = err.message;
+        nodeState.completedAt = new Date().toISOString();
+        savePipeline(pipeline);
+        notifyStep(pipeline, nodeId, 'failed', err.message);
+        console.error(`[pipeline] Plugin ${nodeDef.plugin}: failed — ${err.message}`);
+      }
+      continue;
+    }
+
+    // ── Shell/Agent mode: create task ──
     const taskMode = nodeDef.mode === 'shell' ? 'shell' : 'prompt';
     const task = createTask({
       projectName: projectInfo.name,

package/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;
+}