50c 3.9.2 → 4.0.0

package/lib/subagent.js

@@ -1,366 +1,369 @@
-#!/usr/bin/env node
-/**
- * 50c Sub-Agent - Pure Node.js execution engine
- * Bypasses IDE shell restrictions, works on ALL MCP-compatible IDEs
- * 
- * Capabilities:
- * - SSH remote execution (via ssh2)
- * - HTTP/HTTPS requests (native)
- * - File operations (native)
- * - Process spawning (child_process)
- */
-
-const { spawn, exec } = require('child_process');
-const https = require('https');
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
-
-// User-configured servers loaded from ~/.50c/servers.json
-// Run: 50c servers add <alias> <host> <user> to configure
-function loadUserServers() {
-  try {
-    const serversPath = path.join(require('os').homedir(), '.50c', 'servers.json');
-    if (fs.existsSync(serversPath)) {
-      return JSON.parse(fs.readFileSync(serversPath, 'utf8'));
-    }
-  } catch (e) {}
-  return {};
-}
-const KNOWN_SERVERS = loadUserServers();
-
-/**
- * HTTP/HTTPS fetch - no shell, pure Node
- */
-async function httpFetch(url, options = {}) {
-  return new Promise((resolve, reject) => {
-    const isHttps = url.startsWith('https');
-    const lib = isHttps ? https : http;
-    
-    const urlObj = new URL(url);
-    const bodyData = options.body || '';
-    const reqOptions = {
-      hostname: urlObj.hostname,
-      port: urlObj.port || (isHttps ? 443 : 80),
-      path: urlObj.pathname + urlObj.search,
-      method: options.method || 'GET',
-      headers: {
-        ...options.headers,
-        ...(bodyData ? { 'Content-Length': Buffer.byteLength(bodyData) } : {})
-      },
-      timeout: options.timeout || 30000,
-      // TLS certificate validation enabled for security
-    };
-
-    const req = lib.request(reqOptions, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        resolve({
-          status: res.statusCode,
-          headers: res.headers,
-          body: data,
-          ok: res.statusCode >= 200 && res.statusCode < 300
-        });
-      });
-    });
-
-    req.on('error', reject);
-    req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Request timeout'));
-    });
-
-    if (bodyData) {
-      req.write(bodyData);
-    }
-    req.end();
-  });
-}
-
-/**
- * SSH execution via native ssh command (spawned, not shell)
- * Fixed: Uses explicit identity file for Windows compatibility
- */
-async function sshExec(server, command, options = {}) {
-  const serverConfig = typeof server === 'string' ? KNOWN_SERVERS[server] : server;
-  
-  if (!serverConfig) {
-    throw new Error(`Unknown server: ${server}. Known: ${Object.keys(KNOWN_SERVERS).join(', ')}`);
-  }
-
-  const { host, user = 'root', port = 22 } = serverConfig;
-  const timeout = options.timeout || 30000;
-  
-  // Try to find SSH key - common locations
-  const os = require('os');
-  const homeDir = os.homedir();
-  const keyPaths = [
-    path.join(homeDir, '.ssh', 'id_rsa'),
-    path.join(homeDir, '.ssh', 'id_ed25519'),
-    options.keyFile
-  ].filter(Boolean);
-  
-  let identityArgs = [];
-  for (const keyPath of keyPaths) {
-    if (fs.existsSync(keyPath)) {
-      identityArgs = ['-i', keyPath];
-      break;
-    }
-  }
-
-  return new Promise((resolve, reject) => {
-    const args = [
-      '-o', 'StrictHostKeyChecking=no',
-      '-o', 'UserKnownHostsFile=/dev/null',
-      '-o', 'ConnectTimeout=10',
-      '-o', 'ServerAliveInterval=5',
-      '-o', 'ServerAliveCountMax=2',
-      ...identityArgs,
-      '-p', String(port),
-      `${user}@${host}`,
-      command
-    ];
-
-    const proc = spawn('ssh', args, {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout,
-      windowsHide: true
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    proc.stdout.on('data', data => stdout += data.toString());
-    proc.stderr.on('data', data => stderr += data.toString());
-
-    const timer = setTimeout(() => {
-      proc.kill('SIGTERM');
-      reject(new Error(`SSH timeout after ${timeout}ms`));
-    }, timeout);
-
-    proc.on('close', code => {
-      clearTimeout(timer);
-      resolve({
-        ok: code === 0,
-        code,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        server: serverConfig.name || host
-      });
-    });
-
-    proc.on('error', err => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-
-/**
- * Local command execution (spawned, controlled)
- */
-async function localExec(command, options = {}) {
-  const timeout = options.timeout || 30000;
-  const cwd = options.cwd || process.cwd();
-
-  return new Promise((resolve, reject) => {
-    exec(command, { timeout, cwd, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
-      resolve({
-        ok: !error,
-        code: error ? error.code || 1 : 0,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        command
-      });
-    });
-  });
-}
-
-/**
- * File operations
- */
-const fileOps = {
-  read: (filePath) => {
-    try {
-      return { ok: true, content: fs.readFileSync(filePath, 'utf8') };
-    } catch (e) {
-      return { ok: false, error: e.message };
-    }
-  },
-  
-  write: (filePath, content) => {
-    try {
-      fs.mkdirSync(path.dirname(filePath), { recursive: true });
-      fs.writeFileSync(filePath, content);
-      return { ok: true, path: filePath };
-    } catch (e) {
-      return { ok: false, error: e.message };
-    }
-  },
-  
-  exists: (filePath) => ({ ok: true, exists: fs.existsSync(filePath) }),
-  
-  list: (dirPath) => {
-    try {
-      return { ok: true, files: fs.readdirSync(dirPath) };
-    } catch (e) {
-      return { ok: false, error: e.message };
-    }
-  }
-};
-
-/**
- * 50c MCP Tool calling - call any 50c tool via API
- */
-const API_ENDPOINT = process.env.FIFTYC_ENDPOINT || 'https://api.50c.ai';
-
-async function call50cTool(toolName, toolArgs, apiKey) {
-  const key = apiKey || process.env.FIFTYC_API_KEY || loadApiKey();
-  
-  if (!key) {
-    return { ok: false, error: 'No API key. Set FIFTYC_API_KEY or run: 50c config key <key>' };
-  }
-  
-  try {
-    const response = await httpFetch(`${API_ENDPOINT}/tools/${toolName}`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${key}`
-      },
-      body: JSON.stringify(toolArgs || {}),
-      timeout: 120000 // 2 min for genius+
-    });
-    
-    if (!response.ok) {
-      return { ok: false, error: `HTTP ${response.status}`, body: response.body };
-    }
-    
-    const result = JSON.parse(response.body);
-    if (result.error) {
-      return { ok: false, error: result.error };
-    }
-    
-    return { ok: true, result: result.result || result };
-  } catch (e) {
-    return { ok: false, error: e.message };
-  }
-}
-
-function loadApiKey() {
-  try {
-    const configPath = path.join(require('os').homedir(), '.50c', 'config.json');
-    if (fs.existsSync(configPath)) {
-      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      return config.api_key;
-    }
-  } catch {}
-  return null;
-}
-
-/**
- * Main sub-agent dispatcher
- */
-async function subagent(task) {
-  const { type, ...params } = task;
-
-  switch (type) {
-    case 'http':
-    case 'fetch':
-      return httpFetch(params.url, params);
-
-    case 'ssh':
-      return sshExec(params.server, params.command, params);
-
-    case 'local':
-    case 'exec':
-      return localExec(params.command, params);
-
-    case 'file':
-      const op = fileOps[params.op];
-      if (!op) throw new Error(`Unknown file op: ${params.op}`);
-      return op(params.path, params.content);
-
-    case 'multi':
-      // Parallel execution of multiple tasks
-      const results = await Promise.all(
-        params.tasks.map(t => subagent(t).catch(e => ({ ok: false, error: e.message })))
-      );
-      return { ok: results.every(r => r.ok), results };
-
-    case 'sequence':
-      // Sequential execution, stops on first failure
-      const seqResults = [];
-      for (const t of params.tasks) {
-        const result = await subagent(t).catch(e => ({ ok: false, error: e.message }));
-        seqResults.push(result);
-        if (!result.ok && params.stopOnError !== false) break;
-      }
-      return { ok: seqResults.every(r => r.ok), results: seqResults };
-
-    case 'servers':
-      // List known servers
-      return { ok: true, servers: KNOWN_SERVERS };
-
-    case '50c':
-    case 'tool':
-      // Call 50c MCP tool
-      return call50cTool(params.tool, params.args || {}, params.api_key);
-
-    case 'chain':
-      // Chain multiple 50c tools (output of one feeds into next)
-      let chainResult = params.input || {};
-      const chainSteps = [];
-      for (const step of params.steps) {
-        const args = { ...step.args };
-        // Inject previous result if placeholder exists
-        for (const [k, v] of Object.entries(args)) {
-          if (v === '$prev' || v === '$result') {
-            args[k] = typeof chainResult === 'string' ? chainResult : JSON.stringify(chainResult);
-          }
-        }
-        const stepResult = await call50cTool(step.tool, args, params.api_key);
-        chainSteps.push({ tool: step.tool, result: stepResult });
-        if (!stepResult.ok) {
-          return { ok: false, error: `Chain failed at ${step.tool}`, steps: chainSteps };
-        }
-        chainResult = stepResult.result;
-      }
-      return { ok: true, result: chainResult, steps: chainSteps };
-
-    default:
-      throw new Error(`Unknown task type: ${type}`);
-  }
-}
-
-// Export for MCP integration
-module.exports = {
-  subagent,
-  httpFetch,
-  sshExec,
-  localExec,
-  fileOps,
-  call50cTool,
-  KNOWN_SERVERS
-};
-
-// CLI mode
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  if (args.length === 0) {
-    console.log('50c Sub-Agent - Pure Node execution engine');
-    console.log('Usage: node subagent.js <json-task>');
-    console.log('Example: node subagent.js \'{"type":"http","url":"https://api.50c.ai/health"}\'');
-    process.exit(0);
-  }
-
-  try {
-    const task = JSON.parse(args[0]);
-    subagent(task)
-      .then(r => console.log(JSON.stringify(r, null, 2)))
-      .catch(e => console.error(JSON.stringify({ ok: false, error: e.message })));
-  } catch (e) {
-    console.error(JSON.stringify({ ok: false, error: `Invalid JSON: ${e.message}` }));
-  }
-}
+#!/usr/bin/env node
+/**
+ * 50c Sub-Agent - Pure Node.js execution engine
+ * Bypasses IDE shell restrictions, works on ALL MCP-compatible IDEs
+ * 
+ * Capabilities:
+ * - SSH remote execution (via ssh2)
+ * - HTTP/HTTPS requests (native)
+ * - File operations (native)
+ * - Process spawning (child_process)
+ */
+
+const { spawn, exec } = require('child_process');
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+// Known servers - loaded from ~/.50c/servers.json (not hardcoded for security)
+const os = require('os');
+const SERVERS_FILE = path.join(os.homedir(), '.50c', 'servers.json');
+
+function loadKnownServers() {
+  try {
+    if (fs.existsSync(SERVERS_FILE)) {
+      return JSON.parse(fs.readFileSync(SERVERS_FILE, 'utf8'));
+    }
+  } catch (e) {}
+  // Empty by default - users must configure their own servers
+  return {};
+}
+
+const KNOWN_SERVERS = loadKnownServers();
+
+/**
+ * HTTP/HTTPS fetch - no shell, pure Node
+ */
+async function httpFetch(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const isHttps = url.startsWith('https');
+    const lib = isHttps ? https : http;
+    
+    const urlObj = new URL(url);
+    const bodyData = options.body || '';
+    const reqOptions = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (isHttps ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      method: options.method || 'GET',
+      headers: {
+        ...options.headers,
+        ...(bodyData ? { 'Content-Length': Buffer.byteLength(bodyData) } : {})
+      },
+      timeout: options.timeout || 30000,
+      rejectUnauthorized: false // Allow self-signed certs
+    };
+
+    const req = lib.request(reqOptions, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        resolve({
+          status: res.statusCode,
+          headers: res.headers,
+          body: data,
+          ok: res.statusCode >= 200 && res.statusCode < 300
+        });
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    if (bodyData) {
+      req.write(bodyData);
+    }
+    req.end();
+  });
+}
+
+/**
+ * SSH execution via native ssh command (spawned, not shell)
+ * Fixed: Uses explicit identity file for Windows compatibility
+ */
+async function sshExec(server, command, options = {}) {
+  const serverConfig = typeof server === 'string' ? KNOWN_SERVERS[server] : server;
+  
+  if (!serverConfig) {
+    throw new Error(`Unknown server: ${server}. Known: ${Object.keys(KNOWN_SERVERS).join(', ')}`);
+  }
+
+  const { host, user = 'root', port = 22 } = serverConfig;
+  const timeout = options.timeout || 30000;
+  
+  // Try to find SSH key - common locations
+  const os = require('os');
+  const homeDir = os.homedir();
+  const keyPaths = [
+    path.join(homeDir, '.ssh', 'id_rsa'),
+    path.join(homeDir, '.ssh', 'id_ed25519'),
+    options.keyFile
+  ].filter(Boolean);
+  
+  let identityArgs = [];
+  for (const keyPath of keyPaths) {
+    if (fs.existsSync(keyPath)) {
+      identityArgs = ['-i', keyPath];
+      break;
+    }
+  }
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      '-o', 'StrictHostKeyChecking=no',
+      '-o', 'UserKnownHostsFile=/dev/null',
+      '-o', 'ConnectTimeout=10',
+      '-o', 'ServerAliveInterval=5',
+      '-o', 'ServerAliveCountMax=2',
+      ...identityArgs,
+      '-p', String(port),
+      `${user}@${host}`,
+      command
+    ];
+
+    const proc = spawn('ssh', args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout,
+      windowsHide: true
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', data => stdout += data.toString());
+    proc.stderr.on('data', data => stderr += data.toString());
+
+    const timer = setTimeout(() => {
+      proc.kill('SIGTERM');
+      reject(new Error(`SSH timeout after ${timeout}ms`));
+    }, timeout);
+
+    proc.on('close', code => {
+      clearTimeout(timer);
+      resolve({
+        ok: code === 0,
+        code,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        server: serverConfig.name || host
+      });
+    });
+
+    proc.on('error', err => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Local command execution (spawned, controlled)
+ */
+async function localExec(command, options = {}) {
+  const timeout = options.timeout || 30000;
+  const cwd = options.cwd || process.cwd();
+
+  return new Promise((resolve, reject) => {
+    exec(command, { timeout, cwd, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      resolve({
+        ok: !error,
+        code: error ? error.code || 1 : 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        command
+      });
+    });
+  });
+}
+
+/**
+ * File operations
+ */
+const fileOps = {
+  read: (filePath) => {
+    try {
+      return { ok: true, content: fs.readFileSync(filePath, 'utf8') };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  },
+  
+  write: (filePath, content) => {
+    try {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, content);
+      return { ok: true, path: filePath };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  },
+  
+  exists: (filePath) => ({ ok: true, exists: fs.existsSync(filePath) }),
+  
+  list: (dirPath) => {
+    try {
+      return { ok: true, files: fs.readdirSync(dirPath) };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+};
+
+/**
+ * 50c MCP Tool calling - call any 50c tool via API
+ */
+const API_ENDPOINT = process.env.FIFTYC_ENDPOINT || 'https://api.50c.ai';
+
+async function call50cTool(toolName, toolArgs, apiKey) {
+  const key = apiKey || process.env.FIFTYC_API_KEY || loadApiKey();
+  
+  if (!key) {
+    return { ok: false, error: 'No API key. Set FIFTYC_API_KEY or run: 50c config key <key>' };
+  }
+  
+  try {
+    const response = await httpFetch(`${API_ENDPOINT}/tools/${toolName}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${key}`
+      },
+      body: JSON.stringify(toolArgs || {}),
+      timeout: 120000 // 2 min for genius+
+    });
+    
+    if (!response.ok) {
+      return { ok: false, error: `HTTP ${response.status}`, body: response.body };
+    }
+    
+    const result = JSON.parse(response.body);
+    if (result.error) {
+      return { ok: false, error: result.error };
+    }
+    
+    return { ok: true, result: result.result || result };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+function loadApiKey() {
+  try {
+    const configPath = path.join(require('os').homedir(), '.50c', 'config.json');
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      return config.api_key;
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Main sub-agent dispatcher
+ */
+async function subagent(task) {
+  const { type, ...params } = task;
+
+  switch (type) {
+    case 'http':
+    case 'fetch':
+      return httpFetch(params.url, params);
+
+    case 'ssh':
+      return sshExec(params.server, params.command, params);
+
+    case 'local':
+    case 'exec':
+      return localExec(params.command, params);
+
+    case 'file':
+      const op = fileOps[params.op];
+      if (!op) throw new Error(`Unknown file op: ${params.op}`);
+      return op(params.path, params.content);
+
+    case 'multi':
+      // Parallel execution of multiple tasks
+      const results = await Promise.all(
+        params.tasks.map(t => subagent(t).catch(e => ({ ok: false, error: e.message })))
+      );
+      return { ok: results.every(r => r.ok), results };
+
+    case 'sequence':
+      // Sequential execution, stops on first failure
+      const seqResults = [];
+      for (const t of params.tasks) {
+        const result = await subagent(t).catch(e => ({ ok: false, error: e.message }));
+        seqResults.push(result);
+        if (!result.ok && params.stopOnError !== false) break;
+      }
+      return { ok: seqResults.every(r => r.ok), results: seqResults };
+
+    case 'servers':
+      // List known servers
+      return { ok: true, servers: KNOWN_SERVERS };
+
+    case '50c':
+    case 'tool':
+      // Call 50c MCP tool
+      return call50cTool(params.tool, params.args || {}, params.api_key);
+
+    case 'chain':
+      // Chain multiple 50c tools (output of one feeds into next)
+      let chainResult = params.input || {};
+      const chainSteps = [];
+      for (const step of params.steps) {
+        const args = { ...step.args };
+        // Inject previous result if placeholder exists
+        for (const [k, v] of Object.entries(args)) {
+          if (v === '$prev' || v === '$result') {
+            args[k] = typeof chainResult === 'string' ? chainResult : JSON.stringify(chainResult);
+          }
+        }
+        const stepResult = await call50cTool(step.tool, args, params.api_key);
+        chainSteps.push({ tool: step.tool, result: stepResult });
+        if (!stepResult.ok) {
+          return { ok: false, error: `Chain failed at ${step.tool}`, steps: chainSteps };
+        }
+        chainResult = stepResult.result;
+      }
+      return { ok: true, result: chainResult, steps: chainSteps };
+
+    default:
+      throw new Error(`Unknown task type: ${type}`);
+  }
+}
+
+// Export for MCP integration
+module.exports = {
+  subagent,
+  httpFetch,
+  sshExec,
+  localExec,
+  fileOps,
+  call50cTool,
+  KNOWN_SERVERS
+};
+
+// CLI mode
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log('50c Sub-Agent - Pure Node execution engine');
+    console.log('Usage: node subagent.js <json-task>');
+    console.log('Example: node subagent.js \'{"type":"http","url":"https://api.50c.ai/health"}\'');
+    process.exit(0);
+  }
+
+  try {
+    const task = JSON.parse(args[0]);
+    subagent(task)
+      .then(r => console.log(JSON.stringify(r, null, 2)))
+      .catch(e => console.error(JSON.stringify({ ok: false, error: e.message })));
+  } catch (e) {
+    console.error(JSON.stringify({ ok: false, error: `Invalid JSON: ${e.message}` }));
+  }
+}