claude-code-templates 1.21.5 → 1.21.7

package/components/sandbox/README.md

@@ -0,0 +1,169 @@
+# Claude Code Sandbox Components
+
+Execute Claude Code in isolated cloud environments for secure code generation and development.
+
+## Available Sandbox Providers
+
+### E2B Sandbox (`e2b`)
+Run Claude Code in E2B's secure cloud environment with pre-configured development tools.
+
+**Component**: `e2b/claude-code-sandbox.md`
+
+**Files Created**:
+- `.claude/sandbox/e2b-launcher.py` - Python launcher script
+- `.claude/sandbox/requirements.txt` - Python dependencies
+- `.claude/sandbox/.env.example` - Environment variables template
+
+## Quick Start
+
+```bash
+# Simple execution with API keys as parameters (recommended)
+npx claude-code-templates@latest --sandbox e2b \
+  --e2b-api-key your_e2b_key \
+  --anthropic-api-key your_anthropic_key \
+  --prompt "Create a React todo app"
+
+# With components installation
+npx claude-code-templates@latest --sandbox e2b \
+  --e2b-api-key your_e2b_key \
+  --anthropic-api-key your_anthropic_key \
+  --agent frontend-developer \
+  --command setup-react \
+  --prompt "Create a modern todo app with TypeScript"
+
+# Or use environment variables (set E2B_API_KEY and ANTHROPIC_API_KEY)
+npx claude-code-templates@latest --sandbox e2b --prompt "Create a React todo app"
+```
+
+## Environment Setup
+
+1. **Get API Keys**:
+   - E2B API Key: https://e2b.dev/dashboard
+   - Anthropic API Key: https://console.anthropic.com
+
+2. **Create Environment File**:
+   ```bash
+   # In your project/.claude/sandbox/.env
+   E2B_API_KEY=your_e2b_api_key_here
+   ANTHROPIC_API_KEY=your_anthropic_api_key_here
+   ```
+
+3. **Install Python Requirements** (handled automatically):
+   - Python 3.11+
+   - E2B Python SDK
+   - python-dotenv
+
+## How It Works
+
+1. **Component Download**: Downloads sandbox launcher and requirements
+2. **Environment Check**: Validates Python 3.11+ installation
+3. **Dependencies**: Installs E2B Python SDK automatically
+4. **Sandbox Creation**: Creates E2B sandbox with Claude Code template
+5. **Component Installation**: Installs any specified agents/commands/mcps/settings/hooks inside sandbox
+6. **Prompt Execution**: Runs your prompt through Claude Code in the isolated environment
+7. **Result Display**: Shows complete output and generated files
+8. **Cleanup**: Automatically destroys sandbox after execution
+
+## Usage Examples
+
+### Basic Web Development
+```bash
+npx claude-code-templates@latest --sandbox e2b --prompt "Create an HTML page with modern CSS animations"
+```
+
+### Full Stack with Components  
+```bash
+npx claude-code-templates@latest --sandbox e2b \
+  --agent fullstack-developer \
+  --command setup-node \
+  --prompt "Create a Node.js API with JWT authentication"
+```
+
+### Data Analysis
+```bash
+npx claude-code-templates@latest --sandbox e2b \
+  --agent data-scientist \
+  --prompt "Analyze this CSV data and create visualizations"
+```
+
+### Security Audit
+```bash
+npx claude-code-templates@latest --sandbox e2b \
+  --agent security-auditor \
+  --command security-audit \
+  --prompt "Review this codebase for security vulnerabilities"
+```
+
+## Security Benefits
+
+- ✅ **Complete Isolation**: Code runs in separate cloud environment
+- ✅ **No Local Impact**: Zero risk to your local system or files
+- ✅ **Temporary Environment**: Sandbox destroyed after execution
+- ✅ **Controlled Access**: Only specified components are installed
+- ✅ **API Key Security**: Keys never leave your local environment
+
+## Future Sandbox Providers
+
+## ✅ Production Ready Features (v1.20.3+)
+
+### Enhanced E2B Integration
+- **Automatic File Download**: Generated files are automatically downloaded to local `./e2b-output/` directory
+- **Extended Timeouts**: 15-minute sandbox lifetime with intelligent timeout management
+- **Detailed Logging**: Step-by-step execution monitoring with debugging information
+- **Environment Verification**: Automatic checks for Claude Code installation and permissions
+- **Error Recovery**: Retry logic for connection issues and comprehensive error handling
+
+### Advanced Debugging Tools
+- **Real-time Monitor** (`e2b-monitor.py`): System resource monitoring and performance analysis
+- **Debug Guide** (`SANDBOX_DEBUGGING.md`): Comprehensive troubleshooting documentation
+- **Sandbox State Tracking**: Live monitoring of file system changes and process execution
+
+The system is designed to support multiple sandbox providers:
+
+- **E2B** (`--sandbox e2b`) - ✅ **Fully Implemented** - Cloud-based isolated execution environment
+- **Docker** (`--sandbox docker`) - 🔄 Future - Local containerized execution
+- **AWS CodeBuild** (`--sandbox aws`) - 🔄 Future - AWS-based sandbox environment
+- **GitHub Codespaces** (`--sandbox github`) - 🔄 Future - GitHub's cloud development environment
+- **Custom** (`--sandbox custom`) - 🔄 Future - User-defined sandbox configurations
+
+## Troubleshooting
+
+### Python Not Found
+```bash
+# Install Python 3.11+
+brew install python3  # macOS
+# or visit https://python.org/downloads
+```
+
+### API Keys Not Set
+```bash
+# Create .env file in .claude/sandbox/
+echo "E2B_API_KEY=your_key_here" >> .claude/sandbox/.env
+echo "ANTHROPIC_API_KEY=your_key_here" >> .claude/sandbox/.env
+```
+
+### Dependencies Installation Failed
+```bash
+# Manual installation
+cd .claude/sandbox
+pip3 install -r requirements.txt
+```
+
+## Component Architecture
+
+```
+claude-code-templates/
+└── cli-tool/
+    └── components/
+        └── sandbox/
+            ├── e2b/                           # E2B provider
+            │   ├── claude-code-sandbox.md     # Component documentation
+            │   ├── e2b-launcher.py            # Python launcher script
+            │   ├── requirements.txt           # Python dependencies
+            │   └── .env.example               # Environment template
+            ├── docker/                        # Future: Docker provider
+            ├── aws/                           # Future: AWS provider
+            └── README.md                      # This file
+```
+
+The sandbox system integrates seamlessly with the existing Claude Code Templates component architecture, allowing any combination of agents, commands, MCPs, settings, and hooks to be installed and used within the secure sandbox environment.

package/components/sandbox/e2b/.env.example

@@ -0,0 +1,10 @@
+# E2B API Configuration
+# Get your API key from: https://e2b.dev/dashboard
+E2B_API_KEY=your_e2b_api_key_here
+
+# Anthropic API Configuration  
+# Get your API key from: https://console.anthropic.com
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional: Sandbox timeout in seconds (default: 300)
+# E2B_TIMEOUT=300

package/components/sandbox/e2b/SANDBOX_DEBUGGING.md

@@ -0,0 +1,203 @@
+# E2B Sandbox Debugging Guide
+
+## 🔍 Herramientas de Monitoreo Disponibles
+
+### 1. Launcher Principal con Logging Mejorado
+**Archivo**: `e2b-launcher.py`
+- Logging detallado de cada paso
+- Verificación de instalación de Claude Code
+- Monitoreo de permisos y ambiente
+- Timeouts extendidos para operaciones largas
+- Descarga automática de archivos generados
+
+### 2. Monitor de Sandbox en Tiempo Real
+**Archivo**: `e2b-monitor.py`  
+- Monitoreo de recursos del sistema
+- Tracking de file system en tiempo real
+- Análisis de performance y memory usage
+- Logging con timestamps detallados
+
+### 3. Simulador Demo
+Para testing sin API keys válidos, crea un archivo demo que simule el flujo completo.
+
+## 🚨 Troubleshooting Común
+
+### Problema: "Sandbox timeout"
+**Síntomas**:
+```
+❌ Error: The sandbox was not found: This error is likely due to sandbox timeout
+```
+
+**Soluciones**:
+1. **Aumentar timeout del sandbox**:
+   ```python
+   sbx = Sandbox.create(timeout=600)  # 10 minutos
+   sbx.set_timeout(900)  # Extender a 15 minutos
+   ```
+
+2. **Usar el monitor para ver qué consume tiempo**:
+   ```bash
+   python e2b-monitor.py "Your prompt here" "" your_e2b_key your_anthropic_key
+   ```
+
+### Problema: "Claude not found"
+**Síntomas**:
+```
+❌ Claude not found, checking PATH...
+```
+
+**Debugging Steps**:
+1. **Verificar template correcto**:
+   ```python
+   template="anthropic-claude-code"  # Debe ser exactamente este
+   ```
+
+2. **Verificar instalación en sandbox**:
+   ```bash
+   # El launcher ejecuta automáticamente:
+   which claude
+   claude --version
+   echo $PATH
+   ```
+
+### Problema: "Permission denied"
+**Síntomas**:
+```
+❌ Write permission issue
+```
+
+**Soluciones**:
+1. **Verificar directorio de trabajo**:
+   ```bash
+   pwd
+   whoami
+   ls -la
+   ```
+
+2. **Cambiar a directorio con permisos**:
+   ```python
+   sbx.commands.run("cd /home/user && mkdir workspace && cd workspace")
+   ```
+
+### Problema: API Key Issues
+**Síntomas**:
+```
+❌ Error: 401: Invalid API key
+```
+
+**Debugging**:
+1. **Verificar formato de API key**:
+   - E2B keys: formato específico de E2B
+   - Anthropic keys: empiezan con "sk-ant-"
+
+2. **Verificar permisos**:
+   - Verificar que la key tenga permisos de sandbox
+   - Verificar quota/límites de la cuenta
+
+## 📊 Usando el Monitor para Debugging
+
+### Comando Básico:
+```bash
+python e2b-monitor.py "Create a React app" "" your_e2b_key your_anthropic_key
+```
+
+### Output del Monitor:
+```
+[14:32:15] INFO: 🚀 Starting enhanced E2B sandbox with monitoring
+[14:32:16] INFO: ✅ Sandbox created: abc123xyz
+[14:32:17] INFO: 🔍 System resources check
+[14:32:17] INFO: Memory usage:
+[14:32:17] INFO:                total        used        free
+[14:32:17] INFO:   Mem:           2.0Gi       512Mi       1.5Gi
+[14:32:18] INFO: 📁 Initial file system state
+[14:32:18] INFO: Current directory: /home/user
+[14:32:19] INFO: 🤖 Executing Claude Code with monitoring
+[14:32:19] INFO: Starting monitored execution: echo 'Create a React app'...
+[14:32:22] INFO: Command completed in 3.45 seconds
+[14:32:22] INFO: Exit code: 0
+[14:32:22] INFO: STDOUT length: 2847 characters
+```
+
+## 🎯 Casos de Uso Específicos
+
+### 1. **Debugging Timeouts**
+```bash
+# Usar el monitor para ver exactamente dónde se cuelga
+python e2b-monitor.py "Complex prompt that times out"
+```
+
+### 2. **Verificar Generación de Archivos**
+El launcher automáticamente descarga archivos generados:
+```
+💾 DOWNLOADING FILES TO LOCAL MACHINE:
+✅ Downloaded: ./index.html → ./e2b-output/index.html
+✅ Downloaded: ./styles.css → ./e2b-output/styles.css
+
+📁 All files downloaded to: /path/to/project/e2b-output
+```
+
+### 3. **Monitoreo de Performance**
+```
+[14:33:20] INFO: Top processes:
+[14:33:20] INFO:   USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
+[14:33:20] INFO:   user      1234  5.2  2.1  98765 43210 pts/0    S+   14:32   0:01 claude
+```
+
+## 🛠 Configuración Avanzada
+
+### Variables de Ambiente Útiles:
+```bash
+export E2B_DEBUG=1                    # Debug mode
+export ANTHROPIC_API_KEY=your_key     # Claude API key  
+export E2B_API_KEY=your_key          # E2B API key
+```
+
+### Configuración de Timeout Personalizada:
+```python
+# Para operaciones muy largas (ej: compilación completa)
+sbx = Sandbox.create(timeout=1800)  # 30 minutos
+sbx.set_timeout(3600)               # 1 hora máximo
+```
+
+## 📋 Checklist de Debugging
+
+### Antes de Reportar un Issue:
+- [ ] API keys válidos y con permisos correctos
+- [ ] Template correcto: "anthropic-claude-code"
+- [ ] Timeout suficiente para la operación
+- [ ] Ejecutar con el monitor para logs detallados
+- [ ] Verificar que Claude Code esté instalado en sandbox
+- [ ] Revisar permisos de escritura en directorio
+- [ ] Comprobar memoria/recursos disponibles
+
+### Información a Incluir en Reports:
+- Output completo del launcher o monitor
+- Sandbox ID si está disponible
+- Prompt exacto que causa el problema
+- Componentes instalados (si aplica)
+- Tiempo de ejecución antes del fallo
+
+## 🚀 Funcionalidades del Sistema
+
+### Descarga Automática de Archivos
+El launcher descarga automáticamente todos los archivos generados:
+- HTML, CSS, JS, TS, TSX, Python, JSON, Markdown
+- Se guardan en directorio local `./e2b-output/`
+- Excluye archivos internos de Claude Code
+- Preserva nombres de archivo originales
+
+### Logging Detallado
+- Verificación de instalación de Claude Code
+- Monitoreo de permisos y ambiente del sandbox
+- Tracking de exit codes y output length
+- Timestamps para análisis de performance
+
+### Timeouts Inteligentes
+- 10 minutos timeout inicial para creación
+- 15 minutos total extendido automáticamente
+- 5 minutos timeout para ejecución de Claude Code
+- Timeouts cortos para verificaciones (5-10 segundos)
+
+---
+
+**Con estas herramientas puedes monitorear exactamente qué está pasando dentro del sandbox E2B y debuggear cualquier problema que surja.**

package/components/sandbox/e2b/claude-code-sandbox.md

@@ -0,0 +1,110 @@
+# E2B Claude Code Sandbox
+
+Execute Claude Code in an isolated E2B cloud sandbox environment.
+
+## Description
+
+This component sets up E2B (E2B.dev) integration to run Claude Code in a secure, isolated cloud environment. Perfect for executing code safely without affecting your local system.
+
+## Features
+
+- **Isolated Execution**: Run Claude Code in a secure cloud sandbox
+- **Pre-configured Environment**: Ships with Claude Code already installed
+- **API Integration**: Seamless connection to Anthropic's Claude API
+- **Safe Code Execution**: Execute prompts without local system risks
+- **Component Installation**: Automatically installs any components specified with CLI flags
+
+## Requirements
+
+- E2B API Key (get from https://e2b.dev/dashboard)
+- Anthropic API Key
+- Python 3.11+ (for E2B SDK)
+
+## Usage
+
+```bash
+# Execute a prompt in E2B sandbox (requires API keys as environment variables or CLI parameters)
+npx claude-code-templates@latest --sandbox e2b --prompt "Create a React todo app"
+
+# Pass API keys directly as parameters
+npx claude-code-templates@latest --sandbox e2b \
+  --e2b-api-key your_e2b_key \
+  --anthropic-api-key your_anthropic_key \
+  --prompt "Create a React todo app"
+
+# Install components and execute in sandbox
+npx claude-code-templates@latest --sandbox e2b \
+  --agent frontend-developer \
+  --command setup-react \
+  --e2b-api-key your_e2b_key \
+  --anthropic-api-key your_anthropic_key \
+  --prompt "Create a modern todo app with TypeScript"
+```
+
+## Environment Setup
+
+The component will create:
+- `.claude/sandbox/e2b-launcher.py` - Python script to launch E2B sandbox
+- `.claude/sandbox/requirements.txt` - Python dependencies  
+- `.claude/sandbox/.env.example` - Environment variables template
+
+## API Key Configuration
+
+You can provide API keys in two ways:
+
+### Option 1: CLI Parameters (Recommended)
+```bash
+# Pass keys directly as command parameters
+npx claude-code-templates@latest --sandbox e2b \
+  --e2b-api-key your_e2b_api_key \
+  --anthropic-api-key your_anthropic_api_key \
+  --prompt "Your prompt here"
+```
+
+### Option 2: Environment Variables
+Set these environment variables in your shell or `.env` file:
+```bash
+export E2B_API_KEY=your_e2b_api_key_here
+export ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Or create .claude/sandbox/.env file:
+E2B_API_KEY=your_e2b_api_key_here
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+```
+
+**Note**: CLI parameters take precedence over environment variables.
+
+## How it Works
+
+1. Creates E2B sandbox with `anthropic-claude-code` template
+2. Installs any specified components (agents, commands, etc.)
+3. Executes your prompt using Claude Code inside the sandbox
+4. Returns the complete output and any generated files
+5. Automatically cleans up the sandbox after execution
+
+## Security Benefits
+
+- **Isolation**: Code runs in a separate cloud environment
+- **No Local Impact**: No risk to your local system or files
+- **Temporary**: Sandbox is destroyed after execution
+- **Controlled**: Only specified components and prompts are executed
+
+## Examples
+
+```bash
+# Simple web app creation
+npx claude-code-templates@latest --sandbox e2b --prompt "Create an HTML page with CSS animations"
+
+# Full stack development
+npx claude-code-templates@latest --sandbox e2b --agent fullstack-developer --prompt "Create a Node.js API with authentication"
+
+# Data analysis
+npx claude-code-templates@latest --sandbox e2b --agent data-scientist --prompt "Analyze this CSV data and create visualizations"
+```
+
+## Template Information
+
+- **Provider**: E2B (https://e2b.dev)
+- **Base Template**: anthropic-claude-code
+- **Timeout**: 5 minutes (configurable)
+- **Environment**: Ubuntu with Claude Code pre-installed

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.21.5",
+  "version": "1.21.7",
   "description": "CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects",
   "main": "src/index.js",
   "bin": {
@@ -86,6 +86,7 @@
   "files": [
     "bin/",
     "src/",
+    "components/sandbox/e2b/",
     "README.md"
   ],
   "devDependencies": {

package/src/index.js

@@ -2392,32 +2392,67 @@ async function executeSandbox(options, targetDir) {
     const sandboxDir = path.join(targetDir, '.claude', 'sandbox');
     await fs.ensureDir(sandboxDir);
     
-    // Download E2B component files from new structure
-    const baseUrl = 'https://raw.githubusercontent.com/davila7/claude-code-templates/main/cli-tool/components/sandbox/e2b';
+    // Copy E2B component files from the installed package
+    const componentsDir = path.join(__dirname, '..', 'components', 'sandbox', 'e2b');
     
-    // Download launcher script
-    const launcherResponse = await fetch(`${baseUrl}/e2b-launcher.py`);
-    if (!launcherResponse.ok) {
-      throw new Error(`Failed to download e2b-launcher.py: ${launcherResponse.status} ${launcherResponse.statusText}`);
-    }
-    const launcherContent = await launcherResponse.text();
-    await fs.writeFile(path.join(sandboxDir, 'e2b-launcher.py'), launcherContent, { mode: 0o755 });
-    
-    // Download requirements.txt
-    const requirementsResponse = await fetch(`${baseUrl}/requirements.txt`);
-    if (!requirementsResponse.ok) {
-      throw new Error(`Failed to download requirements.txt: ${requirementsResponse.status} ${requirementsResponse.statusText}`);
-    }
-    const requirementsContent = await requirementsResponse.text();
-    await fs.writeFile(path.join(sandboxDir, 'requirements.txt'), requirementsContent);
-    
-    // Download .env.example
-    const envExampleResponse = await fetch(`${baseUrl}/.env.example`);
-    if (!envExampleResponse.ok) {
-      throw new Error(`Failed to download .env.example: ${envExampleResponse.status} ${envExampleResponse.statusText}`);
+    try {
+      // Check if files exist locally (from npm package)
+      if (await fs.pathExists(componentsDir)) {
+        // Copy files from local package
+        console.log(chalk.gray('📦 Using local E2B component files...'));
+        
+        const launcherPath = path.join(componentsDir, 'e2b-launcher.py');
+        const requirementsPath = path.join(componentsDir, 'requirements.txt');
+        const envExamplePath = path.join(componentsDir, '.env.example');
+        
+        if (await fs.pathExists(launcherPath)) {
+          await fs.copyFile(launcherPath, path.join(sandboxDir, 'e2b-launcher.py'));
+          await fs.chmod(path.join(sandboxDir, 'e2b-launcher.py'), 0o755);
+        } else {
+          throw new Error('e2b-launcher.py not found in package');
+        }
+        
+        if (await fs.pathExists(requirementsPath)) {
+          await fs.copyFile(requirementsPath, path.join(sandboxDir, 'requirements.txt'));
+        }
+        
+        if (await fs.pathExists(envExamplePath)) {
+          await fs.copyFile(envExamplePath, path.join(sandboxDir, '.env.example'));
+        }
+      } else {
+        // Fallback to downloading from GitHub if not found locally
+        console.log(chalk.gray('📥 Downloading E2B component files from GitHub...'));
+        
+        const baseUrl = 'https://raw.githubusercontent.com/davila7/claude-code-templates/main/cli-tool/components/sandbox/e2b';
+        
+        // Download launcher script
+        const launcherResponse = await fetch(`${baseUrl}/e2b-launcher.py`);
+        if (!launcherResponse.ok) {
+          throw new Error(`Failed to download e2b-launcher.py: ${launcherResponse.status} ${launcherResponse.statusText}`);
+        }
+        const launcherContent = await launcherResponse.text();
+        await fs.writeFile(path.join(sandboxDir, 'e2b-launcher.py'), launcherContent, { mode: 0o755 });
+        
+        // Download requirements.txt
+        const requirementsResponse = await fetch(`${baseUrl}/requirements.txt`);
+        if (!requirementsResponse.ok) {
+          throw new Error(`Failed to download requirements.txt: ${requirementsResponse.status} ${requirementsResponse.statusText}`);
+        }
+        const requirementsContent = await requirementsResponse.text();
+        await fs.writeFile(path.join(sandboxDir, 'requirements.txt'), requirementsContent);
+        
+        // Download .env.example
+        const envExampleResponse = await fetch(`${baseUrl}/.env.example`);
+        if (!envExampleResponse.ok) {
+          throw new Error(`Failed to download .env.example: ${envExampleResponse.status} ${envExampleResponse.statusText}`);
+        }
+        const envExampleContent = await envExampleResponse.text();
+        await fs.writeFile(path.join(sandboxDir, '.env.example'), envExampleContent);
+      }
+    } catch (error) {
+      spinner.fail(`Failed to install E2B component: ${error.message}`);
+      throw error;
     }
-    const envExampleContent = await envExampleResponse.text();
-    await fs.writeFile(path.join(sandboxDir, '.env.example'), envExampleContent);
     
     spinner.succeed('E2B sandbox component installed successfully');