slashvibe-mcp 0.3.21 → 0.3.22

package/bridges/telegram.js

@@ -1,261 +0,0 @@
-/**
- * /vibe Telegram Bridge
- *
- * Two-way bridge between /vibe and Telegram:
- * - Receive messages/commands via Telegram bot
- * - Send messages to individuals/groups via bot
- * - Forward /vibe activity to Telegram channels
- */
-
-const config = require('../config');
-
-/**
- * Get Telegram bot credentials from config
- */
-function getBotToken() {
-  const cfg = config.load();
-  return cfg.telegram_bot_token || process.env.TELEGRAM_BOT_TOKEN || null;
-}
-
-/**
- * Check if Telegram bridge is configured
- */
-function isConfigured() {
-  return !!getBotToken();
-}
-
-/**
- * Get bot info
- */
-async function getBotInfo() {
-  const token = getBotToken();
-  if (!token) throw new Error('Telegram bot token not configured');
-
-  const response = await fetch(`https://api.telegram.org/bot${token}/getMe`);
-  const data = await response.json();
-  
-  if (!data.ok) {
-    throw new Error(`Telegram API error: ${data.description}`);
-  }
-  
-  return data.result;
-}
-
-/**
- * Send a message to a chat (user or group)
- */
-async function sendMessage(chatId, text, options = {}) {
-  const token = getBotToken();
-  if (!token) throw new Error('Telegram bot token not configured');
-
-  const body = {
-    chat_id: chatId,
-    text: text,
-    parse_mode: options.markdown ? 'Markdown' : undefined,
-    reply_to_message_id: options.replyTo || undefined,
-    disable_notification: options.silent || false
-  };
-
-  const response = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body)
-  });
-
-  const data = await response.json();
-  
-  if (!data.ok) {
-    throw new Error(`Telegram send error: ${data.description}`);
-  }
-  
-  return data.result;
-}
-
-/**
- * Get updates (messages) from Telegram
- * For long polling or webhook verification
- */
-async function getUpdates(offset = null, limit = 100) {
-  const token = getBotToken();
-  if (!token) throw new Error('Telegram bot token not configured');
-
-  const params = new URLSearchParams({ limit: limit.toString() });
-  if (offset) params.set('offset', offset.toString());
-
-  const response = await fetch(`https://api.telegram.org/bot${token}/getUpdates?${params}`);
-  const data = await response.json();
-  
-  if (!data.ok) {
-    throw new Error(`Telegram getUpdates error: ${data.description}`);
-  }
-  
-  return data.result;
-}
-
-/**
- * Set webhook URL for receiving updates
- */
-async function setWebhook(url, secretToken = null) {
-  const token = getBotToken();
-  if (!token) throw new Error('Telegram bot token not configured');
-
-  const body = { url };
-  if (secretToken) body.secret_token = secretToken;
-
-  const response = await fetch(`https://api.telegram.org/bot${token}/setWebhook`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body)
-  });
-
-  const data = await response.json();
-  
-  if (!data.ok) {
-    throw new Error(`Telegram setWebhook error: ${data.description}`);
-  }
-  
-  return data.result;
-}
-
-/**
- * Process incoming webhook update from Telegram
- */
-function processUpdate(update) {
-  const message = update.message || update.edited_message;
-  if (!message) return null;
-
-  const from = message.from;
-  const chat = message.chat;
-  
-  return {
-    id: `telegram:${message.message_id}`,
-    channel: 'telegram',
-    type: chat.type === 'private' ? 'dm' : 'group',
-    from: {
-      id: from.id.toString(),
-      handle: from.username || from.first_name,
-      name: [from.first_name, from.last_name].filter(Boolean).join(' ')
-    },
-    chat: {
-      id: chat.id.toString(),
-      title: chat.title || null,
-      type: chat.type
-    },
-    content: message.text || '[media]',
-    timestamp: new Date(message.date * 1000).toISOString(),
-    raw: update
-  };
-}
-
-/**
- * Send /vibe activity notification to Telegram
- */
-async function notifyActivity(chatId, activity) {
-  const { handle, action, context } = activity;
-  
-  let text = `🔔 *@${handle}* ${action}`;
-  if (context) {
-    text += `\n_${context}_`;
-  }
-  
-  return sendMessage(chatId, text, { markdown: true, silent: true });
-}
-
-/**
- * Send /vibe status update to Telegram
- */
-async function notifyStatus(chatId, handle, mood, note) {
-  const moodEmoji = {
-    'shipping': '🔥',
-    'debugging': '🐛', 
-    'deep': '🧠',
-    'afk': '☕',
-    'celebrating': '🎉',
-    'pairing': '👯'
-  };
-  
-  const emoji = moodEmoji[mood] || '●';
-  let text = `${emoji} *@${handle}* is ${mood}`;
-  
-  if (note) {
-    text += `\n"${note}"`;
-  }
-  
-  return sendMessage(chatId, text, { markdown: true });
-}
-
-/**
- * Send message from /vibe to Telegram
- */
-async function forwardFromVibe(chatId, handle, message, context = null) {
-  let text = `💭 *@${handle}*: ${message}`;
-  
-  if (context) {
-    text += `\n_via ${context}_`;
-  }
-  
-  return sendMessage(chatId, text, { markdown: true });
-}
-
-/**
- * Handle /vibe commands from Telegram
- */
-function parseVibeCommand(text) {
-  const trimmed = text.trim();
-  
-  // /status mood [note]
-  const statusMatch = trimmed.match(/^\/status\s+(\w+)(?:\s+(.+))?$/);
-  if (statusMatch) {
-    return {
-      command: 'status',
-      params: {
-        mood: statusMatch[1],
-        note: statusMatch[2] || null
-      }
-    };
-  }
-  
-  // /who
-  if (trimmed === '/who') {
-    return { command: 'who' };
-  }
-  
-  // /ship [message]
-  const shipMatch = trimmed.match(/^\/ship(?:\s+(.+))?$/);
-  if (shipMatch) {
-    return {
-      command: 'ship',
-      params: {
-        message: shipMatch[1] || null
-      }
-    };
-  }
-  
-  // /dm @handle message
-  const dmMatch = trimmed.match(/^\/dm\s+@?(\w+)\s+(.+)$/);
-  if (dmMatch) {
-    return {
-      command: 'dm',
-      params: {
-        handle: dmMatch[1],
-        message: dmMatch[2]
-      }
-    };
-  }
-  
-  return null;
-}
-
-module.exports = {
-  isConfigured,
-  getBotToken,
-  getBotInfo,
-  sendMessage,
-  getUpdates,
-  setWebhook,
-  processUpdate,
-  parseVibeCommand,
-  notifyActivity,
-  notifyStatus,
-  forwardFromVibe
-};

package/bridges/webhook-health.js

@@ -1,420 +0,0 @@
-/**
- * /vibe Webhook Health Monitor
- * 
- * Monitors webhook endpoint health and provides diagnostics for bridge connectivity.
- * Ensures external platforms can reach /vibe webhook endpoints reliably.
- */
-
-const https = require('https');
-const { getConfig } = require('./webhook-server');
-
-/**
- * Test webhook endpoint connectivity
- */
-async function testWebhookEndpoint(url) {
-  return new Promise((resolve) => {
-    const startTime = Date.now();
-    
-    const options = {
-      method: 'GET',
-      timeout: 5000,
-      headers: {
-        'User-Agent': 'vibe-webhook-health-check'
-      }
-    };
-
-    const req = https.request(url, options, (res) => {
-      const responseTime = Date.now() - startTime;
-      let body = '';
-
-      res.on('data', chunk => body += chunk);
-      res.on('end', () => {
-        resolve({
-          success: true,
-          status: res.statusCode,
-          responseTime,
-          headers: res.headers,
-          body: body.slice(0, 500) // First 500 chars
-        });
-      });
-    });
-
-    req.on('error', (err) => {
-      resolve({
-        success: false,
-        error: err.message,
-        responseTime: Date.now() - startTime
-      });
-    });
-
-    req.on('timeout', () => {
-      req.destroy();
-      resolve({
-        success: false,
-        error: 'Request timeout',
-        responseTime: Date.now() - startTime
-      });
-    });
-
-    req.end();
-  });
-}
-
-/**
- * Test webhook endpoint with mock payload
- */
-async function testWebhookPost(url, platform, mockPayload) {
-  return new Promise((resolve) => {
-    const startTime = Date.now();
-    const payloadStr = JSON.stringify(mockPayload);
-    
-    const options = {
-      method: 'POST',
-      timeout: 10000,
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(payloadStr),
-        'User-Agent': `vibe-webhook-test-${platform}`
-      }
-    };
-
-    // Add platform-specific headers
-    if (platform === 'telegram') {
-      options.headers['x-telegram-bot-api-secret-token'] = 'test-token';
-    } else if (platform === 'discord') {
-      options.headers['x-signature-ed25519'] = 'test-signature';
-      options.headers['x-signature-timestamp'] = Math.floor(Date.now() / 1000).toString();
-    }
-
-    const req = https.request(url, options, (res) => {
-      const responseTime = Date.now() - startTime;
-      let body = '';
-
-      res.on('data', chunk => body += chunk);
-      res.on('end', () => {
-        resolve({
-          success: res.statusCode >= 200 && res.statusCode < 300,
-          status: res.statusCode,
-          responseTime,
-          body: body.slice(0, 1000)
-        });
-      });
-    });
-
-    req.on('error', (err) => {
-      resolve({
-        success: false,
-        error: err.message,
-        responseTime: Date.now() - startTime
-      });
-    });
-
-    req.on('timeout', () => {
-      req.destroy();
-      resolve({
-        success: false,
-        error: 'Request timeout',
-        responseTime: Date.now() - startTime
-      });
-    });
-
-    req.write(payloadStr);
-    req.end();
-  });
-}
-
-/**
- * Generate mock payloads for testing
- */
-function getMockPayloads() {
-  return {
-    telegram: {
-      update_id: 123456789,
-      message: {
-        message_id: 1,
-        date: Math.floor(Date.now() / 1000),
-        text: '/test webhook connectivity',
-        from: {
-          id: 987654321,
-          is_bot: false,
-          first_name: 'Test',
-          username: 'testuser'
-        },
-        chat: {
-          id: 987654321,
-          type: 'private',
-          first_name: 'Test',
-          username: 'testuser'
-        }
-      }
-    },
-    
-    discord: {
-      type: 1, // PING
-      timestamp: new Date().toISOString(),
-      id: '123456789012345678',
-      token: 'test_interaction_token'
-    }
-  };
-}
-
-/**
- * Comprehensive webhook health check
- */
-async function performWebhookHealthCheck(baseUrl) {
-  const results = {
-    timestamp: new Date().toISOString(),
-    baseUrl,
-    endpoints: {},
-    overall: { healthy: true, issues: [] }
-  };
-
-  // Test health endpoint
-  const healthUrl = `${baseUrl}/health`;
-  console.log(`Testing health endpoint: ${healthUrl}`);
-  
-  const healthResult = await testWebhookEndpoint(healthUrl);
-  results.endpoints.health = {
-    url: healthUrl,
-    ...healthResult
-  };
-  
-  if (!healthResult.success) {
-    results.overall.healthy = false;
-    results.overall.issues.push('Health endpoint unreachable');
-  }
-
-  // Test Telegram webhook endpoint
-  const telegramUrl = `${baseUrl}/webhook/telegram`;
-  console.log(`Testing Telegram webhook: ${telegramUrl}`);
-  
-  const mockPayloads = getMockPayloads();
-  const telegramResult = await testWebhookPost(telegramUrl, 'telegram', mockPayloads.telegram);
-  results.endpoints.telegram = {
-    url: telegramUrl,
-    ...telegramResult
-  };
-
-  if (!telegramResult.success && telegramResult.status !== 401) {
-    // 401 is expected for test payload, other errors are concerning
-    results.overall.healthy = false;
-    results.overall.issues.push(`Telegram webhook issue: ${telegramResult.error || 'HTTP ' + telegramResult.status}`);
-  }
-
-  // Test Discord webhook endpoint  
-  const discordUrl = `${baseUrl}/webhook/discord`;
-  console.log(`Testing Discord webhook: ${discordUrl}`);
-  
-  const discordResult = await testWebhookPost(discordUrl, 'discord', mockPayloads.discord);
-  results.endpoints.discord = {
-    url: discordUrl,
-    ...discordResult
-  };
-
-  if (!discordResult.success && discordResult.status !== 401) {
-    results.overall.healthy = false;
-    results.overall.issues.push(`Discord webhook issue: ${discordResult.error || 'HTTP ' + discordResult.status}`);
-  }
-
-  return results;
-}
-
-/**
- * Get webhook endpoint status for external platforms
- */
-async function getWebhookStatus(publicUrl) {
-  if (!publicUrl) {
-    return {
-      configured: false,
-      error: 'No public webhook URL configured',
-      setup: 'Set WEBHOOK_PUBLIC_URL environment variable'
-    };
-  }
-
-  try {
-    const healthCheck = await performWebhookHealthCheck(publicUrl);
-    
-    return {
-      configured: true,
-      healthy: healthCheck.overall.healthy,
-      lastCheck: healthCheck.timestamp,
-      endpoints: {
-        health: healthCheck.endpoints.health?.success || false,
-        telegram: healthCheck.endpoints.telegram?.success || healthCheck.endpoints.telegram?.status === 401,
-        discord: healthCheck.endpoints.discord?.success || healthCheck.endpoints.discord?.status === 401
-      },
-      issues: healthCheck.overall.issues,
-      publicUrl
-    };
-
-  } catch (e) {
-    return {
-      configured: true,
-      healthy: false,
-      error: e.message,
-      publicUrl
-    };
-  }
-}
-
-/**
- * Generate webhook setup diagnostics
- */
-function getWebhookDiagnostics() {
-  const config = getConfig();
-  
-  const diagnostics = {
-    server: {
-      port: config.port,
-      configured: true
-    },
-    security: {
-      webhookSecret: !!config.secret,
-      telegramSecret: !!config.telegramSecret,
-      discordPublicKey: !!config.discordPublicKey
-    },
-    channels: {
-      telegram: {
-        botConfigured: !!config.telegramSecret,
-        chatId: !!config.telegramChatId
-      },
-      discord: {
-        publicKeyConfigured: !!config.discordPublicKey,
-        channelId: !!config.vibeChannelId
-      }
-    },
-    recommendations: []
-  };
-
-  // Add recommendations based on configuration gaps
-  if (!config.secret) {
-    diagnostics.recommendations.push('Set WEBHOOK_SECRET for signature verification');
-  }
-  
-  if (!config.telegramSecret) {
-    diagnostics.recommendations.push('Set TELEGRAM_WEBHOOK_SECRET for Telegram webhook security');
-  }
-  
-  if (!config.discordPublicKey) {
-    diagnostics.recommendations.push('Set DISCORD_PUBLIC_KEY for Discord interaction verification');
-  }
-
-  if (!config.telegramChatId) {
-    diagnostics.recommendations.push('Set TELEGRAM_VIBE_CHAT_ID to forward messages to /vibe');
-  }
-
-  if (!config.vibeChannelId) {
-    diagnostics.recommendations.push('Set DISCORD_VIBE_CHANNEL_ID to forward messages to /vibe');
-  }
-
-  return diagnostics;
-}
-
-/**
- * Monitor webhook endpoint availability over time
- */
-class WebhookMonitor {
-  constructor(publicUrl, checkIntervalMs = 300000) { // 5 minutes
-    this.publicUrl = publicUrl;
-    this.checkIntervalMs = checkIntervalMs;
-    this.isRunning = false;
-    this.intervalId = null;
-    this.history = [];
-    this.maxHistorySize = 144; // 24 hours at 5-minute intervals
-  }
-
-  async start() {
-    if (this.isRunning) return;
-    
-    console.log(`🔍 Starting webhook endpoint monitoring (${this.publicUrl})`);
-    this.isRunning = true;
-    
-    // Initial check
-    await this.performCheck();
-    
-    // Schedule regular checks
-    this.intervalId = setInterval(() => {
-      this.performCheck().catch(err => {
-        console.error('Webhook monitor error:', err);
-      });
-    }, this.checkIntervalMs);
-  }
-
-  stop() {
-    if (!this.isRunning) return;
-    
-    console.log('🛑 Stopping webhook endpoint monitoring');
-    this.isRunning = false;
-    
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-  }
-
-  async performCheck() {
-    const checkResult = await getWebhookStatus(this.publicUrl);
-    
-    const historyEntry = {
-      timestamp: new Date().toISOString(),
-      healthy: checkResult.healthy,
-      responseTime: checkResult.endpoints?.health ? 
-        (checkResult.endpoints.health.responseTime || 0) : 0,
-      issues: checkResult.issues || []
-    };
-
-    // Add to history
-    this.history.unshift(historyEntry);
-    
-    // Trim history to max size
-    if (this.history.length > this.maxHistorySize) {
-      this.history = this.history.slice(0, this.maxHistorySize);
-    }
-
-    // Log significant state changes
-    if (this.history.length > 1) {
-      const prevCheck = this.history[1];
-      if (checkResult.healthy !== prevCheck.healthy) {
-        const status = checkResult.healthy ? '✅ RECOVERED' : '❌ DEGRADED';
-        console.log(`Webhook health changed: ${status} - ${this.publicUrl}`);
-      }
-    }
-
-    return checkResult;
-  }
-
-  getHealthStats() {
-    if (this.history.length === 0) return null;
-
-    const totalChecks = this.history.length;
-    const healthyChecks = this.history.filter(h => h.healthy).length;
-    const uptime = (healthyChecks / totalChecks) * 100;
-
-    const responseTimes = this.history
-      .filter(h => h.responseTime > 0)
-      .map(h => h.responseTime);
-    
-    const avgResponseTime = responseTimes.length > 0
-      ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length
-      : 0;
-
-    return {
-      uptime: `${uptime.toFixed(1)}%`,
-      totalChecks,
-      healthyChecks,
-      avgResponseTime: Math.round(avgResponseTime),
-      lastCheck: this.history[0]?.timestamp,
-      isCurrentlyHealthy: this.history[0]?.healthy || false
-    };
-  }
-}
-
-module.exports = {
-  testWebhookEndpoint,
-  testWebhookPost,
-  performWebhookHealthCheck,
-  getWebhookStatus,
-  getWebhookDiagnostics,
-  getMockPayloads,
-  WebhookMonitor
-};