slashvibe-mcp 0.2.2 → 0.2.4

package/store/api.js

@@ -10,12 +10,30 @@ const https = require('https');
 const http = require('http');
 const config = require('../config');
 const crypto = require('../crypto');
+const authStore = require('../auth-store');
 
 const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
 
 // Default timeout for API requests (10 seconds)
 const REQUEST_TIMEOUT = 10000;
 
+/**
+ * Force reload of config module to pick up auth changes
+ * This clears the require cache and reloads the config from disk
+ */
+function reloadConfig() {
+  try {
+    // Clear the config module from require cache
+    const configPath = require.resolve('../config');
+    delete require.cache[configPath];
+    // Re-require to get fresh module
+    return require('../config');
+  } catch (e) {
+    console.error('[api] Failed to reload config:', e.message);
+    return config;
+  }
+}
+
 function request(method, path, data = null, options = {}) {
   return new Promise((resolve, reject) => {
     const url = new URL(path, API_URL);
@@ -28,8 +46,9 @@ function request(method, path, data = null, options = {}) {
       'User-Agent': 'vibe-mcp/1.0'
     };
 
-    // Add auth token if provided or if we have one stored
-    const token = options.token || config.getAuthToken();
+    // Add auth token: priority is explicit option > in-memory store > config file
+    // authStore is the SOURCE OF TRUTH during runtime (immediate updates from OAuth)
+    const token = options.token || authStore.getToken() || config.getAuthToken();
     if (token && options.auth !== false) {
       headers['Authorization'] = `Bearer ${token}`;
     }
@@ -46,9 +65,45 @@ function request(method, path, data = null, options = {}) {
     const req = client.request(reqOptions, (res) => {
       let body = '';
       res.on('data', chunk => body += chunk);
-      res.on('end', () => {
+      res.on('end', async () => {
         // Handle non-2xx responses
         if (res.statusCode >= 400) {
+          // 401 REFRESH: If unauthorized and haven't retried, try to recover
+          if (res.statusCode === 401 && !options._retried && options.auth !== false) {
+            console.error('[api] 401 received, attempting token refresh...');
+
+            // First, reload config from disk (in case token was saved but not pushed to store)
+            const freshConfig = reloadConfig();
+            const diskToken = freshConfig.getAuthToken();
+
+            // If disk has a different token, sync it to the auth store
+            if (diskToken && diskToken !== authStore.getToken()) {
+              console.error('[api] Found newer token on disk, syncing to auth store...');
+              authStore.setToken(diskToken);
+            }
+
+            // Now check if we have a fresh token to retry with
+            const freshToken = authStore.getToken() || diskToken;
+
+            // Only retry if we got a different/new token
+            if (freshToken && freshToken !== token) {
+              console.error('[api] Found fresh token, retrying request...');
+              try {
+                const retryResult = await request(method, path, data, {
+                  ...options,
+                  token: freshToken,
+                  _retried: true
+                });
+                resolve(retryResult);
+                return;
+              } catch (retryError) {
+                console.error('[api] Retry failed:', retryError.message);
+              }
+            } else {
+              console.error('[api] No fresh token found, not retrying');
+            }
+          }
+
           try {
             const parsed = JSON.parse(body);
             resolve({ success: false, error: parsed.error || `HTTP ${res.statusCode}`, statusCode: res.statusCode });
@@ -114,8 +169,8 @@ async function registerSession(sessionId, handle, building = null, publicKey = n
       // Use server-issued sessionId and token (not client-generated)
       currentSessionId = result.sessionId;
 
-      // Save token for future authenticated requests
-      config.setAuthToken(result.token, result.sessionId);
+      // Save token for future authenticated requests (persist to shared config)
+      config.savePrivyToken(result.token);
 
       console.error(`[vibe] Registered @${handle} with session ${result.sessionId}`);
     } else if (result.success) {
@@ -198,7 +253,9 @@ async function getActiveUsers() {
     const result = await request('GET', '/api/presence');
     // Combine active and away users
     const users = [...(result.active || []), ...(result.away || [])];
-    return users.map(u => ({
+
+    // Map to normalized format
+    const mappedUsers = users.map(u => ({
       handle: u.username,
       one_liner: u.workingOn,
       lastSeen: new Date(u.lastSeen).getTime(),
@@ -214,8 +271,29 @@ async function getActiveUsers() {
       branch: u.context?.branch || null,
       repo: u.context?.repo || null,
       error: u.context?.error || null,
-      note: u.context?.note || null
+      note: u.context?.note || null,
+      // Away status
+      awayMessage: u.context?.awayMessage || null,
+      awayAt: u.context?.awayAt || null
     }));
+
+    // Sync presence data to local profiles (non-blocking)
+    // This enables discovery to find users by what they're building
+    try {
+      const profiles = require('./profiles');
+      profiles.syncFromPresence(mappedUsers).then(synced => {
+        if (synced > 0) {
+          // Auto-infer interests for new/updated profiles
+          profiles.inferMissingInterests().catch(e =>
+            console.error('[presence] interest inference failed:', e.message)
+          );
+        }
+      }).catch(e => console.error('[presence] sync failed:', e.message));
+    } catch (e) {
+      // Non-fatal: profiles module may not be available in some contexts
+    }
+
+    return mappedUsers;
   } catch (e) {
     console.error('Who failed:', e.message);
     return [];
@@ -230,26 +308,37 @@ async function setVisibility(handle, visible) {
 
 async function sendMessage(from, to, body, type = 'dm', payload = null) {
   try {
-    // AIRC: Create signed message if we have a keypair
-    const keypair = config.getKeypair();
-
     let data;
-    if (keypair) {
-      // Full AIRC-compliant signed message
-      data = crypto.createSignedMessage({
-        from,
-        to,
-        body: body || undefined,
-        payload: payload || undefined
-      }, keypair.privateKey);
-
-      // Also include 'text' for backward compat with current API
-      if (body) data.text = body;
+
+    // Check if using Privy auth (server-side signing)
+    if (config.hasPrivyAuth()) {
+      // NEW: Privy auth flow - server handles signing
+      // Just send message data, server signs it
+      data = { to, body: body || undefined, text: body };
+      if (payload) data.payload = payload;
+
+      console.error('[vibe] Sending message via Privy auth (server-side signing)');
     } else {
-      // Legacy format (no signing)
-      data = { from, to, text: body };
-      if (payload) {
-        data.payload = payload;
+      // LEGACY: Create signed message if we have a keypair
+      const keypair = config.getKeypair();
+
+      if (keypair) {
+        // Full AIRC-compliant signed message
+        data = crypto.createSignedMessage({
+          from,
+          to,
+          body: body || undefined,
+          payload: payload || undefined
+        }, keypair.privateKey);
+
+        // Also include 'text' for backward compat with current API
+        if (body) data.text = body;
+      } else {
+        // No auth at all - legacy format (no signing)
+        data = { from, to, text: body };
+        if (payload) {
+          data.payload = payload;
+        }
       }
     }
 
@@ -258,7 +347,33 @@ async function sendMessage(from, to, body, type = 'dm', payload = null) {
     // Handle auth errors
     if (!result.success && result.error?.includes('Authentication')) {
       console.error('[vibe] Auth failed for message. Try `vibe init` to re-register.');
-      return null;
+      return { error: 'auth_failed', message: 'Authentication failed. Try `vibe init` to re-register.' };
+    }
+
+    // Handle expired token
+    if (result.statusCode === 401) {
+      console.error('[vibe] Auth expired. Run browser auth to refresh token.');
+      return { error: 'auth_expired', message: 'Auth expired. Run `vibe init` to refresh token.' };
+    }
+
+    // Handle storage errors (KV write failed)
+    if (!result.success && result.error === 'storage_error') {
+      console.error('[vibe] Storage error:', result.details || result.message);
+      return { error: 'storage_error', message: result.message || 'Failed to save message. Please try again.' };
+    }
+
+    // Handle other errors
+    if (!result.success && result.error) {
+      console.error('[vibe] Send error:', result.error, result.message);
+      return { error: result.error, message: result.message || 'Failed to send message.' };
+    }
+
+    // Emit list_changed notification for successful message send
+    // This allows other Claude Code instances to see the new message instantly
+    if (result.success || result.message) {
+      if (global.vibeNotifier) {
+        global.vibeNotifier.emitImmediate(); // Immediate for DMs
+      }
     }
 
     return result.message;
@@ -270,8 +385,16 @@ async function sendMessage(from, to, body, type = 'dm', payload = null) {
 
 async function getInbox(handle) {
   try {
+    // Use unified messages endpoint - returns { inbox, unread, bySender }
     const result = await request('GET', `/api/messages?user=${handle}`);
-    // Group messages by sender into threads
+
+    // Check for API errors (auth failures, etc.)
+    if (result.success === false) {
+      console.error('[getInbox] API error:', result.error, result.message);
+      return [];
+    }
+
+    // Group messages by sender into thread format
     const bySender = result.bySender || {};
     return Object.entries(bySender).map(([sender, messages]) => ({
       handle: sender,
@@ -293,6 +416,7 @@ async function getInbox(handle) {
 
 async function getUnreadCount(handle) {
   try {
+    // Use unified messages endpoint - returns { inbox, unread, bySender }
     const result = await request('GET', `/api/messages?user=${handle}`);
     return result.unread || 0;
   } catch (e) {
@@ -303,6 +427,7 @@ async function getUnreadCount(handle) {
 // Get raw inbox messages (for notification checks)
 async function getRawInbox(handle) {
   try {
+    // Use unified messages endpoint - returns { inbox, unread, bySender }
     const result = await request('GET', `/api/messages?user=${handle}`);
     return result.inbox || [];
   } catch (e) {
@@ -315,6 +440,7 @@ async function getThread(myHandle, theirHandle) {
     const result = await request('GET', `/api/messages?user=${myHandle}&with=${theirHandle}`);
     return (result.thread || []).map(m => ({
       from: m.from,
+      isAgent: m.isAgent || m.is_agent || false, // Support both naming conventions
       body: m.text,
       payload: m.payload || null,
       timestamp: new Date(m.createdAt).getTime(),
@@ -327,7 +453,8 @@ async function getThread(myHandle, theirHandle) {
 }
 
 async function markThreadRead(myHandle, theirHandle) {
-  // Reading thread via API already marks as read
+  // No-op: Backend automatically marks messages as read when getThread() is called
+  // See: api/messages.js thread endpoint (GET /api/messages?user=X&with=Y)
 }
 
 // ============ CONSENT ============
@@ -380,6 +507,94 @@ async function blockUser(from, to) {
   }
 }
 
+// ============ STATS ============
+
+async function getStats() {
+  try {
+    const result = await request('GET', '/api/stats');
+    return result;
+  } catch (e) {
+    console.error('Stats failed:', e.message);
+    return { success: false };
+  }
+}
+
+// ============ INVITES ============
+
+async function generateInviteCode(handle) {
+  try {
+    const result = await request('POST', '/api/invites', { handle });
+    return result;
+  } catch (e) {
+    console.error('Generate invite failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
+async function getMyInvites(handle) {
+  try {
+    const result = await request('GET', `/api/invites/my?handle=${handle}`);
+    return result;
+  } catch (e) {
+    console.error('Get invites failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
+async function submitReport({ reporter, reported, reason, message_id, details }) {
+  const result = await request('POST', '/api/report', {
+    reporter,
+    reported,
+    reason,
+    message_id,
+    details
+  });
+  return result;
+}
+
+async function checkInviteCode(code) {
+  try {
+    const result = await request('GET', `/api/invites?code=${code}`);
+    return result;
+  } catch (e) {
+    console.error('Check invite failed:', e.message);
+    return { valid: false, error: e.message };
+  }
+}
+
+// ============ AUTH ============
+
+/**
+ * Verify a Privy token with the server
+ * @param {string} token - Privy JWT token
+ * @returns {Promise<{valid: boolean, handle?: string, error?: string}>}
+ */
+async function verifyPrivyToken(token) {
+  try {
+    const result = await request('POST', '/api/auth/verify', {}, { token, auth: true });
+
+    if (result.valid) {
+      return {
+        valid: true,
+        handle: result.handle,
+        userId: result.userId,
+        github: result.github,
+        expiresAt: result.expiresAt
+      };
+    }
+
+    return {
+      valid: false,
+      error: result.error || 'Token verification failed'
+    };
+  } catch (e) {
+    return {
+      valid: false,
+      error: e.message
+    };
+  }
+}
+
 // ============ HELPERS ============
 
 function formatTimeAgo(timestamp) {
@@ -395,6 +610,202 @@ function formatTimeAgo(timestamp) {
   return `${Math.floor(seconds / 86400)}d ago`;
 }
 
+// ============ AWAY STATUS ============
+
+// Local cache for away status (also sent to server via heartbeat)
+let awayStatusCache = null;
+
+/**
+ * Set away status with optional message
+ * @param {string} handle - User handle
+ * @param {string} status - 'away' or 'online'
+ * @param {string|null} message - Custom away message
+ */
+async function setAwayStatus(handle, status, message = null) {
+  const awayAt = new Date().toISOString();
+
+  // Cache locally
+  awayStatusCache = {
+    status,
+    message,
+    awayAt
+  };
+
+  // Send via heartbeat to server
+  const one_liner = config.getBuildingMessage?.() || 'Building something';
+  await heartbeat(handle, one_liner, {
+    mood: '☕', // AFK emoji
+    awayMessage: message,
+    awayAt: awayAt
+  });
+
+  return { success: true };
+}
+
+/**
+ * Get current away status
+ * @param {string} handle - User handle
+ */
+async function getAwayStatus(handle) {
+  return awayStatusCache;
+}
+
+/**
+ * Clear away status (user is back)
+ * @param {string} handle - User handle
+ */
+async function clearAwayStatus(handle) {
+  const wasAway = awayStatusCache;
+  awayStatusCache = null;
+
+  // Send heartbeat with cleared away status
+  const one_liner = config.getBuildingMessage?.() || 'Building something';
+  await heartbeat(handle, one_liner, {
+    mood: null, // Clear mood
+    awayMessage: null,
+    awayAt: null
+  });
+
+  return wasAway;
+}
+
+// ============ ONBOARDING ============
+
+/**
+ * Get onboarding checklist status for a user
+ * @param {string} handle - User handle
+ * @returns {Promise<{success: boolean, tasks: Array, progress: Object}>}
+ */
+async function getChecklistStatus(handle) {
+  try {
+    const result = await request('GET', `/api/onboarding/checklist?handle=${encodeURIComponent(handle)}`);
+    return result;
+  } catch (e) {
+    console.error('Get checklist status failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
+// ============ ARTIFACTS ============
+
+/**
+ * Create a new artifact
+ * @param {Object} artifact - Artifact object with all metadata
+ */
+async function createArtifact(artifact) {
+  try {
+    const result = await request('POST', '/api/artifacts', artifact);
+
+    if (result.success === false) {
+      return { success: false, error: result.error || 'API request failed' };
+    }
+
+    if (!result.artifact_id) {
+      return { success: false, error: 'Invalid API response - missing artifact_id' };
+    }
+
+    return {
+      success: true,
+      artifact_id: result.artifact_id,
+      slug: result.slug,
+      url: result.url
+    };
+  } catch (e) {
+    console.error('Create artifact failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Get an artifact by slug
+ * @param {string} slug - Artifact slug
+ */
+async function getArtifact(slug) {
+  try {
+    const result = await request('GET', `/api/artifacts/${slug}`);
+
+    if (result.success === false) {
+      return { success: false, error: result.error || 'Not found' };
+    }
+
+    return {
+      success: true,
+      artifact: result.artifact
+    };
+  } catch (e) {
+    console.error('Get artifact failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Update an artifact by ID or slug
+ * @param {string} idOrSlug - Artifact ID or slug
+ * @param {Object} artifact - Updated artifact data
+ */
+async function updateArtifact(idOrSlug, artifact) {
+  try {
+    const result = await request('PUT', `/api/artifacts/${idOrSlug}`, artifact);
+
+    if (result.success === false) {
+      return { success: false, error: result.error || 'Update failed' };
+    }
+
+    return {
+      success: true,
+      artifact: result.artifact
+    };
+  } catch (e) {
+    console.error('Update artifact failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * List artifacts
+ * @param {Object} options - { scope: 'mine'|'for-me'|'network', handle, limit }
+ */
+async function listArtifacts(options) {
+  try {
+    const { scope, handle, limit = 10 } = options;
+    const params = new URLSearchParams({ scope, handle, limit: limit.toString() });
+    const result = await request('GET', `/api/artifacts?${params}`);
+
+    if (result.success === false) {
+      return { success: false, error: result.error || 'List failed' };
+    }
+
+    return {
+      success: true,
+      artifacts: result.artifacts || [],
+      total: result.total || 0
+    };
+  } catch (e) {
+    console.error('List artifacts failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Send artifact card via DM
+ * @param {string} to - Recipient handle
+ * @param {Object} card - Artifact card data
+ */
+async function sendArtifactCard(to, card) {
+  try {
+    const from = config.getHandle();
+
+    // Format as a rich message with artifact card embedded
+    const body = `📦 ${card.preview.creator} shared an artifact with you:\n\n**${card.preview.title}**\n${card.preview.snippet}\n\n🔗 ${card.url}\n\n_${card.context}_`;
+
+    const result = await sendMessage({ from, to, body });
+    return result;
+  } catch (e) {
+    console.error('Send artifact card failed:', e.message);
+    return { success: false, error: e.message };
+  }
+}
+
 module.exports = {
   // Session
   registerSession,
@@ -422,6 +833,35 @@ module.exports = {
   acceptConsent,
   blockUser,
 
+  // Stats
+  getStats,
+
+  // Invites
+  generateInviteCode,
+  getMyInvites,
+  checkInviteCode,
+
+  // Reports
+  submitReport,
+
   // Helpers
-  formatTimeAgo
+  formatTimeAgo,
+
+  // Away Status
+  setAwayStatus,
+  getAwayStatus,
+  clearAwayStatus,
+
+  // Artifacts
+  createArtifact,
+  getArtifact,
+  updateArtifact,
+  listArtifacts,
+  sendArtifactCard,
+
+  // Onboarding
+  getChecklistStatus,
+
+  // Auth
+  verifyPrivyToken
 };

package/store/index.js

@@ -1,16 +1,16 @@
 /**
  * Store — Chooses local or API based on environment
  *
- * If VIBE_API_URL is set, uses remote API
- * Otherwise uses local JSONL files
+ * Default: uses remote API (production behavior)
+ * Set VIBE_LOCAL=true to use local JSONL files
  */
 
-const useApi = !!process.env.VIBE_API_URL;
+const useLocal = process.env.VIBE_LOCAL === 'true';
 
-if (useApi) {
-  module.exports = require('./api');
-  module.exports.storage = 'api';
-} else {
+if (useLocal) {
   module.exports = require('./local');
   module.exports.storage = 'local';
+} else {
+  module.exports = require('./api');
+  module.exports.storage = 'api';
 }