slashvibe-mcp 0.3.22 → 0.3.23

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/auto-update.js

@@ -0,0 +1,125 @@
+/**
+ * Auto-update mechanism for /vibe MCP server
+ * 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 execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export 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;
+  }
+}
+
+export 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
+    };
+  }
+}
+
+export 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;
+}
+
+export 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;
+}

package/debug.js

@@ -0,0 +1,12 @@
+/**
+ * Debug logging — conditional on VIBE_DEBUG env var
+ *
+ * @param {...*} args Arguments to log
+ */
+function debug(...args) {
+  if (process.env.VIBE_DEBUG === 'true') {
+    console.error(...args);
+  }
+}
+
+module.exports = debug;

package/eslint.config.js

@@ -0,0 +1,54 @@
+const js = require('@eslint/js');
+
+module.exports = [
+  js.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'commonjs',
+      globals: {
+        // Node.js globals
+        require: 'readonly',
+        module: 'readonly',
+        exports: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        process: 'readonly',
+        console: 'readonly',
+        Buffer: 'readonly',
+        setTimeout: 'readonly',
+        setInterval: 'readonly',
+        clearTimeout: 'readonly',
+        clearInterval: 'readonly',
+        URL: 'readonly',
+        URLSearchParams: 'readonly',
+        fetch: 'readonly',
+        global: 'readonly',
+        AbortController: 'readonly',
+        AbortSignal: 'readonly'
+      }
+    },
+    rules: {
+      'no-unused-vars': ['warn', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
+      eqeqeq: ['error', 'smart'],
+      'no-var': 'error',
+      'prefer-const': 'warn',
+      'no-throw-literal': 'error',
+      'no-empty': ['warn', { allowEmptyCatch: true }],
+      'no-case-declarations': 'warn',
+      'no-prototype-builtins': 'warn',
+      'no-shadow-restricted-names': 'warn',
+      'no-useless-escape': 'warn'
+    }
+  },
+  // ESM files (use import/export)
+  {
+    files: ['auto-update.js', 'post-install.js'],
+    languageOptions: {
+      sourceType: 'module'
+    }
+  },
+  {
+    ignores: ['node_modules/', 'coverage/', 'dist/']
+  }
+];

package/migrate-v2.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Migration: Add thread_id column for V2 Postgres integration
+ *
+ * This migration adds the thread_id column to the messages table
+ * and creates the necessary index for V2 API compatibility.
+ *
+ * Run: node migrate-v2.js
+ */
+
+const Database = require('better-sqlite3');
+const path = require('path');
+const os = require('os');
+
+const DB_PATH = path.join(os.homedir(), '.vibecodings', 'sessions.db');
+
+function migrate() {
+  console.log('[Migration] Starting V2 schema migration...');
+  console.log(`[Migration] Database: ${DB_PATH}`);
+
+  const db = new Database(DB_PATH);
+
+  // Check if thread_id column already exists
+  const columns = db.prepare('PRAGMA table_info(messages)').all();
+  const hasThreadId = columns.some(col => col.name === 'thread_id');
+
+  if (hasThreadId) {
+    console.log('[Migration] ✅ thread_id column already exists. No migration needed.');
+    db.close();
+    return;
+  }
+
+  console.log('[Migration] Adding thread_id column...');
+
+  try {
+    // Add thread_id column
+    db.exec(`ALTER TABLE messages ADD COLUMN thread_id TEXT;`);
+
+    // Create index for thread_id
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_messages_thread_id
+      ON messages(thread_id);
+    `);
+
+    console.log('[Migration] ✅ Successfully added thread_id column and index');
+
+    // Verify migration
+    const newColumns = db.prepare('PRAGMA table_info(messages)').all();
+    const threadIdColumn = newColumns.find(col => col.name === 'thread_id');
+
+    if (threadIdColumn) {
+      console.log('[Migration] ✅ Verification passed');
+      console.log(`[Migration] Column details: ${JSON.stringify(threadIdColumn)}`);
+    } else {
+      console.error('[Migration] ❌ Verification failed - column not found after migration');
+    }
+  } catch (error) {
+    console.error('[Migration] ❌ Migration failed:', error.message);
+    throw error;
+  } finally {
+    db.close();
+  }
+
+  console.log('[Migration] Complete!');
+}
+
+// Run migration
+if (require.main === module) {
+  migrate();
+}
+
+module.exports = { migrate };

package/notification-emitter.js

@@ -0,0 +1,77 @@
+/**
+ * MCP `list_changed` notification emitter
+ *
+ * Triggers Claude to refresh tool results without reconnection.
+ * Implements debouncing to prevent notification spam.
+ *
+ * This eliminates the need for 30-second polling loops,
+ * reducing API calls by ~90% and providing instant updates.
+ */
+
+class NotificationEmitter {
+  constructor(server) {
+    this.server = server;
+    this.debounceTimers = {};
+  }
+
+  /**
+   * Emit list_changed notification with debouncing
+   * @param {string} reason - Why notification is being sent (for logging/debugging)
+   * @param {number} debounceMs - Debounce window in milliseconds (default: 1000ms)
+   */
+  emitChange(reason, debounceMs = 1000) {
+    // Debounce to prevent notification spam
+    // If we get multiple changes of the same type within the window,
+    // only emit one notification
+    if (this.debounceTimers[reason]) {
+      clearTimeout(this.debounceTimers[reason]);
+    }
+
+    this.debounceTimers[reason] = setTimeout(() => {
+      try {
+        this.server.notification({
+          method: 'notifications/list_changed'
+        });
+        delete this.debounceTimers[reason];
+      } catch (e) {
+        // Silent fail - notifications are best-effort
+        // If notification fails, Claude will continue working normally
+      }
+    }, debounceMs);
+  }
+
+  /**
+   * Emit immediately without debouncing
+   * Use for urgent updates like direct mentions
+   */
+  emitImmediate() {
+    try {
+      this.server.notification({
+        method: 'notifications/list_changed'
+      });
+    } catch (e) {
+      // Silent fail
+    }
+  }
+
+  /**
+   * Cancel pending notifications for a specific reason
+   * Useful when shutting down or cleaning up
+   */
+  cancel(reason) {
+    if (this.debounceTimers[reason]) {
+      clearTimeout(this.debounceTimers[reason]);
+      delete this.debounceTimers[reason];
+    }
+  }
+
+  /**
+   * Cancel all pending notifications
+   */
+  cancelAll() {
+    Object.values(this.debounceTimers).forEach(timer => clearTimeout(timer));
+    this.debounceTimers = {};
+  }
+}
+
+module.exports = NotificationEmitter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.3.22",
+  "version": "0.3.23",
   "mcpName": "io.github.vibecodinginc/vibe-mcp",
   "description": "Social MCP server - DMs, presence, discovery, and games for AI-assisted developers. Works with Claude Code, Cursor, VS Code, Windsurf, and any MCP client.",
   "main": "index.js",
@@ -47,15 +47,7 @@
     "node": ">=18.0.0"
   },
   "files": [
-    "index.js",
-    "config.js",
-    "crypto.js",
-    "discord.js",
-    "memory.js",
-    "notify.js",
-    "presence.js",
-    "prompts.js",
-    "twitter.js",
+    "*.js",
     "version.json",
     "tools/",
     "store/",

package/post-install.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for slashvibe-mcp
+ * Sets up MCP server configuration and CLAUDE.md for Claude Code
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const HOME = homedir();
+const CLAUDE_CONFIG_DIR = path.join(HOME, '.config', 'claude-code');
+const MCP_CONFIG_PATH = path.join(CLAUDE_CONFIG_DIR, 'mcp.json');
+const CLAUDE_MD_DIR = path.join(HOME, '.claude');
+const CLAUDE_MD_PATH = path.join(CLAUDE_MD_DIR, 'CLAUDE.md');
+const VIBE_MARKER = '## /vibe - Terminal-Native Social';
+
+async function setup() {
+  console.log('\n📦 Setting up /vibe...\n');
+
+  try {
+    // Ensure config directory exists
+    await fs.mkdir(CLAUDE_CONFIG_DIR, { recursive: true });
+    await fs.mkdir(CLAUDE_MD_DIR, { recursive: true });
+
+    // Read existing MCP config or create new
+    let config = { mcpServers: {} };
+    try {
+      const existing = await fs.readFile(MCP_CONFIG_PATH, 'utf-8');
+      config = JSON.parse(existing);
+      if (!config.mcpServers) config.mcpServers = {};
+    } catch (error) {
+      // File doesn't exist, use default
+    }
+
+    // Use npx to run slashvibe-mcp — works regardless of install location
+    config.mcpServers.vibe = {
+      command: 'npx',
+      args: ['-y', 'slashvibe-mcp']
+    };
+
+    // Write config
+    await fs.writeFile(MCP_CONFIG_PATH, JSON.stringify(config, null, 2));
+
+    // Inject CLAUDE.md template for dashboard mode
+    await injectClaudeMd();
+
+    console.log('✅ /vibe MCP server configured\n');
+    console.log('Next steps:');
+    console.log('  1. Restart Claude Code');
+    console.log('  2. Run: vibe init @yourusername\n');
+    console.log('📖 Docs: https://slashvibe.dev\n');
+  } catch (error) {
+    console.error('⚠️  Setup incomplete:', error.message);
+    console.error('\nManual setup:');
+    console.error('  Add to ~/.config/claude-code/mcp.json:\n');
+    console.error('  {');
+    console.error('    "mcpServers": {');
+    console.error('      "vibe": {');
+    console.error('        "command": "npx",');
+    console.error('        "args": ["-y", "slashvibe-mcp"]');
+    console.error('      }');
+    console.error('    }');
+    console.error('  }\n');
+  }
+}
+
+/**
+ * Inject /vibe CLAUDE.md template for dashboard mode and hint handling
+ * - If CLAUDE.md doesn't exist, create it with template
+ * - If exists but no /vibe section, append template
+ * - If /vibe section exists, update it with latest template
+ */
+async function injectClaudeMd() {
+  try {
+    // Find the template relative to this script
+    // When installed via npm: ../dashboard/VIBE_CLAUDE_MD_TEMPLATE.md
+    const templatePath = path.join(__dirname, '..', 'dashboard', 'VIBE_CLAUDE_MD_TEMPLATE.md');
+
+    let template;
+    try {
+      template = await fs.readFile(templatePath, 'utf-8');
+    } catch (e) {
+      // Template not found (might be dev environment), skip injection
+      console.log('ℹ️  CLAUDE.md template not found, skipping dashboard setup');
+      return;
+    }
+
+    // Check if CLAUDE.md exists
+    let existingContent = '';
+    try {
+      existingContent = await fs.readFile(CLAUDE_MD_PATH, 'utf-8');
+    } catch (e) {
+      // File doesn't exist, will create new
+    }
+
+    if (existingContent.includes(VIBE_MARKER)) {
+      // /vibe section exists - replace it with updated template
+      // Find the section and replace it
+      const startIndex = existingContent.indexOf(VIBE_MARKER);
+
+      // Find the next ## header (or end of file)
+      const afterMarker = existingContent.substring(startIndex + VIBE_MARKER.length);
+      const nextSectionMatch = afterMarker.match(/\n## (?!\/vibe)/);
+
+      let endIndex;
+      if (nextSectionMatch) {
+        endIndex = startIndex + VIBE_MARKER.length + nextSectionMatch.index;
+      } else {
+        endIndex = existingContent.length;
+      }
+
+      // Replace the section
+      const beforeSection = existingContent.substring(0, startIndex);
+      const afterSection = existingContent.substring(endIndex);
+      const newContent = beforeSection + template + afterSection;
+
+      await fs.writeFile(CLAUDE_MD_PATH, newContent);
+      console.log('✅ CLAUDE.md updated with latest /vibe dashboard');
+    } else if (existingContent) {
+      // CLAUDE.md exists but no /vibe section - append
+      const newContent = existingContent + '\n\n' + template;
+      await fs.writeFile(CLAUDE_MD_PATH, newContent);
+      console.log('✅ /vibe dashboard added to CLAUDE.md');
+    } else {
+      // No CLAUDE.md - create with template
+      await fs.writeFile(CLAUDE_MD_PATH, template);
+      console.log('✅ CLAUDE.md created with /vibe dashboard');
+    }
+  } catch (error) {
+    // Non-fatal - log but don't fail installation
+    console.log('ℹ️  Could not update CLAUDE.md:', error.message);
+  }
+}
+
+setup();

package/test-skills-bootstrap.js

@@ -0,0 +1,20 @@
+// Test the skills bootstrap functionality
+const skillsBootstrap = require('./tools/skills-bootstrap.js');
+
+async function testBootstrap() {
+  try {
+    console.log('Testing skills bootstrap...');
+
+    // Check status first
+    const statusResult = await skillsBootstrap.handler({ action: 'status' });
+    console.log('Status check:', statusResult);
+
+    // Seed the marketplace
+    const seedResult = await skillsBootstrap.handler({ action: 'seed' });
+    console.log('Seed result:', seedResult);
+  } catch (error) {
+    console.error('Bootstrap test failed:', error);
+  }
+}
+
+testBootstrap();

package/test-v2-integration.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+/**
+ * V2 Postgres Integration Test Suite
+ *
+ * Tests the complete message flow:
+ * 1. SQLite schema validation
+ * 2. Message saving (optimistic UI)
+ * 3. thread_id extraction from V2 API
+ * 4. Message status updates
+ * 5. Thread retrieval
+ *
+ * Run: node test-v2-integration.js
+ */
+
+const Database = require('better-sqlite3');
+const path = require('path');
+const os = require('os');
+const sqlite = require('./store/sqlite');
+
+const DB_PATH = path.join(os.homedir(), '.vibecodings', 'sessions.db');
+
+class V2IntegrationTest {
+  constructor() {
+    this.db = new Database(DB_PATH);
+    this.results = {
+      passed: [],
+      failed: [],
+      warnings: []
+    };
+  }
+
+  log(emoji, message) {
+    console.log(`${emoji} ${message}`);
+  }
+
+  pass(test, details = '') {
+    this.results.passed.push({ test, details });
+    this.log('✅', `${test}${details ? ': ' + details : ''}`);
+  }
+
+  fail(test, error) {
+    this.results.failed.push({ test, error });
+    this.log('❌', `${test}: ${error}`);
+  }
+
+  warn(test, message) {
+    this.results.warnings.push({ test, message });
+    this.log('⚠️', `${test}: ${message}`);
+  }
+
+  // Test 1: Schema Validation
+  testSchema() {
+    this.log('🔍', 'Test 1: Validating SQLite schema...');
+
+    const columns = this.db.prepare('PRAGMA table_info(messages)').all();
+    const columnNames = columns.map(c => c.name);
+
+    const requiredColumns = [
+      'local_id',
+      'server_id',
+      'thread_id', // V2 requirement
+      'from_handle',
+      'to_handle',
+      'content',
+      'created_at',
+      'status',
+      'sent_at',
+      'delivered_at',
+      'read_at',
+      'synced_at',
+      'retry_count'
+    ];
+
+    const missing = requiredColumns.filter(col => !columnNames.includes(col));
+
+    if (missing.length > 0) {
+      this.fail('Schema validation', `Missing columns: ${missing.join(', ')}`);
+      return false;
+    }
+
+    this.pass('Schema validation', `All ${requiredColumns.length} columns present`);
+
+    // Check indexes
+    const indexes = this.db.prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='messages'").all();
+    const indexNames = indexes.map(i => i.name);
+
+    if (!indexNames.includes('idx_messages_thread_id')) {
+      this.warn('Index check', 'idx_messages_thread_id missing');
+    } else {
+      this.pass('Index check', 'thread_id index exists');
+    }
+
+    return true;
+  }
+
+  // Test 2: Message Saving (Optimistic UI)
+  testMessageSaving() {
+    this.log('🔍', 'Test 2: Testing optimistic message save...');
+
+    const testMessage = {
+      from_handle: 'test_alice',
+      to_handle: 'test_bob',
+      content: 'Test message for V2 integration',
+      status: 'pending'
+    };
+
+    try {
+      const local_id = sqlite.saveLocalMessage(testMessage);
+
+      if (!local_id) {
+        this.fail('Message saving', 'No local_id returned');
+        return null;
+      }
+
+      // Verify it was saved
+      const saved = this.db.prepare('SELECT * FROM messages WHERE local_id = ?').get(local_id);
+
+      if (!saved) {
+        this.fail('Message saving', 'Message not found after save');
+        return null;
+      }
+
+      if (saved.status !== 'pending') {
+        this.fail('Message saving', `Expected status 'pending', got '${saved.status}'`);
+        return null;
+      }
+
+      this.pass('Message saving', `Saved with local_id: ${local_id.slice(0, 12)}...`);
+      return local_id;
+    } catch (error) {
+      this.fail('Message saving', error.message);
+      return null;
+    }
+  }
+
+  // Test 3: Status Update with thread_id
+  testStatusUpdate(local_id) {
+    if (!local_id) {
+      this.warn('Status update', 'Skipped (no local_id from previous test)');
+      return;
+    }
+
+    this.log('🔍', 'Test 3: Testing status update with thread_id...');
+
+    try {
+      // Simulate V2 API response with server_id and thread_id
+      const server_id = 'msg_test_' + Date.now();
+      const thread_id = 'thread_test_' + Date.now();
+
+      sqlite.updateMessageStatus(local_id, 'sent', server_id, thread_id);
+
+      // Verify update
+      const updated = this.db.prepare('SELECT * FROM messages WHERE local_id = ?').get(local_id);
+
+      if (updated.status !== 'sent') {
+        this.fail('Status update', `Expected status 'sent', got '${updated.status}'`);
+        return;
+      }
+
+      if (updated.server_id !== server_id) {
+        this.fail('Status update', `server_id mismatch`);
+        return;
+      }
+
+      if (updated.thread_id !== thread_id) {
+        this.fail('Status update', `thread_id not saved correctly`);
+        return;
+      }
+
+      if (!updated.sent_at) {
+        this.warn('Status update', 'sent_at timestamp not set');
+      }
+
+      this.pass('Status update', `Status: ${updated.status}, thread_id: ${thread_id.slice(0, 20)}...`);
+    } catch (error) {
+      this.fail('Status update', error.message);
+    }
+  }
+
+  // Test 4: Thread Retrieval
+  testThreadRetrieval() {
+    this.log('🔍', 'Test 4: Testing thread retrieval...');
+
+    try {
+      const messages = sqlite.getThreadMessages('test_alice', 'test_bob', 100);
+
+      if (!Array.isArray(messages)) {
+        this.fail('Thread retrieval', 'Did not return an array');
+        return;
+      }
+
+      if (messages.length === 0) {
+        this.warn('Thread retrieval', 'No messages found (expected from test 2)');
+        return;
+      }
+
+      const msg = messages[0];
+
+      // Check that thread_id is included
+      if (msg.thread_id === undefined) {
+        this.fail('Thread retrieval', 'Message missing thread_id field');
+        return;
+      }
+
+      this.pass('Thread retrieval', `Retrieved ${messages.length} message(s) with thread_id`);
+    } catch (error) {
+      this.fail('Thread retrieval', error.message);
+    }
+  }
+
+  // Test 5: Merge Server Messages (V2 format)
+  testMergeServerMessages() {
+    this.log('🔍', 'Test 5: Testing server message merge with V2 format...');
+
+    const v2Messages = [
+      {
+        id: 'msg_server_001',
+        thread_id: 'thread_xyz',
+        from: 'server_alice',
+        to: 'server_bob',
+        body: 'Server message 1',
+        created_at: new Date().toISOString()
+      },
+      {
+        id: 'msg_server_002',
+        thread_id: 'thread_xyz',
+        from: 'server_bob',
+        to: 'server_alice',
+        body: 'Server message 2',
+        created_at: new Date().toISOString()
+      }
+    ];
+
+    try {
+      const merged = sqlite.mergeServerMessages(v2Messages);
+
+      if (merged !== v2Messages.length) {
+        this.fail('Server message merge', `Expected ${v2Messages.length} merged, got ${merged}`);
+        return;
+      }
+
+      // Verify messages were saved with thread_id
+      const saved = this.db
+        .prepare(
+          `
+        SELECT * FROM messages
+        WHERE server_id IN ('msg_server_001', 'msg_server_002')
+        ORDER BY created_at
+      `
+        )
+        .all();
+
+      if (saved.length !== 2) {
+        this.fail('Server message merge', `Expected 2 messages, found ${saved.length}`);
+        return;
+      }
+
+      // Check thread_id was preserved
+      const threadIds = saved.map(m => m.thread_id);
+      if (!threadIds.every(id => id === 'thread_xyz')) {
+        this.fail('Server message merge', 'thread_id not preserved correctly');
+        return;
+      }
+
+      this.pass('Server message merge', `Merged ${merged} V2 messages with thread_id`);
+    } catch (error) {
+      this.fail('Server message merge', error.message);
+    }
+  }
+
+  // Test 6: Code Review - Check api.js integration
+  testCodeIntegration() {
+    this.log('🔍', 'Test 6: Code integration check...');
+
+    const apiCode = require('fs').readFileSync('./store/api.js', 'utf-8');
+
+    // Check 1: sendMessage saves to SQLite
+    if (!apiCode.includes('sqlite.saveLocalMessage')) {
+      this.fail('Code integration', 'api.js missing sqlite.saveLocalMessage call');
+      return;
+    }
+
+    // Check 2: sendMessage updates status with thread_id
+    if (!apiCode.includes('sqlite.updateMessageStatus')) {
+      this.fail('Code integration', 'api.js missing sqlite.updateMessageStatus call');
+      return;
+    }
+
+    // Check 3: thread_id extraction from V2 response
+    if (!apiCode.includes('thread_id')) {
+      this.fail('Code integration', 'api.js not extracting thread_id from response');
+      return;
+    }
+
+    // Check 4: getThread uses sqlite
+    if (!apiCode.includes('sqlite.getThreadMessages')) {
+      this.fail('Code integration', 'api.js getThread not using SQLite');
+      return;
+    }
+
+    // Check 5: getInbox uses sqlite
+    if (!apiCode.includes('sqlite.getInboxThreads')) {
+      this.warn('Code integration', 'api.js getInbox might not be using SQLite optimally');
+    }
+
+    this.pass('Code integration', 'All critical V2 integration points found in api.js');
+  }
+
+  // Cleanup test data
+  cleanup() {
+    this.log('🧹', 'Cleaning up test data...');
+
+    try {
+      this.db.exec(`
+        DELETE FROM messages
+        WHERE from_handle LIKE 'test_%'
+           OR from_handle LIKE 'server_%'
+           OR to_handle LIKE 'test_%'
+           OR to_handle LIKE 'server_%'
+      `);
+      this.pass('Cleanup', 'Test data removed');
+    } catch (error) {
+      this.warn('Cleanup', error.message);
+    }
+  }
+
+  // Run all tests
+  async runAll() {
+    console.log('\n════════════════════════════════════════════════════════');
+    console.log('       V2 Postgres Integration Test Suite');
+    console.log('════════════════════════════════════════════════════════\n');
+
+    // Run tests
+    const schemaOk = this.testSchema();
+
+    if (schemaOk) {
+      const local_id = this.testMessageSaving();
+      this.testStatusUpdate(local_id);
+      this.testThreadRetrieval();
+      this.testMergeServerMessages();
+    }
+
+    this.testCodeIntegration();
+    this.cleanup();
+
+    // Print summary
+    console.log('\n════════════════════════════════════════════════════════');
+    console.log('                   Test Summary');
+    console.log('════════════════════════════════════════════════════════\n');
+
+    console.log(`✅ Passed:   ${this.results.passed.length}`);
+    console.log(`❌ Failed:   ${this.results.failed.length}`);
+    console.log(`⚠️  Warnings: ${this.results.warnings.length}`);
+
+    if (this.results.failed.length > 0) {
+      console.log('\n❌ Failed Tests:');
+      this.results.failed.forEach(({ test, error }) => {
+        console.log(`   - ${test}: ${error}`);
+      });
+    }
+
+    if (this.results.warnings.length > 0) {
+      console.log('\n⚠️  Warnings:');
+      this.results.warnings.forEach(({ test, message }) => {
+        console.log(`   - ${test}: ${message}`);
+      });
+    }
+
+    console.log('\n════════════════════════════════════════════════════════\n');
+
+    // Close database
+    this.db.close();
+
+    // Exit with appropriate code
+    process.exit(this.results.failed.length > 0 ? 1 : 0);
+  }
+}
+
+// Run tests
+if (require.main === module) {
+  const test = new V2IntegrationTest();
+  test.runAll();
+}
+
+module.exports = V2IntegrationTest;

package/webhook-runner.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+/**
+ * /vibe Webhook Server Runner
+ *
+ * Standalone webhook server for receiving real-time updates from external platforms.
+ * Run this on a public server to bridge external platforms into /vibe.
+ *
+ * Usage:
+ *   node webhook-runner.js [--port 3001]
+ *
+ * Environment Variables:
+ *   WEBHOOK_PORT=3001
+ *   WEBHOOK_SECRET=your-webhook-secret
+ *   TELEGRAM_WEBHOOK_SECRET=telegram-secret-token
+ *   DISCORD_PUBLIC_KEY=discord-public-key
+ */
+
+const express = require('express');
+const cors = require('cors');
+const { createWebhookHandler, getConfig, getSetupInstructions } = require('./bridges/webhook-server');
+
+const app = express();
+
+// Middleware
+app.use(cors());
+app.use(express.json({ limit: '10mb' }));
+app.use(express.raw({ type: 'application/json', limit: '10mb' }));
+
+// Health check
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    service: 'vibe-webhook-server',
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Setup info endpoint
+app.get('/setup', (req, res) => {
+  const instructions = getSetupInstructions();
+  res.json({
+    service: '/vibe Webhook Server',
+    instructions,
+    endpoints: {
+      telegram: '/webhook/telegram',
+      discord: '/webhook/discord',
+      health: '/health'
+    }
+  });
+});
+
+// Webhook endpoints
+app.use('/webhook', createWebhookHandler());
+
+// Error handler
+app.use((err, req, res, next) => {
+  console.error('Webhook server error:', err);
+  res.status(500).json({
+    error: 'Internal server error',
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Start server
+function startServer() {
+  const config = getConfig();
+  const port = config.port;
+
+  const server = app.listen(port, () => {
+    console.log(`🌉 /vibe webhook server running on port ${port}`);
+    console.log();
+    console.log('📡 Endpoints:');
+    console.log(`   Health:   http://localhost:${port}/health`);
+    console.log(`   Setup:    http://localhost:${port}/setup`);
+    console.log(`   Telegram: http://localhost:${port}/webhook/telegram`);
+    console.log(`   Discord:  http://localhost:${port}/webhook/discord`);
+    console.log();
+    console.log('🔧 Configuration:');
+    console.log(`   Port: ${port}`);
+    console.log(`   Webhook Secret: ${config.secret ? '✅ Set' : '❌ Not set'}`);
+    console.log(`   Telegram Secret: ${config.telegramSecret ? '✅ Set' : '❌ Not set'}`);
+    console.log(`   Discord Public Key: ${config.discordPublicKey ? '✅ Set' : '❌ Not set'}`);
+    console.log();
+    console.log('Visit /setup endpoint for platform-specific setup instructions.');
+  });
+
+  // Graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\n🛑 Shutting down webhook server...');
+    server.close(() => {
+      console.log('✅ Webhook server stopped');
+      process.exit(0);
+    });
+  });
+
+  return server;
+}
+
+// CLI handling
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+/vibe Webhook Server
+
+Usage:
+  node webhook-runner.js [options]
+
+Options:
+  --port PORT    Webhook server port (default: 3001)
+  --help, -h     Show this help
+
+Environment Variables:
+  WEBHOOK_PORT              Webhook server port
+  WEBHOOK_SECRET           Secret for webhook signature verification
+  TELEGRAM_WEBHOOK_SECRET  Telegram webhook secret token
+  DISCORD_PUBLIC_KEY       Discord application public key
+
+Examples:
+  node webhook-runner.js
+  node webhook-runner.js --port 8080
+  WEBHOOK_PORT=3001 node webhook-runner.js
+`);
+    process.exit(0);
+  }
+
+  startServer();
+}
+
+module.exports = { app, startServer };