slashvibe-mcp 0.2.9 → 0.3.13

package/tools/webhook-test.js

@@ -0,0 +1,388 @@
+/**
+ * vibe webhook-test — Test webhook endpoints
+ *
+ * Send test events to webhook endpoints to verify they're working.
+ * Useful for debugging X, Telegram, Discord webhook integrations.
+ */
+
+const { requireInit, header, divider, success, warning, error } = require('./_shared');
+
+const definition = {
+  name: 'vibe_webhook_test',
+  description: 'Test webhook endpoints and view webhook activity',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      endpoint: {
+        type: 'string',
+        enum: ['x', 'telegram', 'discord', 'all'],
+        description: 'Which webhook to test (default: all)'
+      },
+      action: {
+        type: 'string',
+        enum: ['test', 'status', 'stats', 'events'],
+        description: 'Test webhook, check status, view stats, or list recent events'
+      },
+      mock_event: {
+        type: 'string',
+        enum: ['mention', 'dm', 'like', 'follow'],
+        description: 'Type of mock event to send (for testing)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of recent events to show (default: 10)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const {
+    endpoint = 'all',
+    action = 'status',
+    mock_event = 'mention',
+    limit = 10
+  } = args;
+
+  try {
+    switch (action) {
+      case 'test':
+        return await testWebhook(endpoint, mock_event);
+      case 'status':
+        return await checkWebhookStatus(endpoint);
+      case 'stats':
+        return await getWebhookStats(endpoint);
+      case 'events':
+        return await getRecentEvents(endpoint, limit);
+      default:
+        return { display: error('Invalid action') };
+    }
+  } catch (e) {
+    return {
+      display: `${header('Webhook Test')}\n\n${error('Test failed: ' + e.message)}`
+    };
+  }
+}
+
+async function testWebhook(endpoint, mockEvent) {
+  let display = header('Webhook Test');
+  display += '\n\n';
+
+  if (endpoint === 'x' || endpoint === 'all') {
+    display += await testXWebhook(mockEvent);
+    display += '\n';
+  }
+
+  if (endpoint === 'telegram' || endpoint === 'all') {
+    display += '**Telegram Webhook:** Not yet implemented\n\n';
+  }
+
+  if (endpoint === 'discord' || endpoint === 'all') {
+    display += '**Discord Webhook:** Not yet implemented\n\n';
+  }
+
+  display += divider();
+  display += '**Next steps:**\n';
+  display += '• Check webhook events: `vibe webhook-test --action events`\n';
+  display += '• View social inbox: `vibe social-inbox --include_webhooks`\n';
+  display += '• Monitor bridge health: `vibe bridge-health`';
+
+  return { display };
+}
+
+async function testXWebhook(mockEvent) {
+  let result = '**X (Twitter) Webhook Test**\n';
+
+  // Check if endpoint exists
+  const webhookUrl = '/api/webhooks/x';
+  result += `Endpoint: ${webhookUrl}\n`;
+
+  // Check configuration
+  const secret = process.env.X_WEBHOOK_SECRET;
+  const configured = !!secret;
+  result += `Secret configured: ${configured ? '✅' : '❌'}\n`;
+
+  if (!configured) {
+    result += warning('Set X_WEBHOOK_SECRET environment variable\n');
+    return result;
+  }
+
+  // Create mock event
+  const mockEvents = {
+    mention: {
+      tweet_create_events: [{
+        id_str: 'test_' + Date.now(),
+        text: '@yourusername This is a test mention from webhook-test',
+        created_at: new Date().toISOString(),
+        user: {
+          id_str: 'test_user_123',
+          screen_name: 'testuser',
+          name: 'Test User',
+          profile_image_url_https: 'https://example.com/avatar.jpg'
+        },
+        entities: {
+          user_mentions: [{
+            id_str: 'your_user_id',
+            screen_name: 'yourusername'
+          }]
+        }
+      }]
+    },
+    dm: {
+      direct_message_events: [{
+        id: 'test_dm_' + Date.now(),
+        created_timestamp: Date.now().toString(),
+        message_create: {
+          sender_id: 'test_user_123',
+          target: { recipient_id: 'your_user_id' },
+          message_data: { text: 'Test DM from webhook-test tool' }
+        }
+      }]
+    },
+    like: {
+      favorite_events: [{
+        id_str: 'test_like_' + Date.now(),
+        created_at: new Date().toISOString(),
+        user: {
+          id_str: 'test_user_123',
+          screen_name: 'testuser',
+          name: 'Test User',
+          profile_image_url_https: 'https://example.com/avatar.jpg'
+        },
+        favorited_status: {
+          id_str: 'your_tweet_123',
+          text: 'Your tweet that got liked',
+          user: { id_str: 'your_user_id' }
+        }
+      }]
+    },
+    follow: {
+      follow_events: [{
+        source: {
+          id_str: 'test_user_123',
+          screen_name: 'testuser',
+          name: 'Test User',
+          profile_image_url_https: 'https://example.com/avatar.jpg',
+          description: 'A test user following you'
+        },
+        target: { id_str: 'your_user_id' },
+        created_at: new Date().toISOString()
+      }]
+    }
+  };
+
+  const testPayload = mockEvents[mockEvent] || mockEvents.mention;
+  result += `Mock event: ${mockEvent}\n`;
+
+  // Generate test signature
+  const crypto = require('crypto');
+  const body = JSON.stringify(testPayload);
+  const signature = crypto
+    .createHmac('sha256', secret)
+    .update(body)
+    .digest('base64');
+
+  result += `Event size: ${body.length} bytes\n`;
+  result += success('Mock event ready for webhook\n');
+
+  // Note: We don't actually send the request to avoid spamming
+  // In a real implementation, this could make an HTTP request to localhost
+  result += warning('Note: This creates a mock event structure.\n');
+  result += 'To test fully, send POST to /api/webhooks/x with:\n';
+  result += `• Header: x-twitter-webhooks-signature: sha256=${signature}\n`;
+  result += `• Body: ${body.slice(0, 100)}...\n`;
+
+  return result;
+}
+
+async function checkWebhookStatus(endpoint) {
+  let display = header('Webhook Status');
+  display += '\n\n';
+
+  // X webhook status
+  if (endpoint === 'x' || endpoint === 'all') {
+    const xSecret = process.env.X_WEBHOOK_SECRET;
+    const xBearer = process.env.X_BEARER_TOKEN;
+    
+    display += '**X (Twitter) Webhook**\n';
+    display += `Endpoint: /api/webhooks/x\n`;
+    display += `Secret: ${xSecret ? '✅ Configured' : '❌ Missing'}\n`;
+    display += `Bearer Token: ${xBearer ? '✅ Configured' : '❌ Missing'}\n`;
+    
+    if (xSecret && xBearer) {
+      display += success('Ready for CRC challenge and events\n');
+    } else {
+      display += warning('Set X_WEBHOOK_SECRET and X_BEARER_TOKEN\n');
+    }
+    display += '\n';
+  }
+
+  // General webhook system
+  const kvConfigured = !!(process.env.KV_REST_API_URL && process.env.KV_REST_API_TOKEN);
+  display += '**Storage System**\n';
+  display += `KV Store: ${kvConfigured ? '✅ Available' : '❌ Not configured'}\n`;
+  display += `Social Inbox: ${kvConfigured ? '✅ Active' : '❌ Disabled'}\n`;
+  
+  if (!kvConfigured) {
+    display += warning('Set KV_REST_API_URL and KV_REST_API_TOKEN for event storage\n');
+  }
+  display += '\n';
+
+  display += divider();
+  display += '**Webhook URLs (for X Developer Portal):**\n';
+  display += '• Development: `https://yourapp.vercel.app/api/webhooks/x`\n';
+  display += '• Production: `https://vibe.fyi/api/webhooks/x`\n\n';
+  display += '**Required X Webhook Events:**\n';
+  display += '• Tweet create events (mentions)\n';
+  display += '• Direct message events\n';
+  display += '• Favorite events (optional)\n';
+  display += '• Follow events (optional)';
+
+  return { display };
+}
+
+async function getWebhookStats(endpoint) {
+  let display = header('Webhook Statistics');
+  display += '\n\n';
+
+  try {
+    const KV_CONFIGURED = !!(process.env.KV_REST_API_URL && process.env.KV_REST_API_TOKEN);
+    if (!KV_CONFIGURED) {
+      display += warning('KV storage not configured - no stats available\n');
+      return { display };
+    }
+
+    const { kv } = await import('@vercel/kv');
+
+    // X webhook stats
+    if (endpoint === 'x' || endpoint === 'all') {
+      const xStats = await kv.hgetall('vibe:x_webhook_stats') || {};
+      
+      display += '**X Webhook Stats**\n';
+      display += `Total deliveries: ${xStats.total_deliveries || 0}\n`;
+      display += `Events processed: ${xStats.events_processed || 0}\n`;
+      display += `Last delivery: ${xStats.last_delivery ? new Date(xStats.last_delivery).toLocaleString() : 'Never'}\n`;
+      
+      // Daily stats (last 7 days)
+      const today = new Date();
+      const dailyStats = [];
+      for (let i = 6; i >= 0; i--) {
+        const date = new Date(today);
+        date.setDate(date.getDate() - i);
+        const dateKey = date.toISOString().split('T')[0];
+        const count = parseInt(xStats[`deliveries_${dateKey}`]) || 0;
+        if (count > 0) {
+          dailyStats.push(`${dateKey}: ${count}`);
+        }
+      }
+      
+      if (dailyStats.length > 0) {
+        display += `Daily activity (last 7d): ${dailyStats.join(', ')}\n`;
+      }
+      
+      display += '\n';
+    }
+
+    display += divider();
+    display += '**Health Check:**\n';
+    display += '• Test webhook: `vibe webhook-test --action test --endpoint x`\n';
+    display += '• View recent events: `vibe webhook-test --action events --limit 5`\n';
+    display += '• Check social inbox: `vibe social-inbox --channel webhooks`';
+
+  } catch (e) {
+    display += error(`Stats unavailable: ${e.message}\n`);
+  }
+
+  return { display };
+}
+
+async function getRecentEvents(endpoint, limit) {
+  let display = header(`Recent Webhook Events (${limit})`);
+  display += '\n\n';
+
+  try {
+    const KV_CONFIGURED = !!(process.env.KV_REST_API_URL && process.env.KV_REST_API_TOKEN);
+    if (!KV_CONFIGURED) {
+      display += warning('KV storage not configured - no events available\n');
+      return { display };
+    }
+
+    const { kv } = await import('@vercel/kv');
+    const inboxKey = 'vibe:social_inbox';
+    
+    const rawEvents = await kv.lrange(inboxKey, 0, limit - 1);
+    
+    if (rawEvents.length === 0) {
+      display += '_No recent webhook events._\n\n';
+      display += 'Events will appear here when webhooks are triggered.\n';
+      display += 'Test with: `vibe webhook-test --action test --endpoint x`';
+      return { display };
+    }
+
+    display += `Found ${rawEvents.length} recent events:\n`;
+    display += divider();
+    display += '\n';
+
+    for (const eventStr of rawEvents) {
+      try {
+        const event = JSON.parse(eventStr);
+        const timeAgo = formatTimeAgo(new Date(event.timestamp));
+        
+        display += `**${event.platform.toUpperCase()}** ${getTypeIcon(event.type)} — _${timeAgo}_\n`;
+        display += `From: @${event.from.handle} (${event.from.name})\n`;
+        display += `${event.content.slice(0, 100)}${event.content.length > 100 ? '...' : ''}\n`;
+        
+        if (event.metadata?.url) {
+          display += `Link: ${event.metadata.url}\n`;
+        }
+        
+        display += `Status: ${event.processed ? '✅ Processed' : '⏳ Pending'}\n`;
+        display += `_[${event.id}]_\n\n`;
+        
+      } catch (e) {
+        display += `_Invalid event data_\n\n`;
+      }
+    }
+
+    display += divider();
+    display += '**Actions:**\n';
+    display += '• View in social inbox: `vibe social-inbox --include_webhooks`\n';
+    display += '• Reply to event: `vibe social-post --content "reply"`\n';
+    display += '• Clear events: `vibe webhook-test --action clear` (not implemented)';
+
+  } catch (e) {
+    display += error(`Failed to fetch events: ${e.message}\n`);
+  }
+
+  return { display };
+}
+
+function formatTimeAgo(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const minutes = Math.floor(diff / (1000 * 60));
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return 'just now';
+}
+
+function getTypeIcon(type) {
+  const icons = {
+    mention: '@',
+    reply: '↩️',
+    dm: '✉️',
+    like: '❤️',
+    repost: '🔁',
+    follow: '👤'
+  };
+  return icons[type] || '📡';
+}
+
+module.exports = { definition, handler };

package/tools/who.js

@@ -24,7 +24,7 @@ const definition = {
   }
 };
 
-// Activity heat based on session signals
+// Activity heat based on session signals + GitHub activity
 function getHeat(user) {
   const lastSeenMs = user.lastSeen;
   const now = Date.now();
@@ -38,6 +38,16 @@ function getHeat(user) {
     }
   }
 
+  // GitHub activity signals — real commits are high-confidence
+  if (user.github?.shipping_mode === 'hot') {
+    const commits = user.github.total_commits || 0;
+    const label = commits > 0 ? `shipping code (${commits} commits)` : 'shipping code';
+    return { icon: '🔥', label, inferred: false, source: 'github' };
+  }
+  if (user.github?.shipping_mode === 'active') {
+    return { icon: '⚡', label: 'pushing commits', inferred: false, source: 'github' };
+  }
+
   // Check for inferred state from smart detection
   if (user.mood_inferred && user.mood) {
     const inferredLabel = user.inferred_state
@@ -73,6 +83,11 @@ function getHeat(user) {
     return { icon: '🔥', label: 'shipping', inferred: false };
   }
 
+  // GitHub building mode (lower activity but still coding)
+  if (user.github?.shipping_mode === 'building') {
+    return { icon: '🔨', label: 'building', inferred: false, source: 'github' };
+  }
+
   // Default based on recency
   if (minutesAgo < 2) {
     return { icon: '⚡', label: 'active', inferred: false };
@@ -116,6 +131,13 @@ function formatActivity(user) {
     return parts.join(' ');
   }
 
+  // GitHub active repos (if no other context and GitHub connected)
+  if (user.github?.active_repos?.length > 0) {
+    const repos = user.github.active_repos.slice(0, 2);
+    const repoNames = repos.map(r => r.split('/').pop());  // Get just repo name
+    return `pushing to ${repoNames.join(', ')}`;
+  }
+
   // Fall back to one_liner
   return user.one_liner || 'Building something';
 }
@@ -128,6 +150,19 @@ async function handler(args) {
   // Apply smart detection — infer states from context signals
   const users = enhanceUsersWithInference(rawUsers);
   const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+
+  // Fetch active help requests (non-blocking)
+  let helpRequests = [];
+  try {
+    const helpResponse = await fetch(`${apiUrl}/api/help?limit=5`);
+    const helpData = await helpResponse.json();
+    if (helpData.success && helpData.requests) {
+      helpRequests = helpData.requests;
+    }
+  } catch (e) {
+    // Silent fail - help requests are nice-to-have
+  }
 
   // Check for notifications (presence + messages)
   notify.checkAll(store);
@@ -139,7 +174,7 @@ async function handler(args) {
 _You're the only one here right now..._
 
 🎮 **Challenge someone later**: "play tictactoe with @friend"
-💬 **Ping @seth**: He's probably around somewhere
+💬 **Message @vibe**: Say hello to the platform!
 🔗 **Invite a friend**: Share \`slashvibe.dev\`
 
 _Check back in a bit — builders come and go._`
@@ -155,6 +190,17 @@ _Check back in a bit — builders come and go._`
 
   let display = `## Who's Around\n\n`;
 
+  // Help requests section (if any)
+  if (helpRequests.length > 0) {
+    display += `**🆘 Needs Help:**\n`;
+    for (const req of helpRequests.slice(0, 3)) {
+      const urgencyIcon = req.urgency === 'high' ? '🔴' : req.urgency === 'low' ? '🟢' : '🟡';
+      const shortProblem = req.problem.length > 50 ? req.problem.slice(0, 47) + '...' : req.problem;
+      display += `${urgencyIcon} **@${req.handle}**: ${shortProblem}\n`;
+    }
+    display += `→ \`vibe stuck\` to help or ask\n\n---\n\n`;
+  }
+
   // Activity section for active users
   if (active.length > 0) {
     active.forEach(u => {
@@ -168,7 +214,12 @@ _Check back in a bit — builders come and go._`
       const activity = formatActivity(u);
       const timeAgo = formatTimeAgo(u.lastSeen);
 
-      display += `${heat.icon} **@${u.handle}**${agentBadge}${tag}${heatLabel}\n`;
+      // Show availability topics if set
+      const availableFor = u.availableFor && Array.isArray(u.availableFor) && u.availableFor.length > 0
+        ? ` — 🤝 _available for: ${u.availableFor.join(', ')}_`
+        : '';
+
+      display += `${heat.icon} **@${u.handle}**${agentBadge}${tag}${heatLabel}${availableFor}\n`;
       if (operatorTag) {
         display += `   ${operatorTag}\n`;
       }

package/tools/withdraw.js

@@ -0,0 +1,145 @@
+/**
+ * vibe_withdraw - Withdraw earnings from FeeRouter
+ *
+ * Generates transaction data to withdraw accumulated on-chain earnings.
+ * User must sign and submit the transaction with their wallet.
+ *
+ * Examples:
+ * - "vibe withdraw"
+ * - "withdraw my earnings"
+ * - "claim my on-chain balance"
+ */
+
+const fetch = require('node-fetch');
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_withdraw',
+  description: 'Withdraw accumulated earnings from the FeeRouter. Generates transaction data for you to sign.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      to_address: {
+        type: 'string',
+        description: 'Optional destination address (defaults to your registered payout wallet)'
+      },
+      check_only: {
+        type: 'boolean',
+        description: 'Only check balance without generating withdrawal transaction'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { to_address, check_only = false } = args;
+
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  const handle = config.getHandle();
+  const token = config.getToken();
+  const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+  try {
+    // Check-only mode
+    if (check_only) {
+      const response = await fetch(
+        `${apiUrl}/api/earnings/withdraw?handle=${encodeURIComponent(handle)}`,
+        {
+          headers: token ? {
+            'Authorization': `Bearer ${token}`
+          } : {}
+        }
+      );
+
+      const result = await response.json();
+
+      if (!response.ok) {
+        return {
+          display: `❌ ${result.error || 'Failed to check balance'}`
+        };
+      }
+
+      const statusEmoji = result.can_withdraw ? '🟢' : '🟡';
+      const action = result.can_withdraw
+        ? 'Run "vibe withdraw" to generate withdrawal transaction.'
+        : result.registered
+          ? 'No balance to withdraw yet.'
+          : 'Register on-chain first: vibe register_onchain';
+
+      return {
+        display: `
+💰 Withdrawal Status: @${handle}
+
+Balance: ${result.balance_eth} ETH
+Registered: ${result.registered ? 'Yes' : 'No'}
+Can Withdraw: ${statusEmoji} ${result.can_withdraw ? 'Yes' : 'No'}
+
+${action}
+        `.trim(),
+        data: result
+      };
+    }
+
+    // Generate withdrawal transaction
+    const response = await fetch(
+      `${apiUrl}/api/earnings/withdraw`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          to_address: to_address || undefined
+        })
+      }
+    );
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      let display = `❌ ${result.error || 'Failed to generate withdrawal'}`;
+      if (result.action) {
+        display += `\n\nNext step: ${result.action}`;
+      }
+      return { display };
+    }
+
+    const destDisplay = result.destination
+      ? `${result.destination.slice(0, 10)}...${result.destination.slice(-8)}`
+      : 'your wallet';
+
+    return {
+      display: `
+💸 Withdrawal Ready: @${handle}
+
+Amount: ${result.balance_display}
+Destination: ${destDisplay}
+Network: ${result.network}
+
+Transaction to sign:
+  To: ${result.transaction.to}
+  Data: ${result.transaction.data?.slice(0, 40)}...
+  Gas: ${result.transaction.gas}
+
+Instructions:
+${result.instructions?.map((i, idx) => `  ${idx + 1}. ${i}`).join('\n')}
+
+Explorer: ${result.explorer}
+      `.trim(),
+      data: result
+    };
+
+  } catch (error) {
+    return {
+      display: `❌ Failed to process withdrawal: ${error.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };