slashvibe-mcp 0.2.2 → 0.2.4

package/README.md

@@ -60,6 +60,7 @@ The MCP server connects to `slashvibe.dev` for:
 
 ## Related
 
+- [GitHub](https://github.com/VibeCodingInc/vibe-mcp) - Source code
 - [slashvibe.dev](https://slashvibe.dev) - Web presence
 - [Spirit Protocol](https://spiritprotocol.io) - Parent ecosystem
 - [AIRC](https://airc.chat) - Agent identity protocol

package/analytics.js

@@ -0,0 +1,107 @@
+/**
+ * Analytics — Retention event tracking from MCP server
+ *
+ * Logs events to the /api/analytics/event endpoint for measuring
+ * user engagement and retention funnel performance.
+ *
+ * Usage:
+ *   const analytics = require('./analytics');
+ *   analytics.track('empty_inbox_action', { action: 'discover', source: 'inbox' });
+ */
+
+const config = require('./config');
+
+const API_URL = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+/**
+ * Track an analytics event (fire and forget)
+ * @param {string} eventType - Event type (from valid types in api/lib/events.js)
+ * @param {object} data - Additional event data
+ */
+async function track(eventType, data = {}) {
+  const handle = config.getHandle();
+  if (!handle) return; // Skip if not initialized
+
+  try {
+    // Fire and forget - don't await or block
+    fetch(`${API_URL}/api/analytics/events`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type: eventType,
+        handle,
+        data: {
+          ...data,
+          client: 'mcp-server',
+          timestamp: Date.now()
+        }
+      })
+    }).catch(() => {}); // Silently ignore errors
+  } catch (e) {
+    // Analytics should never block or fail user flows
+  }
+}
+
+/**
+ * Track empty inbox interaction
+ * @param {string} action - Which action was taken (or 'none' if user closed)
+ * @param {object} context - Context about the state (hadOnboardingTask, hadRecentShips, etc.)
+ */
+function trackEmptyInbox(action, context = {}) {
+  // Track that user reached empty inbox state
+  track('empty_inbox_reached', {
+    hadRecentThreads: context.recentThreads?.length > 0,
+    hadOnboardingTask: !!context.onboardingTask,
+    hadRecentShips: context.recentShips?.length > 0
+  });
+
+  // If an action was taken, track it
+  if (action && action !== 'none') {
+    track('empty_inbox_action', {
+      action,
+      ...context
+    });
+  }
+}
+
+/**
+ * Track lurk mode state change
+ * @param {boolean} enabled - Whether lurk mode was enabled or disabled
+ */
+function trackLurkMode(enabled) {
+  track(enabled ? 'lurk_mode_enabled' : 'lurk_mode_disabled', {});
+}
+
+/**
+ * Track onboarding task completion
+ * @param {string} taskId - The task that was completed
+ */
+function trackOnboardingTask(taskId) {
+  track('onboarding_task_completed', { taskId });
+}
+
+/**
+ * Track discovery initiation
+ * @param {string} source - Where discovery was initiated from (inbox, start, etc.)
+ */
+function trackDiscovery(source) {
+  track('discovery_initiated', { source });
+}
+
+/**
+ * Track session lifecycle
+ * @param {string} event - 'started' or 'ended'
+ * @param {object} sessionData - Session metrics (duration, actions, etc.)
+ */
+function trackSession(event, sessionData = {}) {
+  track(event === 'started' ? 'session_started' : 'session_ended', sessionData);
+}
+
+module.exports = {
+  track,
+  trackEmptyInbox,
+  trackLurkMode,
+  trackOnboardingTask,
+  trackDiscovery,
+  trackSession
+};

package/config.js

@@ -66,7 +66,15 @@ function save(config) {
     publicKey: config.publicKey || existing.publicKey || null,
     privateKey: config.privateKey || existing.privateKey || null,
     // Guided mode (AskUserQuestion menus)
-    guided_mode: config.guided_mode !== undefined ? config.guided_mode : existing.guided_mode
+    guided_mode: config.guided_mode !== undefined ? config.guided_mode : existing.guided_mode,
+    // Notification level
+    notifications: config.notifications || existing.notifications || null,
+    // GitHub Activity settings
+    github_activity_enabled: config.github_activity_enabled !== undefined ? config.github_activity_enabled : existing.github_activity_enabled,
+    github_activity_privacy: config.github_activity_privacy || existing.github_activity_privacy || null,
+    // Privy OAuth token (persisted across MCP process restarts)
+    privyToken: config.privyToken || existing.privyToken || null,
+    authMethod: config.authMethod || existing.authMethod || null
   };
   fs.writeFileSync(PRIMARY_CONFIG, JSON.stringify(data, null, 2));
 }
@@ -203,8 +211,80 @@ function setAuthToken(token, sessionId = null) {
 }
 
 function getAuthToken() {
+  // First check session data
+  const data = getSessionData();
+  if (data?.token) return data.token;
+
+  // Fall back to shared config (persisted across MCP process restarts)
+  const cfg = load();
+  return cfg?.privyToken || null;
+}
+
+/**
+ * Save Privy JWT token (used after browser OAuth flow)
+ * @param {string} token - Privy access token
+ */
+function savePrivyToken(token) {
+  // Save to session data
+  const data = getSessionData() || {};
+  saveSessionData({
+    ...data,
+    sessionId: data.sessionId || generateSessionId(),
+    token,
+    authMethod: 'privy'  // Track that this is a Privy token
+  });
+
+  // Also save to shared config for persistence across MCP restarts
+  const cfg = load();
+  cfg.privyToken = token;
+  cfg.authMethod = 'privy';
+  save(cfg);
+}
+
+/**
+ * Check if user has Privy auth (vs legacy keypair)
+ * Accepts both 'privy' and 'browser' as valid auth methods
+ */
+function hasPrivyAuth() {
+  const validAuthMethods = ['privy', 'browser'];
+
   const data = getSessionData();
-  return data?.token || null;
+  if (validAuthMethods.includes(data?.authMethod) && data?.token) return true;
+
+  const cfg = load();
+  return validAuthMethods.includes(cfg?.authMethod) && cfg?.privyToken;
+}
+
+/**
+ * Remove keypair after migration to Privy
+ * Clears private key from config (security improvement)
+ */
+function removeKeypair() {
+  const cfg = load();
+  delete cfg.publicKey;
+  delete cfg.privateKey;
+  save(cfg);
+
+  // Also clear from session
+  const data = getSessionData();
+  if (data) {
+    delete data.publicKey;
+    delete data.privateKey;
+    saveSessionData(data);
+  }
+}
+
+/**
+ * Get auth URL for browser-based GitHub OAuth
+ * @param {string|null} handle - Custom handle (optional - defaults to GitHub username)
+ */
+function getAuthUrl(handle = null) {
+  const apiUrl = getApiUrl();
+  if (handle) {
+    return `${apiUrl}/api/auth/github?handle=${encodeURIComponent(handle)}`;
+  }
+  // No handle = use GitHub username as handle
+  return `${apiUrl}/api/auth/github`;
 }
 
 function clearSession() {
@@ -228,6 +308,81 @@ function setGuidedMode(enabled) {
   save(config);
 }
 
+// Notification settings
+// Levels: "all" | "mentions" | "off"
+// - all: desktop + bell for unread, mentions, presence (default)
+// - mentions: only @mentions trigger notifications
+// - off: no notifications
+function getNotifications() {
+  const config = load();
+  return config.notifications || 'all';
+}
+
+function setNotifications(level) {
+  const validLevels = ['all', 'mentions', 'off'];
+  if (!validLevels.includes(level)) {
+    throw new Error(`Invalid notification level. Use: ${validLevels.join(', ')}`);
+  }
+  const config = load();
+  config.notifications = level;
+  save(config);
+}
+
+// GitHub Activity settings
+// Shows shipping status based on GitHub commit activity
+// Default: false (opt-in for privacy)
+function getGithubActivityEnabled() {
+  const config = load();
+  return config.github_activity_enabled === true;
+}
+
+function setGithubActivityEnabled(enabled) {
+  const config = load();
+  config.github_activity_enabled = enabled;
+  save(config);
+}
+
+// GitHub Activity privacy level
+// Levels: "full" | "status_only" | "off"
+// - full: Show repos, commit counts, tech stack (default when enabled)
+// - status_only: Just show shipping badge (🔥/⚡), no details
+// - off: Disabled completely
+function getGithubActivityPrivacy() {
+  const config = load();
+  return config.github_activity_privacy || 'full';
+}
+
+function setGithubActivityPrivacy(level) {
+  const validLevels = ['full', 'status_only', 'off'];
+  if (!validLevels.includes(level)) {
+    throw new Error(`Invalid privacy level. Use: ${validLevels.join(', ')}`);
+  }
+  const config = load();
+  config.github_activity_privacy = level;
+  save(config);
+}
+
+// API URL — central endpoint for all API calls
+function getApiUrl() {
+  return process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+}
+
+// ─────────────────────────────────────────────────────────────
+// Generic key-value store for ephemeral session state
+// Used by presence-agent, mute, and other tools for runtime state
+// NOT persisted to disk — resets when MCP server restarts
+// ─────────────────────────────────────────────────────────────
+const sessionState = {};
+
+function get(key, defaultValue = null) {
+  return sessionState[key] !== undefined ? sessionState[key] : defaultValue;
+}
+
+function set(key, value) {
+  sessionState[key] = value;
+  return value;
+}
+
 module.exports = {
   VIBE_DIR,
   CONFIG_FILE,
@@ -248,5 +403,21 @@ module.exports = {
   clearSession,
   generateSessionId,
   getGuidedMode,
-  setGuidedMode
+  setGuidedMode,
+  getNotifications,
+  setNotifications,
+  // GitHub Activity settings
+  getGithubActivityEnabled,
+  setGithubActivityEnabled,
+  getGithubActivityPrivacy,
+  setGithubActivityPrivacy,
+  getApiUrl,
+  // Privy OAuth helpers
+  savePrivyToken,
+  hasPrivyAuth,
+  removeKeypair,
+  getAuthUrl,
+  // Generic key-value for ephemeral session state
+  get,
+  set
 };

package/index.js

@@ -10,9 +10,11 @@ const presence = require('./presence');
 const config = require('./config');
 const store = require('./store');
 const prompts = require('./prompts');
+const NotificationEmitter = require('./notification-emitter');
+const authStore = require('./auth-store');
 
 // Tools that shouldn't show presence footer (would be redundant/noisy)
-const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update'];
+const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update', 'vibe_settings', 'vibe_notifications'];
 
 // Infer user prompt from tool arguments (for pattern logging)
 function inferPromptFromArgs(toolName, args) {
@@ -35,15 +37,30 @@ function inferPromptFromArgs(toolName, args) {
     case 'context': return 'share context';
     case 'summarize': return 'summarize session';
     case 'bye': return 'end session';
-    case 'remember': return `remember about ${handle}`;
-    case 'recall': return `recall ${handle}`;
-    case 'forget': return `forget ${handle}`;
     case 'board': return args.content ? 'post to board' : 'view board';
+    case 'observe': return args.content ? 'record observation' : 'view observations';
     case 'invite': return 'generate invite';
     case 'echo': return 'send feedback';
     case 'x_mentions': return 'check x mentions';
     case 'x_reply': return 'reply on x';
     case 'handoff': return `handoff task to ${handle}`;
+    case 'reserve': return args.paths ? `reserve ${args.paths.join(', ')}` : 'reserve files';
+    case 'release': return `release ${args.reservation_id || 'reservation'}`;
+    case 'reservations': return 'list reservations';
+    case 'solo_game': return `play ${args.game || 'game'}`;
+    case 'game': return `play ${args.game || 'game'} with ${handle}`;
+    case 'multiplayer_game': return `multiplayer ${args.game || 'game'}`;
+    case 'drawing': return args.action ? `drawing ${args.action}` : 'collaborative drawing';
+    case 'crossword': return `crossword ${args.action || 'daily'}`;
+    case 'discover': return `discover ${args.command || 'suggest'}`;
+    case 'suggest_tags': return `suggest tags ${args.command || 'suggest'}`;
+    case 'settings': return args.mute ? `mute for ${args.mute}` : 'view settings';
+    case 'create_artifact': return `create ${args.template || 'artifact'}: ${args.title || 'untitled'}`;
+    case 'view_artifact': return args.slug ? `view artifact ${args.slug}` : `list ${args.list || 'artifacts'}`;
+    case 'broadcast': return args.action ? `broadcast ${args.action}` : 'broadcast status';
+    case 'watch': return args.target ? `watch ${args.target}` : 'list live broadcasts';
+    case 'session': return args.action ? `session ${args.action}` : 'list sessions';
+    case 'chat': return args.message ? `chat "${args.message.slice(0, 30)}..."` : 'view chat';
     default: return `${action} ${handle}`.trim() || null;
   }
 }
@@ -145,12 +162,14 @@ async function getPresenceFooter() {
   }
 }
 
-// Load all tools
-const tools = {
+// Load core tools (always available)
+const coreTools = {
   // Entry point
   vibe_start: require('./tools/start'),
   // Core
   vibe_init: require('./tools/init'),
+  vibe_token: require('./tools/token'),  // Privy OAuth token setter
+  vibe_migrate: require('./tools/migrate'),  // Migrate existing handle to GitHub auth
   vibe_who: require('./tools/who'),
   vibe_ping: require('./tools/ping'),
   vibe_react: require('./tools/react'),
@@ -159,25 +178,56 @@ const tools = {
   vibe_open: require('./tools/open'),
   vibe_status: require('./tools/status'),
   vibe_context: require('./tools/context'),
+  vibe_work_summary: require('./tools/work-summary'),  // Ambient context for composing messages
   vibe_summarize: require('./tools/summarize'),
   vibe_bye: require('./tools/bye'),
   vibe_game: require('./tools/game'),
+  vibe_solo_game: require('./tools/solo-game'),
+  vibe_party_game: require('./tools/party-game'),
+  vibe_multiplayer_game: require('./tools/multiplayer-game'),
+  vibe_drawing: require('./tools/drawing'),
+  vibe_crossword: require('./tools/crossword'),
   // AIRC Handoff (v1) — context portability
   vibe_handoff: require('./tools/handoff'),
-  // Memory tools (Tier 1 — Collaborative Memory)
-  vibe_remember: require('./tools/remember'),
-  vibe_recall: require('./tools/recall'),
-  vibe_forget: require('./tools/forget'),
+  // File reservations (advisory locks)
+  vibe_reserve: require('./tools/reserve'),
+  vibe_release: require('./tools/release'),
+  vibe_reservations: require('./tools/reservations'),
+  // Memory tools removed — simplified UX
   // Consent (AIRC compliance)
   vibe_consent: require('./tools/consent'),
+  // Trust & Safety
+  vibe_report: require('./tools/report'),
+  // Support
+  vibe_help: require('./tools/help'),
+  vibe_agents: require('./tools/agents'),
   // Community
   vibe_invite: require('./tools/invite'),
-  vibe_board: require('./tools/board'),
   vibe_submit: require('./tools/submit'),
-  // Diagnostics
-  vibe_test: require('./tools/test'),
-  vibe_doctor: require('./tools/doctor'),
-  vibe_update: require('./tools/update'),
+  vibe_observe: require('./tools/observe'),
+  // Creative Layer — Ideas, Requests, Ships
+  vibe_idea: require('./tools/idea'),
+  vibe_request: require('./tools/request'),
+  vibe_ship: require('./tools/ship'),
+  vibe_feed: require('./tools/feed'),
+  vibe_insights: require('./tools/insights'),
+  // Launch Analytics — Real-time metrics dashboard
+  vibe_analytics: require('./tools/analytics'),
+  // Artifacts — Just-in-time social objects
+  vibe_create_artifact: require('./tools/artifact-create'),
+  vibe_view_artifact: require('./tools/artifact-view'),
+  // Plans — Async approval workflow
+  vibe_plan: require('./tools/plan'),
+  vibe_approve: require('./tools/approve'),
+  // Discovery & Matchmaking
+  vibe_discover: require('./tools/discover'),
+  vibe_suggest_tags: require('./tools/suggest-tags'),
+  // Follow system
+  vibe_follow: require('./tools/follow'),
+  // GitHub friends import (Plaxo move)
+  vibe_friends: require('./tools/friends'),
+  // Scheduling
+  vibe_schedule: require('./tools/schedule'),
   // @echo feedback agent (by Flynn)
   vibe_echo: require('./tools/echo'),
   // X/Twitter bridge
@@ -186,19 +236,83 @@ const tools = {
   // Unified social inbox (Phase 1a)
   vibe_social_inbox: require('./tools/social-inbox'),
   vibe_social_post: require('./tools/social-post'),
-  // Language evolution
-  vibe_patterns: require('./tools/patterns')
+  // Settings
+  vibe_settings: require('./tools/settings'),
+  // External notification channels
+  vibe_notifications: require('./tools/notifications'),
+  // Background presence agent (Claude Code 2.1)
+  vibe_presence_agent: require('./tools/presence-agent'),
+  // Onboarding checklist
+  vibe_onboarding: require('./tools/onboarding'),
+  // VIBE L2 tools
+  vibe_l2: require('./tools/l2'),
+  vibe_l2_status: require('./tools/l2-status'),
+  vibe_shipback: require('./tools/shipback'),
+  vibe_bridge: require('./tools/l2-bridge'),
+  // Gig Marketplace & Proof-of-Work
+  vibe_gig_browse: require('./tools/gig-browse'),
+  vibe_gig_complete: require('./tools/gig-complete'),
+  vibe_proof_of_work: require('./tools/proof-of-work'),
+  vibe_artifacts_price: require('./tools/artifacts-price'),
+  // Watch Me Code — Live broadcasting & sessions
+  vibe_broadcast: require('./tools/broadcast'),
+  vibe_watch: require('./tools/watch'),
+  vibe_session: require('./tools/session'),
+  vibe_chat: require('./tools/chat'),
+  // Help Signal — Symbiosis layer
+  vibe_stuck: require('./tools/stuck'),
+  // VIBE Economy — Earnings, Withdrawals, Subscriptions
+  vibe_earnings: require('./tools/earnings'),
+  vibe_withdraw: require('./tools/withdraw'),
+  vibe_session_price: require('./tools/session_price'),
+  vibe_subscribe: require('./tools/subscribe'),
+  vibe_subscriptions: require('./tools/subscriptions')
 };
 
+// Admin tools (only loaded when VIBE_ADMIN=true)
+const adminTools = process.env.VIBE_ADMIN === 'true' ? {
+  vibe_admin_inbox: require('./tools/admin-inbox'),
+  vibe_test: require('./tools/test'),
+  vibe_doctor: require('./tools/doctor'),
+  vibe_update: require('./tools/update'),
+  vibe_patterns: require('./tools/patterns'),
+} : {};
+
+// Combine tools
+const tools = { ...coreTools, ...adminTools };
+
 /**
  * MCP Protocol Handler
  */
 class VibeMCPServer {
   constructor() {
+    // Hydrate auth state from disk FIRST (before any tools need it)
+    authStore.hydrate();
+
+    // Initialize notification emitter
+    this.notifier = new NotificationEmitter(this);
+
+    // Make notifier globally accessible for tools and store layer
+    global.vibeNotifier = this.notifier;
+
     // Start presence heartbeat
     presence.start();
   }
 
+  /**
+   * Send MCP notification
+   * Called by NotificationEmitter to push list_changed events
+   */
+  notification(payload) {
+    // Send notification via stdout (MCP protocol)
+    const notification = {
+      jsonrpc: '2.0',
+      method: payload.method,
+      params: payload.params || {}
+    };
+    process.stdout.write(JSON.stringify(notification) + '\n');
+  }
+
   async handleRequest(request) {
     const { method, params, id } = request;
 
@@ -252,34 +366,32 @@ class VibeMCPServer {
 
           const result = await tool.handler(args);
 
+          // Emit list_changed notification for state-changing tools
+          // This triggers Claude to refresh without reconnection
+          const stateChangingTools = [
+            'vibe_dm', 'vibe_ping', 'vibe_react',
+            'vibe_status', 'vibe_context', 'vibe_handoff',
+            'vibe_reserve', 'vibe_release',
+            'vibe_broadcast', 'vibe_session', 'vibe_chat'
+          ];
+          if (stateChangingTools.includes(params.name)) {
+            // Debounced notification (prevents spam)
+            global.vibeNotifier?.emitChange(params.name);
+          }
+
           // Add ambient presence footer (unless tool is in skip list)
           let footer = '';
           if (!SKIP_FOOTER_TOOLS.includes(params.name)) {
             footer = await getPresenceFooter();
           }
 
-          // Build hint indicator for Claude to trigger dashboard flows
-          let hintIndicator = '';
-          if (result.hint || result.actions) {
-            const hintData = {
-              ...(result.hint && { hint: result.hint }),
-              ...(result.suggestion && { suggestion: result.suggestion }),
-              ...(result.unread_count && { unread_count: result.unread_count }),
-              ...(result.for_handle && { for_handle: result.for_handle }),
-              ...(result.memories && { memories: result.memories }),
-              ...(result.threads && { threads: result.threads }),
-              ...(result.actions && { actions: result.actions })
-            };
-            hintIndicator = `\n\n<!-- vibe:dashboard ${JSON.stringify(hintData)} -->`;
-          }
-
           return {
             jsonrpc: '2.0',
             id,
             result: {
               content: [{
                 type: 'text',
-                text: (result.display || JSON.stringify(result, null, 2)) + hintIndicator + footer
+                text: (result.display || JSON.stringify(result, null, 2)) + footer
               }]
             }
           };
@@ -333,9 +445,26 @@ class VibeMCPServer {
     process.stderr.write('vibe init → set identity\n');
     process.stderr.write('vibe who  → see who\'s around\n');
     process.stderr.write('vibe dm   → send a message\n\n');
+
+    // Check for updates (non-blocking)
+    this.checkForUpdates();
+  }
+
+  async checkForUpdates() {
+    try {
+      const { checkForUpdates, formatUpdateNotification } = await import('./auto-update.js');
+      const update = await checkForUpdates();
+
+      if (update) {
+        const notification = formatUpdateNotification(update);
+        process.stderr.write(notification);
+      }
+    } catch (error) {
+      // Silent fail - don't block startup
+    }
   }
 }
 
 // Start
 const server = new VibeMCPServer();
-server.start();
+server.start();

package/intelligence/index.js

@@ -0,0 +1,45 @@
+/**
+ * Intelligence Module — Ambient Social Awareness
+ *
+ * Five layers of intelligence:
+ * 1. Infer — Smart state detection from context signals
+ * 2. Serendipity — Surface meaningful coincidences
+ * 3. Proactive — Background agent for social moments
+ * 4. Patterns — Persistent behavioral memory (work, social, creative)
+ * 5. Interests — Live interest inference from context (Phase 2)
+ */
+
+const infer = require('./infer');
+const serendipity = require('./serendipity');
+const proactive = require('./proactive');
+const patterns = require('./patterns');
+const interests = require('./interests');
+
+module.exports = {
+  // Inference
+  inferState: infer.inferState,
+  enhanceUserWithInference: infer.enhanceUserWithInference,
+  enhanceUsersWithInference: infer.enhanceUsersWithInference,
+  STATES: infer.STATES,
+
+  // Serendipity
+  findSerendipity: serendipity.findSerendipity,
+  getTopSerendipity: serendipity.getTopSerendipity,
+  getAllSerendipity: serendipity.getAllSerendipity,
+
+  // Proactive
+  generateProactiveSuggestions: proactive.generateProactiveSuggestions,
+  getProactiveSummary: proactive.getProactiveSummary,
+  checkProactiveOpportunities: proactive.checkProactiveOpportunities,
+  markAway: proactive.markAway,
+  markBack: proactive.markBack,
+  setSessionStart: proactive.setSessionStart,
+
+  // Patterns (persistent behavioral memory)
+  patterns,
+
+  // Interests (live context inference - Phase 2)
+  inferLiveInterests: interests.inferLiveInterests,
+  mergeInterests: interests.mergeInterests,
+  formatLiveInterests: interests.formatLiveInterests
+};