gitarsenal-cli 1.9.97 → 1.9.98

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-09-13T16:50:38.652Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-09-14T10:39:18.686Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/lib/e2b-sandbox.js

@@ -41,6 +41,40 @@ function getPythonExecutable() {
   return isWindows ? 'python' : 'python3';
 }
 
+/**
+ * Fetch E2B API key directly from the server
+ * @returns {Promise<string>} - The E2B API key
+ */
+async function fetchE2BApiKey() {
+  try {
+    console.log(chalk.blue('🔄 Fetching E2B API key directly from server...'));
+    
+    const pythonExecutable = getPythonExecutable();
+    const fetchTokensScript = path.join(__dirname, '..', 'python', 'fetch_modal_tokens.py');
+    
+    // Run the fetch_modal_tokens.py script with --output-e2b-key flag
+    const { stdout, stderr } = await execAsync(`${pythonExecutable} ${fetchTokensScript} --output-e2b-key`, {
+      env: { ...process.env },
+      timeout: 30000 // 30 seconds timeout
+    });
+    
+    // Parse the output to find the E2B API key
+    const e2bKeyMatch = stdout.match(/E2B_API_KEY=(e2b_[a-zA-Z0-9]+)/);
+    if (e2bKeyMatch && e2bKeyMatch[1]) {
+      const e2bApiKey = e2bKeyMatch[1];
+      console.log(chalk.green(`✅ Successfully fetched E2B API key from server (format: ${e2bApiKey.substring(0, 5)}...)`));
+      return e2bApiKey;
+    }
+    
+    console.error(chalk.yellow('⚠️ Could not extract E2B API key from fetch_modal_tokens.py output'));
+    console.error(chalk.gray('Output: ' + stdout.substring(0, 100) + '...'));
+    return null;
+  } catch (error) {
+    console.error(chalk.red(`❌ Error fetching E2B API key: ${error.message}`));
+    return null;
+  }
+}
+
 /**
  * Run an E2B sandbox with the given options
  * @param {Object} options - Sandbox options
@@ -63,10 +97,27 @@ async function runE2BSandbox(options) {
   // Check if E2B_API_KEY is already set in environment variables
   let e2bApiKey = process.env.E2B_API_KEY;
   
+  // Check if the key is a placeholder value
+  if (e2bApiKey && (e2bApiKey === 'your_e2b_api_key' || e2bApiKey.startsWith('placeholder'))) {
+    console.log(chalk.yellow('⚠️ Found placeholder E2B API key in environment, will try to get real key'));
+    e2bApiKey = null;
+  }
+  
   // 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'));
+    // Check if the key from apiKeys is a placeholder
+    if (e2bApiKey === 'your_e2b_api_key' || e2bApiKey.startsWith('placeholder')) {
+      console.log(chalk.yellow('⚠️ Found placeholder E2B API key in apiKeys, will try to get real key'));
+      e2bApiKey = null;
+    } else {
+      console.log(chalk.green('✅ Using E2B API key from apiKeys'));
+    }
+  }
+  
+  // If still not found, try to fetch it directly from the server
+  if (!e2bApiKey) {
+    e2bApiKey = await fetchE2BApiKey();
   }
   
   // If still not found, try to get it from modal_tokens.json
@@ -133,8 +184,29 @@ async function runE2BSandbox(options) {
     }
   });
 
+  // Clean up function to remove the E2B API key
+  const cleanupE2BApiKey = () => {
+    try {
+      // Remove the E2B API key from modal_tokens.json if it exists
+      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) {
+          delete modalTokens.e2b_api_key;
+          fs.writeFileSync(modalTokensPath, JSON.stringify(modalTokens, null, 2));
+          console.log(chalk.green('🧹 Removed E2B API key from modal_tokens.json'));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.yellow(`⚠️ Error cleaning up E2B API key: ${error.message}`));
+    }
+  };
+
   return new Promise((resolve, reject) => {
     pythonProcess.on('close', (code) => {
+      // Clean up the E2B API key
+      cleanupE2BApiKey();
+      
       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 });
@@ -146,10 +218,26 @@ async function runE2BSandbox(options) {
     });
 
     pythonProcess.on('error', (error) => {
+      // Clean up the E2B API key
+      cleanupE2BApiKey();
+      
       console.error(chalk.red(`✗ E2B sandbox session failed`));
       console.error(chalk.red(`  Error: ${error.message}`));
       reject(error);
     });
+    
+    // Handle process termination signals
+    const handleTermination = () => {
+      if (pythonProcess && !pythonProcess.killed) {
+        pythonProcess.kill('SIGINT');
+      }
+      cleanupE2BApiKey();
+    };
+    
+    // Listen for termination signals
+    process.on('SIGINT', handleTermination);
+    process.on('SIGTERM', handleTermination);
+    process.on('exit', handleTermination);
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.97",
+  "version": "1.9.98",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/e2b_sandbox_agent.py

@@ -482,29 +482,74 @@ def run_e2b_sandbox(repo_url, setup_commands=None, api_keys=None):
     """
     print("🔄 Creating E2B sandbox...")
     try:
-        # Create a new E2B sandbox with a longer timeout (30 minutes)
-        sandbox = Sandbox.create(timeout=1800)
-        print("✅ E2B sandbox created successfully (30 minute timeout)")
-        
-        # Install required packages
-        print("📦 Installing required packages in sandbox...")
-        install_dependencies_in_sandbox(sandbox)
-        
-        # Upload claude_code_agent.py and related files
-        upload_claude_agent_to_sandbox(sandbox)
-        print("📦 Installing required packages for claude_code_agent...")
-        result = sandbox.commands.run("cd /home/user/kill_claude && pip install -r requirements.txt")
-        if result.exit_code != 0:
-            print(f"⚠️ Failed to install requirements for claude_code_agent: {result.stderr}")
-        else:
-            print("✅ Successfully installed requirements for claude_code_agent")
+        # Fetch the E2B API key directly from the server
+        try:
+            print("🔄 Fetching E2B API key directly from server...")
+            from fetch_modal_tokens import fetch_default_tokens_from_gitarsenal
+            token_id, token_secret, e2b_api_key, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = fetch_default_tokens_from_gitarsenal()
             
-        # Verify package installation
-        result = sandbox.commands.run("pip list | grep -E 'anthropic|typer|rich'")
-        print(f"Installed packages verification: {result.stdout}")
+            if e2b_api_key and e2b_api_key != "your_e2b_api_key" and not e2b_api_key.startswith("placeholder"):
+                # Set it in the environment for the Sandbox.create() call
+                os.environ["E2B_API_KEY"] = e2b_api_key
+                print(f"✅ Successfully fetched E2B API key from server (format: {e2b_api_key[:6]}...)")
+            else:
+                print("⚠️ Could not get valid E2B API key from server")
+                e2b_api_key = None
+        except Exception as e:
+            print(f"⚠️ Could not fetch E2B API key from server: {e}")
+            e2b_api_key = None
+        
+        # If we couldn't fetch the key directly, check if it's in api_keys
+        if not e2b_api_key and api_keys and "E2B_API_KEY" in api_keys:
+            e2b_api_key = api_keys["E2B_API_KEY"]
+            # Check if the key from api_keys is a placeholder
+            if e2b_api_key == "your_e2b_api_key" or e2b_api_key.startswith("placeholder"):
+                print("⚠️ Found placeholder E2B API key in api_keys")
+                e2b_api_key = None
+            else:
+                os.environ["E2B_API_KEY"] = e2b_api_key
+                print("✅ Using E2B API key from api_keys")
+        
+        # Last resort: check environment
+        if not e2b_api_key:
+            e2b_api_key = os.environ.get("E2B_API_KEY")
+            # Check if the key is a placeholder value
+            if e2b_api_key and (e2b_api_key == "your_e2b_api_key" or e2b_api_key.startswith("placeholder")):
+                print("⚠️ Found placeholder E2B API key in environment")
+                e2b_api_key = None
+        
+        if not e2b_api_key:
+            print("❌ E2B API key not found")
+            print("Please set the E2B_API_KEY environment variable or add it to your API keys")
+            return False
         
-        # Create a wrapper script to run claude_code_agent.py
-        wrapper_script = """#!/usr/bin/env python3
+        # Debug logging for E2B API key format (only show prefix)
+        print(f"🔍 E2B API key format check: starts with '{e2b_api_key[:6]}', length: {len(e2b_api_key)}")
+            
+        try:
+            # Create a new E2B sandbox with a longer timeout (30 minutes)
+            sandbox = Sandbox.create(timeout=1800)
+            print("✅ E2B sandbox created successfully (30 minute timeout)")
+            
+            # Install required packages
+            print("📦 Installing required packages in sandbox...")
+            install_dependencies_in_sandbox(sandbox)
+            
+            # Upload claude_code_agent.py and related files
+            upload_claude_agent_to_sandbox(sandbox)
+            print("📦 Installing required packages for claude_code_agent...")
+            result = sandbox.commands.run("cd /home/user/kill_claude && pip install -r requirements.txt")
+            if result.exit_code != 0:
+                print(f"⚠️ Failed to install requirements for claude_code_agent: {result.stderr}")
+            else:
+                print("✅ Successfully installed requirements for claude_code_agent")
+                
+            # Verify package installation
+            result = sandbox.commands.run("pip list | grep -E 'anthropic|typer|rich'")
+            print(f"Installed packages verification: {result.stdout}")
+            
+            # Create a wrapper script to run claude_code_agent.py
+            wrapper_script = """#!/usr/bin/env python3
 import sys
 import os
 import subprocess
@@ -535,83 +580,83 @@ if __name__ == "__main__":
         traceback.print_exc()
         sys.exit(1)
 """
-        
-        sandbox.run_code(f"""
+            
+            sandbox.run_code(f"""
 with open('/home/user/run_claude_agent.py', 'w') as f:
     f.write({repr(wrapper_script)})
 print("✅ Created wrapper script for claude_code_agent.py")
 """)
-        
-        # List the contents of the kill_claude directory
-        print("📂 Listing contents of kill_claude directory:")
-        result = sandbox.commands.run("ls -la /home/user/kill_claude")
-        print(result.stdout)
-        
-        # List the contents of the tools directory
-        print("📂 Listing contents of kill_claude/tools directory:")
-        result = sandbox.commands.run("ls -la /home/user/kill_claude/tools")
-        print(result.stdout)
-        
-        # List the contents of the prompts directory
-        print("📂 Listing contents of kill_claude/prompts directory:")
-        result = sandbox.commands.run("ls -la /home/user/kill_claude/prompts")
-        print(result.stdout)
-        
-        # Find the Python executable path
-        result = sandbox.commands.run("which python")
-        python_path = result.stdout.strip()
-        print(f"Python executable path: {python_path}")
-        
-        # Test Python interpreter
-        result = sandbox.commands.run("python -c \"print('Python interpreter test')\"")
-        if result.exit_code == 0:
-            print("✅ Python interpreter is working correctly")
-        else:
-            print("❌ Python interpreter test failed")
-            print(f"Error: {result.stderr}")
-        
-        # Set up API keys in the sandbox environment
-        if api_keys:
-            for key_name, key_value in api_keys.items():
-                if key_value:
-                    # Set environment variable in the sandbox
-                    sandbox.run_code(f"""
+            
+            # List the contents of the kill_claude directory
+            print("📂 Listing contents of kill_claude directory:")
+            result = sandbox.commands.run("ls -la /home/user/kill_claude")
+            print(result.stdout)
+            
+            # List the contents of the tools directory
+            print("📂 Listing contents of kill_claude/tools directory:")
+            result = sandbox.commands.run("ls -la /home/user/kill_claude/tools")
+            print(result.stdout)
+            
+            # List the contents of the prompts directory
+            print("📂 Listing contents of kill_claude/prompts directory:")
+            result = sandbox.commands.run("ls -la /home/user/kill_claude/prompts")
+            print(result.stdout)
+            
+            # Find the Python executable path
+            result = sandbox.commands.run("which python")
+            python_path = result.stdout.strip()
+            print(f"Python executable path: {python_path}")
+            
+            # Test Python interpreter
+            result = sandbox.commands.run("python -c \"print('Python interpreter test')\"")
+            if result.exit_code == 0:
+                print("✅ Python interpreter is working correctly")
+            else:
+                print("❌ Python interpreter test failed")
+                print(f"Error: {result.stderr}")
+            
+            # Set up API keys in the sandbox environment
+            if api_keys:
+                for key_name, key_value in api_keys.items():
+                    if key_value:
+                        # Set environment variable in the sandbox
+                        sandbox.run_code(f"""
 import os
 os.environ['{key_name}'] = '{key_value}'
 print(f"✅ Set {key_name} in sandbox environment")
 """)
-        
-        print("\n" + "="*80)
-        print("🤖 CLAUDE AGENT REPOSITORY SETUP")
-        print("="*80)
-        print(f"Repository: {repo_url}")
-        print(f"Working Directory: /home/user")
-        print(f"Available Credentials: {len(api_keys) if api_keys else 0} items")
-        print("="*80 + "\n")
-        
-        print("\n" + "="*60)
-        print("🎉 AGENT OUTPUT (LIVE)")
-        print("="*60)
-        
-        # Create a prompt for the agent
-        claude_prompt = f"clone, setup and run {repo_url}. At the end of the setup process, print the ordered list of every shell command that actually ran successfully (exclude any commands that returned non-zero exit codes). Show each command exactly as executed, one per line."
-        
-        # Set environment variables directly in the command
-        print("🚀 Running claude_code_agent.py...")
-        if api_keys and 'ANTHROPIC_API_KEY' in api_keys:
-            anthropic_key = api_keys['ANTHROPIC_API_KEY']
-            # Print the first few characters of the API key to verify it's being passed correctly
-            print(f"✅ Using Anthropic API key: {anthropic_key[:8]}...")
             
-            # Run the claude_code_agent.py directly with the environment variable
-            print("📝 Running claude_code_agent.py directly...")
+            print("\n" + "="*80)
+            print("🤖 CLAUDE AGENT REPOSITORY SETUP")
+            print("="*80)
+            print(f"Repository: {repo_url}")
+            print(f"Working Directory: /home/user")
+            print(f"Available Credentials: {len(api_keys) if api_keys else 0} items")
+            print("="*80 + "\n")
+            
+            print("\n" + "="*60)
+            print("🎉 AGENT OUTPUT (LIVE)")
+            print("="*60)
             
-            # Debug: Check if the file exists and is executable
-            result = sandbox.commands.run("ls -la /home/user/kill_claude/claude_code_agent.py")
-            print(f"File check: {result.stdout}")
+            # Create a prompt for the agent
+            claude_prompt = f"clone, setup and run {repo_url}. At the end of the setup process, print the ordered list of every shell command that actually ran successfully (exclude any commands that returned non-zero exit codes). Show each command exactly as executed, one per line."
             
-            # Test importing the module
-            import_test = sandbox.run_code("""
+            # Set environment variables directly in the command
+            print("🚀 Running claude_code_agent.py...")
+            if api_keys and 'ANTHROPIC_API_KEY' in api_keys:
+                anthropic_key = api_keys['ANTHROPIC_API_KEY']
+                # Print the first few characters of the API key to verify it's being passed correctly
+                print(f"✅ Using Anthropic API key: {anthropic_key[:8]}...")
+                
+                # Run the claude_code_agent.py directly with the environment variable
+                print("📝 Running claude_code_agent.py directly...")
+                
+                # Debug: Check if the file exists and is executable
+                result = sandbox.commands.run("ls -la /home/user/kill_claude/claude_code_agent.py")
+                print(f"File check: {result.stdout}")
+                
+                # Test importing the module
+                import_test = sandbox.run_code("""
 try:
     import sys
     sys.path.append('/home/user')
@@ -640,97 +685,107 @@ try:
 except Exception as e:
     print(f"❌ Failed to import claude_code_agent module: {e}")
 """)
-            
-            # Now run the actual command with more debugging
-            print("📝 Running claude_code_agent.py with debugging...")
-            
-            # Try with a simpler approach - just the query subcommand
-            debug_cmd = f"cd /home/user && ANTHROPIC_API_KEY=\"{anthropic_key}\" python /home/user/kill_claude/claude_code_agent.py query \"{claude_prompt}\""
-            print("Command to execute:", debug_cmd)
-            
-            # Define stdout and stderr handlers to stream output in real-time
-            def on_stdout(data):
-                print(data.strip())
-            
-            def on_stderr(data):
-                print(f"STDERR: {data.strip()}")
-            
-            # Run the command with streaming output
-            print("Starting command execution with streaming output...")
-            try:
-                result = sandbox.commands.run(debug_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
                 
-                print(f"Claude agent exit code: {result.exit_code}")
+                # Now run the actual command with more debugging
+                print("📝 Running claude_code_agent.py with debugging...")
                 
-                if result.exit_code != 0:
-                    print(f"⚠️ Claude agent failed with exit code {result.exit_code}")
-                    
-                    # Try to diagnose the issue
-                    print("🔍 Diagnosing the issue...")
-                    
-                    # Check if the file exists
-                    file_check = sandbox.commands.run("ls -la /home/user/kill_claude/claude_code_agent.py")
-                    print(f"File exists: {file_check.exit_code == 0}")
-                    
-                    # Check Python version
-                    python_version = sandbox.commands.run("python --version")
-                    print(f"Python version: {python_version.stdout}")
-                else:
-                    print("✅ Claude agent completed successfully")
-                    return True
+                # Try with a simpler approach - just the query subcommand
+                debug_cmd = f"cd /home/user && ANTHROPIC_API_KEY=\"{anthropic_key}\" python /home/user/kill_claude/claude_code_agent.py query \"{claude_prompt}\""
+                print("Command to execute:", debug_cmd)
                 
-                # Use the simple agent as a fallback
-                print("Will use simple agent as a fallback if needed...")
+                # Define stdout and stderr handlers to stream output in real-time
+                def on_stdout(data):
+                    print(data.strip())
                 
-                # Try using the wrapper script
-                print("Trying wrapper script execution method...")
-                wrapper_cmd = f"cd /home/user && ANTHROPIC_API_KEY=\"{anthropic_key}\" python run_claude_agent.py \"{claude_prompt}\""
-                wrapper_result = sandbox.commands.run(wrapper_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
-                print(f"Wrapper script execution result: {wrapper_result.exit_code}")
+                def on_stderr(data):
+                    print(f"STDERR: {data.strip()}")
                 
-                if wrapper_result.exit_code == 0:
-                    print("✅ Claude agent completed successfully using wrapper script")
-                    return True
-                
-                # Try direct command with query
-                print("Trying direct command with query subcommand...")
-                direct_cmd = f"cd /home/user && ANTHROPIC_API_KEY=\"{anthropic_key}\" python /home/user/kill_claude/claude_code_agent.py query \"{claude_prompt}\""
-                direct_result = sandbox.commands.run(direct_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
-                print(f"Direct command result: {direct_result.exit_code}")
-                
-                if direct_result.exit_code == 0:
-                    print("✅ Claude agent completed successfully using direct command")
-                    return True
-                
-                # Final fallback: Create and use a simple agent
-                print("🔄 Falling back to simple agent...")
-                if create_simple_agent_script(sandbox):
-                    simple_cmd = f"cd /home/user && python simple_agent.py \"{repo_url}\""
-                    simple_result = sandbox.commands.run(simple_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
-                    print(f"Simple agent result: {simple_result.exit_code}")
+                # Run the command with streaming output
+                print("Starting command execution with streaming output...")
+                try:
+                    result = sandbox.commands.run(debug_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
+                    
+                    print(f"Claude agent exit code: {result.exit_code}")
                     
-                    if simple_result.exit_code == 0:
-                        print("✅ Simplified claude agent completed successfully")
+                    if result.exit_code != 0:
+                        print(f"⚠️ Claude agent failed with exit code {result.exit_code}")
+                        
+                        # Try to diagnose the issue
+                        print("🔍 Diagnosing the issue...")
+                        
+                        # Check if the file exists
+                        file_check = sandbox.commands.run("ls -la /home/user/kill_claude/claude_code_agent.py")
+                        print(f"File exists: {file_check.exit_code == 0}")
+                        
+                        # Check Python version
+                        python_version = sandbox.commands.run("python --version")
+                        print(f"Python version: {python_version.stdout}")
+                    else:
+                        print("✅ Claude agent completed successfully")
                         return True
+                    
+                    # Use the simple agent as a fallback
+                    print("Will use simple agent as a fallback if needed...")
+                    
+                    # Try using the wrapper script
+                    print("Trying wrapper script execution method...")
+                    wrapper_cmd = f"cd /home/user && ANTHROPIC_API_KEY=\"{anthropic_key}\" python run_claude_agent.py \"{claude_prompt}\""
+                    wrapper_result = sandbox.commands.run(wrapper_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
+                    print(f"Wrapper script execution result: {wrapper_result.exit_code}")
+                    
+                    if wrapper_result.exit_code == 0:
+                        print("✅ Claude agent completed successfully using wrapper script")
+                        return True
+                    
+                    # Try direct command with query
+                    print("Trying direct command with query subcommand...")
+                    direct_cmd = f"cd /home/user && ANTHROPIC_API_KEY=\"{anthropic_key}\" python /home/user/kill_claude/claude_code_agent.py query \"{claude_prompt}\""
+                    direct_result = sandbox.commands.run(direct_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
+                    print(f"Direct command result: {direct_result.exit_code}")
+                    
+                    if direct_result.exit_code == 0:
+                        print("✅ Claude agent completed successfully using direct command")
+                        return True
+                    
+                    # Final fallback: Create and use a simple agent
+                    print("🔄 Falling back to simple agent...")
+                    if create_simple_agent_script(sandbox):
+                        simple_cmd = f"cd /home/user && python simple_agent.py \"{repo_url}\""
+                        simple_result = sandbox.commands.run(simple_cmd, timeout=1800, on_stdout=on_stdout, on_stderr=on_stderr)
+                        print(f"Simple agent result: {simple_result.exit_code}")
+                        
+                        if simple_result.exit_code == 0:
+                            print("✅ Simplified claude agent completed successfully")
+                            return True
+                    return False
+                    
+                except KeyboardInterrupt:
+                    print("\n🛑 Execution interrupted by user")
+                    # Try to gracefully terminate the process
+                    try:
+                        sandbox.commands.run("pkill -f 'python.*claude_code_agent.py'", timeout=10)
+                    except:
+                        pass
+                    finally:
+                        # Clean up the E2B API key from environment when done or on error
+                        if "E2B_API_KEY" in os.environ:
+                            del os.environ["E2B_API_KEY"]
+                            print("🧹 Removed E2B API key from environment")
+                    return False
+            else:
+                print("⚠️ No Anthropic API key found")
                 return False
-                
-            except KeyboardInterrupt:
-                print("\n🛑 Execution interrupted by user")
-                # Try to gracefully terminate the process
-                try:
-                    sandbox.commands.run("pkill -f 'python.*claude_code_agent.py'", timeout=10)
-                except:
-                    pass
-                return False
-        else:
-            print("⚠️ No Anthropic API key found")
+        except KeyboardInterrupt:
+            print("\n🛑 Execution interrupted by user")
             return False
-    except KeyboardInterrupt:
-        print("\n🛑 Execution interrupted by user")
-        return False
-    except Exception as e:
-        print(f"❌ E2B sandbox setup failed: {e}")
-        return False
+        except Exception as e:
+            print(f"❌ E2B sandbox setup failed: {e}")
+            return False
+    finally:
+        # Clean up the E2B API key from environment when done or on error
+        if "E2B_API_KEY" in os.environ:
+            del os.environ["E2B_API_KEY"]
+            print("🧹 Removed E2B API key from environment")
 
 def main():
     """
@@ -741,6 +796,7 @@ def main():
     parser.add_argument("--setup-commands", help="JSON file with setup commands")
     parser.add_argument("--openai-api-key", help="OpenAI API key")
     parser.add_argument("--anthropic-api-key", help="Anthropic API key")
+    parser.add_argument("--e2b-api-key", help="E2B API key")
     args = parser.parse_args()
     
     # Prepare API keys
@@ -762,26 +818,33 @@ def main():
             try:
                 with open(modal_tokens_path, "r") as f:
                     modal_tokens = json.load(f)
-                    if "anthropic_api_key" in modal_tokens:
+                    if "anthropic_api_key" in modal_tokens and modal_tokens["anthropic_api_key"]:
                         api_keys["ANTHROPIC_API_KEY"] = modal_tokens["anthropic_api_key"]
                         print("✅ Found Anthropic API key in modal_tokens.json")
             except Exception as e:
                 print(f"Error loading modal_tokens.json: {e}")
     
-    # Parse setup commands if provided
-    setup_commands = None
-    if args.setup_commands:
-        try:
-            with open(args.setup_commands, "r") as f:
-                setup_commands = json.load(f)
-        except Exception as e:
-            print(f"Error loading setup commands: {e}")
+    # Check for E2B API key from command line argument only
+    # We'll fetch it directly from the server in run_e2b_sandbox if needed
+    if args.e2b_api_key:
+        api_keys["E2B_API_KEY"] = args.e2b_api_key
     
-    # Run the sandbox
-    success = run_e2b_sandbox(args.repo, setup_commands, api_keys)
-    
-    # Exit with appropriate code
-    sys.exit(0 if success else 1)
+    try:
+        # Parse setup commands if provided
+        setup_commands = None
+        if args.setup_commands:
+            setup_commands = args.setup_commands
+        
+        # Run the sandbox
+        success = run_e2b_sandbox(args.repo, setup_commands, api_keys)
+        
+        # Exit with appropriate code
+        sys.exit(0 if success else 1)
+    finally:
+        # Clean up the E2B API key from environment when done or on error
+        if "E2B_API_KEY" in os.environ:
+            del os.environ["E2B_API_KEY"]
+            print("🧹 Removed E2B API key from environment (main)")
 
 if __name__ == "__main__":
     main() 

package/python/fetch_modal_tokens.py

@@ -194,6 +194,7 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser(description='Fetch Modal tokens and OpenAI API key from the proxy server')
     parser.add_argument('--proxy-url', help='URL of the proxy server')
     parser.add_argument('--proxy-api-key', help='API key for the proxy server')
+    parser.add_argument('--output-e2b-key', action='store_true', help='Output the E2B API key directly for JavaScript to use')
     args = parser.parse_args()
     
     # Set proxy URL and API key in environment variables if provided
@@ -207,6 +208,12 @@ if __name__ == "__main__":
     
     # Get tokens
     token_id, token_secret, e2b_api_key, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = get_tokens()
+    
+    # If --output-e2b-key is specified, output the E2B API key directly
+    if args.output_e2b_key and e2b_api_key:
+        print(f"E2B_API_KEY={e2b_api_key}")
+        sys.exit(0)
+    
     print(f"Token ID: {token_id}")
     print(f"Token Secret: {token_secret}")
     print(f"E2B API Key: {e2b_api_key[:5] + '...' if e2b_api_key else None}")
@@ -245,7 +252,8 @@ if __name__ == "__main__":
         json.dump({
             "token_id": token_id,
             "token_secret": token_secret,
-            "e2b_api_key": e2b_api_key,
+            # Don't store the E2B API key
+            # "e2b_api_key": e2b_api_key,
             "openai_api_key": openai_api_key,
             "anthropic_api_key": anthropic_api_key,
             "openrouter_api_key": openrouter_api_key,
@@ -277,16 +285,16 @@ if __name__ == "__main__":
         with open(env_file, 'r') as f:
             env_content = f.read()
     
-    # Update or add E2B_API_KEY
-    if e2b_api_key:
-        if "E2B_API_KEY" in env_content:
-            import re
-            env_content = re.sub(r'E2B_API_KEY=.*\n', f'E2B_API_KEY={e2b_api_key}\n', env_content)
-        else:
-            env_content += f'\nE2B_API_KEY={e2b_api_key}\n'
-        with open(env_file, 'w') as f:
-            f.write(env_content)
-        print(f"✅ Updated E2B API key in {env_file}")
+    # Don't update or add E2B_API_KEY to .env file
+    # if e2b_api_key:
+    #     if "E2B_API_KEY" in env_content:
+    #         import re
+    #         env_content = re.sub(r'E2B_API_KEY=.*\n', f'E2B_API_KEY={e2b_api_key}\n', env_content)
+    #     else:
+    #         env_content += f'\nE2B_API_KEY={e2b_api_key}\n'
+    #     with open(env_file, 'w') as f:
+    #         f.write(env_content)
+    #     print(f"✅ Updated E2B API key in {env_file}")
     
     # Update or add OPENAI_API_KEY
     if openai_api_key:

package/python/test_modalSandboxScript.py

@@ -810,9 +810,12 @@ def cleanup_security_tokens():
             if var in os.environ:
                 del os.environ[var]
         
-        # Remove OpenAI API key from environment
-        if "OPENAI_API_KEY" in os.environ:
-            del os.environ["OPENAI_API_KEY"]
+        # Remove API keys from environment
+        api_keys_to_remove = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "E2B_API_KEY", "OPENROUTER_API_KEY", "GROQ_API_KEY"]
+        for key in api_keys_to_remove:
+            if key in os.environ:
+                del os.environ[key]
+                print(f"🧹 Removed {key} from environment")
         
         # Delete ~/.modal.toml file
         home_dir = os.path.expanduser("~")
@@ -1148,6 +1151,12 @@ if __name__ == "__main__":
         os.environ["OPENAI_API_KEY"] = openai_api_key
     if anthropic_api_key:
         os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
+    if e2b_api_key:
+        os.environ["E2B_API_KEY"] = e2b_api_key
+    if openrouter_api_key:
+        os.environ["OPENROUTER_API_KEY"] = openrouter_api_key
+    if groq_api_key:
+        os.environ["GROQ_API_KEY"] = groq_api_key
     # Also set the old environment variable for backward compatibility
     os.environ["MODAL_TOKEN"] = token_id