bus-agent 2.3.0

package/webhook-gateway.js

@@ -0,0 +1,420 @@
+#!/usr/bin/env node
+/**
+ * CoCo Webhook Gateway v2.1 — Receive external webhooks and post to Agent Bus
+ *
+ * Features:
+ * - GitHub push, PR, issues, Actions CI status
+ * - GitLab push/merge events
+ * - Slack messages
+ * - Telegram bot updates
+ * - Generic JSON webhooks
+ * - GitHub Actions CI Status endpoint
+ *
+ * Usage:
+ *   node webhook-gateway.js [port]
+ *   # Default port: 8080
+ */
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const BUS_DIR = path.join(__dirname, '.bus');
+const MSGS_DIR = path.join(BUS_DIR, 'messages');
+const CHANNELS_DIR = path.join(BUS_DIR, 'channels');
+
+const PORT = parseInt(process.argv[2], 10) || 8080;
+const AGENT_NAME = 'webhook';
+
+// ── Bus Interface ──────────────────────────────────────
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function getChannels() {
+  if (!fs.existsSync(CHANNELS_DIR)) return [];
+  return fs.readdirSync(CHANNELS_DIR)
+    .filter(f => f.endsWith('.json'))
+    .map(f => f.replace(/\.json$/, ''));
+}
+
+function postToChannel(channelId, from, message, metadata = {}) {
+  const chPath = path.join(CHANNELS_DIR, `${channelId}.json`);
+  if (!fs.existsSync(chPath)) return { ok: false, error: 'Channel not found' };
+
+  const ch = JSON.parse(fs.readFileSync(chPath, 'utf-8'));
+  const msg = {
+    id: `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+    channel: channelId,
+    from: from || AGENT_NAME,
+    message,
+    metadata: { ...metadata, source: 'webhook' },
+    timestamp: new Date().toISOString(),
+  };
+
+  const logDir = path.join(CHANNELS_DIR, channelId, 'log');
+  ensureDir(logDir);
+  fs.writeFileSync(path.join(logDir, `${msg.id}.json`), JSON.stringify(msg, null, 2), 'utf-8');
+
+  // DM all members
+  for (const member of ch.members) {
+    if (member !== (from || AGENT_NAME)) {
+      const inboxDir = path.join(MSGS_DIR, member);
+      ensureDir(inboxDir);
+      const dm = { ...msg, to: member };
+      fs.writeFileSync(path.join(inboxDir, `${msg.id}.json`), JSON.stringify(dm, null, 2), 'utf-8');
+    }
+  }
+
+  return { ok: true, message_id: msg.id, channel: channelId, recipients: ch.members.length - 1 };
+}
+
+function postToAgent(agentName, from, message, metadata = {}) {
+  const msg = {
+    id: `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+    from: from || AGENT_NAME,
+    to: agentName,
+    message,
+    metadata: { ...metadata, source: 'webhook' },
+    timestamp: new Date().toISOString(),
+  };
+
+  const inboxDir = path.join(MSGS_DIR, agentName);
+  ensureDir(inboxDir);
+  fs.writeFileSync(path.join(inboxDir, `${msg.id}.json`), JSON.stringify(msg, null, 2), 'utf-8');
+  return { ok: true, message_id: msg.id, to: agentName };
+}
+
+// ── Webhook Handlers ───────────────────────────────────
+
+function formatBody(body, source) {
+  switch (source) {
+    case 'github': return formatGitHub(body);
+    case 'github-actions': return formatGitHubActions(body);
+    case 'gitlab': return formatGitLab(body);
+    case 'slack': return formatSlack(body);
+    case 'telegram': return formatTelegram(body);
+    default: return formatGeneric(body, source);
+  }
+}
+
+function formatGitHub(body) {
+  const ref = (body.ref || '').replace('refs/heads/', '');
+  const repo = body.repository?.full_name || body.repository?.name || 'unknown';
+  const sender = body.sender?.login || body.pusher?.name || 'unknown';
+
+  // Pull request
+  if (body.pull_request) {
+    const pr = body.pull_request;
+    const action = body.action || 'updated';
+    return `🔀 [${repo}] PR #${pr.number} ${action}: ${pr.title}\n   by ${pr.user?.login} · ${pr.html_url}`;
+  }
+
+  // Issue
+  if (body.issue && !body.comment) {
+    const issue = body.issue;
+    const action = body.action || 'updated';
+    const labels = (issue.labels || []).map(l => l.name).join(', ');
+    return `🎫 [${repo}] Issue #${issue.number} ${action}: ${issue.title}\n   by ${issue.user?.login}${labels ? ` [${labels}]` : ''}`;
+  }
+
+  // Issue comment
+  if (body.issue && body.comment) {
+    const issue = body.issue;
+    const comment = body.comment;
+    return `💬 [${repo}] Comment on #${issue.number}: ${issue.title}\n   by ${comment.user?.login}: ${comment.body?.substring(0, 200)}`;
+  }
+
+  // Commits
+  const commits = body.commits || [];
+  if (commits.length > 0) {
+    const commitMessages = commits.slice(0, 5).map(c => `  • ${c.message?.split('\n')[0]} (${c.id?.substring(0, 7)})`).join('\n');
+    const extra = commits.length > 5 ? `\n  ... and ${commits.length - 5} more` : '';
+    return `📦 [${repo}:${ref}] ${commits.length} commit(s) by ${sender}\n${commitMessages}${extra}`;
+  }
+
+  // Push
+  if (body.ref) {
+    return `📡 [${repo}:${ref}] push by ${sender}`;
+  }
+
+  return `🔔 [${repo}] ${body.action || 'event'} from ${sender}`;
+}
+
+function formatGitHubActions(body) {
+  const workflow = body.workflow || body.workflow_run?.name || 'Workflow';
+  const repo = body.repository?.full_name || 'unknown';
+  const branch = body.ref?.replace('refs/heads/', '') || body.workflow_run?.head_branch || 'unknown';
+  const status = body.action || body.workflow_run?.status || body.workflow_run?.conclusion || 'unknown';
+  const runId = body.workflow_run?.id || body.run_id || '?';
+  const actor = body.sender?.login || 'unknown';
+
+  let icon, statusText;
+  switch (status) {
+    case 'completed': {
+      const conclusion = body.workflow_run?.conclusion || body.conclusion || 'success';
+      if (conclusion === 'success') { icon = '✅'; statusText = 'passed'; }
+      else if (conclusion === 'failure') { icon = '❌'; statusText = 'failed'; }
+      else if (conclusion === 'cancelled') { icon = '🚫'; statusText = 'cancelled'; }
+      else { icon = '⚠️'; statusText = conclusion; }
+      break;
+    }
+    case 'in_progress': icon = '🔄'; statusText = 'in progress'; break;
+    case 'queued': icon = '⏳'; statusText = 'queued'; break;
+    case 'requested': icon = '🔁'; statusText = 'requested'; break;
+    default: icon = 'ℹ️'; statusText = status; break;
+  }
+
+  const url = body.workflow_run?.html_url ||
+              `https://github.com/${repo}/actions/runs/${runId}`;
+
+  let msg = `${icon} [${repo}] ${workflow} ${statusText}`;
+  msg += `\n   Branch: ${branch} · by ${actor}`;
+  msg += `\n   ${url}`;
+
+  // Annotations/errors
+  if (body.workflow_run?.conclusion === 'failure' && body.workflow_run?.head_commit) {
+    msg += `\n   Commit: ${body.workflow_run.head_commit.id?.substring(0, 7)} ${body.workflow_run.head_commit.message?.split('\n')[0] || ''}`;
+  }
+
+  return msg;
+}
+
+function formatGitLab(body) {
+  const ref = (body.ref || '').replace('refs/heads/', '');
+  const project = body.project?.name || 'unknown';
+  const user = body.user_username || body.user?.name || 'unknown';
+
+  // Merge request
+  if (body.object_attributes?.action && body.object_kind === 'merge_request') {
+    const mr = body.object_attributes;
+    return `🔀 [${project}] MR #${mr.iid} ${mr.action}: ${mr.title}\n   by ${user}`;
+  }
+
+  const commits = body.commits || [];
+  const msg = commits.length > 0
+    ? commits.slice(0, 3).map(c => `  • ${c.message?.split('\n')[0]}`).join('\n')
+    : '';
+
+  return `📦 [${project}] ${ref} — by ${user}\n${msg}`;
+}
+
+function formatSlack(body) {
+  const text = body.text || body.event?.text || body.message?.text || '(no text)';
+  const channel = body.event?.channel || body.channel_name || 'unknown';
+  const user = body.event?.user || body.user_name || 'unknown';
+  return `💬 [${channel}] ${user}: ${text}`;
+}
+
+function formatTelegram(body) {
+  const msg = body.message || body.edited_message || body.callback_query?.message || {};
+  const text = msg.text || msg.caption || '(no text)';
+  const from = msg.from?.first_name || msg.from?.username || 'unknown';
+  const chat = msg.chat?.title || msg.chat?.username || msg.chat?.id || 'unknown';
+  return `✈️ [${chat}] ${from}: ${text}`;
+}
+
+function formatGeneric(body, source) {
+  const text = body.text || body.message || body.content || body.msg || JSON.stringify(body);
+  return `[${source}] ${typeof text === 'string' ? text.substring(0, 500) : JSON.stringify(text).substring(0, 500)}`;
+}
+
+// ── HTTP Server ────────────────────────────────────────
+
+function getBody(req) {
+  return new Promise((resolve) => {
+    let body = '';
+    req.on('data', chunk => body += chunk);
+    req.on('end', () => resolve(body));
+  });
+}
+
+function respondJson(res, code, data) {
+  res.writeHead(code, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+  });
+  res.end(JSON.stringify(data, null, 2));
+}
+
+const server = http.createServer(async (req, res) => {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-GitHub-Event, X-GitLab-Event');
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+  const pathname = url.pathname;
+  const method = req.method;
+
+  // ── GET endpoints ──
+
+  if (method === 'GET' && pathname === '/') {
+    respondJson(res, 200, {
+      service: 'bus-agent-webhook-gateway',
+      version: '2.1.0',
+      endpoints: {
+        'POST /webhook/github/:channel': 'GitHub webhook → bus channel',
+        'POST /webhook/github-actions/:channel': 'GitHub Actions CI webhook → bus channel',
+        'POST /webhook/gitlab/:channel': 'GitLab webhook → bus channel',
+        'POST /webhook/slack/:channel': 'Slack webhook → bus channel',
+        'POST /webhook/telegram/:channel': 'Telegram webhook → bus channel',
+        'POST /webhook/generic/:channel': 'Generic webhook → bus channel',
+        'POST /hook/:channel': 'Generic webhook (alias)',
+        'POST /api/send': 'Direct: send to agent or channel',
+        'GET /health': 'Health check',
+        'GET /api/channels': 'List channels',
+        'GET /api/agents': 'List agents',
+      },
+      channels: getChannels(),
+    });
+    return;
+  }
+
+  if (method === 'GET' && pathname === '/health') {
+    respondJson(res, 200, {
+      status: 'ok',
+      uptime: process.uptime(),
+      channels: getChannels().length,
+      bus_dir: fs.existsSync(BUS_DIR),
+      bus_messages: fs.existsSync(MSGS_DIR)
+        ? fs.readdirSync(MSGS_DIR).filter(d => fs.statSync(path.join(MSGS_DIR, d)).isDirectory()).length
+        : 0,
+    });
+    return;
+  }
+
+  if (method === 'GET' && pathname === '/api/channels') {
+    const channels = getChannels();
+    const details = channels.map(id => {
+      const p = path.join(CHANNELS_DIR, `${id}.json`);
+      try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return { id }; }
+    });
+    respondJson(res, 200, { channels: details });
+    return;
+  }
+
+  if (method === 'GET' && pathname === '/api/agents') {
+    const agentsFile = path.join(BUS_DIR, 'agents.json');
+    const agents = fs.existsSync(agentsFile) ? JSON.parse(fs.readFileSync(agentsFile, 'utf-8')) : {};
+    respondJson(res, 200, { agents: Object.keys(agents), count: Object.keys(agents).length });
+    return;
+  }
+
+  // ── POST /api/send — Direct message API ──
+
+  if (method === 'POST' && pathname === '/api/send') {
+    const body = await getBody(req);
+    try {
+      const data = JSON.parse(body);
+      const { to, message, from } = data;
+
+      if (!to || !message) {
+        respondJson(res, 400, { error: 'Missing "to" or "message"' });
+        return;
+      }
+
+      let result;
+      if (to.startsWith('#')) {
+        result = postToChannel(to.slice(1), from || 'api', message);
+      } else {
+        result = postToAgent(to, from || 'api', message);
+      }
+      respondJson(res, 200, { received: true, result });
+    } catch (err) {
+      respondJson(res, 400, { error: `Invalid JSON: ${err.message}` });
+    }
+    return;
+  }
+
+  // ── POST /webhook/:source/:channel  or POST /hook/:channel ──
+
+  const match = pathname.match(/^\/(?:webhook\/(\w+)\/)?(\w+)$/);
+  if (!match || method !== 'POST') {
+    respondJson(res, 404, { error: 'Not found. See GET / for endpoints.' });
+    return;
+  }
+
+  const source = match[1] || 'generic';
+  const channelId = match[2];
+  const body = await getBody(req);
+
+  try {
+    // Detect GitHub Actions from event header
+    let effectiveSource = source;
+    const ghEvent = req.headers['x-github-event'];
+    if (ghEvent === 'workflow_job' || ghEvent === 'workflow_run') {
+      effectiveSource = 'github-actions';
+    }
+
+    const parsed = JSON.parse(body);
+    const message = formatBody(parsed, effectiveSource);
+    const result = postToChannel(channelId, `webhook:${effectiveSource}`, message);
+
+    if (result.ok) {
+      console.log(`[${new Date().toISOString()}] ${effectiveSource} → #${channelId}: ${message.substring(0, 80)}...`);
+      respondJson(res, 200, { received: true, source: effectiveSource, result });
+    } else {
+      respondJson(res, 404, { error: result.error, source: effectiveSource });
+    }
+  } catch (err) {
+    console.error(`[${new Date().toISOString()}] Error:`, err.message);
+    respondJson(res, 400, { error: `Invalid webhook: ${err.message}` });
+  }
+});
+
+// ── Start ──────────────────────────────────────────────
+
+ensureDir(BUS_DIR);
+ensureDir(path.join(MSGS_DIR, AGENT_NAME));
+ensureDir(CHANNELS_DIR);
+
+// Register webhook agent on bus with profile
+const agentsFile = path.join(BUS_DIR, 'agents.json');
+const agents = fs.existsSync(agentsFile) ? JSON.parse(fs.readFileSync(agentsFile, 'utf-8')) : {};
+agents[AGENT_NAME] = {
+  name: AGENT_NAME,
+  description: 'Webhook Gateway — receives external webhooks and posts to channels',
+  capabilities: ['webhook', 'github', 'gitlab', 'slack', 'telegram', 'ci-cd'],
+  tags: ['webhook', 'integration', 'ci'],
+  status: 'idle',
+  version: '2.1.0',
+  last_seen: new Date().toISOString(),
+  registered_at: agents[AGENT_NAME]?.registered_at || new Date().toISOString(),
+};
+fs.writeFileSync(agentsFile, JSON.stringify(agents, null, 2), 'utf-8');
+
+server.listen(PORT, () => {
+  console.log(`
+╔══════════════════════════════════════════════╗
+║    MCP CoCo — Webhook Gateway v2.1          ║
+║    http://localhost:${PORT}                      ║
+╚══════════════════════════════════════════════╝
+
+Endpoints:
+  POST /webhook/github/:channel         GitHub push/PR/issues
+  POST /webhook/github-actions/:channel GitHub Actions CI status
+  POST /webhook/gitlab/:channel         GitLab push/MRs
+  POST /webhook/slack/:channel          Slack messages
+  POST /webhook/telegram/:channel       Telegram bot updates
+  POST /webhook/generic/:channel        Generic JSON webhook
+  POST /hook/:channel                   Generic (alias)
+  POST /api/send                        Direct: {"to":"agent/#channel","message":"..."}
+
+  GET /health                           Health check
+  GET /api/channels                     List channels
+  GET /api/agents                       List agents
+  GET /                                 This help
+
+Scheduled tasks: ${getChannels().join(', ') || '(none)'}
+`);
+
+  // Log incoming events to the bus as system events
+  const evDir = path.join(BUS_DIR, 'events');
+  ensureDir(evDir);
+});