slashvibe-mcp 0.2.2 → 0.2.4

package/tools/l2-status.js

@@ -0,0 +1,217 @@
+/**
+ * vibe_l2_status - VIBE L2 Chain Health
+ *
+ * Check the status of VIBE L2 chain, contracts, and infrastructure.
+ * Shows: chain health, block height, gas prices, contract status.
+ *
+ * Examples:
+ * - "vibe l2 status"
+ * - "check chain health"
+ * - "is vibe l2 running"
+ */
+
+const fetch = require('node-fetch');
+
+// Chain configuration (matches lib/vibe-l2/config.js)
+const CHAINS = {
+  'vibe-l2': {
+    chainId: 84532000,  // Mainnet
+    name: 'VIBE L2',
+    rpcUrl: process.env.VIBE_L2_RPC || 'https://rpc.vibe.network',
+    explorerUrl: 'https://explorer.vibe.network',
+  },
+  'vibe-l2-testnet': {
+    chainId: 84532001,  // Testnet
+    name: 'VIBE L2 Testnet',
+    rpcUrl: process.env.VIBE_L2_TESTNET_RPC || 'https://rpc-testnet.vibe.network',
+    explorerUrl: 'https://explorer-testnet.vibe.network',
+  },
+};
+
+const definition = {
+  name: 'vibe_l2_status',
+  description: 'Check VIBE L2 chain health: block height, gas prices, contract status, Shipback registry.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      network: {
+        type: 'string',
+        description: 'Network to check: vibe-l2, vibe-l2-testnet (default: testnet)'
+      },
+      verbose: {
+        type: 'boolean',
+        description: 'Show detailed contract status'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { network = 'vibe-l2-testnet', verbose = false } = args;
+    try {
+      const chain = CHAINS[network];
+      if (!chain) {
+        return {
+          success: false,
+          error: `Unknown network: ${network}`,
+          available: Object.keys(CHAINS)
+        };
+      }
+
+      // Check RPC health
+      const rpcStatus = await checkRpcHealth(chain.rpcUrl);
+
+      // Get contract addresses from environment
+      // Standardized format: VIBE_ARTIFACTS_TESTNET or VIBE_ARTIFACTS_MAINNET
+      const envSuffix = network === 'vibe-l2' ? 'MAINNET' : 'TESTNET';
+      const contracts = {
+        vibeArtifacts: process.env[`VIBE_ARTIFACTS_${envSuffix}`],
+        shipbackRegistry: process.env[`SHIPBACK_REGISTRY_${envSuffix}`],
+        vibeToken: process.env[`VIBE_TOKEN_${envSuffix}`],
+      };
+
+      // Check Shipback API health
+      const apiUrl = process.env.VIBE_API_URL || 'https://www.slashvibe.dev';
+      let apiHealth = { status: 'unknown' };
+      try {
+        const apiResp = await fetch(`${apiUrl}/api/health?full=true`, { timeout: 5000 });
+        apiHealth = await apiResp.json();
+      } catch (e) {
+        apiHealth = { status: 'error', error: e.message };
+      }
+
+      // Build status report
+      const status = {
+        network: chain.name,
+        chainId: chain.chainId,
+        rpc: {
+          url: chain.rpcUrl,
+          ...rpcStatus
+        },
+        contracts: {
+          vibeArtifacts: contracts.vibeArtifacts || 'not deployed',
+          shipbackRegistry: contracts.shipbackRegistry || 'not deployed',
+          vibeToken: contracts.vibeToken || 'not deployed (optional)',
+        },
+        api: apiHealth.status === 'healthy' ? 'healthy' : apiHealth.status,
+        explorer: chain.explorerUrl
+      };
+
+      // Format output
+      const rpcIcon = rpcStatus.healthy ? '🟢' : '🔴';
+      const apiIcon = apiHealth.status === 'healthy' ? '🟢' : '🟡';
+
+      let formatted = `
+┌─────────────────────────────────────────────────────┐
+│              VIBE L2 STATUS                         │
+├─────────────────────────────────────────────────────┤
+│ Network: ${chain.name.padEnd(39)} │
+│ Chain ID: ${String(chain.chainId).padEnd(38)} │
+├─────────────────────────────────────────────────────┤
+│ RPC ${rpcIcon}                                          │
+│   Block: ${String(rpcStatus.blockNumber || 'N/A').padEnd(39)} │
+│   Gas: ${String(rpcStatus.gasPrice || 'N/A').padEnd(41)} │
+├─────────────────────────────────────────────────────┤
+│ Contracts                                           │
+│   Artifacts: ${(contracts.vibeArtifacts || 'not deployed').substring(0, 35).padEnd(35)} │
+│   Shipback:  ${(contracts.shipbackRegistry || 'not deployed').substring(0, 35).padEnd(35)} │
+│   Token:     ${(contracts.vibeToken || 'optional').substring(0, 35).padEnd(35)} │
+├─────────────────────────────────────────────────────┤
+│ API ${apiIcon}  ${apiUrl.padEnd(43)} │
+└─────────────────────────────────────────────────────┘
+`.trim();
+
+      if (verbose && rpcStatus.healthy) {
+        formatted += `\n\nDetailed RPC Info:
+  Latest Block: ${rpcStatus.blockNumber}
+  Block Time: ${rpcStatus.blockTime || 'unknown'}
+  Gas Price: ${rpcStatus.gasPrice} gwei
+  Chain ID: ${rpcStatus.chainId}`;
+      }
+
+      // Shipback info
+      formatted += `\n\n💰 Shipback Distribution: 80% creator / 15% protocol / 5% foundation`;
+      formatted += `\n📖 Explorer: ${chain.explorerUrl}`;
+
+      return {
+        display: formatted,
+        data: status
+      };
+
+    } catch (error) {
+      return {
+        display: `❌ Failed to check L2 status: ${error.message}`
+      };
+    }
+}
+
+/**
+ * Check RPC endpoint health
+ */
+async function checkRpcHealth(rpcUrl) {
+  try {
+    // eth_blockNumber
+    const blockResp = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'eth_blockNumber',
+        params: [],
+        id: 1
+      }),
+      timeout: 5000
+    });
+
+    const blockData = await blockResp.json();
+    const blockNumber = parseInt(blockData.result, 16);
+
+    // eth_gasPrice
+    const gasResp = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'eth_gasPrice',
+        params: [],
+        id: 2
+      }),
+      timeout: 5000
+    });
+
+    const gasData = await gasResp.json();
+    const gasPrice = parseInt(gasData.result, 16) / 1e9; // Convert to gwei
+
+    // eth_chainId
+    const chainResp = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'eth_chainId',
+        params: [],
+        id: 3
+      }),
+      timeout: 5000
+    });
+
+    const chainData = await chainResp.json();
+    const chainId = parseInt(chainData.result, 16);
+
+    return {
+      healthy: true,
+      blockNumber,
+      gasPrice: gasPrice.toFixed(4),
+      chainId,
+      latency: 'ok'
+    };
+
+  } catch (error) {
+    return {
+      healthy: false,
+      error: error.message
+    };
+  }
+}
+
+module.exports = { definition, handler };

package/tools/l2.js

@@ -0,0 +1,206 @@
+/**
+ * vibe_l2 - Unified VIBE L2 Command
+ *
+ * One command to rule them all.
+ *
+ * Examples:
+ * - "vibe l2"              - Overview and status
+ * - "vibe l2 status"       - Chain health
+ * - "vibe l2 shipback"     - View earnings
+ * - "vibe l2 bridge"       - Bridge info
+ * - "vibe l2 mint"         - Mint artifact on L2
+ */
+
+const config = require('../config');
+
+const definition = {
+  name: 'vibe_l2',
+  description: 'VIBE L2 commands: status, shipback, bridge, mint. Run "vibe l2" for overview.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      command: {
+        type: 'string',
+        description: 'Command: status, shipback, bridge, mint, or omit for overview'
+      },
+      args: {
+        type: 'object',
+        description: 'Arguments for the command'
+      }
+    }
+  }
+};
+
+async function handler(args) {
+  const { command, args: cmdArgs = {} } = args;
+
+  if (!config.isInitialized()) {
+    return {
+      display: 'Run `vibe init` first to set your identity.'
+    };
+  }
+
+  const handle = config.getHandle();
+
+  // No command = show overview
+  if (!command) {
+    return showOverview(handle);
+  }
+
+  // Route to specific tool
+  switch (command.toLowerCase()) {
+    case 'status':
+      const statusTool = require('./l2-status');
+      return statusTool.handler(cmdArgs);
+
+    case 'shipback':
+    case 'earnings':
+      const shipbackTool = require('./shipback');
+      return shipbackTool.handler(cmdArgs);
+
+    case 'bridge':
+      const bridgeTool = require('./l2-bridge');
+      return bridgeTool.handler(cmdArgs);
+
+    case 'mint':
+      return showMintInfo(handle);
+
+    case 'help':
+      return showHelp();
+
+    default:
+      return {
+        display: `Unknown command: ${command}\n\nRun "vibe l2 help" for available commands.`
+      };
+  }
+}
+
+function showOverview(handle) {
+  return {
+    display: `
+╔═══════════════════════════════════════════════════════════════════╗
+║                         VIBE L2                                    ║
+║           Creator-First Economics for the AI Coding Era           ║
+╠═══════════════════════════════════════════════════════════════════╣
+║                                                                    ║
+║   "You shipped it, you earn from it"                              ║
+║                                                                    ║
+║   VIBE L2 is an OP Stack chain where creators earn 80% of         ║
+║   gas fees from interactions with their deployed contracts.       ║
+║                                                                    ║
+╠═══════════════════════════════════════════════════════════════════╣
+║                                                                    ║
+║   SHIPBACK ECONOMICS                                               ║
+║   ┌──────────────────────────────────────────────────────────┐    ║
+║   │  User interacts with your artifact                       │    ║
+║   │              ↓                                           │    ║
+║   │  Gas fee collected → Distributed:                        │    ║
+║   │                                                          │    ║
+║   │  ████████████████████░░░░░  80% → You (Creator)         │    ║
+║   │  ███░░░░░░░░░░░░░░░░░░░░░░  15% → Protocol Treasury     │    ║
+║   │  █░░░░░░░░░░░░░░░░░░░░░░░░   5% → Foundation Grants     │    ║
+║   └──────────────────────────────────────────────────────────┘    ║
+║                                                                    ║
+╠═══════════════════════════════════════════════════════════════════╣
+║                                                                    ║
+║   COMMANDS                                                         ║
+║   ────────────────────────────────────────────────────────────    ║
+║   vibe l2 status      Check chain health & contracts              ║
+║   vibe l2 shipback    View/claim your earnings                    ║
+║   vibe l2 bridge      Move ETH between Base ↔ VIBE L2             ║
+║   vibe l2 mint        Mint an artifact on VIBE L2                 ║
+║                                                                    ║
+╠═══════════════════════════════════════════════════════════════════╣
+║                                                                    ║
+║   QUICK START                                                      ║
+║   1. Bridge ETH:     vibe l2 bridge deposit 0.1                   ║
+║   2. Link wallet:    vibe l2 shipback link                        ║
+║   3. Create art:     vibe create artifact                         ║
+║   4. Mint on L2:     vibe l2 mint                                 ║
+║   5. Earn forever:   vibe l2 shipback                             ║
+║                                                                    ║
+╚═══════════════════════════════════════════════════════════════════╝
+
+Logged in as: @${handle}
+`.trim()
+  };
+}
+
+function showMintInfo(handle) {
+  return {
+    display: `
+🎨 MINT ON VIBE L2
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Minting on VIBE L2 gives you:
+• 80% of all gas fees from interactions (Shipback)
+• Ultra-low minting costs (~0.0001 ETH)
+• Session provenance on-chain
+• Automatic royalties (10% default)
+
+To mint an artifact:
+
+1. First, create the artifact content:
+   vibe create artifact
+
+2. Then mint it on VIBE L2:
+   vibe mint --chain vibe-l2
+
+Or use the API directly:
+   POST /api/nft/mint
+   {
+     "artifact_id": "art_xxx",
+     "chain": "vibe-l2"
+   }
+
+Prerequisites:
+• ETH on VIBE L2 (use: vibe l2 bridge deposit 0.1)
+• Linked wallet (use: vibe l2 shipback link)
+
+Current handle: @${handle}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`.trim()
+  };
+}
+
+function showHelp() {
+  return {
+    display: `
+VIBE L2 COMMANDS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+vibe l2                    Show this overview
+vibe l2 status             Chain health, contracts, gas prices
+vibe l2 shipback           View Shipback earnings
+vibe l2 shipback link      Link wallet to handle
+vibe l2 shipback claim     Claim accumulated earnings
+vibe l2 shipback contracts List registered contracts
+vibe l2 bridge             Bridge overview
+vibe l2 bridge deposit X   Deposit X ETH to VIBE L2
+vibe l2 bridge withdraw X  Withdraw X ETH to Base
+vibe l2 bridge estimate    Gas cost estimates
+vibe l2 mint               Mint artifact info
+
+ARCHITECTURE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│  Ethereum   │────▶│    Base     │────▶│   VIBE L2   │
+│ (Security)  │     │  (Bridge)   │     │   (Apps)    │
+└─────────────┘     └─────────────┘     └─────────────┘
+
+Stack: OP Stack via Conduit
+DA: Celestia
+Gas: ETH (not token)
+
+LINKS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Explorer: https://explorer.vibe.network
+Bridge:   https://bridge.vibe.network
+Docs:     https://docs.slashvibe.dev/l2
+`.trim()
+  };
+}
+
+module.exports = { definition, handler };

package/tools/migrate.js

@@ -0,0 +1,156 @@
+/**
+ * vibe migrate — Migrate existing handle to GitHub auth
+ *
+ * For users who have existing handles with local keypairs,
+ * this command helps them migrate to the new Privy/GitHub auth.
+ *
+ * Flow:
+ * 1. Check if user has existing handle and keys
+ * 2. Sign migration request with old key (proves ownership)
+ * 3. Get migration URL from server
+ * 4. User completes GitHub auth in browser
+ * 5. Token pasted via `vibe token`
+ */
+
+const config = require('../config');
+const crypto = require('../crypto');
+
+const definition = {
+  name: 'vibe_migrate',
+  description: 'Migrate your existing handle to GitHub authentication. Use this if you have an existing handle with local keys.',
+  inputSchema: {
+    type: 'object',
+    properties: {}
+  }
+};
+
+async function handler(args) {
+  const handle = config.getHandle();
+
+  if (!handle) {
+    return {
+      display: `❌ **No handle found**
+
+You need to have an existing handle to migrate.
+If you're new, use \`vibe init @yourhandle "what you're building"\` instead.`
+    };
+  }
+
+  // Check if already using Privy auth
+  if (config.hasPrivyAuth()) {
+    return {
+      display: `✅ **Already using GitHub auth**
+
+@${handle} is already authenticated via GitHub.
+No migration needed!`
+    };
+  }
+
+  // Check if we have a keypair to sign with
+  const keypair = config.getKeypair();
+
+  // Build migration request
+  const https = require('https');
+  const apiUrl = config.getApiUrl();
+
+  try {
+    const timestamp = Date.now();
+    let signature = null;
+
+    // If we have a keypair, sign the migration request
+    if (keypair) {
+      const messageToSign = {
+        action: 'migrate',
+        handle: handle,
+        timestamp: timestamp
+      };
+      signature = crypto.sign(messageToSign, keypair.privateKey);
+    }
+
+    // Request migration token from server
+    const result = await new Promise((resolve, reject) => {
+      const url = new URL('/api/auth/migrate', apiUrl);
+      const data = JSON.stringify({
+        handle,
+        legacy_signature: signature,
+        timestamp
+      });
+
+      const req = https.request({
+        hostname: url.hostname,
+        port: 443,
+        path: url.pathname,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': data.length
+        }
+      }, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(body));
+          } catch (e) {
+            resolve({ success: false, error: body });
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.write(data);
+      req.end();
+    });
+
+    if (!result.success) {
+      return {
+        display: `❌ **Migration failed**
+
+Error: ${result.error}
+${result.message || ''}
+
+If you're having trouble, try:
+1. Make sure your handle is registered
+2. Check that your local keys match what's on the server
+3. Contact support if the issue persists`
+      };
+    }
+
+    // Success - show auth URL
+    return {
+      display: `## Migrate @${handle} to GitHub Auth
+
+${result.verified ? '✅ **Ownership verified** via signature' : '⚠️ **Unverified** — GitHub auth will claim this handle'}
+
+🔐 **Open this URL in your browser:**
+
+${result.authUrl}
+
+After authenticating:
+\`vibe token <paste-token-here>\`
+
+---
+
+**Why migrate?**
+• Your identity is verified via GitHub (no impersonation)
+• Messages are signed server-side (more secure)
+• No private keys stored locally
+
+_Migration token expires in 1 hour._`,
+      authUrl: result.authUrl,
+      verified: result.verified,
+      migrationToken: result.migrationToken
+    };
+
+  } catch (e) {
+    return {
+      display: `❌ **Migration request failed**
+
+Error: ${e.message}
+
+Make sure you have internet connectivity and try again.`
+    };
+  }
+}
+
+module.exports = { definition, handler };