slashvibe-mcp 0.3.20 → 0.3.21

package/tools/lib/git-bundle.js

@@ -0,0 +1,407 @@
+/**
+ * Git Bundle Library
+ *
+ * Creates and validates git bundles for session sharing.
+ * Used by broadcast.js to capture code changes during a broadcast.
+ *
+ * Key functions:
+ * - captureSessionStart() - Returns current HEAD commit
+ * - createBundle(startCommit) - Creates bundle from startCommit to HEAD
+ * - validateBundle(buffer) - Validates bundle integrity
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Max bundle size (10MB)
+const MAX_BUNDLE_SIZE = 10 * 1024 * 1024;
+
+// Files to exclude from bundles (security)
+const EXCLUDED_PATTERNS = [
+  '.env',
+  '.env.*',
+  '*.pem',
+  '*.key',
+  '*.p12',
+  '*.pfx',
+  '.npmrc',
+  '.netrc',
+  'credentials.json',
+  'secrets.json',
+  '*_rsa',
+  '*_dsa',
+  '*_ed25519',
+  '*_ecdsa',
+  'id_rsa*',
+  'id_dsa*',
+  '*.keystore',
+];
+
+/**
+ * Check if we're in a git repository
+ */
+function isGitRepo() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get current git branch
+ */
+function getCurrentBranch() {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get current HEAD commit hash
+ */
+function getHeadCommit() {
+  try {
+    return execSync('git rev-parse HEAD', {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get commit count between two commits
+ */
+function getCommitCount(startCommit, endCommit = 'HEAD') {
+  try {
+    const output = execSync(`git rev-list --count ${startCommit}..${endCommit}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return parseInt(output.trim(), 10);
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Get list of files changed between commits
+ */
+function getChangedFiles(startCommit, endCommit = 'HEAD') {
+  try {
+    const output = execSync(`git diff --name-only ${startCommit}..${endCommit}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return output.trim().split('\n').filter(Boolean);
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Check if any excluded files would be in the bundle
+ */
+function hasExcludedFiles(changedFiles) {
+  const excluded = [];
+
+  for (const file of changedFiles) {
+    const basename = path.basename(file);
+
+    for (const pattern of EXCLUDED_PATTERNS) {
+      // Simple glob matching
+      if (pattern.startsWith('*')) {
+        const suffix = pattern.slice(1);
+        if (basename.endsWith(suffix)) {
+          excluded.push(file);
+          break;
+        }
+      } else if (pattern.endsWith('*')) {
+        const prefix = pattern.slice(0, -1);
+        if (basename.startsWith(prefix)) {
+          excluded.push(file);
+          break;
+        }
+      } else if (pattern.includes('*')) {
+        // Pattern like ".env.*"
+        const [prefix, suffix] = pattern.split('*');
+        if (basename.startsWith(prefix) && (suffix === '' || basename.endsWith(suffix))) {
+          excluded.push(file);
+          break;
+        }
+      } else if (basename === pattern || file === pattern) {
+        excluded.push(file);
+        break;
+      }
+    }
+  }
+
+  return excluded;
+}
+
+/**
+ * Capture git state at session start
+ * @returns {object} - { success, commit, branch, error? }
+ */
+function captureSessionStart() {
+  if (!isGitRepo()) {
+    return { success: false, error: 'Not a git repository' };
+  }
+
+  const commit = getHeadCommit();
+  const branch = getCurrentBranch();
+
+  if (!commit) {
+    return { success: false, error: 'Could not get HEAD commit' };
+  }
+
+  return {
+    success: true,
+    commit,
+    branch,
+    capturedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Create a git bundle from startCommit to HEAD
+ * @param {string} startCommit - Starting commit hash
+ * @returns {object} - { success, buffer, metadata, error? }
+ */
+function createBundle(startCommit) {
+  if (!isGitRepo()) {
+    return { success: false, error: 'Not a git repository' };
+  }
+
+  if (!startCommit) {
+    return { success: false, error: 'Start commit required' };
+  }
+
+  const endCommit = getHeadCommit();
+  const branch = getCurrentBranch();
+
+  if (!endCommit) {
+    return { success: false, error: 'Could not get HEAD commit' };
+  }
+
+  // Check if there are any new commits
+  const commitCount = getCommitCount(startCommit, endCommit);
+  if (commitCount === 0) {
+    return {
+      success: false,
+      error: 'No new commits since session start',
+      metadata: {
+        startCommit,
+        endCommit,
+        branch,
+      },
+    };
+  }
+
+  // Check for excluded files
+  const changedFiles = getChangedFiles(startCommit, endCommit);
+  const excludedFiles = hasExcludedFiles(changedFiles);
+
+  if (excludedFiles.length > 0) {
+    console.log(`[git-bundle] Warning: Excluding sensitive files: ${excludedFiles.join(', ')}`);
+  }
+
+  // Create temp file for bundle
+  const tmpDir = os.tmpdir();
+  const bundlePath = path.join(tmpDir, `vibe-bundle-${Date.now()}.bundle`);
+
+  try {
+    // Create the bundle
+    // Format: git bundle create <file> <range>
+    const bundleRange = `${startCommit}..HEAD`;
+
+    execSync(`git bundle create "${bundlePath}" ${bundleRange}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+
+    // Read the bundle
+    const buffer = fs.readFileSync(bundlePath);
+
+    // Check size
+    if (buffer.length > MAX_BUNDLE_SIZE) {
+      fs.unlinkSync(bundlePath);
+      return {
+        success: false,
+        error: `Bundle too large (${Math.round(buffer.length / 1024 / 1024)}MB > ${MAX_BUNDLE_SIZE / 1024 / 1024}MB limit)`,
+      };
+    }
+
+    // Clean up temp file
+    fs.unlinkSync(bundlePath);
+
+    const metadata = {
+      initialCommit: startCommit,
+      finalCommit: endCommit,
+      branch,
+      commitCount,
+      changedFiles: changedFiles.filter((f) => !excludedFiles.includes(f)),
+      excludedFiles,
+      size: buffer.length,
+      createdAt: new Date().toISOString(),
+    };
+
+    console.log(`[git-bundle] Created bundle: ${commitCount} commits, ${changedFiles.length} files, ${buffer.length} bytes`);
+
+    return {
+      success: true,
+      buffer,
+      metadata,
+    };
+  } catch (error) {
+    // Clean up on error
+    try {
+      if (fs.existsSync(bundlePath)) {
+        fs.unlinkSync(bundlePath);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    console.error('[git-bundle] Failed to create bundle:', error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Validate a git bundle
+ * @param {Buffer} buffer - The bundle data
+ * @returns {object} - { success, info, error? }
+ */
+function validateBundle(buffer) {
+  if (!buffer || buffer.length === 0) {
+    return { success: false, error: 'Empty buffer' };
+  }
+
+  // Check magic bytes (git bundles start with "# v2 git bundle" or "# v3 git bundle")
+  const header = buffer.slice(0, 20).toString('utf8');
+  if (!header.startsWith('# v2 git bundle') && !header.startsWith('# v3 git bundle')) {
+    return { success: false, error: 'Invalid bundle format' };
+  }
+
+  // Write to temp and verify
+  const tmpDir = os.tmpdir();
+  const bundlePath = path.join(tmpDir, `vibe-verify-${Date.now()}.bundle`);
+
+  try {
+    fs.writeFileSync(bundlePath, buffer);
+
+    // Verify the bundle
+    const output = execSync(`git bundle verify "${bundlePath}"`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+
+    fs.unlinkSync(bundlePath);
+
+    return {
+      success: true,
+      info: output.trim(),
+      size: buffer.length,
+    };
+  } catch (error) {
+    try {
+      if (fs.existsSync(bundlePath)) {
+        fs.unlinkSync(bundlePath);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Apply a bundle to create a new branch (for forking)
+ * @param {Buffer} buffer - The bundle data
+ * @param {string} branchName - Name for the new branch
+ * @returns {object} - { success, branch, error? }
+ */
+function applyBundle(buffer, branchName = 'forked-session') {
+  if (!isGitRepo()) {
+    return { success: false, error: 'Not a git repository' };
+  }
+
+  const validation = validateBundle(buffer);
+  if (!validation.success) {
+    return { success: false, error: `Invalid bundle: ${validation.error}` };
+  }
+
+  const tmpDir = os.tmpdir();
+  const bundlePath = path.join(tmpDir, `vibe-apply-${Date.now()}.bundle`);
+
+  try {
+    fs.writeFileSync(bundlePath, buffer);
+
+    // Get the refs in the bundle
+    const listOutput = execSync(`git bundle list-heads "${bundlePath}"`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+
+    const refs = listOutput.trim().split('\n');
+    if (refs.length === 0) {
+      throw new Error('No refs in bundle');
+    }
+
+    // Get the first commit hash from the bundle
+    const firstRef = refs[0].split(/\s+/)[0];
+
+    // Unbundle (fetch from bundle)
+    execSync(`git fetch "${bundlePath}" ${firstRef}:${branchName}`, {
+      stdio: 'pipe',
+    });
+
+    fs.unlinkSync(bundlePath);
+
+    console.log(`[git-bundle] Applied bundle to branch: ${branchName}`);
+
+    return {
+      success: true,
+      branch: branchName,
+      refs: refs.map((r) => r.split(/\s+/)),
+    };
+  } catch (error) {
+    try {
+      if (fs.existsSync(bundlePath)) {
+        fs.unlinkSync(bundlePath);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    console.error('[git-bundle] Failed to apply bundle:', error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  isGitRepo,
+  getCurrentBranch,
+  getHeadCommit,
+  captureSessionStart,
+  createBundle,
+  validateBundle,
+  applyBundle,
+  MAX_BUNDLE_SIZE,
+  EXCLUDED_PATTERNS,
+};

package/tools/migrate.js

@@ -2,7 +2,7 @@
  * vibe migrate — Migrate existing handle to GitHub auth
  *
  * For users who have existing handles with local keypairs,
- * this command helps them migrate to the new Privy/GitHub auth.
+ * this command helps them migrate to GitHub OAuth auth.
  *
  * Flow:
  * 1. Check if user has existing handle and keys
@@ -36,8 +36,8 @@ If you're new, use \`vibe init @yourhandle "what you're building"\` instead.`
     };
   }
 
-  // Check if already using Privy auth
-  if (config.hasPrivyAuth()) {
+  // Check if already using GitHub auth
+  if (config.hasOAuth()) {
     return {
       display: `✅ **Already using GitHub auth**
 

package/tools/multiplayer-game.js

@@ -105,7 +105,7 @@ async function handler(args) {
   const roomId = roomName || 'default';
 
   // Get current game state
-  let gameState = getGameRoom(game, roomId);
+  const gameState = getGameRoom(game, roomId);
   
   try {
     if (game === 'drawing') {

package/tools/onboarding.js

@@ -110,23 +110,23 @@ Error: ${response.error || 'Unknown error'}`
       if (nextTask) {
         switch (nextTask.id) {
           case 'read_welcome':
-            display += '→ Say **"check my messages"** to read @vibe\'s welcome\n';
+            display += '→ Say **"check my messages"** to read @seth\'s welcome\n';
             break;
           case 'reply_seth':
-            display += '→ Say **"reply to vibe"** or **"dm @vibe hi!"**\n';
+            display += '→ Say **"reply to seth"** or **"dm @seth hi!"**\n';
             break;
-          case 'message_builder':
-            display += '→ Say **"who\'s around?"** then message someone\n';
+          case 'find_github_friends':
+            display += '→ Say **"find my github friends"** to see who you know! 🔥\n';
             break;
           case 'first_ship':
             display += '→ Say **"ship something"** or **"I shipped X"**\n';
             break;
+          case 'share_ship':
+            display += '→ After shipping, click the Twitter link to share! 🐦\n';
+            break;
           case 'invite_friend':
             display += '→ Say **"invite a friend"** or **"share my invite link"**\n';
             break;
-          case 'leave_feedback':
-            display += '→ Say **"echo feedback about X"** or **"give feedback"**\n';
-            break;
         }
       }
     }

package/tools/open.js

@@ -8,6 +8,15 @@ const memory = require('../memory');
 const patterns = require('../intelligence/patterns');
 const { formatPayload } = require('../protocol');
 const { requireInit, normalizeHandle } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+// Truncate message for preview (first 100 chars, clean break at word)
+function summarizeMessage(text, maxLen = 100) {
+  if (!text || text.length <= maxLen) return text;
+  const truncated = text.slice(0, maxLen);
+  const lastSpace = truncated.lastIndexOf(' ');
+  return (lastSpace > maxLen * 0.7 ? truncated.slice(0, lastSpace) : truncated) + '...';
+}
 
 const definition = {
   name: 'vibe_open',
@@ -46,38 +55,152 @@ async function handler(args) {
     patterns.logMessageReceived(them);
   }
 
-  // Check if they're typing
+  // Check if they're typing (cross-platform: synced via KV)
   let typingNotice = '';
   try {
     const typingUsers = await store.getTypingUsers(myHandle);
-    if (typingUsers.includes(them)) {
+    const isTyping = typingUsers.some(t => t.handle?.toLowerCase() === them.toLowerCase());
+    if (isTyping) {
       typingNotice = `\n_@${them} is typing..._\n`;
     }
   } catch (e) {}
 
+  // Get their presence status (for "last seen" display)
+  let presenceStatus = '';
+  try {
+    const activeUsers = await store.getActiveUsers();
+    const theirPresence = activeUsers.find(u => u.handle?.toLowerCase() === them.toLowerCase());
+
+    if (theirPresence) {
+      if (theirPresence.status === 'active') {
+        presenceStatus = '🟢 online now';
+      } else if (theirPresence.status === 'away') {
+        const ago = store.formatTimeAgo(theirPresence.lastSeen);
+        presenceStatus = `☕ away · last seen ${ago}`;
+      } else {
+        const ago = store.formatTimeAgo(theirPresence.lastSeen);
+        presenceStatus = `last seen ${ago}`;
+      }
+    }
+  } catch (e) {}
+
   if (thread.length === 0) {
-    return {
-      display: `## @${them}
+    const statusLine = presenceStatus ? `\n_${presenceStatus}_` : '';
+
+    // Fetch conversation starters to help break the ice
+    let starters = [];
+    let starterContext = {};
+    try {
+      const apiUrl = config.getApiUrl();
+      const promptsResponse = await fetch(`${apiUrl}/api/prompts?from=${myHandle}&to=${them}`, {
+        headers: { 'User-Agent': 'vibe-mcp-client' }
+      });
+      if (promptsResponse.ok) {
+        const data = await promptsResponse.json();
+        if (data.success && data.prompts) {
+          starters = data.prompts.slice(0, 3);
+          starterContext = data.context || {};
+        }
+      }
+    } catch (e) {}
+
+    // Build display with conversation starters
+    let emptyDisplay = `## @${them}${statusLine}
 
 _No messages yet._${typingNotice}
+`;
+
+    if (starters.length > 0) {
+      emptyDisplay += `\n**💬 Conversation starters:**\n`;
+      starters.forEach((starter, i) => {
+        emptyDisplay += `${i + 1}. "${starter}"\n`;
+      });
+      emptyDisplay += `\n_Copy one or say your own!_`;
+    } else {
+      emptyDisplay += `\nSay "message ${them} hello" to start`;
+    }
+
+    // Build response with actions for quick-send
+    const response = { display: emptyDisplay };
+
+    if (starters.length > 0) {
+      response.actions = formatActions(starters.map((starter, i) => ({
+        label: `Send #${i + 1}`,
+        action: `vibe dm @${them} ${starter}`,
+        description: starter.slice(0, 40) + (starter.length > 40 ? '...' : '')
+      })));
+      response.conversationStarters = starters;
+      response.context = starterContext;
+    }
 
-Say "message ${them} hello" to start`
-    };
+    return response;
   }
 
-  // Check if they're an agent (from first message if available)
-  const theirMessage = thread.find(m => m.from === them);
-  const agentIndicator = theirMessage?.isAgent ? ' 🤖' : '';
+  // Get latest message from them for the summary preview
+  const latestFromThem = theirMessages.length > 0
+    ? theirMessages.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))[0]
+    : null;
+
+  // Build the preview summary line (what appears in collapsed view)
+  let display = '';
+
+  // Header with presence status
+  const statusSuffix = presenceStatus ? ` · _${presenceStatus}_` : '';
 
-  let display = `## Thread with @${them}${agentIndicator}\n\n`;
+  if (latestFromThem) {
+    const agentBadge = latestFromThem.isAgent ? ' 🤖' : '';
+    const time = store.formatTimeAgo(latestFromThem.timestamp);
+    const preview = latestFromThem.body
+      ? summarizeMessage(latestFromThem.body)
+      : (latestFromThem.payload ? '[attachment]' : '');
 
-  thread.forEach(m => {
+    display = `💬 @${them}${agentBadge}${statusSuffix}\n> (${time}): "${preview}"\n\n`;
+  } else {
+    // No messages from them yet - you sent first
+    display = `💬 @${them}${statusSuffix}\n> _Waiting for reply..._\n\n`;
+  }
+
+  // Thread section - sorted newest first so their latest message appears at top
+  display += `---\n📜 Thread\n\n`;
+
+  const sortedThread = [...thread].sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+
+  // Build a map for reply lookups
+  const messageMap = {};
+  thread.forEach(m => { messageMap[m.id] = m; });
+
+  sortedThread.forEach(m => {
     const isMe = m.from === myHandle;
     const agentBadge = m.isAgent && !isMe ? '🤖 ' : '';
     const sender = isMe ? 'you' : `@${m.from}`;
     const time = store.formatTimeAgo(m.timestamp);
 
-    display += `${agentBadge}**${sender}** — _${time}_\n`;
+    // Status indicator for sent messages: ✓ sent, ✓✓ delivered, ✓✓ read
+    let statusIndicator = '';
+    if (isMe) {
+      if (m.status === 'read' || m.readByThem) {
+        statusIndicator = ' ✓✓ read';
+      } else if (m.status === 'delivered' || m.delivered) {
+        statusIndicator = ' ✓✓';
+      } else {
+        statusIndicator = ' ✓';
+      }
+    }
+
+    display += `${agentBadge}**${sender}** — _${time}${statusIndicator}_\n`;
+
+    // Show reply context if this is a threaded reply
+    if (m.reply_to_id || m.replyToId) {
+      const replyToId = m.reply_to_id || m.replyToId;
+      const originalMsg = messageMap[replyToId];
+      if (originalMsg) {
+        const originalSender = originalMsg.from === myHandle ? 'you' : `@${originalMsg.from}`;
+        const preview = (originalMsg.body || '').substring(0, 50);
+        display += `> ↩ replying to ${originalSender}: "${preview}${preview.length >= 50 ? '...' : ''}"\n`;
+      } else {
+        display += `> ↩ _replying to earlier message_\n`;
+      }
+    }
 
     // Show text if present
     if (m.body) {
@@ -114,6 +237,14 @@ Say "message ${them} hello" to start`
     response.reason = 'long_thread';
   }
 
+  // Add smart reply actions based on their last message
+  if (latestFromThem && latestFromThem.body) {
+    response.actions = formatActions(actions.afterOpenThread(them, latestFromThem.body));
+  } else {
+    // No message from them yet - offer generic options
+    response.actions = formatActions(actions.afterOpenThread(them, ''));
+  }
+
   return response;
 }
 

package/tools/party-game.js

@@ -103,7 +103,7 @@ async function handler(args) {
   const gameKey = getGameKey(game, room || myHandle);
 
   // Get or create game state
-  let gameState = activeGames[gameKey];
+  const gameState = activeGames[gameKey];
 
   if (game === 'twotruths') {
     return handleTwoTruths(args, myHandle, gameKey, gameState);