50c 1.5.0 → 2.0.1

package/bin/50c.js

@@ -1,289 +1,241 @@
 #!/usr/bin/env node
-const https = require('https');
-const readline = require('readline');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const API_ENDPOINT = process.env.FIFTYC_ENDPOINT || 'https://50c.ai';
-const MCP_ENDPOINT = API_ENDPOINT + '/mcp';
-const API_KEY = process.env.FIFTYC_API_KEY;
-
-// Version
-if (process.argv.includes('--version') || process.argv.includes('-v')) {
-  console.log(require('../package.json').version);
-  process.exit(0);
-}
-
-// Install MCP to IDE
-if (process.argv.includes('--install') || process.argv.includes('install')) {
-  installMCP();
-  process.exit(0);
-}
+/**
+ * 50c CLI & MCP Server
+ * The AI toolkit - one package, all tools, works everywhere
+ */
 
-// Help
-if (process.argv.includes('--help') || process.argv.includes('-h')) {
-  showHelp();
-  process.exit(0);
-}
+const readline = require('readline');
+const lib = require('../lib');
 
-function installMCP() {
-  const home = os.homedir();
-  const isWin = process.platform === 'win32';
-  const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
-  const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
-  
-  const ides = [
-    // Desktop IDEs
-    { name: 'Claude Desktop', path: isWin ? path.join(appData, 'Claude', 'claude_desktop_config.json') : path.join(home, '.claude', 'claude_desktop_config.json'), key: 'mcpServers' },
-    { name: 'Cursor', path: path.join(home, '.cursor', 'mcp.json'), key: 'mcpServers' },
-    { name: 'Windsurf', path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'), key: 'mcpServers' },
-    { name: 'VS Code', path: path.join(home, '.vscode', 'mcp.json'), key: 'servers' },
-    { name: 'VS Code Insiders', path: path.join(home, '.vscode-insiders', 'mcp.json'), key: 'servers' },
-    { name: 'VSCodium', path: path.join(home, '.vscodium', 'mcp.json'), key: 'servers' },
-    { name: 'Verdent', path: path.join(home, '.verdent', 'mcp.json'), key: 'mcpServers' },
-    // Roo Code / Continue / Cline
-    { name: 'Roo Code', path: path.join(home, '.roo-code', 'mcp.json'), key: 'mcpServers' },
-    { name: 'Roo Code (AppData)', path: isWin ? path.join(appData, 'Roo-Code', 'mcp.json') : null, key: 'mcpServers' },
-    { name: 'Continue', path: path.join(home, '.continue', 'mcp.json'), key: 'mcpServers' },
-    { name: 'Cline', path: path.join(home, '.cline', 'mcp.json'), key: 'mcpServers' },
-    { name: 'Cline (VS Code)', path: isWin ? path.join(appData, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json') : path.join(home, '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'), key: 'mcpServers' },
-    // JetBrains IDEs
-    { name: 'JetBrains', path: path.join(home, '.jb-mcp', 'mcp.json'), key: 'mcpServers' },
-    { name: 'IntelliJ IDEA', path: isWin ? path.join(appData, 'JetBrains', 'IntelliJIdea', 'mcp.json') : path.join(home, '.config', 'JetBrains', 'mcp.json'), key: 'mcpServers' },
-    // Augment
-    { name: 'Augment', path: path.join(home, '.augment', 'mcp.json'), key: 'mcpServers' },
-    // Zed
-    { name: 'Zed', path: path.join(home, '.config', 'zed', 'settings.json'), key: 'context_servers', nested: true },
-  ].filter(ide => ide.path); // Remove null paths
-  
-  const mcpEntry = {
-    command: 'npx',
-    args: ['-y', '50c'],
-    env: { FIFTYC_API_KEY: API_KEY || '<YOUR_API_KEY>' }
-  };
+// MCP Protocol Handler
+async function handleMCP(req) {
+  const { id, method, params } = req;
   
-  // Zed uses different format
-  const zedEntry = {
-    command: { path: 'npx', args: ['-y', '50c'], env: { FIFTYC_API_KEY: API_KEY || '<YOUR_API_KEY>' } }
-  };
-  
-  let installed = [];
-  let hostedNote = false;
-  
-  for (const ide of ides) {
-    try {
-      let config = {};
-      const dir = path.dirname(ide.path);
-      
-      if (fs.existsSync(ide.path)) {
-        config = JSON.parse(fs.readFileSync(ide.path, 'utf8'));
-      } else if (fs.existsSync(dir)) {
-        // Dir exists but no config file - create it
-      } else {
-        continue; // IDE not installed
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: { listChanged: true } },
+        serverInfo: { name: '50c', version: '2.0.0' }
       }
-      
-      if (!config[ide.key]) config[ide.key] = {};
-      if (config[ide.key]['50c']) {
-        console.log(`[skip] ${ide.name} - already configured`);
-        continue;
-      }
-      
-      config[ide.key]['50c'] = ide.name === 'Zed' ? zedEntry : mcpEntry;
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(ide.path, JSON.stringify(config, null, 2));
-      installed.push(ide.name);
-      console.log(`[done] ${ide.name} - added 50c`);
-    } catch (e) {
-      // Skip silently
-    }
+    };
   }
   
-  console.log('');
-  if (installed.length > 0) {
-    console.log(`Installed to: ${installed.join(', ')}`);
-    console.log('');
-    if (!API_KEY) {
-      console.log('Next: Set FIFTYC_API_KEY in the config or as env var');
-      console.log('Get key at: https://50c.ai');
-    } else {
-      console.log('Restart your IDE to activate 50c tools.');
-    }
-  } else {
-    console.log('No local IDEs detected.');
+  if (method === 'notifications/initialized') {
+    return null;
   }
   
-  console.log('');
-  console.log('Hosted IDEs (manual setup via their MCP settings):');
-  console.log('  Bolt.new, Replit, Lovable, Mocha, v0.dev');
-  console.log('  Use: npx -y 50c (command) with FIFTYC_API_KEY env');
-}
-
-function showHelp() {
-  console.log(`
-50c - AI Augmentation CLI & MCP Server
-
-QUICK START:
-  npx 50c install             Auto-configure MCP for your IDE
-  
-USAGE:
-  50c <command> <input>       Direct CLI mode
-  50c                         MCP mode (JSON-RPC via stdin)
-
-COMMANDS:
-  install                     Add 50c to all detected IDEs
-  genius <problem>            Deep problem solving ($0.50)
-  hints <topic>               5 brutal 2-word hints ($0.05)
-  hints+ <topic>              10 expanded hints ($0.10)
-  vibe <working_on>           3 unconventional ideas ($0.05)
-  one-liner <product>         Elevator pitch in 8 words ($0.02)
-  roast <code>                Brutal code review ($0.05)
-  name-it <does>              5 names + domain check ($0.03)
-  price-it <product>          SaaS pricing strategy ($0.05)
-  compute <code>              Execute Python code ($0.02)
-
-EXAMPLES:
-  npx 50c install
-  50c genius "How do I scale PostgreSQL?"
-  50c hints "api design"
-
-ENVIRONMENT:
-  FIFTYC_API_KEY     Your API key (required)
-
-MCP MODE:
-  Run without arguments for IDE integration (Claude Desktop, Cursor, etc.)
-`);
-}
-
-// CLI commands
-const COMMANDS = ['genius', 'hints', 'hints+', 'vibe', 'compute', 'one-liner', 'roast', 'name-it', 'price-it', 'mind-opener'];
-const command = process.argv[2];
-const input = process.argv.slice(3).join(' ');
-
-// Check API key (not needed for install/help/version)
-if (!API_KEY && command && COMMANDS.includes(command)) {
-  console.error('Error: FIFTYC_API_KEY environment variable required');
-  console.error('Get your key at: https://50c.ai');
-  process.exit(1);
-}
-
-if (command && COMMANDS.includes(command)) {
-  if (!input) {
-    console.error(`Error: ${command} requires input`);
-    process.exit(1);
+  if (method === 'tools/list') {
+    const tools = await lib.getTools();
+    return { jsonrpc: '2.0', id, result: { tools } };
   }
   
-  runCLI(command, input).then(result => {
-    console.log(result);
-    process.exit(0);
-  }).catch(err => {
-    console.error('Error:', err.message);
-    process.exit(1);
-  });
-} else if (command) {
-  startMCPMode();
-} else {
-  startMCPMode();
-}
-
-async function runCLI(cmd, query) {
-  // Map CLI commands to MCP tool names
-  const toolMap = {
-    'genius': { name: 'genius', arg: 'problem' },
-    'hints': { name: 'hints', arg: 'query' },
-    'hints+': { name: 'hints_plus', arg: 'query' },
-    'vibe': { name: 'quick_vibe', arg: 'working_on' },
-    'compute': { name: 'compute', arg: 'code' },
-    'one-liner': { name: 'one_liner', arg: 'product' },
-    'roast': { name: 'roast', arg: 'code' },
-    'name-it': { name: 'name_it', arg: 'does' },
-    'price-it': { name: 'price_it', arg: 'product' },
-    'mind-opener': { name: 'mind_opener', arg: 'problem' }
-  };
-  
-  const tool = toolMap[cmd];
-  if (!tool) throw new Error(`Unknown command: ${cmd}`);
+  if (method === 'tools/call') {
+    const result = await lib.handleTool(params?.name, params?.arguments || {});
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+      }
+    };
+  }
   
-  const request = {
+  return {
     jsonrpc: '2.0',
-    id: 1,
-    method: 'tools/call',
-    params: { 
-      name: tool.name, 
-      arguments: { [tool.arg]: query } 
-    }
+    id,
+    error: { code: -32601, message: 'Method not found' }
   };
-  
-  const response = await callRemoteMCP(request);
-  
-  if (response.error) {
-    throw new Error(response.error.message || JSON.stringify(response.error));
-  }
-  
-  return response.result?.content?.[0]?.text || 'No output';
 }
 
-function startMCPMode() {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+// MCP Server Mode
+async function runMCP() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
   
   rl.on('line', async (line) => {
     try {
-      const clean = line.trim();
-      if (!clean) return;
-      const request = JSON.parse(clean);
-      const response = await callRemoteMCP(request);
-      process.stdout.write(JSON.stringify(response) + '\n');
-    } catch (e) {
-      process.stdout.write(JSON.stringify({
+      const req = JSON.parse(line);
+      const res = await handleMCP(req);
+      if (res) console.log(JSON.stringify(res));
+    } catch (err) {
+      console.log(JSON.stringify({
         jsonrpc: '2.0',
         id: null,
-        error: { code: -32603, message: e.message }
-      }) + '\n');
+        error: { code: -32700, message: 'Parse error' }
+      }));
     }
   });
 }
 
-function callRemoteMCP(request) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(MCP_ENDPOINT);
-    const postData = JSON.stringify(request);
-    
-    const options = {
-      hostname: url.hostname,
-      port: url.port || 443,
-      path: url.pathname,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(postData),
-        'Authorization': `Bearer ${API_KEY}`,
-        'User-Agent': '50c-cli/1.4.0'
+// CLI Mode
+async function runCLI(args) {
+  const cmd = args[0];
+  const cmdArgs = args.slice(1);
+  
+  switch (cmd) {
+    case 'status':
+      console.log(JSON.stringify(await lib.getStatus(), null, 2));
+      break;
+      
+    case 'discover':
+      console.log(JSON.stringify(await lib.packs.discover(), null, 2));
+      break;
+      
+    case 'enable':
+      console.log(JSON.stringify(await lib.packs.enablePack(cmdArgs[0]), null, 2));
+      break;
+      
+    case 'disable':
+      console.log(JSON.stringify(await lib.packs.disablePack(cmdArgs[0]), null, 2));
+      break;
+      
+    case 'packs':
+      console.log(JSON.stringify(await lib.packs.listPacks(), null, 2));
+      break;
+      
+    // Vault commands
+    case 'vault':
+      const vaultCmd = cmdArgs[0];
+      const vaultArgs = cmdArgs.slice(1);
+      
+      if (vaultCmd === 'init') {
+        const passphrase = process.env.VAULT_PASSPHRASE || vaultArgs[0];
+        if (!passphrase) {
+          console.error('Usage: 50c vault init <passphrase>');
+          console.error('Or set VAULT_PASSPHRASE env var');
+          process.exit(1);
+        }
+        console.log(JSON.stringify(await lib.vault.init(passphrase), null, 2));
       }
-    };
-    
-    const req = https.request(options, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
+      else if (vaultCmd === 'unlock') {
+        const passphrase = process.env.VAULT_PASSPHRASE || vaultArgs[0];
+        if (!passphrase) {
+          console.error('Usage: 50c vault unlock <passphrase>');
+          process.exit(1);
+        }
+        console.log(JSON.stringify(await lib.vault.unlock(passphrase), null, 2));
+      }
+      else if (vaultCmd === 'lock') {
+        console.log(JSON.stringify(lib.vault.lock(), null, 2));
+      }
+      else if (vaultCmd === 'yolo') {
+        const passphrase = process.env.VAULT_PASSPHRASE || vaultArgs[0];
+        if (!passphrase) {
+          console.error('Usage: 50c vault yolo <passphrase>');
+          process.exit(1);
+        }
+        console.log(JSON.stringify(await lib.vault.yolo(passphrase), null, 2));
+      }
+      else if (vaultCmd === 'add') {
+        const [name, ...valueParts] = vaultArgs;
+        const value = valueParts.join(' ');
+        if (!name || !value) {
+          console.error('Usage: 50c vault add <name> <value>');
+          process.exit(1);
+        }
+        console.log(JSON.stringify(await lib.vault.add(name, value), null, 2));
+      }
+      else if (vaultCmd === 'get') {
+        const name = vaultArgs[0];
+        if (!name) {
+          console.error('Usage: 50c vault get <name>');
+          process.exit(1);
+        }
         try {
-          resolve(JSON.parse(data));
+          console.log(await lib.vault.get(name));
         } catch (e) {
-          reject(new Error(`Invalid response: ${data.substring(0, 200)}`));
+          console.error(e.message);
+          process.exit(1);
         }
-      });
-    });
-    
-    req.setTimeout(120000, () => {
-      req.destroy();
-      reject(new Error('Request timeout'));
-    });
-    
-    req.on('error', reject);
-    req.write(postData);
-    req.end();
-  });
+      }
+      else if (vaultCmd === 'list') {
+        const namespace = vaultArgs[0];
+        const list = await lib.vault.list(namespace);
+        list.forEach(n => console.log(n));
+      }
+      else if (vaultCmd === 'delete' || vaultCmd === 'rm') {
+        const name = vaultArgs[0];
+        if (!name) {
+          console.error('Usage: 50c vault delete <name>');
+          process.exit(1);
+        }
+        console.log(JSON.stringify(await lib.vault.remove(name), null, 2));
+      }
+      else if (vaultCmd === 'status') {
+        console.log(JSON.stringify(await lib.vault.status(), null, 2));
+      }
+      else {
+        console.log(`50c vault commands:
+  init <passphrase>    Initialize vault
+  unlock <passphrase>  Unlock for session
+  lock                 Lock immediately
+  yolo <passphrase>    Stay unlocked (dev mode)
+  add <name> <value>   Add credential
+  get <name>           Get credential
+  list [namespace]     List credentials
+  delete <name>        Delete credential
+  status               Check vault status`);
+      }
+      break;
+      
+    case 'help':
+    default:
+      console.log(`50c - The AI Toolkit
+
+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
+
+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)
+
+MCP Config:
+  {
+    "mcpServers": {
+      "50c": {
+        "command": "50c",
+        "env": { "FIFTY_CENT_API_KEY": "cv_xxx" }
+      }
+    }
+  }
+
+More info: https://50c.ai/docs`);
+  }
 }
 
-process.on('SIGINT', () => process.exit(130));
-process.on('SIGTERM', () => process.exit(143));
+// Main
+async function main() {
+  const args = process.argv.slice(2);
+  
+  // MCP mode: --mcp flag or no args AND piped input
+  const isMCPMode = args[0] === '--mcp' || (args.length === 0 && !process.stdin.isTTY);
+  
+  if (isMCPMode) {
+    await runMCP();
+  } else if (args.length === 0) {
+    // No args, show help
+    await runCLI(['help']);
+  } else {
+    await runCLI(args);
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/lib/config.js

@@ -0,0 +1,185 @@
+/**
+ * 50c Config & Mode Detection
+ * Handles local vs cloud mode automatically
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+
+// Storage locations by OS
+function getLocalDir() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), '50c');
+  } else if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', '50c');
+  } else {
+    return path.join(os.homedir(), '.local', 'share', '50c');
+  }
+}
+
+const LOCAL_DIR = getLocalDir();
+const CONFIG_FILE = path.join(LOCAL_DIR, 'config.json');
+const VAULT_DIR = path.join(LOCAL_DIR, 'vault');
+const API_URL = process.env.FIFTY_CENT_API_URL || 'https://api.50c.ai';
+
+// Default config
+const DEFAULT_CONFIG = {
+  api_key: '',
+  packs: {
+    vault: true,   // Always on
+    whm: false,
+    cf: false,
+    wp: false,
+    ux: false
+  },
+  vault: {
+    yolo_mode: false,
+    session_ttl: 3600,
+    idle_timeout: 1800
+  }
+};
+
+// Detect mode: local or cloud
+function detectMode() {
+  // Explicit override
+  if (process.env.FIFTY_CENT_MODE === 'cloud') return 'cloud';
+  if (process.env.FIFTY_CENT_MODE === 'local') return 'local';
+  
+  // Cloud indicators
+  if (process.env.REPL_ID) return 'cloud';                    // Replit
+  if (process.env.LOVABLE_PROJECT) return 'cloud';            // Lovable
+  if (process.env.CODESPACE_NAME) return 'cloud';             // GitHub Codespaces
+  if (process.env.CODESANDBOX_SSE) return 'cloud';            // CodeSandbox
+  if (process.env.GITPOD_WORKSPACE_ID) return 'cloud';        // Gitpod
+  
+  // Check if we can write locally
+  try {
+    if (!fs.existsSync(LOCAL_DIR)) {
+      fs.mkdirSync(LOCAL_DIR, { recursive: true, mode: 0o700 });
+    }
+    const testFile = path.join(LOCAL_DIR, '.write-test');
+    fs.writeFileSync(testFile, 'test', { mode: 0o600 });
+    fs.unlinkSync(testFile);
+    return 'local';
+  } catch {
+    return 'cloud';
+  }
+}
+
+const MODE = detectMode();
+
+// Ensure local directory exists
+function ensureLocalDir() {
+  if (MODE !== 'local') return;
+  if (!fs.existsSync(LOCAL_DIR)) {
+    fs.mkdirSync(LOCAL_DIR, { recursive: true, mode: 0o700 });
+  }
+  if (!fs.existsSync(VAULT_DIR)) {
+    fs.mkdirSync(VAULT_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+// Load config (local or cloud)
+async function loadConfig() {
+  if (MODE === 'local') {
+    return loadConfigLocal();
+  } else {
+    return loadConfigCloud();
+  }
+}
+
+function loadConfigLocal() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const saved = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...saved, packs: { ...DEFAULT_CONFIG.packs, ...saved.packs } };
+    }
+  } catch {}
+  return { ...DEFAULT_CONFIG };
+}
+
+async function loadConfigCloud() {
+  const apiKey = process.env.FIFTY_CENT_API_KEY || process.env.FIFTYC_API_KEY;
+  if (!apiKey) return { ...DEFAULT_CONFIG };
+  
+  try {
+    const response = await apiRequest('GET', '/user/config');
+    if (response && response.packs) {
+      return { ...DEFAULT_CONFIG, ...response, packs: { ...DEFAULT_CONFIG.packs, ...response.packs } };
+    }
+  } catch {}
+  return { ...DEFAULT_CONFIG };
+}
+
+// Save config (local or cloud)
+async function saveConfig(config) {
+  if (MODE === 'local') {
+    return saveConfigLocal(config);
+  } else {
+    return saveConfigCloud(config);
+  }
+}
+
+function saveConfigLocal(config) {
+  ensureLocalDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+async function saveConfigCloud(config) {
+  const apiKey = process.env.FIFTY_CENT_API_KEY || process.env.FIFTYC_API_KEY;
+  if (!apiKey) throw new Error('API key required for cloud mode');
+  
+  await apiRequest('PUT', '/user/config', { packs: config.packs, vault: config.vault });
+}
+
+// API request helper
+function apiRequest(method, endpoint, body = null) {
+  return new Promise((resolve, reject) => {
+    const apiKey = process.env.FIFTY_CENT_API_KEY || process.env.FIFTYC_API_KEY || '';
+    const url = new URL(endpoint, API_URL);
+    
+    const options = {
+      hostname: url.hostname,
+      port: url.port || 443,
+      path: url.pathname,
+      method: method,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'User-Agent': '50c/2.0.0'
+      }
+    };
+    
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          resolve({ raw: data });
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+module.exports = {
+  MODE,
+  LOCAL_DIR,
+  VAULT_DIR,
+  CONFIG_FILE,
+  API_URL,
+  DEFAULT_CONFIG,
+  detectMode,
+  ensureLocalDir,
+  loadConfig,
+  saveConfig,
+  apiRequest
+};