slashvibe-mcp 0.2.9 → 0.3.13

package/tools/_deprecated/bridge-live.js

@@ -0,0 +1,384 @@
+/**
+ * vibe bridge-live — Real-time bridge activity monitor
+ *
+ * Live dashboard showing incoming messages, outgoing posts, and bridge health.
+ * Perfect for monitoring social activity during /vibe sessions.
+ */
+
+const twitter = require('../twitter');
+const telegram = require('../bridges/telegram');
+const farcaster = require('../bridges/farcaster');
+const { requireInit, header, divider, success, warning } = require('./_shared');
+
+const definition = {
+  name: 'vibe_bridge_live',
+  description: 'Real-time monitor of social bridge activity and health',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      duration: {
+        type: 'number',
+        description: 'Monitor duration in seconds (default: 30, max: 300)'
+      },
+      refresh_interval: {
+        type: 'number',
+        description: 'Refresh interval in seconds (default: 5, min: 2)'
+      },
+      platforms: {
+        type: 'array',
+        items: { 
+          type: 'string',
+          enum: ['x', 'telegram', 'farcaster', 'discord']
+        },
+        description: 'Platforms to monitor (default: all configured)'
+      },
+      show_content: {
+        type: 'boolean',
+        description: 'Show message content preview (default: true)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { 
+    duration = 30, 
+    refresh_interval = 5,
+    platforms,
+    show_content = true
+  } = args;
+
+  // Validate inputs
+  if (duration > 300) {
+    return { display: 'Maximum duration is 300 seconds (5 minutes)' };
+  }
+  
+  if (refresh_interval < 2) {
+    return { display: 'Minimum refresh interval is 2 seconds' };
+  }
+
+  const startTime = Date.now();
+  const endTime = startTime + (duration * 1000);
+  const interval = refresh_interval * 1000;
+
+  let display = header('Bridge Live Monitor');
+  display += `\\n\\nStarted: ${new Date().toLocaleTimeString()}\\n`;
+  display += `Duration: ${duration}s | Refresh: ${refresh_interval}s\\n`;
+  display += divider();
+  display += '\\n';
+
+  // Initial snapshot
+  const activity = {
+    sessions: 0,
+    messages: [],
+    errors: [],
+    platforms: await getActivePlatforms(platforms)
+  };
+
+  // Show initial state
+  display += await formatLiveSnapshot(activity, show_content);
+
+  // Simulated live monitoring (in real implementation, this would be event-driven)
+  let currentTime = Date.now();
+  let sessionCount = 1;
+
+  while (currentTime < endTime) {
+    // Wait for next refresh
+    await sleep(interval);
+    currentTime = Date.now();
+    sessionCount++;
+
+    // Simulate new activity (in real implementation, this would pull from event queues)
+    const newActivity = await collectRecentActivity(activity.platforms, interval / 1000);
+    
+    if (newActivity.length > 0) {
+      activity.messages.push(...newActivity);
+      activity.sessions = sessionCount;
+      
+      // Keep only recent messages (last 10)
+      activity.messages = activity.messages.slice(-10);
+      
+      // Update display with new activity
+      display += `\\n\\n**Update ${sessionCount}** (${new Date().toLocaleTimeString()})\\n`;
+      display += formatNewActivity(newActivity, show_content);
+    }
+
+    // Check for platform issues
+    const healthIssues = await checkForNewIssues(activity.platforms);
+    if (healthIssues.length > 0) {
+      activity.errors.push(...healthIssues);
+      display += '\\n' + warning('New issues detected:\\n' + healthIssues.map(e => `• ${e}`).join('\\n'));
+    }
+
+    // Progress indicator
+    const elapsed = (currentTime - startTime) / 1000;
+    const remaining = Math.max(0, duration - elapsed);
+    display += `\\n\\n_Monitoring... ${remaining.toFixed(0)}s remaining_`;
+
+    if (remaining <= 0) break;
+  }
+
+  // Final summary
+  display += '\\n\\n' + divider();
+  display += formatFinalSummary(activity, duration);
+
+  return { display };
+}
+
+async function getActivePlatforms(requestedPlatforms) {
+  const platforms = {};
+
+  // Check which platforms are configured and active
+  const available = ['x', 'telegram', 'farcaster', 'discord'];
+  const toCheck = requestedPlatforms || available;
+
+  for (const platform of toCheck) {
+    switch (platform) {
+      case 'x':
+        if (twitter.isConfigured()) {
+          try {
+            const me = await twitter.getMe();
+            platforms.x = {
+              active: true,
+              username: me.data.username,
+              lastActivity: Date.now()
+            };
+          } catch (e) {
+            platforms.x = { active: false, error: e.message };
+          }
+        }
+        break;
+
+      case 'telegram':
+        if (telegram.isConfigured()) {
+          try {
+            const bot = await telegram.getBotInfo();
+            platforms.telegram = {
+              active: true,
+              username: bot.username,
+              lastActivity: Date.now()
+            };
+          } catch (e) {
+            platforms.telegram = { active: false, error: e.message };
+          }
+        }
+        break;
+
+      case 'farcaster':
+        if (farcaster.isConfigured()) {
+          try {
+            const user = await farcaster.getUser();
+            platforms.farcaster = {
+              active: true,
+              username: user.users[0].username,
+              lastActivity: Date.now()
+            };
+          } catch (e) {
+            platforms.farcaster = { active: false, error: e.message };
+          }
+        }
+        break;
+        
+      case 'discord':
+        // Discord webhook doesn't provide status info
+        platforms.discord = {
+          active: false, // Assume webhook-only for now
+          username: 'webhook',
+          lastActivity: Date.now()
+        };
+        break;
+    }
+  }
+
+  return platforms;
+}
+
+async function formatLiveSnapshot(activity, showContent) {
+  let result = '**Active Platforms:**\\n';
+  
+  const activePlatforms = Object.entries(activity.platforms)
+    .filter(([_, platform]) => platform.active);
+  
+  if (activePlatforms.length === 0) {
+    result += '_No active platforms_\\n\\n';
+    result += 'Configure platforms with: `vibe bridges`\\n';
+    return result;
+  }
+
+  for (const [name, platform] of activePlatforms) {
+    const icon = platform.active ? '🟢' : '🔴';
+    result += `${icon} **${name.toUpperCase()}** (@${platform.username})\\n`;
+  }
+
+  result += '\\n**Recent Activity:**\\n';
+  if (activity.messages.length === 0) {
+    result += '_No recent messages_\\n';
+  } else {
+    result += formatMessages(activity.messages.slice(-5), showContent);
+  }
+
+  return result;
+}
+
+async function collectRecentActivity(platforms, intervalSeconds) {
+  const activity = [];
+  
+  // In a real implementation, this would:
+  // 1. Check webhook queues for new messages
+  // 2. Poll APIs for mentions/DMs since last check
+  // 3. Monitor outgoing message queues
+  // 4. Track rate limit status
+  
+  // For demo, simulate some activity
+  const activePlatforms = Object.keys(platforms).filter(p => platforms[p].active);
+  
+  if (activePlatforms.length > 0 && Math.random() < 0.3) {
+    const randomPlatform = activePlatforms[Math.floor(Math.random() * activePlatforms.length)];
+    
+    activity.push({
+      platform: randomPlatform,
+      type: Math.random() < 0.7 ? 'mention' : 'dm',
+      from: `user_${Math.floor(Math.random() * 1000)}`,
+      content: generateSampleMessage(),
+      timestamp: new Date().toISOString(),
+      processed: true
+    });
+  }
+
+  return activity;
+}
+
+function generateSampleMessage() {
+  const samples = [
+    'Hey! Checking out /vibe',
+    'Love the unified social interface',
+    'How do I post to multiple channels?', 
+    'The bridge system is really smooth',
+    'Just shipped a new feature!',
+    '/status shipping working on something cool'
+  ];
+  
+  return samples[Math.floor(Math.random() * samples.length)];
+}
+
+async function checkForNewIssues(platforms) {
+  const issues = [];
+  
+  // Simulate health checks
+  for (const [name, platform] of Object.entries(platforms)) {
+    if (platform.active && Math.random() < 0.05) { // 5% chance of issue
+      issues.push(`${name}: Rate limit approaching`);
+    }
+  }
+  
+  return issues;
+}
+
+function formatNewActivity(activities, showContent) {
+  if (activities.length === 0) return '_No new activity_\\n';
+  
+  let result = '';
+  for (const activity of activities) {
+    const icon = getActivityIcon(activity.type);
+    const platform = activity.platform.toUpperCase();
+    
+    result += `${icon} **${platform}** from @${activity.from}`;
+    
+    if (showContent && activity.content) {
+      const preview = activity.content.length > 50 
+        ? activity.content.slice(0, 50) + '...'
+        : activity.content;
+      result += ` — "${preview}"`;
+    }
+    
+    result += `\\n`;
+  }
+  
+  return result;
+}
+
+function formatMessages(messages, showContent) {
+  let result = '';
+  
+  for (const msg of messages) {
+    const timeAgo = formatTimeAgo(new Date(msg.timestamp));
+    const icon = getActivityIcon(msg.type);
+    const platform = msg.platform.toUpperCase();
+    
+    result += `${icon} **${platform}** @${msg.from} — _${timeAgo}_\\n`;
+    
+    if (showContent && msg.content) {
+      const preview = msg.content.length > 80 
+        ? msg.content.slice(0, 80) + '...'
+        : msg.content;
+      result += `   "${preview}"\\n`;
+    }
+    
+    result += '\\n';
+  }
+  
+  return result;
+}
+
+function formatFinalSummary(activity, duration) {
+  const totalMessages = activity.messages.length;
+  const activePlatforms = Object.values(activity.platforms).filter(p => p.active).length;
+  const errorCount = activity.errors.length;
+  
+  let result = success(`**Live Monitor Complete**\\n\\n`);
+  result += `**Summary:**\\n`;
+  result += `• Duration: ${duration} seconds\\n`;
+  result += `• Active platforms: ${activePlatforms}\\n`;  
+  result += `• Messages processed: ${totalMessages}\\n`;
+  result += `• Errors: ${errorCount}\\n\\n`;
+  
+  if (activity.messages.length > 0) {
+    result += `**Most Recent Messages:**\\n`;
+    result += formatMessages(activity.messages.slice(-3), true);
+  }
+  
+  if (activity.errors.length > 0) {
+    result += `\\n**Issues Detected:**\\n`;
+    result += activity.errors.map(e => `• ${e}`).join('\\n');
+    result += '\\n\\nRun `vibe bridge-health` for detailed diagnostics.';
+  }
+  
+  result += '\\n\\n**Next Steps:**\\n';
+  result += '• Check unified inbox: `vibe social-inbox --refresh`\\n';
+  result += '• Post across platforms: `vibe social-post "message" --channels ["x","telegram"]`\\n';
+  result += '• Monitor health: `vibe bridge-health --details`';
+  
+  return result;
+}
+
+function getActivityIcon(type) {
+  const icons = {
+    mention: '@',
+    dm: '✉️',
+    reply: '↩️',
+    like: '❤️',
+    repost: '🔁',
+    post: '📤'
+  };
+  return icons[type] || '📨';
+}
+
+function formatTimeAgo(date) {
+  const now = new Date();
+  const diffMs = now - date;
+  const diffSecs = Math.floor(diffMs / 1000);
+  const diffMins = Math.floor(diffSecs / 60);
+  
+  if (diffSecs < 60) return `${diffSecs}s ago`;
+  if (diffMins < 60) return `${diffMins}m ago`;
+  return date.toLocaleTimeString();
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = { definition, handler };