slashvibe-mcp 0.3.20 → 0.3.21

package/tools/session.js

@@ -0,0 +1,467 @@
+/**
+ * vibe session — Session management
+ *
+ * Save broadcasts as replayable sessions, browse sessions, and fork them.
+ *
+ * Commands:
+ * - session save              → Save current/recent broadcast as session
+ * - session save --room X     → Save specific broadcast
+ * - session list              → List my sessions
+ * - session browse            → Browse all public sessions
+ * - session fork <id>         → Fork a session (story only)
+ * - session fork <id> --full  → Fork with git bundle (get actual code)
+ * - session view <id>         → View session details
+ */
+
+const config = require('../config');
+const gitApply = require('./lib/git-apply');
+
+const definition = {
+  name: 'vibe_session',
+  description: 'Save broadcasts as sessions, list your sessions, fork others\' sessions.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['save', 'list', 'browse', 'fork', 'view'],
+        description: 'Action: save, list, browse, fork, or view'
+      },
+      room: {
+        type: 'string',
+        description: 'Room ID to save (for save action)'
+      },
+      id: {
+        type: 'string',
+        description: 'Session ID (for fork/view action)'
+      },
+      title: {
+        type: 'string',
+        description: 'Session title (for save action)'
+      },
+      visibility: {
+        type: 'string',
+        enum: ['public', 'unlisted', 'private'],
+        description: 'Session visibility (default: public)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Number of sessions to show (default: 10)'
+      },
+      full: {
+        type: 'boolean',
+        description: 'For fork: download git bundle and apply locally (default: false)'
+      },
+      branch: {
+        type: 'string',
+        description: 'For fork --full: branch name for applied code (default: forked-session)'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const myHandle = config.getHandle();
+  const apiUrl = config.getApiUrl();
+  const action = args.action || 'list';
+
+  if (!myHandle && action !== 'browse' && action !== 'view') {
+    return { display: '⚠️ Not initialized. Run `vibe init` first.' };
+  }
+
+  // SAVE broadcast as session
+  if (action === 'save') {
+    // Get room ID from args or from active broadcast
+    let roomId = args.room;
+
+    if (!roomId) {
+      // Check for active broadcast
+      const broadcast = config.get('broadcast');
+      if (broadcast) {
+        roomId = broadcast.roomId;
+      }
+    }
+
+    if (!roomId) {
+      return {
+        display: `⚠️ No broadcast to save.\n\n**Options:**\n1. Specify a room: \`vibe session save --room room_xxx\`\n2. Start a broadcast first: \`vibe broadcast start\``
+      };
+    }
+
+    const title = args.title || `Session by @${myHandle}`;
+    const visibility = args.visibility || 'public';
+
+    try {
+      const response = await fetch(`${apiUrl}/api/sessions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          fromBroadcast: roomId,
+          handle: myHandle,
+          title,
+          visibility
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        if (data.error?.includes('buffer not found')) {
+          return {
+            display: `⚠️ Broadcast buffer expired.\n\n_Buffers expire 1 hour after broadcast ends. Start a new broadcast to create a session._`
+          };
+        }
+        return { display: `⚠️ Failed to save session: ${data.error}` };
+      }
+
+      const formatDuration = (secs) => {
+        if (!secs || secs < 60) return 'under 1 minute';
+        if (secs < 3600) return `${Math.floor(secs / 60)} minutes`;
+        return `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
+      };
+
+      // Chapter icons for display
+      const chapterIcons = {
+        setup: '🔧',
+        problem: '❌',
+        investigation: '🔍',
+        breakthrough: '💡',
+        implementation: '⚡',
+        ship: '🚀'
+      };
+
+      let display = `✅ **Session Saved**\n\n`;
+      display += `**${data.title}**\n\n`;
+      display += `📎 ${data.shareUrl}\n\n`;
+      display += `**Stats:**\n`;
+      display += `- Duration: ${formatDuration(data.stats?.durationSeconds)}\n`;
+      display += `- Chunks: ${data.stats?.chunks || 0}\n`;
+
+      // Show chapters if detected
+      const chapters = data.chapters || [];
+      if (chapters.length > 0) {
+        display += `- Chapters: ${chapters.length}\n\n`;
+        display += `📖 **Story Arc:**\n`;
+        const chapterFlow = chapters.map(ch => {
+          const icon = chapterIcons[ch.type] || '📋';
+          return `${icon} ${ch.title}`;
+        }).join(' → ');
+        display += `   ${chapterFlow}\n\n`;
+      } else {
+        display += `- Fork points: ${data.stats?.forkPoints || 0}\n\n`;
+      }
+
+      display += `_Share this URL or find it later with \`vibe session list\`_`;
+
+      return { display };
+
+    } catch (error) {
+      return { display: `## Save Error\n\n${error.message}` };
+    }
+  }
+
+  // LIST my sessions
+  if (action === 'list') {
+    const limit = args.limit || 10;
+
+    try {
+      const response = await fetch(
+        `${apiUrl}/api/sessions/browse?author=${myHandle}&limit=${limit}`,
+        { headers: { 'Accept': 'application/json' } }
+      );
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ Failed to fetch sessions: ${data.error}` };
+      }
+
+      if (!data.sessions || data.sessions.length === 0) {
+        let display = `📼 **No Sessions Yet**\n\n`;
+        display += `You haven't saved any sessions.\n\n`;
+        display += `**Create your first session:**\n`;
+        display += `1. \`vibe broadcast start "What you're building"\`\n`;
+        display += `2. Code for a while...\n`;
+        display += `3. \`vibe broadcast stop\`\n`;
+        display += `4. \`vibe session save\``;
+        return { display };
+      }
+
+      const formatDuration = (secs) => {
+        if (!secs || secs < 60) return '<1m';
+        if (secs < 3600) return `${Math.floor(secs / 60)}m`;
+        return `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
+      };
+
+      const formatDate = (dateStr) => {
+        const date = new Date(dateStr);
+        return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+      };
+
+      let display = `📼 **Your Sessions** (${data.sessions.length}${data.hasMore ? '+' : ''})\n\n`;
+
+      for (const s of data.sessions) {
+        const duration = formatDuration(s.duration_seconds);
+        const date = formatDate(s.created_at);
+        const views = s.views || 0;
+        const forks = s.forks || 0;
+
+        display += `**${s.title}**\n`;
+        display += `   ${date} · ${duration}`;
+        if (views > 0) display += ` · ${views} views`;
+        if (forks > 0) display += ` · ${forks} forks`;
+        display += `\n`;
+        display += `   → \`vibe session view ${s.id}\`\n\n`;
+      }
+
+      if (data.hasMore) {
+        display += `_More sessions available. Use \`--limit 20\` to see more._`;
+      }
+
+      return { display };
+
+    } catch (error) {
+      return { display: `## List Error\n\n${error.message}` };
+    }
+  }
+
+  // BROWSE all public sessions
+  if (action === 'browse') {
+    const limit = args.limit || 10;
+
+    try {
+      const response = await fetch(
+        `${apiUrl}/api/sessions/browse?limit=${limit}&sort=popular`,
+        { headers: { 'Accept': 'application/json' } }
+      );
+
+      const data = await response.json();
+
+      if (!data.success) {
+        return { display: `⚠️ Failed to fetch sessions: ${data.error}` };
+      }
+
+      if (!data.sessions || data.sessions.length === 0) {
+        return {
+          display: `📼 No public sessions yet.\n\n_Be the first! Start a broadcast and save it._`
+        };
+      }
+
+      const formatDuration = (secs) => {
+        if (!secs || secs < 60) return '<1m';
+        if (secs < 3600) return `${Math.floor(secs / 60)}m`;
+        return `${Math.floor(secs / 3600)}h`;
+      };
+
+      let display = `📼 **Public Sessions** (${data.total} total)\n\n`;
+
+      for (const s of data.sessions) {
+        const duration = formatDuration(s.duration_seconds);
+        const views = s.views || 0;
+        const forks = s.forks || 0;
+
+        display += `**${s.title}** by @${s.author_handle}\n`;
+        display += `   ${duration}`;
+        if (views > 0) display += ` · ${views} views`;
+        if (forks > 0) display += ` · ${forks} forks`;
+        display += `\n`;
+        display += `   → \`vibe session view ${s.id}\`\n\n`;
+      }
+
+      if (data.hasMore) {
+        display += `_More sessions available. Use \`--limit 20\` to see more._`;
+      }
+
+      return { display };
+
+    } catch (error) {
+      return { display: `## Browse Error\n\n${error.message}` };
+    }
+  }
+
+  // VIEW session details
+  if (action === 'view') {
+    if (!args.id) {
+      return { display: '⚠️ Session ID required. Usage: `vibe session view ses_xxx`' };
+    }
+
+    const sessionId = args.id;
+
+    try {
+      // Use the story endpoint which returns full session details
+      const response = await fetch(`${apiUrl}/story/${sessionId}?format=json`);
+
+      if (!response.ok) {
+        return {
+          display: `⚠️ Session not found: ${sessionId}\n\n_Check the ID or browse sessions with \`vibe session browse\`_`
+        };
+      }
+
+      const data = await response.json();
+
+      if (!data.success && !data.session) {
+        return { display: `⚠️ Failed to fetch session: ${data.error}` };
+      }
+
+      const s = data.session || data.story || data;
+
+      const formatDuration = (secs) => {
+        if (!secs || secs < 60) return 'under 1 minute';
+        if (secs < 3600) return `${Math.floor(secs / 60)} minutes`;
+        return `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
+      };
+
+      // Chapter icons for display
+      const chapterIcons = {
+        setup: '🔧',
+        problem: '❌',
+        investigation: '🔍',
+        breakthrough: '💡',
+        implementation: '⚡',
+        ship: '🚀'
+      };
+
+      let display = `📼 **${s.title}**\n\n`;
+      display += `**Author:** @${s.author || s.author_handle}\n`;
+      display += `**Duration:** ${formatDuration(s.durationSeconds || s.duration_seconds)}\n`;
+      display += `**Views:** ${s.views || 0}\n`;
+      display += `**Forks:** ${s.forks || 0}\n\n`;
+
+      // Display chapters if available
+      const chapters = s.chapters || [];
+      if (chapters.length > 0) {
+        display += `📖 **Chapters** (${chapters.length})\n`;
+        for (let i = 0; i < chapters.length; i++) {
+          const ch = chapters[i];
+          const icon = chapterIcons[ch.type] || '📋';
+          display += `   ${i + 1}. ${icon} **${ch.title}** (${ch.startTime || '0:00'})\n`;
+          if (ch.summary) {
+            display += `      _${ch.summary.slice(0, 60)}${ch.summary.length > 60 ? '...' : ''}_\n`;
+          }
+        }
+        display += '\n';
+      }
+
+      // Display fork points if available
+      const forkPoints = s.forkPoints || [];
+      if (forkPoints.length > 0) {
+        display += `🔀 **Fork Points** (${forkPoints.length})\n`;
+        for (const fp of forkPoints.slice(0, 5)) {
+          display += `   - ${fp.label}: ${fp.description || ''}\n`;
+        }
+        if (forkPoints.length > 5) {
+          display += `   _...and ${forkPoints.length - 5} more_\n`;
+        }
+        display += '\n';
+      }
+
+      if (s.description) {
+        display += `**Description:**\n${s.description}\n\n`;
+      }
+
+      if (s.summary) {
+        display += `**Summary:**\n${s.summary}\n\n`;
+      }
+
+      display += `**View full session:**\n`;
+      display += `https://slashvibe.dev/story/${sessionId}\n\n`;
+
+      display += `**Actions:**\n`;
+      display += `- Fork: \`vibe session fork ${sessionId}\`\n`;
+
+      return { display };
+
+    } catch (error) {
+      return { display: `## View Error\n\n${error.message}` };
+    }
+  }
+
+  // FORK a session
+  if (action === 'fork') {
+    if (!args.id) {
+      return { display: '⚠️ Session ID required. Usage: `vibe session fork ses_xxx`' };
+    }
+
+    const sessionId = args.id;
+    const fullFork = args.full === true;
+    const branchName = args.branch || 'forked-session';
+    const forkLevel = fullFork ? 'full' : 'story_only';
+
+    try {
+      const response = await fetch(`${apiUrl}/api/sessions/fork`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          parentSessionId: sessionId,
+          forkerHandle: myHandle,
+          forkTo: 'session',
+          forkLevel
+        })
+      });
+
+      const data = await response.json();
+
+      if (!data.success) {
+        if (data.error?.includes('not found')) {
+          return {
+            display: `⚠️ Session not found: ${sessionId}\n\n_Check the ID or browse sessions with \`vibe session browse\`_`
+          };
+        }
+        if (data.error?.includes('private')) {
+          return { display: `⚠️ Cannot fork a private session.` };
+        }
+        return { display: `⚠️ Failed to fork session: ${data.error}` };
+      }
+
+      let display = `🍴 **Session Forked!**\n\n`;
+      display += `**From:** ${data.parentSession?.title || sessionId}\n`;
+      display += `**By:** @${data.parentSession?.author || 'unknown'}\n\n`;
+      display += `**Fork ID:** ${data.forkId}\n\n`;
+
+      // Handle full fork with git bundle
+      if (fullFork && data.git?.bundleDownloadUrl) {
+        display += `📦 **Downloading git bundle...**\n`;
+
+        const applyResult = await gitApply.applyBundleFromUrl(
+          data.git.bundleDownloadUrl,
+          branchName
+        );
+
+        if (applyResult.success) {
+          display += `✅ **Code applied to branch:** \`${applyResult.branch}\`\n\n`;
+          display += `**Git info:**\n`;
+          display += `- Branch: ${data.git.branch || 'unknown'}\n`;
+          display += `- Commits: ${data.git.initialCommit?.slice(0, 7)}..${data.git.finalCommit?.slice(0, 7)}\n`;
+          display += `- Bundle size: ${Math.round(applyResult.size / 1024)}KB\n\n`;
+          display += `**Next steps:**\n`;
+          display += `\`\`\`\ngit checkout ${applyResult.branch}\n\`\`\`\n`;
+        } else {
+          display += `⚠️ **Bundle apply failed:** ${applyResult.error}\n\n`;
+          display += `_The session was forked, but the code bundle could not be applied._\n`;
+          display += `_You can still view the story at the URL below._\n\n`;
+        }
+      } else if (fullFork && data.git?.hasBundleAvailable && !data.git?.bundleDownloadUrl) {
+        display += `⚠️ **Git bundle not available** (R2 storage may not be configured)\n\n`;
+      } else if (fullFork && !data.git?.hasBundleAvailable) {
+        display += `ℹ️ **No git bundle** for this session (no commits during broadcast)\n\n`;
+      }
+
+      display += `**View the story:**\n${data.storyUrl}\n\n`;
+
+      if (!fullFork && data.git?.hasBundleAvailable) {
+        display += `_💡 Want the actual code? Use \`vibe session fork ${sessionId} --full\`_`;
+      } else if (!fullFork) {
+        display += `_Learn from this session and build your own version!_`;
+      }
+
+      return { display };
+
+    } catch (error) {
+      return { display: `## Fork Error\n\n${error.message}` };
+    }
+  }
+
+  return { display: 'Unknown action. Use: save, list, browse, view, or fork' };
+}
+
+module.exports = { definition, handler };

package/tools/session_price.js

@@ -0,0 +1,128 @@
+/**
+ * vibe_session_price - Set session access type and price
+ *
+ * Configure how others can access your sessions:
+ * - public: Free for all
+ * - ppv: Pay-per-view ($1-$50)
+ * - subscribers_only: Requires active subscription
+ * - private: Creator only
+ *
+ * Examples:
+ * - "set session to ppv $5"
+ * - "make my session public"
+ * - "set session price to $10"
+ */
+
+const fetch = require('node-fetch');
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_session_price',
+  description: 'Set session access type and price. Options: public (free), ppv ($1-$50), subscribers_only, private.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      session_id: {
+        type: 'string',
+        description: 'Session ID to configure (defaults to current session if available)'
+      },
+      access_type: {
+        type: 'string',
+        enum: ['public', 'ppv', 'subscribers_only', 'private'],
+        description: 'Access type: public (free), ppv (pay-per-view), subscribers_only, private'
+      },
+      price_dollars: {
+        type: 'number',
+        description: 'Price in dollars for PPV access (1-50). Required if access_type is ppv.'
+      }
+    },
+    required: ['access_type']
+  }
+};
+
+async function handler(args) {
+  const { session_id, access_type, price_dollars } = args;
+
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  // Validate PPV pricing
+  if (access_type === 'ppv') {
+    if (!price_dollars || price_dollars < 1 || price_dollars > 50) {
+      return {
+        display: '❌ PPV access requires a price between $1 and $50'
+      };
+    }
+  }
+
+  const token = config.getToken();
+  const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+
+  try {
+    const response = await fetch(
+      `${apiUrl}/api/sessions/access`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          session_id: session_id || undefined,
+          access_type,
+          ppv_price_dollars: price_dollars || undefined
+        })
+      }
+    );
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      return {
+        display: `❌ ${result.error || 'Failed to update session access'}`
+      };
+    }
+
+    // Format success message
+    let accessDesc;
+    switch (access_type) {
+      case 'public':
+        accessDesc = '🌐 Public - Free for everyone';
+        break;
+      case 'ppv':
+        accessDesc = `💵 Pay-Per-View - $${price_dollars}`;
+        break;
+      case 'subscribers_only':
+        accessDesc = '⭐ Subscribers Only';
+        break;
+      case 'private':
+        accessDesc = '🔒 Private - Only you';
+        break;
+    }
+
+    let display = `
+✅ Session Access Updated
+
+Session: ${result.session_id}
+Access: ${accessDesc}`;
+
+    if (access_type === 'ppv') {
+      display += `\nPrice: $${price_dollars}`;
+      display += '\n\nViewers will need to purchase access to see this session.';
+    } else if (access_type === 'subscribers_only') {
+      display += '\n\nOnly your subscribers can view this session.';
+    }
+
+    return { display: display.trim(), data: result };
+
+  } catch (error) {
+    return {
+      display: `❌ Failed to update session access: ${error.message}`
+    };
+  }
+}
+
+module.exports = { definition, handler };