slashvibe-mcp 0.3.21 → 0.3.22

package/auth-store.js

@@ -1,148 +0,0 @@
-/**
- * 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.authToken || 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

@@ -1,130 +0,0 @@
-/**
- * Auto-update mechanism for /vibe MCP server
- * Checks for updates and prompts user to update
- */
-
-const { exec } = require('child_process');
-const { promisify } = require('util');
-const fs = require('fs').promises;
-const path = require('path');
-
-const execAsync = promisify(exec);
-
-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;
-  }
-}
-
-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
-    };
-  }
-}
-
-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;
-}
-
-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;
-}
-
-module.exports = {
-  checkForUpdates,
-  performUpdate,
-  compareVersions,
-  formatUpdateNotification
-};

package/bridges/bridge-monitor.js

@@ -1,388 +0,0 @@
-/**
- * /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
-};