slashvibe-mcp 0.3.20 → 0.3.21

package/tools/_work-context.test.js

@@ -0,0 +1,260 @@
+/**
+ * Tests for _work-context.js
+ *
+ * Run with: node --test tools/_work-context.test.js
+ * Or: node tools/_work-context.test.js (for quick inline tests)
+ */
+
+const { test, describe } = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+
+const {
+  gatherWorkContext,
+  gatherWithTimeout,
+  getGitInfo,
+  getProjectInfo,
+  sanitize,
+  redact,
+  cap
+} = require('./_work-context');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// UNIT TESTS: Utility functions
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('sanitize()', () => {
+  test('removes ANSI escape sequences', () => {
+    const input = '\x1B[31mRed text\x1B[0m';
+    assert.strictEqual(sanitize(input), 'Red text');
+  });
+
+  test('removes control characters but keeps newlines/tabs', () => {
+    const input = 'Hello\x00World\tTab\nNewline';
+    assert.strictEqual(sanitize(input), 'HelloWorld\tTab\nNewline');
+  });
+
+  test('handles null/undefined gracefully', () => {
+    assert.strictEqual(sanitize(null), null);
+    assert.strictEqual(sanitize(undefined), undefined);
+  });
+
+  test('trims whitespace', () => {
+    assert.strictEqual(sanitize('  hello  '), 'hello');
+  });
+});
+
+describe('cap()', () => {
+  test('returns original if under limit', () => {
+    assert.strictEqual(cap('hello', 10), 'hello');
+  });
+
+  test('truncates with ellipsis if over limit', () => {
+    assert.strictEqual(cap('hello world', 8), 'hello w…');
+  });
+
+  test('handles exact length', () => {
+    assert.strictEqual(cap('hello', 5), 'hello');
+  });
+
+  test('handles null/undefined', () => {
+    assert.strictEqual(cap(null, 10), null);
+    assert.strictEqual(cap(undefined, 10), undefined);
+  });
+});
+
+describe('redact()', () => {
+  test('redacts email addresses', () => {
+    const input = 'Contact me at user@example.com';
+    assert.strictEqual(redact(input), 'Contact me at [REDACTED]');
+  });
+
+  test('redacts long hex strings (tokens)', () => {
+    const input = 'Value: a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6';
+    assert.strictEqual(redact(input), 'Value: [REDACTED]');
+  });
+
+  test('redacts OpenAI API keys', () => {
+    const input = 'Key: sk-1234567890abcdefghij1234567890';
+    assert.strictEqual(redact(input), 'Key: [REDACTED]');
+  });
+
+  test('redacts GitHub tokens', () => {
+    const input = 'ghp_abcdefghijklmnopqrstuvwxyz1234567890';
+    assert.strictEqual(redact(input), '[REDACTED]');
+  });
+
+  test('redacts sensitive words', () => {
+    const words = ['password', 'secret', 'token', 'api_key'];
+    words.forEach(word => {
+      assert.ok(redact(`My ${word} is hidden`).includes('[REDACTED]'));
+    });
+  });
+
+  test('handles null/undefined', () => {
+    assert.strictEqual(redact(null), null);
+    assert.strictEqual(redact(undefined), undefined);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INTEGRATION TESTS: Git info gathering
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('getGitInfo()', () => {
+  test('returns object with expected shape when in git repo', () => {
+    const info = getGitInfo();
+
+    // We're in the vibe-platform repo, so git should work
+    if (info) {
+      assert.ok(typeof info.branch === 'string', 'branch should be a string');
+      assert.ok(Array.isArray(info.recentCommits), 'recentCommits should be an array');
+      assert.ok(Array.isArray(info.changedFiles), 'changedFiles should be an array');
+      assert.ok(typeof info.hasUncommitted === 'boolean', 'hasUncommitted should be boolean');
+    }
+  });
+
+  test('commit messages are capped and redacted', () => {
+    const info = getGitInfo();
+    if (info && info.recentCommits.length > 0) {
+      const firstCommit = info.recentCommits[0];
+      assert.ok(firstCommit.message.length <= 80, 'commit message should be <= 80 chars');
+      assert.ok(firstCommit.hash.length <= 7, 'commit hash should be <= 7 chars');
+    }
+  });
+
+  test('changed files use basename only (no full paths)', () => {
+    const info = getGitInfo();
+    if (info && info.changedFiles.length > 0) {
+      info.changedFiles.forEach(file => {
+        assert.ok(!file.includes('/'), `file "${file}" should not contain path separators`);
+      });
+    }
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INTEGRATION TESTS: Project info gathering
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('getProjectInfo()', () => {
+  test('returns object with expected shape', () => {
+    const info = getProjectInfo();
+
+    assert.ok(typeof info.name === 'string', 'name should be a string');
+    assert.ok(typeof info.type === 'string', 'type should be a string');
+    assert.ok(typeof info.directory === 'string', 'directory should be a string');
+  });
+
+  test('detects project name from package.json', () => {
+    const info = getProjectInfo();
+    // We're in mcp-server which has a package.json
+    assert.strictEqual(info.name, 'slashvibe-mcp');
+  });
+
+  test('detects project type', () => {
+    const info = getProjectInfo();
+    // This is a Node.js project
+    assert.ok(['node', 'typescript', 'react', 'nextjs'].includes(info.type));
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INTEGRATION TESTS: Full context gathering
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('gatherWorkContext()', () => {
+  test('returns complete context object', () => {
+    const ctx = gatherWorkContext();
+
+    assert.ok(ctx.git !== undefined, 'should have git property');
+    assert.ok(ctx.project !== undefined, 'should have project property');
+    assert.ok(ctx.suggestions !== undefined, 'should have suggestions property');
+  });
+
+  test('suggestions.brief is reasonably short', () => {
+    const ctx = gatherWorkContext();
+    assert.ok(ctx.suggestions.brief.length <= 200, 'brief should be <= 200 chars');
+  });
+
+  test('suggestions.detailed exists', () => {
+    const ctx = gatherWorkContext();
+    assert.ok(typeof ctx.suggestions.detailed === 'string');
+  });
+});
+
+describe('gatherWithTimeout()', () => {
+  test('resolves within timeout', async () => {
+    const start = Date.now();
+    const ctx = await gatherWithTimeout(5000);
+    const elapsed = Date.now() - start;
+
+    assert.ok(elapsed < 5000, 'should resolve before timeout');
+    assert.ok(ctx.suggestions !== undefined, 'should have suggestions');
+  });
+
+  test('provides fallback on very short timeout', async () => {
+    // 1ms timeout should trigger fallback
+    const ctx = await gatherWithTimeout(1);
+
+    // Should still have basic structure
+    assert.ok(ctx.project !== undefined);
+    assert.ok(ctx.suggestions !== undefined);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SECURITY TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('Security: Shell injection prevention', () => {
+  test('branch names with shell metacharacters are safe', () => {
+    // This test verifies we're using execFileSync, not execSync
+    // If we were vulnerable, a branch like "; rm -rf /" would execute
+    // Since we use execFileSync with shell: false, it's treated as literal text
+    const info = getGitInfo();
+    // If we got here without error, shell injection was prevented
+    assert.ok(true, 'No shell injection occurred');
+  });
+});
+
+describe('Security: Output sanitization', () => {
+  test('ANSI escape sequences in commit messages are stripped', () => {
+    const ctx = gatherWorkContext();
+    if (ctx.git?.recentCommits?.length > 0) {
+      ctx.git.recentCommits.forEach(commit => {
+        assert.ok(!commit.message.includes('\x1B'), 'should not contain ANSI escapes');
+      });
+    }
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Run tests when executed directly
+// ═══════════════════════════════════════════════════════════════════════════
+
+if (require.main === module) {
+  console.log('Running _work-context.js tests...\n');
+  console.log('Use: node --test tools/_work-context.test.js');
+  console.log('Or run this file directly for a quick smoke test.\n');
+
+  // Quick smoke test
+  console.log('=== Quick Smoke Test ===\n');
+
+  const ctx = gatherWorkContext();
+  console.log('Project:', ctx.project?.name);
+  console.log('Type:', ctx.project?.type);
+  console.log('Branch:', ctx.git?.branch || 'N/A');
+  console.log('Recent commits:', ctx.git?.recentCommits?.length || 0);
+  console.log('Changed files:', ctx.git?.changedFiles?.length || 0);
+  console.log('Has uncommitted:', ctx.git?.hasUncommitted);
+  console.log('\nBrief summary:', ctx.suggestions?.brief);
+  console.log('Detailed summary:', ctx.suggestions?.detailed);
+
+  console.log('\n=== Sanitization Tests ===\n');
+  console.log('sanitize("\\x1B[31mred\\x1B[0m"):', sanitize('\x1B[31mred\x1B[0m'));
+  console.log('cap("hello world", 8):', cap('hello world', 8));
+  console.log('redact("email: a@b.com"):', redact('email: a@b.com'));
+
+  console.log('\n✓ All smoke tests passed\n');
+}

package/tools/activity.js

@@ -0,0 +1,220 @@
+/**
+ * vibe activity — See what's happening on /vibe
+ *
+ * Real-time activity feed showing:
+ * - Ships (what people are shipping)
+ * - Joins (who just joined)
+ * - Help requests (who needs help)
+ * - Online activity (who's active)
+ *
+ * Creates FOMO, drives engagement
+ */
+
+const config = require('../config');
+const { requireInit } = require('./_shared');
+const { actions, formatActions } = require('./_actions');
+
+const definition = {
+  name: 'vibe_activity',
+  description: 'See what\'s happening on /vibe - ships, joins, help requests, and online activity.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      filter: {
+        type: 'string',
+        enum: ['all', 'ships', 'joins', 'help', 'online'],
+        description: 'Filter by activity type (default: all)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of activities to show (default: 15)'
+      }
+    }
+  }
+};
+
+// Activity type to emoji mapping
+const TYPE_ICONS = {
+  ship: '🚀',
+  join: '👋',
+  help: '🆘',
+  online: '🟢',
+  achievement: '🏆',
+};
+
+// Format relative time
+function formatTimeAgo(timestamp) {
+  const now = Date.now();
+  const time = new Date(timestamp).getTime();
+  const seconds = Math.floor((now - time) / 1000);
+
+  if (seconds < 60) return 'just now';
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { filter = 'all', limit = 15 } = args;
+  const apiUrl = config.getApiUrl();
+
+  // Build query params
+  const params = new URLSearchParams();
+  params.set('limit', String(limit));
+
+  if (filter !== 'all') {
+    // Map filter to API type
+    const typeMap = {
+      ships: 'ship',
+      joins: 'join',
+      help: 'help',
+      online: 'online',
+    };
+    params.set('types', typeMap[filter] || filter);
+  }
+
+  try {
+    const response = await fetch(`${apiUrl}/api/feed?${params.toString()}`, {
+      headers: { 'User-Agent': 'vibe-mcp-client' }
+    });
+
+    if (!response.ok) {
+      return {
+        display: '❌ Failed to fetch activity feed. Try again later.'
+      };
+    }
+
+    const data = await response.json();
+
+    if (!data.success || !data.activities || data.activities.length === 0) {
+      return {
+        display: `## 📡 Activity Feed
+
+_No recent activity to show._
+
+**Be the first!**
+- Ship something: \`vibe ship "Built a cool feature"\`
+- Ask for help: \`vibe stuck "Need help with auth"\`
+- Say hi: \`vibe dm @someone hello!\``
+      };
+    }
+
+    let display = `## 📡 Activity Feed\n\n`;
+
+    // Group by time period for better display
+    const { grouped } = data;
+
+    if (grouped.recent?.length > 0) {
+      display += `**🔴 Live (last 30 min)**\n\n`;
+      for (const activity of grouped.recent) {
+        display += formatActivity(activity);
+      }
+      display += '\n';
+    }
+
+    if (grouped.today?.length > 0) {
+      display += `**📅 Today**\n\n`;
+      for (const activity of grouped.today) {
+        display += formatActivity(activity);
+      }
+      display += '\n';
+    }
+
+    if (grouped.earlier?.length > 0) {
+      display += `**📆 Earlier**\n\n`;
+      for (const activity of grouped.earlier.slice(0, 5)) {
+        display += formatActivity(activity);
+      }
+    }
+
+    // Quick stats
+    const shipCount = data.activities.filter(a => a.type === 'ship').length;
+    const onlineCount = data.activities.filter(a => a.type === 'online').length;
+    const helpCount = data.activities.filter(a => a.type === 'help').length;
+
+    display += `---\n`;
+    display += `${shipCount} ships · ${onlineCount} active · ${helpCount} need help\n`;
+
+    // Add filter hint
+    display += `\n_Filter: \`vibe activity --filter ships\` or \`help\` or \`joins\`_`;
+
+    const response_data = { display };
+
+    // Suggest actions based on what's happening
+    const actionList = [];
+
+    // If there's a help request, suggest helping
+    const helpActivity = data.activities.find(a => a.type === 'help');
+    if (helpActivity) {
+      actionList.push({
+        label: `Help @${helpActivity.handle}`,
+        action: `vibe stuck offer ${helpActivity.handle}`,
+        description: `They need help with: ${helpActivity.content?.slice(0, 40)}...`
+      });
+    }
+
+    // If someone shipped, suggest reacting
+    const shipActivity = data.activities.find(a => a.type === 'ship');
+    if (shipActivity) {
+      actionList.push({
+        label: `React to @${shipActivity.handle}'s ship`,
+        action: `vibe react fire to @${shipActivity.handle}`,
+        description: `Shipped: ${shipActivity.content?.slice(0, 40)}...`
+      });
+    }
+
+    // If someone just joined, suggest welcoming
+    const joinActivity = data.activities.find(a => a.type === 'join');
+    if (joinActivity) {
+      actionList.push({
+        label: `Welcome @${joinActivity.handle}`,
+        action: `vibe dm @${joinActivity.handle} Welcome to /vibe!`,
+        description: 'Say hi to the new builder'
+      });
+    }
+
+    if (actionList.length > 0) {
+      response_data.actions = formatActions(actionList);
+    }
+
+    return response_data;
+
+  } catch (error) {
+    console.error('[vibe_activity] Error:', error.message);
+    return {
+      display: '❌ Failed to fetch activity feed. Check your connection.'
+    };
+  }
+}
+
+function formatActivity(activity) {
+  const icon = activity.icon || TYPE_ICONS[activity.type] || '•';
+  const time = formatTimeAgo(activity.timestamp);
+
+  switch (activity.type) {
+    case 'ship':
+      return `${icon} **@${activity.handle}** shipped: ${activity.content || 'something'}\n   _${time}_\n\n`;
+
+    case 'join':
+      const name = activity.github_name ? ` (${activity.github_name})` : '';
+      return `${icon} **@${activity.handle}**${name} joined /vibe\n   _${time}_\n\n`;
+
+    case 'help':
+      const urgency = activity.urgency === 'high' ? ' 🔴' : '';
+      return `${icon} **@${activity.handle}** needs help${urgency}: ${activity.content || 'something'}\n   _${time}_\n\n`;
+
+    case 'online':
+      return `${icon} **@${activity.handle}** is building: ${activity.content || 'something'}\n   _${time}_\n\n`;
+
+    case 'achievement':
+      return `${icon} **@${activity.handle}** earned: ${activity.content}\n   _${time}_\n\n`;
+
+    default:
+      return `• **@${activity.handle}**: ${activity.content || ''}\n   _${time}_\n\n`;
+  }
+}
+
+module.exports = { definition, handler };

package/tools/analytics.js

@@ -0,0 +1,191 @@
+/**
+ * vibe analytics — Real-time launch metrics for terminal
+ *
+ * Shows live platform metrics in a terminal-friendly format.
+ * Perfect for monitoring during Watch Me Code launch.
+ *
+ * Commands:
+ * - analytics (default) — Launch dashboard with all metrics
+ * - analytics presence — Who's online right now
+ * - analytics sessions — Live streaming stats
+ * - analytics health — System health status
+ */
+
+const config = require('../config');
+
+const API_BASE = 'https://www.slashvibe.dev/api';
+
+const definition = {
+  name: 'vibe_analytics',
+  description: 'Real-time launch metrics. Shows presence, sessions, health. Perfect for launch monitoring.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      view: {
+        type: 'string',
+        enum: ['dashboard', 'presence', 'sessions', 'health'],
+        description: 'Which view to show (default: dashboard)'
+      }
+    }
+  }
+};
+
+// Fetch launch metrics from API
+async function fetchLaunchMetrics() {
+  try {
+    const res = await fetch(`${API_BASE}/analytics/launch`);
+    const data = await res.json();
+    return data.success ? data : null;
+  } catch (e) {
+    console.error('[analytics] Fetch error:', e.message);
+    return null;
+  }
+}
+
+// Format the full dashboard view
+function formatDashboard(data) {
+  const { presence, sessions, growth, viral, health, countdown } = data;
+
+  const lines = [
+    '',
+    '╔══════════════════════════════════════════════════════════════╗',
+    `║  🚀 LAUNCH COMMAND CENTER              ${countdown.padStart(20)} ║`,
+    '╠══════════════════════════════════════════════════════════════╣',
+    '║                                                              ║',
+    '║  PRESENCE                    LIVE SESSIONS                   ║',
+    `║  🟢 Online: ${String(presence.online).padEnd(6)}            📺 Live Now: ${String(sessions.live_now).padEnd(5)}            ║`,
+    `║  🟡 Away:   ${String(presence.away).padEnd(6)}            👀 Viewers:  ${String(sessions.viewers_now).padEnd(5)}            ║`,
+    `║  Total:    ${String(presence.total_active).padEnd(6)}            🔥 Reactions: ${String(sessions.reactions_now || 0).padEnd(5)}          ║`,
+    '║                                                              ║',
+    '╠══════════════════════════════════════════════════════════════╣',
+    '║  GROWTH TODAY                VIRAL                           ║',
+    `║  📝 Registrations: ${String(growth.registrations_today).padEnd(4)}       📨 Invites:  ${String(viral.invites_sent_today).padEnd(5)}           ║`,
+    `║  💬 Messages:      ${String(growth.messages_today).padEnd(4)}       🔗 Shares:   ${String(viral.share_link_clicks_today).padEnd(5)}           ║`,
+    `║  🚀 Ships:         ${String(growth.ships_today).padEnd(4)}       🖼️  OG Views: ${String(viral.og_image_requests_today).padEnd(5)}           ║`,
+    '║                                                              ║',
+    '╠══════════════════════════════════════════════════════════════╣',
+    '║  HEALTH                                                      ║',
+    `║  Status: ${health.status === 'healthy' ? '✅ Healthy' : health.status === 'degraded' ? '⚠️  Degraded' : '❌ Unhealthy'}    Latency: ${String(health.api_latency_ms).padEnd(4)}ms                ║`,
+    `║  KV: ${health.kv_healthy ? '✅' : '❌'}    Postgres: ${health.db_healthy ? '✅' : '❌'}                                       ║`,
+    '║                                                              ║',
+    '╚══════════════════════════════════════════════════════════════╝',
+    '',
+  ];
+
+  return lines.join('\n');
+}
+
+// Format presence view
+function formatPresence(data) {
+  const { presence } = data;
+
+  return `
+**Presence** (real-time)
+
+🟢 **${presence.online}** online now
+🟡 **${presence.away}** away
+📊 **${presence.total_active}** total active
+
+_Updated: ${new Date().toLocaleTimeString()}_
+`;
+}
+
+// Format sessions view
+function formatSessions(data) {
+  const { sessions } = data;
+
+  if (sessions.live_now === 0) {
+    return `
+**Live Sessions**
+
+No live sessions right now.
+
+📺 Sessions today: ${sessions.started_today}
+🔗 Shares today: ${sessions.shares_today}
+✂️ Clips today: ${sessions.clips_today}
+
+_Start streaming with \`vibe broadcast start "title"\`_
+`;
+  }
+
+  let display = `
+**Live Sessions** 📺
+
+🔴 **${sessions.live_now}** live now
+👀 **${sessions.viewers_now}** watching
+🔥 **${sessions.reactions_now || 0}** reactions
+`;
+
+  // Show top streams if available
+  if (sessions.live_streams && sessions.live_streams.length > 0) {
+    display += '\n**Active Streams:**\n';
+    for (const stream of sessions.live_streams) {
+      display += `• @${stream.handle}: ${stream.viewers} viewers, ${stream.durationMins}m\n`;
+      display += `  ${stream.watchUrl}\n`;
+    }
+  }
+
+  display += `
+Today:
+- ${sessions.started_today} sessions started
+- ${sessions.shares_today} shares
+- ${sessions.clips_today} clips
+
+_Watch live at slashvibe.dev/live_
+`;
+
+  return display;
+}
+
+// Format health view
+function formatHealth(data) {
+  const { health } = data;
+
+  const statusEmoji = health.status === 'healthy' ? '✅' : health.status === 'degraded' ? '⚠️' : '❌';
+
+  return `
+**System Health** ${statusEmoji}
+
+Status: **${health.status}**
+Latency: ${health.api_latency_ms}ms
+
+Services:
+- KV Storage: ${health.kv_healthy ? '✅ Healthy' : '❌ Down'}
+- PostgreSQL: ${health.db_healthy ? '✅ Healthy' : '❌ Down'}
+
+_Check slashvibe.dev/mission-control for full dashboard_
+`;
+}
+
+async function handler(args) {
+  const view = args.view || 'dashboard';
+
+  const data = await fetchLaunchMetrics();
+
+  if (!data) {
+    return {
+      display: '❌ Could not fetch analytics. Check your connection.'
+    };
+  }
+
+  let display;
+
+  switch (view) {
+    case 'presence':
+      display = formatPresence(data);
+      break;
+    case 'sessions':
+      display = formatSessions(data);
+      break;
+    case 'health':
+      display = formatHealth(data);
+      break;
+    case 'dashboard':
+    default:
+      display = formatDashboard(data);
+  }
+
+  return { display };
+}
+
+module.exports = { definition, handler };