gitarsenal-cli 1.0.2 → 1.0.5

package/test_modalSandboxScript.py

@@ -0,0 +1,2354 @@
+import os
+import sys
+import modal
+import time
+import subprocess
+import json
+import re
+import datetime
+import getpass
+import requests
+
+def handle_interactive_input(prompt, is_password=False):
+    """Handle interactive input from the user with optional password masking"""
+    print("\n" + "="*60)
+    print(f"{prompt}")
+    print("="*60)
+    
+    try:
+        if is_password:
+            user_input = getpass.getpass("Input (hidden): ").strip()
+        else:
+            user_input = input("Input: ").strip()
+            
+        if not user_input:
+            print("❌ No input provided.")
+            return None
+        print("✅ Input received successfully!")
+        return user_input
+    except KeyboardInterrupt:
+        print("\n❌ Input cancelled by user.")
+        return None
+    except Exception as e:
+        print(f"❌ Error getting input: {e}")
+        return None
+
+def handle_wandb_login(sandbox, current_dir):
+    """Handle Weights & Biases login with proper API key input"""
+    # Define _to_str function locally to avoid NameError
+    def _to_str(maybe_bytes):
+        try:
+            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
+        except UnicodeDecodeError:
+            # Handle non-UTF-8 bytes by replacing invalid characters
+            if isinstance(maybe_bytes, (bytes, bytearray)):
+                return maybe_bytes.decode('utf-8', errors='replace')
+            else:
+                return str(maybe_bytes)
+        except Exception:
+            # Last resort fallback
+            return str(maybe_bytes)
+            
+    print("\n🔑 WEIGHTS & BIASES LOGIN")
+    print("="*60)
+    print("Setting up Weights & Biases credentials")
+    print("You can get your API key from: https://wandb.ai/authorize")
+    
+    # Get API key from user
+    api_key = handle_interactive_input(
+        "🔑 WEIGHTS & BIASES API KEY REQUIRED\n" +
+        "Please paste your W&B API key below:\n" +
+        "(Your API key should be 40 characters long)",
+        is_password=True
+    )
+    
+    if not api_key:
+        print("❌ No API key provided. Cannot continue with W&B login.")
+        return False, "", "No W&B API key provided"
+    
+    # Validate API key length
+    if len(api_key) != 40:
+        print(f"⚠️ Warning: API key should be 40 characters long, yours was {len(api_key)}")
+        confirm = handle_interactive_input("Continue anyway? (yes/no)")
+        if not confirm or confirm.lower() not in ["yes", "y"]:
+            print("❌ W&B login cancelled.")
+            return False, "", "W&B login cancelled"
+    
+    # Use non-interactive login
+    cmd = f"wandb login {api_key}"
+    print(f"🔄 Running non-interactive login command")
+    
+    # Execute the command
+    result = sandbox.exec("bash", "-c", f"cd {current_dir} && {cmd}")
+    
+    # Collect output
+    stdout_lines = []
+    stderr_lines = []
+    
+    for line in result.stdout:
+        line_str = _to_str(line)
+        stdout_lines.append(line_str)
+        sys.stdout.write(line_str)
+        sys.stdout.flush()
+    
+    for line in result.stderr:
+        line_str = _to_str(line)
+        stderr_lines.append(line_str)
+        sys.stderr.write(line_str)
+        sys.stderr.flush()
+    
+    result.wait()
+    exit_code = result.returncode
+    
+    stdout_buffer = ''.join(stdout_lines)
+    stderr_buffer = ''.join(stderr_lines)
+    
+    if exit_code == 0:
+        print("✅ Weights & Biases login successful")
+        # Also set the environment variable for this session
+        os.environ["WANDB_API_KEY"] = api_key
+        print("✅ WANDB_API_KEY environment variable set")
+    else:
+        print(f"❌ Weights & Biases login failed with exit code {exit_code}")
+        if stderr_buffer:
+            print(f"Error: {stderr_buffer}")
+    
+    return exit_code == 0, stdout_buffer, stderr_buffer
+
+def handle_huggingface_login(sandbox, current_dir):
+    """Handle Hugging Face login with proper token input"""
+    # Define _to_str function locally to avoid NameError
+    def _to_str(maybe_bytes):
+        try:
+            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
+        except UnicodeDecodeError:
+            # Handle non-UTF-8 bytes by replacing invalid characters
+            if isinstance(maybe_bytes, (bytes, bytearray)):
+                return maybe_bytes.decode('utf-8', errors='replace')
+            else:
+                return str(maybe_bytes)
+        except Exception:
+            # Last resort fallback
+            return str(maybe_bytes)
+            
+    print("\n🔑 HUGGING FACE LOGIN")
+    print("="*60)
+    print("Setting up Hugging Face credentials")
+    
+    # Get token from user
+    token = prompt_for_hf_token()
+    if not token:
+        print("❌ No token provided. Cannot continue with Hugging Face login.")
+        return False, "", "No Hugging Face token provided"
+    
+    # Use non-interactive login
+    cmd = f"huggingface-cli login --token {token} --add-to-git-credential"
+    print(f"🔄 Running non-interactive login command")
+    
+    # Execute the command
+    result = sandbox.exec("bash", "-c", f"cd {current_dir} && {cmd}")
+    
+    # Collect output
+    stdout_lines = []
+    stderr_lines = []
+    
+    for line in result.stdout:
+        line_str = _to_str(line)
+        stdout_lines.append(line_str)
+        sys.stdout.write(line_str)
+        sys.stdout.flush()
+    
+    for line in result.stderr:
+        line_str = _to_str(line)
+        stderr_lines.append(line_str)
+        sys.stderr.write(line_str)
+        sys.stderr.flush()
+    
+    result.wait()
+    exit_code = result.returncode
+    
+    stdout_buffer = ''.join(stdout_lines)
+    stderr_buffer = ''.join(stderr_lines)
+    
+    if exit_code == 0:
+        print("✅ Hugging Face login successful")
+        # Also set the environment variable for this session
+        os.environ["HF_TOKEN"] = token
+        print("✅ HF_TOKEN environment variable set")
+    else:
+        print(f"❌ Hugging Face login failed with exit code {exit_code}")
+        if stderr_buffer:
+            print(f"Error: {stderr_buffer}")
+    
+    return exit_code == 0, stdout_buffer, stderr_buffer
+
+def handle_interactive_command(cmd, sandbox, current_dir):
+    """Handle interactive commands by prompting the user for input"""
+    print(f"⚠️ Interactive command detected: {cmd}")
+    print("⚠️ Some prompts may not be visible. If the command appears stuck, it may be waiting for input.")
+    
+    # This is a placeholder for more sophisticated interactive command handling
+    # In a real implementation, you would need to handle specific interactive commands differently
+    return None
+
+def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Call OpenAI to debug a failed command and suggest a fix"""
+    # Define _to_str function locally to avoid NameError
+    def _to_str(maybe_bytes):
+        try:
+            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
+        except UnicodeDecodeError:
+            # Handle non-UTF-8 bytes by replacing invalid characters
+            if isinstance(maybe_bytes, (bytes, bytearray)):
+                return maybe_bytes.decode('utf-8', errors='replace')
+            else:
+                return str(maybe_bytes)
+        except Exception:
+            # Last resort fallback
+            return str(maybe_bytes)
+            
+    # Skip debugging for certain commands that commonly return non-zero exit codes
+    # but aren't actually errors (like test commands)
+    if command.strip().startswith("test "):
+        print("🔍 Skipping debugging for test command - non-zero exit code is expected behavior")
+        return None
+        
+    # Validate error_output - if it's empty, we can't debug effectively
+    if not error_output or not error_output.strip():
+        print("⚠️ Error output is empty. Cannot effectively debug the command.")
+        print("⚠️ Skipping OpenAI debugging due to lack of error information.")
+        return None
+        
+    if not api_key:
+        # Try to get API key from environment
+        api_key = os.environ.get("OPENAI_API_KEY")
+        
+    if not api_key:
+        print("\n" + "="*60)
+        print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
+        print("="*60)
+        print("To debug failed commands, an OpenAI API key is needed.")
+        print("📝 Please paste your OpenAI API key below:")
+        print("   (Your input will be hidden for security)")
+        print("-" * 60)
+        
+        try:
+            api_key = getpass.getpass("OpenAI API Key: ").strip()
+            if not api_key:
+                print("❌ No API key provided. Skipping debugging.")
+                return None
+            print("✅ API key received successfully!")
+        except KeyboardInterrupt:
+            print("\n❌ API key input cancelled by user.")
+            return None
+        except Exception as e:
+            print(f"❌ Error getting API key: {e}")
+            return None
+    
+    # Get current directory context
+    directory_context = ""
+    system_info = ""
+    
+    if sandbox:
+        try:
+            print("🔍 Getting system information for better debugging...")
+            
+            # Get OS information
+            os_info_cmd = """
+            echo "OS Information:"
+            cat /etc/os-release 2>/dev/null || echo "OS release info not available"
+            echo -e "\nKernel Information:"
+            uname -a
+            echo -e "\nPython Information:"
+            python --version
+            echo -e "\nPackage Manager:"
+            which apt 2>/dev/null && echo "apt available" || echo "apt not available"
+            which yum 2>/dev/null && echo "yum available" || echo "yum not available"
+            which dnf 2>/dev/null && echo "dnf available" || echo "dnf not available"
+            which apk 2>/dev/null && echo "apk available" || echo "apk not available"
+            echo -e "\nEnvironment Variables:"
+            env | grep -E "^(PATH|PYTHON|VIRTUAL_ENV|HOME|USER|SHELL|LANG)" || echo "No relevant env vars found"
+            """
+            
+            os_result = sandbox.exec("bash", "-c", os_info_cmd)
+            os_output = ""
+            for line in os_result.stdout:
+                os_output += _to_str(line)
+            os_result.wait()
+            
+            system_info = f"""
+System Information:
+{os_output}
+"""
+            print("✅ System information gathered successfully")
+        except Exception as e:
+            print(f"⚠️ Error getting system information: {e}")
+            system_info = "System information not available\n"
+    
+    if current_dir and sandbox:
+        try:
+            print("🔍 Getting directory context for better debugging...")
+            
+            # Get current directory contents
+            ls_result = sandbox.exec("bash", "-c", f"cd {current_dir} && ls -la")
+            ls_output = ""
+            for line in ls_result.stdout:
+                ls_output += _to_str(line)
+            ls_result.wait()
+            
+            # Get parent directory contents if this isn't root
+            parent_context = ""
+            if current_dir != "/" and "/" in current_dir:
+                parent_dir = os.path.dirname(current_dir)
+                parent_result = sandbox.exec("bash", "-c", f"cd {parent_dir} && ls -la")
+                parent_ls = ""
+                for line in parent_result.stdout:
+                    parent_ls += _to_str(line)
+                parent_result.wait()
+                parent_context = f"\nParent directory ({parent_dir}) contents:\n{parent_ls}"
+            
+            directory_context = f"""
+Current directory: {current_dir}
+
+Directory contents:
+{ls_output}
+{parent_context}
+"""
+            print("✅ Directory context gathered successfully")
+        except Exception as e:
+            print(f"⚠️ Error getting directory context: {e}")
+            directory_context = f"\nCurrent directory: {current_dir}\n"
+    
+    # Prepare the API request
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+    
+    # Create a prompt for the LLM
+    print("\n" + "="*60)
+    print("DEBUG: ERROR_OUTPUT SENT TO LLM:")
+    print("="*60)
+    print(f"{error_output}")
+    print("="*60 + "\n")
+    
+    prompt = f"""
+I'm trying to run the following command in a Linux environment:
+
+```
+{command}
+```
+
+But it failed with this error:
+
+```
+{error_output}
+```
+{system_info}
+{directory_context}
+Please analyze the error and provide ONLY a single terminal command that would fix the issue.
+Consider the current directory, system information, and directory contents carefully before suggesting a solution.
+
+IMPORTANT: For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
+- For apt/apt-get: use -y or --yes
+- For pip: use --no-input
+- For rm: use -f or --force
+- For other commands: check their documentation for the appropriate non-interactive flag
+
+Do not provide any explanations, just the exact command to run.
+"""
+    
+    # Prepare the API request payload
+    payload = {
+        "model": "gpt-4.1",
+        "messages": [
+            {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue, analyze the issue first understand why its happening and then provide the command to fix the issue. If you see missing pytest errors, suggest 'pip install pytest'. For wandb login issues, suggest 'wandb login YOUR_API_KEY' and the system will handle prompting for the actual key."},
+            {"role": "user", "content": prompt}
+        ],
+        "temperature": 0.2,
+        "max_tokens": 300
+    }
+    
+    try:
+        print("🤖 Calling OpenAI to debug the failed command...")
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            fix_command = result["choices"][0]["message"]["content"].strip()
+            
+            # Extract just the command if it's wrapped in backticks or explanation
+            if "```" in fix_command:
+                # Extract content between backticks
+                import re
+                code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
+                if code_blocks:
+                    fix_command = code_blocks[0].strip()
+            
+            # If the response still has explanatory text, try to extract just the command
+            if len(fix_command.split('\n')) > 1:
+                # Take the shortest non-empty line as it's likely the command
+                lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
+                if lines:
+                    fix_command = min(lines, key=len)
+            
+            print(f"🔧 Suggested fix: {fix_command}")
+            return fix_command
+        else:
+            print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
+            return None
+    except Exception as e:
+        print(f"❌ Error calling OpenAI API: {e}")
+        return None
+
+def prompt_for_hf_token():
+    """Prompt user for Hugging Face token when needed"""
+    print("\n" + "="*60)
+    print("🔑 HUGGING FACE TOKEN REQUIRED")
+    print("="*60)
+    print("The training script requires a valid Hugging Face token.")
+    print("You can get your token from: https://huggingface.co/settings/tokens")
+    print("📝 Please paste your Hugging Face token below:")
+    print("   (Your input will be hidden for security)")
+    print("-" * 60)
+    
+    try:
+        token = getpass.getpass("HF Token: ").strip()
+        if not token:
+            print("❌ No token provided.")
+            return None
+        print("✅ Token received successfully!")
+        return token
+    except KeyboardInterrupt:
+        print("\n❌ Token input cancelled by user.")
+        return None
+    except Exception as e:
+        print(f"❌ Error getting token: {e}")
+        return None
+
+def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands=None, volume_name=None):
+    # Execution history for tracking all commands and their results in this session
+    execution_history = []
+    
+    # Track session start time
+    session_start = datetime.datetime.now().isoformat()
+    
+    # Track previous errors to detect repeated failures
+    previous_errors = {}
+    
+    # Track Python version management
+    conda_installed = False
+    python_version_switched = False
+    current_python_version = None
+    
+    # Generate a unique app name with timestamp to avoid conflicts
+    timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+    app_name = f"sandbox-{timestamp}"
+    
+    gpu_configs = {
+        'A10G': {'gpu': 'A10G', 'memory': 24},
+        'A100': {'gpu': 'A100-SXM4-40GB', 'memory': 40},
+        'H100': {'gpu': 'H100', 'memory': 80},
+        'T4': {'gpu': 'T4', 'memory': 16},
+        'V100': {'gpu': 'V100-SXM2-16GB', 'memory': 16}
+    }
+    
+    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]
+    print(f"🚀 Creating Modal sandbox with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
+    
+    # Initialize uv_path variable
+    uv_path = ""
+    
+    # Setup volume if specified
+    volume = None
+    volume_mount_path = "/persistent"
+    
+    if volume_name:
+        print(f"📦 Setting up volume: {volume_name}")
+        try:
+            # Try to get existing volume or create new one
+            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"sandbox-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
+
+    # Enable output for image building
+    with modal.enable_output():
+        # Create a Modal app and sandbox
+        print(f"🚀 Creating Modal sandbox with GPU: {gpu_type.lower()} (App: {app_name})...")
+        # Always use lookup with create_if_missing=True to properly initialize the app
+        app = modal.App.lookup(app_name, create_if_missing=True)
+        print(f"Created app: {app_name}")
+        
+        # Create the sandbox with increased timeout for long-running operations
+        print("⏱️ Setting 30-minute timeout for long-running installations...")
+        
+        # Setup volume mount if available
+        volumes = {}
+        if volume:
+            volumes[volume_mount_path] = volume
+            print(f"📦 Mounting volume '{volume_name}' at {volume_mount_path}")
+        
+        cuda_image = modal.Image.from_registry("nvidia/cuda:12.8.1-devel-ubuntu24.04", add_python="3.12")
+
+        sandbox = modal.Sandbox.create(
+            "sleep", "infinity", 
+            app=app, 
+            gpu=gpu_type.lower(), 
+            image=cuda_image,
+            timeout=3600,  # 40 minutes instead of 15 minutes
+            volumes=volumes if volumes else None
+        )
+
+    # Get the sandbox ID for reference
+    sandbox_id = sandbox.object_id
+    print(f"📋 Sandbox ID: {sandbox_id}")
+
+    # Wait a moment for the container to be registered
+    print("⏳ Waiting for container to be registered...")
+    time.sleep(5)  # Increased wait time
+
+    # Function to extract container ID from text output
+    def extract_container_id_from_text(output):
+        print("Extracting container ID from text output...")
+        
+        # First, try to find lines with the app name
+        lines = output.split('\n')
+        app_lines = [line for line in lines if app_name in line]
+        
+        if app_lines:
+            # Get the first line with the app name
+            app_line = app_lines[0]
+            print(f"Found line with app name: {app_line}")
+            
+            # Try to extract the container ID
+            if '│' in app_line:
+                parts = app_line.split('│')
+                if len(parts) >= 2:
+                    container_id_part = parts[1].strip()
+                    if container_id_part.startswith('ta-'):
+                        return container_id_part
+        
+        # If that didn't work, try regex pattern matching
+        container_matches = re.findall(r'ta-[A-Z0-9]+', output)
+        if container_matches:
+            return container_matches[0]
+        
+        return None
+
+    # Get the container ID using multiple approaches
+    print("📋 Getting container ID...")
+    container_id = None
+
+    # Approach 1: Use modal container list --json
+    try:
+        print("Trying JSON approach...")
+        result = subprocess.run(["modal", "container", "list", "--json"], capture_output=True, text=True)
+        output = result.stdout
+        print(f"JSON output: {output}")
+        
+        import json
+        try:
+            containers = json.loads(output)
+            print(f"Parsed JSON: {containers}")
+            if containers and isinstance(containers, list) and len(containers) > 0:
+                # The container ID is in the "Container ID" field, not "id"
+                container_id = containers[0].get("Container ID")
+                if container_id:
+                    print(f"📋 Found container ID from JSON: {container_id}")
+                else:
+                    # Try lowercase keys as a fallback
+                    container_id = containers[0].get("container_id") or containers[0].get("container id")
+                    if container_id:
+                        print(f"📋 Found container ID from JSON with lowercase keys: {container_id}")
+        except json.JSONDecodeError as json_err:
+            print(f"JSON parse error: {json_err}")
+    except Exception as e:
+        print(f"Error with JSON approach: {e}")
+
+    # Approach 2: Use modal container list with text parsing
+    if not container_id:
+        try:
+            print("Trying text output approach...")
+            result = subprocess.run(["modal", "container", "list"], capture_output=True, text=True)
+            output = result.stdout
+            print("Modal container list output:")
+            print(output)
+            
+            container_id = extract_container_id_from_text(output)
+            if container_id:
+                print(f"📋 Found container ID from text: {container_id}")
+        except Exception as e:
+            print(f"Error with text approach: {e}")
+
+    # Approach 3: Use shell command to get first container
+    if not container_id:
+        try:
+            print("Trying shell command approach...")
+            cmd = "modal container list | grep -v Container | grep -v '─' | head -1 | awk '{print $1}'"
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            output = result.stdout.strip()
+            print(f"Shell command output: {output}")
+            
+            if output and output.startswith('ta-'):
+                container_id = output
+                print(f"📋 Found container ID from shell command: {container_id}")
+        except Exception as e:
+            print(f"Error with shell command approach: {e}")
+
+    # Approach 4: Get all containers and find the one with our app
+    if not container_id:
+        try:
+            print("Trying app matching approach...")
+            cmd = "modal container list"
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            output = result.stdout
+            
+            # Look for our app name in the output
+            if app_name in output:
+                print(f"Found {app_name} in container list")
+                # Try to get the container ID from the same line
+                lines = output.split('\n')
+                for line in lines:
+                    if app_name in line:
+                        print(f"Found line: {line}")
+                        # Try to extract the first column
+                        if '│' in line:
+                            container_id_part = line.split('│')[1].strip()
+                            if container_id_part.startswith('ta-'):
+                                container_id = container_id_part
+                                print(f"📋 Found container ID from app matching: {container_id}")
+                                break
+        except Exception as e:
+            print(f"Error with app matching approach: {e}")
+
+    # Final fallback: Use sandbox ID to create a container ID
+    if not container_id:
+        print("⚠️ All approaches failed to find container ID")
+        # Use sandbox ID as container prefix
+        short_id = sandbox_id.split('-')[1][:8] if '-' in sandbox_id else sandbox_id[:8]
+        container_id = f"ta-{short_id.upper()}"
+        print(f"📋 Using derived container ID: {container_id}")
+
+    # Ensure we have a non-None container ID
+    if not container_id:
+        print("⚠️ Critical error: Failed to determine container ID")
+        print("⚠️ Using a placeholder container ID")
+        container_id = "ta-UNKNOWN"
+
+    # Try to verify the container ID exists
+    print("🔍 Verifying container ID...")
+    verify_cmd = f"modal container logs {container_id} --tail 1 2>/dev/null || echo 'Container not found'"
+    verify_result = subprocess.run(verify_cmd, shell=True, capture_output=True, text=True)
+    if "Container not found" in verify_result.stdout:
+        print(f"⚠️ Container ID verification failed: {container_id}")
+        
+        # Last resort: Try to find any valid container
+        print("🔍 Looking for any valid container as last resort...")
+        list_cmd = "modal container list | grep -v Container | grep -v '─' | grep -v '┏' | grep -v '┃' | head -1"
+        list_result = subprocess.run(list_cmd, shell=True, capture_output=True, text=True)
+        if list_result.stdout.strip():
+            print(f"Found container line: {list_result.stdout.strip()}")
+            # Try to extract the ID from the first column
+            container_line = list_result.stdout.strip()
+            if '│' in container_line:
+                possible_id = container_line.split('│')[1].strip()
+                if possible_id.startswith('ta-'):
+                    container_id = possible_id
+                    print(f"📋 Using container ID from list as last resort: {container_id}")
+                    
+                    # Verify this container
+                    verify_cmd = f"modal container logs {container_id} --tail 1 2>/dev/null || echo 'Container not found'"
+                    verify_result = subprocess.run(verify_cmd, shell=True, capture_output=True, text=True)
+                    if "Container not found" not in verify_result.stdout:
+                        print(f"✅ Last resort container ID verified: {container_id}")
+                    else:
+                        print("⚠️ Last resort container ID also failed verification")
+            
+        print("⚠️ Container connection may fail. You may need to connect manually.")
+    else:
+        print(f"✅ Container ID verified: {container_id}")
+
+    # Function to convert bytes to string
+    def _to_str(maybe_bytes):
+        try:
+            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
+        except UnicodeDecodeError:
+            # Handle non-UTF-8 bytes by replacing invalid characters
+            if isinstance(maybe_bytes, (bytes, bytearray)):
+                return maybe_bytes.decode('utf-8', errors='replace')
+            else:
+                return str(maybe_bytes)
+        except Exception:
+            # Last resort fallback
+            return str(maybe_bytes)
+
+    # Skip the persistent shell approach for now due to async stream complexity
+    print("🔍 Modal's async streams require complex async handling")
+    print("🔄 Switching to individual command execution approach for reliability...")
+    
+    # Initialize state tracking variables
+    current_dir = "/"
+    execution_history = []
+    
+    # Function to run commands using individual sandbox.exec calls
+    def run_command(cmd, show_output=True, retry_count=0, max_retries=3, debug_with_llm=True, timeout=600):
+        """
+        Execute a command in the sandbox with error handling and automatic retries.
+        
+        When a command fails and is fixed by the LLM debugging system, the retry count
+        is reset to 0, so successful fixes don't count against the maximum retry limit.
+        This ensures that a command that's been fixed gets a fresh set of retry attempts.
+        """
+        # Use the outer scope variables
+        nonlocal current_dir, execution_history, sandbox, previous_errors
+        nonlocal conda_installed, python_version_switched, current_python_version
+        
+        # Record command start time
+        command_start_time = datetime.datetime.now().isoformat()
+        start_time = time.time()
+        
+        # Prevent infinite retry loops
+        if retry_count >= max_retries:
+            print(f"⚠️ Maximum retry count ({max_retries}) reached. Stopping retries.")
+            return False, "", f"Maximum retry count ({max_retries}) reached"
+        
+        # Special handling for cd commands to prevent common navigation errors
+        if cmd.strip().startswith("cd "):
+            # Extract the target directory from the cd command
+            cd_parts = cmd.split(None, 1)
+            if len(cd_parts) >= 2:
+                target_dir = cd_parts[1].strip().strip('"\'')
+                
+                # Check if this is a repo name that matches the end of current_dir
+                # This prevents errors like "cd repo-name" when already in "/root/repo-name"
+                if (target_dir != "/" and target_dir != "." and target_dir != ".." and 
+                    not target_dir.startswith("/") and not target_dir.startswith("./") and 
+                    not target_dir.startswith("../") and current_dir.endswith("/" + target_dir)):
+                    print(f"⚠️ Detected redundant directory navigation: {cmd}")
+                    print(f"📂 Already in the correct directory: {current_dir}")
+                    print(f"✅ Skipping unnecessary navigation command")
+                    return True, f"Already in directory {current_dir}", ""
+        
+        # Remove any parenthetical text that could cause syntax errors in bash
+        if '(' in cmd:
+            original_cmd = cmd
+            cmd = re.sub(r'\([^)]*\)', '', cmd).strip()
+            print(f"🔄 Removing parenthetical text:")
+            print(f"  Original: {original_cmd}")
+            print(f"  Cleaned: {cmd}")
+            
+        # Convert pip install commands to use uv for faster installation
+        original_cmd = cmd
+        if 'uv_path' in globals() and uv_path and ('pip install' in cmd or 'pip3 install' in cmd) and not cmd.startswith(uv_path):
+            # Replace pip/pip3 install with uv pip install, but only if not already using uv
+            cmd = cmd.replace('pip install', f'{uv_path} pip install')
+            cmd = cmd.replace('pip3 install', f'{uv_path} pip install')
+            print(f"🚀 Converting to uv for faster installation:")
+            print(f"  Original: {original_cmd}")
+            print(f"  Converted: {cmd}")
+        
+        print(f"\n▶ {cmd}\n")
+        
+        # Check if this is a potentially long-running command
+        long_running_patterns = [
+            'pip install', 'apt install', 'yum install',
+            'wget', 'curl', 'git clone', 'npm install', 'yarn install',
+            'cmake', 'make', 'gcc', 'g++', 'python setup.py'
+        ]
+        
+        is_long_running = any(pattern in cmd.lower() for pattern in long_running_patterns)
+        if is_long_running:
+            print(f"⏱️ Detected potentially long-running command. This may take several minutes...")
+            print(f"📦 Large packages (like PyTorch) can take 5-10 minutes to download and install.")
+            print(f"🔄 The container has a 30-minute timeout to accommodate this.")
+        
+        # Use the original command without modification for interactivity
+        cmd_to_execute = cmd
+        
+        # Special handling for huggingface-cli login command
+        if "huggingface-cli login" in cmd_to_execute:
+            print("🔍 Detected huggingface-cli login command")
+            print("🔄 Using non-interactive login approach with token instead")
+            
+            # Check if the command already has a token
+            if "--token" in cmd_to_execute:
+                print("✅ Command already includes token parameter")
+            else:
+                # Prompt for HF token
+                hf_token = prompt_for_hf_token()
+                if hf_token:
+                    # Replace with non-interactive command
+                    cmd_to_execute = f"huggingface-cli login --token {hf_token} --add-to-git-credential"
+                    print(f"🔄 Using non-interactive command: {cmd_to_execute}")
+                else:
+                    print("❌ No token provided. Cannot continue with Hugging Face login.")
+                    return False, "", "No Hugging Face token provided"
+        
+        # Special handling for wandb login command
+        elif "wandb login" in cmd_to_execute and "YOUR_API_KEY" not in cmd_to_execute:
+            print("🔍 Detected Weights & Biases login command")
+            print("🔄 Using API key approach for non-interactive login")
+            
+            # Check if the command already includes an API key
+            has_api_key = False
+            cmd_parts = cmd_to_execute.split()
+            for part in cmd_parts:
+                if part != "wandb" and part != "login" and not part.startswith("-"):
+                    has_api_key = True
+                    break
+            
+            if not has_api_key:
+                # Prompt for W&B API key
+                print("\n" + "="*60)
+                print("🔑 WEIGHTS & BIASES API KEY REQUIRED")
+                print("="*60)
+                print("You can get your API key from: https://wandb.ai/authorize")
+                print("📝 Please paste your W&B API key below:")
+                print("   (Your input will be hidden for security)")
+                print("-" * 60)
+                
+                try:
+                    api_key = getpass.getpass("W&B API Key: ").strip()
+                    if not api_key:
+                        print("❌ No API key provided. Cannot continue with W&B login.")
+                        return False, "", "No W&B API key provided"
+                    
+                    # Validate API key length (typically 40 characters)
+                    if len(api_key) != 40:
+                        print(f"⚠️ Warning: API key should be 40 characters long, yours was {len(api_key)}")
+                        confirm = input("Continue anyway? (yes/no): ").strip().lower()
+                        if confirm not in ["yes", "y"]:
+                            print("❌ W&B login cancelled.")
+                            return False, "", "W&B login cancelled"
+                    
+                    print("✅ API key received successfully!")
+                    
+                    # Replace with non-interactive command
+                    cmd_to_execute = f"wandb login {api_key}"
+                    print(f"🔄 Using non-interactive command: wandb login [API_KEY_HIDDEN]")
+                except KeyboardInterrupt:
+                    print("\n❌ API key input cancelled by user.")
+                    return False, "", "W&B API key input cancelled"
+                except Exception as e:
+                    print(f"❌ Error getting API key: {e}")
+                    return False, "", f"Error getting W&B API key: {e}"
+        
+        # Validate the command before execution
+        if not cmd_to_execute or cmd_to_execute.strip() == "":
+            print("⚠️ Empty command detected, skipping execution")
+            return False, "", "Empty command"
+        
+        # Sanitize command to prevent issues with special characters
+        # Remove any null bytes or other problematic characters
+        cmd_to_execute = cmd_to_execute.replace('\x00', '').strip()
+        
+        if len(cmd_to_execute) > 10000:  # Prevent extremely long commands
+            print("⚠️ Command too long, truncating")
+            cmd_to_execute = cmd_to_execute[:10000]
+        
+        # Prepare the command with environment variables and error handling
+        full_command = f"""
+# Change to current directory
+cd "{current_dir}"
+
+# Execute the command
+{cmd_to_execute}
+"""
+        
+        # Execute the command using sandbox.exec
+        try:
+            print(f"🔄 Executing command in directory: {current_dir}")
+            
+            # Use sandbox.exec for individual command execution
+            result = sandbox.exec("bash", "-c", full_command.strip())
+            
+            # Collect output in real-time - Modal streams are already set up for line-by-line streaming
+            stdout_lines = []
+            stderr_lines = []
+            
+            # Process output streams in real-time - Modal handles this natively
+            # We don't need to use threading here as Modal's streams are designed to be consumed directly
+            if show_output:
+                print("\n--- Command Output ---")
+            
+            # Track if we've shown timeout warnings
+            timeout_warnings = set()
+            last_output_time = time.time()
+            
+            # Read stdout in real-time
+            for line in result.stdout:
+                # Check for timeout
+                current_time = time.time()
+                elapsed = current_time - start_time
+                time_since_output = current_time - last_output_time
+                
+                # Show timeout warning every 30 seconds if no output for 30+ seconds
+                if time_since_output > 30 and int(time_since_output) // 30 not in timeout_warnings:
+                    warning_time = int(time_since_output) // 30 * 30
+                    timeout_warnings.add(int(time_since_output) // 30)
+                    print(f"Still running after {int(elapsed)} seconds...")
+                
+                # If total time exceeds timeout, break
+                if elapsed > timeout:
+                    print(f"⚠️ Command timed out after {timeout} seconds")
+                    # Force terminate the command
+                    try:
+                        result.terminate()
+                    except:
+                        pass
+                    return False, "Command timed out", f"Command execution exceeded timeout of {timeout} seconds"
+                
+                # Process the line
+                line_str = _to_str(line)
+                stdout_lines.append(line_str)
+                if show_output:
+                    # Print immediately with flush to ensure real-time display
+                    print(line_str, end="", flush=True)
+                
+                # Update last output time
+                last_output_time = time.time()
+            
+            # Read stderr in real-time
+            for line in result.stderr:
+                # Check for timeout
+                current_time = time.time()
+                elapsed = current_time - start_time
+                time_since_output = current_time - last_output_time
+                
+                # Show timeout warning every 30 seconds if no output for 30+ seconds
+                if time_since_output > 30 and int(time_since_output) // 30 not in timeout_warnings:
+                    warning_time = int(time_since_output) // 30 * 30
+                    timeout_warnings.add(int(time_since_output) // 30)
+                    print(f"Still running after {int(elapsed)} seconds...")
+                
+                # If total time exceeds timeout, break
+                if elapsed > timeout:
+                    print(f"⚠️ Command timed out after {timeout} seconds")
+                    # Force terminate the command
+                    try:
+                        result.terminate()
+                    except:
+                        pass
+                    return False, "Command timed out", f"Command execution exceeded timeout of {timeout} seconds"
+                
+                # Process the line
+                line_str = _to_str(line)
+                stderr_lines.append(line_str)
+                if show_output:
+                    # Print immediately with flush to ensure real-time display
+                    print(line_str, end="", file=sys.stderr, flush=True)
+                
+                # Update last output time
+                last_output_time = time.time()
+            
+            if show_output:
+                print("--- End Output ---\n")
+            
+            stdout_buffer = ''.join(stdout_lines)
+            stderr_buffer = ''.join(stderr_lines)
+            
+            # Wait for the process to complete before accessing returncode
+            result.wait()
+            exit_code = result.returncode
+            
+        except Exception as e:
+            print(f"❌ Error executing command: {e}")
+            return False, "", str(e)
+        
+        # Record command completion time
+        command_end_time = datetime.datetime.now().isoformat()
+        
+        # Calculate duration in seconds
+        start_dt = datetime.datetime.fromisoformat(command_start_time)
+        end_dt = datetime.datetime.fromisoformat(command_end_time)
+        duration = (end_dt - start_dt).total_seconds()
+        
+        # Record this command execution in history
+        execution_record = {
+            "command": cmd_to_execute,
+            "original_command": cmd if cmd != cmd_to_execute else None,
+            "start_time": command_start_time,
+            "end_time": command_end_time,
+            "duration_seconds": duration,
+            "exit_code": exit_code,
+            "stdout": stdout_buffer,
+            "stderr": stderr_buffer,
+            "directory": current_dir
+        }
+        execution_history.append(execution_record)
+        
+        # Update current directory if this was a cd command and it succeeded
+        if cmd_to_execute.strip().startswith("cd ") and exit_code == 0:
+            # Extract the target directory from the cd command
+            cd_parts = cmd_to_execute.split(None, 1)
+            if len(cd_parts) >= 2:
+                target_dir = cd_parts[1].strip('"\'')
+                
+                # Store the previous directory for logging
+                previous_dir = current_dir
+                
+                # Handle different types of paths
+                if target_dir.startswith('/'):
+                    # Absolute path
+                    current_dir = target_dir
+                elif target_dir == '..':
+                    # Parent directory
+                    current_dir = '/'.join(current_dir.rstrip('/').split('/')[:-1]) or '/'
+                elif target_dir == '.':
+                    # Current directory - no change
+                    pass
+                else:
+                    # Relative path - handle special case where target is already at the end of current_dir
+                    if current_dir.endswith('/' + target_dir):
+                        print(f"📂 Already in directory {current_dir}, no change needed")
+                    else:
+                        current_dir = f"{current_dir.rstrip('/')}/{target_dir}"
+                
+                print(f"📂 Updated current directory: {previous_dir} -> {current_dir}")
+                execution_record["new_current_dir"] = current_dir
+                
+                # Verify the directory actually exists
+                verify_cmd = f"test -d \"{current_dir}\""
+                verify_result = sandbox.exec("bash", "-c", verify_cmd)
+                verify_result.wait()
+                
+                if verify_result.returncode != 0:
+                    print(f"⚠️ Warning: Directory {current_dir} does not exist")
+                    print(f"⚠️ Reverting to previous directory: {previous_dir}")
+                    current_dir = previous_dir
+                    execution_record["new_current_dir"] = current_dir
+        
+        # Check for errors and handle Hugging Face token issues
+        if exit_code != 0:
+            # Check for specific Hugging Face token errors
+            hf_token_error_patterns = [
+                "Token is required",
+                "LocalTokenNotFoundError", 
+                "Invalid user token",
+                "401 Client Error: Unauthorized",
+                "Invalid credentials in Authorization header",
+                "HF_TOKEN environment variable is invalid"
+            ]
+            
+            is_hf_token_error = any(pattern in stderr_buffer for pattern in hf_token_error_patterns)
+            
+            if is_hf_token_error:
+                print(f"🔑 Detected Hugging Face token authentication error!")
+                print(f"🔍 Error details: {stderr_buffer}")
+                
+                # Prompt for the real token
+                real_token = prompt_for_hf_token()
+                
+                if real_token:
+                    print(f"🔄 Setting HF_TOKEN and retrying command...")
+                    
+                    # Retry with the token set
+                    token_command = f"export HF_TOKEN='{real_token}'; {cmd_to_execute}"
+                    return run_command(token_command, show_output, retry_count + 1, max_retries)
+                else:
+                    print("❌ No token provided. Cannot continue with Hugging Face operations.")
+                    return False, stdout_buffer, "No Hugging Face token provided"
+            
+            # Check for "No such file or directory" errors with cd commands
+            if "cd " in cmd_to_execute and "No such file or directory" in stderr_buffer:
+                print("⚠️ Directory navigation error detected")
+                
+                # Extract the target directory from the cd command
+                cd_parts = cmd_to_execute.split(None, 1)
+                if len(cd_parts) >= 2:
+                    target_dir = cd_parts[1].strip('"\'')
+                    
+                    # Check if this might be a repository name that's already in the path
+                    if not target_dir.startswith('/') and '/' + target_dir in current_dir:
+                        print(f"🔍 The directory '{target_dir}' appears to be part of the current path: {current_dir}")
+                        print(f"⚠️ This is likely a redundant navigation attempt")
+                        
+                        # If we're already in a directory that ends with the target, consider it a success
+                        if current_dir.endswith('/' + target_dir):
+                            print(f"✅ Already in the correct directory: {current_dir}")
+                            return True, f"Already in directory {current_dir}", ""
+            
+            print(f"⚠️ Command failed with exit code {exit_code}")
+            if stderr_buffer.strip():
+                print(f"Error output: {stderr_buffer}")
+            
+            # If command failed and we're debugging with LLM
+            if debug_with_llm:
+                print("🔍 Attempting to debug the failed command with OpenAI...")
+                
+                # Check if the command is a hanging huggingface-cli login
+                if "huggingface-cli login" in cmd_to_execute and not stderr_buffer.strip():
+                    print("🔍 Detected hanging huggingface-cli login command")
+                    print("🔄 Using non-interactive login approach with HF_TOKEN instead")
+                    
+                    # Prompt for HF token
+                    hf_token = prompt_for_hf_token()
+                    if hf_token:
+                        # Set the token as environment variable and create .huggingface folder
+                        print("✅ Token received, setting up non-interactive authentication")
+                        setup_commands = [
+                            "mkdir -p ~/.huggingface",
+                            f"echo '{hf_token}' > ~/.huggingface/token",
+                            f"export HF_TOKEN='{hf_token}'",
+                            "echo 'HF_TOKEN and token file have been set up'"
+                        ]
+                        
+                        for setup_cmd in setup_commands:
+                            setup_success, setup_stdout, _ = run_command(setup_cmd, show_output=True, debug_with_llm=False)
+                            if not setup_success:
+                                print(f"⚠️ Setup command failed: {setup_cmd}")
+                        
+                        print("✅ Hugging Face authentication set up non-interactively")
+                        return True, "Hugging Face authentication set up successfully", ""
+                    else:
+                        print("❌ No token provided. Cannot set up Hugging Face authentication.")
+                        return False, "", "No Hugging Face token provided"
+                
+                # Check if the error is related to missing pytest
+                if "ModuleNotFoundError: No module named 'pytest'" in stderr_buffer or "ImportError: No module named pytest" in stderr_buffer:
+                    print("🔍 Detected missing pytest module, installing it automatically...")
+                    pytest_install_success, _, _ = run_command("pip install pytest", show_output=True, debug_with_llm=False)
+                    if pytest_install_success:
+                        print("✅ Successfully installed pytest, retrying original command...")
+                        return run_command(cmd, show_output, retry_count + 1, max_retries)
+                
+                # Check for Python version-specific errors
+                python_version_errors = [
+                    # Python 3.13 distutils issue
+                    ("ModuleNotFoundError: No module named 'distutils'", "3.13"),
+                    # Add more version-specific error patterns here
+                    ("ImportError: cannot import name 'soft_unicode' from 'markupsafe'", None),
+                    ("AttributeError: module 'setuptools.dist' has no attribute 'check_specifier'", None)
+                ]
+                
+                # Check if any of the error patterns match
+                for error_pattern, problematic_version in python_version_errors:
+                    if error_pattern in stderr_buffer:
+                        print(f"🔍 Detected Python version-specific error: {error_pattern}")
+                        
+                        # Get current Python version if not already known
+                        if not current_python_version:
+                            version_cmd = "python --version"
+                            version_success, version_stdout, _ = run_command(version_cmd, show_output=False, debug_with_llm=False)
+                            if version_success:
+                                current_python_version = version_stdout.strip()
+                                print(f"🐍 Current Python version: {current_python_version}")
+                        
+                        # Check if we've already tried switching Python versions
+                        if python_version_switched:
+                            print("⚠️ Already attempted to switch Python versions once, not trying again")
+                            break
+                        
+                        print("🔄 Attempting to fix by switching Python version...")
+                        
+                        # Install conda if not already installed
+                        if not conda_installed:
+                            print("📦 Installing Miniconda to manage Python versions...")
+                            conda_install_cmds = [
+                                "apt-get update -y",
+                                "apt-get install -y wget bzip2",
+                                "wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh",
+                                "bash /tmp/miniconda.sh -b -p /opt/conda",
+                                "rm /tmp/miniconda.sh",
+                                "echo 'export PATH=/opt/conda/bin:$PATH' >> ~/.bashrc",
+                                "export PATH=/opt/conda/bin:$PATH",
+                                "conda init bash",
+                                "source ~/.bashrc",
+                                "conda activate base"
+                            ]
+                            
+                            for conda_cmd in conda_install_cmds:
+                                print(f"🔄 Running: {conda_cmd}")
+                                conda_success, _, _ = run_command(conda_cmd, show_output=True, debug_with_llm=False)
+                                if not conda_success:
+                                    print("⚠️ Failed to install conda, continuing with system Python")
+                                    break
+                            
+                            # Check if conda was successfully installed
+                            conda_check_cmd = "conda --version"
+                            conda_check_success, conda_check_stdout, _ = run_command(conda_check_cmd, show_output=True, debug_with_llm=False)
+                            conda_installed = conda_check_success
+                            
+                            if conda_installed:
+                                print(f"✅ Successfully installed conda: {conda_check_stdout.strip()}")
+                            else:
+                                print("⚠️ Failed to verify conda installation")
+                                break
+                        
+                        # Determine target Python version
+                        target_version = "3.10"  # Default to a stable version
+                        if problematic_version == "3.13":
+                            # If we're on 3.13 and having issues, go to 3.10
+                            target_version = "3.10"
+                        elif "3.13" in str(current_python_version):
+                            # If we're on 3.13 for any other error, try 3.10
+                            target_version = "3.10"
+                        elif "3.10" in str(current_python_version):
+                            # If we're on 3.10 and having issues, try 3.9
+                            target_version = "3.9"
+                        
+                        print(f"🐍 Switching from {current_python_version} to Python {target_version}...")
+                        
+                        # Create and activate a conda environment with the target Python version
+                        conda_cmds = [
+                            f"conda create -y -n py{target_version} python={target_version}",
+                            f"echo 'conda activate py{target_version}' >> ~/.bashrc",
+                            f"conda init bash",
+                            f"source ~/.bashrc",
+                            f"conda activate py{target_version}"
+                        ]
+                        
+                        for conda_cmd in conda_cmds:
+                            print(f"🔄 Running: {conda_cmd}")
+                            conda_success, _, _ = run_command(conda_cmd, show_output=True, debug_with_llm=False)
+                            if not conda_success:
+                                print(f"⚠️ Failed to run conda command: {conda_cmd}")
+                        
+                        # Verify Python version changed
+                        verify_cmd = "python --version"
+                        verify_success, verify_stdout, _ = run_command(verify_cmd, show_output=True, debug_with_llm=False)
+                        
+                        if verify_success and target_version in verify_stdout:
+                            print(f"✅ Successfully switched to Python {verify_stdout.strip()}")
+                            python_version_switched = True
+                            current_python_version = verify_stdout.strip()
+                            
+                            # Reinstall pip and setuptools in the new environment
+                            print("📦 Installing pip and setuptools in new environment...")
+                            run_command("pip install --upgrade pip setuptools wheel", show_output=True, debug_with_llm=False)
+                            
+                            # Retry the original command with the new Python version
+                            print(f"🔄 Retrying original command with Python {target_version}...")
+                            # Reset the retry counter since we've made a significant change
+                            return run_command(cmd, show_output, 0, max_retries)
+                        else:
+                            print("⚠️ Failed to switch Python version, continuing with current version")
+                        
+                        break
+                
+                # Check if stderr is empty, try to use stdout as fallback
+                debug_output = stderr_buffer
+                if not debug_output or not debug_output.strip():
+                    print("⚠️ stderr is empty, checking if stdout contains error information...")
+                    if stdout_buffer and stdout_buffer.strip():
+                        print("✅ Using stdout for debugging as stderr is empty")
+                        debug_output = stdout_buffer
+                    else:
+                        print("⚠️ Both stderr and stdout are empty. Limited debugging information available.")
+                        debug_output = f"Command failed with exit code {exit_code}, but no error output was captured."
+                
+                # Print debug output for verification
+                print(f"🔍 Debug output to be sent to OpenAI ({len(debug_output)} chars):")
+                print("="*60)
+                print(debug_output if debug_output else "[EMPTY]")
+                print("="*60)
+                
+                fix_command = call_openai_for_debug(cmd_to_execute, debug_output, current_dir=current_dir, sandbox=sandbox)
+                
+                if fix_command:
+                    print(f"🔧 OpenAI suggested fix command: {fix_command}")
+                    
+                    # Check if the suggested command is "wandb login YOUR_API_KEY" or similar
+                    if "wandb login" in fix_command and ("YOUR_API_KEY" in fix_command or "[your_api_key]" in fix_command):
+                        print("🔍 Detected placeholder API key in suggested command")
+                        print("🔄 Prompting for actual W&B API key instead")
+                        
+                        # Prompt for W&B API key
+                        print("\n" + "="*60)
+                        print("🔑 WEIGHTS & BIASES API KEY REQUIRED")
+                        print("="*60)
+                        print("You can get your API key from: https://wandb.ai/authorize")
+                        print("📝 Please paste your W&B API key below:")
+                        print("   (Your input will be hidden for security)")
+                        print("-" * 60)
+                        
+                        try:
+                            api_key = getpass.getpass("W&B API Key: ").strip()
+                            if api_key:
+                                # Replace placeholder with actual API key
+                                fix_command = f"wandb login {api_key}"
+                                print(f"🔄 Using actual API key: wandb login [API_KEY_HIDDEN]")
+                            else:
+                                print("❌ No API key provided. Cannot continue with W&B login.")
+                                return False, stdout_buffer, stderr_buffer
+                        except Exception as e:
+                            print(f"❌ Error getting API key: {e}")
+                            return False, stdout_buffer, stderr_buffer
+                    
+                    # Special handling for cd commands to prevent directory navigation loops
+                    if fix_command.strip().startswith("cd "):
+                        # Extract the target directory from the cd command
+                        cd_parts = fix_command.split(None, 1)
+                        if len(cd_parts) >= 2:
+                            target_dir = cd_parts[1].strip('"\'')
+                            
+                            # Check if this is trying to navigate to a directory we're already in
+                            if target_dir.endswith(current_dir.split('/')[-1]) or current_dir.endswith('/' + target_dir):
+                                print(f"⚠️ Detected potential directory navigation loop")
+                                print(f"🔍 Current directory: {current_dir}")
+                                print(f"🔍 Suggested navigation: {target_dir}")
+                                
+                                # Check if we're already in the target directory or a directory that contains it
+                                if current_dir.endswith('/' + target_dir) or ('/' + target_dir + '/' in current_dir):
+                                    print(f"✅ Already in or past the target directory")
+                                    print(f"🔄 Skipping redundant navigation and retrying the original command")
+                                    return run_command(cmd, show_output, retry_count + 1, max_retries)
+                    
+                    # Automatically run the fix command without asking for permission
+                    print(f"🔄 Running suggested fix command: {fix_command}")
+                    # Run the fix command with debugging disabled to prevent infinite loop
+                    fix_success, fix_stdout, fix_stderr = run_command(fix_command, show_output=True, debug_with_llm=False)
+                    
+                    if fix_success:
+                        print("✅ Fix command succeeded!")
+                        # Retry the original command with reset retry count
+                        print(f"🔄 Retrying original command: {cmd}")
+                        
+                        # Create a key for tracking this error
+                        error_key = f"{cmd}:{stderr_buffer[:100]}"
+                        
+                        # Check if we've seen this error before
+                        if error_key in previous_errors:
+                            # We've seen this error before, don't reset the retry count
+                            previous_errors[error_key] += 1
+                            print(f"⚠️ Same error encountered {previous_errors[error_key]} times. Not resetting retry count.")
+                            return run_command(cmd, show_output, retry_count + 1, max_retries)
+                        else:
+                            # First time seeing this error, track it and reset retry count
+                            previous_errors[error_key] = 1
+                            print(f"🔄 Resetting retry count to 0 after successful fix")
+                            return run_command(cmd, show_output, 0, max_retries)  # Reset retry count to 0
+                    else:
+                        print("❌ Fix command failed.")
+                        return False, stdout_buffer, stderr_buffer
+    
+        return exit_code == 0, stdout_buffer, stderr_buffer
+
+    # Initialize the environment with basic commands
+    print("🔄 Initializing environment...")
+    init_commands = [
+        "export PS1='$ '",  # Set a simple prompt
+        "export TERM=xterm-256color",  # Set terminal type
+        "source ~/.bashrc 2>/dev/null || true"  # Source bashrc if available
+    ]
+    
+    # Add volume-specific initialization if volume is available
+    if volume:
+        volume_commands = [
+            f"mkdir -p {volume_mount_path}/venvs",  # Create virtual environments directory
+            f"mkdir -p {volume_mount_path}/cache",  # Create cache directory
+            f"export PIP_CACHE_DIR={volume_mount_path}/cache/pip",  # Pip cache
+            f"export UV_CACHE_DIR={volume_mount_path}/cache/uv",  # UV cache
+        ]
+        init_commands.extend(volume_commands)
+        print(f"📦 Setting up persistent storage directories in {volume_mount_path}")
+    
+    # Run initialization commands
+    for i, init_cmd in enumerate(init_commands, 1):
+        print(f"📋 Running init command {i}/{len(init_commands)}: {init_cmd}")
+        success, stdout, stderr = run_command(init_cmd, show_output=False)
+        if not success:
+            print(f"⚠️ Init command failed: {stderr}")
+    
+    print("✅ Environment initialization completed")
+
+    print("📦 Installing basic tools...")
+    run_command("apt-get update && apt-get install -y git curl wget")
+    
+    print("📦 Installing uv with pip...")
+    run_command("pip install uv")
+    
+    # Set uv path to system installation
+    uv_path = "uv"
+
+    # Test if uv is available and working
+    test_uv_cmd = f"{uv_path} --version || echo 'uv not found'"
+    test_success, test_stdout, test_stderr = run_command(test_uv_cmd)
+    if not test_success or 'uv not found' in test_stdout:
+        print("⚠️ uv installation not found in system path, trying alternative installation...")
+        # Try alternative installation method
+        print("📦 Installing uv using the official installer...")
+        run_command("curl -LsSf https://astral.sh/uv/install.sh | sh")
+        run_command("source $HOME/.local/bin/env")
+        run_command('export PATH="$HOME/.local/bin:$PATH"')
+        
+        # Update path to the local installation
+        uv_path = "$HOME/.local/bin/uv"
+        
+        # Test again
+        test_uv_cmd = f"{uv_path} --version || echo 'uv not found'"
+        test_success, test_stdout, test_stderr = run_command(test_uv_cmd)
+        if not test_success or 'uv not found' in test_stdout:
+            print("⚠️ uv installation still failed, using standard pip")
+            uv_path = ""
+        else:
+            print(f"✅ uv installed successfully via alternative method: {test_stdout.strip()}")
+    else:
+        print(f"✅ uv installed successfully via pip: {test_stdout.strip()}")
+
+    # Initialize repo_clone_dir for use throughout the function
+    repo_clone_dir = "/root"  # Always use home directory for repositories
+
+    # Clone repository if URL is provided
+    if repo_url:
+        try:
+            # Extract repo name from URL
+            repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
+            
+            print(f"📥 Cloning repository in Modal container: {repo_url}")
+            
+            # Determine the best location for the repository
+            repo_clone_dir = "/root"  # Always use home directory for repositories
+            print(f"📦 Using home directory for repository: {repo_clone_dir}")
+            
+            # Ensure we're in the home directory and update current directory tracking
+            cd_success, cd_stdout, cd_stderr = run_command(f"cd {repo_clone_dir}", show_output=False)
+            if cd_success:
+                current_dir = repo_clone_dir
+                print(f"📂 Successfully changed to: {repo_clone_dir}")
+            else:
+                print(f"⚠️ Failed to change to {repo_clone_dir}: {cd_stderr}")
+                current_dir = "/"
+            
+            # First, list current directory contents for debugging
+            print("📂 Current directory contents before cloning:")
+            run_command("pwd && ls -la", show_output=True)
+            
+            # Check if repository already exists in current location
+            print(f"🔍 Checking if {repo_name_from_url} directory exists...")
+            
+            # First ensure we're in the right directory and check with absolute path
+            check_cmd = f"cd {repo_clone_dir} && test -d {repo_name_from_url}"
+            success, stdout, stderr = run_command(check_cmd, show_output=False, retry_count=0, max_retries=0)
+            
+            # The directory exists if the test command succeeds (exit code 0)
+            repo_exists = success
+            print(f"📂 Repository check result: exists={repo_exists} (exit code: {0 if success else 1})")
+            print(f"📂 Checking in directory: {repo_clone_dir}/{repo_name_from_url}")
+            
+            if repo_exists:
+                print(f"📂 Repository directory already exists: {repo_name_from_url}")
+                # Check if it's actually a git repository - disable retries to avoid bad debugging
+                git_check_cmd = f"cd {repo_clone_dir}/{repo_name_from_url} && git status"
+                git_check_success, git_stdout, git_stderr = run_command(git_check_cmd, show_output=False, retry_count=0, max_retries=0)
+                if git_check_success:
+                    print(f"✅ Valid git repository found, using existing: {repo_name_from_url}")
+                else:
+                    print(f"⚠️ Directory exists but is not a valid git repository, removing and re-cloning...")
+                    remove_cmd = f"cd {repo_clone_dir} && rm -rf {repo_name_from_url}"
+                    run_command(remove_cmd, show_output=False)
+                    repo_exists = False
+            
+            if not repo_exists:
+                print(f"📥 Repository does not exist, proceeding with clone...")
+                print(f"📥 Cloning repository: {repo_url}")
+                print(f"📥 Repository name will be: {repo_name_from_url}")
+                print(f"📥 Clone location: {repo_clone_dir}")
+                
+                # Ensure we're in the right directory before cloning
+                run_command(f"cd {repo_clone_dir}", show_output=False)
+                
+                # Execute the git clone command with verbose output - use absolute path, disable retries
+                clone_cmd = f"cd {repo_clone_dir} && git clone {repo_url}"
+                clone_success, clone_stdout, clone_stderr = run_command(clone_cmd, show_output=True, retry_count=0, max_retries=0)
+                
+                print(f"📥 Clone command completed. Success: {clone_success}")
+                if clone_stdout.strip():
+                    print(f"📥 Clone stdout: {clone_stdout.strip()}")
+                if clone_stderr.strip():
+                    print(f"📥 Clone stderr: {clone_stderr.strip()}")
+                
+                if not clone_success:
+                    print(f"❌ Failed to clone repository: {clone_stderr}")
+                    print("🔄 Trying alternative clone methods...")
+                    
+                    # Try with different git options - use absolute path, disable retries
+                    print("🔄 Attempting shallow clone...")
+                    shallow_clone_cmd = f"cd {repo_clone_dir} && git clone --depth 1 {repo_url}"
+                    clone_success, clone_stdout, clone_stderr = run_command(shallow_clone_cmd, show_output=True, retry_count=0, max_retries=0)
+                    
+                    print(f"📥 Shallow clone command completed. Success: {clone_success}")
+                    if clone_stdout.strip():
+                        print(f"📥 Shallow clone stdout: {clone_stdout.strip()}")
+                    if clone_stderr.strip():
+                        print(f"📥 Shallow clone stderr: {clone_stderr.strip()}")
+                    
+                    if not clone_success:
+                        print(f"❌ Alternative clone also failed: {clone_stderr}")
+                        print("⚠️ Continuing without repository...")
+                        repo_name_from_url = None
+                    else:
+                        print(f"✅ Repository cloned successfully with shallow clone")
+                else:
+                    print(f"✅ Repository cloned successfully")
+            else:
+                print(f"📂 Repository already exists, skipping clone")
+
+            # Verify repository directory exists and change to it
+            if repo_name_from_url:
+                print("📂 Verifying repository directory...")
+                
+                # List available directories for debugging
+                print("📂 Available directories after cloning:")
+                run_command("ls -la", show_output=True)
+                
+                # Check if the repository directory exists using simple test
+                check_success, _, _ = run_command(f"test -d {repo_name_from_url}", show_output=False)
+                
+                if check_success:
+                    print(f"📂 Repository directory confirmed: {repo_name_from_url}")
+                    # Change to the repository directory
+                    cd_success, cd_stdout, cd_stderr = run_command(f"cd {repo_name_from_url}")
+                    if cd_success:
+                        print(f"📂 Successfully changed to repository directory: {repo_name_from_url}")
+                        repo_dir_name = f"{repo_clone_dir}/{repo_name_from_url}" if repo_clone_dir != "/" else repo_name_from_url
+                    else:
+                        print(f"⚠️ Failed to change to repository directory: {cd_stderr}")
+                        repo_dir_name = repo_clone_dir
+                else:
+                    print(f"⚠️ Repository directory not found after cloning: {repo_name_from_url}")
+                    print("🔍 Looking for alternative directories...")
+                    
+                    # Look for any git repositories
+                    search_success, search_stdout, search_stderr = run_command("find . -maxdepth 1 -type d -name '.git' -exec dirname {} \\;", show_output=False)
+                    
+                    if search_success and search_stdout.strip():
+                        found_dirs = [d.replace('./', '') for d in search_stdout.strip().split('\n') if d.strip() and d != '.']
+                        if found_dirs:
+                            repo_dir_name = f"{repo_clone_dir}/{found_dirs[0]}" if repo_clone_dir != "/" else found_dirs[0]
+                            print(f"📂 Found git repository: {repo_dir_name}")
+                            run_command(f"cd {found_dirs[0]}")
+                        else:
+                            repo_dir_name = repo_clone_dir
+                            print("📂 Using current directory")
+                    else:
+                        repo_dir_name = repo_clone_dir
+                        print("📂 Using current directory")
+            else:
+                repo_dir_name = repo_clone_dir
+                print("📂 No valid repository, using current directory")
+
+            # Show final directory status
+            print("📂 Final directory status:")
+            run_command("pwd && ls -la", show_output=True)
+            
+        except Exception as e:
+            print(f"❌ Error during repository cloning: {e}")
+            print(f"❌ Exception type: {type(e).__name__}")
+            print("⚠️ Continuing without repository...")
+            repo_dir_name = repo_clone_dir
+            run_command("pwd && ls -la", show_output=True)
+    else:
+        repo_dir_name = repo_clone_dir
+        print("📂 No repository URL provided, using current directory")
+        run_command("pwd && ls -la", show_output=True)
+
+    # Run setup commands if provided - now we're already in the repository directory
+    if setup_commands:
+        print("⚙️ Running user setup commands in Modal container...")
+        
+        # Check if git clone is already in the setup commands
+        has_git_clone = any('git clone' in cmd for cmd in setup_commands)
+        
+        # Only add git clone if:
+        # 1. No git clone in setup commands AND
+        # 2. We have a repo URL AND  
+        # 3. Repository was NOT already cloned successfully
+        if not has_git_clone and repo_url and not repo_exists:
+            print("📥 Git clone not found in setup commands and repository not yet cloned, adding it...")
+            clone_cmd = f"git clone {repo_url}"
+            setup_commands = [clone_cmd] + setup_commands
+            print(f"📥 Added git clone command: {clone_cmd}")
+        elif has_git_clone and repo_exists:
+            print("⚠️ Repository already cloned successfully, removing duplicate git clone from setup commands...")
+            # Remove git clone commands since repository is already cloned
+            setup_commands = [cmd for cmd in setup_commands if 'git clone' not in cmd]
+            print(f"📥 Removed duplicate git clone commands")
+        elif repo_exists:
+            print("📂 Repository already cloned successfully, skipping git clone in setup commands")
+        
+        # Print all commands that will be executed
+        print("📋 Setup commands to execute in container:")
+        for i, cmd in enumerate(setup_commands, 1):
+            print(f"  {i}. {cmd}")
+        
+        print(f"\n🚀 Executing commands in container directory: {repo_dir_name}")
+        
+        # Ensure we start in the /root directory and reset current_dir
+        current_dir = "/root"
+        print(f"📂 Resetting working directory to: {current_dir}")
+        
+        # Verify we can access /root directory
+        verify_success, verify_output, _ = run_command("pwd", show_output=True)
+        if verify_success:
+            print(f"✅ Current directory verified: {verify_output.strip()}")
+        
+        # Execute each command individually in the repository directory within the container
+        for i, cmd in enumerate(setup_commands, 1):
+            print(f"\n📋 Executing command {i}/{len(setup_commands)} in container: {cmd}")
+            
+            # If this is a cd command, just run it directly
+            if cmd.strip().startswith('cd '):
+                # Execute the command directly (we're already in the right directory)
+                success, stdout, stderr = run_command(cmd)
+                continue
+                
+            # For git clone commands, handle as before
+            if 'git clone' in cmd:
+                # Execute the command directly
+                success, stdout, stderr = run_command(cmd)
+                
+                if success:
+                    print(f"✅ Command executed successfully in container: {cmd}")
+                    if stdout.strip():
+                        print(f"📄 Output: {stdout.strip()}")
+                    
+                    # Handle repository directory change as before
+                    print("📂 Git clone detected, attempting to change to repository directory...")
+                    # Extract repository name from the clone command
+                    parts = cmd.split()
+                    if len(parts) >= 3:
+                        clone_url = parts[2]  # git clone <url>
+                        target_dir = clone_url.split('/')[-1].replace('.git', '')
+                        
+                        # Check if we're already in the target directory
+                        if current_dir.endswith(f"/{target_dir}") or current_dir == f"/{target_dir}":
+                            print(f"📂 Already in target directory: {current_dir}")
+                        else:
+                            # The repository should now be at current_dir/target_dir
+                            repo_full_path = f"{current_dir.rstrip('/')}/{target_dir}"
+                            
+                            # Check if directory exists using absolute path
+                            dir_check_success, _, _ = run_command(f"test -d '{repo_full_path}'", show_output=False)
+                            if dir_check_success:
+                                current_dir = repo_full_path
+                                print(f"📂 Successfully changed current directory to: {current_dir}")
+                                # Verify the change worked
+                                verify_success, verify_output, _ = run_command("pwd", show_output=True)
+                                if verify_success:
+                                    print(f"✅ Directory change verified: {verify_output.strip()}")
+                                    # List contents to confirm we're in the right place
+                                    run_command("ls -la", show_output=True)
+                                    
+                                    # Initialize git submodules if they exist
+                                    print("📦 Checking for git submodules...")
+                                    submodule_check_success, _, _ = run_command("test -f .gitmodules", show_output=False)
+                                    if submodule_check_success:
+                                        print("📦 Git submodules found, initializing...")
+                                        run_command("git submodule update --init --recursive", show_output=True)
+                                        print("✅ Git submodules initialized")
+                                    else:
+                                        print("📦 No git submodules found")
+                                else:
+                                    print("⚠️ Directory change verification failed")
+                            else:
+                                print(f"⚠️ Repository directory {repo_full_path} not found after clone")
+                                print("🔍 Checking what was actually created:")
+                                run_command("find . -maxdepth 2 -name '*.git' -type d", show_output=True)
+                                run_command("ls -la", show_output=True)
+            else:
+                # For Python commands, make sure we're in the correct directory first
+                if cmd.startswith('python '):
+                    # Fix the directory path issue - ensure we're in the correct repository directory
+                    # Check if we're in a nested directory that matches the repo name
+                    repo_dir_parts = current_dir.split('/')
+                    if len(repo_dir_parts) >= 2 and repo_dir_parts[-1] == repo_dir_parts[-2]:
+                        # We're in a nested directory like /root/nanoGPT/nanoGPT
+                        # Move up one level to /root/nanoGPT
+                        print(f"⚠️ Detected nested directory structure: {current_dir}")
+                        parent_dir = '/'.join(repo_dir_parts[:-1])
+                        print(f"🔄 Moving to parent directory: {parent_dir}")
+                        cd_success, _, _ = run_command(f"cd {parent_dir}", show_output=False)
+                        if cd_success:
+                            current_dir = parent_dir
+                            print(f"📂 Updated current directory to: {current_dir}")
+                
+                # Execute the command directly (we're already in the right directory)
+                success, stdout, stderr = run_command(cmd)
+                
+                if success:
+                    print(f"✅ Command executed successfully in container: {cmd}")
+                    if stdout.strip():
+                        print(f"📄 Output: {stdout.strip()}")
+                else:
+                    print(f"❌ Command failed in container: {cmd}")
+                    print(f"❌ Error: {stderr}")
+                    # Continue with next command even if this one failed
+                
+        # Show final status of the repository directory in container
+        print(f"\n📂 Final directory contents in container ({repo_dir_name}):")
+        run_command("pwd && ls -la")
+        
+    else:
+        print("⚠️ No setup commands provided.")
+        
+        # If no setup commands but we have a repo URL, at least try to clone it
+        if repo_url and not repo_exists:
+            print("📥 No setup commands provided, but cloning repository anyway...")
+            clone_success, _, _ = run_command(f"git clone {repo_url}", show_output=True)
+            if clone_success:
+                print(f"✅ Repository cloned successfully")
+                # Try to change to the repository directory
+                if repo_name_from_url:
+                    run_command(f"cd {repo_name_from_url}")
+                    print("📂 Final directory status after clone:")
+                    run_command("pwd && ls -la", show_output=True)
+
+    # Write container ID to file for future reference
+    with open(os.path.expanduser("~/.modal_last_container_id"), "w") as f:
+        f.write(container_id)
+
+    # Print connection instructions
+    print(f"✅ Modal sandbox created successfully!")
+    print(f"📋 Sandbox ID: {sandbox_id}")
+    print(f"📋 Container ID: {container_id}")
+    if volume:
+        print(f"📦 Volume: {volume_name} (mounted at {volume_mount_path})")
+        print(f"💾 Persistent storage available for pip and uv caches")
+        print(f"📂 Repositories will be cloned in home directory (/root) for faster access")
+    print("🔗 To connect to this container, run:")
+    print(f"modal container exec --pty {container_id} bash")
+    print("⏳ Sandbox will remain running until you terminate it with:")
+    print(f"modal sandbox terminate {sandbox_id}")
+
+    # Try to open a new terminal window and connect to the container
+    if container_id:
+        print("🖥️ Attempting to open new terminal window...")
+        # Use osascript to open a new terminal with the modal shell command
+        terminal_script = f'''
+        tell application "Terminal"
+            do script "modal shell {container_id}"
+            activate
+        end tell
+        '''
+        
+        try:
+            result = subprocess.run(['osascript', '-e', terminal_script], 
+                                  capture_output=True, text=True, timeout=30)
+            if result.returncode == 0:
+                print("✅ New terminal window opened successfully")
+            else:
+                print(f"⚠️ Failed to open terminal window: {result.stderr}")
+                
+                # Try alternative approach with iTerm2 if Terminal failed
+                print("🔄 Trying with iTerm2 instead...")
+                iterm_script = f'''
+                tell application "iTerm"
+                    create window with default profile
+                    tell current session of current window
+                        write text "modal shell {container_id}"
+                    end tell
+                end tell
+                '''
+                
+                try:
+                    iterm_result = subprocess.run(['osascript', '-e', iterm_script], 
+                                              capture_output=True, text=True, timeout=30)
+                    if iterm_result.returncode == 0:
+                        print("✅ New iTerm2 window opened successfully")
+                    else:
+                        print(f"⚠️ Failed to open iTerm2 window: {iterm_result.stderr}")
+                        print("📝 You can manually connect using:")
+                        print(f"   modal shell {container_id}")
+                except Exception as e:
+                    print(f"⚠️ Error opening iTerm2: {e}")
+                    print("📝 You can manually connect using:")
+                    print(f"   modal shell {container_id}")
+        except subprocess.TimeoutExpired:
+            print("⚠️ Terminal opening timed out")
+        except Exception as e:
+            print(f"⚠️ Error opening terminal: {e}")
+            print("📝 You can manually connect using:")
+            print(f"   modal shell {container_id}")
+        
+        # Also provide manual connection instructions
+        print("\n" + "="*60)
+        print("🚀 SANDBOX READY!")
+        print("="*60)
+        print(f"📋 Sandbox ID: {sandbox_id}")
+        print(f"🆔 Container ID: {container_id}")
+        if volume:
+            print(f"💾 Volume: {volume_name} mounted at {volume_mount_path}")
+            print("📁 Persistent storage available for caches and repositories")
+        print("\n🔗 To connect to your container, run:")
+        print(f"   modal shell {container_id}")
+        print("="*60)
+    else:
+        print("❌ No container ID available for connection")
+    
+    return {
+        "run_command": run_command,
+        "current_dir": current_dir,
+        "execution_history": execution_history,
+        "container_id": container_id,
+        "sandbox_id": sandbox_id
+    }
+
+def fetch_setup_commands_from_api(repo_url):
+    """Fetch setup commands from the GitIngest API using real repository analysis."""
+    import tempfile
+    import subprocess
+    import os
+    import shutil
+    import json
+    
+    api_url = "http://localhost:3000/api/analyze-with-gitingest"
+    
+    print(f"🔍 Fetching setup commands from API for repository: {repo_url}")
+    
+    # Check if gitingest command line tool is available - try multiple possible command names
+    has_gitingest_cli = False
+    gitingest_cmd_name = None
+    
+    # Try the standard command name first
+    try:
+        print(f"🔍 Checking for GitIngest CLI tool...")
+        result = subprocess.run(["gitingest", "--help"], check=True, capture_output=True, text=True)
+        has_gitingest_cli = True
+        gitingest_cmd_name = "gitingest"
+        print(f"✅ GitIngest CLI tool found")
+    except (subprocess.SubprocessError, FileNotFoundError) as e:
+        print(f"  - GitIngest command not found: {str(e)}")
+    
+    # Create a temporary directory for output
+    temp_dir = tempfile.mkdtemp(prefix="repo_analysis_")
+    output_file = os.path.join(temp_dir, "digest.json")
+    
+    try:
+        if has_gitingest_cli:
+            # Use gitingest CLI tool to analyze the repository directly from URL
+            print(f"🔎 Running GitIngest analysis on {repo_url}...")
+            
+            # Based on the help output, the correct format is:
+            # gitingest [OPTIONS] [SOURCE]
+            # With options:
+            # -o, --output TEXT           Output file path
+            # --format TEXT               Output format (json)
+            
+            # Run gitingest command with proper parameters
+            gitingest_run_cmd = [
+                gitingest_cmd_name,
+                repo_url,
+                "-o", output_file,  # Use -o for output file
+            ]
+            
+            print(f"🔄 Executing: {' '.join(gitingest_run_cmd)}")
+            
+            result = subprocess.run(gitingest_run_cmd, capture_output=True, text=True)
+            
+            if result.returncode != 0:
+                print(f"⚠️ GitIngest CLI failed with exit code {result.returncode}")
+                print(f"⚠️ Error output: {result.stderr}")
+                print("Falling back to basic analysis")
+                gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+            else:
+                print(f"✅ GitIngest analysis completed successfully")
+                
+                # Read the output file - note that the default format might not be JSON
+                try:
+                    # First try to parse as JSON
+                    try:
+                        with open(output_file, 'r', encoding='utf-8') as f:
+                            content = f.read()
+                            try:
+                                gitingest_data = json.loads(content)
+                                print(f"✅ GitIngest data loaded as JSON from {output_file}")
+                            except json.JSONDecodeError:
+                                # If not JSON, convert the text output to a basic structure
+                                print(f"⚠️ GitIngest output is not in JSON format, converting text to structure")
+                                gitingest_data = {
+                                    "system_info": {
+                                        "detected_language": "Unknown",
+                                        "detected_technologies": [],
+                                    },
+                                    "repository_analysis": {
+                                        "summary": content[:5000],  # First 5000 chars as summary
+                                        "content_preview": content[:10000]  # First 10000 chars as preview
+                                    },
+                                    "success": True
+                                }
+                    except FileNotFoundError:
+                        print(f"⚠️ Output file not found at {output_file}")
+                        gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+                except Exception as e:
+                    print(f"⚠️ Error reading GitIngest output: {e}")
+                    gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+        else:
+            # Fall back to basic analysis if gitingest CLI is not available
+            gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+        
+        # Prepare the request payload with GitIngest data
+        payload = {
+            "repoUrl": repo_url,
+            "gitingestData": gitingest_data,
+            "userRequest": "Setup and run the repository"
+        }
+        
+        print(f"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
+        
+        # Make the API request
+        print(f"🌐 Making POST request to: {api_url}")
+        response = requests.post(api_url, json=payload, timeout=60)
+        
+        print(f"📥 API Response status code: {response.status_code}")
+        
+        if response.status_code == 200:
+            try:
+                data = response.json()
+                print(f"📄 API Response data received")
+                
+                # Extract setup commands from the response
+                if "setupInstructions" in data and "commands" in data["setupInstructions"]:
+                    commands = data["setupInstructions"]["commands"]
+                    print(f"✅ Successfully fetched {len(commands)} setup commands from API")
+                    
+                    # Print the commands for reference
+                    for i, cmd in enumerate(commands, 1):
+                        print(f"  {i}. {cmd}")
+                    
+                    return commands
+                else:
+                    print("⚠️ API response did not contain setupInstructions.commands field")
+                    print("📋 Available fields in response:")
+                    for key in data.keys():
+                        print(f"  - {key}")
+                    return []
+            except json.JSONDecodeError as e:
+                print(f"❌ Failed to parse API response as JSON: {e}")
+                print(f"Raw response: {response.text[:500]}...")
+                return []
+        else:
+            print(f"❌ API request failed with status code: {response.status_code}")
+            print(f"Error response: {response.text[:500]}...")
+            return []
+    except requests.exceptions.ConnectionError:
+        print(f"❌ Connection error: Could not connect to {api_url}")
+        print("⚠️ Make sure the API server is running at localhost:3000")
+        return []
+    except Exception as e:
+        print(f"❌ Error fetching setup commands from API: {e}")
+        import traceback
+        traceback.print_exc()
+        return []
+    finally:
+        # Clean up the temporary directory
+        print(f"🧹 Cleaning up temporary directory...")
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+def generate_basic_repo_analysis_from_url(repo_url):
+    """Generate basic repository analysis data from a repository URL."""
+    import tempfile
+    import subprocess
+    import os
+    import shutil
+    
+    # Create a temporary directory for cloning
+    temp_dir = tempfile.mkdtemp(prefix="repo_basic_analysis_")
+    
+    try:
+        print(f"📥 Cloning repository to {temp_dir} for basic analysis...")
+        clone_result = subprocess.run(
+            ["git", "clone", "--depth", "1", repo_url, temp_dir],
+            capture_output=True,
+            text=True
+        )
+        
+        if clone_result.returncode != 0:
+            print(f"❌ Failed to clone repository: {clone_result.stderr}")
+            return {
+                "system_info": {
+                    "platform": "linux",
+                    "python_version": "3.10",
+                    "detected_language": "Unknown",
+                    "detected_technologies": [],
+                    "file_count": 0,
+                    "repo_stars": 0,
+                    "repo_forks": 0,
+                    "primary_package_manager": "Unknown",
+                    "complexity_level": "low"
+                },
+                "repository_analysis": {
+                    "summary": f"Repository analysis for {repo_url}",
+                    "tree": "Failed to clone repository",
+                    "content_preview": "No content available"
+                },
+                "success": False
+            }
+        
+        print(f"✅ Repository cloned successfully for basic analysis")
+        
+        # Use the existing generate_basic_repo_analysis function
+        return generate_basic_repo_analysis(temp_dir)
+    finally:
+        # Clean up the temporary directory
+        print(f"🧹 Cleaning up temporary directory for basic analysis...")
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+def generate_basic_repo_analysis(repo_dir):
+    """Generate basic repository analysis when GitIngest is not available."""
+    import os
+    import subprocess
+    
+    # Detect language and technologies based on file extensions
+    file_extensions = {}
+    file_count = 0
+    
+    for root, _, files in os.walk(repo_dir):
+        for file in files:
+            file_count += 1
+            ext = os.path.splitext(file)[1].lower()
+            if ext:
+                file_extensions[ext] = file_extensions.get(ext, 0) + 1
+    
+    # Determine primary language
+    language_map = {
+        '.py': 'Python',
+        '.js': 'JavaScript',
+        '.ts': 'TypeScript',
+        '.jsx': 'JavaScript',
+        '.tsx': 'TypeScript',
+        '.java': 'Java',
+        '.cpp': 'C++',
+        '.c': 'C',
+        '.go': 'Go',
+        '.rs': 'Rust',
+        '.rb': 'Ruby',
+        '.php': 'PHP',
+        '.swift': 'Swift',
+        '.kt': 'Kotlin',
+        '.cs': 'C#'
+    }
+    
+    # Count files by language
+    language_counts = {}
+    for ext, count in file_extensions.items():
+        if ext in language_map:
+            lang = language_map[ext]
+            language_counts[lang] = language_counts.get(lang, 0) + count
+    
+    # Determine primary language
+    primary_language = max(language_counts.items(), key=lambda x: x[1])[0] if language_counts else "Unknown"
+    
+    # Detect package managers
+    package_managers = []
+    package_files = {
+        'requirements.txt': 'pip',
+        'setup.py': 'pip',
+        'pyproject.toml': 'pip',
+        'package.json': 'npm',
+        'yarn.lock': 'yarn',
+        'pnpm-lock.yaml': 'pnpm',
+        'Cargo.toml': 'cargo',
+        'go.mod': 'go',
+        'Gemfile': 'bundler',
+        'pom.xml': 'maven',
+        'build.gradle': 'gradle',
+        'composer.json': 'composer'
+    }
+    
+    for file, manager in package_files.items():
+        if os.path.exists(os.path.join(repo_dir, file)):
+            package_managers.append(manager)
+    
+    primary_package_manager = package_managers[0] if package_managers else "Unknown"
+    
+    # Get README content
+    readme_content = ""
+    for readme_name in ['README.md', 'README', 'README.txt', 'readme.md']:
+        readme_path = os.path.join(repo_dir, readme_name)
+        if os.path.exists(readme_path):
+            with open(readme_path, 'r', encoding='utf-8', errors='ignore') as f:
+                readme_content = f.read()
+            break
+    
+    # Try to get repository info
+    repo_info = {}
+    try:
+        # Get remote origin URL
+        cmd = ["git", "config", "--get", "remote.origin.url"]
+        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
+        if result.returncode == 0:
+            repo_info["url"] = result.stdout.strip()
+        
+        # Get commit count as a proxy for activity
+        cmd = ["git", "rev-list", "--count", "HEAD"]
+        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
+        if result.returncode == 0:
+            repo_info["commit_count"] = int(result.stdout.strip())
+    except Exception:
+        pass
+    
+    # Build the analysis data
+    return {
+        "system_info": {
+            "platform": "linux",  # Assuming Linux for container environment
+            "python_version": "3.10",  # Common Python version
+            "detected_language": primary_language,
+            "detected_technologies": list(language_counts.keys()),
+            "file_count": file_count,
+            "repo_stars": repo_info.get("stars", 0),
+            "repo_forks": repo_info.get("forks", 0),
+            "primary_package_manager": primary_package_manager,
+            "complexity_level": "medium"  # Default assumption
+        },
+        "repository_analysis": {
+            "summary": f"Repository analysis for {repo_dir}",
+            "readme_content": readme_content[:5000] if readme_content else "No README found",
+            "package_managers": package_managers,
+            "file_extensions": list(file_extensions.keys())
+        },
+        "success": True
+    }
+
+def get_setup_commands_from_local_api(repo_url, gitingest_data):
+    """Try to get setup commands from the local API."""
+    api_url = "http://localhost:3000/api/analyze-with-gitingest"
+    
+    # Prepare the request payload
+    payload = {
+        "repoUrl": repo_url,
+        "gitingestData": gitingest_data,
+        "userRequest": "Setup and run the repository"
+    }
+    
+    try:
+        # Make the API request
+        print(f"🌐 Making POST request to local API: {api_url}")
+        response = requests.post(api_url, json=payload, timeout=60)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if "setupInstructions" in data and "commands" in data["setupInstructions"]:
+                commands = data["setupInstructions"]["commands"]
+                print(f"✅ Successfully fetched {len(commands)} setup commands from local API")
+                for i, cmd in enumerate(commands, 1):
+                    print(f"  {i}. {cmd}")
+                return commands
+    except Exception as e:
+        print(f"❌ Error connecting to local API: {e}")
+    
+    return None
+
+if __name__ == "__main__":
+    # Parse command line arguments when script is run directly
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Create a Modal sandbox with GPU')
+    parser.add_argument('--gpu', type=str, default='A10G', help='GPU type (default: A10G)')
+    parser.add_argument('--repo-url', type=str, help='Repository URL to clone')
+    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('--use-api', action='store_true', help='Fetch setup commands from API')
+    
+    args = parser.parse_args()
+    
+    # Get setup commands from file if specified
+    setup_commands = args.setup_commands or []
+    
+    # If --use-api flag is set and repo_url is provided, fetch setup commands from API
+    if args.use_api and args.repo_url:
+        print("🔄 Using API to fetch setup commands")
+        api_commands = fetch_setup_commands_from_api(args.repo_url)
+        if api_commands:
+            setup_commands = api_commands
+            print(f"📋 Using {len(setup_commands)} commands from API")
+        else:
+            print("⚠️ Failed to get commands from API, no fallback commands will be used")
+            # Do not fall back to basic setup commands
+            setup_commands = []
+    
+    # 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}")
+    
+    # Print received setup commands for debugging
+    if setup_commands:
+        print(f"📋 Using {len(setup_commands)} setup commands:")
+        for i, cmd in enumerate(setup_commands, 1):
+            print(f"  {i}. {cmd}")
+            
+    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 reading commands file: {e}")
+    
+    # Execute setup script if provided
+    if args.setup_script:
+        print(f"📜 Setup script path: {args.setup_script}")
+        
+        # Verify script exists
+        if os.path.exists(args.setup_script):
+            print(f"✅ Script exists at: {args.setup_script}")
+            
+            # Check if script is executable
+            if not os.access(args.setup_script, os.X_OK):
+                print(f"⚠️ Script is not executable, setting permissions...")
+                try:
+                    os.chmod(args.setup_script, 0o755)
+                    print(f"✅ Set executable permissions on script")
+                except Exception as e:
+                    print(f"❌ Failed to set permissions: {e}")
+            
+            working_dir = args.working_dir or os.getcwd()
+            print(f"📂 Using working directory: {working_dir}")
+            
+            # Execute the script directly instead of through sandbox
+            try:
+                print(f"🔄 Executing script directly: bash {args.setup_script} {working_dir}")
+                result = subprocess.run(['bash', args.setup_script, working_dir], 
+                                       capture_output=True, text=True)
+                
+                print(f"📋 Script output:")
+                print(result.stdout)
+                
+                if result.returncode != 0:
+                    print(f"❌ Script execution failed with error code {result.returncode}")
+                    print(f"Error output: {result.stderr}")
+                else:
+                    print(f"✅ Script executed successfully")
+                    
+                # Skip the regular setup commands since we executed the script directly
+                setup_commands = []
+            except Exception as e:
+                print(f"❌ Failed to execute script: {e}")
+                # Fall back to running the script through sandbox
+                setup_commands = [f"bash {args.setup_script} {working_dir}"]
+                print("🔄 Falling back to running script through sandbox")
+        else:
+            print(f"❌ Script not found at: {args.setup_script}")
+            # Try to find the script in common locations
+            possible_paths = [
+                os.path.join(os.path.expanduser('~'), os.path.basename(args.setup_script)),
+                os.path.join('/tmp', os.path.basename(args.setup_script)),
+                os.path.join('/var/tmp', os.path.basename(args.setup_script))
+            ]
+            
+            found = False
+            for test_path in possible_paths:
+                if os.path.exists(test_path):
+                    print(f"🔍 Found script at alternative location: {test_path}")
+                    setup_commands = [f"bash {test_path} {args.working_dir or os.getcwd()}"]
+                    found = True
+                    break
+            
+            if not found:
+                print("❌ Could not find script in any location")
+                setup_commands = []
+    
+    try:
+        result = create_modal_sandbox(
+            args.gpu, 
+            args.repo_url, 
+            args.repo_name, 
+            setup_commands,
+            getattr(args, 'volume_name', None)
+        )
+        
+        print("\n⏳ Keeping the sandbox alive. Press Ctrl+C to exit (sandbox will continue running)...")
+        while True:
+            time.sleep(90)
+            print(".", end="", flush=True)
+    except KeyboardInterrupt:
+        print("\n👋 Script exited. The sandbox will continue running.")
+        if 'result' in locals() and result:
+            container_id = None
+            # Try to get container ID from the result dictionary
+            if isinstance(result, dict):
+                # The container ID might be stored in execution_history or elsewhere
+                # Let's try to find it in the current_dir which might contain it
+                current_dir = result.get('current_dir', '')
+                if 'container_id' in result:
+                    container_id = result['container_id']
+                elif hasattr(result, 'container_id'):
+                    container_id = result.container_id
+            
+            # If we still don't have the container ID, try to read it from the file
+            if not container_id:
+                try:
+                    with open(os.path.expanduser("~/.modal_last_container_id"), "r") as f:
+                        container_id = f.read().strip()
+                    print(f"📋 Retrieved container ID from file: {container_id}")
+                except Exception as e:
+                    print(f"⚠️ Could not read container ID from file: {e}")
+            
+            if container_id:
+                print(f"🚀 Starting shell in container: {container_id}")
+                try:
+                    # Execute the modal shell command directly
+                    shell_cmd = f"modal shell {container_id}"
+                    print(f"🔄 Executing: {shell_cmd}")
+                    subprocess.run(shell_cmd, shell=True)
+                except Exception as e:
+                    print(f"❌ Error starting shell: {e}")
+                    print(f"📝 You can manually connect using:")
+                    print(f"   modal shell {container_id}")
+            else:
+                print("⚠️ Could not determine container ID")
+                print("📝 You can manually connect using:")
+                print("   modal container list")
+                print("   modal shell <CONTAINER_ID>")