slashvibe-mcp 0.3.19 → 0.3.21

package/README.md

@@ -1,6 +1,19 @@
 # vibe-mcp
 
-Social layer for Claude Code. DMs, presence, and connection between AI-assisted developers.
+Social layer for AI-assisted coding. DMs, presence, and connection between developers.
+
+**Works in:** Claude Code • Cursor • Any MCP-compatible IDE
+
+## Quick Start
+
+**Claude Code:**
+```bash
+npx slashvibe-mcp setup
+```
+
+**Cursor:** See [Cursor Setup Guide](docs/CURSOR_SETUP.md)
+
+**Other IDEs:** Any editor supporting MCP protocol can use the manual config below.
 
 ## Installation
 

package/index.js

@@ -99,10 +99,11 @@ async function getPresenceFooter() {
     const handle = config.getHandle();
     if (!handle) return '';
 
-    // Fetch presence and unread in parallel
-    const [users, unreadCount] = await Promise.all([
+    // Fetch presence, unread, and live broadcasts in parallel
+    const [users, unreadCount, liveCount] = await Promise.all([
       store.getActiveUsers().catch(() => []),
-      store.getUnreadCount(handle).catch(() => 0)
+      store.getUnreadCount(handle).catch(() => 0),
+      store.getLiveBroadcastCount().catch(() => 0)
     ]);
 
     // Filter out self
@@ -125,7 +126,7 @@ async function getPresenceFooter() {
     // Build the visible footer
     let footer = '\n\n────────────────────────────────────────\n';
 
-    // Line 1: vibe · X online · Y unread
+    // Line 1: vibe · X online · Y unread · Z live
     const parts = ['vibe'];
     if (onlineCount > 0) {
       parts.push(`${onlineCount} online`);
@@ -133,6 +134,9 @@ async function getPresenceFooter() {
     if (unreadCount > 0) {
       parts.push(`**${unreadCount} unread**`);
     }
+    if (liveCount > 0) {
+      parts.push(`🔴 ${liveCount} live`);
+    }
     footer += parts.join(' · ');
 
     // Line 2: Activity hints (if anyone is online)
@@ -154,8 +158,10 @@ async function getPresenceFooter() {
         }
       });
       footer += hints.join(' · ');
-    } else if (unreadCount === 0) {
-      footer += '\n_room is quiet_';
+    } else if (unreadCount === 0 && liveCount === 0) {
+      footer += '\n_room is quiet · `vibe broadcast start` to go live_';
+    } else if (unreadCount === 0 && liveCount > 0) {
+      footer += '\n_no messages · watch live broadcasts with `vibe watch`_';
     }
 
     footer += '\n────────────────────────────────────────';
@@ -281,7 +287,13 @@ const coreTools = {
   vibe_withdraw: require('./tools/withdraw'),
   vibe_session_price: require('./tools/session_price'),
   vibe_subscribe: require('./tools/subscribe'),
-  vibe_subscriptions: require('./tools/subscriptions')
+  vibe_subscriptions: require('./tools/subscriptions'),
+  // NFT Minting — Mint artifacts to VIBE L2, Base, or Ethereum
+  vibe_mint: require('./tools/mint'),
+  // Platform Status — Health, leaderboard, streaks
+  vibe_health: require('./tools/health'),
+  vibe_leaderboard: require('./tools/leaderboard'),
+  vibe_streak: require('./tools/streak')
 };
 
 // Admin tools (only loaded when VIBE_ADMIN=true)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.3.19",
+  "version": "0.3.21",
   "mcpName": "io.github.vibecodinginc/vibe",
   "description": "Social layer for Claude Code - DMs, presence, and connection between AI-assisted developers",
   "main": "index.js",
@@ -49,6 +49,7 @@
     "notify.js",
     "notification-emitter.js",
     "analytics.js",
+    "smart-inbox.js",
     "presence.js",
     "prompts.js",
     "twitter.js",

package/smart-inbox.js

@@ -0,0 +1,276 @@
+/**
+ * Smart Inbox Checking
+ *
+ * Intelligent notification checking that triggers at natural breaks:
+ * - After git commits
+ * - After test/build completion
+ * - After periods of activity (not idle)
+ * - On explicit check request
+ *
+ * Uses debouncing to avoid notification spam.
+ */
+
+const config = require('./config');
+const notify = require('./notify');
+const store = require('./store');
+const fs = require('fs');
+const path = require('path');
+
+// State file for tracking check timing
+const SMART_STATE_FILE = path.join(config.VIBE_DIR, '.smart_inbox_state.json');
+
+// Timing constants
+const MIN_CHECK_INTERVAL = 60 * 1000;       // Minimum 1 minute between checks
+const ACTIVITY_COOLDOWN = 5 * 60 * 1000;    // 5 min after activity burst
+const COMMIT_DELAY = 3 * 1000;              // 3 second delay after commit (let it settle)
+const TEST_DELAY = 2 * 1000;                // 2 second delay after test
+const BUILD_DELAY = 5 * 1000;               // 5 second delay after build
+
+// Trigger types
+const TRIGGERS = {
+  COMMIT: 'commit',
+  TEST_PASS: 'test_pass',
+  TEST_FAIL: 'test_fail',
+  BUILD_COMPLETE: 'build_complete',
+  BUILD_FAIL: 'build_fail',
+  NATURAL_BREAK: 'natural_break',
+  EXPLICIT: 'explicit',
+  SESSION_START: 'session_start',
+  SESSION_END: 'session_end',
+};
+
+function loadState() {
+  try {
+    if (fs.existsSync(SMART_STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(SMART_STATE_FILE, 'utf8'));
+    }
+  } catch (e) {}
+  return {
+    lastCheck: null,
+    lastTrigger: null,
+    checkCount: 0,
+    triggersToday: {},
+    activityBurst: null,
+  };
+}
+
+function saveState(state) {
+  try {
+    fs.writeFileSync(SMART_STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {}
+}
+
+/**
+ * Check if we should actually run a check based on timing
+ */
+function shouldCheck(trigger) {
+  const state = loadState();
+  const now = Date.now();
+
+  // Always allow explicit checks
+  if (trigger === TRIGGERS.EXPLICIT) {
+    return { should: true, reason: 'explicit_request' };
+  }
+
+  // Check minimum interval
+  if (state.lastCheck && (now - state.lastCheck) < MIN_CHECK_INTERVAL) {
+    return { should: false, reason: 'too_soon', wait: MIN_CHECK_INTERVAL - (now - state.lastCheck) };
+  }
+
+  // Session events always trigger
+  if (trigger === TRIGGERS.SESSION_START || trigger === TRIGGERS.SESSION_END) {
+    return { should: true, reason: 'session_event' };
+  }
+
+  // For build/test/commit, we want them but with debounce
+  if ([TRIGGERS.COMMIT, TRIGGERS.TEST_PASS, TRIGGERS.TEST_FAIL,
+       TRIGGERS.BUILD_COMPLETE, TRIGGERS.BUILD_FAIL].includes(trigger)) {
+    // If same trigger happened in last 30 seconds, skip
+    if (state.lastTrigger === trigger && state.lastCheck && (now - state.lastCheck) < 30000) {
+      return { should: false, reason: 'debounced', wait: 30000 - (now - state.lastCheck) };
+    }
+    return { should: true, reason: 'event_trigger' };
+  }
+
+  // Natural breaks - check if there's been activity recently
+  if (trigger === TRIGGERS.NATURAL_BREAK) {
+    // If we haven't checked in 5+ minutes and there's been activity, good time
+    if (!state.lastCheck || (now - state.lastCheck) > ACTIVITY_COOLDOWN) {
+      return { should: true, reason: 'natural_break' };
+    }
+    return { should: false, reason: 'not_time_yet' };
+  }
+
+  return { should: true, reason: 'default' };
+}
+
+/**
+ * Perform smart inbox check
+ * Returns notification info if any
+ */
+async function check(trigger = TRIGGERS.EXPLICIT, context = {}) {
+  const decision = shouldCheck(trigger);
+
+  if (!decision.should) {
+    return {
+      checked: false,
+      reason: decision.reason,
+      waitMs: decision.wait || 0,
+    };
+  }
+
+  const handle = config.getHandle();
+  if (!handle) {
+    return { checked: false, reason: 'not_initialized' };
+  }
+
+  const state = loadState();
+  const now = Date.now();
+
+  // Apply appropriate delay based on trigger
+  let delay = 0;
+  switch (trigger) {
+    case TRIGGERS.COMMIT:
+      delay = COMMIT_DELAY;
+      break;
+    case TRIGGERS.TEST_PASS:
+    case TRIGGERS.TEST_FAIL:
+      delay = TEST_DELAY;
+      break;
+    case TRIGGERS.BUILD_COMPLETE:
+    case TRIGGERS.BUILD_FAIL:
+      delay = BUILD_DELAY;
+      break;
+  }
+
+  if (delay > 0) {
+    await new Promise(r => setTimeout(r, delay));
+  }
+
+  // Run the actual notification check
+  let unreadCount = 0;
+  let notified = false;
+  let newUsers = [];
+  let newShips = [];
+
+  try {
+    // Get unread messages
+    const inbox = await store.getRawInbox(handle).catch(() => []);
+    unreadCount = inbox.length;
+
+    if (inbox.length > 0) {
+      notified = await notify.checkAndNotify(inbox);
+    }
+
+    // Get presence for online users
+    const users = await store.getActiveUsers().catch(() => []);
+    if (users.length > 0) {
+      newUsers = notify.checkPresence(users);
+    }
+
+    // Get ships from connections
+    try {
+      const localStore = require('./store/local');
+      const memories = localStore.getAllThreadMemories ? localStore.getAllThreadMemories() : {};
+      const memoryHandles = Object.keys(memories).map(h => h.toLowerCase());
+      if (memoryHandles.length > 0) {
+        newShips = await notify.checkShips(memoryHandles);
+      }
+    } catch (e) {
+      // Memory check is optional
+    }
+  } catch (e) {
+    // Silent fail
+  }
+
+  // Update state
+  state.lastCheck = now;
+  state.lastTrigger = trigger;
+  state.checkCount++;
+
+  // Track triggers by day
+  const today = new Date().toISOString().split('T')[0];
+  if (!state.triggersToday || state.triggersToday.date !== today) {
+    state.triggersToday = { date: today, counts: {} };
+  }
+  state.triggersToday.counts[trigger] = (state.triggersToday.counts[trigger] || 0) + 1;
+
+  saveState(state);
+
+  return {
+    checked: true,
+    trigger,
+    reason: decision.reason,
+    unreadCount,
+    notified,
+    newOnline: newUsers.map(u => u.handle),
+    newShips: newShips.map(s => s.author),
+    context,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+/**
+ * Trigger after git commit
+ */
+async function afterCommit(commitMessage = '', branch = '') {
+  return check(TRIGGERS.COMMIT, { commitMessage, branch });
+}
+
+/**
+ * Trigger after test completion
+ */
+async function afterTest(passed = true, testOutput = '') {
+  const trigger = passed ? TRIGGERS.TEST_PASS : TRIGGERS.TEST_FAIL;
+  return check(trigger, { passed, testOutput: testOutput.slice(0, 200) });
+}
+
+/**
+ * Trigger after build completion
+ */
+async function afterBuild(success = true, buildOutput = '') {
+  const trigger = success ? TRIGGERS.BUILD_COMPLETE : TRIGGERS.BUILD_FAIL;
+  return check(trigger, { success, buildOutput: buildOutput.slice(0, 200) });
+}
+
+/**
+ * Trigger on natural break (between tasks, file saves, etc.)
+ */
+async function onNaturalBreak(activity = '') {
+  return check(TRIGGERS.NATURAL_BREAK, { activity });
+}
+
+/**
+ * Explicit check (user requested)
+ */
+async function checkNow() {
+  return check(TRIGGERS.EXPLICIT);
+}
+
+/**
+ * Get check stats
+ */
+function getStats() {
+  const state = loadState();
+  const now = Date.now();
+
+  return {
+    lastCheck: state.lastCheck ? new Date(state.lastCheck).toISOString() : null,
+    lastTrigger: state.lastTrigger,
+    checkCount: state.checkCount,
+    todayTriggers: state.triggersToday?.counts || {},
+    timeSinceLastCheck: state.lastCheck ? Math.floor((now - state.lastCheck) / 1000) : null,
+  };
+}
+
+module.exports = {
+  TRIGGERS,
+  check,
+  afterCommit,
+  afterTest,
+  afterBuild,
+  onNaturalBreak,
+  checkNow,
+  getStats,
+  shouldCheck,
+};

package/store/api.js

@@ -17,6 +17,30 @@ const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
 // Default timeout for API requests (10 seconds)
 const REQUEST_TIMEOUT = 10000;
 
+// Retry configuration
+const MAX_RETRIES = 3;
+const INITIAL_RETRY_DELAY = 500; // 500ms
+const MAX_RETRY_DELAY = 5000; // 5 seconds
+
+/**
+ * Calculate exponential backoff delay with jitter
+ * @param {number} attempt - Current attempt number (0-based)
+ * @returns {number} Delay in milliseconds
+ */
+function getBackoffDelay(attempt) {
+  const exponentialDelay = INITIAL_RETRY_DELAY * Math.pow(2, attempt);
+  const jitter = Math.random() * 0.3 * exponentialDelay; // 0-30% jitter
+  return Math.min(exponentialDelay + jitter, MAX_RETRY_DELAY);
+}
+
+/**
+ * Sleep for a given duration
+ * @param {number} ms - Milliseconds to sleep
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
 /**
  * Force reload of config module to pick up auth changes
  * This clears the require cache and reloads the config from disk
@@ -34,7 +58,10 @@ function reloadConfig() {
   }
 }
 
-function request(method, path, data = null, options = {}) {
+/**
+ * Internal single request (no retries)
+ */
+function requestOnce(method, path, data = null, options = {}) {
   return new Promise((resolve, reject) => {
     const url = new URL(path, API_URL);
     const isHttps = url.protocol === 'https:';
@@ -124,11 +151,11 @@ function request(method, path, data = null, options = {}) {
     // Handle timeout
     req.on('timeout', () => {
       req.destroy();
-      resolve({ success: false, error: 'Request timeout', timeout: true });
+      resolve({ success: false, error: 'Request timeout', timeout: true, retryable: true });
     });
 
     req.on('error', (e) => {
-      resolve({ success: false, error: e.message, network: true });
+      resolve({ success: false, error: e.message, network: true, retryable: true });
     });
 
     if (data) {
@@ -138,6 +165,40 @@ function request(method, path, data = null, options = {}) {
   });
 }
 
+/**
+ * Make HTTP request with exponential backoff retry for transient failures
+ */
+async function request(method, path, data = null, options = {}) {
+  const maxRetries = options.maxRetries ?? MAX_RETRIES;
+  const skipRetry = options._skipRetry || false;
+
+  // Don't retry if explicitly disabled or already in a retry chain
+  if (skipRetry || maxRetries === 0) {
+    return requestOnce(method, path, data, options);
+  }
+
+  let lastResult;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    lastResult = await requestOnce(method, path, data, { ...options, _skipRetry: true });
+
+    // Success or non-retryable error - return immediately
+    if (!lastResult.retryable) {
+      return lastResult;
+    }
+
+    // Don't retry on last attempt
+    if (attempt < maxRetries) {
+      const delay = getBackoffDelay(attempt);
+      console.error(`[api] Retrying ${method} ${path} in ${Math.round(delay)}ms (attempt ${attempt + 1}/${maxRetries})`);
+      await sleep(delay);
+    }
+  }
+
+  // All retries exhausted
+  console.error(`[api] All ${maxRetries} retries failed for ${method} ${path}`);
+  return lastResult;
+}
+
 // ============ PRESENCE ============
 
 // Use v2 API by default (Postgres-backed)
@@ -318,7 +379,23 @@ async function getActiveUsers() {
 }
 
 async function setVisibility(handle, visible) {
-  // TODO: implement visibility toggle API
+  try {
+    const endpoint = USE_V2_PRESENCE ? '/api/v2/presence' : '/api/presence';
+    const result = await request('POST', endpoint, {
+      action: 'visibility',
+      visible: visible
+    });
+
+    if (result.success === false) {
+      console.error('[setVisibility] API error:', result.error);
+      return { success: false, error: result.error };
+    }
+
+    return { success: true, visible };
+  } catch (e) {
+    console.error('[setVisibility] Error:', e.message);
+    return { success: false, error: e.message };
+  }
 }
 
 // ============ MESSAGES ============
@@ -512,6 +589,22 @@ async function getUnreadCount(handle) {
   }
 }
 
+/**
+ * Get count of active live broadcasts
+ * Used in presence footer to show "X live now"
+ */
+async function getLiveBroadcastCount() {
+  try {
+    const result = await request('GET', '/api/watch', null, { auth: false });
+    if (result.broadcasts) {
+      return Object.keys(result.broadcasts).length;
+    }
+    return 0;
+  } catch (e) {
+    return 0;
+  }
+}
+
 // Get raw inbox messages (for notification checks)
 // V2: Fetches threads and constructs message objects from unread threads
 // Read state is synced via Postgres cursors, so if you read on iOS it's reflected here
@@ -1096,6 +1189,9 @@ module.exports = {
   markMessagesDelivered,
   searchMessages,
 
+  // Watch Me Code
+  getLiveBroadcastCount,
+
   // Consent
   getConsentStatus,
   getPendingConsents,

package/tools/broadcast.js

@@ -6,12 +6,13 @@
  *
  * Commands:
  * - broadcast start "Building X"  → Start streaming
- * - broadcast stop                → End + show stats
+ * - 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',
@@ -74,12 +75,18 @@ async function handler(args) {
         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()
+        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
@@ -109,12 +116,29 @@ async function handler(args) {
     }
 
     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
+          roomId: broadcast.roomId,
+          // Include git bundle if available
+          gitBundle: bundlePayload,
         })
       });
 
@@ -136,10 +160,25 @@ async function handler(args) {
 
       let display = `📺 Broadcast ended\n\n`;
       display += `**Duration:** ${formatDuration(duration)}\n`;
-      display += `**Room:** ${broadcast.roomId}\n\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`;
 
-      // Suggest saving as session
-      if (data.suggestions) {
+      // 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`;