slashvibe-mcp 0.2.9 → 0.3.13

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

@@ -0,0 +1,286 @@
+/**
+ * Collaborative Drawing — Create or join a shared drawing session
+ * 
+ * Multiple users can draw together on a shared canvas in real-time.
+ * Perfect for sketching, doodling, or playing Pictionary together!
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+const drawing = require('../games/drawing');
+
+const definition = {
+  name: 'vibe_collaborative_drawing',
+  description: 'Create or join a collaborative drawing session with multiple users. Draw together on a shared canvas!',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      room: {
+        type: 'string',
+        description: 'Drawing room name (creates if doesn\'t exist, e.g., "art-party", "sketch-together")'
+      },
+      action: {
+        type: 'string',
+        description: 'Action to take',
+        enum: ['view', 'draw', 'line', 'clear', 'theme']
+      },
+      x: {
+        type: 'number',
+        description: 'X coordinate (0-19 for draw/line actions)'
+      },
+      y: {
+        type: 'number', 
+        description: 'Y coordinate (0-11 for draw/line actions)'
+      },
+      x1: {
+        type: 'number',
+        description: 'End X coordinate (for line action)'
+      },
+      y1: {
+        type: 'number',
+        description: 'End Y coordinate (for line action)'
+      },
+      char: {
+        type: 'string',
+        description: 'Character/emoji to draw (e.g., "star", "heart", "tree"). See available chars in canvas display.'
+      },
+      theme: {
+        type: 'string',
+        description: 'Drawing theme/prompt to set for the room'
+      }
+    },
+    required: ['room']
+  }
+};
+
+// Storage key for drawing sessions
+function getDrawingRoomKey(roomName) {
+  return `drawing_room:${roomName.toLowerCase()}`;
+}
+
+// Get or create drawing room
+async function getOrCreateRoom(roomName) {
+  const key = getDrawingRoomKey(roomName);
+  
+  try {
+    const existing = await store.kv.get(key);
+    if (existing) {
+      return JSON.parse(existing);
+    }
+  } catch (e) {
+    console.log(`[drawing] Creating new room: ${roomName}`);
+  }
+  
+  // Create new room
+  const newRoom = drawing.createInitialDrawingState();
+  await store.kv.set(key, JSON.stringify(newRoom));
+  return newRoom;
+}
+
+// Save room state
+async function saveRoom(roomName, gameState) {
+  const key = getDrawingRoomKey(roomName);
+  await store.kv.set(key, JSON.stringify(gameState));
+}
+
+// Post drawing activity to board
+async function postDrawingActivity(roomName, playerHandle, action, details = '') {
+  const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+  
+  try {
+    let content = '';
+    switch (action) {
+      case 'created':
+        content = `🎨 @${playerHandle} created collaborative drawing room "${roomName}" — join in!`;
+        break;
+      case 'joined':
+        content = `🎨 @${playerHandle} joined the "${roomName}" drawing session`;
+        break;
+      case 'drew':
+        content = `🎨 @${playerHandle} is drawing in "${roomName}" ${details}`;
+        break;
+      case 'theme':
+        content = `🎯 @${playerHandle} set drawing theme in "${roomName}": ${details}`;
+        break;
+      default:
+        return; // Don't post for other actions
+    }
+
+    await fetch(`${API_URL}/api/board`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        author: 'echo',
+        content,
+        category: 'general'
+      })
+    });
+  } catch (e) {
+    console.error('[drawing] Failed to post to board:', e.message);
+  }
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { room, action = 'view', x, y, x1, y1, char, theme } = args;
+  const myHandle = config.getHandle();
+  
+  if (!room) {
+    return { display: 'Room name is required. Use something like "art-party" or "sketch-together"' };
+  }
+
+  // Normalize room name
+  const roomName = room.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+  
+  try {
+    // Get or create room
+    let gameState = await getOrCreateRoom(roomName);
+    const wasNewRoom = gameState.players.length === 0;
+    
+    // Add player to room if not already there
+    if (!gameState.players.includes(myHandle)) {
+      const addResult = drawing.addPlayer(gameState, myHandle);
+      if (addResult.error) {
+        return { display: addResult.error };
+      }
+      gameState = addResult.gameState;
+      await saveRoom(roomName, gameState);
+      
+      // Post activity
+      if (wasNewRoom) {
+        await postDrawingActivity(roomName, myHandle, 'created');
+      } else {
+        await postDrawingActivity(roomName, myHandle, 'joined');
+      }
+    }
+    
+    // Handle different actions
+    switch (action) {
+      case 'view':
+        // Just show current state
+        break;
+        
+      case 'draw':
+        if (x === undefined || y === undefined || !char) {
+          return { display: 'Draw action requires x, y coordinates and char. Example: `--action draw --x 10 --y 5 --char heart`' };
+        }
+        
+        // Validate character name
+        const drawChar = drawing.DRAWING_CHARS[char];
+        if (!drawChar) {
+          const availableChars = Object.keys(drawing.DRAWING_CHARS).join(', ');
+          return { display: `Invalid character "${char}". Available: ${availableChars}` };
+        }
+        
+        const drawResult = drawing.makeMove(gameState, x, y, drawChar, myHandle);
+        if (drawResult.error) {
+          return { display: drawResult.error };
+        }
+        
+        gameState = drawResult.gameState;
+        await saveRoom(roomName, gameState);
+        await postDrawingActivity(roomName, myHandle, 'drew', `(${drawChar} at ${x},${y})`);
+        break;
+        
+      case 'line':
+        if (x === undefined || y === undefined || x1 === undefined || y1 === undefined || !char) {
+          return { display: 'Line action requires x, y, x1, y1 coordinates and char. Example: `--action line --x 5 --y 5 --x1 15 --y1 8 --char star`' };
+        }
+        
+        const lineChar = drawing.DRAWING_CHARS[char];
+        if (!lineChar) {
+          const availableChars = Object.keys(drawing.DRAWING_CHARS).join(', ');
+          return { display: `Invalid character "${char}". Available: ${availableChars}` };
+        }
+        
+        const lineResult = drawing.drawLine(gameState, x, y, x1, y1, lineChar, myHandle);
+        if (lineResult.error) {
+          return { display: lineResult.error };
+        }
+        
+        gameState = lineResult.gameState;
+        await saveRoom(roomName, gameState);
+        await postDrawingActivity(roomName, myHandle, 'drew', `line from (${x},${y}) to (${x1},${y1})`);
+        break;
+        
+      case 'clear':
+        if (x === undefined || y === undefined) {
+          // Clear entire canvas
+          const clearResult = drawing.clearRegion(gameState, 0, 0, drawing.CANVAS_WIDTH - 1, drawing.CANVAS_HEIGHT - 1, myHandle);
+          if (clearResult.error) {
+            return { display: clearResult.error };
+          }
+          gameState = clearResult.gameState;
+          await postDrawingActivity(roomName, myHandle, 'drew', '(cleared canvas)');
+        } else {
+          // Clear specific region
+          const clearX1 = x1 !== undefined ? x1 : x;
+          const clearY1 = y1 !== undefined ? y1 : y;
+          const clearResult = drawing.clearRegion(gameState, x, y, clearX1, clearY1, myHandle);
+          if (clearResult.error) {
+            return { display: clearResult.error };
+          }
+          gameState = clearResult.gameState;
+          await postDrawingActivity(roomName, myHandle, 'drew', `(cleared region ${x},${y} to ${clearX1},${clearY1})`);
+        }
+        await saveRoom(roomName, gameState);
+        break;
+        
+      case 'theme':
+        if (!theme) {
+          return { display: 'Theme action requires a theme. Example: `--action theme --theme "draw a house"`' };
+        }
+        
+        const themeResult = drawing.setTheme(gameState, theme, myHandle);
+        if (themeResult.error) {
+          return { display: themeResult.error };
+        }
+        
+        gameState = themeResult.gameState;
+        await saveRoom(roomName, gameState);
+        await postDrawingActivity(roomName, myHandle, 'theme', theme);
+        break;
+        
+      default:
+        return { display: `Unknown action "${action}". Use: view, draw, line, clear, or theme` };
+    }
+    
+    // Format and return display
+    const display = drawing.formatDrawingDisplay(gameState);
+    const stats = drawing.getCanvasStats(gameState);
+    
+    let result = `# 🎨 Collaborative Drawing Room: "${roomName}"\n\n${display}`;
+    
+    // Add usage instructions
+    result += '\n**How to draw:**\n';
+    result += `• \`vibe collaborative-drawing --room "${roomName}" --action draw --x 10 --y 5 --char heart\`\n`;
+    result += `• \`vibe collaborative-drawing --room "${roomName}" --action line --x 5 --y 3 --x1 15 --y1 8 --char star\`\n`;
+    result += `• \`vibe collaborative-drawing --room "${roomName}" --action clear\` (clear all)\n`;
+    result += `• \`vibe collaborative-drawing --room "${roomName}" --action theme --theme "draw a sunset"\`\n\n`;
+    
+    // Add tips if there's a theme
+    if (gameState.theme) {
+      const tips = drawing.getDrawingTips(gameState.theme);
+      result += `**Drawing tips for "${gameState.theme}":**\n`;
+      result += tips.map(tip => `• ${tip}`).join('\n') + '\n\n';
+    }
+    
+    // Add stats
+    result += `**Canvas stats:** ${stats.fillPercentage}% filled, ${stats.totalMoves} moves, ${stats.uniqueCharsUsed} different characters used\n`;
+    
+    if (stats.mostUsedChar) {
+      result += `Most used: ${stats.mostUsedChar[0]} (${stats.mostUsedChar[1]} times)\n`;
+    }
+    
+    return { display: result };
+    
+  } catch (error) {
+    console.error('[drawing] Error:', error);
+    return { display: `Error: ${error.message}` };
+  }
+}
+
+module.exports = { definition, handler };

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,
+};

package/tools/crossword.js

@@ -19,7 +19,7 @@ const DAILY_ROOM_PREFIX = 'daily-';
 
 const definition = {
   name: 'vibe_crossword',
-  description: 'Multiplayer crossword puzzles. Search triggers: "crossword", "puzzle", "word game", "daily challenge", "brain teaser". Daily 5x5 minis with collaborative and competitive modes.',
+  description: 'Play multiplayer crossword puzzles. Daily 5x5 minis, collaborative or competitive.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -200,6 +200,22 @@ function listRooms() {
 
 // Handler
 async function handler(args) {
+  // Check if crossword module is available
+  if (!crossword.isAvailable()) {
+    return {
+      display: `**Crossword not available**
+
+The crossword-layout-generator module isn't installed.
+
+**To fix:**
+\`\`\`bash
+cd ~/.vibe/vibe-repo/mcp-server && npm install
+\`\`\`
+
+Then restart Claude Code.`
+    };
+  }
+
   // Require init
   const initCheck = requireInit();
   if (initCheck) {