gitarsenal-cli 1.9.96 → 1.9.97

package/lib/e2b-sandbox.js

@@ -0,0 +1,158 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const os = require('os');
+
+const execAsync = promisify(exec);
+
+/**
+ * Get the Python executable path from the virtual environment
+ * @returns {string} - Path to Python executable or 'python3'
+ */
+function getPythonExecutable() {
+  // Check if PYTHON_EXECUTABLE is set by the virtual environment activation
+  if (process.env.PYTHON_EXECUTABLE && fs.existsSync(process.env.PYTHON_EXECUTABLE)) {
+    return process.env.PYTHON_EXECUTABLE;
+  }
+  
+  // Try to find the virtual environment Python
+  const venvPath = path.join(__dirname, '..', '.venv');
+  const isWindows = process.platform === 'win32';
+  
+  // Check for uv-style virtual environment first
+  const uvPythonPath = path.join(venvPath, 'bin', 'python');
+  
+  // Check for traditional venv structure
+  const traditionalPythonPath = isWindows ? 
+    path.join(venvPath, 'Scripts', 'python.exe') : 
+    path.join(venvPath, 'bin', 'python');
+  
+  if (fs.existsSync(uvPythonPath)) {
+    return uvPythonPath;
+  } else if (fs.existsSync(traditionalPythonPath)) {
+    return traditionalPythonPath;
+  }
+  
+  // Fall back to system Python
+  return isWindows ? 'python' : 'python3';
+}
+
+/**
+ * Run an E2B sandbox with the given options
+ * @param {Object} options - Sandbox options
+ * @param {string} options.repoUrl - GitHub repository URL
+ * @param {Array<string>} options.setupCommands - Setup commands
+ * @returns {Promise<void>}
+ */
+async function runE2BSandbox(options) {
+  const { 
+    repoUrl, 
+    setupCommands = [], 
+    userId,
+    userName,
+    userEmail,
+    apiKeys = {}
+  } = options;
+  
+  console.log(chalk.blue('🚀 Starting E2B sandbox...'));
+  
+  // Check if E2B_API_KEY is already set in environment variables
+  let e2bApiKey = process.env.E2B_API_KEY;
+  
+  // If not, try to get it from apiKeys
+  if (!e2bApiKey && apiKeys.E2B_API_KEY) {
+    e2bApiKey = apiKeys.E2B_API_KEY;
+    console.log(chalk.green('✅ Using E2B API key from apiKeys'));
+  }
+  
+  // If still not found, try to get it from modal_tokens.json
+  if (!e2bApiKey) {
+    try {
+      const modalTokensPath = path.join(__dirname, '..', 'python', 'modal_tokens.json');
+      if (fs.existsSync(modalTokensPath)) {
+        const modalTokens = JSON.parse(fs.readFileSync(modalTokensPath, 'utf8'));
+        if (modalTokens.e2b_api_key) {
+          e2bApiKey = modalTokens.e2b_api_key;
+          console.log(chalk.green('✅ Using E2B API key from modal_tokens.json'));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.yellow(`⚠️ Error reading modal_tokens.json: ${error.message}`));
+    }
+  }
+
+  // Check if we have a valid E2B API key
+  if (!e2bApiKey) {
+    console.error(chalk.red('❌ E2B API key not found'));
+    console.error(chalk.yellow('Please set the E2B_API_KEY environment variable or add it to your API keys'));
+    return { success: false, error: 'E2B API key not found' };
+  }
+
+  // Log a masked version of the API key for debugging
+  console.log(chalk.green(`✅ E2B API key found (${e2bApiKey.substring(0, 5)}...)`));
+
+  // Set up the environment for the Python process
+  const pythonExecutable = getPythonExecutable();
+  if (!pythonExecutable) {
+    console.error(chalk.red('❌ Python executable not found'));
+    return { success: false, error: 'Python executable not found' };
+  }
+
+  // Get OpenAI and Anthropic API keys from environment or apiKeys
+  const openaiApiKey = apiKeys.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+  const anthropicApiKey = apiKeys.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+
+  // Run the e2b_sandbox_agent.py script with the repository URL
+  const scriptPath = path.join(__dirname, '..', 'python', 'e2b_sandbox_agent.py');
+  
+  // Prepare command line arguments
+  const args = [
+    scriptPath,
+    '--repo', repoUrl
+  ];
+  
+  // Add API keys if available
+  if (openaiApiKey) {
+    args.push('--openai-api-key', openaiApiKey);
+  }
+  
+  if (anthropicApiKey) {
+    args.push('--anthropic-api-key', anthropicApiKey);
+  }
+
+  // Run the Python script
+  const pythonProcess = spawn(pythonExecutable, args, {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      E2B_API_KEY: e2bApiKey
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    pythonProcess.on('close', (code) => {
+      if (code === 0 || code === 130) {  // 130 is the exit code for SIGINT (Ctrl+C)
+        console.log(chalk.green('✅ E2B sandbox session completed'));
+        resolve({ success: true });
+      } else {
+        console.error(chalk.red(`✗ E2B sandbox session failed`));
+        console.error(chalk.red(`  Exit code: ${code}`));
+        reject(new Error(`Process exited with code ${code}`));
+      }
+    });
+
+    pythonProcess.on('error', (error) => {
+      console.error(chalk.red(`✗ E2B sandbox session failed`));
+      console.error(chalk.red(`  Error: ${error.message}`));
+      reject(error);
+    });
+  });
+}
+
+module.exports = {
+  runE2BSandbox
+}; 

package/lib/execAsync.js

@@ -0,0 +1,12 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+/**
+ * Promisified version of child_process.exec
+ * @type {Function}
+ */
+const execAsync = promisify(exec);
+
+module.exports = {
+  execAsync
+}; 

package/lib/sandbox.js

@@ -6,6 +6,7 @@ const ora = require('ora');
 const { promisify } = require('util');
 const { exec } = require('child_process');
 const os = require('os');
+const { runE2BSandbox } = require('./e2b-sandbox');
 
 const execAsync = promisify(exec);
 
@@ -22,62 +23,38 @@ function getPythonScriptPath() {
   }
   
   // If not found, return the path where it will be copied during installation
-  return packageScriptPath;
+  return path.join(os.homedir(), '.gitarsenal', 'python', 'test_modalSandboxScript.py');
 }
 
 /**
- * Run the container with the given options
+ * Run a container with the given options
  * @param {Object} options - Container options
- * @param {string} options.repoUrl - GitHub repository URL
- * @param {string} options.gpuType - GPU type
- * @param {number} options.gpuCount - Number of GPUs (default: 1)
- * @param {string} options.volumeName - Volume name
- * @param {Array<string>} options.setupCommands - Setup commands
- * @param {boolean} options.showExamples - Whether to show usage examples
- * @param {Object} options.analysisData - Repository analysis data from best_gpu endpoint
  * @returns {Promise<void>}
  */
-async function runContainer(options) {
-  const { 
-    repoUrl, 
-    gpuType, 
-    gpuCount = 1,
-    volumeName, 
-    setupCommands = [], 
+async function runContainer(options = {}) {
+  const {
     showExamples = false,
+    repoUrl = '',
+    gpuType = 'A10G',
+    gpuCount = 1,
+    volumeName = '',
+    setupCommands = [],
     yes = false,
-    userId,
-    userName,
-    userEmail,
-    analysisData
+    userId = '',
+    userName = '',
+    userEmail = '',
+    apiKeys = {},
+    analysisData = null,
+    sandboxProvider = 'modal'
   } = options;
-  
-  // Get the path to the Python script
-  const scriptPath = getPythonScriptPath();
-  
-  // Check if the script exists
-  if (!fs.existsSync(scriptPath)) {
-    throw new Error(`Python script not found at ${scriptPath}. Please reinstall the package.`);
-  }
-  
-  // Prepare command arguments
-  const args = [
-    scriptPath
-  ];
 
-  // If show examples is true, only pass that flag
+  // Check if this is just a request to show examples
   if (showExamples) {
-    args.push('--show-examples');
-    
-    // Log the command being executed
-    // console.log(chalk.dim(`\nExecuting: python ${args.join(' ')}`));
-    
-    // Run the Python script with show examples flag
-    const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
-    const pythonProcess = spawn(pythonExecutable, ['-u', ...args], {
-      stdio: 'inherit', // Inherit stdio to show real-time output
-      env: { ...process.env, PYTHONUNBUFFERED: '1' } // Force unbuffered output
-    });
+    const scriptPath = getPythonScriptPath();
+    const pythonProcess = spawn('python', [
+      scriptPath,
+      '--show-examples'
+    ], { stdio: 'inherit' });
     
     return new Promise((resolve, reject) => {
       pythonProcess.on('close', (code) => {
@@ -87,94 +64,101 @@ async function runContainer(options) {
           reject(new Error(`Process exited with code ${code}`));
         }
       });
-      
-      pythonProcess.on('error', (error) => {
-        reject(error);
-      });
     });
   }
+
+  // Choose sandbox provider
+  if (sandboxProvider === 'e2b') {
+    console.log(chalk.blue('🚀 Using E2B sandbox provider'));
+    return runE2BSandbox({
+      repoUrl,
+      setupCommands,
+      userId,
+      userName,
+      userEmail,
+      apiKeys
+    });
+  }
+
+  console.log(chalk.blue('🚀 Using Modal sandbox provider'));
+  
+  // Get the path to the Python script
+  const scriptPath = getPythonScriptPath();
+  
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(`Python script not found at ${scriptPath}`);
+  }
+  
+  console.log('Launching container...');
+  
+  // Convert setup commands to JSON for passing to Python
+  const setupCommandsJson = JSON.stringify(setupCommands);
+  
+  // Convert analysis data to JSON for passing to Python
+  const analysisDataJson = analysisData ? JSON.stringify(analysisData) : '';
+  
+  // Convert API keys to JSON for passing to Python
+  const apiKeysJson = JSON.stringify(apiKeys);
+  
+  // Build the command arguments
+  const args = [
+    scriptPath,
+    '--gpu', gpuType,
+  ];
+  
+  if (gpuCount && gpuCount > 1) {
+    args.push('--gpu-count', gpuCount.toString());
+  }
   
-  // Add normal arguments
-  if (gpuType) args.push('--gpu', gpuType);
-  if (gpuCount && gpuCount > 1) args.push('--gpu-count', gpuCount.toString());
-  if (repoUrl) args.push('--repo-url', repoUrl);
+  if (repoUrl) {
+    args.push('--repo-url', repoUrl);
+  }
   
   if (volumeName) {
     args.push('--volume-name', volumeName);
   }
   
-  // Repository setup is now handled by Agent when --repo-url is provided
+  if (setupCommands && setupCommands.length > 0) {
+    args.push('--setup-commands-json', setupCommandsJson);
+  }
   
-  // Add --yes flag to skip confirmation prompts
-  if (yes) {
-    args.push('--yes');
-    console.log(chalk.gray(`🔍 Debug: Adding --yes flag to Python script`));
+  if (userId) {
+    args.push('--user-id', userId);
   }
   
-  // Add user credentials if provided
-  if (userId && userEmail && userName) {
-    args.push('--user-id', userEmail);
-    args.push('--user-name', userId);
-    args.push('--display-name', userName);
+  if (userName) {
+    args.push('--user-name', userName);
   }
-
-  // Add analysis data if provided
-  if (analysisData) {
-    args.push('--analysis-data', JSON.stringify(analysisData));
+  
+  if (userEmail) {
+    args.push('--display-name', userEmail);
+  }
+  
+  if (analysisDataJson) {
+    args.push('--analysis-data', analysisDataJson);
   }
   
-  // Handle manual setup commands if provided
-  if (setupCommands.length > 0) {
-    // Create a temporary file to store setup commands
-    const tempCommandsFile = path.join(os.tmpdir(), `gitarsenal-commands-${Date.now()}.txt`);
-    fs.writeFileSync(tempCommandsFile, setupCommands.join('\n'));
-    args.push('--commands-file', tempCommandsFile);
+  if (yes) {
+    args.push('--yes');
   }
   
-  // Log the command being executed
-  // console.log(chalk.dim(`\nExecuting: python ${args.join(' ')}`));
-  // console.log(chalk.gray(`🔍 Debug: yes parameter = ${yes}`));
+  // Use system Python instead of virtual env Python
+  const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
   
-  // Run the Python script without spinner to avoid terminal interference
-  console.log(chalk.dim('Launching container...'));
+  // Run the Python script
+  const pythonProcess = spawn(pythonCmd, args, { stdio: 'inherit' });
   
-  try {
-    // Run the Python script
-    const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
-    const pythonProcess = spawn(pythonExecutable, ['-u', ...args], {
-      stdio: 'inherit', // Inherit stdio to show real-time output
-      env: { ...process.env, PYTHONUNBUFFERED: '1' } // Force unbuffered output
-    });
-    
-    // Handle process completion
-    return new Promise((resolve, reject) => {
-      pythonProcess.on('close', (code) => {
-        if (code === 0) {
-          console.log(chalk.green('✓ Environment ready'));
-          console.log(chalk.dim('  Your secure development environment is now active'));
-          resolve();
-        } else {
-          console.log(chalk.red('✗ Launch failed'));
-          console.log(chalk.dim(`  Exit code: ${code}`));
-          reject(new Error(`Process exited with code ${code}`));
-        }
-      });
-      
-      // Handle process errors
-      pythonProcess.on('error', (error) => {
-        console.log(chalk.red('✗ Process error'));
-        console.log(chalk.dim(`  ${error.message}`));
-        reject(error);
-      });
+  return new Promise((resolve, reject) => {
+    pythonProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Process exited with code ${code}`));
+      }
     });
-  } catch (error) {
-    console.log(chalk.red('✗ Launch error'));
-    console.log(chalk.dim(`  ${error.message}`));
-    throw error;
-  }
+  });
 }
 
 module.exports = {
-  runContainer,
-  getPythonScriptPath
+  runContainer
 }; 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.96",
+  "version": "1.9.97",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {
@@ -21,6 +21,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@e2b/code-interpreter": "^2.0.0",
     "@supabase/supabase-js": "^2.53.0",
     "boxen": "^5.1.2",
     "chalk": "^4.1.2",

package/python/credentials_manager.py

@@ -159,7 +159,8 @@ class CredentialsManager:
                 "MODAL_TOKEN_ID",
                 "MODAL_TOKEN", 
                 "MODAL_TOKEN_SECRET",
-                "GROQ_API_KEY"
+                "GROQ_API_KEY",
+                "E2B_API_KEY"       
             ]
             
             for var in security_vars: