ai-control-center 1.15.2

package/lib/openclaw/bridge.js

@@ -0,0 +1,650 @@
+/**
+ * OpenClaw Bridge — WebSocket client connecting AICC event bus to OpenClaw Gateway.
+ *
+ * Subscribes to AICC pipeline events and forwards them to OpenClaw Gateway
+ * for multi-channel distribution (Telegram, WhatsApp, Slack, Discord, etc.).
+ *
+ * Features:
+ *   - Auto-reconnect with exponential backoff (1s → 30s)
+ *   - Auth via token from ~/.openclaw/openclaw.json
+ *   - Event formatting for OpenClaw session messages
+ *   - Graceful shutdown
+ */
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { logActivity } from '../utils/activity-log.js';
+
+let _ws = null;
+let _bus = null;
+let _reconnectTimer = null;
+let _reconnectDelay = 1000;
+let _stopping = false;
+let _connected = false;
+
+const MAX_RECONNECT_DELAY = 30000;
+const GATEWAY_PORT = 18789;
+
+// ─── Config helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Read OpenClaw config from ~/.openclaw/openclaw.json.
+ * Returns { token, port } or null if not found.
+ */
+function readOpenClawConfig() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  const configPath = resolve(homeDir, '.openclaw', 'openclaw.json');
+  if (!existsSync(configPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(configPath, 'utf8'));
+    return {
+      token: raw.gateway?.token || raw.auth?.token || null,
+      port: raw.gateway?.port || GATEWAY_PORT,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get WebSocket URL for OpenClaw Gateway.
+ */
+function getGatewayUrl() {
+  const cfg = readOpenClawConfig();
+  const port = cfg?.port || GATEWAY_PORT;
+  return `ws://localhost:${port}`;
+}
+
+// ─── Event formatting ────────────────────────────────────────────────────────
+
+/**
+ * Format an AICC pipeline event into an OpenClaw session message.
+ */
+function formatEventMessage(eventType, data) {
+  const ts = new Date().toISOString();
+
+  switch (eventType) {
+    case 'status': {
+      const s = data.status || {};
+      const prev = data.previousStage || 'unknown';
+      return {
+        type: 'pipeline.status',
+        stage: s.stage,
+        previousStage: prev,
+        feature: s.current_feature || null,
+        pipelineMode: s.pipeline_mode || 'manual',
+        timestamp: ts,
+        summary: `Pipeline: ${prev} → ${s.stage}${s.current_feature ? ` | Feature: ${s.current_feature}` : ''}`,
+      };
+    }
+
+    case 'pipeline-event': {
+      const evt = data.event || 'unknown';
+      const evtData = data.data || {};
+      return {
+        type: `pipeline.${evt}`,
+        event: evt,
+        ...evtData,
+        timestamp: ts,
+        summary: evtData.message || `Pipeline event: ${evt}`,
+      };
+    }
+
+    case 'log': {
+      return {
+        type: 'pipeline.log',
+        agent: data.agent,
+        message: data.message,
+        logType: data.type || 'info',
+        timestamp: ts,
+        summary: `[${data.agent}] ${data.message}`,
+      };
+    }
+
+    default:
+      return {
+        type: `pipeline.${eventType}`,
+        ...data,
+        timestamp: ts,
+        summary: `Event: ${eventType}`,
+      };
+  }
+}
+
+// ─── WebSocket connection ────────────────────────────────────────────────────
+
+/**
+ * Create WebSocket connection to OpenClaw Gateway.
+ * Uses dynamic import for 'ws' to avoid hard dependency.
+ */
+async function connect() {
+  if (_stopping) return;
+
+  const url = getGatewayUrl();
+  const cfg = readOpenClawConfig();
+
+  let WebSocket;
+  try {
+    const wsModule = await import('ws');
+    WebSocket = wsModule.default || wsModule.WebSocket || wsModule;
+  } catch {
+    logActivity('OPENCLAW', 'WARN', 'ws package not installed — bridge disabled. Run: npm i ws');
+    return;
+  }
+
+  try {
+    const headers = {};
+    if (cfg?.token) {
+      headers['Authorization'] = `Bearer ${cfg.token}`;
+    }
+
+    _ws = new WebSocket(url, { headers });
+
+    _ws.on('open', () => {
+      _connected = true;
+      _reconnectDelay = 1000; // reset backoff
+      logActivity('OPENCLAW', 'SUCCESS', `Bridge connected to ${url}`);
+
+      // Send connect frame — register as AICC node device
+      _ws.send(JSON.stringify({
+        type: 'connect',
+        client: 'aicc-bridge',
+        version: '1.0',
+        device: {
+          id: 'aicc-pipeline',
+          name: 'AI Control Center Pipeline',
+          type: 'pipeline-engine',
+          capabilities: [
+            'pipeline.status',
+            'pipeline.feature',
+            'pipeline.bug',
+            'pipeline.deploy',
+            'pipeline.approve',
+            'pipeline.reject',
+            'pipeline.review',
+            'pipeline.health',
+            'pipeline.logs',
+            'pipeline.files',
+            'pipeline.read',
+            'pipeline.events',
+            'pipeline.reset',
+            'pipeline.cleanup',
+          ],
+        },
+        // Expose AICC tools so OpenClaw AI can invoke them directly
+        tools: buildToolDefinitions(),
+      }));
+
+      // Register cron jobs for pipeline monitoring
+      registerCronJobs();
+    });
+
+    _ws.on('message', (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        handleIncomingMessage(msg);
+      } catch {
+        // ignore non-JSON messages
+      }
+    });
+
+    _ws.on('close', (code) => {
+      _connected = false;
+      if (!_stopping) {
+        logActivity('OPENCLAW', 'WARN', `Bridge disconnected (code ${code}) — reconnecting in ${_reconnectDelay / 1000}s`);
+        scheduleReconnect();
+      }
+    });
+
+    _ws.on('error', (err) => {
+      _connected = false;
+      // Only log if not a connection refused (gateway not running)
+      if (err.code !== 'ECONNREFUSED') {
+        logActivity('OPENCLAW', 'ERROR', `Bridge error: ${err.message}`);
+      }
+    });
+  } catch (err) {
+    logActivity('OPENCLAW', 'ERROR', `Bridge connection failed: ${err.message}`);
+    scheduleReconnect();
+  }
+}
+
+/**
+ * Schedule a reconnection attempt with exponential backoff.
+ */
+function scheduleReconnect() {
+  if (_stopping || _reconnectTimer) return;
+  _reconnectTimer = setTimeout(() => {
+    _reconnectTimer = null;
+    _reconnectDelay = Math.min(_reconnectDelay * 2, MAX_RECONNECT_DELAY);
+    connect();
+  }, _reconnectDelay);
+}
+
+/**
+ * Send a message to OpenClaw Gateway.
+ */
+function send(msg) {
+  if (!_ws || _ws.readyState !== 1 /* OPEN */) return false;
+  try {
+    _ws.send(JSON.stringify(msg));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Incoming message handler ────────────────────────────────────────────────
+
+/**
+ * Handle messages received from OpenClaw Gateway.
+ * These can be commands from users via Telegram/WhatsApp/etc.
+ */
+async function handleIncomingMessage(msg) {
+  if (!_bus) return;
+
+  switch (msg.type) {
+    case 'command': {
+      // OpenClaw → AICC command execution
+      const result = await executeCommand(msg.command, msg.args || [], msg);
+      if (result !== undefined) {
+        send({
+          type: 'command-result',
+          requestId: msg.requestId || null,
+          command: msg.command,
+          result,
+          timestamp: new Date().toISOString(),
+        });
+      }
+      break;
+    }
+
+    case 'tool.call': {
+      // OpenClaw AI invokes an AICC tool directly
+      const toolName = msg.tool || '';
+      const toolArgs = msg.parameters || {};
+      // Map tool name to command + args
+      const cmd = toolName.replace('pipeline.', '');
+      const cmdArgs = [];
+      if (toolArgs.description) cmdArgs.push(toolArgs.description);
+      if (toolArgs.reason) cmdArgs.push(toolArgs.reason);
+      if (toolArgs.subdir) cmdArgs.push(toolArgs.subdir);
+      if (toolArgs.filename) cmdArgs.push(toolArgs.filename);
+      if (toolArgs.testLevel) cmdArgs.push(toolArgs.testLevel);
+      if (toolArgs.lines) cmdArgs.push(String(toolArgs.lines));
+
+      const toolResult = await executeCommand(cmd, cmdArgs, msg);
+      send({
+        type: 'tool.result',
+        callId: msg.callId || null,
+        tool: msg.tool,
+        result: toolResult,
+        timestamp: new Date().toISOString(),
+      });
+      break;
+    }
+
+    case 'ping': {
+      send({ type: 'pong', timestamp: new Date().toISOString() });
+      break;
+    }
+
+    case 'ack':
+    case 'pong':
+      break;
+
+    default:
+      _bus.emit('openclaw-message', msg);
+      break;
+  }
+}
+
+/**
+ * Execute an AICC command received from OpenClaw.
+ * Maps command names to action-runner functions.
+ */
+async function executeCommand(command, args, context) {
+  let actions;
+  try {
+    actions = await import('../shared/action-runner.js');
+  } catch (err) {
+    return { error: `Failed to load action-runner: ${err.message}` };
+  }
+
+  try {
+    switch (command) {
+      case 'status':
+        return actions.getStatusData();
+
+      case 'health':
+        return await actions.getHealthData();
+
+      case 'feature': {
+        const desc = args[0];
+        if (!desc || desc.length < 10) return { error: 'Description must be ≥ 10 characters' };
+        return await actions.runNewFeature(desc, 'manual', 'feature');
+      }
+
+      case 'bug': {
+        const desc = args[0];
+        if (!desc || desc.length < 10) return { error: 'Description must be ≥ 10 characters' };
+        return await actions.runNewFeature(desc, 'manual', 'bug');
+      }
+
+      case 'approve':
+        return await actions.runApprove();
+
+      case 'reject': {
+        const reason = args[0] || 'Rejected via OpenClaw';
+        return await actions.runReject(reason);
+      }
+
+      case 'deploy':
+        return await actions.runDeploy(args[0] || 'NoTestRun');
+
+      case 'review':
+        return actions.getLatestReview() || { found: false };
+
+      case 'logs':
+        return actions.getLogsData(parseInt(args[0], 10) || 30);
+
+      case 'files':
+        return actions.listFiles(args[0] || 'specs');
+
+      case 'read': {
+        const subdir = args[0];
+        const name = args[1];
+        if (!subdir || !name) return { error: 'Usage: read <subdir> <filename>' };
+        const content = actions.readFile(subdir, name);
+        return content !== null ? { name, content } : { error: 'File not found' };
+      }
+
+      case 'reset':
+        return actions.runReset();
+
+      case 'cleanup':
+        return await actions.runCleanup();
+
+      default:
+        return { error: `Unknown command: ${command}` };
+    }
+  } catch (err) {
+    logActivity('OPENCLAW', 'ERROR', `Command "${command}" failed: ${err.message}`);
+    return { error: err.message };
+  }
+}
+
+// ─── Event bus listeners ─────────────────────────────────────────────────────
+
+function onStatus(data) {
+  const msg = formatEventMessage('status', data);
+  // Inject into OpenClaw session so AI has pipeline context
+  send({ type: 'event', payload: msg, inject: true, scope: 'session' });
+
+  // On stage completion, inject the stage's output document into the session
+  // so OpenClaw AI has full context when answering user questions
+  const stage = data.status?.stage;
+  const prev = data.previousStage;
+  if (stage && stage !== prev) {
+    injectStageDocument(stage);
+  }
+}
+
+/**
+ * Inject stage output documents into OpenClaw session.
+ * When a stage completes, the AI on the other end needs context about what was produced.
+ */
+async function injectStageDocument(stage) {
+  let actions;
+  try {
+    actions = await import('../shared/action-runner.js');
+  } catch { return; }
+
+  const DOC_MAP = {
+    spec_complete:           { subdir: 'specs',        prefix: 'SPEC-',   label: 'PM Spec' },
+    arch_complete:           { subdir: 'architecture', prefix: 'ARCH-',   label: 'Architecture' },
+    implementation_complete: { subdir: 'tasks',         prefix: 'TASKS-',  label: 'Task List' },
+    review_complete:         { subdir: 'reviews',       prefix: 'REVIEW-', label: 'Code Review' },
+  };
+
+  const docInfo = DOC_MAP[stage];
+  if (!docInfo) return;
+
+  // Find and read the latest document for this stage
+  const files = actions.listFiles(docInfo.subdir);
+  if (!files || files.length === 0) return;
+
+  const latest = files[0]; // already sorted by reverse date
+  const content = actions.readFile(docInfo.subdir, latest.name);
+  if (!content) return;
+
+  // Truncate for session injection (max 3000 chars to avoid flooding)
+  const truncated = content.length > 3000
+    ? content.slice(0, 3000) + '\n\n... (truncated, use `aicc read` for full content)'
+    : content;
+
+  send({
+    type: 'context',
+    scope: 'session',
+    inject: true,
+    label: `${docInfo.label}: ${latest.name}`,
+    content: truncated,
+    timestamp: new Date().toISOString(),
+  });
+}
+
+function onPipelineEvent(data) {
+  const msg = formatEventMessage('pipeline-event', data);
+  // Pipeline events always injected — they drive proactive PM responses
+  send({ type: 'event', payload: msg, inject: true, scope: 'session' });
+}
+
+function onLog(data) {
+  const msg = formatEventMessage('log', data);
+  // Logs are event-only (not injected into session to avoid noise)
+  send({ type: 'event', payload: msg, inject: false });
+}
+
+// ─── Tool definitions for OpenClaw ───────────────────────────────────────────
+
+/**
+ * Build tool definitions that OpenClaw AI agents can call.
+ * These map to AICC CLI commands executed via the bridge.
+ */
+function buildToolDefinitions() {
+  return [
+    {
+      name: 'pipeline.status',
+      description: 'Get current pipeline status including stage, feature, provider health, and cost.',
+      parameters: {},
+    },
+    {
+      name: 'pipeline.feature',
+      description: 'Create a new feature request in the pipeline.',
+      parameters: { description: { type: 'string', required: true, minLength: 10 } },
+    },
+    {
+      name: 'pipeline.bug',
+      description: 'Create a bug fix request in the pipeline.',
+      parameters: { description: { type: 'string', required: true, minLength: 10 } },
+    },
+    {
+      name: 'pipeline.deploy',
+      description: 'Deploy the approved feature.',
+      parameters: { testLevel: { type: 'string', default: 'NoTestRun' } },
+    },
+    {
+      name: 'pipeline.approve',
+      description: 'Approve the current feature after review.',
+      parameters: {},
+    },
+    {
+      name: 'pipeline.reject',
+      description: 'Reject the current feature with feedback.',
+      parameters: { reason: { type: 'string', required: true } },
+    },
+    {
+      name: 'pipeline.review',
+      description: 'Get the latest code review.',
+      parameters: {},
+    },
+    {
+      name: 'pipeline.health',
+      description: 'Get system health including AI provider status and circuit breakers.',
+      parameters: {},
+    },
+    {
+      name: 'pipeline.logs',
+      description: 'Get recent activity logs.',
+      parameters: { lines: { type: 'number', default: 30 } },
+    },
+    {
+      name: 'pipeline.files',
+      description: 'List workflow files in a subdirectory (specs, architecture, tasks, reviews).',
+      parameters: { subdir: { type: 'string', required: true } },
+    },
+    {
+      name: 'pipeline.read',
+      description: 'Read a specific workflow file.',
+      parameters: { subdir: { type: 'string', required: true }, filename: { type: 'string', required: true } },
+    },
+    {
+      name: 'pipeline.reset',
+      description: 'Abandon the current feature and reset pipeline to idle.',
+      parameters: {},
+    },
+    {
+      name: 'pipeline.cleanup',
+      description: 'Archive old workflow files.',
+      parameters: {},
+    },
+  ];
+}
+
+// ─── Cron registration ───────────────────────────────────────────────────────
+
+/**
+ * Register OpenClaw cron jobs for pipeline monitoring.
+ * These run inside the OpenClaw Gateway and invoke the AICC skill.
+ */
+function registerCronJobs() {
+  const cronJobs = [
+    {
+      id: 'aicc-active-monitor',
+      schedule: '*/2 * * * *', // every 2 minutes
+      prompt: 'Check pipeline status with `npx aicc status`. If pipeline is active (not idle/deployed), report progress to the user. If stalled >5 minutes on same stage, warn.',
+      condition: 'pipeline_active',
+    },
+    {
+      id: 'aicc-idle-heartbeat',
+      schedule: '*/30 * * * *', // every 30 minutes
+      prompt: 'Quick health check with `npx aicc health`. Report only if there are issues, banned models, or the pipeline is waiting for user action (review_complete, inbox).',
+      condition: 'always',
+    },
+    {
+      id: 'aicc-stall-detector',
+      schedule: '*/5 * * * *', // every 5 minutes
+      prompt: 'Check `npx aicc status`. If the pipeline has been on the same active stage for >10 minutes, alert the user and suggest retry or reset.',
+      condition: 'pipeline_active',
+    },
+  ];
+
+  for (const job of cronJobs) {
+    send({
+      type: 'cron.register',
+      cron: job,
+    });
+  }
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Start the OpenClaw bridge.
+ * Connects to gateway and subscribes to AICC event bus.
+ *
+ * @param {PipelineBus} bus - The AICC event bus instance
+ * @returns {Promise<boolean>} true if connection initiated
+ */
+export async function startBridge(bus) {
+  if (_bus) return true; // already running
+
+  const cfg = readOpenClawConfig();
+  if (!cfg) {
+    logActivity('OPENCLAW', 'INFO', 'No ~/.openclaw/openclaw.json found — bridge not started');
+    return false;
+  }
+
+  _bus = bus;
+  _stopping = false;
+
+  // Subscribe to event bus
+  bus.on('status', onStatus);
+  bus.on('pipeline-event', onPipelineEvent);
+  bus.on('log', onLog);
+
+  // Connect to gateway
+  await connect();
+  return true;
+}
+
+/**
+ * Stop the OpenClaw bridge gracefully.
+ */
+export function stopBridge() {
+  _stopping = true;
+
+  // Unsubscribe from event bus
+  if (_bus) {
+    _bus.off('status', onStatus);
+    _bus.off('pipeline-event', onPipelineEvent);
+    _bus.off('log', onLog);
+    _bus = null;
+  }
+
+  // Clear reconnect timer
+  if (_reconnectTimer) {
+    clearTimeout(_reconnectTimer);
+    _reconnectTimer = null;
+  }
+
+  // Close WebSocket
+  if (_ws) {
+    try { _ws.close(1000, 'AICC bridge shutdown'); } catch { /* ok */ }
+    _ws = null;
+  }
+
+  _connected = false;
+  _reconnectDelay = 1000;
+}
+
+/**
+ * Check if bridge is currently connected to OpenClaw Gateway.
+ */
+export function isBridgeConnected() {
+  return _connected && _ws?.readyState === 1;
+}
+
+/**
+ * Check if OpenClaw is available (config exists).
+ */
+export function isOpenClawAvailable() {
+  return readOpenClawConfig() !== null;
+}
+
+/**
+ * Send a direct message to OpenClaw Gateway.
+ * Useful for sending pipeline results, notifications, etc.
+ *
+ * @param {string} channel - Target channel (e.g., 'telegram', 'slack', 'all')
+ * @param {string} message - The message text
+ * @param {object} [opts] - Additional options
+ */
+export function sendToOpenClaw(channel, message, opts = {}) {
+  return send({
+    type: 'message',
+    channel,
+    content: message,
+    format: opts.format || 'html',
+    ...opts,
+  });
+}