claude-code-templates 1.21.4 → 1.21.6

package/components/sandbox/e2b/e2b-launcher.py

@@ -0,0 +1,426 @@
+#!/usr/bin/env python3.11
+"""
+E2B Claude Code Sandbox Launcher
+Executes Claude Code prompts in isolated E2B cloud sandbox
+"""
+
+import os
+import sys
+import json
+import datetime
+import re
+import threading
+import time
+
+# Debug: Print Python path information
+print(f"Python executable: {sys.executable}")
+print(f"Python version: {sys.version}")
+print(f"Python path: {sys.path[:3]}...")  # Show first 3 paths
+
+try:
+    from e2b import Sandbox
+    print("✓ E2B imported successfully")
+except ImportError as e:
+    print(f"✗ E2B import failed: {e}")
+    print("Trying to install E2B...")
+    import subprocess
+    # Try different installation methods for different Python environments
+    install_commands = [
+        [sys.executable, '-m', 'pip', 'install', '--user', 'e2b'],  # User install first
+        [sys.executable, '-m', 'pip', 'install', '--break-system-packages', 'e2b'],  # System packages
+        [sys.executable, '-m', 'pip', 'install', 'e2b']  # Default fallback
+    ]
+    
+    result = None
+    for cmd in install_commands:
+        print(f"Trying: {' '.join(cmd)}")
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode == 0:
+            print("✓ Installation successful")
+            break
+        else:
+            print(f"✗ Failed: {result.stderr.strip()[:100]}...")
+    
+    if result is None:
+        result = subprocess.run([sys.executable, '-m', 'pip', 'install', 'e2b'], 
+                              capture_output=True, text=True)
+    print(f"Install result: {result.returncode}")
+    if result.stdout:
+        print(f"Install stdout: {result.stdout}")
+    if result.stderr:
+        print(f"Install stderr: {result.stderr}")
+    
+    # Try importing again
+    try:
+        from e2b import Sandbox
+        print("✓ E2B imported successfully after install")
+    except ImportError as e2:
+        print(f"✗ E2B still failed after install: {e2}")
+        sys.exit(1)
+
+# Try to import and use dotenv if available, but don't fail if it's not
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    # dotenv is optional since we can get keys from command line arguments
+    pass
+
+def main():
+    
+    # Parse command line arguments
+    if len(sys.argv) < 2:
+        print("Usage: python e2b-launcher.py <prompt> [components_to_install] [e2b_api_key] [anthropic_api_key]")
+        sys.exit(1)
+    
+    prompt = sys.argv[1]
+    components_to_install = sys.argv[2] if len(sys.argv) > 2 else ""
+    
+    # Get API keys from command line arguments or environment variables
+    e2b_api_key = sys.argv[3] if len(sys.argv) > 3 else os.getenv('E2B_API_KEY')
+    anthropic_api_key = sys.argv[4] if len(sys.argv) > 4 else os.getenv('ANTHROPIC_API_KEY')
+    
+    if not e2b_api_key:
+        print("Error: E2B API key is required")
+        print("Provide via command line argument or E2B_API_KEY environment variable")
+        sys.exit(1)
+    
+    if not anthropic_api_key:
+        print("Error: Anthropic API key is required")
+        print("Provide via command line argument or ANTHROPIC_API_KEY environment variable")
+        sys.exit(1)
+    
+    try:
+        # Create E2B sandbox with Claude Code template with retry logic
+        print("🚀 Creating E2B sandbox with Claude Code...")
+        
+        # Try creating sandbox with retries for WebSocket issues
+        max_retries = 3
+        retry_count = 0
+        sbx = None
+        
+        while retry_count < max_retries and sbx is None:
+            try:
+                if retry_count > 0:
+                    print(f"🔄 Retry {retry_count}/{max_retries - 1} - WebSocket connection...")
+                
+                sbx = Sandbox.create(
+                    template="anthropic-claude-code",
+                    api_key=e2b_api_key,
+                    envs={
+                        'ANTHROPIC_API_KEY': anthropic_api_key,
+                    },
+                    timeout=600,  # 10 minutes timeout for longer operations
+                )
+                
+                # Keep sandbox alive during operations
+                print(f"🔄 Extending sandbox timeout to prevent early termination...")
+                sbx.set_timeout(900)  # 15 minutes total
+                print(f"✅ Sandbox created: {sbx.sandbox_id}")
+                break
+                
+            except Exception as e:
+                error_msg = str(e).lower()
+                if "websocket" in error_msg or "connection" in error_msg or "timeout" in error_msg:
+                    retry_count += 1
+                    if retry_count < max_retries:
+                        print(f"⚠️  WebSocket connection failed (attempt {retry_count}), retrying in 3 seconds...")
+                        import time
+                        time.sleep(3)
+                        continue
+                    else:
+                        print(f"❌ WebSocket connection failed after {max_retries} attempts")
+                        print("💡 This might be due to:")
+                        print("   • Network/firewall restrictions blocking WebSocket connections")
+                        print("   • Temporary E2B service issues")
+                        print("   • Corporate proxy blocking WebSocket traffic")
+                        print("💡 Try:")
+                        print("   • Running from a different network")
+                        print("   • Checking your firewall/proxy settings")
+                        print("   • Waiting a few minutes and trying again")
+                        raise e
+                else:
+                    # Non-WebSocket error, don't retry
+                    raise e
+        
+        if sbx is None:
+            raise Exception("Failed to create sandbox after all retry attempts")
+        
+        # Install components if specified
+        if components_to_install:
+            print("📦 Installing specified components...")
+            install_result = sbx.commands.run(
+                f"npx claude-code-templates@latest {components_to_install}",
+                timeout=120,  # 2 minutes for component installation
+            )
+            
+            if install_result.exit_code != 0:
+                print(f"⚠️  Component installation warnings:")
+                print(install_result.stderr)
+            else:
+                print("✅ Components installed successfully")
+        
+        # Build enhanced prompt with instructions
+        # Parse components to extract agents
+        agents = []
+        if components_to_install:
+            # Split by '--' to get individual component types
+            parts = components_to_install.split('--')
+            for part in parts:
+                part = part.strip()
+                if part.startswith('agent '):
+                    # Extract agent names after 'agent ' prefix
+                    agent_names = part[6:].strip()  # Remove 'agent ' prefix
+                    if agent_names:
+                        # Split by comma if multiple agents
+                        agents.extend([a.strip() for a in agent_names.split(',')])
+        
+        # Create enhanced prompt with proper instructions
+        if agents:
+            agent_list = ', '.join(agents)
+            enhanced_prompt = f"""You are Claude Code, an AI assistant specialized in software development. 
+
+IMPORTANT INSTRUCTIONS:
+1. Execute the user's request immediately and create the requested code/files
+2. You have access to the following specialized agents: {agent_list}
+3. Use these agents in the order you deem most appropriate for completing the task
+4. Generate all necessary files and code to fulfill the request
+5. Be proactive and create a complete, working implementation
+
+USER REQUEST: {prompt}
+
+Now, please execute this request and create all necessary files."""
+        else:
+            enhanced_prompt = f"""You are Claude Code, an AI assistant specialized in software development.
+
+IMPORTANT INSTRUCTIONS:
+1. Execute the user's request immediately and create the requested code/files
+2. Generate all necessary files and code to fulfill the request
+3. Be proactive and create a complete, working implementation
+4. Don't just acknowledge the request - actually create the implementation
+
+USER REQUEST: {prompt}
+
+Now, please execute this request and create all necessary files."""
+        
+        # Execute Claude Code with the enhanced prompt
+        print(f"🤖 Executing Claude Code with prompt: '{prompt[:50]}{'...' if len(prompt) > 50 else ''}'")
+        if agents:
+            print(f"🤝 Using agents: {', '.join(agents)}")
+        
+        # First, check if Claude Code is installed and available
+        print("🔍 Checking Claude Code installation...")
+        check_result = sbx.commands.run("which claude", timeout=10)
+        if check_result.exit_code == 0:
+            print(f"✅ Claude found at: {check_result.stdout.strip()}")
+        else:
+            print("❌ Claude not found, checking PATH...")
+            path_result = sbx.commands.run("echo $PATH", timeout=5)
+            print(f"PATH: {path_result.stdout}")
+            ls_result = sbx.commands.run("ls -la /usr/local/bin/ | grep claude", timeout=5)
+            print(f"Claude binaries: {ls_result.stdout}")
+        
+        # Check current directory and permissions
+        print("🔍 Checking sandbox environment...")
+        pwd_result = sbx.commands.run("pwd", timeout=5)
+        print(f"Current directory: {pwd_result.stdout.strip()}")
+        
+        whoami_result = sbx.commands.run("whoami", timeout=5)
+        print(f"Current user: {whoami_result.stdout.strip()}")
+        
+        # Check if we can write to current directory
+        test_write = sbx.commands.run("touch test_write.tmp && rm test_write.tmp", timeout=5)
+        if test_write.exit_code == 0:
+            print("✅ Write permissions OK")
+        else:
+            print("❌ Write permission issue")
+        
+        # Build Claude Code command with enhanced prompt and better error handling
+        # Escape single quotes in the enhanced prompt
+        escaped_prompt = enhanced_prompt.replace("'", "'\\''")
+        claude_command = f"echo '{escaped_prompt}' | claude -p --dangerously-skip-permissions"
+        
+        # Show the original user prompt in the command display (not the enhanced version)
+        display_prompt = prompt[:100] + '...' if len(prompt) > 100 else prompt
+        print(f"🚀 Running command: echo '{display_prompt}' | claude -p --dangerously-skip-permissions")
+        
+        # Show loading message with visual separation
+        print("")
+        print("=" * 60)
+        print("☁️  EXECUTING CLAUDE CODE IN SECURE CLOUD SANDBOX")
+        print("=" * 60)
+        print("")
+        print("    ⏳ Starting execution...")
+        print("    🔒 Isolated E2B environment active")
+        print("    📡 Streaming real-time output below:")
+        print("")
+        print("-" * 60)
+        print("📝 LIVE OUTPUT:")
+        print("-" * 60)
+        
+        # Collect output for later use
+        stdout_buffer = []
+        stderr_buffer = []
+        
+        # Track if we've received any output and last activity time
+        has_output = [False]  # Use list to allow modification in nested function
+        last_activity = [time.time()]
+        execution_complete = [False]
+        
+        # Progress indicator thread
+        def show_progress():
+            """Show periodic progress updates if no output for a while"""
+            progress_messages = [
+                "⏳ Still processing...",
+                "🔄 Claude Code is working on your request...",
+                "⚙️  Analyzing requirements...",
+                "🛠️  Building solution...",
+                "📝 Generating code...",
+                "🔍 Reviewing implementation..."
+            ]
+            message_index = 0
+            
+            while not execution_complete[0]:
+                time.sleep(5)  # Check every 5 seconds
+                
+                # If no activity for 10 seconds and no output yet
+                if not has_output[0] and (time.time() - last_activity[0]) > 10:
+                    print(f"\n    {progress_messages[message_index % len(progress_messages)]}")
+                    message_index += 1
+                    last_activity[0] = time.time()
+        
+        # Start progress thread
+        progress_thread = threading.Thread(target=show_progress, daemon=True)
+        progress_thread.start()
+        
+        # Define callbacks for streaming output
+        def on_stdout(data):
+            """Handle stdout output in real-time"""
+            if data:
+                # Mark that we've received output and update activity time
+                if not has_output[0]:
+                    has_output[0] = True
+                    print("\n🎯 Claude Code started responding:\n")
+                
+                last_activity[0] = time.time()
+                
+                # Print the data as it comes
+                print(data, end='', flush=True)
+                stdout_buffer.append(data)
+        
+        def on_stderr(data):
+            """Handle stderr output in real-time"""
+            if data:
+                # Mark that we've received output and update activity time
+                if not has_output[0]:
+                    has_output[0] = True
+                    print("\n🎯 Claude Code started responding:\n")
+                
+                last_activity[0] = time.time()
+                
+                # Print stderr with warning prefix
+                if data.strip():
+                    print(f"⚠️  {data}", end='', flush=True)
+                stderr_buffer.append(data)
+        
+        # Execute with streaming output and extended timeout
+        try:
+            result = sbx.commands.run(
+                claude_command,
+                timeout=600,  # 10 minutes timeout for complex operations
+                on_stdout=on_stdout,
+                on_stderr=on_stderr
+            )
+        finally:
+            # Mark execution as complete to stop progress thread
+            execution_complete[0] = True
+        
+        # Join collected output
+        full_stdout = ''.join(stdout_buffer)
+        full_stderr = ''.join(stderr_buffer)
+        
+        # Print execution summary
+        print("")
+        print("-" * 60)
+        print(f"🔍 Command exit code: {result.exit_code}")
+        
+        # Since we already streamed the output, just show summary
+        if full_stdout:
+            print(f"📤 Total stdout: {len(full_stdout)} characters")
+        if full_stderr:
+            print(f"⚠️  Total stderr: {len(full_stderr)} characters")
+        
+        # List generated files
+        print("=" * 60)
+        print("📁 GENERATED FILES:")
+        print("=" * 60)
+        
+        files_result = sbx.commands.run("find . -type f \\( -name '*.html' -o -name '*.js' -o -name '*.css' -o -name '*.py' -o -name '*.json' -o -name '*.md' -o -name '*.tsx' -o -name '*.ts' \\) ! -path '*/.claude/*' ! -path '*/node_modules/*' | head -20")
+        if files_result.stdout.strip():
+            print(files_result.stdout)
+            
+            # Download important files to local machine
+            print("\n" + "=" * 60)
+            print("💾 DOWNLOADING FILES TO LOCAL MACHINE:")
+            print("=" * 60)
+            
+            # Create project directory with sandbox ID in current working directory
+            project_dir = f"sandbox-{sbx.sandbox_id[:8]}"  # Use first 8 chars of sandbox ID
+            local_output_dir = os.path.join(os.getcwd(), project_dir)  # Use current working directory
+            
+            # Ensure the project directory exists
+            os.makedirs(local_output_dir, exist_ok=True)
+            
+            print(f"📂 Downloading files to project directory: {local_output_dir}")
+            print(f"📍 Current working directory: {os.getcwd()}")
+            
+            files_to_download = files_result.stdout.strip().split('\n')
+            for file_path in files_to_download:
+                file_path = file_path.strip()
+                if file_path:  # Already filtered out .claude and node_modules in find command
+                    try:
+                        # Read file content from sandbox
+                        file_content = sbx.commands.run(f"cat '{file_path}'", timeout=30)
+                        if file_content.exit_code == 0:
+                            # Preserve directory structure by removing leading ./
+                            relative_path = file_path.lstrip('./')
+                            local_file = os.path.join(local_output_dir, relative_path)
+                            
+                            # Create directory structure if needed
+                            os.makedirs(os.path.dirname(local_file), exist_ok=True)
+                            
+                            # Write file locally
+                            with open(local_file, 'w', encoding='utf-8') as f:
+                                f.write(file_content.stdout)
+                            
+                            print(f"✅ Downloaded: {file_path} → {local_file}")
+                        else:
+                            print(f"❌ Failed to read: {file_path}")
+                    except Exception as e:
+                        print(f"❌ Error downloading {file_path}: {e}")
+            
+            print(f"\n📁 All files downloaded to: {os.path.abspath(local_output_dir)}")
+            
+        else:
+            print("No common files generated")
+        
+        print("=" * 60)
+        print(f"✅ Execution completed successfully")
+        print(f"🗂️  Sandbox ID: {sbx.sandbox_id}")
+        print("💡 Note: Sandbox will be automatically destroyed")
+        
+    except Exception as e:
+        print(f"❌ Error executing Claude Code in sandbox: {str(e)}")
+        sys.exit(1)
+    
+    finally:
+        # Cleanup sandbox
+        try:
+            if 'sbx' in locals():
+                sbx.kill()
+                print("🧹 Sandbox cleaned up")
+        except Exception as cleanup_error:
+            print(f"⚠️  Cleanup warning: {cleanup_error}")
+
+if __name__ == "__main__":
+    main()

package/components/sandbox/e2b/e2b-monitor.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3.11
+"""
+E2B Sandbox Real-time Monitor
+Provides real-time monitoring and debugging of E2B sandbox operations
+"""
+
+import os
+import sys
+import time
+import json
+from datetime import datetime
+
+def log_with_timestamp(message, level="INFO"):
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    print(f"[{timestamp}] {level}: {message}")
+
+def monitor_sandbox_execution(sbx, command, timeout=600):
+    """
+    Monitor sandbox command execution with real-time feedback
+    """
+    log_with_timestamp(f"Starting monitored execution: {command[:100]}...")
+    
+    # Start command execution
+    start_time = time.time()
+    result = None
+    
+    try:
+        # Execute command with monitoring
+        log_with_timestamp("Command started, monitoring execution...")
+        
+        # For real implementation, you would run the command and monitor
+        # This is a template for when you have valid API keys
+        result = sbx.commands.run(command, timeout=timeout)
+        
+        elapsed = time.time() - start_time
+        log_with_timestamp(f"Command completed in {elapsed:.2f} seconds")
+        
+        # Log execution results
+        log_with_timestamp(f"Exit code: {result.exit_code}")
+        if result.stdout:
+            log_with_timestamp(f"STDOUT length: {len(result.stdout)} characters")
+            if len(result.stdout) < 500:
+                log_with_timestamp(f"STDOUT preview: {result.stdout[:200]}...")
+        if result.stderr:
+            log_with_timestamp(f"STDERR length: {len(result.stderr)} characters", "WARNING")
+            log_with_timestamp(f"STDERR: {result.stderr}", "ERROR")
+            
+        return result
+        
+    except Exception as e:
+        elapsed = time.time() - start_time
+        log_with_timestamp(f"Command failed after {elapsed:.2f} seconds: {e}", "ERROR")
+        raise e
+
+def monitor_file_system(sbx, description="Monitoring file system"):
+    """
+    Monitor sandbox file system state
+    """
+    log_with_timestamp(f"📁 {description}")
+    
+    try:
+        # Check current directory
+        pwd_result = sbx.commands.run("pwd", timeout=10)
+        log_with_timestamp(f"Current directory: {pwd_result.stdout.strip()}")
+        
+        # List files
+        ls_result = sbx.commands.run("ls -la", timeout=10)
+        log_with_timestamp("Directory contents:")
+        for line in ls_result.stdout.split('\n')[:10]:  # Show first 10 files
+            if line.strip():
+                log_with_timestamp(f"  {line}")
+        
+        # Check disk usage
+        du_result = sbx.commands.run("du -sh .", timeout=10)
+        log_with_timestamp(f"Directory size: {du_result.stdout.strip()}")
+        
+        # Check for specific file types
+        find_result = sbx.commands.run("find . -type f -name '*.html' -o -name '*.js' -o -name '*.css' -o -name '*.json' | head -10", timeout=15)
+        if find_result.stdout.strip():
+            log_with_timestamp("Generated files found:")
+            for file in find_result.stdout.split('\n')[:10]:
+                if file.strip():
+                    log_with_timestamp(f"  📄 {file.strip()}")
+        
+    except Exception as e:
+        log_with_timestamp(f"File system monitoring error: {e}", "ERROR")
+
+def monitor_system_resources(sbx):
+    """
+    Monitor sandbox system resources
+    """
+    log_with_timestamp("🔍 System resources check")
+    
+    try:
+        # Memory usage
+        mem_result = sbx.commands.run("free -h", timeout=10)
+        log_with_timestamp("Memory usage:")
+        for line in mem_result.stdout.split('\n')[:3]:
+            if line.strip():
+                log_with_timestamp(f"  {line}")
+        
+        # CPU load
+        load_result = sbx.commands.run("uptime", timeout=10)
+        log_with_timestamp(f"System load: {load_result.stdout.strip()}")
+        
+        # Process list (top 5 processes)
+        ps_result = sbx.commands.run("ps aux --sort=-%cpu | head -6", timeout=10)
+        log_with_timestamp("Top processes:")
+        lines = ps_result.stdout.split('\n')
+        for line in lines[:6]:  # Header + top 5
+            if line.strip():
+                log_with_timestamp(f"  {line}")
+                
+    except Exception as e:
+        log_with_timestamp(f"System monitoring error: {e}", "ERROR")
+
+def enhanced_sandbox_execution(prompt, components_to_install="", e2b_api_key=None, anthropic_api_key=None):
+    """
+    Enhanced sandbox execution with full monitoring
+    This would be called instead of the basic launcher when you have valid API keys
+    """
+    
+    log_with_timestamp("🚀 Starting enhanced E2B sandbox with monitoring")
+    log_with_timestamp("=" * 60)
+    
+    try:
+        from e2b import Sandbox
+        log_with_timestamp("✅ E2B SDK imported successfully")
+    except ImportError as e:
+        log_with_timestamp(f"❌ E2B import failed: {e}", "ERROR")
+        return False
+    
+    if not e2b_api_key or not anthropic_api_key:
+        log_with_timestamp("❌ Missing API keys", "ERROR")
+        return False
+    
+    try:
+        # Create sandbox with monitoring
+        log_with_timestamp("Creating E2B sandbox...")
+        sbx = Sandbox.create(
+            template="anthropic-claude-code",
+            api_key=e2b_api_key,
+            envs={'ANTHROPIC_API_KEY': anthropic_api_key},
+            timeout=600
+        )
+        
+        log_with_timestamp(f"✅ Sandbox created: {sbx.sandbox_id}")
+        sbx.set_timeout(900)
+        log_with_timestamp("⏱️  Sandbox timeout extended to 15 minutes")
+        
+        # Initial system check
+        monitor_system_resources(sbx)
+        monitor_file_system(sbx, "Initial file system state")
+        
+        # Install components if specified
+        if components_to_install:
+            log_with_timestamp(f"📦 Installing components: {components_to_install}")
+            install_command = f"npx claude-code-templates@latest {components_to_install}"
+            monitor_sandbox_execution(sbx, install_command, timeout=120)
+            monitor_file_system(sbx, "After components installation")
+        
+        # Verify Claude Code installation
+        log_with_timestamp("🔍 Verifying Claude Code installation")
+        claude_check = monitor_sandbox_execution(sbx, "which claude", timeout=10)
+        if claude_check.exit_code == 0:
+            version_check = monitor_sandbox_execution(sbx, "claude --version", timeout=10)
+            log_with_timestamp(f"Claude version: {version_check.stdout.strip()}")
+        else:
+            log_with_timestamp("❌ Claude Code not found in PATH", "ERROR")
+        
+        # Execute main prompt with monitoring
+        log_with_timestamp("🤖 Executing Claude Code with monitoring")
+        claude_command = f"echo '{prompt}' | claude -p --dangerously-skip-permissions"
+        
+        result = monitor_sandbox_execution(sbx, claude_command, timeout=600)
+        
+        # Final file system check
+        monitor_file_system(sbx, "Final file system state")
+        
+        # Display results
+        log_with_timestamp("=" * 60)
+        log_with_timestamp("🎯 CLAUDE CODE RESULTS")
+        log_with_timestamp("=" * 60)
+        
+        if result.stdout:
+            print(result.stdout)
+        
+        if result.stderr:
+            log_with_timestamp("⚠️  STDERR OUTPUT", "WARNING")
+            print(result.stderr)
+        
+        log_with_timestamp("✅ Execution completed successfully")
+        
+        # Cleanup
+        sbx.kill()
+        log_with_timestamp("🧹 Sandbox cleaned up")
+        return True
+        
+    except Exception as e:
+        log_with_timestamp(f"❌ Execution failed: {e}", "ERROR")
+        return False
+
+def main():
+    if len(sys.argv) < 2:
+        print("E2B Sandbox Monitor")
+        print("Usage: python e2b-monitor.py <prompt> [components] [e2b_key] [anthropic_key]")
+        print()
+        print("This tool provides enhanced monitoring and debugging for E2B sandbox operations.")
+        print("Use this when you have valid API keys and want detailed insight into sandbox execution.")
+        sys.exit(1)
+    
+    prompt = sys.argv[1]
+    components = sys.argv[2] if len(sys.argv) > 2 else ""
+    e2b_key = sys.argv[3] if len(sys.argv) > 3 else os.getenv('E2B_API_KEY')
+    anthropic_key = sys.argv[4] if len(sys.argv) > 4 else os.getenv('ANTHROPIC_API_KEY')
+    
+    log_with_timestamp("🎬 E2B Sandbox Monitor Starting")
+    log_with_timestamp("=" * 60)
+    
+    success = enhanced_sandbox_execution(prompt, components, e2b_key, anthropic_key)
+    
+    if success:
+        log_with_timestamp("🎉 Monitoring session completed successfully")
+    else:
+        log_with_timestamp("❌ Monitoring session failed")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/components/sandbox/e2b/requirements.txt

@@ -0,0 +1 @@
+e2b>=2.0.2

package/components/settings/api/bedrock-configuration.json

@@ -0,0 +1,7 @@
+{
+  "description": "Configure Claude Code to use Amazon Bedrock for AI model access. Enables enterprise-grade deployment with AWS billing and compliance features, ideal for organizations already using AWS infrastructure.",
+  "env": {
+    "CLAUDE_CODE_USE_BEDROCK": "1",
+    "AWS_BEARER_TOKEN_BEDROCK": "your-bedrock-api-key"
+  }
+}

package/components/settings/api/corporate-proxy.json

@@ -0,0 +1,7 @@
+{
+  "description": "Configure proxy settings for corporate network environments. Allows Claude Code to work behind corporate firewalls and proxy servers while maintaining security compliance with enterprise network policies.",
+  "env": {
+    "HTTP_PROXY": "http://proxy.company.com:8080",
+    "HTTPS_PROXY": "https://proxy.company.com:8080"
+  }
+}

package/components/settings/api/custom-headers.json

@@ -0,0 +1,6 @@
+{
+  "description": "Add custom headers to API requests for specialized authentication or routing requirements. Useful for enterprise deployments with custom authentication systems or API gateways that require additional metadata.",
+  "env": {
+    "ANTHROPIC_CUSTOM_HEADERS": "X-Company-ID: your-company-id\\nX-Environment: production\\nX-API-Version: v1"
+  }
+}