@aion0/forge 0.5.21 → 0.5.23

package/lib/builtin-plugins/http.yaml

@@ -0,0 +1,66 @@
+id: http
+name: HTTP Request
+icon: "🌐"
+version: "1.1.0"
+author: forge
+description: |
+  Make HTTP requests to any API endpoint.
+  Create instances for common API calls:
+  - "Health Check" → default_url: https://api.example.com/health, default_method: GET
+  - "Deploy Hook" → default_url: https://deploy.example.com/trigger, default_method: POST
+  - "Notify Slack" → default_url: https://hooks.slack.com/xxx, default_method: POST
+
+config:
+  default_url:
+    type: string
+    label: Default URL
+    description: "Pre-configured URL"
+  default_method:
+    type: select
+    label: Default Method
+    options: ["GET", "POST", "PUT", "DELETE", "PATCH"]
+    default: "GET"
+  default_headers:
+    type: json
+    label: Default Headers
+    description: 'e.g., {"Authorization": "Bearer xxx"}'
+  default_body:
+    type: json
+    label: Default Body
+    description: "Default request body (for POST/PUT)"
+  expected_status:
+    type: string
+    label: Expected Status Code
+    description: "e.g., 200, 201 — used to validate response"
+  description:
+    type: string
+    label: Description
+    description: "What this request does (shown to agents)"
+
+params:
+  url:
+    type: string
+    label: URL
+    description: "Overrides default_url if set"
+  method:
+    type: select
+    label: Method
+    options: ["GET", "POST", "PUT", "DELETE", "PATCH"]
+  headers:
+    type: json
+    label: Headers
+  body:
+    type: json
+    label: Body
+
+defaultAction: request
+
+actions:
+  request:
+    run: http
+    method: "{{params.method}}"
+    url: "{{params.url}}"
+    headers: "{{params.headers}}"
+    body: "{{params.body}}"
+    output:
+      result: "$body"

package/lib/builtin-plugins/jenkins.yaml

@@ -0,0 +1,92 @@
+id: jenkins
+name: Jenkins CI
+icon: "🔧"
+version: "1.1.0"
+author: forge
+description: |
+  Trigger and monitor Jenkins CI/CD jobs.
+  Create instances per job or per Jenkins server:
+  - "Build Backend" → default_job: backend-build
+  - "E2E Tests" → default_job: e2e-test-suite
+  - "Security Scan" → default_job: sonar-scan
+
+config:
+  url:
+    type: string
+    label: Jenkins URL
+    required: true
+    description: "e.g., https://jenkins.example.com"
+  user:
+    type: string
+    label: Username
+    required: true
+  token:
+    type: secret
+    label: API Token
+    required: true
+  default_job:
+    type: string
+    label: Default Job Name
+    description: "Pre-configured job — no need to pass job param each time"
+
+params:
+  job:
+    type: string
+    label: Job Name
+    description: "Overrides default_job if set"
+  parameters:
+    type: json
+    label: Build Parameters
+    description: "JSON object of build parameters"
+  build_number:
+    type: string
+    label: Build Number
+    description: "Specific build number (for log/status). Defaults to lastBuild"
+
+defaultAction: trigger
+
+actions:
+  trigger:
+    run: http
+    method: POST
+    url: "{{config.url}}/job/{{params.job}}/buildWithParameters"
+    headers:
+      Authorization: "Basic {{config.user}}:{{config.token}}"
+    body: "{{params.parameters | json}}"
+    output:
+      queue_url: "$.headers.location"
+
+  wait:
+    run: poll
+    url: "{{config.url}}/job/{{params.job}}/lastBuild/api/json"
+    headers:
+      Authorization: "Basic {{config.user}}:{{config.token}}"
+    interval: 30
+    until: "$.result != null"
+    timeout: 3600
+    output:
+      result: "$.result"
+      duration: "$.duration"
+      url: "$.url"
+      build_number: "$.number"
+
+  get_log:
+    run: http
+    method: GET
+    url: "{{config.url}}/job/{{params.job}}/{{params.build_number}}/consoleText"
+    headers:
+      Authorization: "Basic {{config.user}}:{{config.token}}"
+    output:
+      log: "$body"
+
+  status:
+    run: http
+    method: GET
+    url: "{{config.url}}/job/{{params.job}}/lastBuild/api/json"
+    headers:
+      Authorization: "Basic {{config.user}}:{{config.token}}"
+    output:
+      result: "$.result"
+      building: "$.building"
+      number: "$.number"
+      timestamp: "$.timestamp"

package/lib/builtin-plugins/llm-vision.yaml

@@ -0,0 +1,85 @@
+id: llm-vision
+name: LLM Vision
+icon: "👁"
+version: "0.1.0"
+author: forge
+description: |
+  Send images to vision-capable LLMs for evaluation.
+  Supports OpenAI (GPT-4o), Anthropic (Claude), Google (Gemini).
+  Create instances per model for multi-model evaluation.
+
+config:
+  provider:
+    type: select
+    label: Provider
+    options: ["openai", "anthropic", "google"]
+    required: true
+  api_key:
+    type: secret
+    label: API Key
+    required: true
+  model:
+    type: string
+    label: Model
+    description: "e.g., gpt-4o, claude-sonnet-4-6, gemini-2.0-flash"
+    default: "gpt-4o"
+  default_prompt:
+    type: string
+    label: Default Evaluation Prompt
+    description: "Default prompt if none provided per-call"
+
+params:
+  image:
+    type: string
+    label: Image file path
+    required: true
+    description: "Local path to image file"
+  prompt:
+    type: string
+    label: Evaluation prompt
+    description: "What to evaluate — overrides default_prompt"
+  max_tokens:
+    type: number
+    label: Max tokens
+    default: 1024
+
+defaultAction: evaluate
+
+actions:
+  evaluate:
+    run: shell
+    command: |
+      PROVIDER="{{config.provider}}"
+      IMAGE="{{params.image}}"
+      PROMPT="{{params.prompt}}"
+      MODEL="{{config.model}}"
+      MAX_TOKENS="{{params.max_tokens}}"
+      [ -z "$MAX_TOKENS" ] && MAX_TOKENS=1024
+      IMG_BASE64=$(base64 < "$IMAGE" | tr -d '\n')
+      MIME="image/png"
+      case "$IMAGE" in *.jpg|*.jpeg) MIME="image/jpeg";; *.webp) MIME="image/webp";; esac
+
+      if [ "$PROVIDER" = "openai" ]; then
+        curl -s https://api.openai.com/v1/chat/completions \
+          -H "Authorization: Bearer {{config.api_key}}" \
+          -H "Content-Type: application/json" \
+          -d "{\"model\":\"$MODEL\",\"max_tokens\":$MAX_TOKENS,\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"$PROMPT\"},{\"type\":\"image_url\",\"image_url\":{\"url\":\"data:$MIME;base64,$IMG_BASE64\"}}]}]}" \
+          | python3 -c "import sys,json; print(json.load(sys.stdin)['choices'][0]['message']['content'])" 2>&1
+
+      elif [ "$PROVIDER" = "anthropic" ]; then
+        curl -s https://api.anthropic.com/v1/messages \
+          -H "x-api-key: {{config.api_key}}" \
+          -H "anthropic-version: 2023-06-01" \
+          -H "Content-Type: application/json" \
+          -d "{\"model\":\"$MODEL\",\"max_tokens\":$MAX_TOKENS,\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"$PROMPT\"},{\"type\":\"image\",\"source\":{\"type\":\"base64\",\"media_type\":\"$MIME\",\"data\":\"$IMG_BASE64\"}}]}]}" \
+          | python3 -c "import sys,json; r=json.load(sys.stdin); print(r['content'][0]['text'])" 2>&1
+
+      elif [ "$PROVIDER" = "google" ]; then
+        curl -s "https://generativelanguage.googleapis.com/v1beta/models/$MODEL:generateContent?key={{config.api_key}}" \
+          -H "Content-Type: application/json" \
+          -d "{\"contents\":[{\"parts\":[{\"text\":\"$PROMPT\"},{\"inline_data\":{\"mime_type\":\"$MIME\",\"data\":\"$IMG_BASE64\"}}]}]}" \
+          | python3 -c "import sys,json; r=json.load(sys.stdin); print(r['candidates'][0]['content']['parts'][0]['text'])" 2>&1
+      fi
+    timeout: 120
+    output:
+      result: "$stdout"

package/lib/builtin-plugins/playwright.yaml

@@ -0,0 +1,111 @@
+id: playwright
+name: Playwright
+icon: "🎭"
+version: "0.3.0"
+author: forge
+description: |
+  Browser testing and screenshots via Playwright.
+  Create one instance per environment (local, docker, or remote).
+  Forge does not install Playwright. Set up your own environment:
+  - Local: https://playwright.dev/docs/intro
+  - Docker: docker pull mcr.microsoft.com/playwright:v1.52.0-noble
+  - Remote: https://www.browserless.io/docs
+
+config:
+  mode:
+    type: select
+    label: Execution Mode
+    options: ["local", "docker", "remote"]
+    default: "local"
+    required: true
+  base_url:
+    type: string
+    label: Application URL
+    description: "URL of the app being tested"
+    default: "http://localhost:3000"
+    required: true
+  server_url:
+    type: string
+    label: Remote WebSocket URL
+    description: "For remote mode (e.g., ws://playwright:3000)"
+  docker_image:
+    type: string
+    label: Docker Image
+    default: "mcr.microsoft.com/playwright:v1.52.0-noble"
+  project_dir:
+    type: string
+    label: Project Directory
+    description: "For docker mode — local path to mount as /app"
+  headless:
+    type: select
+    label: Headless Mode
+    options: ["true", "false"]
+    default: "true"
+    description: "false = show browser window (local mode only)"
+
+params:
+  test_file:
+    type: string
+    label: Test file or directory
+  url:
+    type: string
+    label: URL to screenshot
+  args:
+    type: string
+    label: Extra CLI arguments
+
+defaultAction: test
+
+actions:
+  # Local mode
+  local_test:
+    run: shell
+    command: "BASE_URL={{config.base_url}} npx playwright test {{params.test_file}} {{params.args}} --reporter=line $([ '{{config.headless}}' = 'false' ] && echo '--headed') 2>&1"
+    timeout: 600
+    output:
+      result: "$stdout"
+
+  local_screenshot:
+    run: shell
+    command: "npx playwright screenshot --wait-for-timeout=3000 {{config.base_url}} /tmp/forge-screenshot-$(date +%s).png 2>&1"
+    timeout: 60
+    output:
+      result: "$stdout"
+
+  # Docker mode
+  docker_test:
+    run: shell
+    command: "docker run --rm -e BASE_URL={{config.base_url}} -v {{config.project_dir}}:/app -w /app {{config.docker_image}} npx playwright test {{params.test_file}} {{params.args}} --reporter=line 2>&1"
+    timeout: 600
+    output:
+      result: "$stdout"
+
+  docker_screenshot:
+    run: shell
+    command: "docker run --rm {{config.docker_image}} npx playwright screenshot --wait-for-timeout=3000 {{config.base_url}} /tmp/screenshot.png 2>&1"
+    timeout: 60
+    output:
+      result: "$stdout"
+
+  # Remote mode
+  remote_test:
+    run: shell
+    command: "PW_TEST_CONNECT_WS_ENDPOINT={{config.server_url}} BASE_URL={{config.base_url}} npx playwright test {{params.test_file}} {{params.args}} --reporter=line 2>&1"
+    timeout: 600
+    output:
+      result: "$stdout"
+
+  remote_screenshot:
+    run: shell
+    command: "PW_TEST_CONNECT_WS_ENDPOINT={{config.server_url}} npx playwright screenshot --wait-for-timeout=3000 {{config.base_url}} /tmp/forge-screenshot-$(date +%s).png 2>&1"
+    timeout: 60
+    output:
+      result: "$stdout"
+
+  # Common (all modes)
+  check_url:
+    run: shell
+    command: "curl -sf -o /dev/null -w '%{http_code}' {{config.base_url}}"
+    timeout: 10
+    output:
+      status_code: "$stdout"

package/lib/builtin-plugins/shell-command.yaml

@@ -0,0 +1,60 @@
+id: shell-command
+name: Shell Command
+icon: "💻"
+version: "1.1.0"
+author: forge
+description: |
+  Run shell commands with structured output.
+  Create instances for common operations:
+  - "Run Tests" → default_command: npm test
+  - "Build" → default_command: npm run build
+  - "Deploy Staging" → default_command: ssh staging 'cd /app && git pull && pm2 restart'
+
+config:
+  default_command:
+    type: string
+    label: Default Command
+    description: "Pre-configured command to run if none provided"
+  default_cwd:
+    type: string
+    label: Working Directory
+    description: "Default working directory"
+  default_timeout:
+    type: number
+    label: Timeout (seconds)
+    default: 300
+  expected_output:
+    type: string
+    label: Expected Output Pattern
+    description: "Regex pattern to validate output (e.g., 'SUCCESS|PASSED')"
+  description:
+    type: string
+    label: Description
+    description: "What this command does (shown to agents)"
+
+params:
+  command:
+    type: string
+    label: Command
+    description: "Overrides default_command if set"
+  cwd:
+    type: string
+    label: Working Directory
+  timeout:
+    type: number
+    label: Timeout (seconds)
+  args:
+    type: string
+    label: Extra Arguments
+    description: "Appended to the command"
+
+defaultAction: run
+
+actions:
+  run:
+    run: shell
+    command: "{{params.command}} {{params.args}}"
+    cwd: "{{params.cwd}}"
+    timeout: 300
+    output:
+      stdout: "$stdout"

package/lib/builtin-plugins/slack.yaml

@@ -0,0 +1,48 @@
+id: slack
+name: Slack
+icon: "📢"
+version: "1.1.0"
+author: forge
+description: |
+  Send messages to Slack channels via Incoming Webhook.
+  Create instances per channel or workspace:
+  - "Dev Alerts" → webhook for #dev-alerts
+  - "Deploy Notify" → webhook for #deployments
+
+config:
+  webhook_url:
+    type: secret
+    label: Webhook URL
+    required: true
+    description: "Slack Incoming Webhook URL"
+  default_channel:
+    type: string
+    label: Default Channel
+    description: "Override channel (e.g., #dev-alerts)"
+  description:
+    type: string
+    label: Description
+    description: "What this webhook is for (shown to agents)"
+
+params:
+  text:
+    type: string
+    label: Message
+    required: true
+  channel:
+    type: string
+    label: Channel
+    description: "Overrides default_channel"
+
+defaultAction: send
+
+actions:
+  send:
+    run: http
+    method: POST
+    url: "{{config.webhook_url}}"
+    headers:
+      Content-Type: application/json
+    body: '{"text":"{{params.text}}","channel":"{{params.channel}}"}'
+    output:
+      status: "$body"

package/lib/builtin-plugins/webhook.yaml

@@ -0,0 +1,56 @@
+id: webhook
+name: Webhook
+icon: "🪝"
+version: "1.1.0"
+author: forge
+description: |
+  Send webhook notifications to any URL.
+  Create instances per endpoint:
+  - "Deploy Hook" → url: https://deploy.example.com/hook
+  - "CI Trigger" → url: https://ci.example.com/trigger
+
+config:
+  url:
+    type: string
+    label: Webhook URL
+    required: true
+    description: "Target URL to send webhooks to"
+  secret:
+    type: secret
+    label: Secret
+    description: "Shared secret for signature verification (optional)"
+  default_event:
+    type: string
+    label: Default Event Type
+    default: "forge.notification"
+    description: "Sent as X-Forge-Event header"
+  default_method:
+    type: select
+    label: HTTP Method
+    options: ["POST", "PUT", "PATCH"]
+    default: "POST"
+
+params:
+  payload:
+    type: json
+    label: Payload
+    description: "JSON body to send"
+  event:
+    type: string
+    label: Event Type
+    description: "Overrides default_event"
+
+defaultAction: send
+
+actions:
+  send:
+    run: http
+    method: "{{params.method}}"
+    url: "{{config.url}}"
+    headers:
+      Content-Type: application/json
+      X-Forge-Event: "{{params.event}}"
+      X-Forge-Secret: "{{config.secret}}"
+    body: "{{params | json}}"
+    output:
+      status: "$body"

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;
     }