gitarsenal-cli 1.9.96 → 1.9.97

package/python/e2b_sandbox_agent.py

@@ -0,0 +1,787 @@
+#!/usr/bin/env python3
+"""
+E2B Sandbox Runner with Agent for GitArsenal
+-------------------------------------------
+This script creates an E2B sandbox, uploads the kill_claude agent files,
+and runs the agent to set up a repository.
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+from e2b_code_interpreter import Sandbox
+
+def install_dependencies_in_sandbox(sandbox):
+    """
+    Install required packages in the sandbox
+    """
+    print("📦 Installing required packages in sandbox...")
+    
+    # Install Python packages
+    packages = [
+        "openai",
+        "anthropic",
+        "python-dotenv",
+        "requests",
+        "tiktoken",
+        "typer",
+        "rich"
+    ]
+    
+    for package in packages:
+        print(f"  📦 Installing {package}...")
+        result = sandbox.commands.run(f"pip install {package}")
+        if result.exit_code == 0:
+            print(f"  ✓ Installed {package}")
+        else:
+            print(f"  ❌ Failed to install {package}")
+            print(result.stderr)
+    
+    # Check if git is available
+    result = sandbox.commands.run("which git")
+    if result.exit_code == 0:
+        print("  ✓ Git is already installed")
+    else:
+        print("  ❌ Git is not available")
+        return False
+    
+    print("✅ Dependencies installation completed")
+    return True
+
+def upload_claude_agent_to_sandbox(sandbox):
+    """
+    Upload the claude_code_agent.py and related files to the sandbox
+    """
+    print("📤 Uploading claude_code_agent.py and related files...")
+    
+    # Create necessary directories
+    sandbox.commands.run("mkdir -p /home/user/kill_claude/tools")
+    sandbox.commands.run("mkdir -p /home/user/kill_claude/prompts")
+    
+    # Find the kill_claude directory path
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    gitarsenal_root = os.path.dirname(script_dir)
+    kill_claude_dir = os.path.join(gitarsenal_root, "kill_claude")
+    
+    if not os.path.exists(kill_claude_dir):
+        print(f"❌ Could not find kill_claude directory at {kill_claude_dir}")
+        return False
+    
+    # Upload claude_code_agent.py
+    agent_path = os.path.join(kill_claude_dir, "claude_code_agent.py")
+    if os.path.exists(agent_path):
+        with open(agent_path, "r") as f:
+            agent_content = f.read()
+                
+            # Check for common issues and fix them
+            print("Checking for common issues in claude_code_agent.py...")
+            
+            # Ensure it has the proper shebang
+            if not agent_content.startswith("#!/usr/bin/env python"):
+                agent_content = "#!/usr/bin/env python3\n" + agent_content
+            print("  ✓ Added shebang to claude_code_agent.py")
+            
+            # Check for API key environment variable access
+            if "os.environ['ANTHROPIC_API_KEY']" in agent_content and "os.environ.get('ANTHROPIC_API_KEY')" not in agent_content:
+                agent_content = agent_content.replace(
+                    "os.environ['ANTHROPIC_API_KEY']", 
+                    "os.environ.get('ANTHROPIC_API_KEY')"
+                )
+            print("  ✓ Fixed API key access to use os.environ.get()")
+            
+            # Check for the correct model name
+            if "claude-3-5-sonnet" in agent_content and "claude-3-5-sonnet-20241022" not in agent_content:
+                agent_content = agent_content.replace(
+                    "claude-3-5-sonnet", 
+                    "claude-3-5-sonnet-20241022"
+                )
+            print("  ✓ Updated model name to claude-3-5-sonnet-20241022")
+                
+            # Check if it's using Typer correctly
+            if "app = typer.Typer()" in agent_content and "if __name__ == \"__main__\":" in agent_content:
+                # Make sure the main function is called correctly
+                if "if __name__ == \"__main__\":\n    app()" not in agent_content and "if __name__ == \"__main__\":\n    main()" in agent_content:
+                    agent_content = agent_content.replace(
+                        "if __name__ == \"__main__\":\n    main()",
+                        "if __name__ == \"__main__\":\n    app()"
+                    )
+                    print("  ✓ Fixed Typer app execution")
+            
+            sandbox.run_code(f"""
+with open('/home/user/kill_claude/claude_code_agent.py', 'w') as f:
+    f.write({repr(agent_content)})
+""")
+            print("  ✓ Uploaded claude_code_agent.py with fixes")
+            
+            # Ensure the first line has the shebang
+            sandbox.run_code("""
+content = ''
+with open('/home/user/kill_claude/claude_code_agent.py', 'r') as f:
+    content = f.read()
+if not content.startswith('#!/usr/bin/env python'):
+    with open('/home/user/kill_claude/claude_code_agent.py', 'w') as f:
+        f.write('#!/usr/bin/env python3\\n' + content)
+    print("  ✓ Added shebang to claude_code_agent.py")
+""")
+    else:
+        print(f"❌ Could not find claude_code_agent.py at {agent_path}")
+        return False
+    
+    # Upload requirements.txt
+    req_path = os.path.join(kill_claude_dir, "requirements.txt")
+    if os.path.exists(req_path):
+        with open(req_path, "r") as f:
+            req_content = f.read()
+        sandbox.run_code(f"""
+with open('/home/user/kill_claude/requirements.txt', 'w') as f:
+    f.write({repr(req_content)})
+""")
+        print("  ✓ Uploaded requirements.txt")
+    
+    # Upload prompts
+    prompts_dir = os.path.join(kill_claude_dir, "prompts")
+    if os.path.exists(prompts_dir):
+        for prompt_file in os.listdir(prompts_dir):
+            if prompt_file.endswith(".md"):
+                prompt_path = os.path.join(prompts_dir, prompt_file)
+                with open(prompt_path, "r") as f:
+                    prompt_content = f.read()
+                sandbox.run_code(f"""
+with open('/home/user/kill_claude/prompts/{prompt_file}', 'w') as f:
+    f.write({repr(prompt_content)})
+""")
+            print(f"Preparing Agents...")
+    
+    # Upload tools
+    tools_dir = os.path.join(kill_claude_dir, "tools")
+    if os.path.exists(tools_dir):
+        for tool_file in os.listdir(tools_dir):
+            if tool_file.endswith(".py"):
+                tool_path = os.path.join(tools_dir, tool_file)
+                with open(tool_path, "r") as f:
+                    tool_content = f.read()
+                sandbox.run_code(f"""
+with open('/home/user/kill_claude/tools/{tool_file}', 'w') as f:
+    f.write({repr(tool_content)})
+""")
+            print(f"Preparing Tools...")
+    
+    # Create __init__.py in tools directory
+    sandbox.run_code("""
+with open('/home/user/kill_claude/tools/__init__.py', 'w') as f:
+    f.write('')
+""")
+    
+    print("✅ Agents are ready to go!")
+    return True
+
+def create_simple_agent_script(sandbox):
+    """
+    Create a simpler agent script that emulates the TodoWrite functionality
+    """
+    print("📝 Creating simple agent script...")
+    
+    script_content = """
+import os
+import sys
+import subprocess
+import time
+import json
+
+def run_command(cmd, cwd=None):
+    print(f"Running: {cmd}")
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True, cwd=cwd)
+    if result.stdout:
+        print("Output:")
+        print(result.stdout.strip())
+    if result.stderr:
+        print("Error:")
+        print(result.stderr.strip())
+    return result.returncode == 0, result.stdout
+
+def print_todo_list(todos):
+    print("╭────────────────────────── 🛠️ Using Tool: TodoWrite ───────────────────────────╮")
+    print("│ ╭────────────────────────── Todo List ({} items) ───────────────────────────╮ │".format(len(todos)))
+    print("│ │ ┏━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ │ │")
+    print("│ │ ┃ #   ┃ Status     ┃ Task                                              ┃ │ │")
+    print("│ │ ┡━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩ │ │")
+    
+    for i, todo in enumerate(todos, 1):
+        status = "⏳ Pending"
+        if todo.get("status") == "in_progress":
+            status = "🔄 In Progress"
+        elif todo.get("status") == "completed":
+            status = "✓ Completed"
+        
+        content = todo.get("content", "")
+        print("│ │ │ {:<3} │ {:<10} │ {:<50} │ │ │".format(i, status, content[:50]))
+    
+    print("│ │ └─────┴────────────┴────────────────────────────────────────────────────┘ │ │")
+    print("│ ╰────────────────────────────────────────────────────────────────────────────╯ │")
+    print("╰──────────────────────────────────────────────────────────────────────────────────╯")
+
+def update_todo(todos, index, status):
+    if 0 <= index < len(todos):
+        todos[index]["status"] = status
+    return todos
+
+def setup_repository(repo_url):
+    print("Setting up repository: " + repo_url)
+    
+    # Initialize todo list
+    todos = [
+        {"id": "1", "content": "Clone the repository from GitHub", "status": "pending"},
+        {"id": "2", "content": "Examine repository structure and setup requirements", "status": "pending"},
+        {"id": "3", "content": "Install dependencies and setup the project", "status": "pending"},
+        {"id": "4", "content": "Run the application/tests", "status": "pending"},
+        {"id": "5", "content": "Print ordered list of successful commands", "status": "pending"}
+    ]
+    
+    print_todo_list(todos)
+    
+    # Step 1: Clone repository
+    print("\\n============================================================")
+    print("🎉 AGENT OUTPUT (LIVE)")
+    print("============================================================")
+    
+    todos = update_todo(todos, 0, "in_progress")
+    print_todo_list(todos)
+    
+    # Create directory
+    repo_dir = os.path.join(os.getcwd(), 'repo')
+    os.makedirs(repo_dir, exist_ok=True)
+    
+    # Clone repository
+    print("Cloning repository...")
+    success, _ = run_command(f"git clone {repo_url} .", cwd=repo_dir)
+    if not success:
+        print("Failed to clone repository")
+        print("Trying again with --depth 1...")
+        success, _ = run_command(f"git clone --depth 1 {repo_url} .", cwd=repo_dir)
+        if not success:
+            print("Failed to clone repository even with --depth 1")
+            return False
+    
+    todos = update_todo(todos, 0, "completed")
+    todos = update_todo(todos, 1, "in_progress")
+    print_todo_list(todos)
+    
+    # Step 2: Examine repository structure
+    print("Analyzing repository structure...")
+    
+    # Python project checks
+    has_requirements = os.path.exists(os.path.join(repo_dir, 'requirements.txt'))
+    has_setup_py = os.path.exists(os.path.join(repo_dir, 'setup.py'))
+    has_pyproject = os.path.exists(os.path.join(repo_dir, 'pyproject.toml'))
+    
+    # JavaScript project checks
+    has_package_json = os.path.exists(os.path.join(repo_dir, 'package.json'))
+    
+    # Print repository info
+    print("Repository information:")
+    print(f"  Python project: {has_requirements or has_setup_py or has_pyproject}")
+    print(f"  JavaScript project: {has_package_json}")
+    
+    todos = update_todo(todos, 1, "completed")
+    todos = update_todo(todos, 2, "in_progress")
+    print_todo_list(todos)
+    
+    # Step 3: Setup Python environment if needed
+    if has_requirements or has_setup_py or has_pyproject:
+        print("Setting up Python environment...")
+        
+        # Create and activate virtual environment
+        run_command('python -m venv .venv', cwd=repo_dir)
+        
+        # Install dependencies
+        if has_requirements:
+            print("Installing requirements.txt dependencies...")
+            run_command('.venv/bin/pip install -r requirements.txt', cwd=repo_dir)
+        
+        if has_setup_py:
+            print("Installing package in development mode...")
+            run_command('.venv/bin/pip install -e .', cwd=repo_dir)
+    
+    # Setup JavaScript environment if needed
+    if has_package_json:
+        print("Setting up JavaScript environment...")
+        run_command('npm install', cwd=repo_dir)
+    
+    todos = update_todo(todos, 2, "completed")
+    todos = update_todo(todos, 3, "in_progress")
+    print_todo_list(todos)
+    
+    # Step 4: Run tests if available
+    if has_requirements or has_setup_py or has_pyproject:
+        if os.path.exists(os.path.join(repo_dir, 'tests')):
+            print("Running tests...")
+            run_command('.venv/bin/pytest', cwd=repo_dir)
+    
+    todos = update_todo(todos, 3, "completed")
+    todos = update_todo(todos, 4, "in_progress")
+    print_todo_list(todos)
+    
+    # Step 5: Print successful commands
+    print("\\n============================================================")
+    print("✅ Successful commands:")
+    print("git clone " + repo_url)
+    if has_requirements:
+        print("python -m venv .venv")
+        print(".venv/bin/pip install -r requirements.txt")
+    if has_setup_py:
+        print(".venv/bin/pip install -e .")
+    if has_package_json:
+        print("npm install")
+    print("============================================================")
+    
+    todos = update_todo(todos, 4, "completed")
+    print_todo_list(todos)
+    
+    print("Repository setup complete!")
+    return True
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print('Usage: python simple_agent.py <repository_url>')
+        sys.exit(1)
+    
+    repo_url = sys.argv[1]
+    print('GitArsenal Simple Agent')
+    print('Repository URL: ' + repo_url)
+    print('Working Directory: ' + os.getcwd())
+    
+    start_time = time.time()
+    success = setup_repository(repo_url)
+    end_time = time.time()
+    
+    print('Setup completed in ' + str(round(end_time - start_time, 2)) + ' seconds')
+    
+    if success:
+        print('Repository setup successful!')
+        print('You can now work with the repository in the repo directory')
+    else:
+        print('Repository setup failed')
+        sys.exit(1)
+"""
+    
+    # Debugging: Check if we can write to the directory
+    try:
+        # First check if we can list the directory
+        result = sandbox.commands.run("ls -la /home/user")
+        print(f"Directory contents of /home/user: {result.stdout}")
+        
+        # Check if we can create a simple file
+        result = sandbox.commands.run("echo 'test' > /home/user/test.txt")
+        print(f"Create test file result: {result.exit_code}")
+        
+        # Check if the file was created
+        result = sandbox.commands.run("cat /home/user/test.txt")
+        print(f"Test file contents: {result.stdout}")
+    except Exception as e:
+        print(f"⚠️ Directory check failed: {e}")
+    
+    # Method 1: Use Python to write the file
+    try:
+        # Use Python to create the file
+        python_code = f'''
+import os
+
+script_content = """{script_content}"""
+
+with open("/home/user/simple_agent.py", "w") as f:
+    f.write(script_content)
+
+print("File written successfully")
+'''
+        
+        result = sandbox.run_code(python_code)
+        print(f"Python file creation result: {result}")
+        
+        # Verify the file exists
+        result = sandbox.commands.run("ls -la /home/user/simple_agent.py")
+        if result.exit_code == 0:
+            print("✅ Simple agent script created successfully")
+            return True
+        else:
+            print(f"⚠️ File creation verification failed: {result.stderr}")
+    except Exception as e:
+        print(f"⚠️ Error creating file with Python: {e}")
+    
+    # Method 2: Use a temporary file
+    try:
+        print("Trying with temporary file...")
+        # Create a temporary file
+        result = sandbox.commands.run("touch /home/user/temp_script.py")
+        
+        # Write the script content to the temporary file in chunks
+        chunk_size = 1000  # Write in chunks to avoid command line limits
+        for i in range(0, len(script_content), chunk_size):
+            chunk = script_content[i:i+chunk_size]
+            # Escape special characters
+            chunk = chunk.replace('"', '\\"').replace("'", "\\'").replace("`", "\\`").replace("$", "\\$")
+            result = sandbox.commands.run(f'echo "{chunk}" >> /home/user/temp_script.py')
+            print(f"  Writing chunk {i//chunk_size + 1}...")
+        
+        # Move the temporary file to the final location
+        result = sandbox.commands.run("mv /home/user/temp_script.py /home/user/simple_agent.py")
+        
+        # Make it executable
+        result = sandbox.commands.run("chmod +x /home/user/simple_agent.py")
+        
+        # Verify the file exists
+        result = sandbox.commands.run("ls -la /home/user/simple_agent.py")
+        if result.exit_code == 0:
+            print("✅ Simple agent script created (chunked method)")
+            return True
+        else:
+            print(f"⚠️ File creation verification failed: {result.stderr}")
+    except Exception as e:
+        print(f"❌ Failed to create simple_agent.py with chunked method: {e}")
+    
+    # Method 3: Use a heredoc approach
+    try:
+        print("Trying with heredoc approach...")
+        
+        # Create a small script that uses heredoc to create the file
+        heredoc_script = """
+cat > /home/user/simple_agent.py << 'EOL'
+""" + script_content + """
+EOL
+"""
+        
+        # Write the heredoc script to a temporary file
+        result = sandbox.commands.run("touch /home/user/create_script.sh")
+        result = sandbox.commands.run(f'echo "{heredoc_script}" > /home/user/create_script.sh')
+        
+        # Make it executable
+        result = sandbox.commands.run("chmod +x /home/user/create_script.sh")
+        
+        # Run the script
+        result = sandbox.commands.run("bash /home/user/create_script.sh")
+        
+        # Verify the file exists
+        result = sandbox.commands.run("ls -la /home/user/simple_agent.py")
+        if result.exit_code == 0:
+            print("✅ Simple agent script created (heredoc method)")
+            return True
+        else:
+            print(f"⚠️ File creation verification failed: {result.stderr}")
+    except Exception as e:
+        print(f"❌ Failed to create simple_agent.py with heredoc method: {e}")
+    
+    print("❌ All methods to create simple_agent.py failed")
+    return False
+
+def run_e2b_sandbox(repo_url, setup_commands=None, api_keys=None):
+    """
+    Run the E2B sandbox with the given repository URL
+    """
+    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")
+            
+        # 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
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python run_claude_agent.py <prompt>")
+        sys.exit(1)
+    
+    prompt = sys.argv[1]
+    
+    # Set up the environment
+    os.environ['ANTHROPIC_API_KEY'] = os.environ.get('ANTHROPIC_API_KEY', '')
+    
+    try:
+        # Import the module
+        sys.path.append('/home/user')
+        from kill_claude import claude_code_agent
+        
+        # Set sys.argv to use the query subcommand
+        sys.argv = ['/home/user/kill_claude/claude_code_agent.py', 'query', prompt]
+        
+        # Call the main function
+        claude_code_agent.main()
+    except Exception as e:
+        print(f"Error executing claude_code_agent.py: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+"""
+        
+        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"""
+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...")
+            
+            # 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')
+    from kill_claude import claude_code_agent
+    print("✅ Successfully imported claude_code_agent module")
+    
+    # Check if the main function exists and is callable
+    if hasattr(claude_code_agent, 'main'):
+        print("✅ main function exists in claude_code_agent module")
+        if callable(getattr(claude_code_agent, 'main')):
+            print("✅ main function is callable")
+        else:
+            print("❌ main function is not callable")
+    else:
+        print("❌ main function does not exist in claude_code_agent module")
+    
+    # Check if it's a Typer app
+    if hasattr(claude_code_agent, 'app') and hasattr(claude_code_agent.app, 'command'):
+        print("✅ This is a Typer app")
+        print("Available commands:", [cmd.name for cmd in claude_code_agent.app.registered_commands])
+    else:
+        print("❌ This is not a Typer app or app structure is different")
+    
+    # Print the module's attributes to see what's available
+    print("Module attributes:", dir(claude_code_agent))
+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}")
+                
+                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
+                return False
+        else:
+            print("⚠️ No Anthropic API key found")
+            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
+
+def main():
+    """
+    Main function to run the E2B sandbox
+    """
+    parser = argparse.ArgumentParser(description="Run an E2B sandbox with a repository")
+    parser.add_argument("--repo", required=True, help="Repository URL to clone")
+    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")
+    args = parser.parse_args()
+    
+    # Prepare API keys
+    api_keys = {}
+    
+    # Check for OpenAI API key
+    openai_api_key = args.openai_api_key or os.environ.get("OPENAI_API_KEY")
+    if openai_api_key:
+        api_keys["OPENAI_API_KEY"] = openai_api_key
+    
+    # Check for Anthropic API key
+    anthropic_api_key = args.anthropic_api_key or os.environ.get("ANTHROPIC_API_KEY")
+    if anthropic_api_key:
+        api_keys["ANTHROPIC_API_KEY"] = anthropic_api_key
+    else:
+        # Try to get Anthropic API key from modal_tokens.json
+        modal_tokens_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "modal_tokens.json")
+        if os.path.exists(modal_tokens_path):
+            try:
+                with open(modal_tokens_path, "r") as f:
+                    modal_tokens = json.load(f)
+                    if "anthropic_api_key" in modal_tokens:
+                        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}")
+    
+    # Run the sandbox
+    success = run_e2b_sandbox(args.repo, setup_commands, api_keys)
+    
+    # Exit with appropriate code
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main()