claude-code-templates 1.20.3 → 1.21.1

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

@@ -0,0 +1,355 @@
+#!/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
+
+# 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("    ⏳ Executing... Please wait")
+        print("    🔒 Isolated E2B environment active")
+        print("    ⏱️  This may take a few minutes")
+        print("")
+        print("    ⣾⣿⣷ Processing...")
+        print("")
+        print("-" * 60)
+        
+        # Execute with extended timeout for complex operations
+        result = sbx.commands.run(
+            claude_command,
+            timeout=600,  # 10 minutes timeout for complex operations
+        )
+        
+        print(f"🔍 Command exit code: {result.exit_code}")
+        if result.stdout:
+            print(f"📤 Command stdout length: {len(result.stdout)} characters")
+        if result.stderr:
+            print(f"📤 Command stderr length: {len(result.stderr)} characters")
+        
+        print("=" * 60)
+        print("🎯 CLAUDE CODE OUTPUT:")
+        print("=" * 60)
+        print(result.stdout)
+        
+        if result.stderr:
+            print("=" * 60)
+            print("⚠️  STDERR:")
+            print("=" * 60)
+            print(result.stderr)
+        
+        # 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/cli-tool/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/cli-tool/components/sandbox/e2b/requirements.txt

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

package/cli-tool/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/cli-tool/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/cli-tool/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"
+  }
+}

package/cli-tool/components/settings/api/vertex-configuration.json

@@ -0,0 +1,8 @@
+{
+  "description": "Configure Claude Code to use Google Vertex AI for AI model access. Provides integration with Google Cloud Platform infrastructure and billing, suitable for organizations using GCP services.",
+  "env": {
+    "CLAUDE_CODE_USE_VERTEX": "1",
+    "VERTEX_REGION_CLAUDE_3_5_SONNET": "us-central1",
+    "VERTEX_REGION_CLAUDE_3_5_HAIKU": "us-central1"
+  }
+}

package/cli-tool/components/settings/authentication/api-key-helper.json

@@ -0,0 +1,7 @@
+{
+  "description": "Configure a custom script to dynamically generate authentication tokens. The script will be executed to obtain fresh API keys, useful for environments with rotating credentials or temporary access tokens. TTL is set to 1 hour (3600000ms).",
+  "apiKeyHelper": "/bin/generate_temp_api_key.sh",
+  "env": {
+    "CLAUDE_CODE_API_KEY_HELPER_TTL_MS": "3600000"
+  }
+}

package/cli-tool/components/settings/authentication/force-claudeai-login.json

@@ -0,0 +1,4 @@
+{
+  "description": "Restrict authentication to Claude.ai accounts only. This prevents users from logging in with Anthropic Console accounts, ensuring all access goes through the Claude.ai platform for consistent user experience and billing.",
+  "forceLoginMethod": "claudeai"
+}

package/cli-tool/components/settings/authentication/force-console-login.json

@@ -0,0 +1,4 @@
+{
+  "description": "Restrict authentication to Anthropic Console accounts only. This ensures all usage is billed through the API billing system and prevents access via Claude.ai accounts, ideal for enterprise environments with centralized billing.",
+  "forceLoginMethod": "console"
+}

package/cli-tool/components/settings/cleanup/retention-7-days.json

@@ -0,0 +1,4 @@
+{
+  "description": "Set chat transcript retention to 7 days for privacy.",
+  "cleanupPeriodDays": 7
+}

package/cli-tool/components/settings/cleanup/retention-90-days.json

@@ -0,0 +1,4 @@
+{
+  "description": "Set chat transcript retention to 90 days for extended history.",
+  "cleanupPeriodDays": 90
+}

package/cli-tool/components/settings/environment/bash-timeouts.json

@@ -0,0 +1,8 @@
+{
+  "description": "Configure timeout settings for bash command execution. Prevents long-running commands from hanging indefinitely while allowing sufficient time for complex operations like builds and deployments.",
+  "env": {
+    "BASH_DEFAULT_TIMEOUT_MS": "120000",
+    "BASH_MAX_TIMEOUT_MS": "600000",
+    "BASH_MAX_OUTPUT_LENGTH": "100000"
+  }
+}

package/cli-tool/components/settings/environment/development-utils.json

@@ -0,0 +1,8 @@
+{
+  "description": "Enhanced development environment configuration with useful utilities and debugging features. Includes built-in ripgrep usage, terminal title updates, and directory maintenance for improved developer experience.",
+  "env": {
+    "USE_BUILTIN_RIPGREP": "1",
+    "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1",
+    "CLAUDE_CODE_DISABLE_TERMINAL_TITLE": "0"
+  }
+}