ultra-dex 3.1.0 → 3.3.0

package/lib/commands/exec.js

@@ -0,0 +1,434 @@
+/**
+ * ultra-dex exec command
+ * Docker-based code execution sandbox for running generated code safely
+ * This is what makes Ultra-Dex truly autonomous - it can VERIFY code works
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs/promises';
+import path from 'path';
+import { spawn, exec as execCallback } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(execCallback);
+
+// ============================================================================
+// SANDBOX CONFIGURATION
+// ============================================================================
+
+const SANDBOX_CONFIG = {
+  // Docker image for sandboxed execution
+  defaultImage: 'node:20-alpine',
+
+  // Language-specific images
+  images: {
+    javascript: 'node:20-alpine',
+    typescript: 'node:20-alpine',
+    python: 'python:3.12-alpine',
+    rust: 'rust:1.75-alpine',
+    go: 'golang:1.22-alpine',
+    ruby: 'ruby:3.3-alpine',
+  },
+
+  // Resource limits
+  limits: {
+    memory: '512m',
+    cpus: '1.0',
+    timeout: 60000, // 60 seconds
+    networkDisabled: true,
+  },
+
+  // Workspace settings
+  workspace: {
+    containerPath: '/workspace',
+    tempDir: '.ultra-dex/sandbox',
+  }
+};
+
+// ============================================================================
+// DOCKER UTILITIES
+// ============================================================================
+
+/**
+ * Check if Docker is available
+ */
+async function checkDocker() {
+  try {
+    await execAsync('docker --version');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Pull Docker image if not available
+ */
+async function ensureImage(image, spinner) {
+  try {
+    await execAsync(`docker image inspect ${image} > /dev/null 2>&1`);
+    return true;
+  } catch {
+    spinner.text = `Pulling Docker image: ${image}...`;
+    try {
+      await execAsync(`docker pull ${image}`);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+}
+
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(filepath) {
+  const ext = path.extname(filepath).toLowerCase();
+  const langMap = {
+    '.js': 'javascript',
+    '.mjs': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.py': 'python',
+    '.rs': 'rust',
+    '.go': 'go',
+    '.rb': 'ruby',
+  };
+  return langMap[ext] || 'javascript';
+}
+
+/**
+ * Get execution command for language
+ */
+function getExecCommand(language, filename) {
+  const commands = {
+    javascript: `node ${filename}`,
+    typescript: `npx tsx ${filename}`,
+    python: `python ${filename}`,
+    rust: `rustc ${filename} -o /tmp/out && /tmp/out`,
+    go: `go run ${filename}`,
+    ruby: `ruby ${filename}`,
+  };
+  return commands[language] || `node ${filename}`;
+}
+
+// ============================================================================
+// SANDBOX EXECUTOR
+// ============================================================================
+
+/**
+ * Execute code in Docker sandbox
+ */
+export async function executeInSandbox(code, options = {}) {
+  const {
+    language = 'javascript',
+    filename = 'main.js',
+    timeout = SANDBOX_CONFIG.limits.timeout,
+    allowNetwork = false,
+    env = {},
+    workdir = process.cwd(),
+  } = options;
+
+  const image = SANDBOX_CONFIG.images[language] || SANDBOX_CONFIG.defaultImage;
+  const tempDir = path.join(workdir, SANDBOX_CONFIG.workspace.tempDir);
+  const tempFile = path.join(tempDir, filename);
+
+  // Ensure temp directory exists
+  await fs.mkdir(tempDir, { recursive: true });
+
+  // Write code to temp file
+  await fs.writeFile(tempFile, code, 'utf8');
+
+  // Build Docker command
+  const dockerArgs = [
+    'run',
+    '--rm',
+    '-i',
+    `--memory=${SANDBOX_CONFIG.limits.memory}`,
+    `--cpus=${SANDBOX_CONFIG.limits.cpus}`,
+    allowNetwork ? '' : '--network=none',
+    `-v`, `${tempDir}:${SANDBOX_CONFIG.workspace.containerPath}:ro`,
+    `-w`, SANDBOX_CONFIG.workspace.containerPath,
+  ];
+
+  // Add environment variables
+  for (const [key, value] of Object.entries(env)) {
+    dockerArgs.push('-e', `${key}=${value}`);
+  }
+
+  dockerArgs.push(image);
+
+  // Add execution command
+  const execCmd = getExecCommand(language, filename);
+  dockerArgs.push('sh', '-c', execCmd);
+
+  // Filter empty strings
+  const filteredArgs = dockerArgs.filter(Boolean);
+
+  return new Promise((resolve, reject) => {
+    const result = {
+      stdout: '',
+      stderr: '',
+      exitCode: null,
+      timedOut: false,
+      duration: 0,
+    };
+
+    const startTime = Date.now();
+    const proc = spawn('docker', filteredArgs);
+
+    const timeoutId = setTimeout(() => {
+      result.timedOut = true;
+      proc.kill('SIGKILL');
+    }, timeout);
+
+    proc.stdout.on('data', (data) => {
+      result.stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data) => {
+      result.stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeoutId);
+      result.exitCode = code;
+      result.duration = Date.now() - startTime;
+      resolve(result);
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Execute a file in sandbox
+ */
+export async function executeFile(filepath, options = {}) {
+  const code = await fs.readFile(filepath, 'utf8');
+  const language = detectLanguage(filepath);
+  const filename = path.basename(filepath);
+
+  return executeInSandbox(code, {
+    ...options,
+    language,
+    filename,
+  });
+}
+
+/**
+ * Execute npm/shell command in sandbox
+ */
+export async function executeCommand(command, options = {}) {
+  const {
+    timeout = SANDBOX_CONFIG.limits.timeout,
+    workdir = process.cwd(),
+    allowNetwork = true, // Commands often need network
+  } = options;
+
+  const tempDir = path.join(workdir, SANDBOX_CONFIG.workspace.tempDir);
+  await fs.mkdir(tempDir, { recursive: true });
+
+  const dockerArgs = [
+    'run',
+    '--rm',
+    '-i',
+    `--memory=${SANDBOX_CONFIG.limits.memory}`,
+    `--cpus=${SANDBOX_CONFIG.limits.cpus}`,
+    allowNetwork ? '' : '--network=none',
+    `-v`, `${workdir}:${SANDBOX_CONFIG.workspace.containerPath}`,
+    `-w`, SANDBOX_CONFIG.workspace.containerPath,
+    SANDBOX_CONFIG.defaultImage,
+    'sh', '-c', command,
+  ].filter(Boolean);
+
+  return new Promise((resolve, reject) => {
+    const result = {
+      stdout: '',
+      stderr: '',
+      exitCode: null,
+      timedOut: false,
+      duration: 0,
+    };
+
+    const startTime = Date.now();
+    const proc = spawn('docker', dockerArgs);
+
+    const timeoutId = setTimeout(() => {
+      result.timedOut = true;
+      proc.kill('SIGKILL');
+    }, timeout);
+
+    proc.stdout.on('data', (data) => {
+      result.stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data) => {
+      result.stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeoutId);
+      result.exitCode = code;
+      result.duration = Date.now() - startTime;
+      resolve(result);
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+
+// ============================================================================
+// TEST RUNNER
+// ============================================================================
+
+/**
+ * Run tests in sandbox
+ */
+export async function runTests(testCommand = 'npm test', options = {}) {
+  const spinner = ora('Running tests in sandbox...').start();
+
+  try {
+    const result = await executeCommand(testCommand, {
+      ...options,
+      allowNetwork: true, // Tests may need to install deps
+    });
+
+    if (result.exitCode === 0) {
+      spinner.succeed(chalk.green('Tests passed!'));
+    } else {
+      spinner.fail(chalk.red('Tests failed'));
+    }
+
+    return result;
+  } catch (err) {
+    spinner.fail(chalk.red(`Test execution failed: ${err.message}`));
+    throw err;
+  }
+}
+
+// ============================================================================
+// CLI COMMAND
+// ============================================================================
+
+export function registerExecCommand(program) {
+  program
+    .command('exec [file]')
+    .description('Execute code in isolated Docker sandbox')
+    .option('-c, --code <code>', 'Execute inline code')
+    .option('-l, --language <lang>', 'Language (js, ts, py, go, rs, rb)')
+    .option('-t, --timeout <ms>', 'Timeout in milliseconds', '60000')
+    .option('--allow-network', 'Allow network access in sandbox')
+    .option('--command <cmd>', 'Run shell command instead of file')
+    .option('--test', 'Run npm test in sandbox')
+    .action(async (file, options) => {
+      console.log(chalk.cyan('\n🐳 Ultra-Dex Code Sandbox\n'));
+
+      // Check Docker availability
+      const spinner = ora('Checking Docker...').start();
+      const hasDocker = await checkDocker();
+
+      if (!hasDocker) {
+        spinner.fail(chalk.red('Docker not found. Please install Docker to use the sandbox.'));
+        console.log(chalk.yellow('\nInstall Docker: https://docs.docker.com/get-docker/'));
+        return;
+      }
+      spinner.succeed('Docker available');
+
+      const timeout = parseInt(options.timeout, 10);
+
+      try {
+        let result;
+
+        if (options.test) {
+          // Run tests
+          result = await runTests('npm test', { timeout, allowNetwork: true });
+        } else if (options.command) {
+          // Run shell command
+          spinner.start(`Executing: ${options.command}`);
+          result = await executeCommand(options.command, {
+            timeout,
+            allowNetwork: options.allowNetwork,
+          });
+        } else if (options.code) {
+          // Execute inline code
+          const language = options.language || 'javascript';
+          const image = SANDBOX_CONFIG.images[language];
+
+          spinner.start('Preparing sandbox...');
+          await ensureImage(image, spinner);
+
+          spinner.text = 'Executing code...';
+          result = await executeInSandbox(options.code, {
+            language,
+            timeout,
+            allowNetwork: options.allowNetwork,
+          });
+        } else if (file) {
+          // Execute file
+          const language = options.language || detectLanguage(file);
+          const image = SANDBOX_CONFIG.images[language];
+
+          spinner.start('Preparing sandbox...');
+          await ensureImage(image, spinner);
+
+          spinner.text = `Executing ${file}...`;
+          result = await executeFile(file, {
+            timeout,
+            allowNetwork: options.allowNetwork,
+          });
+        } else {
+          spinner.fail('No code, file, or command specified');
+          console.log(chalk.yellow('\nUsage:'));
+          console.log('  ultra-dex exec script.js');
+          console.log('  ultra-dex exec -c "console.log(1+1)"');
+          console.log('  ultra-dex exec --command "npm test"');
+          console.log('  ultra-dex exec --test');
+          return;
+        }
+
+        // Show results
+        if (result.timedOut) {
+          spinner.fail(chalk.red(`Execution timed out after ${timeout}ms`));
+        } else if (result.exitCode === 0) {
+          spinner.succeed(chalk.green(`Completed in ${result.duration}ms`));
+        } else {
+          spinner.warn(chalk.yellow(`Exited with code ${result.exitCode}`));
+        }
+
+        // Print output
+        if (result.stdout) {
+          console.log(chalk.bold('\n📤 Output:'));
+          console.log(result.stdout);
+        }
+
+        if (result.stderr) {
+          console.log(chalk.bold('\n⚠️  Stderr:'));
+          console.log(chalk.red(result.stderr));
+        }
+
+        // Summary
+        console.log(chalk.gray(`\n⏱️  Duration: ${result.duration}ms`));
+        console.log(chalk.gray(`🔒 Network: ${options.allowNetwork ? 'Enabled' : 'Disabled'}`));
+
+      } catch (err) {
+        spinner.fail(chalk.red(`Execution failed: ${err.message}`));
+      }
+    });
+}
+
+export default {
+  registerExecCommand,
+  executeInSandbox,
+  executeFile,
+  executeCommand,
+  runTests,
+  checkDocker,
+};

package/lib/commands/generate.js

@@ -13,11 +13,12 @@ import { SYSTEM_PROMPT, generateUserPrompt } from '../templates/prompts/generate
 import { validateSafePath } from '../utils/validation.js';
 import { githubTreeUrl, githubWebUrl } from '../config/urls.js';
 import { saveState } from './plan.js';
+import { getRandomMessage } from '../utils/messages.js';
 
 export function registerGenerateCommand(program) {
   program
     .command('generate [idea]')
-    .description('Generate a full implementation plan from an idea using AI')
+    .description('Create the plan (Thanos style) - AI Generates Full Plan')
     .option('-p, --provider <provider>', 'AI provider (claude, openai, gemini)')
     .option('-m, --model <model>', 'Specific model to use')
     .option('-o, --output <directory>', 'Output directory', '.')
@@ -25,7 +26,9 @@ export function registerGenerateCommand(program) {
     .option('--stream', 'Stream output in real-time', true)
     .option('--no-stream', 'Disable streaming')
     .action(async (idea, options) => {
-      console.log(chalk.cyan('\n🚀 Ultra-Dex Plan Generator\n'));
+      console.log(chalk.cyan('\n🚀 Ultra-Dex Plan Generator (Reality Stone Mode)\n'));
+      console.log(chalk.hex('#7c3aed').italic(`"${getRandomMessage('start')}"`));
+      console.log('');
 
       const dirValidation = validateSafePath(options.output, 'Output directory');
       if (dirValidation !== true) {
@@ -38,7 +41,7 @@ export function registerGenerateCommand(program) {
       const hasProvider = configured.some(p => p.configured) || options.key;
 
       if (!hasProvider) {
-        console.log(chalk.yellow('⚠️  No AI provider configured.\n'));
+        console.log(chalk.yellow('⚠️  No Infinity Stones (AI Keys) configured.\n'));
         console.log(chalk.white('Set one of these environment variables:'));
         configured.forEach(p => {
           console.log(chalk.gray(`  export ${p.envKey}=your-key-here`));
@@ -54,7 +57,7 @@ export function registerGenerateCommand(program) {
           {
             type: 'input',
             name: 'idea',
-            message: 'Describe your SaaS idea:',
+            message: 'Describe the reality you wish to create:',
             validate: input => input.trim().length > 10 || 'Please provide a more detailed description',
           },
         ]);
@@ -85,7 +88,7 @@ export function registerGenerateCommand(program) {
       }
 
       // Generate the plan
-      const spinner = ora('Generating your implementation plan...').start();
+      const spinner = ora('Reshaping reality (Generating Plan)...').start();
       const startTime = Date.now();
 
       try {
@@ -94,7 +97,7 @@ export function registerGenerateCommand(program) {
 
         if (options.stream) {
           spinner.stop();
-          console.log(chalk.cyan('📝 Generating plan:\n'));
+          console.log(chalk.cyan('📝 Manifesting Reality:\n'));
           console.log(chalk.gray('─'.repeat(60)));
 
           result = await provider.generateStream(
@@ -128,7 +131,7 @@ export function registerGenerateCommand(program) {
         // Add header to plan
         const header = `# Implementation Plan
 
-> Generated by Ultra-Dex AI Plan Generator
+> Generated by Ultra-Dex AI Plan Generator (Doomsday Edition)
 
 `;
         if (!planContent.startsWith('#')) {
@@ -208,17 +211,17 @@ ${idea}
 2. Start with the first feature
 3. Use Ultra-Dex agents for guidance
 
-## AI Agents
-- @Planner: Break down tasks
-- @CTO: Architecture decisions
-- @Backend: API logic
-- @Frontend: UI components
-- @Testing: QA and tests
+## AI Agents (The Avengers)
+- @Planner (Nick Fury): Break down tasks
+- @CTO (Iron Man): Architecture decisions
+- @Backend (Thor): API logic
+- @Frontend (Spider-Man): UI components
+- @Testing (Ant-Man): QA and tests
 `;
 
         await fs.writeFile(quickStartPath, quickStartContent);
 
-        spinner.succeed('Plan generated successfully!');
+        spinner.succeed(chalk.green('Reality successfully rewritten!'));
 
         console.log(chalk.green('\n✅ Files created:'));
         console.log(chalk.gray(`  ${planPath}`));
@@ -232,9 +235,9 @@ ${idea}
         console.log(chalk.cyan('  1. Review IMPLEMENTATION-PLAN.md'));
         console.log(chalk.cyan('  2. Run `ultra-dex dashboard` to visualize your progress'));
         console.log(chalk.cyan('  3. Run `ultra-dex build` to let Auto-Pilot take the first task'));
-        console.log(chalk.cyan('  4. Use AI agents for specialized guidance\n'));
+        console.log(chalk.cyan('  4. Summon Avengers (AI agents) for guidance\n'));
       } catch (err) {
-        spinner.fail('Failed to generate plan');
+        spinner.fail(chalk.red('Failed to manifest reality'));
         console.error(chalk.red('Error:'), err.message);
       }
     });