slashvibe-mcp 0.2.0

package/README.md

@@ -0,0 +1,69 @@
+# vibe-mcp
+
+Social layer for Claude Code. DMs, presence, and connection between AI-assisted developers.
+
+## Installation
+
+```bash
+# Install globally
+npm install -g vibe-mcp
+
+# Or add to Claude Code MCP config
+claude mcp add vibe-mcp
+```
+
+## Manual Setup
+
+Add to `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "vibe": {
+      "command": "npx",
+      "args": ["vibe-mcp"],
+      "env": {
+        "VIBE_API_URL": "https://www.slashvibe.dev"
+      }
+    }
+  }
+}
+```
+
+## 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
+- **Games** - Play tic-tac-toe while coding
+
+## 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 `slashvibe.dev` for:
+- User presence and discovery
+- Message routing
+- Identity verification
+
+## Related
+
+- [slashvibe.dev](https://slashvibe.dev) - Web presence
+- [Spirit Protocol](https://spiritprotocol.io) - Parent ecosystem
+- [AIRC](https://airc.chat) - Agent identity protocol
+
+## License
+
+MIT

package/config.js

@@ -0,0 +1,252 @@
+/**
+ * Config — User identity and paths
+ *
+ * UNIFIED: Uses ~/.vibecodings/config.json as primary source
+ * Falls back to ~/.vibe/config.json for backward compat
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const VIBE_DIR = path.join(process.env.HOME, '.vibe');
+const VIBECODINGS_DIR = path.join(process.env.HOME, '.vibecodings');
+const PRIMARY_CONFIG = path.join(VIBECODINGS_DIR, 'config.json');  // Primary
+const FALLBACK_CONFIG = path.join(VIBE_DIR, 'config.json');        // Fallback
+const CONFIG_FILE = PRIMARY_CONFIG;
+
+function ensureDir() {
+  if (!fs.existsSync(VIBECODINGS_DIR)) {
+    fs.mkdirSync(VIBECODINGS_DIR, { recursive: true });
+  }
+}
+
+function load() {
+  ensureDir();
+  // Try primary config first
+  try {
+    if (fs.existsSync(PRIMARY_CONFIG)) {
+      const data = JSON.parse(fs.readFileSync(PRIMARY_CONFIG, 'utf8'));
+      // Normalize: support both 'handle' and 'username' field names
+      return {
+        ...data, // Pass through all fields (including x_credentials, etc.)
+        handle: data.handle || data.username || null,
+        one_liner: data.one_liner || data.workingOn || null,
+        visible: data.visible !== false,
+        // AIRC keypair (persisted across sessions)
+        publicKey: data.publicKey || null,
+        privateKey: data.privateKey || null
+      };
+    }
+  } catch (e) {}
+  // Fallback to legacy config (returns full object)
+  try {
+    if (fs.existsSync(FALLBACK_CONFIG)) {
+      return JSON.parse(fs.readFileSync(FALLBACK_CONFIG, 'utf8'));
+    }
+  } catch (e) {}
+  return { handle: null, one_liner: null, visible: true, publicKey: null, privateKey: null };
+}
+
+function save(config) {
+  ensureDir();
+  // Load existing to preserve fields we're not updating
+  let existing = {};
+  try {
+    if (fs.existsSync(PRIMARY_CONFIG)) {
+      existing = JSON.parse(fs.readFileSync(PRIMARY_CONFIG, 'utf8'));
+    }
+  } catch (e) {}
+
+  // Save to primary config in vibecodings format
+  const data = {
+    username: config.handle || config.username || existing.username,
+    workingOn: config.one_liner || config.workingOn || existing.workingOn,
+    createdAt: config.createdAt || existing.createdAt || new Date().toISOString().split('T')[0],
+    // AIRC keypair (persisted across sessions)
+    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
+  };
+  fs.writeFileSync(PRIMARY_CONFIG, JSON.stringify(data, null, 2));
+}
+
+function getHandle() {
+  // Prefer session-specific handle over shared config
+  const sessionHandle = getSessionHandle();
+  if (sessionHandle) return sessionHandle;
+  // Fall back to shared config
+  const config = load();
+  return config.handle || null;
+}
+
+function getOneLiner() {
+  // Prefer session-specific one_liner over shared config
+  const sessionOneLiner = getSessionOneLiner();
+  if (sessionOneLiner) return sessionOneLiner;
+  // Fall back to shared config
+  const config = load();
+  return config.one_liner || null;
+}
+
+function isInitialized() {
+  // Check session first, then shared config
+  const sessionHandle = getSessionHandle();
+  if (sessionHandle) return true;
+  const config = load();
+  return config.handle && config.handle.length > 0;
+}
+
+// Session management - unique ID per Claude Code instance
+// Now stores full identity (handle + one_liner), not just sessionId
+const SESSION_FILE = path.join(VIBECODINGS_DIR, `.session_${process.pid}`);
+
+function generateSessionId() {
+  return 'sess_' + Date.now().toString(36) + Math.random().toString(36).substring(2, 10);
+}
+
+function getSessionData() {
+  try {
+    if (fs.existsSync(SESSION_FILE)) {
+      const content = fs.readFileSync(SESSION_FILE, 'utf8').trim();
+      // Support old format (just sessionId string) and new format (JSON)
+      if (content.startsWith('{')) {
+        return JSON.parse(content);
+      }
+      // Old format: just the sessionId
+      return { sessionId: content, handle: null, one_liner: null };
+    }
+  } catch (e) {}
+  return null;
+}
+
+function saveSessionData(data) {
+  ensureDir();
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2));
+}
+
+function getSessionId() {
+  const data = getSessionData();
+  if (data?.sessionId) {
+    return data.sessionId;
+  }
+  // Generate new session
+  const sessionId = generateSessionId();
+  saveSessionData({ sessionId, handle: null, one_liner: null });
+  return sessionId;
+}
+
+function getSessionHandle() {
+  const data = getSessionData();
+  return data?.handle || null;
+}
+
+function getSessionOneLiner() {
+  const data = getSessionData();
+  return data?.one_liner || null;
+}
+
+function setSessionIdentity(handle, one_liner, keypair = null) {
+  const sessionId = getSessionId();
+  const existingData = getSessionData() || {};
+  saveSessionData({
+    sessionId,
+    handle,
+    one_liner,
+    // Preserve token if already set (from server registration)
+    token: existingData.token || null,
+    // AIRC keypair (generated on init)
+    publicKey: keypair?.publicKey || existingData.publicKey || null,
+    privateKey: keypair?.privateKey || existingData.privateKey || null
+  });
+}
+
+function getKeypair() {
+  // First check session data
+  const sessionData = getSessionData();
+  if (sessionData?.publicKey && sessionData?.privateKey) {
+    return {
+      publicKey: sessionData.publicKey,
+      privateKey: sessionData.privateKey
+    };
+  }
+  // Fall back to shared config (keypairs persist across MCP invocations)
+  const config = load();
+  if (config?.publicKey && config?.privateKey) {
+    return {
+      publicKey: config.publicKey,
+      privateKey: config.privateKey
+    };
+  }
+  return null;
+}
+
+function hasKeypair() {
+  return getKeypair() !== null;
+}
+
+function saveKeypair(keypair) {
+  // Save to shared config so it persists across MCP process invocations
+  const config = load();
+  config.publicKey = keypair.publicKey;
+  config.privateKey = keypair.privateKey;
+  save(config);
+}
+
+function setAuthToken(token, sessionId = null) {
+  const data = getSessionData() || {};
+  saveSessionData({
+    ...data,
+    sessionId: sessionId || data.sessionId || generateSessionId(),
+    token
+  });
+}
+
+function getAuthToken() {
+  const data = getSessionData();
+  return data?.token || null;
+}
+
+function clearSession() {
+  try {
+    if (fs.existsSync(SESSION_FILE)) {
+      fs.unlinkSync(SESSION_FILE);
+    }
+  } catch (e) {}
+}
+
+// Guided mode — show AskUserQuestion menus (default: true for new users)
+function getGuidedMode() {
+  const config = load();
+  // Default to true (guided mode on) if not set
+  return config.guided_mode !== false;
+}
+
+function setGuidedMode(enabled) {
+  const config = load();
+  config.guided_mode = enabled;
+  save(config);
+}
+
+module.exports = {
+  VIBE_DIR,
+  CONFIG_FILE,
+  load,
+  save,
+  getHandle,
+  getOneLiner,
+  isInitialized,
+  getSessionId,
+  getSessionHandle,
+  getSessionOneLiner,
+  setSessionIdentity,
+  setAuthToken,
+  getAuthToken,
+  getKeypair,
+  hasKeypair,
+  saveKeypair,
+  clearSession,
+  generateSessionId,
+  getGuidedMode,
+  setGuidedMode
+};

package/crypto.js

@@ -0,0 +1,200 @@
+/**
+ * AIRC Crypto — Ed25519 keypair generation and message signing
+ *
+ * Implements AIRC v0.1 signing specification:
+ * - Ed25519 keypairs (Node.js crypto)
+ * - Canonical JSON serialization
+ * - Base64 signature encoding
+ */
+
+const crypto = require('crypto');
+
+/**
+ * Generate a new Ed25519 keypair
+ * @returns {{ publicKey: string, privateKey: string }} Base64-encoded keys
+ */
+function generateKeypair() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+
+  return {
+    publicKey: publicKey.export({ type: 'spki', format: 'der' }).toString('base64'),
+    privateKey: privateKey.export({ type: 'pkcs8', format: 'der' }).toString('base64')
+  };
+}
+
+/**
+ * Serialize object to canonical JSON per AIRC spec
+ * - Keys sorted alphabetically (recursive)
+ * - No whitespace
+ * - UTF-8 encoding
+ *
+ * @param {object} obj Object to serialize
+ * @returns {string} Canonical JSON string
+ */
+function canonicalJSON(obj) {
+  if (obj === null || obj === undefined) return 'null';
+  if (typeof obj !== 'object') return JSON.stringify(obj);
+  if (Array.isArray(obj)) {
+    return '[' + obj.map(canonicalJSON).join(',') + ']';
+  }
+
+  // Sort keys alphabetically and recurse
+  const sortedKeys = Object.keys(obj).sort();
+  const pairs = sortedKeys
+    .filter(k => obj[k] !== undefined) // Exclude undefined values
+    .map(k => `${JSON.stringify(k)}:${canonicalJSON(obj[k])}`);
+  return '{' + pairs.join(',') + '}';
+}
+
+/**
+ * Sign an object with Ed25519 private key
+ *
+ * Per AIRC spec:
+ * 1. Clone object
+ * 2. Remove 'signature' field if present
+ * 3. Serialize to canonical JSON
+ * 4. Sign UTF-8 bytes
+ *
+ * @param {object} obj Object to sign
+ * @param {string} privateKeyBase64 Base64-encoded private key (PKCS8 DER)
+ * @returns {string} Base64-encoded signature
+ */
+function sign(obj, privateKeyBase64) {
+  // Clone and remove signature field
+  const toSign = { ...obj };
+  delete toSign.signature;
+
+  // Get canonical JSON
+  const canonical = canonicalJSON(toSign);
+
+  // Import private key
+  const privateKey = crypto.createPrivateKey({
+    key: Buffer.from(privateKeyBase64, 'base64'),
+    format: 'der',
+    type: 'pkcs8'
+  });
+
+  // Sign
+  const signature = crypto.sign(null, Buffer.from(canonical, 'utf8'), privateKey);
+  return signature.toString('base64');
+}
+
+/**
+ * Verify signature on an object
+ *
+ * @param {object} obj Object with signature field
+ * @param {string} publicKeyBase64 Base64-encoded public key (SPKI DER)
+ * @returns {boolean} True if signature is valid
+ */
+function verify(obj, publicKeyBase64) {
+  if (!obj.signature) return false;
+
+  // Clone and remove signature
+  const toVerify = { ...obj };
+  const signature = toVerify.signature;
+  delete toVerify.signature;
+
+  // Get canonical JSON
+  const canonical = canonicalJSON(toVerify);
+
+  try {
+    // Import public key
+    const publicKey = crypto.createPublicKey({
+      key: Buffer.from(publicKeyBase64, 'base64'),
+      format: 'der',
+      type: 'spki'
+    });
+
+    // Verify
+    return crypto.verify(
+      null,
+      Buffer.from(canonical, 'utf8'),
+      publicKey,
+      Buffer.from(signature, 'base64')
+    );
+  } catch (e) {
+    console.error('[crypto] Verification failed:', e.message);
+    return false;
+  }
+}
+
+/**
+ * Generate a random nonce (16+ chars)
+ * @returns {string} Hex-encoded nonce
+ */
+function generateNonce() {
+  return crypto.randomBytes(16).toString('hex');
+}
+
+/**
+ * Generate AIRC-compliant message ID
+ * @returns {string} Message ID (msg_ prefix + random)
+ */
+function generateMessageId() {
+  return 'msg_' + crypto.randomBytes(12).toString('hex');
+}
+
+/**
+ * Create a signed AIRC message
+ *
+ * @param {object} params Message parameters
+ * @param {string} params.from Sender handle
+ * @param {string} params.to Recipient handle
+ * @param {string} [params.body] Message body
+ * @param {object} [params.payload] Message payload
+ * @param {string} privateKeyBase64 Sender's private key
+ * @returns {object} Complete signed message
+ */
+function createSignedMessage({ from, to, body, payload }, privateKeyBase64) {
+  const message = {
+    v: '0.1',
+    id: generateMessageId(),
+    from,
+    to,
+    timestamp: Math.floor(Date.now() / 1000),
+    nonce: generateNonce()
+  };
+
+  if (body) message.body = body;
+  if (payload) message.payload = payload;
+
+  // Sign
+  message.signature = sign(message, privateKeyBase64);
+
+  return message;
+}
+
+/**
+ * Create a signed heartbeat
+ *
+ * @param {string} handle User handle
+ * @param {string} status Status (online/idle/busy/offline)
+ * @param {string} [context] Activity context
+ * @param {string} privateKeyBase64 User's private key
+ * @returns {object} Signed heartbeat
+ */
+function createSignedHeartbeat(handle, status, context, privateKeyBase64) {
+  const heartbeat = {
+    handle,
+    status,
+    timestamp: Math.floor(Date.now() / 1000),
+    nonce: generateNonce()
+  };
+
+  if (context) heartbeat.context = context;
+
+  heartbeat.signature = sign(heartbeat, privateKeyBase64);
+
+  return heartbeat;
+}
+
+module.exports = {
+  generateKeypair,
+  canonicalJSON,
+  sign,
+  verify,
+  generateNonce,
+  generateMessageId,
+  createSignedMessage,
+  createSignedHeartbeat
+};

package/discord.js

@@ -0,0 +1,151 @@
+/**
+ * /vibe Discord Webhook Integration
+ *
+ * Posts /vibe activity to a Discord channel via webhook.
+ * One-way: /vibe → Discord (outbound only)
+ */
+
+const config = require('./config');
+
+/**
+ * Get Discord webhook URL from config
+ */
+function getWebhookUrl() {
+  const cfg = config.load();
+  return cfg.discord_webhook_url || null;
+}
+
+/**
+ * Check if Discord integration is configured
+ */
+function isConfigured() {
+  return !!getWebhookUrl();
+}
+
+/**
+ * Post a message to Discord via webhook
+ */
+async function post(content, options = {}) {
+  const webhookUrl = getWebhookUrl();
+  if (!webhookUrl) return false;
+
+  try {
+    const body = {
+      content,
+      username: options.username || '/vibe',
+      avatar_url: options.avatar || 'https://slashvibe.dev/vibe-icon.png'
+    };
+
+    // Support embeds for richer messages
+    if (options.embed) {
+      body.embeds = [options.embed];
+      delete body.content;
+    }
+
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    return response.ok;
+  } catch (e) {
+    // Silent fail - Discord is best-effort
+    return false;
+  }
+}
+
+/**
+ * Post when someone joins /vibe
+ */
+async function postJoin(handle, oneLiner) {
+  const embed = {
+    color: 0x6B8FFF, // Spirit blue
+    title: `@${handle} joined /vibe`,
+    description: oneLiner || 'Building something',
+    footer: { text: 'slashvibe.dev' },
+    timestamp: new Date().toISOString()
+  };
+  return post(null, { embed });
+}
+
+/**
+ * Post when someone sends a message (anonymized)
+ */
+async function postActivity(handle, action) {
+  const embed = {
+    color: 0x2ECC71, // Green
+    description: `**@${handle}** ${action}`,
+    timestamp: new Date().toISOString()
+  };
+  return post(null, { embed });
+}
+
+/**
+ * Post when someone changes status
+ */
+async function postStatus(handle, mood, note) {
+  const moodEmoji = {
+    'shipping': '🔥',
+    'debugging': '🐛',
+    'deep': '🧠',
+    'afk': '☕',
+    'celebrating': '🎉',
+    'pairing': '👯'
+  };
+
+  const emoji = moodEmoji[mood] || '●';
+  const embed = {
+    color: 0x9B59B6, // Purple
+    description: `${emoji} **@${handle}** is ${mood}${note ? `: "${note}"` : ''}`,
+    timestamp: new Date().toISOString()
+  };
+  return post(null, { embed });
+}
+
+/**
+ * Post a system announcement
+ */
+async function postAnnouncement(message) {
+  const embed = {
+    color: 0x6B8FFF,
+    title: '/vibe',
+    description: message,
+    timestamp: new Date().toISOString()
+  };
+  return post(null, { embed });
+}
+
+/**
+ * Post who's currently online
+ */
+async function postOnlineList(users) {
+  if (users.length === 0) {
+    return post('_Room is quiet..._');
+  }
+
+  const list = users.map(u => {
+    const mood = u.mood ? ` ${u.mood}` : '';
+    return `• **@${u.handle}**${mood} — ${u.one_liner || 'building'}`;
+  }).join('\n');
+
+  const embed = {
+    color: 0x6B8FFF,
+    title: `${users.length} online in /vibe`,
+    description: list,
+    footer: { text: 'slashvibe.dev' },
+    timestamp: new Date().toISOString()
+  };
+  return post(null, { embed });
+}
+
+module.exports = {
+  isConfigured,
+  getWebhookUrl,
+  post,
+  postJoin,
+  postActivity,
+  postStatus,
+  postAnnouncement,
+  postOnlineList
+};