claude-code-templates 1.21.5 → 1.21.6

package/components/mcps/devtools/ios-simulator-mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "ios-simulator": {
+      "description": "Control iOS Simulator directly from Claude Code. Launch apps, take screenshots, manage device states, and streamline mobile development workflows.",
+      "command": "npx",
+      "args": ["-y", "ios-simulator-mcp"]
+    }
+  }
+}

package/components/mcps/devtools/just-mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "just-mcp": {
+      "description": "Execute Just commands and task runners seamlessly from Claude Code. Manage project tasks, run build scripts, and automate development workflows with Just integration.",
+      "command": "/path/to/just-mcp",
+      "args": ["--stdio"]
+    }
+  }
+}

package/components/mcps/devtools/leetcode.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "leetcode": {
+        "description": "A Model Context Protocol (MCP) server for LeetCode that enables AI assistants to access LeetCode problems, user information, and contest data.",
+        "command": "mcp-server-leetcode"
+    }
+  }
+}

package/components/mcps/devtools/mcp-server-atlassian-bitbucket.json

@@ -0,0 +1,9 @@
+{
+	"mcpServers": {
+		"bitbucket": {
+            "description": "A Node.js/TypeScript Model Context Protocol (MCP) server for Atlassian Bitbucket Cloud. Enables AI systems (e.g., LLMs like Claude or Cursor AI) to securely interact with your repositories, pull requests, workspaces, and code in real time.",
+			"command": "npx",
+			"args": ["-y", "@aashari/mcp-server-atlassian-bitbucket"]
+		}
+	}
+}

package/components/mcps/devtools/mcp-server-trello.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "trello": {
+      "command": "pnpx",
+      "args": ["@delorenj/mcp-server-trello"],
+      "env": {
+        "TRELLO_API_KEY": "your-api-key",
+        "TRELLO_TOKEN": "your-token"
+      }
+    }
+  }
+}

package/components/mcps/filesystem/filesystem-access.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "filesystem": {
+      "description": "Secure filesystem access for Claude Code with configurable directory permissions and file operations.",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-filesystem",
+        "/path/to/allowed/files"
+      ]
+    }
+  }
+}

package/components/mcps/integration/github-integration.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "github": {
+      "description": "Direct GitHub API integration for repository management, issue tracking, pull requests, and collaborative development workflows.",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
+      }
+    }
+  }
+}

package/components/mcps/integration/memory-integration.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "memory": {
+      "description": "Persistent memory and context management for Claude Code sessions. Store and recall information across conversations and projects.",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"]
+    }
+  }
+}

package/components/mcps/marketing/facebook-ads-mcp-server.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "fb-ads-mcp-server": {
+      "description": "This project provides an MCP server acting as an interface to the Meta Ads, enabling programmatic access to Meta Ads data and management features.",
+      "command": "python",
+      "args": [
+        "/path/to/your/fb-ads-mcp-server/server.py",
+        "--fb-token",
+        "YOUR_META_ACCESS_TOKEN"
+      ]
+    }
+  }
+}

package/components/mcps/marketing/google-ads-mcp-server.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "google-ads": {
+      "description": "A FastMCP-powered Model Context Protocol server for Google Ads API integration with automatic OAuth 2.0 authentication",
+      "command": "/full/path/to/your/project/.venv/bin/python",
+      "args": [
+        "/full/path/to/your/project/server.py"
+      ]
+    }
+  }
+}

package/components/mcps/web/web-fetch.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "fetch": {
+      "description": "Web content fetching and data extraction capabilities. Access external APIs, scrape web content, and integrate external data sources.",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-fetch"]
+    }
+  }
+}

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