gitarsenal-cli 1.9.96 → 1.9.97

package/python/test_enhanced_sandbox_script.py

@@ -0,0 +1,1429 @@
+import os
+import sys
+import time
+import subprocess
+import json
+import re
+import datetime
+import getpass
+import secrets
+import string
+import argparse
+from pathlib import Path
+import modal
+
+
+def generate_random_password(length=16):
+    """Generate a random password for SSH access"""
+    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
+    password = ''.join(secrets.choice(alphabet) for i in range(length))
+    return password
+
+
+def get_stored_credentials():
+    """Load stored credentials from ~/.gitarsenal/credentials.json"""
+    import json
+    from pathlib import Path
+    
+    try:
+        credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
+        if credentials_file.exists():
+            with open(credentials_file, 'r') as f:
+                credentials = json.load(f)
+            return credentials
+        else:
+            return {}
+    except Exception as e:
+        print(f"⚠️ Error loading stored credentials: {e}")
+        return {}
+
+
+def parse_analysis_data(analysis_data_json):
+    """Parse analysis data JSON string and return structured data"""
+    if not analysis_data_json:
+        return None
+    
+    try:
+        import json
+        analysis_data = json.loads(analysis_data_json)
+        return analysis_data
+    except json.JSONDecodeError as e:
+        print(f"⚠️ Error parsing analysis data: {e}")
+        return None
+    except Exception as e:
+        print(f"⚠️ Unexpected error parsing analysis data: {e}")
+        return None
+
+
+def select_base_image_from_analysis(analysis_data):
+    """Select the appropriate Docker base image based on CUDA recommendations from analysis"""
+    # Default fallback image
+    default_image = "nvidia/cuda:12.4.1-devel-ubuntu22.04"
+    default_python = "3.11"
+    
+    if not analysis_data:
+        print("🐳 No analysis data available, using default CUDA image")
+        return default_image, default_python
+    
+    # Extract CUDA recommendation
+    cuda_rec = analysis_data.get('cudaRecommendation', {})
+    if not cuda_rec:
+        print("🐳 No CUDA recommendation found, using default CUDA image")
+        return default_image, default_python
+    
+    recommended_cuda = cuda_rec.get('recommendedCudaVersion', '')
+    docker_image = cuda_rec.get('dockerImage', '')
+    
+    # Handle null values from analysis
+    if recommended_cuda == 'null' or recommended_cuda is None:
+        recommended_cuda = ''
+    if docker_image == 'null' or docker_image is None:
+        docker_image = ''
+    
+    # Check if analysis returned no useful CUDA information
+    if not recommended_cuda and not docker_image:
+        print("⚠️ Repository analysis did not detect specific CUDA requirements")
+        print("🐳 Will use default CUDA 12.4.1 image for broad compatibility")
+    
+    print(f"🔍 CUDA Analysis Results:")
+    print(f"  - Recommended CUDA Version: {recommended_cuda or 'None'}")
+    print(f"  - Recommended Docker Image: {docker_image or 'None'}")
+    print(f"  - Full CUDA Recommendation: {cuda_rec}")
+    
+    # If a specific docker image is recommended, use it
+    if docker_image and docker_image.strip():
+        print(f"🔍 Validating recommended Docker image: {docker_image}")
+        # Validate that the recommended Docker image follows expected patterns
+        is_valid_image = False
+        
+        # Check if it's a pytorch image or other specialized image
+        if 'pytorch' in docker_image.lower():
+            print(f"🐳 Using PyTorch-optimized image: {docker_image}")
+            return docker_image, "3.11"  # PyTorch images usually have Python pre-installed
+        elif 'tensorflow' in docker_image.lower():
+            print(f"🐳 Using TensorFlow-optimized image: {docker_image}")
+            return docker_image, "3.11"
+        elif 'nvidia/cuda' in docker_image.lower():
+            # Instead of regex validation, use a whitelist of known good images
+            # This prevents using images that match the pattern but don't exist
+            known_good_images = {
+                # CUDA 12.x images
+                'nvidia/cuda:12.4.1-devel-ubuntu22.04',
+                'nvidia/cuda:12.4.1-runtime-ubuntu22.04',
+                'nvidia/cuda:12.3.2-devel-ubuntu22.04',
+                'nvidia/cuda:12.3.2-runtime-ubuntu22.04',
+                'nvidia/cuda:12.2.2-devel-ubuntu22.04',
+                'nvidia/cuda:12.2.2-runtime-ubuntu22.04',
+                'nvidia/cuda:12.1.0-devel-ubuntu22.04',
+                'nvidia/cuda:12.1.0-runtime-ubuntu22.04',
+                'nvidia/cuda:12.0.1-devel-ubuntu22.04',
+                # CUDA 11.x images
+                'nvidia/cuda:11.8.0-devel-ubuntu22.04',
+                'nvidia/cuda:11.8.0-runtime-ubuntu22.04',
+                'nvidia/cuda:11.8.0-cudnn8-devel-ubuntu22.04',
+                'nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04',
+                'nvidia/cuda:11.7.1-devel-ubuntu22.04',
+                'nvidia/cuda:11.7.1-runtime-ubuntu22.04',
+                'nvidia/cuda:11.7.1-cudnn8-devel-ubuntu22.04',
+                'nvidia/cuda:11.7.1-cudnn8-runtime-ubuntu22.04',
+                'nvidia/cuda:11.6.2-devel-ubuntu20.04',
+                'nvidia/cuda:11.6.2-runtime-ubuntu20.04',
+            }
+            
+            if docker_image.lower() in known_good_images:
+                print(f"🐳 Using verified NVIDIA CUDA image: {docker_image}")
+                return docker_image, "3.11"
+            else:
+                print(f"⚠️ NVIDIA CUDA image not in whitelist: {docker_image}")
+                print(f"🔄 Falling back to CUDA version mapping...")
+                # Continue to version mapping below
+        else:
+            print(f"🐳 Using custom recommended image: {docker_image}")
+            return docker_image, "3.11"
+    
+    # Map CUDA versions to appropriate base images
+    cuda_image_mapping = {
+        '12.4': 'nvidia/cuda:12.4.1-devel-ubuntu22.04',
+        '12.3': 'nvidia/cuda:12.3.2-devel-ubuntu22.04', 
+        '12.2': 'nvidia/cuda:12.2.2-devel-ubuntu22.04',
+        '12.1': 'nvidia/cuda:12.1.0-devel-ubuntu22.04',
+        '12.0': 'nvidia/cuda:12.0.1-devel-ubuntu22.04',
+        '11.8': 'nvidia/cuda:11.8.0-devel-ubuntu22.04',
+        '11.7': 'nvidia/cuda:11.7.1-devel-ubuntu22.04',
+        '11.6': 'nvidia/cuda:11.6.2-devel-ubuntu20.04',
+        # Add some runtime variants for better compatibility
+        '11.8-runtime': 'nvidia/cuda:11.8.0-runtime-ubuntu22.04',
+        '11.7-runtime': 'nvidia/cuda:11.7.1-runtime-ubuntu22.04',
+        '12.1-runtime': 'nvidia/cuda:12.1.0-runtime-ubuntu22.04',
+    }
+    
+    # Extract major.minor version from recommended CUDA version
+    if recommended_cuda and recommended_cuda.strip():
+        # Handle versions like "12.4", "CUDA 12.4", "12.4.0", "11.8-runtime", etc.
+        import re
+        version_match = re.search(r'(\d+\.\d+)', recommended_cuda)
+        if version_match:
+            cuda_version = version_match.group(1)
+            
+            # First try exact match
+            if cuda_version in cuda_image_mapping:
+                selected_image = cuda_image_mapping[cuda_version]
+                print(f"🐳 Selected CUDA {cuda_version} image: {selected_image}")
+                return selected_image, "3.11"
+            
+            # Try with -runtime suffix if original recommended image was runtime
+            if (docker_image and 'runtime' in docker_image.lower()) or 'runtime' in recommended_cuda.lower():
+                runtime_key = f"{cuda_version}-runtime"
+                if runtime_key in cuda_image_mapping:
+                    selected_image = cuda_image_mapping[runtime_key]
+                    print(f"🐳 Selected CUDA {cuda_version} runtime image: {selected_image}")
+                    return selected_image, "3.11"
+            
+            # If no exact match, try to find the closest version
+            available_versions = [v for v in cuda_image_mapping.keys() if not v.endswith('-runtime')]
+            available_versions.sort(reverse=True)  # Sort descending to prefer newer versions
+            
+            for available_version in available_versions:
+                if available_version.startswith(cuda_version.split('.')[0]):  # Same major version
+                    selected_image = cuda_image_mapping[available_version]
+                    print(f"🐳 Selected closest CUDA {available_version} image for requested {cuda_version}: {selected_image}")
+                    return selected_image, "3.11"
+            
+            print(f"⚠️ CUDA version {cuda_version} not in mapping, using default")
+        else:
+            print(f"⚠️ Could not parse CUDA version from: {recommended_cuda}")
+    
+    print(f"🐳 Using default CUDA image: {default_image}")
+    return default_image, default_python
+
+
+# Global SSH container function (must be at global scope for Modal)
+def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, setup_commands=None, openai_api_key=None, anthropic_api_key=None, stored_credentials=None):
+    """Start SSH container with password authentication and intelligent repository setup using Agent."""
+    import subprocess
+    import time
+    import os
+    import json
+    import sys
+    
+    # Set root password
+    subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
+    
+    # Set OpenAI API key if provided
+    if openai_api_key:
+        os.environ['OPENAI_API_KEY'] = openai_api_key
+    else:
+        print("⚠️ No OpenAI API key provided to container")
+    
+    # Set up stored credentials in container environment
+    if stored_credentials:
+        print(f"🔐 Setting up {len(stored_credentials)} stored credentials in container...")
+        for key, value in stored_credentials.items():
+            # Set each credential as an environment variable
+            env_var_name = key.upper().replace('-', '_').replace(' ', '_')
+            os.environ[env_var_name] = value
+            print(f"✅ Set {env_var_name} in container environment")
+        
+        # Also save credentials to a file in the container for easy access
+        credentials_dir = "/root/.gitarsenal"
+        os.makedirs(credentials_dir, exist_ok=True)
+        credentials_file = os.path.join(credentials_dir, "credentials.json")
+        with open(credentials_file, 'w') as f:
+            json.dump(stored_credentials, f, indent=2)
+        print(f"✅ Saved credentials to {credentials_file}")
+        
+        # Print available credentials for user reference
+        print("\n🔐 AVAILABLE CREDENTIALS IN CONTAINER:")
+        print("="*50)
+        for key, value in stored_credentials.items():
+            masked_value = value[:8] + "..." if len(value) > 8 else "***"
+            env_var_name = key.upper().replace('-', '_').replace(' ', '_')
+            print(f"  {key} -> {env_var_name} = {masked_value}")
+        print("="*50)
+        print("💡 These credentials are available as environment variables and in /root/.gitarsenal/credentials.json")
+        
+    
+    # Start SSH service
+    subprocess.run(["service", "ssh", "start"], check=True)
+    
+    # Use Agent for intelligent repository setup
+    if repo_url:
+        print("🤖 Using Agent for intelligent repository setup...")
+        
+        # Set up environment variables for the Agent
+        if openai_api_key:
+            os.environ['OPENAI_API_KEY'] = openai_api_key
+        if anthropic_api_key:
+            os.environ['ANTHROPIC_API_KEY'] = anthropic_api_key
+        
+        # Set up Anthropic API key from stored credentials
+        if stored_credentials:
+            # Look for Anthropic API key in various possible names
+            for key_name in ['ANTHROPIC_API_KEY', 'anthropic_api_key', 'anthropic-api-key']:
+                if key_name in stored_credentials:
+                    anthropic_api_key = stored_credentials[key_name]
+                    os.environ['ANTHROPIC_API_KEY'] = anthropic_api_key
+                    print(f"✅ Set Anthropic API key from stored credentials")
+                    break
+                    
+            if not anthropic_api_key:
+                print("⚠️ No Anthropic API key found in stored credentials")
+                print("💡 Agent will require an Anthropic API key for operation")
+        
+        try:
+            print("🔧 Running Agent for repository setup...")
+            
+            print("\n" + "="*80)
+            print("🤖 AGENT REPOSITORY SETUP")
+            print("="*80)
+            print(f"Repository: {repo_url}")
+            print(f"Working Directory: /root")
+            if stored_credentials:
+                print(f"Available Credentials: {len(stored_credentials)} items")
+            print("="*80 + "\n")
+            
+            # Call Agent directly as subprocess with real-time output
+            claude_prompt = f"clone, setup and run {repo_url}. At the end of the setup process, print the ordered list of every shell command that actually ran successfully (exclude any commands that returned non-zero exit codes). Show each command exactly as executed, one per line."
+            # print(f"🚀 Executing the task: \"{claude_prompt}\"")
+            print("\n" + "="*60)
+            print("🎉 AGENT OUTPUT (LIVE)")
+            print("="*60)
+            
+            # Use Popen for real-time output streaming with optimizations
+            import sys
+            import select
+            import fcntl
+            import os as os_module
+            
+            process = subprocess.Popen(
+                ["python", "-u", "/python/kill_claude/claude_code_agent.py", claude_prompt],  # -u for unbuffered output
+                cwd="/root",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,  # Keep separate for better handling
+                text=True,
+                bufsize=0,  # Unbuffered for fastest output
+                universal_newlines=True,
+                env=dict(os.environ, PYTHONUNBUFFERED='1')  # Force unbuffered Python output
+            )
+            
+            # Make stdout and stderr non-blocking for faster reading
+            def make_non_blocking(fd):
+                flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+                fcntl.fcntl(fd, fcntl.F_SETFL, flags | os_module.O_NONBLOCK)
+            
+            make_non_blocking(process.stdout)
+            make_non_blocking(process.stderr)
+            
+            # Stream output in real-time with robust error handling
+            try:
+                stdout_buffer = ""
+                stderr_buffer = ""
+                
+                while process.poll() is None:
+                    try:
+                        # Use select for efficient I/O multiplexing with error handling
+                        ready, _, _ = select.select([process.stdout, process.stderr], [], [], 0.1)  # 100ms timeout
+                        
+                        for stream in ready:
+                            try:
+                                if stream == process.stdout:
+                                    chunk = stream.read(1024)  # Read in chunks for efficiency
+                                    if chunk is not None and chunk:
+                                        stdout_buffer += chunk
+                                        # Process complete lines immediately
+                                        while '\n' in stdout_buffer:
+                                            line, stdout_buffer = stdout_buffer.split('\n', 1)
+                                            # Add subtle color to agent output for better readability
+                                            print(line, flush=True)  # Use default terminal colors
+                                elif stream == process.stderr:
+                                    chunk = stream.read(1024)
+                                    if chunk is not None and chunk:
+                                        stderr_buffer += chunk
+                                        # Process complete lines immediately  
+                                        while '\n' in stderr_buffer:
+                                            line, stderr_buffer = stderr_buffer.split('\n', 1)
+                                            print(f"STDERR: {line}", flush=True)
+                            except (BlockingIOError, OSError, ValueError):
+                                # Handle various I/O errors gracefully
+                                continue
+                    except (select.error, OSError):
+                        # If select fails, fall back to simple polling
+                        time.sleep(0.1)
+                        continue
+                
+                # Process any remaining output after process ends
+                try:
+                    # Read any remaining data from streams
+                    remaining_stdout = process.stdout.read()
+                    remaining_stderr = process.stderr.read()
+                    
+                    if remaining_stdout:
+                        stdout_buffer += remaining_stdout
+                    if remaining_stderr:
+                        stderr_buffer += remaining_stderr
+                    
+                    # Output remaining buffered content
+                    if stdout_buffer.strip():
+                        print(stdout_buffer.strip(), flush=True)
+                    if stderr_buffer.strip():
+                        print(f"STDERR: {stderr_buffer.strip()}", flush=True)
+                except (OSError, ValueError):
+                    # Handle cases where streams are already closed
+                    pass
+                
+                # Get final return code
+                return_code = process.returncode
+                
+                print("\n" + "="*60)
+                if return_code == 0:
+                    print("✅ Agent completed successfully!")
+                else:
+                    print(f"⚠️ Agent exited with code: {return_code}")
+                print("="*60)
+                
+            except subprocess.TimeoutExpired:
+                print("\n⚠️ Agent timed out after 10 minutes")
+                process.kill()
+                process.wait()
+            except Exception as stream_error:
+                pass
+                
+                # Fallback to simple readline approach
+                try:
+                    # Restart the process with simpler streaming
+                    if process.poll() is None:
+                        process.kill()
+                        process.wait()
+                    
+                    fallback_process = subprocess.Popen(
+                        ["python", "-u", "/python/kill_claude/claude_code_agent.py", claude_prompt],
+                        cwd="/root",
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                        text=True,
+                        bufsize=1,
+                        universal_newlines=True
+                    )
+                    
+                    # Simple line-by-line reading
+                    while True:
+                        line = fallback_process.stdout.readline()
+                        if line == '' and fallback_process.poll() is not None:
+                            break
+                        if line:
+                            print(line.rstrip(), flush=True)
+                    
+                    return_code = fallback_process.returncode
+                    
+                    print("\n" + "="*60)
+                    if return_code == 0:
+                        print("✅ Agent completed successfully!")
+                    else:
+                        print(f"⚠️ Agent exited with code: {return_code}")
+                    print("="*60)
+                    
+                except Exception as fallback_error:
+                    print(f"\n❌ Fallback streaming also failed: {fallback_error}")
+                    print("⚠️ Agent may have completed, but output streaming failed")
+                    return_code = 1
+            
+        except Exception as e:
+            print(f"❌ Error during repository setup: {e}")
+            print("⚠️ Proceeding without setup...")
+            import traceback
+            traceback.print_exc()
+    else:
+        print("⚠️ No repository URL provided, skipping setup")
+    
+    print("🔌 Creating SSH tunnel on port 22...")
+    # Create SSH tunnel
+    with modal.forward(22, unencrypted=True) as tunnel:
+        host, port = tunnel.tcp_socket
+        
+        print("\n" + "=" * 80)
+        print("🎉 SSH CONTAINER IS READY!")
+        print("=" * 80)
+        print(f"🌐 SSH Host: {host}")
+        print(f"🔌 SSH Port: {port}")
+        print(f"👤 Username: root")
+        print(f"🔐 Password: {ssh_password}")
+        print()
+        print("🔗 CONNECT USING THIS COMMAND:")
+        print(f"ssh -p {port} root@{host}")
+        print("=" * 80)
+        
+        print("🔄 Starting keep-alive loop...")
+        # Keep the container running
+        iteration = 0
+        while True:
+            iteration += 1
+            if iteration % 10 == 1:  # Print every 5 minutes (10 * 30 seconds = 5 minutes)
+                print(f"💓 Container alive (iteration {iteration})")
+            
+            time.sleep(30)
+            # Check if SSH service is still running
+            try:
+                subprocess.run(["service", "ssh", "status"], check=True, 
+                             capture_output=True)
+            except subprocess.CalledProcessError:
+                print("⚠️ SSH service stopped, restarting...")
+                subprocess.run(["service", "ssh", "start"], check=True)
+
+
+# Create Modal SSH container with GPU support and intelligent repository setup using Agent
+def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
+                               volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False, gpu_count=1, analysis_data=None):
+    """Create a Modal SSH container with GPU support and intelligent repository setup.
+    
+    When repo_url is provided, uses Agent for intelligent repository setup.
+    The setup_commands parameter is maintained for backwards compatibility but ignored when using Agent.
+    Args:
+        analysis_data: Repository analysis data from best_gpu endpoint for dynamic image selection
+    """
+    
+    # Use interactive mode if specified
+    if interactive:
+        # If GPU type is not specified, use default
+        if not gpu_type:
+            gpu_type = "A10G"
+            print(f"✅ Using default GPU type: {gpu_type}")
+        else:
+            print(f"✅ Using provided GPU type: {gpu_type}")
+            
+        # If repo URL is not specified, prompt for it
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    return None
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                return None
+                
+        # If volume name is not specified, ask about persistent volume
+        if not volume_name:
+            try:
+                use_volume = input("? Use persistent volume for faster installs? (Y/n): ").strip().lower()
+                if use_volume in ('', 'y', 'yes'):
+                    volume_name = input("? Enter volume name: ").strip()
+                    if not volume_name:
+                        volume_name = "gitarsenal-volume"
+                        print(f"Using default volume name: {volume_name}")
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+    
+    # Check if Modal is authenticated
+    try:
+        modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+        modal_token = os.environ.get("MODAL_TOKEN")
+        openai_api_key = os.environ.get("OPENAI_API_KEY")
+        # Try to access Modal token to check authentication
+        try:
+            # Check if token is set in environment
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            if not modal_token_id:
+                print("⚠️ MODAL_TOKEN_ID not found in environment.")
+                # Try to get from MODAL_TOKEN
+                modal_token = os.environ.get("MODAL_TOKEN")
+                if modal_token:
+                    print("✅ Found token in environment variable")
+                    os.environ["MODAL_TOKEN_ID"] = modal_token
+                    modal_token_id = modal_token
+                    print(f"✅ Set token (length: {len(modal_token)})")        
+        except Exception as e:
+            print(f"⚠️ Error checking Modal token: {e}")
+            # Try to use the token from environment
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            modal_token = os.environ.get("MODAL_TOKEN")
+            if modal_token_id:
+                print(f"🔄 Using token from environment (length: {len(modal_token_id)})")
+            elif modal_token:
+                print(f"🔄 Using token from environment (length: {len(modal_token)})")
+                os.environ["MODAL_TOKEN_ID"] = modal_token
+                modal_token_id = modal_token
+            else:
+                print("❌ No Modal token available. Cannot proceed.")
+                return None
+            
+            # Set it in both environment variables
+            os.environ["MODAL_TOKEN_ID"] = modal_token_id
+            os.environ["MODAL_TOKEN"] = modal_token_id
+            print("✅ Set both token and id environment variables")
+    except Exception as e:
+        print(f"⚠️ Error checking Modal authentication: {e}")
+        print("Continuing anyway, but Modal operations may fail")
+    
+    # Generate a unique app name with timestamp to avoid conflicts
+    timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+    app_name = f"ssh-container-{timestamp}"
+    
+    gpu_configs = {
+        'T4': {'gpu': 't4', 'memory': 16},
+        'L4': {'gpu': 'l4', 'memory': 24},
+        'A10G': {'gpu': 'a10g', 'memory': 24},
+        'A100-40GB': {'gpu': 'a100', 'memory': 40},
+        'A100-80GB': {'gpu': 'a100-80gb', 'memory': 80},
+        'L40S': {'gpu': 'l40s', 'memory': 48},
+        'H100': {'gpu': 'h100', 'memory': 80},
+        'H200': {'gpu': 'h200', 'memory': 141},
+        'B200': {'gpu': 'b200', 'memory': 96}
+    }
+    
+    if gpu_type not in gpu_configs:
+        print(f"⚠️ Unknown GPU type: {gpu_type}. Using A10G as default.")
+        gpu_type = 'A10G'
+    
+    gpu_spec = gpu_configs[gpu_type]
+    
+    # Configure GPU string for Modal (support multiple GPUs)
+    if gpu_count > 1:
+        modal_gpu_spec = f"{gpu_spec['gpu']}:{gpu_count}"
+        total_memory = gpu_spec['memory'] * gpu_count
+        print(f"🚀 Creating SSH container with {gpu_count}x {gpu_spec['gpu']} GPUs ({total_memory}GB total VRAM)")
+    else:
+        modal_gpu_spec = gpu_spec['gpu']
+        print(f"🚀 Creating SSH container with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
+    
+    # Store the modal GPU specification for the decorator
+    gpu_spec['modal_gpu'] = modal_gpu_spec
+    
+    # Generate or use provided SSH password
+    if not ssh_password:
+        ssh_password = generate_random_password()
+        print(f"🔐 Generated SSH password: {ssh_password}")
+    
+    # Setup volume if specified
+    volume = None
+    volume_mount_path = "/persistent"
+    
+    if volume_name:
+        print(f"📦 Setting up volume: {volume_name}")
+        try:
+            volume = modal.Volume.from_name(volume_name, create_if_missing=True)
+            print(f"✅ Volume '{volume_name}' ready for use")
+        except Exception as e:
+            print(f"⚠️ Could not setup volume '{volume_name}': {e}")
+            print("⚠️ Continuing without persistent volume")
+            volume = None
+    else:
+        # Create a default volume for this session
+        default_volume_name = f"ssh-vol-{timestamp}"
+        print(f"📦 Creating default volume: {default_volume_name}")
+        try:
+            volume = modal.Volume.from_name(default_volume_name, create_if_missing=True)
+            volume_name = default_volume_name
+            print(f"✅ Default volume '{default_volume_name}' created")
+        except Exception as e:
+            print(f"⚠️ Could not create default volume: {e}")
+            print("⚠️ Continuing without persistent volume")
+            volume = None
+    
+    modal_token = os.environ.get("MODAL_TOKEN_ID")
+
+    # Create SSH-enabled image
+    print("📦 Building SSH-enabled image...")
+    
+    # Get the current directory path for mounting local Python sources
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    # Get the gitarsenal-cli root directory for kill_claude files
+    gitarsenal_root = os.path.dirname(current_dir)
+    
+    # Select base image dynamically based on analysis data
+    base_image_name, python_version = select_base_image_from_analysis(analysis_data)
+    print(f"🐳 Building image with: {base_image_name} (Python {python_version})")
+    
+    try:
+        base_image = modal.Image.from_registry(base_image_name, add_python=python_version)
+    except Exception as e:
+        print(f"⚠️ Failed to load recommended image {base_image_name}: {e}")
+        print("🐳 Falling back to default CUDA image")
+        base_image = modal.Image.from_registry("nvidia/cuda:12.4.1-devel-ubuntu22.04", add_python="3.11")
+    
+    # Build the SSH image with the chosen base
+    ssh_image = (
+        base_image
+        # Set timezone and debconf to non-interactive mode to prevent prompts
+        .env({"DEBIAN_FRONTEND": "noninteractive", "TZ": "UTC"})
+        .run_commands(
+            # Configure timezone and package management non-interactively
+            "ln -snf /usr/share/zoneinfo/UTC /etc/localtime",
+            "echo UTC > /etc/timezone",
+            # Configure dpkg to avoid interactive prompts
+            "echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections"
+        )
+        .apt_install(
+            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
+            "python3", "python3-pip", "unzip", "ca-certificates"
+        )
+    )
+    
+    # Add Python packages using the appropriate method
+    ssh_image = ssh_image.uv_pip_install("uv", "modal", "gitingest", "requests", "openai", "anthropic", "exa-py")
+    
+    # Add the rest of the configuration
+    ssh_image = ssh_image.run_commands(
+        # Create SSH directory
+        "mkdir -p /var/run/sshd",
+        "mkdir -p /root/.ssh",
+        "chmod 700 /root/.ssh",
+
+        "ssh-keygen -A",
+        "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
+        "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
+        "echo 'export PATH=/usr/local/cuda/bin:$PATH' >> /root/.bashrc",
+        
+        # Install Bun (JavaScript runtime and package manager)
+        "curl -fsSL https://bun.com/install | bash",
+        "echo 'export PATH=/root/.bun/bin:$PATH' >> /root/.bashrc",
+        
+        # Install Pixi (modern package management tool)
+        "curl -fsSL https://pixi.sh/install.sh | sh",
+        "echo 'export PATH=/root/.pixi/bin:$PATH' >> /root/.bashrc",
+        
+        # Create base directories (subdirectories will be created automatically when mounting)
+        "mkdir -p /python",
+    ).add_local_dir(current_dir, "/python", ignore=lambda p: not p.name.endswith('.py')).add_local_dir(os.path.join(gitarsenal_root, "kill_claude"), "/python/kill_claude")
+    print("✅ SSH image built successfully")
+        
+    # Configure volumes if available
+    volumes_config = {}
+    if volume:
+        volumes_config[volume_mount_path] = volume
+    
+    # Create app with image passed directly (THIS IS THE KEY CHANGE)
+    print("🔍 Testing app creation...")
+    app = modal.App(app_name, image=ssh_image)  # Pass image here
+    print("✅ Created app successfully")
+        
+    # Apply the decorator to the global SSH container function
+    decorated_ssh_function = app.function(
+        timeout=timeout_minutes * 60,  # Convert to seconds
+        gpu=gpu_spec['modal_gpu'],  # Use the user-selected GPU type and count
+        volumes=volumes_config if volumes_config else None,
+    )(ssh_container_function)
+    
+    # Run the container
+    try:
+        print("⏳ Starting container... This may take 1-2 minutes...")
+        
+        # Start the container and wait for it to complete (blocking)
+        with modal.enable_output():
+            with app.run():
+                # Get the API key from environment
+                openai_api_key = os.environ.get("OPENAI_API_KEY")
+                anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                
+                # Get stored credentials from local file
+                stored_credentials = get_stored_credentials()
+                if stored_credentials:
+                    print(f"🔐 Found {len(stored_credentials)} stored credentials to send to container")
+                else:
+                    print("⚠️ No stored credentials found")
+                
+                # Use spawn() to get a FunctionCall handle, then wait for it
+                print("🚀 Spawning SSH container...")
+                try:
+                    function_call = decorated_ssh_function.spawn(ssh_password, repo_url, repo_name, setup_commands, openai_api_key, anthropic_api_key, stored_credentials)
+                    print(f"✅ Container spawned with call ID: {function_call.object_id}")
+                    print(f"🔍 Function call status: {function_call}")
+                except Exception as spawn_error:
+                    print(f"❌ Error during spawn: {spawn_error}")
+                    raise
+                
+                try:
+                    # Wait for the function to start and print connection info (with timeout)
+                    print("⏳ Waiting for container to initialize...")
+                    try:
+                        print("\n⏳ Monitoring container (press Ctrl+C to stop monitoring)...")
+                        result = function_call.get()  # Wait indefinitely
+                        print(f"🔚 Container function completed with result: {result}")
+                    except KeyboardInterrupt:
+                        print("\n🛑 Stopped monitoring. Container is still running remotely.")
+                        print("💡 Use Modal's web UI or CLI to stop the container when done.")
+                        print("🔒 Keeping tokens active since container is still running.")
+                        return {
+                            "app_name": app_name,
+                            "ssh_password": ssh_password,
+                            "volume_name": volume_name,
+                            "status": "monitoring_stopped",
+                            "function_call_id": function_call.object_id
+                        }
+                             
+                except KeyboardInterrupt:
+                    print("\n🛑 Interrupted by user. Container may still be running remotely.")
+                    print("💡 Use Modal's web UI or CLI to check running containers.")
+                    print("🔒 Keeping tokens active since container may still be running.")
+                    return {
+                        "app_name": app_name,
+                        "ssh_password": ssh_password,
+                        "volume_name": volume_name,
+                        "status": "interrupted",
+                        "function_call_id": function_call.object_id
+                    }
+                except Exception as e:
+                    print(f"⚠️ Container execution error: {e}")
+                    print("💡 Container may still be accessible via SSH if it started successfully.")
+                    print("🧹 Cleaning up tokens due to execution error.")
+                    cleanup_modal_token()
+                    raise
+                
+        # Only clean up tokens if container actually completed normally
+        print("🧹 Container completed normally, cleaning up tokens.")
+        cleanup_modal_token()
+        
+        return {
+            "app_name": app_name,
+            "ssh_password": ssh_password,
+            "volume_name": volume_name
+        }
+    except Exception as e:
+        print(f"❌ Error running container: {e}")
+        return None
+
+
+def cleanup_security_tokens():
+    """Delete all security tokens and API keys after SSH container is started"""
+    print("🧹 Cleaning up security tokens and API keys...")
+    
+    try:
+        # Remove Modal tokens from environment variables
+        modal_env_vars = ["MODAL_TOKEN_ID", "MODAL_TOKEN", "MODAL_TOKEN_SECRET"]
+        for var in modal_env_vars:
+            if var in os.environ:
+                del os.environ[var]
+        
+        # Remove OpenAI API key from environment
+        if "OPENAI_API_KEY" in os.environ:
+            del os.environ["OPENAI_API_KEY"]
+        
+        # Delete ~/.modal.toml file
+        home_dir = os.path.expanduser("~")
+        modal_toml = os.path.join(home_dir, ".modal.toml")
+        if os.path.exists(modal_toml):
+            os.remove(modal_toml)
+        
+        # Delete ~/.gitarsenal/openai_key file
+        openai_key_file = os.path.join(home_dir, ".gitarsenal", "openai_key")
+        if os.path.exists(openai_key_file):
+            os.remove(openai_key_file)
+        
+    except Exception as e:
+        print(f"❌ Error during security cleanup: {e}")
+
+# Keep the old function for backward compatibility
+def cleanup_modal_token():
+    """Legacy function - now calls the comprehensive cleanup"""
+    cleanup_security_tokens()
+
+
+def show_usage_examples():
+    """Display usage examples for the script."""
+    print("Usage Examples\n")
+    
+    print("🔐 Authentication Commands")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --register                    # Register new account                  │")
+    print("│ gitarsenal --login                        # Login to existing account            │")
+    print("│ gitarsenal --logout                       # Logout from account                  │")
+    print("│ gitarsenal --user-info                    # Show current user information       │")
+    print("│ gitarsenal --change-password              # Change password                     │")
+    print("│ gitarsenal --delete-account               # Delete account                      │")
+    print("│ gitarsenal --store-api-key openai        # Store OpenAI API key                │")
+    print("│ gitarsenal --auth                         # Interactive auth management         │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("Basic Container Creation with Agent")
+    print("┌────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo https://github.com/username/repo.git  │")
+    print("│ # Agent will intelligently clone and setup the repository  │")
+    print("└────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("With Persistent Storage")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo https://github.com/username/repo.git \\  │")
+    print("│   --volume-name my-persistent-volume                             │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("With Multiple GPUs")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A100-80GB --gpu-count 4 \\                       │")
+    print("│   --repo https://github.com/username/repo.git                │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("Intelligent Repository Setup (default)")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo https://github.com/username/repo.git             │")
+    print("│ # Agent analyzes repo and sets up environment automatically           │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("With Manual Setup Commands (Advanced)")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --setup-commands \"pip install torch\" \"python train.py\"     │")
+    print("│ # Only use when not providing --repo (bypasses Agent)            │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("Development Mode (Skip Authentication)")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --skip-auth --gpu A10G --repo-url https://github.com/username/repo.git │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("Available GPU Options:")
+    print("  T4, L4, A10G, A100-40GB, A100-80GB, L40S, H100, H200, B200")
+    print("  Use --gpu-count to specify multiple GPUs (1-8)")
+    print()
+    print("Authentication Behavior:")
+    print("  • First time: Interactive registration/login required")
+    print("  • Subsequent runs: Automatic login with stored session")
+    print("  • Use --skip-auth for development (bypasses auth)")
+    print()
+    print("GPU Selection Behavior:")
+    print("  • With --gpu: Uses specified GPU without prompting")
+    print("  • Without --gpu: Shows interactive GPU selection menu")
+    print()
+    print("Repository Setup Behavior:")
+    print("  • With --repo Agent intelligently clones and sets up repository")
+    print("  • Without --repo: Manual container setup (no automatic repository setup)")
+    print("  • Legacy --setup-commands: Only used when --repo not provided")
+    print()
+    print("Examples:")
+    print("  # Intelligent repository setup (recommended):")
+    print("  gitarsenal --gpu A10G --repo https://github.com/username/repo.git")
+    print()
+    print("  # Development mode (skip authentication):")
+    print("  gitarsenal --skip-auth --gpu A10G --repo https://github.com/username/repo.git")
+    print()
+    print("  # Manual setup (advanced users):")
+    print("  gitarsenal --gpu A10G --setup-commands \"pip install torch\" \"python train.py\"")
+
+
+def _check_authentication(auth_manager):
+    """Check if user is authenticated, prompt for login if not"""
+    if auth_manager.is_authenticated():
+        user = auth_manager.get_current_user()
+        print(f"✅ Authenticated as: {user['username']}")
+        return True
+    
+    print("\n🔐 Authentication required")
+    return auth_manager.interactive_auth_flow()
+
+
+def _handle_auth_commands(auth_manager, args):
+    """Handle authentication-related commands"""
+    if args.login:
+        print("\n🔐 LOGIN")
+        username = input("Username: ").strip()
+        password = getpass.getpass("Password: ").strip()
+        if auth_manager.login_user(username, password):
+            print("✅ Login successful!")
+        else:
+            print("❌ Login failed.")
+    
+    elif args.register:
+        print("\n🔐 REGISTRATION")
+        username = input("Username (min 3 characters): ").strip()
+        email = input("Email: ").strip()
+        password = getpass.getpass("Password (min 8 characters): ").strip()
+        confirm_password = getpass.getpass("Confirm password: ").strip()
+        
+        if password != confirm_password:
+            print("❌ Passwords do not match.")
+            return
+        
+        if auth_manager.register_user(username, email, password):
+            print("✅ Registration successful!")
+            # Auto-login after registration
+            if auth_manager.login_user(username, password):
+                print("✅ Auto-login successful!")
+        else:
+            print("❌ Registration failed.")
+    
+    elif args.logout:
+        auth_manager.logout_user()
+    
+    elif args.user_info:
+        auth_manager.show_user_info()
+    
+    elif args.change_password:
+        if not auth_manager.is_authenticated():
+            print("❌ Not logged in. Please login first.")
+            return
+        
+        current_password = getpass.getpass("Current password: ").strip()
+        new_password = getpass.getpass("New password (min 8 characters): ").strip()
+        confirm_password = getpass.getpass("Confirm new password: ").strip()
+        
+        if new_password != confirm_password:
+            print("❌ New passwords do not match.")
+            return
+        
+        if auth_manager.change_password(current_password, new_password):
+            print("✅ Password changed successfully!")
+        else:
+            print("❌ Failed to change password.")
+    
+    elif args.delete_account:
+        if not auth_manager.is_authenticated():
+            print("❌ Not logged in. Please login first.")
+            return
+        
+        password = getpass.getpass("Enter your password to confirm deletion: ").strip()
+        if auth_manager.delete_account(password):
+            print("✅ Account deleted successfully!")
+        else:
+            print("❌ Failed to delete account.")
+    
+    elif args.store_api_key:
+        if not auth_manager.is_authenticated():
+            print("❌ Not logged in. Please login first.")
+            return
+        
+        service = args.store_api_key
+        api_key = getpass.getpass(f"Enter {service} API key: ").strip()
+        
+        if auth_manager.store_api_key(service, api_key):
+            print(f"✅ {service} API key stored successfully!")
+        else:
+            print(f"❌ Failed to store {service} API key.")
+    
+    elif args.auth:
+        # Interactive authentication management
+        while True:
+            print("\n" + "="*60)
+            print("🔐 AUTHENTICATION MANAGEMENT")
+            print("="*60)
+            print("1. Login")
+            print("2. Register")
+            print("3. Show user info")
+            print("4. Change password")
+            print("5. Store API key")
+            print("6. Delete account")
+            print("7. Logout")
+            print("8. Exit")
+            
+            choice = input("\nSelect an option (1-8): ").strip()
+            
+            if choice == "1":
+                username = input("Username: ").strip()
+                password = getpass.getpass("Password: ").strip()
+                auth_manager.login_user(username, password)
+            elif choice == "2":
+                username = input("Username (min 3 characters): ").strip()
+                email = input("Email: ").strip()
+                password = getpass.getpass("Password (min 8 characters): ").strip()
+                confirm_password = getpass.getpass("Confirm password: ").strip()
+                if password == confirm_password:
+                    auth_manager.register_user(username, email, password)
+                else:
+                    print("❌ Passwords do not match.")
+            elif choice == "3":
+                auth_manager.show_user_info()
+            elif choice == "4":
+                if auth_manager.is_authenticated():
+                    current_password = getpass.getpass("Current password: ").strip()
+                    new_password = getpass.getpass("New password (min 8 characters): ").strip()
+                    confirm_password = getpass.getpass("Confirm new password: ").strip()
+                    if new_password == confirm_password:
+                        auth_manager.change_password(current_password, new_password)
+                    else:
+                        print("❌ New passwords do not match.")
+                else:
+                    print("❌ Not logged in.")
+            elif choice == "5":
+                if auth_manager.is_authenticated():
+                    service = input("Service name (e.g., openai, modal): ").strip()
+                    api_key = getpass.getpass(f"Enter {service} API key: ").strip()
+                    auth_manager.store_api_key(service, api_key)
+                else:
+                    print("❌ Not logged in.")
+            elif choice == "6":
+                if auth_manager.is_authenticated():
+                    password = getpass.getpass("Enter your password to confirm deletion: ").strip()
+                    auth_manager.delete_account(password)
+                else:
+                    print("❌ Not logged in.")
+            elif choice == "7":
+                auth_manager.logout_user()
+            elif choice == "8":
+                print("👋 Goodbye!")
+                break
+            else:
+                print("❌ Invalid option. Please try again.")
+
+# Replace the existing GPU argument parsing in the main section
+if __name__ == "__main__":
+    # Parse command line arguments when script is run directly
+    import argparse
+    import sys
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--repo-name', type=str, help='Repository name override')
+    parser.add_argument('--setup-commands', type=str, nargs='+', help='Setup commands to run (deprecated)')
+    parser.add_argument('--setup-commands-json', type=str, help='Setup commands as JSON array')
+    parser.add_argument('--commands-file', type=str, help='Path to file containing setup commands (one per line)')
+    parser.add_argument('--setup-script', type=str, help='Path to bash script containing setup commands')
+    parser.add_argument('--working-dir', type=str, help='Working directory for the setup script')
+    parser.add_argument('--volume-name', type=str, help='Name of the Modal volume for persistent storage')
+    parser.add_argument('--timeout', type=int, default=60, help='Container timeout in minutes (default: 60)')
+    parser.add_argument('--ssh-password', type=str, help='SSH password (random if not provided)')
+    parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
+    parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
+    parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
+    parser.add_argument('--yes', action='store_true', help='Automatically confirm prompts (non-interactive)')
+
+    parser.add_argument('--gpu', default='A10G', help='GPU type to use')
+    parser.add_argument('--gpu-count', type=int, default=None, help='Number of GPUs to use (default: 1)')
+    parser.add_argument('--repo-url', help='Repository URL')
+    
+    # Authentication-related arguments
+    parser.add_argument('--auth', action='store_true', help='Manage authentication (login, register, logout)')
+    parser.add_argument('--login', action='store_true', help='Login to GitArsenal')
+    parser.add_argument('--register', action='store_true', help='Register new account')
+    parser.add_argument('--logout', action='store_true', help='Logout from GitArsenal')
+    parser.add_argument('--user-info', action='store_true', help='Show current user information')
+    parser.add_argument('--change-password', action='store_true', help='Change password')
+    parser.add_argument('--delete-account', action='store_true', help='Delete account')
+    parser.add_argument('--store-api-key', type=str, help='Store API key for a service (e.g., openai, modal)')
+    parser.add_argument('--skip-auth', action='store_true', help='Skip authentication check (for development)')
+    
+    # User credential arguments (passed from JavaScript CLI)
+    parser.add_argument('--user-id', type=str, help='User email address (passed from JavaScript CLI)')
+    parser.add_argument('--user-name', type=str, help='Username (passed from JavaScript CLI)')
+    parser.add_argument('--display-name', type=str, help='Display name (passed from JavaScript CLI)')
+    
+    # Analysis data argument (passed from JavaScript CLI)
+    parser.add_argument('--analysis-data', type=str, help='Repository analysis data as JSON string (from best_gpu endpoint)')
+    
+    args = parser.parse_args()
+    
+    # Initialize tokens (import here to avoid container import issues)
+    from fetch_modal_tokens import get_tokens
+    token_id, token_secret, openai_api_key, anthropic_api_key, openrouter_api_key, groq_api_key = get_tokens()
+
+    # Check if we got valid tokens
+    if token_id is None or token_secret is None:
+        raise ValueError("Could not get valid tokens")
+
+    # Explicitly set the environment variables again to be sure
+    os.environ["MODAL_TOKEN_ID"] = token_id
+    os.environ["MODAL_TOKEN_SECRET"] = token_secret
+    if openai_api_key:
+        os.environ["OPENAI_API_KEY"] = openai_api_key
+    if anthropic_api_key:
+        os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
+    # Also set the old environment variable for backward compatibility
+    os.environ["MODAL_TOKEN"] = token_id
+
+    # Set token variables for later use
+    token = token_id  # For backward compatibility
+    
+    # Initialize authentication manager (import here to avoid container import issues)
+    from auth_manager import AuthManager
+    auth_manager = AuthManager()
+    
+    # Handle authentication-related commands
+    if args.auth or args.login or args.register or args.logout or args.user_info or args.change_password or args.delete_account or args.store_api_key:
+        _handle_auth_commands(auth_manager, args)
+        sys.exit(0)
+    
+    # If --list-gpus is specified, just show GPU options and exit
+    if args.list_gpus:
+        print("\n📊 Available GPU Options:")
+        print("┌──────────────┬─────────┐")
+        print("│   GPU Type   │  VRAM   │")
+        print("├──────────────┼─────────┤")
+        print("│ 1. T4        │ 16GB    │")
+        print("│ 2. L4        │ 24GB    │")
+        print("│ 3. A10G      │ 24GB    │")
+        print("│ 4. A100-40   │ 40GB    │")
+        print("│ 5. A100-80   │ 80GB    │")
+        print("│ 6. L40S      │ 48GB    │")
+        print("│ 7. H100      │ 80GB    │")
+        print("│ 8. H200      │ 141GB   │")
+        print("│ 9. B200      │ 141GB   │")
+        print("└──────────────┴─────────┘")
+        print("Use --gpu <type> to specify a GPU type")
+        print("Use --gpu-count <number> to specify multiple GPUs (1-8)")
+        print("\nExample: --gpu A100-80GB --gpu-count 4 (for 4x A100-80GB GPUs)")
+        sys.exit(0)
+    
+    # If no arguments or only --show-examples is provided, show usage examples
+    if len(sys.argv) == 1 or args.show_examples:
+        show_usage_examples()
+        sys.exit(0)
+    
+    # Authentication is handled by the JavaScript CLI when credentials are passed
+    if args.user_id and args.user_name and args.display_name:
+        print(f"✅ Authenticated as: {args.display_name} ({args.user_id})")
+    elif not args.skip_auth:
+        # Only perform authentication check if running Python script directly (not from CLI)
+        if not _check_authentication(auth_manager):
+            print("\n❌ Authentication required. Please login or register first.")
+            print("Use --login to login or --register to create an account.")
+            sys.exit(1)
+    
+    # Check for dependencies
+    print("⠏ Checking dependencies...")
+    print("--- Dependency Check ---")
+    
+    # Check Python version
+    python_version = sys.version.split()[0]
+    print(f"✓ Python {python_version} found")
+    
+    # Check Modal CLI
+    try:
+        subprocess.run(["modal", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Modal CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Modal CLI not found. Please install with: pip install modal")
+    
+    # Check Gitingest CLI
+    try:
+        subprocess.run(["gitingest", "--help"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Gitingest CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("⚠️ Gitingest CLI not found (optional)")
+    
+    # Check Git
+    try:
+        subprocess.run(["git", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Git found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Git not found. Please install Git.")
+    
+    print("------------------------")
+    print("\n✔ Dependencies checked")
+    
+    # Use provided GPU argument or prompt for selection
+    if args.gpu:
+        gpu_type = args.gpu
+        # Validate the provided GPU type
+        valid_gpus = ['T4', 'L4', 'A10G', 'A100-40GB', 'A100-80GB', 'L40S', 'H100', 'H200', 'B200']
+        if gpu_type not in valid_gpus:
+            print(f"⚠️ Warning: '{gpu_type}' is not in the list of known GPU types.")
+            print(f"Available GPU types: {', '.join(valid_gpus)}")
+            print(f"Proceeding with '{gpu_type}' anyway...")
+        else:
+            print(f"✅ Using specified GPU: {gpu_type}")
+    else:
+        print("\n📋 No GPU type specified with --gpu flag.")
+        print("🔄 Using default GPU type: A10G")
+        gpu_type = "A10G"
+        args.gpu = gpu_type
+    
+    # Parse analysis data if provided
+    analysis_data = None
+    if args.analysis_data:
+        print("🔍 Parsing repository analysis data...")
+        analysis_data = parse_analysis_data(args.analysis_data)
+        if analysis_data:
+            print("✅ Analysis data parsed successfully")
+        else:
+            print("⚠️ Failed to parse analysis data, proceeding without it")
+    else:
+        print("ℹ️ No analysis data provided")
+    
+    # Display configuration after GPU selection
+    print("\n📋 Container Configuration:")
+    print(f"Repository URL: {args.repo_url or 'Not specified'}")
+    gpu_count = args.gpu_count if args.gpu_count is not None else 1
+    if gpu_count > 1:
+        print(f"GPU Type: {gpu_count}x {gpu_type}")
+    else:
+        print(f"GPU Type: {gpu_type}")
+    print(f"Volume: {args.volume_name or 'None'}")
+    if args.repo_url:
+        print("Repository Setup: Agent (intelligent)")
+    elif args.setup_commands:
+        print(f"Setup Commands: {len(args.setup_commands)} custom commands")
+    else:
+        print("Setup Commands: None")
+    
+    # Confirm settings (skip if --yes specified)
+    if not getattr(args, 'yes', False):
+        try:
+            proceed = input("Proceed with these settings? (Y/n): ").strip().lower()
+            if proceed in ('n', 'no'):
+                print("🛑 Operation cancelled by user.")
+                sys.exit(0)
+        except KeyboardInterrupt:
+            print("\n🛑 Operation cancelled by user.")
+            sys.exit(0)
+    else:
+        print("")
+    
+    # Interactive mode or missing required arguments
+    if args.interactive or not args.repo_url or not args.volume_name:
+        # Get repository URL if not provided
+        repo_url = args.repo_url
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    sys.exit(1)
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Ask about persistent volume
+        volume_name = args.volume_name
+        if not volume_name:
+            try:
+                use_volume = input("? Use persistent volume for faster installs? (Y/n): ").strip().lower()
+                if use_volume in ('', 'y', 'yes'):
+                    volume_name = input("? Enter volume name: ").strip()
+                    if not volume_name:
+                        volume_name = "gitarsenal-volume"
+                        print(f"Using default volume name: {volume_name}")
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Ask about GPU count if not specified
+        gpu_count = getattr(args, 'gpu_count', None)
+        if gpu_count is None:
+            try:
+                gpu_count_input = input("? How many GPUs do you need? (1-8, default: 1): ").strip()
+                if gpu_count_input:
+                    try:
+                        gpu_count = int(gpu_count_input)
+                        if gpu_count < 1 or gpu_count > 8:
+                            print("⚠️ GPU count must be between 1 and 8. Using default: 1")
+                            gpu_count = 1
+                    except ValueError:
+                        print("⚠️ Invalid GPU count. Using default: 1")
+                        gpu_count = 1
+                else:
+                    # User pressed enter without input, use default
+                    gpu_count = 1
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
+        
+        # Update args with interactive values
+        args.repo_url = repo_url
+        args.volume_name = volume_name
+        args.gpu_count = gpu_count
+    
+    try:    
+        # Setup commands are no longer used when repo_url is provided (Agent handles setup)
+        setup_commands = args.setup_commands or []
+        
+        # Repository setup approach
+        if args.repo_url:
+            print("🤖 Repository setup will be handled by Agent in container")
+            setup_commands = []  # Agent will handle setup intelligently
+        else:
+            print("⚠️ No repository URL provided - setup commands may be needed manually")
+            
+        # Parse setup commands from JSON if provided
+        if args.setup_commands_json:
+            try:
+                json_commands = json.loads(args.setup_commands_json)
+                if isinstance(json_commands, list):
+                    setup_commands = json_commands
+                    print(f"📋 Parsed {len(setup_commands)} commands from JSON:")
+                    for i, cmd in enumerate(setup_commands, 1):
+                        print(f"  {i}. {cmd}")
+                else:
+                    print(f"⚠️ Invalid JSON format for setup commands: not a list")
+            except json.JSONDecodeError as e:
+                print(f"⚠️ Error parsing JSON setup commands: {e}")
+                print(f"Received JSON string: {args.setup_commands_json}")
+        
+        # Load commands from file if specified
+        if args.commands_file and os.path.exists(args.commands_file):
+            try:
+                with open(args.commands_file, 'r') as f:
+                    # Check if the file contains JSON or line-by-line commands
+                    content = f.read().strip()
+                    
+                    if content.startswith('[') and content.endswith(']'):
+                        # JSON format
+                        try:
+                            json_commands = json.loads(content)
+                            if isinstance(json_commands, list):
+                                setup_commands.extend(json_commands)
+                                print(f"📋 Loaded {len(json_commands)} commands from JSON file {args.commands_file}")
+                            else:
+                                print(f"⚠️ Invalid JSON format in commands file: not a list")
+                        except json.JSONDecodeError as json_err:
+                            print(f"⚠️ Error parsing JSON commands file: {json_err}")
+                            # Fall back to line-by-line parsing
+                            file_commands = [line.strip() for line in content.split('\n') if line.strip()]
+                            setup_commands.extend(file_commands)
+                            print(f"📋 Loaded {len(file_commands)} commands from file (line-by-line fallback)")
+                    else:
+                        # Line-by-line format
+                        file_commands = [line.strip() for line in content.split('\n') if line.strip()]
+                        setup_commands.extend(file_commands)
+                        print(f"📋 Loaded {len(file_commands)} commands from file (line-by-line format)")
+            except Exception as e:
+                print(f"⚠️ Error loading commands from file: {e}")
+        
+        # Load commands from setup script if specified
+        if args.setup_script and os.path.exists(args.setup_script):
+            try:
+                with open(args.setup_script, 'r') as f:
+                    script_content = f.read().strip()
+                    # Convert script to individual commands
+                    script_commands = [line.strip() for line in script_content.split('\n') 
+                                    if line.strip() and not line.strip().startswith('#')]
+                    setup_commands.extend(script_commands)
+                    print(f"📋 Loaded {len(script_commands)} commands from script {args.setup_script}")
+            except Exception as e:
+                print(f"⚠️ Error loading commands from script: {e}")
+        
+        # Create the container with the specified options
+        if args.ssh_password:
+            print(f"🔑 Using provided SSH password")
+            ssh_password = args.ssh_password
+        else:
+            ssh_password = generate_random_password()
+            print(f"🔑 Generated random SSH password: {ssh_password}")
+        
+        # Extract repository name from URL if not provided
+        repo_name = args.repo_name
+        if not repo_name and args.repo_url:
+            # Try to extract repo name from URL
+            url_parts = args.repo_url.rstrip('/').split('/')
+            if url_parts:
+                repo_name = url_parts[-1]
+                if repo_name.endswith('.git'):
+                    repo_name = repo_name[:-4]
+        
+        # Create the container
+        result = create_modal_ssh_container(
+            gpu_type=args.gpu,
+            repo_url=args.repo_url,
+            repo_name=repo_name,
+            setup_commands=setup_commands,
+            volume_name=args.volume_name,
+            timeout_minutes=args.timeout,
+            ssh_password=ssh_password,
+            interactive=args.interactive,
+            gpu_count=args.gpu_count if args.gpu_count is not None else 1,
+            analysis_data=analysis_data,  # Pass parsed analysis_data instead of raw args.analysis_data
+        )
+        
+        if result:
+            print(f"\n✅ Container operation completed: {result.get('status', 'success')}")
+            if result.get('function_call_id'):
+                print(f"🆔 Function Call ID: {result['function_call_id']}")
+                print("💡 You can use this ID to check container status via Modal CLI")
+        else:
+            print("\n❌ Container creation failed")
+            
+    except KeyboardInterrupt:
+        print("\n🛑 Operation cancelled by user")
+        cleanup_modal_token()
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")
+        print("📋 Error details:")
+        import traceback
+        traceback.print_exc()
+        cleanup_modal_token()
+        sys.exit(1)