slashvibe-mcp 0.2.4 → 0.2.6

package/auth-store.js

@@ -0,0 +1,148 @@
+/**
+ * Auth Store - In-memory singleton for authentication state
+ *
+ * This is the SOURCE OF TRUTH for auth during MCP runtime.
+ * File persistence (config.json) is only for durability across restarts.
+ *
+ * Why this exists:
+ * - OAuth callback and API calls happen in the same MCP process
+ * - File-based auth was unreliable due to per-PID session files and caching
+ * - In-memory state is immediate and deterministic
+ *
+ * Usage:
+ * - Startup: authStore.hydrate() loads from disk once
+ * - OAuth: authStore.setToken(token) updates immediately
+ * - API calls: authStore.getToken() returns current token (no file I/O)
+ */
+
+// In-memory state - the single source of truth during runtime
+let _token = null;
+let _handle = null;
+let _oneLiner = null;
+let _hydrated = false;
+
+/**
+ * Hydrate auth state from disk (call once at MCP startup)
+ * This loads persisted state from config.json
+ */
+function hydrate() {
+  if (_hydrated) return; // Only hydrate once
+
+  try {
+    const config = require('./config');
+    const cfg = config.load();
+
+    _token = cfg.privyToken || null;
+    _handle = cfg.handle || cfg.username || null;
+    _oneLiner = cfg.one_liner || cfg.workingOn || null;
+    _hydrated = true;
+
+    if (_token) {
+      console.error('[auth-store] Hydrated from disk: @' + _handle);
+    } else {
+      console.error('[auth-store] Hydrated from disk: no token');
+    }
+  } catch (e) {
+    console.error('[auth-store] Hydration failed:', e.message);
+  }
+}
+
+/**
+ * Set auth token (call after OAuth completes)
+ * @param {string} token - JWT token
+ */
+function setToken(token) {
+  const hadToken = !!_token;
+  _token = token;
+
+  if (!hadToken && token) {
+    console.error('[auth-store] Token set (was empty)');
+  } else if (hadToken && token && token !== _token) {
+    console.error('[auth-store] Token updated');
+  }
+}
+
+/**
+ * Get current auth token
+ * @returns {string|null} Current token or null
+ */
+function getToken() {
+  return _token;
+}
+
+/**
+ * Set user handle
+ * @param {string} handle - User handle (without @)
+ */
+function setHandle(handle) {
+  _handle = handle;
+}
+
+/**
+ * Get current handle
+ * @returns {string|null} Current handle or null
+ */
+function getHandle() {
+  return _handle;
+}
+
+/**
+ * Set one-liner (what user is building)
+ * @param {string} oneLiner - One-liner description
+ */
+function setOneLiner(oneLiner) {
+  _oneLiner = oneLiner;
+}
+
+/**
+ * Get current one-liner
+ * @returns {string|null} Current one-liner or null
+ */
+function getOneLiner() {
+  return _oneLiner;
+}
+
+/**
+ * Check if user is authenticated
+ * @returns {boolean} True if token exists
+ */
+function isAuthenticated() {
+  return !!_token;
+}
+
+/**
+ * Clear all auth state (for logout/reset)
+ */
+function clear() {
+  _token = null;
+  _handle = null;
+  _oneLiner = null;
+  console.error('[auth-store] Cleared');
+}
+
+/**
+ * Get full auth state (for debugging)
+ * @returns {object} Current auth state
+ */
+function getState() {
+  return {
+    token: _token ? _token.substring(0, 20) + '...' : null,
+    handle: _handle,
+    oneLiner: _oneLiner,
+    hydrated: _hydrated,
+    isAuthenticated: !!_token
+  };
+}
+
+module.exports = {
+  hydrate,
+  setToken,
+  getToken,
+  setHandle,
+  getHandle,
+  setOneLiner,
+  getOneLiner,
+  isAuthenticated,
+  clear,
+  getState
+};

package/auto-update.js

@@ -0,0 +1,125 @@
+/**
+ * Auto-update mechanism for /vibe MCP server
+ * Checks for updates and prompts user to update
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function checkForUpdates() {
+  try {
+    // Read local version
+    const versionPath = path.join(__dirname, 'version.json');
+    const localVersion = JSON.parse(await fs.readFile(versionPath, 'utf-8'));
+
+    // Check remote version
+    const response = await fetch('https://www.slashvibe.dev/api/version', {
+      headers: { 'User-Agent': 'vibe-mcp-client' }
+    });
+
+    if (!response.ok) {
+      return null; // Silent fail - don't block startup
+    }
+
+    const remoteVersion = await response.json();
+
+    // Compare versions
+    if (compareVersions(remoteVersion.version, localVersion.version) > 0) {
+      return {
+        current: localVersion.version,
+        latest: remoteVersion.version,
+        changelog: remoteVersion.changelog,
+        features: remoteVersion.features,
+        breaking: remoteVersion.breaking
+      };
+    }
+
+    return null; // Up to date
+  } catch (error) {
+    // Silent fail - don't block startup
+    return null;
+  }
+}
+
+export async function performUpdate() {
+  try {
+    const repoPath = path.join(__dirname, '..');
+
+    // Check if we're in a git repo
+    try {
+      await execAsync('git rev-parse --git-dir', { cwd: repoPath });
+    } catch {
+      throw new Error('Not a git repository. Manual update required.');
+    }
+
+    // Stash any local changes
+    await execAsync('git stash', { cwd: repoPath });
+
+    // Pull latest
+    const { stdout, stderr } = await execAsync('git pull origin main', { cwd: repoPath });
+
+    // Pop stash if we had changes
+    try {
+      await execAsync('git stash pop', { cwd: repoPath });
+    } catch {
+      // No stash to pop, that's fine
+    }
+
+    return {
+      success: true,
+      output: stdout,
+      message: 'Update successful! Restart /vibe to apply changes.'
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+export function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if (parts1[i] > parts2[i]) return 1;
+    if (parts1[i] < parts2[i]) return -1;
+  }
+
+  return 0;
+}
+
+export function formatUpdateNotification(update) {
+  if (!update) return null;
+
+  let message = `\n${'='.repeat(60)}\n`;
+  message += `📦 /vibe UPDATE AVAILABLE\n`;
+  message += `${'='.repeat(60)}\n\n`;
+  message += `Current: v${update.current}\n`;
+  message += `Latest:  v${update.latest}${update.breaking ? ' ⚠️  BREAKING' : ''}\n\n`;
+  message += `${update.changelog}\n\n`;
+
+  if (update.features && update.features.length > 0) {
+    message += `New features:\n`;
+    update.features.forEach(f => {
+      message += `  • ${f}\n`;
+    });
+    message += `\n`;
+  }
+
+  message += `Update now:\n`;
+  message += `  vibe update\n`;
+  message += `\n`;
+  message += `Or manually:\n`;
+  message += `  cd ~/.vibe/vibe-repo && git pull origin main\n`;
+  message += `${'='.repeat(60)}\n`;
+
+  return message;
+}

package/bridges/bridge-monitor.js

@@ -0,0 +1,388 @@
+/**
+ * /vibe Bridge Health Monitor
+ *
+ * Continuously monitors bridge connections and provides health metrics.
+ * Tracks API quotas, error rates, response times, and connection status.
+ */
+
+const twitter = require('../twitter');
+const telegram = require('./telegram');
+const farcaster = require('./farcaster');
+const discord = require('../discord');
+const config = require('../config');
+
+/**
+ * Bridge health status tracker
+ */
+class BridgeMonitor {
+  constructor() {
+    this.metrics = {
+      x: { calls: 0, errors: 0, lastCheck: null, avgResponseTime: 0, status: 'unknown' },
+      telegram: { calls: 0, errors: 0, lastCheck: null, avgResponseTime: 0, status: 'unknown' },
+      farcaster: { calls: 0, errors: 0, lastCheck: null, avgResponseTime: 0, status: 'unknown' },
+      discord: { calls: 0, errors: 0, lastCheck: null, avgResponseTime: 0, status: 'unknown' }
+    };
+    this.healthCheckInterval = null;
+    this.alertThresholds = {
+      errorRate: 0.1, // 10% error rate triggers alert
+      responseTime: 5000, // 5 second response time threshold
+      consecutiveFailures: 3
+    };
+  }
+
+  /**
+   * Start continuous health monitoring
+   */
+  startMonitoring(intervalMinutes = 5) {
+    console.log(`🔍 Starting bridge health monitoring (every ${intervalMinutes} minutes)`);
+    
+    // Initial health check
+    this.performHealthCheck();
+    
+    // Schedule regular health checks
+    this.healthCheckInterval = setInterval(() => {
+      this.performHealthCheck();
+    }, intervalMinutes * 60 * 1000);
+  }
+
+  /**
+   * Stop health monitoring
+   */
+  stopMonitoring() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+      console.log('🛑 Stopped bridge health monitoring');
+    }
+  }
+
+  /**
+   * Perform comprehensive health check on all bridges
+   */
+  async performHealthCheck() {
+    console.log('🔍 Running bridge health check...');
+    const results = {};
+
+    // Test each configured bridge
+    const bridges = ['x', 'telegram', 'farcaster', 'discord'];
+    
+    for (const bridge of bridges) {
+      try {
+        const startTime = Date.now();
+        const isHealthy = await this.checkBridgeHealth(bridge);
+        const responseTime = Date.now() - startTime;
+        
+        this.updateMetrics(bridge, true, responseTime);
+        results[bridge] = { 
+          healthy: isHealthy, 
+          responseTime,
+          error: null
+        };
+        
+      } catch (error) {
+        this.updateMetrics(bridge, false, 0);
+        results[bridge] = { 
+          healthy: false, 
+          responseTime: 0,
+          error: error.message
+        };
+      }
+    }
+
+    // Check for alerts
+    this.checkForAlerts(results);
+    
+    console.log(`✅ Health check complete: ${Object.values(results).filter(r => r.healthy).length}/${bridges.length} bridges healthy`);
+    
+    return results;
+  }
+
+  /**
+   * Check health of specific bridge
+   */
+  async checkBridgeHealth(bridge) {
+    switch (bridge) {
+      case 'x':
+        if (!twitter.isConfigured()) return false;
+        const me = await twitter.getMe();
+        return !!(me && me.data && me.data.id);
+
+      case 'telegram':
+        if (!telegram.isConfigured()) return false;
+        const botInfo = await telegram.getBotInfo();
+        return !!(botInfo && botInfo.id);
+
+      case 'farcaster':
+        if (!farcaster.isConfigured()) return false;
+        const user = await farcaster.getUser();
+        return !!(user && user.users && user.users.length > 0);
+
+      case 'discord':
+        if (!discord.isConfigured()) return false;
+        // Discord webhooks can't be tested without sending, so assume healthy if configured
+        return true;
+
+      default:
+        throw new Error(`Unknown bridge: ${bridge}`);
+    }
+  }
+
+  /**
+   * Update bridge metrics
+   */
+  updateMetrics(bridge, success, responseTime) {
+    const metric = this.metrics[bridge];
+    
+    metric.calls++;
+    if (!success) metric.errors++;
+    metric.lastCheck = new Date().toISOString();
+    
+    // Update average response time (simple moving average)
+    if (responseTime > 0) {
+      metric.avgResponseTime = metric.avgResponseTime === 0 
+        ? responseTime 
+        : (metric.avgResponseTime + responseTime) / 2;
+    }
+    
+    // Update status
+    const errorRate = metric.errors / metric.calls;
+    const isHealthy = success && errorRate < this.alertThresholds.errorRate;
+    metric.status = isHealthy ? 'healthy' : 'degraded';
+  }
+
+  /**
+   * Check metrics against alert thresholds
+   */
+  checkForAlerts(results) {
+    const alerts = [];
+    
+    for (const [bridge, result] of Object.entries(results)) {
+      const metric = this.metrics[bridge];
+      
+      // High error rate alert
+      if (metric.calls > 10) { // Only alert after some calls
+        const errorRate = metric.errors / metric.calls;
+        if (errorRate > this.alertThresholds.errorRate) {
+          alerts.push({
+            bridge,
+            type: 'high_error_rate',
+            message: `High error rate: ${(errorRate * 100).toFixed(1)}%`,
+            severity: 'warning'
+          });
+        }
+      }
+      
+      // Slow response time alert
+      if (result.responseTime > this.alertThresholds.responseTime) {
+        alerts.push({
+          bridge,
+          type: 'slow_response',
+          message: `Slow response: ${result.responseTime}ms`,
+          severity: 'warning'
+        });
+      }
+      
+      // Bridge down alert
+      if (!result.healthy) {
+        alerts.push({
+          bridge,
+          type: 'bridge_down',
+          message: `Bridge unhealthy: ${result.error || 'Unknown error'}`,
+          severity: 'critical'
+        });
+      }
+    }
+    
+    // Process alerts
+    if (alerts.length > 0) {
+      this.handleAlerts(alerts);
+    }
+  }
+
+  /**
+   * Handle bridge alerts (log, notify, etc.)
+   */
+  async handleAlerts(alerts) {
+    for (const alert of alerts) {
+      const icon = alert.severity === 'critical' ? '🚨' : '⚠️';
+      console.log(`${icon} Bridge Alert [${alert.bridge.toUpperCase()}]: ${alert.message}`);
+    }
+    
+    // In a full implementation, this would:
+    // 1. Send notifications to /vibe users
+    // 2. Log to monitoring system
+    // 3. Trigger automatic recovery attempts
+    // 4. Update status dashboard
+  }
+
+  /**
+   * Get current health status for all bridges
+   */
+  getHealthStatus() {
+    const status = {};
+    
+    for (const [bridge, metric] of Object.entries(this.metrics)) {
+      const errorRate = metric.calls > 0 ? metric.errors / metric.calls : 0;
+      
+      status[bridge] = {
+        configured: this.isBridgeConfigured(bridge),
+        status: metric.status,
+        calls: metric.calls,
+        errors: metric.errors,
+        errorRate: (errorRate * 100).toFixed(1) + '%',
+        avgResponseTime: Math.round(metric.avgResponseTime) + 'ms',
+        lastCheck: metric.lastCheck,
+        uptime: this.calculateUptime(bridge)
+      };
+    }
+    
+    return status;
+  }
+
+  /**
+   * Check if bridge is configured
+   */
+  isBridgeConfigured(bridge) {
+    switch (bridge) {
+      case 'x': return twitter.isConfigured();
+      case 'telegram': return telegram.isConfigured();
+      case 'farcaster': return farcaster.isConfigured();
+      case 'discord': return discord.isConfigured();
+      default: return false;
+    }
+  }
+
+  /**
+   * Calculate bridge uptime percentage
+   */
+  calculateUptime(bridge) {
+    const metric = this.metrics[bridge];
+    if (metric.calls === 0) return '0%';
+    
+    const successRate = (metric.calls - metric.errors) / metric.calls;
+    return (successRate * 100).toFixed(1) + '%';
+  }
+
+  /**
+   * Get API quota information (where available)
+   */
+  async getQuotaInfo() {
+    const quotas = {};
+    
+    // X API has rate limits we can track
+    if (twitter.isConfigured()) {
+      try {
+        // This would require implementing rate limit header tracking
+        quotas.x = {
+          remaining: 'Unknown',
+          reset: 'Unknown',
+          note: 'Rate limit tracking not implemented'
+        };
+      } catch (e) {
+        quotas.x = { error: e.message };
+      }
+    }
+    
+    // Telegram has generous limits
+    if (telegram.isConfigured()) {
+      quotas.telegram = {
+        remaining: '30 messages/second',
+        note: 'Telegram bot API limits'
+      };
+    }
+    
+    // Farcaster via Neynar has API limits
+    if (farcaster.isConfigured()) {
+      quotas.farcaster = {
+        remaining: 'Depends on Neynar plan',
+        note: 'Check Neynar dashboard for quotas'
+      };
+    }
+    
+    return quotas;
+  }
+
+  /**
+   * Test bridge recovery after outage
+   */
+  async testRecovery(bridge) {
+    console.log(`🔄 Testing recovery for ${bridge} bridge...`);
+    
+    try {
+      const isHealthy = await this.checkBridgeHealth(bridge);
+      if (isHealthy) {
+        this.metrics[bridge].status = 'healthy';
+        console.log(`✅ ${bridge} bridge recovered`);
+        return true;
+      } else {
+        console.log(`❌ ${bridge} bridge still unhealthy`);
+        return false;
+      }
+    } catch (error) {
+      console.log(`💥 ${bridge} bridge recovery test failed: ${error.message}`);
+      return false;
+    }
+  }
+}
+
+// Global monitor instance
+let globalMonitor = null;
+
+/**
+ * Get or create global monitor instance
+ */
+function getMonitor() {
+  if (!globalMonitor) {
+    globalMonitor = new BridgeMonitor();
+  }
+  return globalMonitor;
+}
+
+/**
+ * Start monitoring all bridges
+ */
+function startMonitoring(intervalMinutes = 5) {
+  const monitor = getMonitor();
+  monitor.startMonitoring(intervalMinutes);
+  return monitor;
+}
+
+/**
+ * Stop monitoring
+ */
+function stopMonitoring() {
+  if (globalMonitor) {
+    globalMonitor.stopMonitoring();
+  }
+}
+
+/**
+ * Get current health dashboard
+ */
+async function getHealthDashboard() {
+  const monitor = getMonitor();
+  
+  const healthStatus = monitor.getHealthStatus();
+  const quotaInfo = await monitor.getQuotaInfo();
+  const recentCheck = await monitor.performHealthCheck();
+  
+  return {
+    timestamp: new Date().toISOString(),
+    bridges: healthStatus,
+    quotas: quotaInfo,
+    recentCheck,
+    summary: {
+      totalBridges: Object.keys(healthStatus).length,
+      healthyBridges: Object.values(healthStatus).filter(b => b.status === 'healthy').length,
+      configuredBridges: Object.values(healthStatus).filter(b => b.configured).length
+    }
+  };
+}
+
+module.exports = {
+  BridgeMonitor,
+  getMonitor,
+  startMonitoring,
+  stopMonitoring,
+  getHealthDashboard
+};