slashvibe-mcp 0.3.20 → 0.3.21

package/tools/broadcast.js

@@ -0,0 +1,325 @@
+/**
+ * vibe broadcast — Live terminal broadcasting
+ *
+ * Share your terminal in real-time with the /vibe community.
+ * Start streaming, share the URL, let others watch you code.
+ *
+ * Commands:
+ * - broadcast start "Building X"  → Start streaming
+ * - broadcast stop                → End + show stats + git bundle
+ * - broadcast status              → Check if broadcasting
+ * - broadcast stream <data>       → Push terminal data (internal)
+ */
+
+const config = require('../config');
+const gitBundle = require('./lib/git-bundle');
+
+const definition = {
+  name: 'vibe_broadcast',
+  description: 'Start/stop live terminal broadcasting. Share your coding session in real-time.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['start', 'stop', 'status', 'stream'],
+        description: 'Action: start, stop, status, or stream'
+      },
+      title: {
+        type: 'string',
+        description: 'Broadcast title (for start action)'
+      },
+      data: {
+        type: 'string',
+        description: 'Terminal data to stream (for stream action)'
+      }
+    }
+  }
+};
+
+// Store active broadcast state in memory (per MCP process)
+let activeBroadcast = null;
+
+async function handler(args) {
+  const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const action = args.action || 'status';
+
+  if (!myHandle) {
+    return { display: '⚠️ Not initialized. Run `vibe init` first.' };
+  }
+
+  // START broadcasting
+  if (action === 'start') {
+    if (activeBroadcast) {
+      return {
+        display: `📺 Already broadcasting!\n\nRoom: ${activeBroadcast.roomId}\nShare: ${activeBroadcast.shareUrl}\n\nUse \`vibe broadcast stop\` to end.`
+      };
+    }
+
+    const title = args.title || `@${myHandle}'s live session`;
+
+    try {
+      const response = await fetch(`${apiUrl}/api/watch`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          handle: myHandle,
+          title
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ Failed to start broadcast: ${data.error}` };
+      }
+
+      // Capture git state at session start
+      const gitState = gitBundle.captureSessionStart();
+
+      // Store broadcast state
+      activeBroadcast = {
+        roomId: data.roomId,
+        shareUrl: data.shareUrl,
+        title,
+        startedAt: Date.now(),
+        // Git tracking for bundle generation on stop
+        gitInitialCommit: gitState.success ? gitState.commit : null,
+        gitBranch: gitState.success ? gitState.branch : null,
+      };
+
+      // Also store in config for persistence across tool calls
+      config.set('broadcast', activeBroadcast);
+
+      let display = `🔴 **LIVE**\n\n`;
+      display += `📺 ${title}\n\n`;
+      display += `**Share URL:**\n${data.shareUrl}\n\n`;
+      display += `Room ID: ${data.roomId}\n\n`;
+      display += `_Your terminal output is now streaming._\n`;
+      display += `_Use \`vibe broadcast stop\` when done._`;
+
+      return { display };
+
+    } catch (error) {
+      return { display: `## Broadcast Error\n\n${error.message}` };
+    }
+  }
+
+  // STOP broadcasting
+  if (action === 'stop') {
+    // Check stored state
+    const broadcast = activeBroadcast || config.get('broadcast');
+
+    if (!broadcast) {
+      return { display: '📺 Not currently broadcasting.' };
+    }
+
+    try {
+      // Prepare git bundle if we have a starting commit
+      let bundlePayload = null;
+      if (broadcast.gitInitialCommit) {
+        const bundleResult = gitBundle.createBundle(broadcast.gitInitialCommit);
+        if (bundleResult.success) {
+          bundlePayload = {
+            base64: bundleResult.buffer.toString('base64'),
+            metadata: bundleResult.metadata,
+          };
+        } else {
+          // Log but don't fail - bundle is optional
+          console.log(`[broadcast] Git bundle skipped: ${bundleResult.error}`);
+        }
+      }
+
+      const response = await fetch(`${apiUrl}/api/watch`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          action: 'stop',
+          roomId: broadcast.roomId,
+          // Include git bundle if available
+          gitBundle: bundlePayload,
+        })
+      });
+
+      const data = await response.json();
+
+      // Clear broadcast state
+      const duration = broadcast.startedAt
+        ? Math.round((Date.now() - broadcast.startedAt) / 1000)
+        : 0;
+
+      activeBroadcast = null;
+      config.set('broadcast', null);
+
+      const formatDuration = (secs) => {
+        if (secs < 60) return `${secs}s`;
+        if (secs < 3600) return `${Math.floor(secs / 60)}m ${secs % 60}s`;
+        return `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
+      };
+
+      let display = `📺 Broadcast ended\n\n`;
+      display += `**Duration:** ${formatDuration(duration)}\n`;
+      display += `**Room:** ${broadcast.roomId}\n`;
+
+      // Show git bundle status
+      if (bundlePayload) {
+        const commits = bundlePayload.metadata.commitCount || 0;
+        const files = bundlePayload.metadata.changedFiles?.length || 0;
+        display += `**Git:** ${commits} commit${commits !== 1 ? 's' : ''}, ${files} file${files !== 1 ? 's' : ''} bundled 📦\n`;
+      } else if (broadcast.gitInitialCommit) {
+        display += `**Git:** No new commits to bundle\n`;
+      }
+      display += `\n`;
+
+      // Show auto-save info
+      if (data.autoSave?.saved) {
+        display += `✅ Session auto-saved: \`${data.autoSave.sessionId}\`\n`;
+        if (bundlePayload) {
+          display += `_Code bundle included - viewers can fork the full code!_\n`;
+        }
+      } else if (data.suggestions) {
+        display += `_💡 Want to save this session? Use \`vibe session save\`_`;
+      } else {
+        display += `_💡 Save this broadcast as a replayable session:_\n`;
+        display += `\`vibe session save --room ${broadcast.roomId}\``;
+      }
+
+      return { display };
+
+    } catch (error) {
+      // Clear state anyway
+      activeBroadcast = null;
+      config.set('broadcast', null);
+      return { display: `## Broadcast Error\n\n${error.message}` };
+    }
+  }
+
+  // STATUS check
+  if (action === 'status') {
+    const broadcast = activeBroadcast || config.get('broadcast');
+
+    if (!broadcast) {
+      return {
+        display: `📺 Not broadcasting.\n\n_Start with \`vibe broadcast start "What you're building"\`_`
+      };
+    }
+
+    try {
+      // Get metrics for comprehensive status
+      const [broadcastResponse, metricsResponse] = await Promise.all([
+        fetch(`${apiUrl}/api/watch?room=${broadcast.roomId}`),
+        fetch(`${apiUrl}/api/watch/metrics?room=${broadcast.roomId}`)
+      ]);
+
+      const broadcastData = await broadcastResponse.json();
+      const metricsData = await metricsResponse.json();
+
+      if (!broadcastData.success) {
+        // Broadcast expired on server
+        activeBroadcast = null;
+        config.set('broadcast', null);
+        return {
+          display: `📺 Broadcast expired.\n\n_Start a new one with \`vibe broadcast start\`_`
+        };
+      }
+
+      const duration = broadcast.startedAt
+        ? Math.round((Date.now() - broadcast.startedAt) / 1000)
+        : 0;
+      const formatDuration = (secs) => {
+        if (secs < 60) return `${secs}s`;
+        if (secs < 3600) return `${Math.floor(secs / 60)}m ${secs % 60}s`;
+        return `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
+      };
+
+      let display = `🔴 **LIVE** — ${formatDuration(duration)}\n\n`;
+      display += `📺 ${broadcast.title || 'Untitled'}\n\n`;
+
+      // Viewer stats
+      const viewers = metricsData.success ? metricsData.viewers : { current: broadcastData.broadcast?.viewerCount || 0, peak: 0 };
+      display += `**Viewers:** ${viewers.current}`;
+      if (viewers.peak > viewers.current) {
+        display += ` (peak: ${viewers.peak})`;
+      }
+      display += `\n`;
+
+      // Chat stats
+      if (metricsData.success && metricsData.chat) {
+        display += `**Chat:** ${metricsData.chat.total} messages`;
+        if (metricsData.chat.perMinute > 0) {
+          display += ` (${metricsData.chat.perMinute}/min)`;
+        }
+        display += `\n`;
+      }
+
+      // Reactions
+      if (metricsData.success && metricsData.reactions?.total > 0) {
+        const breakdown = metricsData.reactions.breakdown || {};
+        const reactionStr = Object.entries(breakdown)
+          .slice(0, 5)
+          .map(([type, count]) => `${type}×${count}`)
+          .join(' ');
+        display += `**Reactions:** ${reactionStr}\n`;
+      }
+
+      // Engagement score
+      if (metricsData.success && metricsData.engagement) {
+        display += `**Engagement:** ${metricsData.engagement.score}/100\n`;
+      }
+
+      display += `\n**Share:** ${broadcast.shareUrl}\n\n`;
+      display += `---\n`;
+      display += `_View chat: \`vibe chat\`_\n`;
+      display += `_Stop: \`vibe broadcast stop\`_`;
+
+      return { display };
+
+    } catch (error) {
+      return { display: `## Status Error\n\n${error.message}` };
+    }
+  }
+
+  // STREAM data (internal - called by terminal hooks)
+  if (action === 'stream') {
+    const broadcast = activeBroadcast || config.get('broadcast');
+
+    if (!broadcast) {
+      return { display: 'Not broadcasting' };
+    }
+
+    if (!args.data) {
+      return { display: 'No data to stream' };
+    }
+
+    try {
+      const response = await fetch(`${apiUrl}/api/watch`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          action: 'stream',
+          roomId: broadcast.roomId,
+          data: args.data
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `Stream error: ${data.error}` };
+      }
+
+      // Silent success - don't spam output
+      return {
+        display: `streamed (${data.bufferSize} chunks, ${data.viewerCount} viewers)`
+      };
+
+    } catch (error) {
+      return { display: `Stream error: ${error.message}` };
+    }
+  }
+
+  return { display: 'Unknown action. Use: start, stop, status' };
+}
+
+module.exports = { definition, handler };

package/tools/chat.js

@@ -0,0 +1,202 @@
+/**
+ * vibe chat — Live chat during broadcasts
+ *
+ * For broadcasters: See chat messages and reactions from viewers
+ * For viewers: Send messages to active broadcasts
+ *
+ * Commands:
+ * - chat                     → Show recent chat (if broadcasting or watching)
+ * - chat "message"           → Send message to current broadcast
+ * - chat --room room_xxx     → Show chat for specific room
+ * - chat "message" @handle   → Send to someone's broadcast
+ */
+
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_chat',
+  description: 'See and send chat messages during live broadcasts. Broadcasters see viewer engagement in real-time.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string',
+        description: 'Message to send (omit to just view chat)'
+      },
+      room: {
+        type: 'string',
+        description: 'Room ID to view/send to'
+      },
+      target: {
+        type: 'string',
+        description: 'Handle of broadcaster to message (@user)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of messages to show (default: 15)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const limit = args.limit || 15;
+
+  // Determine which room we're interacting with
+  let roomId = args.room;
+  const targetHandle = args.target?.replace('@', '').toLowerCase();
+
+  // If no room specified, check if we're broadcasting
+  if (!roomId) {
+    const activeBroadcast = config.get('broadcast');
+    if (activeBroadcast) {
+      roomId = activeBroadcast.roomId;
+    }
+  }
+
+  // If target handle specified, find their room
+  if (targetHandle && !roomId) {
+    try {
+      const liveResponse = await fetch(`${apiUrl}/api/live`, {
+        headers: { 'Accept': 'application/json' }
+      });
+      const liveData = await liveResponse.json();
+
+      if (liveData.success && liveData.broadcasts) {
+        const broadcast = liveData.broadcasts.find(
+          b => b.handle.toLowerCase() === targetHandle
+        );
+        if (broadcast) {
+          roomId = broadcast.roomId;
+        } else {
+          return {
+            display: `📺 @${targetHandle} is not live right now.\n\n_Check who's streaming with \`vibe watch\`_`
+          };
+        }
+      }
+    } catch (error) {
+      return { display: `## Error\n\n${error.message}` };
+    }
+  }
+
+  // If still no room, show error
+  if (!roomId) {
+    let display = `💬 **No Active Broadcast**\n\n`;
+    display += `To view/send chat, either:\n`;
+    display += `1. Start broadcasting: \`vibe broadcast start\`\n`;
+    display += `2. Specify a room: \`vibe chat --room room_xxx\`\n`;
+    display += `3. Specify a user: \`vibe chat @handle\``;
+    return { display };
+  }
+
+  // SEND message
+  if (args.message) {
+    if (!myHandle) {
+      return { display: '⚠️ Not initialized. Run `vibe init` first to send messages.' };
+    }
+
+    try {
+      const response = await fetch(`${apiUrl}/api/watch/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          roomId,
+          message: args.message,
+          handle: myHandle
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        if (data.error?.includes('not found')) {
+          return { display: `📺 Broadcast has ended.` };
+        }
+        return { display: `⚠️ Failed to send: ${data.error}` };
+      }
+
+      return {
+        display: `💬 Sent to chat: "${args.message}"`
+      };
+
+    } catch (error) {
+      return { display: `## Chat Error\n\n${error.message}` };
+    }
+  }
+
+  // VIEW chat and reactions
+  try {
+    // Fetch chat and reactions in parallel
+    const [chatResponse, reactResponse, broadcastResponse] = await Promise.all([
+      fetch(`${apiUrl}/api/watch/chat?room=${roomId}&limit=${limit}`),
+      fetch(`${apiUrl}/api/watch/react?room=${roomId}&limit=20`),
+      fetch(`${apiUrl}/api/watch?room=${roomId}`)
+    ]);
+
+    const chatData = await chatResponse.json();
+    const reactData = await reactResponse.json();
+    const broadcastData = await broadcastResponse.json();
+
+    if (!broadcastData.success) {
+      return { display: `📺 Broadcast not found or ended.` };
+    }
+
+    const broadcast = broadcastData.broadcast;
+    const messages = chatData.messages || [];
+    const reactions = reactData.reactions || [];
+
+    // Build display
+    let display = `💬 **Chat** — @${broadcast.handle}'s broadcast\n`;
+    display += `👥 ${broadcast.viewerCount || 0} watching`;
+    if (chatData.messagesPerMinute > 0) {
+      display += ` · ${chatData.messagesPerMinute} msg/min`;
+    }
+    display += `\n\n`;
+
+    // Recent reactions summary
+    if (reactions.length > 0) {
+      const reactionCounts = {};
+      for (const r of reactions.slice(0, 20)) {
+        reactionCounts[r.emoji] = (reactionCounts[r.emoji] || 0) + 1;
+      }
+      const reactionStr = Object.entries(reactionCounts)
+        .map(([emoji, count]) => `${emoji}×${count}`)
+        .join(' ');
+      display += `**Reactions:** ${reactionStr}\n\n`;
+    }
+
+    // Chat messages
+    if (messages.length === 0) {
+      display += `_No messages yet. Be the first to chat!_\n`;
+      display += `\`vibe chat "your message"\``;
+    } else {
+      display += `**Recent Messages:**\n`;
+      for (const msg of messages.slice(-limit)) {
+        const time = formatTime(msg.timestamp);
+        const badge = msg.isBroadcaster ? ' 🎙️' : '';
+        display += `[${time}] **@${msg.handle}**${badge}: ${msg.message}\n`;
+      }
+    }
+
+    display += `\n---\n`;
+    display += `_Reply: \`vibe chat "your message"\`_`;
+
+    return { display };
+
+  } catch (error) {
+    return { display: `## Chat Error\n\n${error.message}` };
+  }
+}
+
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true
+  });
+}
+
+module.exports = { definition, handler };

package/tools/collaborative-drawing.js

@@ -138,7 +138,7 @@ async function handler(args) {
   try {
     // Get or create room
     let gameState = await getOrCreateRoom(roomName);
-    let wasNewRoom = gameState.players.length === 0;
+    const wasNewRoom = gameState.players.length === 0;
     
     // Add player to room if not already there
     if (!gameState.players.includes(myHandle)) {

package/tools/connection-status.js

@@ -0,0 +1,178 @@
+/**
+ * vibe_connection_status - Check connection health
+ *
+ * Shows if you're connected to the /vibe network and API health.
+ * Helps debug connection issues.
+ */
+
+const config = require('../config');
+
+const connectionStatusSchema = {
+  name: 'vibe_connection_status',
+  description: 'Check your connection status to /vibe. Shows API health, latency, and session info.',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+  },
+};
+
+async function connectionStatusHandler() {
+  const handle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const token = config.getToken();
+
+  const results = {
+    initialized: !!handle,
+    handle: handle || null,
+    apiUrl,
+    hasToken: !!token,
+    checks: {},
+  };
+
+  // Check API health
+  const healthStart = Date.now();
+  try {
+    const response = await fetch(`${apiUrl}/api/health`, {
+      signal: AbortSignal.timeout(5000),
+    });
+    const health = await response.json();
+    results.checks.api = {
+      status: health.status === 'healthy' ? '✅ healthy' : '⚠️ degraded',
+      latency: Date.now() - healthStart,
+      version: health.version,
+    };
+  } catch (e) {
+    results.checks.api = {
+      status: '❌ unreachable',
+      latency: Date.now() - healthStart,
+      error: e.message,
+    };
+  }
+
+  // Check auth (if we have a token)
+  if (token && handle) {
+    const authStart = Date.now();
+    try {
+      const response = await fetch(`${apiUrl}/api/v2/presence?user=${handle}`, {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+        },
+        signal: AbortSignal.timeout(5000),
+      });
+
+      if (response.status === 401) {
+        results.checks.auth = {
+          status: '❌ token expired',
+          latency: Date.now() - authStart,
+          action: 'Run `vibe init` to re-authenticate',
+        };
+      } else if (response.ok) {
+        results.checks.auth = {
+          status: '✅ authenticated',
+          latency: Date.now() - authStart,
+        };
+      } else {
+        results.checks.auth = {
+          status: '⚠️ error',
+          latency: Date.now() - authStart,
+          httpStatus: response.status,
+        };
+      }
+    } catch (e) {
+      results.checks.auth = {
+        status: '❌ failed',
+        latency: Date.now() - authStart,
+        error: e.message,
+      };
+    }
+  }
+
+  // Check presence write (can we heartbeat?)
+  if (token && handle) {
+    const presenceStart = Date.now();
+    try {
+      const response = await fetch(`${apiUrl}/api/presence`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+          username: handle,
+          workingOn: 'Checking connection status',
+        }),
+        signal: AbortSignal.timeout(5000),
+      });
+
+      if (response.ok) {
+        results.checks.presence = {
+          status: '✅ online',
+          latency: Date.now() - presenceStart,
+        };
+      } else {
+        results.checks.presence = {
+          status: '⚠️ error',
+          latency: Date.now() - presenceStart,
+          httpStatus: response.status,
+        };
+      }
+    } catch (e) {
+      results.checks.presence = {
+        status: '❌ offline',
+        latency: Date.now() - presenceStart,
+        error: e.message,
+      };
+    }
+  }
+
+  // Format output
+  let output = '## /vibe Connection Status\n\n';
+
+  if (!results.initialized) {
+    output += '❌ **Not initialized**\n';
+    output += 'Run `vibe init` to get started.\n';
+    return { content: [{ type: 'text', text: output }] };
+  }
+
+  output += `**Handle:** @${results.handle}\n`;
+  output += `**API:** ${results.apiUrl}\n\n`;
+
+  output += '### Health Checks\n\n';
+
+  for (const [name, check] of Object.entries(results.checks)) {
+    output += `**${name}:** ${check.status}`;
+    if (check.latency) {
+      output += ` (${check.latency}ms)`;
+    }
+    output += '\n';
+
+    if (check.error) {
+      output += `  _Error: ${check.error}_\n`;
+    }
+    if (check.action) {
+      output += `  → ${check.action}\n`;
+    }
+  }
+
+  // Overall status
+  const allHealthy = Object.values(results.checks).every(c =>
+    c.status.includes('✅')
+  );
+
+  output += '\n';
+  if (allHealthy) {
+    output += '🟢 **All systems operational**\n';
+  } else {
+    output += '🟡 **Some issues detected** — check details above\n';
+  }
+
+  return {
+    content: [{ type: 'text', text: output }],
+    connectionStatus: results,
+  };
+}
+
+module.exports = {
+  schema: connectionStatusSchema,
+  handler: connectionStatusHandler,
+};