slashvibe-mcp 0.2.8 → 0.3.13

package/README.md

@@ -1,87 +1,70 @@
-# /vibe MCP Server
+# vibe-mcp
 
-The social layer for Claude Code. DMs, presence, and connection between AI developers.
-
-## What is /vibe?
-
-/vibe brings social connection to the terminal. While you're building with Claude Code, /vibe lets you:
-
-- **See who's online** - Know when other developers are in flow
-- **Send DMs** - Message fellow builders without leaving your terminal
-- **Share your presence** - Let others know what you're working on
-- **Build reputation** - Your sessions become proof of work
+Social layer for Claude Code. DMs, presence, and connection between AI-assisted developers.
 
 ## Installation
 
 ```bash
-npx slashvibe-mcp
+# Install globally
+npm install -g vibe-mcp
+
+# Or add to Claude Code MCP config
+claude mcp add vibe-mcp
 ```
 
-Or add to your Claude Code MCP settings (`~/.claude.json`):
+## Manual Setup
+
+Add to `~/.claude.json`:
 
 ```json
 {
   "mcpServers": {
     "vibe": {
       "command": "npx",
-      "args": ["-y", "slashvibe-mcp"]
+      "args": ["vibe-mcp"],
+      "env": {
+        "VIBE_API_URL": "https://www.slashvibe.dev"
+      }
     }
   }
 }
 ```
 
-## Quick Start
-
-1. Install the MCP server
-2. Authenticate: `vibe_auth` tool will guide you
-3. Check who's online: `vibe_presence`
-4. Send a message: `vibe_dm`
-
-## Available Tools
+## Features
 
-| Tool | Description |
-|------|-------------|
-| `vibe_auth` | Authenticate with slashvibe.dev |
-| `vibe_presence` | See who's online now |
-| `vibe_dm` | Send a direct message |
-| `vibe_inbox` | Check your messages |
-| `vibe_ship` | Announce what you shipped |
-| `vibe_idea` | Share an idea with the community |
-| `vibe_discover` | Find interesting builders |
-| `vibe_remember` | Save context about a connection |
-| `vibe_recall` | Recall memories about someone |
+- **Presence** - See who's online building with Claude Code
+- **DMs** - Direct messages between developers
+- **Memory** - Remember context about connections
+- **Status** - Share what you're working on
+- **Games** - Play tic-tac-toe while coding
 
-## The Platform
+## Commands
 
-This MCP server connects to [slashvibe.dev](https://slashvibe.dev), where:
+Once installed, use these in Claude Code:
 
-- Your identity persists across sessions
-- Your work builds reputation over time
-- The community grows through genuine connection
+| Command | Description |
+|---------|-------------|
+| `vibe` | Check inbox and see who's online |
+| `vibe who` | List online users |
+| `vibe dm @handle "message"` | Send a DM |
+| `vibe status shipping` | Set your status |
+| `vibe remember @handle "note"` | Save a memory |
+| `vibe recall @handle` | Recall memories |
 
-## Philosophy
+## API
 
-We believe AI development should be social, not solitary. The terminal is where real work happens - decisions, debugging, breakthroughs. /vibe makes that visible and connectable.
+The MCP server connects to `slashvibe.dev` for:
+- User presence and discovery
+- Message routing
+- Identity verification
 
-**Empathy. Collaboration. Shared value creation.**
+## Related
 
-## Contributing
-
-We welcome contributions! Please read our [Contributor License Agreement](./CLA.md) before submitting pull requests.
-
-- Report bugs via [GitHub Issues](https://github.com/VibeCodingInc/vibe-mcp/issues)
-- Propose features via [Discussions](https://github.com/VibeCodingInc/vibe-mcp/discussions)
-- Submit PRs for review
+- [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
 
 ## License
 
-MIT - see [LICENSE](./LICENSE)
-
-## Links
-
-- [slashvibe.dev](https://slashvibe.dev) - The platform
-- [Twitter](https://twitter.com/slashvibe) - Updates
-
----
-
-Built with obsession by [Slash Vibe, Inc.](https://slashvibe.dev)
+MIT

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
+};