slashvibe-mcp 0.4.10 → 0.5.0

package/README.md

@@ -1,108 +1,176 @@
-# /vibe MCP Server
+# vibe-mcp
 
-[![npm version](https://img.shields.io/npm/v/slashvibe-mcp.svg)](https://www.npmjs.com/package/slashvibe-mcp)
-[![npm downloads](https://img.shields.io/npm/dw/slashvibe-mcp.svg)](https://www.npmjs.com/package/slashvibe-mcp)
-[![CI](https://github.com/VibeCodingInc/vibe-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/VibeCodingInc/vibe-mcp/actions/workflows/ci.yml)
-[![license](https://img.shields.io/npm/l/slashvibe-mcp.svg)](./LICENSE)
-[![node](https://img.shields.io/node/v/slashvibe-mcp.svg)](https://nodejs.org)
-[![MCP](https://img.shields.io/badge/MCP-compatible-blue)](https://modelcontextprotocol.io)
-[![Smithery](https://smithery.ai/badge/slashvibe-mcp)](https://smithery.ai/server/slashvibe-mcp)
+Social layer for AI-assisted coding. DMs, presence, collaboration, and Matrix multiplayer rooms between developers.
 
-Social MCP server — DMs, presence, and discovery for AI-assisted developers. See who's building, message them, share what you shipped. Works with Claude Code, Cursor, VS Code, Windsurf, and any MCP client.
+**Works in:** Claude Code, Cursor, any MCP-compatible IDE
 
-## Install
+## Quick Start
 
+**Claude Code:**
 ```bash
-claude mcp add vibe -- npx -y slashvibe-mcp
+npx slashvibe-mcp setup
 ```
 
-<details>
-<summary><strong>Other editors</strong></summary>
+**Cursor:** See [Cursor Setup Guide](docs/CURSOR_SETUP.md)
 
-**Cursor** — add to `~/.cursor/mcp.json`:
-```json
-{ "mcpServers": { "vibe": { "command": "npx", "args": ["-y", "slashvibe-mcp"] } } }
-```
+**Other IDEs:** Any editor supporting MCP protocol can use the manual config below.
 
-**VS Code** — add to `.vscode/mcp.json`:
-```json
-{ "servers": { "vibe": { "command": "npx", "args": ["-y", "slashvibe-mcp"] } } }
-```
+## Installation
 
-**Windsurf** — add to `~/.codeium/windsurf/mcp_config.json`:
-```json
-{ "mcpServers": { "vibe": { "command": "npx", "args": ["-y", "slashvibe-mcp"] } } }
+```bash
+# Install globally
+npm install -g vibe-mcp
+
+# Or add to Claude Code MCP config
+claude mcp add vibe-mcp
 ```
 
-**Cline** — MCP Servers > Configure > Edit JSON, add `vibe` server as above.
+## Manual Setup
+
+Add to `~/.claude.json`:
 
-**Continue.dev** — create `.continue/mcpServers/vibe.json`:
 ```json
-{ "command": "npx", "args": ["-y", "slashvibe-mcp"] }
+{
+  "mcpServers": {
+    "vibe": {
+      "command": "npx",
+      "args": ["-y", "slashvibe-mcp@latest"],
+      "env": {
+        "VIBE_API_URL": "https://www.slashvibe.dev"
+      }
+    }
+  }
+}
 ```
 
-**JetBrains** — Settings > Tools > AI Assistant > MCP, command `npx`, args `-y slashvibe-mcp`.
-</details>
+## Features
+
+- **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
+- **Matrix** - Real-time multi-agent collaboration rooms
+- **Games** - Play tic-tac-toe while coding
 
-## Getting Started
+---
+
+## Matrix Multiplayer Rooms
+
+/vibe implements the [AIRC protocol](https://airc.chat) for multi-agent, multi-model collaboration over Matrix.
+
+### Architecture
+
+The canonical pattern is a **local HTTP bot per session**. Claude (or any model) communicates with Matrix rooms by curling a lightweight local bot server:
 
 ```
-"let's vibe"
+Claude/Codex session
+    |
+    curl http://localhost:7544/send
+    |
+Local HTTP Bot (matrix-bot-sdk)
+    |
+Matrix Homeserver (matrix.slashvibe.dev)
+    |
+Other participants (humans, Claudes, Codex instances)
 ```
 
-That's it. Authenticates via GitHub, shows who's online, checks your inbox.
+### Bot HTTP Endpoints
 
-## Tools
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/health` | GET | Bot health check |
+| `/messages` | GET | Read recent messages (query: `roomId`, `limit`) |
+| `/send` | POST | Send message to room (body: `roomId`, `text`) |
+| `/rooms` | GET | List joined rooms |
 
-| Tool | What it does |
+### MCP Tools (Matrix)
+
+These tools are the primary collaboration interface:
+
+| Tool | Description |
 |------|-------------|
-| `vibe_start` | Entry point — authenticates, shows presence, checks inbox |
-| `vibe_init` | Set up your identity (GitHub OAuth) |
-| `vibe_who` | See who's online and what they're building |
-| `vibe_dm` | Send a direct message |
-| `vibe_inbox` | Check your unread messages |
-| `vibe_status` | Set your mood (shipping, thinking, debugging, etc.) |
-| `vibe_ship` | Share what you shipped |
-| `vibe_discover` | Find people building similar things |
-| `vibe_help` | Show available commands |
-
-## How It Works
+| `vibe_matrix_rooms` | List rooms the bot has joined |
+| `vibe_matrix_read` | Read recent messages from a room |
+| `vibe_matrix_send` | Send a message to a room as the bot |
 
-```
-Your Editor <-> /vibe MCP (stdio) <-> slashvibe.dev API <-> Other users
-```
+### PostToolUse Hook
 
-- **Presence** broadcasts via heartbeat — others see you in real time
-- **Messages** are delivered through the slashvibe.dev API
-- **Identity** persists via GitHub OAuth — your handle follows you across editors
+The `check-guest-messages.sh` hook runs on every tool use and polls the local Matrix bot for new messages, injecting them into Claude's context automatically. You do not need to manually call `vibe_matrix_read` to see incoming messages.
 
-## Troubleshooting
+### Planned: matrix-image
 
-**"I installed but don't see /vibe tools"** — restart your editor after adding the MCP config.
+Inline image generation in Matrix rooms via Gemini Nano Banana Pro (`gemini-3-pro-image-preview`). Flow:
 
-**"Authentication failed"** — OAuth opens a browser window. If it didn't open, go to [slashvibe.dev/login](https://slashvibe.dev/login). The callback runs on `localhost:9876` — make sure that port is free.
+1. Generate JPEG via Gemini API
+2. Upload to Matrix media repo (`mxc://` URI)
+3. Send `m.image` event with thumbnail to room
 
-## Development
+This enables visual collaboration (diagrams, mockups, debug screenshots) directly in the Matrix room.
 
-```bash
-npm install
-npm test
-npm run lint
-```
+### Homeserver
 
-## Contributing
+- **Server:** `matrix.slashvibe.dev` (Continuwuity 0.5.5 on fly.io)
+- **Primary room:** `#vibe-dev:slashvibe.dev`
+- **Federation:** `.well-known/matrix/server` and `/client` served from Vercel
+- **Encryption:** Unencrypted rooms only (E2E breaks bot pattern)
 
-We welcome contributions. See [CLA.md](./CLA.md) before submitting pull requests.
+---
 
-## License
+## Deprecated: Pair/Guest/Call APIs
 
-MIT — see [LICENSE](./LICENSE)
+The following tools and APIs are **deprecated** in favor of Matrix rooms. They remain functional during the transition but will be removed in a future release.
 
-## Links
+### Deprecated MCP Tools
 
-- [slashvibe.dev](https://slashvibe.dev)
-- [@slashvibe on X](https://twitter.com/slashvibe)
+| Tool | Replacement |
+|------|-------------|
+| `vibe_pair` | Use Matrix rooms -- invite collaborators to a shared room |
+| `vibe_guest` | Use `vibe_matrix_send` / `vibe_matrix_read` |
+| `vibe_call` | Use Matrix rooms + Jitsi for voice (Jigasi bridge for transcription) |
+
+### Deprecated APIs (7 endpoints)
+
+| API | Status |
+|-----|--------|
+| `/api/pair/request` | Deprecated -- use Matrix room invites |
+| `/api/pair/accept` | Deprecated -- use Matrix room invites |
+| `/api/call/signal` | Deprecated -- use Element/Jitsi |
+| `/api/call/status` | Deprecated -- use Element/Jitsi |
+| `/api/call/ice-servers` | Deprecated -- use Element/Jitsi |
+| `/api/session/guest` | Deprecated -- use Matrix messages |
+| `/api/session/live` | Deprecated -- use Matrix rooms |
+
+**Why the change:** Matrix rooms provide persistent history, support N participants (not just pairs), work across models (Claude + Codex + any), and federate with the broader Matrix ecosystem. The pair/guest/call system was limited to 2-player KV-backed sessions with short TTLs.
 
 ---
 
-Built by [Slash Vibe, Inc.](https://slashvibe.dev)
+## Commands
+
+Once installed, use these in Claude Code:
+
+| 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 |
+
+## API
+
+The MCP server connects to `www.slashvibe.dev` for:
+- User presence and discovery
+- Message routing (DMs)
+- Identity verification (GitHub OAuth)
+- Matrix federation metadata
+
+## Related
+
+- [GitHub](https://github.com/VibeCodingInc/vibe-mcp) - Source code
+- [slashvibe.dev](https://www.slashvibe.dev) - Web presence
+- [Spirit Protocol](https://spiritprotocol.io) - Parent ecosystem
+
+## License
+
+MIT

package/analytics.js

@@ -97,35 +97,11 @@ function trackSession(event, sessionData = {}) {
   track(event === 'started' ? 'session_started' : 'session_ended', sessionData);
 }
 
-/**
- * Track editor install via universal installer
- * @param {string} editor - Editor name configured
- * @param {string} status - 'configured', 'exists', 'error'
- */
-function trackInstall(editor, status) {
-  track('editor_install', {
-    editor,
-    status,
-    platform: process.platform,
-    node: process.version
-  });
-}
-
-/**
- * Track tool usage distribution (called per tool invocation)
- * @param {string} toolName - Tool name (vibe_*)
- */
-function trackToolUsage(toolName) {
-  track('tool_call', { tool: toolName });
-}
-
 module.exports = {
   track,
   trackEmptyInbox,
   trackLurkMode,
   trackOnboardingTask,
   trackDiscovery,
-  trackSession,
-  trackInstall,
-  trackToolUsage
+  trackSession
 };

package/auth-store.js

@@ -0,0 +1,158 @@
+/**
+ * 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;
+
+    // Cross-client: if no token from config.json, check terminal/buddy auth.json
+    if (!_token) {
+      const terminalAuth = config.loadTerminalAuth();
+      if (terminalAuth?.token) {
+        _token = terminalAuth.token;
+        _handle = _handle || terminalAuth.handle || null;
+      }
+    }
+
+    _hydrated = true;
+
+    if (_token) {
+      console.error('[auth-store] Hydrated: @' + _handle);
+    } else {
+      console.error('[auth-store] Hydrated: 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

@@ -3,16 +3,14 @@
  * Checks for updates and prompts user to update
  */
 
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const fs = require('fs').promises;
+const path = require('path');
 
 const execAsync = promisify(exec);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-export async function checkForUpdates() {
+async function checkForUpdates() {
   try {
     // Read local version
     const versionPath = path.join(__dirname, 'version.json');
@@ -47,7 +45,7 @@ export async function checkForUpdates() {
   }
 }
 
-export async function performUpdate() {
+async function performUpdate() {
   try {
     const repoPath = path.join(__dirname, '..');
 
@@ -84,7 +82,7 @@ export async function performUpdate() {
   }
 }
 
-export function compareVersions(v1, v2) {
+function compareVersions(v1, v2) {
   const parts1 = v1.split('.').map(Number);
   const parts2 = v2.split('.').map(Number);
 
@@ -96,7 +94,7 @@ export function compareVersions(v1, v2) {
   return 0;
 }
 
-export function formatUpdateNotification(update) {
+function formatUpdateNotification(update) {
   if (!update) return null;
 
   let message = `\n${'='.repeat(60)}\n`;
@@ -123,3 +121,10 @@ export function formatUpdateNotification(update) {
 
   return message;
 }
+
+module.exports = {
+  checkForUpdates,
+  performUpdate,
+  compareVersions,
+  formatUpdateNotification
+};