50c 1.4.1 → 2.0.0

package/bin/50c.js

@@ -1,187 +1,241 @@
 #!/usr/bin/env node
-const https = require('https');
-const readline = require('readline');
-
-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);
-}
-
-// Help
-if (process.argv.includes('--help') || process.argv.includes('-h')) {
-  showHelp();
-  process.exit(0);
-}
-
-function showHelp() {
-  console.log(`
-50c - AI Augmentation CLI & MCP Server
-
-USAGE:
-  50c <command> <input>     Direct CLI mode
-  50c                       MCP mode (JSON-RPC via stdin)
-
-COMMANDS:
-  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:
-  50c genius "How do I scale PostgreSQL?"
-  50c hints "api design"
-  50c one-liner "habit tracker with friends"
-  50c roast "const x = localStorage.getItem('jwt')"
-  50c name-it "AI that writes emails"
-  50c price-it "email automation SaaS"
-
-ENVIRONMENT:
-  FIFTYC_API_KEY     Your API key (required)
-  FIFTYC_ENDPOINT    Custom endpoint (default: https://50c.ai)
-
-MCP MODE:
-  Run without arguments for IDE integration (Claude Desktop, Cursor, etc.)
-`);
-}
-
-// Check API key
-if (!API_KEY) {
-  console.error('Error: FIFTYC_API_KEY environment variable required');
-  console.error('Get your key at: https://50c.ai');
-  process.exit(1);
-}
-
-// 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(' ');
+/**
+ * 50c CLI & MCP Server
+ * The AI toolkit - one package, all tools, works everywhere
+ */
 
-if (command && COMMANDS.includes(command)) {
-  if (!input) {
-    console.error(`Error: ${command} requires input`);
-    process.exit(1);
-  }
-  
-  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();
-}
+const readline = require('readline');
+const lib = require('../lib');
 
-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' }
-  };
+// MCP Protocol Handler
+async function handleMCP(req) {
+  const { id, method, params } = req;
   
-  const tool = toolMap[cmd];
-  if (!tool) throw new Error(`Unknown command: ${cmd}`);
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: { listChanged: true } },
+        serverInfo: { name: '50c', version: '2.0.0' }
+      }
+    };
+  }
   
-  const request = {
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'tools/call',
-    params: { 
-      name: tool.name, 
-      arguments: { [tool.arg]: query } 
-    }
-  };
+  if (method === 'notifications/initialized') {
+    return null;
+  }
   
-  const response = await callRemoteMCP(request);
+  if (method === 'tools/list') {
+    const tools = await lib.getTools();
+    return { jsonrpc: '2.0', id, result: { tools } };
+  }
   
-  if (response.error) {
-    throw new Error(response.error.message || JSON.stringify(response.error));
+  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) }]
+      }
+    };
   }
   
-  return response.result?.content?.[0]?.text || 'No output';
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code: -32601, message: 'Method not found' }
+  };
 }
 
-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`);
+  }
+}
+
+// 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);
+  }
 }
 
-process.on('SIGINT', () => process.exit(130));
-process.on('SIGTERM', () => process.exit(143));
+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;
+  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;
+  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 || '';
+    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
+};

package/lib/core/tools.js

@@ -0,0 +1,107 @@
+/**
+ * 50c Core Tools - Always Free
+ * search, fetch, domain_check, balance
+ */
+
+const https = require('https');
+const http = require('http');
+const { apiRequest } = require('../config');
+
+// Web Search
+async function webSearch(query, options = {}) {
+  return apiRequest('POST', '/tools/web_search', {
+    query,
+    max_results: options.max_results || 5
+  });
+}
+
+// Page Fetch
+async function pageFetch(url, query = '') {
+  return apiRequest('POST', '/tools/page_fetch', { url, query });
+}
+
+// Domain Check
+async function domainCheck(domain) {
+  return apiRequest('POST', '/tools/domain_check', { domain });
+}
+
+// Check Balance
+async function checkBalance() {
+  return apiRequest('GET', '/user/balance');
+}
+
+// Tool definitions
+const CORE_TOOLS = [
+  {
+    name: 'web_search',
+    description: 'Search the internet. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        max_results: { type: 'number', default: 5 }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'page_fetch',
+    description: 'Fetch and extract content from URL. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to fetch' },
+        query: { type: 'string', description: 'Optional: question about the page' }
+      },
+      required: ['url']
+    }
+  },
+  {
+    name: 'domain_check',
+    description: 'Check domain availability. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        domain: { type: 'string', description: 'Domain to check (e.g., example.com)' }
+      },
+      required: ['domain']
+    }
+  },
+  {
+    name: 'check_balance',
+    description: 'Check your credit balance. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  }
+];
+
+// Handle core tool calls
+async function handleTool(name, args) {
+  try {
+    switch (name) {
+      case 'web_search':
+        return await webSearch(args.query, args);
+      case 'page_fetch':
+        return await pageFetch(args.url, args.query);
+      case 'domain_check':
+        return await domainCheck(args.domain);
+      case 'check_balance':
+        return await checkBalance();
+      default:
+        return { error: `Unknown core tool: ${name}` };
+    }
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+module.exports = {
+  CORE_TOOLS,
+  handleTool,
+  webSearch,
+  pageFetch,
+  domainCheck,
+  checkBalance
+};