50c 2.7.0 → 2.9.0

package/bin/50c.js

@@ -73,12 +73,243 @@ async function runMCP() {
   });
 }
 
+// Detect IDE from environment/process
+function detectIDE() {
+  const env = process.env;
+  if (env.CURSOR_SESSION || env.CURSOR_TRACE_ID) return 'cursor';
+  if (env.WINDSURF_SESSION) return 'windsurf';
+  if (env.VSCODE_PID || env.TERM_PROGRAM === 'vscode') return 'vscode';
+  if (env.CLAUDE_DESKTOP) return 'claude-desktop';
+  // Check for common IDE paths
+  const cwd = process.cwd();
+  if (cwd.includes('.cursor')) return 'cursor';
+  if (cwd.includes('windsurf')) return 'windsurf';
+  return null;
+}
+
+// Get MCP config path for IDE
+function getMCPConfigPath(ide) {
+  const os = require('os');
+  const path = require('path');
+  const home = os.homedir();
+  
+  const paths = {
+    'cursor': path.join(home, '.cursor', 'mcp.json'),
+    'windsurf': path.join(home, '.codeium', 'windsurf', 'mcp_config.json'),
+    'vscode': path.join(home, '.vscode', 'mcp.json'),
+    'claude-desktop': process.platform === 'win32' 
+      ? path.join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json')
+      : path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+    'verdent': path.join(home, '.verdent', 'mcp.json')
+  };
+  return paths[ide] || null;
+}
+
 // CLI Mode
 async function runCLI(args) {
   const cmd = args[0];
   const cmdArgs = args.slice(1);
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
   
   switch (cmd) {
+    case 'init': {
+      console.log('\n  50c init - Quick Setup\n');
+      
+      // Detect IDE
+      const ide = detectIDE() || cmdArgs[0];
+      const ides = ['cursor', 'windsurf', 'vscode', 'claude-desktop', 'verdent'];
+      
+      if (!ide) {
+        console.log('  Detected IDE: none\n');
+        console.log('  Which IDE are you using?');
+        ides.forEach((i, idx) => console.log(`    ${idx + 1}. ${i}`));
+        console.log('\n  Run: 50c init <ide>');
+        console.log('  Example: 50c init cursor\n');
+        break;
+      }
+      
+      if (!ides.includes(ide)) {
+        console.log(`  Unknown IDE: ${ide}`);
+        console.log(`  Supported: ${ides.join(', ')}\n`);
+        break;
+      }
+      
+      console.log(`  IDE: ${ide}`);
+      
+      // Check for API key
+      const apiKey = process.env.FIFTYC_API_KEY || process.env.FIFTY_CENT_API_KEY;
+      if (apiKey) {
+        console.log(`  API Key: ${apiKey.slice(0, 8)}...`);
+      } else {
+        console.log('  API Key: not set');
+        console.log('\n  Get your key at: https://50c.ai');
+        console.log('  Then run: 50c init <ide>\n');
+      }
+      
+      // Get config path
+      const configPath = getMCPConfigPath(ide);
+      if (!configPath) {
+        console.log(`  Config path: unknown for ${ide}\n`);
+        break;
+      }
+      
+      console.log(`  Config: ${configPath}`);
+      
+      // Generate config
+      const mcpConfig = {
+        mcpServers: {
+          '50c': {
+            command: 'npx',
+            args: ['-y', '50c'],
+            env: apiKey ? { FIFTYC_API_KEY: apiKey } : {}
+          }
+        }
+      };
+      
+      // Check if file exists
+      let existingConfig = {};
+      try {
+        if (fs.existsSync(configPath)) {
+          existingConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          console.log('  Status: updating existing config');
+        } else {
+          console.log('  Status: creating new config');
+        }
+      } catch (e) {
+        console.log('  Status: creating new config');
+      }
+      
+      // Merge configs
+      const finalConfig = {
+        ...existingConfig,
+        mcpServers: {
+          ...(existingConfig.mcpServers || {}),
+          '50c': mcpConfig.mcpServers['50c']
+        }
+      };
+      
+      // Create directory if needed
+      const configDir = path.dirname(configPath);
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+      }
+      
+      // Write config
+      fs.writeFileSync(configPath, JSON.stringify(finalConfig, null, 2));
+      console.log('\n  Done! 50c added to ' + ide);
+      
+      // Show next steps
+      console.log('\n  Next steps:');
+      console.log('    1. Restart ' + ide);
+      console.log('    2. 50c should appear with 117+ tools');
+      if (!apiKey) {
+        console.log('    3. Set FIFTYC_API_KEY in the config for full access');
+      }
+      console.log('\n  Try: 50c tools   (see all available tools)');
+      console.log('       50c doctor  (check setup)\n');
+      break;
+    }
+    
+    case 'tools': {
+      const tools = await lib.getTools();
+      const packFilter = cmdArgs.find(a => a.startsWith('--pack='))?.split('=')[1];
+      const search = cmdArgs.find(a => !a.startsWith('--'));
+      
+      let filtered = tools;
+      if (packFilter) {
+        filtered = tools.filter(t => t.name.startsWith(packFilter) || t.name.includes(packFilter));
+      }
+      if (search) {
+        const s = search.toLowerCase();
+        filtered = filtered.filter(t => 
+          t.name.toLowerCase().includes(s) || 
+          (t.description || '').toLowerCase().includes(s)
+        );
+      }
+      
+      console.log(`\n  50c Tools (${filtered.length}/${tools.length})\n`);
+      
+      // Group by prefix
+      const groups = {};
+      filtered.forEach(t => {
+        const prefix = t.name.split('_')[0];
+        if (!groups[prefix]) groups[prefix] = [];
+        groups[prefix].push(t);
+      });
+      
+      for (const [prefix, groupTools] of Object.entries(groups)) {
+        console.log(`  ${prefix} (${groupTools.length}):`);
+        groupTools.slice(0, 5).forEach(t => {
+          const cost = t.cost ? ` $${t.cost.toFixed(2)}` : ' FREE';
+          console.log(`    ${t.name}${cost}`);
+        });
+        if (groupTools.length > 5) {
+          console.log(`    ... and ${groupTools.length - 5} more`);
+        }
+        console.log('');
+      }
+      
+      console.log('  Filter: 50c tools <search>');
+      console.log('          50c tools --pack=grabr\n');
+      break;
+    }
+    
+    case 'doctor': {
+      console.log('\n  50c doctor - System Check\n');
+      
+      // Check API key
+      const apiKey = process.env.FIFTYC_API_KEY || process.env.FIFTY_CENT_API_KEY;
+      console.log(`  API Key: ${apiKey ? 'set (' + apiKey.slice(0, 8) + '...)' : 'not set'}`);
+      
+      // Check vault
+      const vaultStatus = await lib.vault.status();
+      console.log(`  Vault: ${vaultStatus.initialized ? 'initialized' : 'not initialized'}`);
+      if (vaultStatus.initialized) {
+        console.log(`         ${vaultStatus.locked ? 'locked' : 'unlocked'}`);
+      }
+      
+      // Check packs
+      const packs = await lib.packs.listPacks();
+      console.log(`  Packs: ${packs.enabled?.length || 0} enabled`);
+      
+      // Check tools
+      const tools = await lib.getTools();
+      console.log(`  Tools: ${tools.length} available`);
+      
+      // Check IDE configs
+      console.log('\n  IDE Configs:');
+      const ides = ['cursor', 'windsurf', 'vscode', 'claude-desktop', 'verdent'];
+      for (const ide of ides) {
+        const configPath = getMCPConfigPath(ide);
+        if (configPath && fs.existsSync(configPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            const has50c = config.mcpServers?.['50c'] ? 'configured' : 'no 50c';
+            console.log(`    ${ide}: ${has50c}`);
+          } catch (e) {
+            console.log(`    ${ide}: invalid config`);
+          }
+        }
+      }
+      
+      // Overall status
+      console.log('\n  Status:');
+      if (!apiKey) {
+        console.log('    ! Set FIFTYC_API_KEY for API access');
+      }
+      if (!vaultStatus.initialized) {
+        console.log('    ! Run: 50c vault init <passphrase>');
+      }
+      if (apiKey && vaultStatus.initialized && tools.length > 50) {
+        console.log('    All good! 50c is ready.\n');
+      } else {
+        console.log('\n  Run: 50c init <ide>  to configure\n');
+      }
+      break;
+    }
+    
     case 'status':
       console.log(JSON.stringify(await lib.getStatus(), null, 2));
       break;
@@ -185,36 +416,44 @@ async function runCLI(args) {
       break;
       
     case 'help':
+    case '-h':
+    case '--help':
     default:
-      console.log(`50c - The AI Toolkit
+      console.log(`
+  50c - AI Toolkit (117+ tools)
 
-Usage:
-  50c                    Start MCP server (for AI tools)
-  50c status             Show status
-  50c discover           Show available packs
-  50c enable <pack>      Enable a pack
-  50c disable <pack>     Disable a pack
-  50c packs              List packs
-  50c vault <cmd>        Vault commands
+  Quick Start:
+    50c init <ide>         Auto-configure for your IDE
+    50c tools              List all available tools
+    50c doctor             Check setup and diagnose issues
 
-Packs:
-  vault    Secure credentials (always on)
-  whm      WHM/cPanel/SSH (39 tools)
-  cf       Cloudflare (34 tools)
-  wp       WordPress (14 tools)
-  ux       UI/UX toolkit (17 tools)
+  Packs:
+    50c packs              List enabled/available packs
+    50c enable <pack>      Enable a pack
+    50c disable <pack>     Disable a pack
+    50c discover           Show pack recommendations
 
-MCP Config:
-  {
-    "mcpServers": {
-      "50c": {
-        "command": "50c",
-        "env": { "FIFTY_CENT_API_KEY": "cv_xxx" }
-      }
-    }
-  }
+  Vault (secure storage):
+    50c vault init <pass>  Initialize encrypted vault
+    50c vault add <k> <v>  Store a credential
+    50c vault get <key>    Retrieve a credential
+    50c vault list         List stored credentials
+
+  MCP Server:
+    50c                    Start MCP server (for IDEs)
+    50c --mcp              Force MCP mode
+
+  Supported IDEs:
+    cursor, windsurf, vscode, claude-desktop, verdent
+
+  Example:
+    $ npx -y 50c init cursor
+    $ 50c tools grabr
+    $ 50c vault init mysecret
 
-More info: https://50c.ai/docs`);
+  Docs: https://50c.ai/docs
+  Help: https://discord.gg/50c
+`);
   }
 }
 

package/lib/index.js

@@ -23,13 +23,15 @@ const cf = require('./packs/cf');
 const wp = require('./packs/wp');
 const ux = require('./packs/ux');
 const promptEngine = require('./packs/prompt_engine');
+const grabr = require('./packs/grabr');
 
 // Tool name mappings by pack
 const TOOL_PACKS = {
   beacon: ['hints', 'hints_plus', 'roast', 'quick_vibe', 'one_liner', 'name_it', 'price_it', 'compute', 'ide_conversation', 'learning_stats'],
   labs: ['genius', 'mind_opener', 'idea_fold', 'agent_autopsy', 'prompt_fortress', 'context_health', 'context_compress', 'context_extract', 'context_reposition'],
   labs_plus: ['bcalc', 'genius_plus', 'bcalc_why', 'discovery_collision', 'cvi_loop', 'cvi_verify', 'chaos_fingerprint', 'resonance', 'prime_residue', 'echo_sequence', 'conversation_diagnostic', 'handoff'],
-  prompt_engine: ['prompt_extract', 'prompt_phases', 'prompt_refine', 'prompt_expand', 'prompt_categorize']
+  prompt_engine: ['prompt_extract', 'prompt_phases', 'prompt_refine', 'prompt_expand', 'prompt_categorize'],
+  grabr: ['grabr_scrape', 'grabr_contact', 'grabr_wayback', 'grabr_sitemap', 'grabr_batch', 'grabr_intel']
 };
 
 // Get all available tools based on enabled packs
@@ -56,6 +58,7 @@ async function getTools() {
   if (config.packs.wp) tools.push(...wp.WP_TOOLS);
   if (config.packs.ux) tools.push(...ux.UX_TOOLS);
   if (config.packs.prompt_engine) tools.push(...promptEngine.PROMPT_ENGINE_TOOLS);
+  if (config.packs.grabr) tools.push(...grabr.GRABR_TOOLS);
   
   // ENTERPRISE tier
   if (config.packs.labs_plus) tools.push(...labsPlus.LABS_PLUS_TOOLS);
@@ -112,6 +115,14 @@ async function handleTool(name, args = {}) {
     return promptEngine.handleTool(name, args);
   }
   
+  // Grabr tools (PRO)
+  if (TOOL_PACKS.grabr.includes(name) || name.startsWith('grabr_')) {
+    if (!config.packs.grabr) {
+      return { error: 'Requires Pro tier ($99/mo). Enable grabr pack or upgrade at sales.50c.ai/50c-pro/' };
+    }
+    return grabr.handleTool(name, args);
+  }
+  
   // Labs+ tools (ENTERPRISE)
   if (TOOL_PACKS.labs_plus.includes(name)) {
     if (!config.packs.labs_plus) {
@@ -183,5 +194,6 @@ module.exports = {
   beacon,
   labs,
   labsPlus,
-  promptEngine
+  promptEngine,
+  grabr
 };

package/lib/packs/grabr.js

@@ -0,0 +1,443 @@
+/**
+ * 50c Grabr Pack - PRO Tier
+ * Web scraping + contact extraction + Wayback Machine
+ * Designed for: Lead gen, OSINT, competitive intel, domain recovery
+ */
+
+const { apiRequest } = require('../config');
+
+// URL validation regex
+const URL_REGEX = /^https?:\/\/[^\s/$.?#].[^\s]*$/i;
+const DOMAIN_REGEX = /^[a-zA-Z0-9][-a-zA-Z0-9]*(\.[a-zA-Z0-9][-a-zA-Z0-9]*)+$/;
+
+// Contact extraction patterns (from Grabr)
+const EMAIL_REGEX = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g;
+const PHONE_PATTERNS = [
+  /\+1[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+  /\b1[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+  /\b\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+];
+
+const SOCIAL_PATTERNS = {
+  twitter: /https?:\/\/(www\.)?(twitter\.com|x\.com)\/[a-zA-Z0-9_]+/gi,
+  facebook: /https?:\/\/(www\.)?facebook\.com\/[a-zA-Z0-9.]+/gi,
+  linkedin: /https?:\/\/(www\.)?linkedin\.com\/(in|company)\/[a-zA-Z0-9-]+/gi,
+  instagram: /https?:\/\/(www\.)?instagram\.com\/[a-zA-Z0-9_.]+/gi,
+  youtube: /https?:\/\/(www\.)?youtube\.com\/(c|channel|user)\/[a-zA-Z0-9_-]+/gi,
+};
+
+// Invalid email patterns to filter
+const INVALID_EMAIL_PATTERNS = [
+  /\.(png|jpg|jpeg|gif|svg|webp)$/i,
+  /example\.com/i,
+  /test\.com/i,
+  /sentry\.io/i,
+];
+
+function isValidEmail(email) {
+  const lower = email.toLowerCase();
+  for (const pattern of INVALID_EMAIL_PATTERNS) {
+    if (pattern.test(lower)) return false;
+  }
+  const parts = email.split('@');
+  if (parts.length !== 2) return false;
+  const [local, domain] = parts;
+  if (!local || !domain || !domain.includes('.')) return false;
+  return true;
+}
+
+function extractEmails(text) {
+  const matches = text.match(EMAIL_REGEX) || [];
+  return [...new Set(matches.filter(isValidEmail).map(e => e.toLowerCase()))];
+}
+
+function extractPhones(text) {
+  const phones = new Set();
+  for (const pattern of PHONE_PATTERNS) {
+    const matches = text.matchAll(pattern);
+    for (const match of matches) {
+      let digits = match[0].replace(/\D/g, '');
+      if (digits.length === 11 && digits[0] === '1') digits = digits.slice(1);
+      if (digits.length === 10) {
+        // Validate area code
+        if (digits[0] === '0' || digits[0] === '1') continue;
+        if (digits[3] === '0' || digits[3] === '1') continue;
+        if (/^(\d)\1+$/.test(digits)) continue; // All same digits
+        const formatted = `+1 (${digits.slice(0,3)}) ${digits.slice(3,6)}-${digits.slice(6)}`;
+        phones.add(formatted);
+      }
+    }
+  }
+  return [...phones];
+}
+
+function extractSocialLinks(text) {
+  const social = {};
+  for (const [platform, pattern] of Object.entries(SOCIAL_PATTERNS)) {
+    const matches = text.match(pattern);
+    if (matches && matches.length > 0) {
+      // Filter out share/intent links
+      const valid = matches.filter(url => 
+        !url.includes('/share') && 
+        !url.includes('/intent') && 
+        !url.includes('/sharer')
+      );
+      if (valid.length > 0) social[platform] = valid[0];
+    }
+  }
+  return social;
+}
+
+function extractAddress(text) {
+  const addressRegex = /(\d+\s+[A-Za-z\s]+(?:Street|St|Avenue|Ave|Road|Rd|Boulevard|Blvd|Lane|Ln|Drive|Dr|Court|Ct|Way|Place|Pl)\.?),?\s*([A-Za-z\s]+),?\s*([A-Z]{2})\s*(\d{5})/gi;
+  const match = addressRegex.exec(text);
+  if (match) {
+    return {
+      street: match[1].trim(),
+      city: match[2].trim(),
+      state: match[3],
+      zip: match[4]
+    };
+  }
+  return null;
+}
+
+// Tool implementations
+async function grabrScrape(url, depth = 1) {
+  if (!URL_REGEX.test(url)) {
+    return { error: 'Invalid URL format' };
+  }
+  
+  try {
+    // Use 50c page_fetch via API
+    const result = await apiRequest('page_fetch', { url });
+    if (result.error) return { error: result.error };
+    
+    const html = result.content || result.text || '';
+    
+    const contacts = {
+      emails: extractEmails(html),
+      phones: extractPhones(html),
+      address: extractAddress(html),
+      social: extractSocialLinks(html)
+    };
+    
+    // Deep scrape - follow contact/about pages
+    if (depth >= 2 && contacts.emails.length === 0) {
+      const contactLinks = html.match(/href=["']([^"']*(?:contact|about)[^"']*)["']/gi) || [];
+      for (const linkMatch of contactLinks.slice(0, 2)) {
+        const href = linkMatch.match(/href=["']([^"']+)["']/)?.[1];
+        if (href) {
+          try {
+            const fullUrl = href.startsWith('http') ? href : new URL(href, url).href;
+            const subResult = await apiRequest('page_fetch', { url: fullUrl });
+            if (subResult.content) {
+              contacts.emails.push(...extractEmails(subResult.content));
+              contacts.phones.push(...extractPhones(subResult.content));
+              if (!contacts.address) contacts.address = extractAddress(subResult.content);
+              Object.assign(contacts.social, extractSocialLinks(subResult.content));
+            }
+          } catch (e) { /* skip broken links */ }
+        }
+      }
+      // Dedupe
+      contacts.emails = [...new Set(contacts.emails)];
+      contacts.phones = [...new Set(contacts.phones)];
+    }
+    
+    return {
+      success: true,
+      url,
+      depth,
+      contacts,
+      meta: {
+        title: (html.match(/<title>([^<]+)<\/title>/i) || [])[1] || null,
+        description: (html.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["']/i) || [])[1] || null
+      }
+    };
+  } catch (e) {
+    return { error: e.message || 'Scrape failed' };
+  }
+}
+
+async function grabrContact(content) {
+  if (!content || typeof content !== 'string') {
+    return { error: 'Content required' };
+  }
+  
+  return {
+    success: true,
+    emails: extractEmails(content),
+    phones: extractPhones(content),
+    address: extractAddress(content),
+    social: extractSocialLinks(content)
+  };
+}
+
+async function grabrWayback(url, years = 5) {
+  if (!URL_REGEX.test(url)) {
+    return { error: 'Invalid URL format' };
+  }
+  
+  try {
+    const snapshots = [];
+    const currentYear = new Date().getFullYear();
+    const startYear = currentYear - years;
+    const months = [1, 6]; // Check Jan and June
+    
+    for (let year = currentYear; year >= startYear && snapshots.length < 10; year--) {
+      for (const month of months) {
+        if (snapshots.length >= 10) break;
+        const timestamp = `${year}${String(month).padStart(2, '0')}01`;
+        const checkUrl = `https://archive.org/wayback/available?url=${encodeURIComponent(url)}&timestamp=${timestamp}`;
+        
+        try {
+          const resp = await fetch(checkUrl, { 
+            headers: { 'User-Agent': '50c-grabr/1.0' },
+            signal: AbortSignal.timeout(10000)
+          });
+          if (resp.ok) {
+            const data = await resp.json();
+            if (data.archived_snapshots?.closest?.available) {
+              const snap = data.archived_snapshots.closest;
+              if (!snapshots.find(s => s.timestamp === snap.timestamp)) {
+                snapshots.push({
+                  timestamp: snap.timestamp,
+                  url: snap.url,
+                  date: `${snap.timestamp.slice(0,4)}-${snap.timestamp.slice(4,6)}-${snap.timestamp.slice(6,8)}`
+                });
+              }
+            }
+          }
+        } catch (e) { /* skip failed checks */ }
+        
+        // Rate limit
+        await new Promise(r => setTimeout(r, 500));
+      }
+    }
+    
+    return {
+      success: true,
+      url,
+      snapshots,
+      oldest: snapshots[snapshots.length - 1]?.date || null,
+      newest: snapshots[0]?.date || null
+    };
+  } catch (e) {
+    return { error: e.message || 'Wayback lookup failed' };
+  }
+}
+
+async function grabrSitemap(url) {
+  // Normalize to sitemap URL
+  let sitemapUrl = url;
+  if (!url.includes('sitemap')) {
+    const base = url.replace(/\/$/, '');
+    sitemapUrl = `${base}/sitemap.xml`;
+  }
+  
+  try {
+    const result = await apiRequest('page_fetch', { url: sitemapUrl });
+    if (result.error) {
+      // Try robots.txt fallback
+      const robotsUrl = url.replace(/\/$/, '') + '/robots.txt';
+      const robotsResult = await apiRequest('page_fetch', { url: robotsUrl });
+      if (robotsResult.content) {
+        const sitemapMatch = robotsResult.content.match(/Sitemap:\s*(\S+)/i);
+        if (sitemapMatch) {
+          const altResult = await apiRequest('page_fetch', { url: sitemapMatch[1] });
+          if (altResult.content) {
+            result.content = altResult.content;
+          }
+        }
+      }
+    }
+    
+    if (!result.content) {
+      return { error: 'Sitemap not found' };
+    }
+    
+    // Parse sitemap XML
+    const urls = [];
+    const locMatches = result.content.matchAll(/<loc>([^<]+)<\/loc>/gi);
+    for (const match of locMatches) {
+      urls.push(match[1]);
+    }
+    
+    return {
+      success: true,
+      sitemapUrl,
+      urls: urls.slice(0, 500), // Cap at 500
+      total: urls.length
+    };
+  } catch (e) {
+    return { error: e.message || 'Sitemap parse failed' };
+  }
+}
+
+async function grabrBatch(urls, delayMs = 1000) {
+  if (!Array.isArray(urls) || urls.length === 0) {
+    return { error: 'URLs array required' };
+  }
+  if (urls.length > 10) {
+    return { error: 'Maximum 10 URLs per batch' };
+  }
+  
+  const results = [];
+  for (const url of urls) {
+    const result = await grabrScrape(url, 1);
+    results.push({ url, ...result });
+    
+    // Rate limit between requests
+    if (delayMs > 0) {
+      await new Promise(r => setTimeout(r, Math.max(delayMs, 500)));
+    }
+  }
+  
+  return {
+    success: true,
+    processed: results.length,
+    results
+  };
+}
+
+async function grabrIntel(domain) {
+  if (!DOMAIN_REGEX.test(domain)) {
+    return { error: 'Invalid domain format' };
+  }
+  
+  const url = `https://${domain}`;
+  
+  // Parallel fetch main info
+  const [scrapeResult, sitemapResult, waybackResult] = await Promise.all([
+    grabrScrape(url, 2),
+    grabrSitemap(url).catch(() => ({ urls: [], total: 0 })),
+    grabrWayback(url, 3).catch(() => ({ snapshots: [] }))
+  ]);
+  
+  return {
+    success: true,
+    domain,
+    contacts: scrapeResult.contacts || {},
+    meta: scrapeResult.meta || {},
+    pages: {
+      total: sitemapResult.total || 0,
+      sample: (sitemapResult.urls || []).slice(0, 10)
+    },
+    history: {
+      snapshots: (waybackResult.snapshots || []).length,
+      oldest: waybackResult.oldest,
+      newest: waybackResult.newest
+    }
+  };
+}
+
+// Tool definitions for MCP
+const GRABR_TOOLS = [
+  {
+    name: 'grabr_scrape',
+    description: 'Deep scrape URL for contacts (email, phone, address) + social links. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to scrape' },
+        depth: { type: 'number', description: 'Scrape depth 1-3 (default 1)', default: 1 }
+      },
+      required: ['url']
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'grabr_contact',
+    description: 'Extract contacts from HTML/text content. $0.02',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'HTML or text to extract from' }
+      },
+      required: ['content']
+    },
+    cost: 0.02,
+    tier: 'pro'
+  },
+  {
+    name: 'grabr_wayback',
+    description: 'Get Wayback Machine snapshots for URL. $0.02',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to check' },
+        years: { type: 'number', description: 'Years to look back (default 5)', default: 5 }
+      },
+      required: ['url']
+    },
+    cost: 0.02,
+    tier: 'pro'
+  },
+  {
+    name: 'grabr_sitemap',
+    description: 'Parse sitemap.xml and return all page URLs. $0.02',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'Site URL or sitemap URL' }
+      },
+      required: ['url']
+    },
+    cost: 0.02,
+    tier: 'pro'
+  },
+  {
+    name: 'grabr_batch',
+    description: 'Scrape up to 10 URLs with rate limiting. $0.10',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        urls: { type: 'array', items: { type: 'string' }, description: 'URLs to scrape (max 10)' },
+        delayMs: { type: 'number', description: 'Delay between requests in ms (min 500)', default: 1000 }
+      },
+      required: ['urls']
+    },
+    cost: 0.10,
+    tier: 'pro'
+  },
+  {
+    name: 'grabr_intel',
+    description: 'Full domain intel: contacts, pages, social, history. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        domain: { type: 'string', description: 'Domain name (e.g., example.com)' }
+      },
+      required: ['domain']
+    },
+    cost: 0.08,
+    tier: 'pro'
+  }
+];
+
+async function handleTool(name, args) {
+  try {
+    switch (name) {
+      case 'grabr_scrape':
+        return await grabrScrape(args.url, args.depth || 1);
+      case 'grabr_contact':
+        return await grabrContact(args.content);
+      case 'grabr_wayback':
+        return await grabrWayback(args.url, args.years || 5);
+      case 'grabr_sitemap':
+        return await grabrSitemap(args.url);
+      case 'grabr_batch':
+        return await grabrBatch(args.urls, args.delayMs || 1000);
+      case 'grabr_intel':
+        return await grabrIntel(args.domain);
+      default:
+        return { error: `Unknown grabr tool: ${name}` };
+    }
+  } catch (e) {
+    return { error: e.message || 'Tool execution failed' };
+  }
+}
+
+module.exports = { GRABR_TOOLS, handleTool };

package/lib/packs.js

@@ -87,6 +87,13 @@ const PACKS = {
     tier: 'pro',
     highlights: ['domains_expiring', 'writing_draft', 'bookmarks_prune', 'csv_clean']
   },
+  grabr: {
+    name: 'grabr',
+    description: 'Web scraping - contacts, social links, Wayback, sitemaps',
+    tools: 6,
+    tier: 'pro',
+    highlights: ['grabr_scrape', 'grabr_intel', 'grabr_wayback', 'grabr_batch']
+  },
 
   // === ENTERPRISE TIER ($499/mo) ===
   labs_plus: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "50c",
-  "version": "2.7.0",
-  "description": "AI toolkit with prompt engine. One install, 105+ tools.",
+  "version": "2.9.0",
+  "description": "AI toolkit with init/doctor CLI. One install, 117+ tools.",
   "main": "lib/index.js",
   "bin": {
     "50c": "./bin/50c.js"
@@ -13,17 +13,16 @@
     "tools",
     "genius",
     "prompt-engine",
-    "agent-autopsy",
-    "prompt-fortress",
+    "grabr",
+    "scraper",
+    "wayback",
     "bcalc",
     "vault",
     "cloudflare",
     "whm",
     "cpanel",
     "wordpress",
-    "librarian",
-    "bookmarks",
-    "csv"
+    "librarian"
   ],
   "author": "genxis.com",
   "license": "MIT",