ai-control-center 1.15.2

package/lib/shared/event-bus.js

@@ -0,0 +1,185 @@
+/**
+ * Pipeline Event Bus — central nervous system for web UI + Telegram.
+ *
+ * Watches .ai-workflow/status.json for changes (1s poll) and emits events
+ * that WebSocket clients and the Telegram bot listen to.
+ *
+ * ZERO changes to existing terminal CLI code — this watches the file on disk.
+ */
+import { EventEmitter } from 'events';
+import { existsSync, readFileSync, unwatchFile, watchFile } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Find the project root by walking up from cwd until aicc.config.js is found.
+ * Mirrors the same logic in utils/pipeline.js — MUST stay in sync.
+ */
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (true) {
+    if (existsSync(resolve(dir, 'aicc.config.js'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  // Fallback: package dir (works when package IS the project)
+  return resolve(__dirname, '../../..');
+}
+
+const ROOT = findProjectRoot();
+const STATUS_FILE = resolve(ROOT, '.ai-workflow/status.json');
+
+class PipelineBus extends EventEmitter {
+  constructor() {
+    super();
+    this._lastStatus = null;
+    this._lastStatusJson = '';
+    this._watching = false;
+    this._lastStageChangeTime = Date.now();
+    this._stallWatchdog = null;
+    this._stallCount = 0; // consecutive stall detections for recovery
+    this._stallMaxRetries = 2;
+    this._stallThresholdMs = 300_000; // 5 minutes per stall detection
+  }
+
+  /** Start watching status.json for changes */
+  startWatching() {
+    if (this._watching) return;
+    this._watching = true;
+
+    // Initial read
+    this._lastStatus = this._readStatus();
+    this._lastStatusJson = JSON.stringify(this._lastStatus);
+
+    // Poll every 1s — negligible cost, works for any writer (terminal, web, telegram)
+    watchFile(STATUS_FILE, { interval: 1000 }, () => {
+      const newStatus = this._readStatus();
+      const newJson = JSON.stringify(newStatus);
+
+      if (newJson !== this._lastStatusJson) {
+        const oldStage = this._lastStatus?.stage;
+        this._lastStatus = newStatus;
+        this._lastStatusJson = newJson;
+
+        // Reset stall timer, idle notify timer, and stall counter when the stage changes
+        if (newStatus?.stage !== oldStage) {
+          this._lastStageChangeTime = Date.now();
+          this._lastIdleNotifyTime = Date.now(); // suppress immediate idle heartbeat after stage change
+          this._stallCount = 0; // reset consecutive stall counter
+        }
+
+        this.emit('status', {
+          status: newStatus,
+          previousStage: oldStage,
+          timestamp: new Date().toISOString(),
+        });
+      }
+    });
+
+    // Stall watchdog: notify user if an active pipeline stage hasn't moved in 5 minutes
+    const STALL_THRESHOLD_MS = 5 * 60 * 1000;
+    const ACTIVE_STAGES = new Set(['spec', 'arch', 'impl', 'review', 'fix', 'deploy']);
+    this._lastIdleNotifyTime = Date.now(); // suppress idle notification on first boot
+    this._stallWatchdog = setInterval(() => {
+      const s = this._lastStatus;
+      if (!s?.stage) return;
+
+      // Active stage stall detection
+      if (ACTIVE_STAGES.has(s.stage)) {
+        const stalledMs = Date.now() - this._lastStageChangeTime;
+        if (stalledMs >= STALL_THRESHOLD_MS) {
+          this._stallCount++;
+          this.emitEvent('pipeline_stalled', {
+            stage: s.stage,
+            feature: s.current_feature,
+            minutesElapsed: Math.round(stalledMs / 60000),
+            stallCount: this._stallCount,
+            message: `⚠️ <b>Pipeline stall detected</b>\n\nStage <code>${s.stage}</code> has been running for <b>${Math.round(stalledMs / 60000)} minutes</b> with no progress.\n\nFeature: <code>${s.current_feature || 'unknown'}</code>\n\nThe AI may still be working on a large response — or something may have gone wrong. Use /status to check.`,
+          });
+
+          // After maxRetries consecutive stalls (10 min total), auto-recover
+          if (this._stallCount >= this._stallMaxRetries) {
+            this._stallCount = 0;
+            this._lastStageChangeTime = Date.now(); // prevent immediate re-trigger
+            this.emitEvent('pipeline_stall_recovery', {
+              action: 'retry_stage',
+              stage: s.stage,
+              feature: s.current_feature,
+              message: `🔄 <b>Auto-recovery</b>\n\nPipeline stalled for ${Math.round(stalledMs / 60000)}min on <code>${s.stage}</code>. Auto-retrying...`,
+            });
+          }
+        }
+        return;
+      }
+
+      // Long-idle heartbeat: if pipeline has been idle/deployed for 30+ min,
+      // send a single periodic status update so users know the bot is alive.
+      // Also covers waiting-for-action stages: review_complete (approve/reject needed), inbox (feature queued).
+      const IDLE_STAGES = new Set(['deployed', 'approved', 'rejected', 'review_complete', 'inbox']);
+      const IDLE_NOTIFY_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+      if (IDLE_STAGES.has(s.stage)) {
+        const sinceLastNotify = Date.now() - (this._lastIdleNotifyTime || 0);
+        if (sinceLastNotify >= IDLE_NOTIFY_INTERVAL_MS) {
+          this._lastIdleNotifyTime = Date.now();
+          const idleMin = Math.round((Date.now() - this._lastStageChangeTime) / 60000);
+          const stageEmoji = { idle: '💤', deployed: '🚀', approved: '✅', rejected: '❌', review_complete: '🔍', inbox: '📬' };
+          this.emitEvent('idle_heartbeat', {
+            stage: s.stage,
+            feature: s.current_feature,
+            minutesIdle: idleMin,
+            message: `${stageEmoji[s.stage] || '📋'} <b>Status check</b> — pipeline is <code>${s.stage}</code> for ${idleMin} min.${s.current_feature ? `\nFeature: <code>${s.current_feature}</code>` : ''}\n\nBot is online and ready. Send a message or /help to get started.`,
+          });
+        }
+      }
+    }, 2 * 60 * 1000); // check every 2 minutes
+  }
+
+  /** Stop watching */
+  stopWatching() {
+    if (!this._watching) return;
+    unwatchFile(STATUS_FILE);
+    clearInterval(this._stallWatchdog);
+    this._stallWatchdog = null;
+    this._watching = false;
+  }
+
+  /** Get current pipeline status */
+  getStatus() {
+    return this._readStatus();
+  }
+
+  /** Emit a pipeline event (review done, deploy result, etc.) */
+  emitEvent(event, data = {}) {
+    this.emit('pipeline-event', {
+      event,
+      data,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Emit a log line */
+  emitLog(agent, message, type = 'info') {
+    this.emit('log', {
+      agent,
+      message,
+      type,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Read status.json safely */
+  _readStatus() {
+    try {
+      if (!existsSync(STATUS_FILE)) return { stage: 'idle', current_feature: null };
+      return JSON.parse(readFileSync(STATUS_FILE, 'utf8'));
+    } catch {
+      return { stage: 'idle', current_feature: null };
+    }
+  }
+}
+
+export const bus = new PipelineBus();
+export const ROOT_DIR = ROOT;

package/lib/slack/bot.js

@@ -0,0 +1,378 @@
+/**
+ * AI Control Center Slack Bot — pipeline control + notifications via Slack Web API.
+ *
+ * Uses native fetch() to call Slack Web API (no @slack/bolt dependency).
+ * Listens on the event bus and posts updates to a configured channel.
+ * Supports slash commands for pipeline control.
+ *
+ * Setup:
+ *   1. Create a Slack App at https://api.slack.com/apps
+ *   2. Add Bot Token Scopes: chat:write, commands
+ *   3. Install to workspace, get Bot Token
+ *   4. Set env vars:
+ *      export SLACK_BOT_TOKEN=xoxb-...
+ *      export SLACK_SIGNING_SECRET=...
+ *   5. Configure in aicc.config.js:
+ *      slack: { enabled: true, channel: '#ai-pipeline' }
+ */
+import { getConfig } from '../config.js';
+import * as actions from '../shared/action-runner.js';
+import { bus } from '../shared/event-bus.js';
+import { formatCostSummary, getCostSummary, getActiveBudget } from '../utils/cost-tracker.js';
+
+const SLACK_API = 'https://slack.com/api';
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * Call a Slack Web API method via native fetch.
+ *
+ * @param {string} method — Slack API method (e.g. 'chat.postMessage')
+ * @param {string} token — Bot token
+ * @param {object} body — JSON payload
+ * @returns {Promise<object>}
+ */
+async function slackApiCall(method, token, body) {
+  const res = await fetch(`${SLACK_API}/${method}`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json; charset=utf-8',
+    },
+    body: JSON.stringify(body),
+  });
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API ${method} failed: ${data.error || 'unknown error'}`);
+  }
+  return data;
+}
+
+// ─── Module-level state ────────────────────────────────────────────────────────
+
+let _bot = null;
+
+// ─── SlackBot class ────────────────────────────────────────────────────────────
+
+/**
+ * Slack bot that bridges pipeline events to Slack channels.
+ */
+export class SlackBot {
+  /**
+   * @param {object} config
+   * @param {string} config.token — Slack Bot Token (xoxb-...)
+   * @param {string} [config.signingSecret] — Slack Signing Secret
+   * @param {string} [config.channel] — Default channel to post to
+   */
+  constructor(config = {}) {
+    this._token = config.token;
+    this._signingSecret = config.signingSecret || '';
+    this._channel = config.channel || '#ai-pipeline';
+    this._subscriptions = [];
+    this._running = false;
+  }
+
+  /** Start the bot — subscribe to pipeline events and post to Slack */
+  start() {
+    if (this._running) return;
+    this._running = true;
+
+    const handler = (event) => this._handleEvent(event);
+    bus.on('pipeline-event', handler);
+    bus.on('status', handler);
+    this._subscriptions.push(
+      { event: 'pipeline-event', handler },
+      { event: 'status', handler },
+    );
+
+    console.log(`  🔔 Slack bot started → ${this._channel}`);
+  }
+
+  /** Stop the bot — unsubscribe from all events */
+  stop() {
+    this._running = false;
+    for (const { event, handler } of this._subscriptions) {
+      bus.removeListener(event, handler);
+    }
+    this._subscriptions = [];
+    console.log('  🔕 Slack bot stopped');
+  }
+
+  /**
+   * Handle a pipeline event and post to Slack.
+   * @param {object} event
+   */
+  async _handleEvent(event) {
+    if (!this._running || !this._token) return;
+
+    try {
+      // Room messages — forward agent chat to Slack
+      const pipelineEvent = event.event;
+      if (pipelineEvent === 'room:message' && event.data) {
+        const { formatForSlack } = await import('../roleplay/agent-messenger.js');
+        const { isRoleplayEnabled } = await import('../roleplay/roleplay-config.js');
+        if (isRoleplayEnabled()) {
+          const payload = formatForSlack(event.data.role, event.data.message, event.data.type);
+          await slackApiCall('chat.postMessage', this._token, { channel: this._channel, ...payload });
+        }
+        return;
+      }
+
+      const blocks = this._eventToBlocks(event);
+      if (blocks) {
+        await slackApiCall('chat.postMessage', this._token, {
+          channel: this._channel,
+          blocks,
+          text: event.type || 'Pipeline update',
+        });
+      }
+    } catch (e) {
+      console.error(`[Slack] Failed to post event: ${e.message}`);
+    }
+  }
+
+  /** Convert a pipeline event to Slack Block Kit blocks */
+  _eventToBlocks(event) {
+    const type = event.type || event.event;
+    if (!type) return null;
+
+    const emoji = {
+      review_done: '📝', deploy_result: '🚀', feature_start: '✨',
+      stage_change: '🔄', error: '❌', approval_needed: '⏳',
+      idle: '💤', stall: '⚠️',
+    };
+
+    const icon = emoji[type] || 'ℹ️';
+    const header = `${icon} ${type.replace(/_/g, ' ').toUpperCase()}`;
+
+    const blocks = [
+      { type: 'header', text: { type: 'plain_text', text: header } },
+    ];
+
+    if (event.data?.message || event.message) {
+      blocks.push({
+        type: 'section',
+        text: { type: 'mrkdwn', text: event.data?.message || event.message },
+      });
+    }
+
+    if (event.data?.stage || event.stage) {
+      blocks.push({
+        type: 'context',
+        elements: [{ type: 'mrkdwn', text: `*Stage:* ${event.data?.stage || event.stage}` }],
+      });
+    }
+
+    return blocks;
+  }
+
+  /**
+   * Format pipeline status as Slack Block Kit.
+   * @param {object} status
+   * @returns {Array}
+   */
+  _formatStatus(status) {
+    if (!status) return [{ type: 'section', text: { type: 'mrkdwn', text: '⚠️ No status data available' } }];
+
+    const stageEmoji = {
+      idle: '💤', reviewing: '📝', implementing: '🔧',
+      deploying: '🚀', testing: '🧪', fixing: '🔨',
+    };
+    const icon = stageEmoji[status.stage] || '❓';
+
+    return [
+      { type: 'header', text: { type: 'plain_text', text: `${icon} Pipeline Status` } },
+      {
+        type: 'section',
+        fields: [
+          { type: 'mrkdwn', text: `*Stage:*\n${status.stage || 'unknown'}` },
+          { type: 'mrkdwn', text: `*Feature:*\n${status.current_feature || '—'}` },
+          { type: 'mrkdwn', text: `*Auto-pilot:*\n${status.auto_pilot ? '✅ On' : '❌ Off'}` },
+          { type: 'mrkdwn', text: `*Checkpoint:*\n${status.checkpoint || '—'}` },
+        ],
+      },
+    ];
+  }
+
+  /**
+   * Format health data as Slack Block Kit.
+   * @param {object} health
+   * @returns {Array}
+   */
+  _formatHealth(health) {
+    if (!health) return [{ type: 'section', text: { type: 'mrkdwn', text: '⚠️ No health data available' } }];
+
+    const overallIcon = health.status === 'healthy' ? '🟢' : health.status === 'degraded' ? '🟡' : '🔴';
+
+    const blocks = [
+      { type: 'header', text: { type: 'plain_text', text: `${overallIcon} System Health` } },
+    ];
+
+    if (health.checks && typeof health.checks === 'object') {
+      const lines = Object.entries(health.checks).map(([name, check]) => {
+        const icon = check.status === 'ok' ? '✅' : check.status === 'warn' ? '⚠️' : '❌';
+        return `${icon} *${name}:* ${check.message || check.status}`;
+      });
+      blocks.push({ type: 'section', text: { type: 'mrkdwn', text: lines.join('\n') } });
+    }
+
+    return blocks;
+  }
+}
+
+// ─── Slash command handler ─────────────────────────────────────────────────────
+
+/**
+ * Process a slash command and return a response.
+ *
+ * @param {string} command — the command name (e.g. 'status', 'deploy')
+ * @param {string} args — additional arguments
+ * @param {string} userId — Slack user ID
+ * @returns {Promise<{text:string, blocks?:Array}>}
+ */
+export async function handleSlashCommand(command, args, userId) {
+  const cmd = (command || '').trim().toLowerCase();
+
+  try {
+    switch (cmd) {
+      case 'status': {
+        const status = await actions.getStatusData();
+        const bot = new SlackBot({});
+        return { text: 'Pipeline status', blocks: bot._formatStatus(status) };
+      }
+
+      case 'feature': {
+        if (!args?.trim()) return { text: '❌ Usage: `/aicc feature <description>`' };
+        const result = await actions.runNewFeature(args.trim());
+        return { text: `✨ Feature started: ${args.trim()}`, blocks: [
+          { type: 'section', text: { type: 'mrkdwn', text: `✨ *Feature started:* ${args.trim()}` } },
+        ] };
+      }
+
+      case 'deploy': {
+        await actions.runDeploy();
+        return { text: '🚀 Deploy initiated' };
+      }
+
+      case 'approve': {
+        await actions.runApprove();
+        return { text: '✅ Approved' };
+      }
+
+      case 'reject': {
+        const reason = args?.trim() || 'Rejected via Slack';
+        await actions.runReject(reason);
+        return { text: `❌ Rejected: ${reason}` };
+      }
+
+      case 'review': {
+        await actions.runReview();
+        return { text: '📝 Review triggered' };
+      }
+
+      case 'health': {
+        const health = await actions.getHealthData();
+        const bot = new SlackBot({});
+        return { text: 'System health', blocks: bot._formatHealth(health) };
+      }
+
+      case 'cost': {
+        const summary = getCostSummary();
+        const text = formatCostSummary(summary);
+        return { text, blocks: [
+          { type: 'section', text: { type: 'mrkdwn', text: `\`\`\`\n${text}\n\`\`\`` } },
+        ] };
+      }
+
+      case 'retry': {
+        const fresh = args?.trim().toLowerCase() === 'fresh';
+        await actions.retryFromCheckpoint(fresh);
+        return { text: `🔄 Retry initiated${fresh ? ' (fresh)' : ''}` };
+      }
+
+      default:
+        return {
+          text: '🤖 *AICC Commands:*\n' +
+            '• `status` — pipeline status\n' +
+            '• `feature <desc>` — create feature\n' +
+            '• `deploy` — deploy\n' +
+            '• `approve` — approve\n' +
+            '• `reject <reason>` — reject\n' +
+            '• `review` — trigger review\n' +
+            '• `health` — health check\n' +
+            '• `cost` — cost breakdown\n' +
+            '• `retry [fresh]` — retry from checkpoint',
+        };
+    }
+  } catch (e) {
+    return { text: `❌ Error: ${e.message}` };
+  }
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Send a message to a Slack channel.
+ *
+ * @param {string} channel — Channel name or ID
+ * @param {string} text — Fallback text
+ * @param {Array} [blocks] — Slack Block Kit blocks
+ */
+export async function sendSlackMessage(channel, text, blocks) {
+  let token;
+  try {
+    const cfg = getConfig();
+    token = cfg.slack?.token || process.env.SLACK_BOT_TOKEN;
+  } catch {
+    token = process.env.SLACK_BOT_TOKEN;
+  }
+
+  if (!token) throw new Error('Slack bot token not configured');
+
+  const body = { channel, text };
+  if (blocks) body.blocks = blocks;
+  return slackApiCall('chat.postMessage', token, body);
+}
+
+/**
+ * Start the Slack bot.
+ *
+ * @param {object} [options]
+ * @param {string} [options.token] — Slack Bot Token
+ * @param {string} [options.signingSecret] — Slack Signing Secret
+ * @param {string} [options.channel] — Default channel
+ * @returns {SlackBot}
+ */
+export function startSlackBot(options = {}) {
+  if (_bot) { _bot.stop(); }
+
+  let slackConfig = {};
+  try {
+    const cfg = getConfig();
+    slackConfig = cfg.slack || {};
+  } catch { /* use options only */ }
+
+  const config = {
+    token: options.token || slackConfig.token || process.env.SLACK_BOT_TOKEN,
+    signingSecret: options.signingSecret || slackConfig.signingSecret || process.env.SLACK_SIGNING_SECRET,
+    channel: options.channel || slackConfig.channel || '#ai-pipeline',
+  };
+
+  if (!config.token) {
+    console.error('  ✗  Slack bot token not configured.');
+    console.error('     Set SLACK_BOT_TOKEN env var or slack.token in aicc.config.js');
+    return null;
+  }
+
+  _bot = new SlackBot(config);
+  _bot.start();
+  return _bot;
+}
+
+/** Stop the Slack bot */
+export function stopSlackBot() {
+  if (_bot) {
+    _bot.stop();
+    _bot = null;
+  }
+}