slashvibe-mcp 0.2.2 → 0.2.4

package/tools/mint.js

@@ -0,0 +1,377 @@
+/**
+ * vibe_mint — Mint a /vibe moment as an NFT
+ *
+ * Supports multiple chains:
+ * - vibe-l2 (default) — VIBE L2 with Shipback (80% gas fees to creator)
+ * - base — Base mainnet
+ * - base-sepolia — Base testnet
+ * - ethereum — Ethereum mainnet
+ *
+ * Flow:
+ * 1. Upload metadata to IPFS (Pinata)
+ * 2. Call VibeArtifacts.mintArtifact() with session provenance
+ * 3. Return tx hash + token ID + marketplace links
+ */
+
+// Lazy-load ethers to avoid startup crash if not installed
+let ethers = null;
+function getEthers() {
+  if (!ethers) {
+    try {
+      ethers = require('ethers');
+    } catch (e) {
+      throw new Error('ethers package not installed. Run: npm install ethers');
+    }
+  }
+  return ethers;
+}
+
+// Polyfill fetch for Node <18
+const fetch = globalThis.fetch || require('node-fetch');
+
+const config = require('../config');
+
+// Chain configurations
+// Env var format: VIBE_ARTIFACTS_MAINNET / VIBE_ARTIFACTS_TESTNET (matches deploy script)
+const CHAINS = {
+  'vibe-l2': {
+    name: 'VIBE L2',
+    chainId: 84532000,  // Mainnet
+    rpcUrl: process.env.VIBE_L2_RPC || 'https://rpc.vibe.network',
+    contractAddress: process.env.VIBE_ARTIFACTS_MAINNET,
+    explorerUrl: 'https://explorer.vibe.network',
+    marketplaceUrl: 'https://slashvibe.dev/a',
+    shipbackEnabled: true,
+    recommended: true
+  },
+  'vibe-l2-testnet': {
+    name: 'VIBE L2 Testnet',
+    chainId: 84532001,  // Testnet
+    rpcUrl: process.env.VIBE_L2_TESTNET_RPC || 'https://rpc-testnet.vibe.network',
+    contractAddress: process.env.VIBE_ARTIFACTS_TESTNET,
+    explorerUrl: 'https://explorer-testnet.vibe.network',
+    marketplaceUrl: 'https://slashvibe.dev/a',
+    shipbackEnabled: true
+  },
+  'base-sepolia': {
+    name: 'Base Sepolia',
+    chainId: 84532,
+    rpcUrl: process.env.BASE_SEPOLIA_RPC_URL || 'https://sepolia.base.org',
+    contractAddress: process.env.VIBE_ARTIFACTS_BASE_SEPOLIA,
+    explorerUrl: 'https://sepolia.basescan.org',
+    marketplaceUrl: 'https://testnets.opensea.io/assets/base-sepolia',
+    shipbackEnabled: false
+  },
+  'base': {
+    name: 'Base',
+    chainId: 8453,
+    rpcUrl: process.env.BASE_RPC_URL || 'https://mainnet.base.org',
+    contractAddress: process.env.VIBE_ARTIFACTS_BASE,
+    explorerUrl: 'https://basescan.org',
+    marketplaceUrl: 'https://opensea.io/assets/base',
+    shipbackEnabled: false
+  },
+  'ethereum': {
+    name: 'Ethereum',
+    chainId: 1,
+    rpcUrl: process.env.ETH_RPC_URL || 'https://eth.llamarpc.com',
+    contractAddress: process.env.VIBE_ARTIFACTS_ADDRESS,
+    explorerUrl: 'https://etherscan.io',
+    marketplaceUrl: 'https://opensea.io/assets/ethereum',
+    shipbackEnabled: false
+  }
+};
+
+// Get default chain (prefer VIBE L2 if configured)
+function getDefaultChain() {
+  if (CHAINS['vibe-l2'].contractAddress) return 'vibe-l2';
+  if (CHAINS['vibe-l2-testnet'].contractAddress) return 'vibe-l2-testnet';
+  if (CHAINS['base-sepolia'].contractAddress) return 'base-sepolia';
+  if (CHAINS['base'].contractAddress) return 'base';
+  return 'ethereum';
+}
+
+// Contract ABI (extended for session provenance)
+const VIBE_ARTIFACTS_ABI = [
+  // Legacy simple mint
+  'function mint(address to, string memory uri) public returns (uint256)',
+  // New mint with provenance
+  'function mintArtifact(address to, string uri, string sessionId, string creatorHandle, string artifactType, bytes32 sessionHash, address royaltyRecipient, uint96 royaltyBps) returns (uint256)',
+  'function totalSupply() public view returns (uint256)',
+  'event ArtifactMinted(uint256 indexed tokenId, address indexed creator, string sessionId, string artifactType, bytes32 sessionHash)'
+];
+
+const PINATA_JWT = process.env.PINATA_JWT || null;
+const MINTER_PRIVATE_KEY = process.env.VIBE_MINTER_PRIVATE_KEY || null;
+
+const definition = {
+  name: 'vibe_mint',
+  description: 'Mint a /vibe artifact as an NFT. Default: VIBE L2 (80% Shipback). Also supports Base, Ethereum.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      title: {
+        type: 'string',
+        description: 'Title of the artifact'
+      },
+      description: {
+        type: 'string',
+        description: 'Description of what happened'
+      },
+      chain: {
+        type: 'string',
+        description: 'Chain to mint on: vibe-l2, base, base-sepolia, ethereum (default: vibe-l2)'
+      },
+      session_id: {
+        type: 'string',
+        description: 'Session ID for provenance (ses_xxx)'
+      },
+      attributes: {
+        type: 'object',
+        description: 'Optional attributes',
+        additionalProperties: true
+      },
+      image_url: {
+        type: 'string',
+        description: 'Optional image URL'
+      },
+      dry_run: {
+        type: 'boolean',
+        description: 'Preview without minting'
+      }
+    },
+    required: ['title', 'description']
+  }
+};
+
+async function uploadToIPFS(metadata) {
+  if (!PINATA_JWT) {
+    throw new Error('PINATA_JWT not configured');
+  }
+
+  const response = await fetch('https://api.pinata.cloud/pinning/pinJSONToIPFS', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${PINATA_JWT}`
+    },
+    body: JSON.stringify({
+      pinataContent: metadata,
+      pinataMetadata: {
+        name: `vibe-artifact-${Date.now()}`
+      }
+    })
+  });
+
+  if (!response.ok) {
+    throw new Error(`Pinata upload failed: ${response.statusText}`);
+  }
+
+  const result = await response.json();
+  return `ipfs://${result.IpfsHash}`;
+}
+
+async function mintOnchain(uri, chain, creatorHandle, sessionId) {
+  if (!chain.contractAddress) {
+    throw new Error(`Contract not configured for ${chain.name}`);
+  }
+  if (!MINTER_PRIVATE_KEY) {
+    throw new Error('VIBE_MINTER_PRIVATE_KEY not configured');
+  }
+
+  const ethers = getEthers();
+  const crypto = require('crypto');
+
+  const provider = new ethers.JsonRpcProvider(chain.rpcUrl);
+  const wallet = new ethers.Wallet(MINTER_PRIVATE_KEY, provider);
+  const contract = new ethers.Contract(chain.contractAddress, VIBE_ARTIFACTS_ABI, wallet);
+
+  // Compute session hash for provenance
+  const sessionData = JSON.stringify({ sessionId, creatorHandle, timestamp: Date.now() });
+  const sessionHash = '0x' + crypto.createHash('sha256').update(sessionData).digest('hex');
+
+  let tx;
+  try {
+    // Try new mintArtifact with provenance
+    tx = await contract.mintArtifact(
+      wallet.address,      // to
+      uri,                 // metadata URI
+      sessionId,           // session ID
+      creatorHandle,       // creator handle
+      'session_artifact',  // artifact type
+      sessionHash,         // session hash
+      wallet.address,      // royalty recipient
+      1000                 // 10% royalty (1000 bps)
+    );
+  } catch (e) {
+    // Fallback to legacy mint if new function not available
+    console.log('[mint] Falling back to legacy mint:', e.message);
+    tx = await contract.mint(wallet.address, uri);
+  }
+
+  const receipt = await tx.wait();
+
+  // Parse the event to get tokenId
+  const event = receipt.logs.find(log => {
+    try {
+      const parsed = contract.interface.parseLog(log);
+      return parsed?.name === 'ArtifactMinted';
+    } catch {
+      return false;
+    }
+  });
+
+  let tokenId = null;
+  if (event) {
+    const parsed = contract.interface.parseLog(event);
+    tokenId = parsed.args.tokenId.toString();
+  }
+
+  return {
+    txHash: receipt.hash,
+    tokenId,
+    contractAddress: chain.contractAddress
+  };
+}
+
+async function handler(args) {
+  const {
+    title,
+    description,
+    chain: chainArg,
+    session_id,
+    attributes = {},
+    image_url,
+    dry_run = false
+  } = args;
+
+  // Get handle from config
+  const handle = config.isInitialized() ? config.getHandle() : 'anonymous';
+
+  // Determine chain
+  const chainName = chainArg || getDefaultChain();
+  const chain = CHAINS[chainName];
+
+  if (!chain) {
+    return {
+      display: `Unknown chain: ${chainArg}\n\nAvailable chains:\n` +
+        Object.entries(CHAINS).map(([k, v]) =>
+          `• ${k} - ${v.name}${v.shipbackEnabled ? ' (80% Shipback)' : ''}${v.recommended ? ' ✨' : ''}`
+        ).join('\n')
+    };
+  }
+
+  // Build metadata with session provenance
+  const sessionId = session_id || `ses_${Date.now()}`;
+  const metadata = {
+    name: title,
+    description,
+    attributes: [
+      { trait_type: 'Source', value: '/vibe MCP' },
+      { trait_type: 'Minted Via', value: 'Claude Code' },
+      { trait_type: 'Chain', value: chain.name },
+      { trait_type: 'Creator', value: `@${handle}` },
+      { trait_type: 'Session', value: sessionId },
+      { trait_type: 'Date', value: new Date().toISOString().split('T')[0] },
+      ...Object.entries(attributes).map(([key, value]) => ({
+        trait_type: key,
+        value: String(value)
+      }))
+    ],
+    external_url: `https://slashvibe.dev/a/${sessionId}`,
+    // Session provenance
+    provenance: {
+      sessionId,
+      creatorHandle: handle,
+      mintedAt: new Date().toISOString(),
+      chain: chainName,
+      shipbackEnabled: chain.shipbackEnabled
+    }
+  };
+
+  if (image_url) {
+    metadata.image = image_url;
+  }
+
+  // Dry run - show metadata and chain info
+  if (dry_run) {
+    let display = `## Dry Run - Metadata Preview\n\n`;
+    display += `**Chain:** ${chain.name}${chain.shipbackEnabled ? ' (80% Shipback enabled!)' : ''}\n\n`;
+    display += '```json\n' + JSON.stringify(metadata, null, 2) + '\n```\n\n';
+    display += `Ready to mint. Run without \`dry_run\` to mint onchain.`;
+    return { display };
+  }
+
+  // Check configuration
+  if (!chain.contractAddress) {
+    let display = `## Configuration Required\n\n`;
+    display += `Chain **${chain.name}** is not configured.\n\n`;
+
+    if (chain.shipbackEnabled) {
+      display += `To use VIBE L2 (recommended - 80% Shipback):\n`;
+      display += `1. Sign up at https://conduit.xyz\n`;
+      display += `2. Deploy contracts: \`node scripts/deploy-vibe-l2.js\`\n`;
+      display += `3. Set env var: \`VIBE_ARTIFACTS_TESTNET=0x...\`\n\n`;
+    }
+
+    display += `Available configured chains:\n`;
+    Object.entries(CHAINS).forEach(([k, v]) => {
+      if (v.contractAddress) {
+        display += `• ${k} - ${v.name}\n`;
+      }
+    });
+
+    if (!Object.values(CHAINS).some(c => c.contractAddress)) {
+      display += `\nNo chains configured. Set environment variables:\n`;
+      display += `• VIBE_ARTIFACTS_TESTNET (recommended)\n`;
+      display += `• VIBE_ARTIFACTS_BASE_SEPOLIA\n`;
+      display += `• VIBE_MINTER_PRIVATE_KEY\n`;
+      display += `• PINATA_JWT\n`;
+    }
+
+    return { display };
+  }
+
+  try {
+    // 1. Upload to IPFS
+    const ipfsUri = await uploadToIPFS(metadata);
+
+    // 2. Mint onchain
+    const { txHash, tokenId } = await mintOnchain(ipfsUri, chain, handle, sessionId);
+
+    // 3. Build result
+    const explorerUrl = `${chain.explorerUrl}/tx/${txHash}`;
+    const marketplaceUrl = tokenId
+      ? `${chain.marketplaceUrl}/${chain.contractAddress}/${tokenId}`
+      : null;
+
+    let display = `## 🎨 VIBE #${tokenId || '?'} Minted on ${chain.name}\n\n`;
+    display += `**${title}**\n\n`;
+    display += `• IPFS: \`${ipfsUri}\`\n`;
+    display += `• Tx: [${txHash.slice(0, 10)}...](${explorerUrl})\n`;
+    display += `• Creator: @${handle}\n`;
+    display += `• Session: ${sessionId}\n`;
+
+    if (marketplaceUrl) {
+      display += `• View: [Marketplace](${marketplaceUrl})\n`;
+    }
+
+    if (chain.shipbackEnabled) {
+      display += `\n💰 **Shipback enabled!** You'll earn 80% of all gas fees from interactions.\n`;
+      display += `Check earnings: \`vibe l2 shipback\``;
+    }
+
+    display += `\n\n_Onchain. Forever._`;
+
+    return { display };
+
+  } catch (err) {
+    return {
+      display: `## Mint Failed\n\n${err.message}\n\n` +
+        `Chain: ${chain.name}\n` +
+        `Check configuration and try again.`
+    };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/multiplayer-game.js

@@ -0,0 +1,275 @@
+/**
+ * vibe multiplayer-game — Join multiplayer games like drawing, tic-tac-toe rooms, etc.
+ *
+ * Supports: drawing, multiplayer-tictactoe, wordchain, storybuilder
+ */
+
+const config = require('../config');
+const store = require('../store');
+const { requireInit, normalizeHandle } = require('./_shared');
+
+// Game implementations
+const drawing = require('../games/drawing');
+const multiTicTacToe = require('../games/multiplayer-tictactoe');
+const wordchain = require('../games/wordchain');
+const storybuilder = require('../games/storybuilder');
+
+// Global game state storage (in memory for now)
+const globalGameRooms = {};
+
+const definition = {
+  name: 'vibe_multiplayer_game',
+  description: 'Join or interact with multiplayer games (drawing, multiplayer-tictactoe, wordchain, storybuilder)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      game: {
+        type: 'string',
+        description: 'Game type to join/play',
+        enum: ['drawing', 'multiplayer-tictactoe', 'wordchain', 'storybuilder']
+      },
+      action: {
+        type: 'string',
+        description: 'Action to take (join, leave, draw, move, etc.)',
+        enum: ['join', 'leave', 'show', 'draw', 'move', 'clear', 'theme', 'restart', 'spectate', 'word', 'sentence']
+      },
+      x: {
+        type: 'number',
+        description: 'X coordinate for drawing (0-19)'
+      },
+      y: {
+        type: 'number',
+        description: 'Y coordinate for drawing (0-11)'
+      },
+      char: {
+        type: 'string',
+        description: 'Character to draw (empty, dot, circle, square, star, heart, tree, house, sun, moon, water, mountain, person, cat, dog, car, plane, flower, umbrella, rainbow)'
+      },
+      position: {
+        type: 'number',
+        description: 'Position for tic-tac-toe (1-9)'
+      },
+      word: {
+        type: 'string',
+        description: 'Word to add to word chain'
+      },
+      sentence: {
+        type: 'string',
+        description: 'Sentence to add to story'
+      },
+      theme: {
+        type: 'string',
+        description: 'Theme to set for drawing game'
+      },
+      roomName: {
+        type: 'string',
+        description: 'Room name for multiplayer-tictactoe'
+      }
+    },
+    required: ['game', 'action']
+  }
+};
+
+// Get or create global game room
+function getGameRoom(gameType, roomId = 'default') {
+  const key = `${gameType}:${roomId}`;
+  
+  if (!globalGameRooms[key]) {
+    if (gameType === 'drawing') {
+      globalGameRooms[key] = drawing.createInitialDrawingState();
+    } else if (gameType === 'multiplayer-tictactoe') {
+      const myHandle = config.getHandle();
+      globalGameRooms[key] = multiTicTacToe.createInitialMultiplayerTicTacToeState(myHandle, roomId);
+    } else if (gameType === 'wordchain') {
+      globalGameRooms[key] = wordchain.createInitialWordChainState();
+    } else if (gameType === 'storybuilder') {
+      globalGameRooms[key] = storybuilder.createInitialStoryBuilderState();
+    }
+  }
+  
+  return globalGameRooms[key];
+}
+
+// Update global game room
+function updateGameRoom(gameType, roomId, newState) {
+  const key = `${gameType}:${roomId}`;
+  globalGameRooms[key] = newState;
+}
+
+async function handler(args) {
+  const initCheck = requireInit();
+  if (initCheck) return initCheck;
+
+  const { game, action, x, y, char, position, word, sentence, theme, roomName } = args;
+  const myHandle = config.getHandle();
+  const roomId = roomName || 'default';
+
+  // Get current game state
+  let gameState = getGameRoom(game, roomId);
+  
+  try {
+    if (game === 'drawing') {
+      if (action === 'join') {
+        const result = drawing.addPlayer(gameState, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `🎨 **Joined Collaborative Drawing!**\n\n${drawing.formatDrawingDisplay(result.gameState)}\n\nUse commands like:\n• \`vibe multiplayer-game drawing draw --x 10 --y 5 --char star\`\n• \`vibe multiplayer-game drawing theme --theme "house"\`` };
+      
+      } else if (action === 'draw') {
+        if (x === undefined || y === undefined || !char) {
+          return { display: 'Need x, y coordinates and character to draw. Example: `vibe multiplayer-game drawing draw --x 10 --y 5 --char star`' };
+        }
+        
+        // Convert char name to actual character
+        const charMap = drawing.DRAWING_CHARS;
+        const actualChar = charMap[char] || char;
+        
+        const result = drawing.makeMove(gameState, x, y, actualChar, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `🎨 **Drew ${actualChar} at (${x},${y})**\n\n${drawing.formatDrawingDisplay(result.gameState)}` };
+      
+      } else if (action === 'clear') {
+        const x0 = x || 0;
+        const y0 = y || 0;
+        const x1 = args.x1 || x0;
+        const y1 = args.y1 || y0;
+        
+        const result = drawing.clearRegion(gameState, x0, y0, x1, y1, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `🧹 **Cleared region**\n\n${drawing.formatDrawingDisplay(result.gameState)}` };
+      
+      } else if (action === 'theme') {
+        if (!theme) {
+          return { display: 'Need a theme! Example: `vibe multiplayer-game drawing theme --theme "house"`' };
+        }
+        const result = drawing.setTheme(gameState, theme, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        const tips = drawing.getDrawingTips(theme);
+        return { display: `🎯 **Set theme: ${theme}**\n\n**Tips:** ${tips.join(', ')}\n\n${drawing.formatDrawingDisplay(result.gameState)}` };
+      
+      } else if (action === 'show') {
+        return { display: drawing.formatDrawingDisplay(gameState) };
+      }
+
+    } else if (game === 'multiplayer-tictactoe') {
+      if (action === 'join') {
+        const result = multiTicTacToe.joinRoom(gameState, myHandle, false);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `🎯 **Joined Multiplayer Tic-Tac-Toe!**\n\n${multiTicTacToe.formatMultiplayerTicTacToeDisplay(result.gameState, myHandle)}` };
+      
+      } else if (action === 'spectate') {
+        const result = multiTicTacToe.joinRoom(gameState, myHandle, true);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `👁️ **Now spectating Multiplayer Tic-Tac-Toe**\n\n${multiTicTacToe.formatMultiplayerTicTacToeDisplay(result.gameState, myHandle)}` };
+      
+      } else if (action === 'move') {
+        if (!position) {
+          return { display: 'Need position (1-9)! Example: `vibe multiplayer-game multiplayer-tictactoe move --position 5`' };
+        }
+        const result = multiTicTacToe.makeMove(gameState, position, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `🎯 **Played position ${position}**\n\n${multiTicTacToe.formatMultiplayerTicTacToeDisplay(result.gameState, myHandle)}` };
+      
+      } else if (action === 'restart') {
+        const result = multiTicTacToe.restartGame(gameState, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `🔄 **Restarted game!**\n\n${multiTicTacToe.formatMultiplayerTicTacToeDisplay(result.gameState, myHandle)}` };
+      
+      } else if (action === 'leave') {
+        const result = multiTicTacToe.leaveRoom(gameState, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: '👋 Left the game room.' };
+      
+      } else if (action === 'show') {
+        return { display: multiTicTacToe.formatMultiplayerTicTacToeDisplay(gameState, myHandle) };
+      }
+
+    } else if (game === 'wordchain') {
+      if (action === 'join') {
+        const result = wordchain.addPlayer && wordchain.addPlayer(gameState, myHandle);
+        if (result && result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        
+        // For wordchain, just show the current state since it doesn't have explicit player management
+        return { display: `🔗 **Joined Word Chain!**\n\n${wordchain.formatWordChainDisplay(gameState)}\n\nAdd words with: \`vibe multiplayer-game wordchain word --word "apple"\`` };
+      
+      } else if (action === 'word') {
+        if (!word) {
+          return { display: 'Need a word! Example: `vibe multiplayer-game wordchain word --word "apple"`' };
+        }
+        
+        // For wordchain, we need to determine if this is player 1 or 2 move
+        // For simplicity, let's alternate based on move count
+        const isPlayer1Move = gameState.moves % 2 === 0;
+        
+        const result = wordchain.makeMove(gameState, word, isPlayer1Move);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `🔗 **Added word: ${word}**\n\n${wordchain.formatWordChainDisplay(result.gameState)}` };
+      
+      } else if (action === 'show') {
+        return { display: wordchain.formatWordChainDisplay(gameState) };
+      }
+
+    } else if (game === 'storybuilder') {
+      if (action === 'join') {
+        const result = storybuilder.addPlayer(gameState, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `📚 **Joined Story Builder!**\n\n${storybuilder.formatStoryBuilderDisplay(result.gameState)}\n\nAdd sentences with: \`vibe multiplayer-game storybuilder sentence --sentence "Once upon a time..."\`` };
+      
+      } else if (action === 'sentence') {
+        if (!sentence) {
+          return { display: 'Need a sentence! Example: `vibe multiplayer-game storybuilder sentence --sentence "Once upon a time..."`' };
+        }
+        const result = storybuilder.addSentence(gameState, sentence, myHandle);
+        if (result.error) {
+          return { display: `❌ ${result.error}` };
+        }
+        updateGameRoom(game, roomId, result.gameState);
+        return { display: `📚 **Added sentence!**\n\n${storybuilder.formatStoryBuilderDisplay(result.gameState)}` };
+      
+      } else if (action === 'show') {
+        return { display: storybuilder.formatStoryBuilderDisplay(gameState) };
+      }
+    }
+
+    return { display: `❌ Unknown action "${action}" for game "${game}"` };
+
+  } catch (error) {
+    return { display: `❌ Error: ${error.message}` };
+  }
+}
+
+module.exports = { definition, handler };