slashvibe-mcp 0.2.9 → 0.3.13

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/auth-store.js

@@ -0,0 +1,148 @@
+/**
+ * Auth Store - In-memory singleton for authentication state
+ *
+ * This is the SOURCE OF TRUTH for auth during MCP runtime.
+ * File persistence (config.json) is only for durability across restarts.
+ *
+ * Why this exists:
+ * - OAuth callback and API calls happen in the same MCP process
+ * - File-based auth was unreliable due to per-PID session files and caching
+ * - In-memory state is immediate and deterministic
+ *
+ * Usage:
+ * - Startup: authStore.hydrate() loads from disk once
+ * - OAuth: authStore.setToken(token) updates immediately
+ * - API calls: authStore.getToken() returns current token (no file I/O)
+ */
+
+// In-memory state - the single source of truth during runtime
+let _token = null;
+let _handle = null;
+let _oneLiner = null;
+let _hydrated = false;
+
+/**
+ * Hydrate auth state from disk (call once at MCP startup)
+ * This loads persisted state from config.json
+ */
+function hydrate() {
+  if (_hydrated) return; // Only hydrate once
+
+  try {
+    const config = require('./config');
+    const cfg = config.load();
+
+    _token = cfg.authToken || cfg.privyToken || null;
+    _handle = cfg.handle || cfg.username || null;
+    _oneLiner = cfg.one_liner || cfg.workingOn || null;
+    _hydrated = true;
+
+    if (_token) {
+      console.error('[auth-store] Hydrated from disk: @' + _handle);
+    } else {
+      console.error('[auth-store] Hydrated from disk: no token');
+    }
+  } catch (e) {
+    console.error('[auth-store] Hydration failed:', e.message);
+  }
+}
+
+/**
+ * Set auth token (call after OAuth completes)
+ * @param {string} token - JWT token
+ */
+function setToken(token) {
+  const hadToken = !!_token;
+  _token = token;
+
+  if (!hadToken && token) {
+    console.error('[auth-store] Token set (was empty)');
+  } else if (hadToken && token && token !== _token) {
+    console.error('[auth-store] Token updated');
+  }
+}
+
+/**
+ * Get current auth token
+ * @returns {string|null} Current token or null
+ */
+function getToken() {
+  return _token;
+}
+
+/**
+ * Set user handle
+ * @param {string} handle - User handle (without @)
+ */
+function setHandle(handle) {
+  _handle = handle;
+}
+
+/**
+ * Get current handle
+ * @returns {string|null} Current handle or null
+ */
+function getHandle() {
+  return _handle;
+}
+
+/**
+ * Set one-liner (what user is building)
+ * @param {string} oneLiner - One-liner description
+ */
+function setOneLiner(oneLiner) {
+  _oneLiner = oneLiner;
+}
+
+/**
+ * Get current one-liner
+ * @returns {string|null} Current one-liner or null
+ */
+function getOneLiner() {
+  return _oneLiner;
+}
+
+/**
+ * Check if user is authenticated
+ * @returns {boolean} True if token exists
+ */
+function isAuthenticated() {
+  return !!_token;
+}
+
+/**
+ * Clear all auth state (for logout/reset)
+ */
+function clear() {
+  _token = null;
+  _handle = null;
+  _oneLiner = null;
+  console.error('[auth-store] Cleared');
+}
+
+/**
+ * Get full auth state (for debugging)
+ * @returns {object} Current auth state
+ */
+function getState() {
+  return {
+    token: _token ? _token.substring(0, 20) + '...' : null,
+    handle: _handle,
+    oneLiner: _oneLiner,
+    hydrated: _hydrated,
+    isAuthenticated: !!_token
+  };
+}
+
+module.exports = {
+  hydrate,
+  setToken,
+  getToken,
+  setHandle,
+  getHandle,
+  setOneLiner,
+  getOneLiner,
+  isAuthenticated,
+  clear,
+  getState
+};

package/auto-update.js

@@ -0,0 +1,130 @@
+/**
+ * Auto-update mechanism for /vibe MCP server
+ * Checks for updates and prompts user to update
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const fs = require('fs').promises;
+const path = require('path');
+
+const execAsync = promisify(exec);
+
+async function checkForUpdates() {
+  try {
+    // Read local version
+    const versionPath = path.join(__dirname, 'version.json');
+    const localVersion = JSON.parse(await fs.readFile(versionPath, 'utf-8'));
+
+    // Check remote version
+    const response = await fetch('https://www.slashvibe.dev/api/version', {
+      headers: { 'User-Agent': 'vibe-mcp-client' }
+    });
+
+    if (!response.ok) {
+      return null; // Silent fail - don't block startup
+    }
+
+    const remoteVersion = await response.json();
+
+    // Compare versions
+    if (compareVersions(remoteVersion.version, localVersion.version) > 0) {
+      return {
+        current: localVersion.version,
+        latest: remoteVersion.version,
+        changelog: remoteVersion.changelog,
+        features: remoteVersion.features,
+        breaking: remoteVersion.breaking
+      };
+    }
+
+    return null; // Up to date
+  } catch (error) {
+    // Silent fail - don't block startup
+    return null;
+  }
+}
+
+async function performUpdate() {
+  try {
+    const repoPath = path.join(__dirname, '..');
+
+    // Check if we're in a git repo
+    try {
+      await execAsync('git rev-parse --git-dir', { cwd: repoPath });
+    } catch {
+      throw new Error('Not a git repository. Manual update required.');
+    }
+
+    // Stash any local changes
+    await execAsync('git stash', { cwd: repoPath });
+
+    // Pull latest
+    const { stdout, stderr } = await execAsync('git pull origin main', { cwd: repoPath });
+
+    // Pop stash if we had changes
+    try {
+      await execAsync('git stash pop', { cwd: repoPath });
+    } catch {
+      // No stash to pop, that's fine
+    }
+
+    return {
+      success: true,
+      output: stdout,
+      message: 'Update successful! Restart /vibe to apply changes.'
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if (parts1[i] > parts2[i]) return 1;
+    if (parts1[i] < parts2[i]) return -1;
+  }
+
+  return 0;
+}
+
+function formatUpdateNotification(update) {
+  if (!update) return null;
+
+  let message = `\n${'='.repeat(60)}\n`;
+  message += `📦 /vibe UPDATE AVAILABLE\n`;
+  message += `${'='.repeat(60)}\n\n`;
+  message += `Current: v${update.current}\n`;
+  message += `Latest:  v${update.latest}${update.breaking ? ' ⚠️  BREAKING' : ''}\n\n`;
+  message += `${update.changelog}\n\n`;
+
+  if (update.features && update.features.length > 0) {
+    message += `New features:\n`;
+    update.features.forEach(f => {
+      message += `  • ${f}\n`;
+    });
+    message += `\n`;
+  }
+
+  message += `Update now:\n`;
+  message += `  vibe update\n`;
+  message += `\n`;
+  message += `Or manually:\n`;
+  message += `  cd ~/.vibe/vibe-repo && git pull origin main\n`;
+  message += `${'='.repeat(60)}\n`;
+
+  return message;
+}
+
+module.exports = {
+  checkForUpdates,
+  performUpdate,
+  compareVersions,
+  formatUpdateNotification
+};