gitarsenal-cli 1.5.6 → 1.5.7

package/python/test_modalSandboxScript.py

@@ -326,23 +326,14 @@ def handle_huggingface_login(sandbox, current_dir):
     
     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"""
-    print("\n🔍 DEBUG: Starting OpenAI LLM debugging...")
+    print("\n🔍 DEBUG: Starting LLM debugging...")
     print(f"🔍 DEBUG: Command: {command}")
     print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
     print(f"🔍 DEBUG: Current directory: {current_dir}")
     print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
-    print(f"🔍 DEBUG: API key provided: {'Yes' if api_key else 'No'}")
     
     # Define _to_str function locally to avoid NameError
     def _to_str(maybe_bytes):
@@ -387,8 +378,8 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                 from fetch_modal_tokens import get_tokens
                 _, _, api_key = get_tokens()
                 if api_key:
-                    print("✅ Successfully fetched OpenAI API key from server")
-                    print(f"🔍 DEBUG: Fetched OpenAI API key value: {api_key}")
+                    # print("✅ Successfully fetched OpenAI API key from server")
+                    # print(f"🔍 DEBUG: Fetched OpenAI API key value: {api_key}")
                     # Set in environment for this session
                     os.environ["OPENAI_API_KEY"] = api_key
                 else:
@@ -656,11 +647,26 @@ But it failed with this error:
 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
+IMPORTANT GUIDELINES:
+1. 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
+
+2. If the error indicates a file is not found (e.g., "No such file or directory", "cannot open", "not found"):
+   - FIRST try to search for the file using: find . -name "filename" -type f 2>/dev/null
+   - If found, navigate to that directory using: cd /path/to/directory
+   - If not found, then consider creating the file or installing missing packages
+
+3. For missing packages or dependencies:
+   - Use pip install for Python packages
+   - Use apt-get install for system packages
+   - Use npm install for Node.js packages
+
+4. For authentication issues:
+   - For wandb login: suggest 'wandb login YOUR_API_KEY' (system will prompt for actual key)
+   - For huggingface: suggest 'huggingface-cli login' (system will prompt for token)
 
 Do not provide any explanations, just the exact command to run.
 """
@@ -695,7 +701,7 @@ Do not provide any explanations, just the exact command to run.
         payload = {
             "model": model_name,
             "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": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue. Analyze the issue first, understand why it's happening, then provide the command to fix it. For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found. For missing packages, use appropriate package managers (pip, apt-get, npm). For authentication, suggest login commands with placeholders."},
                 {"role": "user", "content": prompt}
             ],
             "temperature": 0.2,
@@ -793,7 +799,7 @@ Do not provide any explanations, just the exact command to run.
     for model in models_to_try:
         result, error = try_api_call(model)
         if result:
-            print(f"✅ Successfully got response from {model}")
+            # print(f"✅ Successfully got response from {model}")
             break
         else:
             print(f"⚠️ Failed to get response from {model}: {error}")
@@ -806,7 +812,7 @@ Do not provide any explanations, just the exact command to run.
     # Process the response
     try:
         print(f"🔍 DEBUG: Processing OpenAI response...")
-        print(f"🔍 DEBUG: Response structure: {list(result.keys())}")
+        # print(f"🔍 DEBUG: Response structure: {list(result.keys())}")
         print(f"🔍 DEBUG: Choices count: {len(result.get('choices', []))}")
         
         fix_command = result["choices"][0]["message"]["content"].strip()
@@ -931,1474 +937,6 @@ def prompt_for_hf_token():
         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):
-    # Import the credentials manager if available
-    try:
-        from credentials_manager import CredentialsManager
-        credentials_manager = CredentialsManager()
-    except ImportError:
-        credentials_manager = None
-        print("⚠️ Credentials manager not found, will use environment variables or prompt for credentials")
-    
-    # Check if Modal is authenticated
-    try:
-        # Try to import modal first to check if it's installed
-        import modal
-        
-        # Try to access Modal token to check authentication
-        try:
-            # This will raise an exception if not authenticated
-            modal.config.get_current_workspace_name()
-            print("✅ Authentication verified")
-        except modal.exception.AuthError:
-            print("\n" + "="*80)
-            print("🔑 AUTHENTICATION REQUIRED")
-            print("="*80)
-            print("GitArsenal requires authentication to create cloud environments.")
-            
-            # Try to get token from credentials manager
-            modal_token = None
-            if credentials_manager:
-                try:
-                    modal_token = credentials_manager.get_modal_token()
-                    if modal_token:
-                        # Set the token in the environment
-                        os.environ["MODAL_TOKEN_ID"] = modal_token
-                        print("✅ Modal token set from credentials manager")
-                        
-                        # Try to authenticate with the token
-                        try:
-                            import subprocess
-                            token_result = subprocess.run(
-                                ["modal", "token", "set", "--from-env"], 
-                                capture_output=True, text=True
-                            )
-                            if token_result.returncode == 0:
-                                print("✅ Successfully authenticated with Modal")
-                            else:
-                                print(f"⚠️ Failed to authenticate with Modal: {token_result.stderr}")
-                                print("\nPlease authenticate manually:")
-                                print("1. Run 'modal token new' to get a new token")
-                                print("2. Then restart this command")
-                                return None
-                        except Exception as e:
-                            print(f"⚠️ Error setting Modal token: {e}")
-                            return None
-                except Exception as e:
-                    print(f"⚠️ Error getting Modal token: {e}")
-            
-            if not modal_token:
-                print("\nTo authenticate with Modal, you need to:")
-                print("1. Create a Modal account at https://modal.com if you don't have one")
-                print("2. Run the following command to get a token:")
-                print("   modal token new")
-                print("3. Then set up your credentials in GitArsenal:")
-                print("   ./gitarsenal.py credentials set modal_token")
-                print("\nAfter completing these steps, try your command again.")
-                print("="*80)
-                return None
-    except ImportError:
-        print("\n" + "="*80)
-        print("❌ MODAL PACKAGE NOT INSTALLED")
-        print("="*80)
-        print("GitArsenal requires the Modal package to be installed.")
-        print("\nTo install Modal, run:")
-        print("   pip install modal")
-        print("\nAfter installation, authenticate with Modal:")
-        print("1. Run 'modal token new'")
-        print("2. Then run './gitarsenal.py credentials set modal_token'")
-        print("="*80)
-        return None
-    except Exception as e:
-        print(f"⚠️ Error checking Modal authentication: {e}")
-        print("Continuing anyway, but Modal operations may fail")
-    
-    # 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 = {
-        'T4': {'gpu': 'T4', 'memory': 16},
-        'L4': {'gpu': 'L4', 'memory': 24},
-        'A10G': {'gpu': 'A10G', 'memory': 24},
-        'A100-40': {'gpu': 'A100-SXM4-40GB', 'memory': 40},
-        'A100-80': {'gpu': 'A100-80', 'memory': 80},
-        'L40S': {'gpu': 'L40S', 'memory': 48},
-        'H100': {'gpu': 'H100', 'memory': 80},
-        'H200': {'gpu': 'H200', 'memory': 141},
-        'B200': {'gpu': 'B200', 'memory': 96}
-    }
-    
-    if gpu_type not in gpu_configs:
-        print(f"⚠️ Unknown GPU type: {gpu_type}. Using A10G as default.")
-        gpu_type = 'A10G'
-    
-    gpu_spec = gpu_configs[gpu_type]
-    print(f"🚀 Creating 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 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("🔍 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.
-        
-        The debug_with_llm parameter controls whether to use OpenAI to debug failed commands.
-        By default, this is set to True to ensure all command failures are debugged.
-        """
-        # 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"
-                # BUT we need to be careful about nested directories like /root/litex/litex
-                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)):
-                    
-                    # Advanced check: analyze directory contents to determine if navigation makes sense
-                    print(f"🔍 Analyzing directory contents to determine navigation necessity...")
-                    
-                    # Get current directory contents
-                    current_contents_cmd = "ls -la"
-                    current_result = sandbox.exec("bash", "-c", current_contents_cmd)
-                    current_result.wait()
-                    current_contents = _to_str(current_result.stdout) if current_result.stdout else ""
-                    
-                    # Check if target directory exists
-                    test_cmd = f"test -d \"{target_dir}\""
-                    test_result = sandbox.exec("bash", "-c", test_cmd)
-                    test_result.wait()
-                    
-                    if test_result.returncode == 0:
-                        # Target directory exists, get its contents
-                        target_contents_cmd = f"ls -la \"{target_dir}\""
-                        target_result = sandbox.exec("bash", "-c", target_contents_cmd)
-                        target_result.wait()
-                        target_contents = _to_str(target_result.stdout) if target_result.stdout else ""
-                        
-                        try:
-                            # Call LLM for analysis with the dedicated function
-                            llm_response = analyze_directory_navigation_with_llm(current_dir, target_dir, current_contents, target_contents, api_key)
-                            
-                            # Extract decision from LLM response
-                            if llm_response and "NAVIGATE" in llm_response.upper():
-                                print(f"🤖 LLM Analysis: Navigation makes sense - contents are different")
-                                print(f"📂 Current: {current_dir}")
-                                print(f"🎯 Target: {target_dir}")
-                                print(f"🔄 Proceeding with navigation...")
-                            else:
-                                print(f"🤖 LLM Analysis: Navigation is redundant - contents are similar")
-                                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}", ""
-                                
-                        except Exception as e:
-                            print(f"⚠️ LLM analysis failed: {e}")
-                            print(f"🔄 Falling back to simple directory existence check...")
-                            # Fallback to simple check
-                            print(f"🔍 Detected nested directory '{target_dir}' exists in current location")
-                            print(f"📂 Current: {current_dir}")
-                            print(f"🎯 Target: {target_dir}")
-                            print(f"🔄 Proceeding with navigation to nested directory...")
-                    else:
-                        # No nested directory exists, so this is truly redundant
-                        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...")
-                print(f"🔍 DEBUG: Command that failed: {cmd_to_execute}")
-                print(f"🔍 DEBUG: Exit code: {exit_code}")
-                print(f"🔍 DEBUG: stderr length: {len(stderr_buffer)}")
-                print(f"🔍 DEBUG: stdout length: {len(stdout_buffer)}")
-                
-                # Ensure we have a non-empty error message to debug
-                if not stderr_buffer.strip() and stdout_buffer.strip():
-                    print("⚠️ stderr is empty but stdout contains content, using stdout for debugging")
-                    stderr_buffer = stdout_buffer
-                
-                # 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 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)
-                
-                print(f"🔍 DEBUG: About to call call_openai_for_debug...")
-                print(f"🔍 DEBUG: Command: {cmd_to_execute}")
-                print(f"🔍 DEBUG: Debug output length: {len(debug_output)}")
-                print(f"🔍 DEBUG: Current directory: {current_dir}")
-                print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
-                print(f"🔍 DEBUG: Debug output preview: {debug_output[:200]}...")
-                
-                # Get the API key from environment or use the one that was fetched earlier
-                api_key = os.environ.get("OPENAI_API_KEY")
-                fix_command = call_openai_for_debug(cmd_to_execute, debug_output, api_key=api_key, current_dir=current_dir, sandbox=sandbox)
-                
-                print(f"🔍 DEBUG: call_openai_for_debug returned: {fix_command}")
-                
-                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
-        # Set to track if we should stop execution due to critical failures
-        stop_execution = False
-        
-        for i, cmd in enumerate(setup_commands, 1):
-            if stop_execution:
-                print(f"\n⚠️ Skipping command {i}/{len(setup_commands)} due to previous critical failure")
-                continue
-                
-            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)
-                # If cd command fails, try to fix it before continuing
-                if not success:
-                    print(f"❌ Command failed in container: {cmd}")
-                    print(f"❌ Error: {stderr}")
-                    # Try to fix the cd command with LLM debugging
-                    print("🔄 Attempting to fix cd command before continuing...")
-                    retry_success, retry_stdout, retry_stderr = run_command(cmd, debug_with_llm=True)
-                    if not retry_success:
-                        print("⚠️ Failed to fix cd command, this may cause subsequent commands to fail")
-                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:
-                    print(f"❌ Command failed in container: {cmd}")
-                    print(f"❌ Error: {stderr}")
-                    # Try to fix the git clone command with LLM debugging
-                    print("🔄 Attempting to fix git clone command before continuing...")
-                    retry_success, retry_stdout, retry_stderr = run_command(cmd, debug_with_llm=True)
-                    if not retry_success:
-                        print("⚠️ Failed to fix git clone command, this may cause subsequent commands to fail")
-                        print("🔄 Continuing with next command...")
-            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}")
-                    
-                    # Try to fix the command with LLM debugging and retry up to 3 times
-                    max_fix_attempts = 3
-                    for attempt in range(max_fix_attempts):
-                        print(f"🔄 Attempting to fix command (attempt {attempt+1}/{max_fix_attempts})...")
-                        retry_success, retry_stdout, retry_stderr = run_command(cmd, debug_with_llm=True)
-                        if retry_success:
-                            print(f"✅ Command fixed and executed successfully on attempt {attempt+1}")
-                            break
-                        else:
-                            print(f"❌ Fix attempt {attempt+1} failed")
-                    
-                    if not retry_success:
-                        print("⚠️ Failed to fix command after multiple attempts")
-                        # Ask if user wants to continue with next command or abort
-                        try:
-                            continue_choice = input("Continue with next command? (y/n): ").strip().lower()
-                            if continue_choice != 'y':
-                                print("🛑 Aborting setup commands execution")
-                                stop_execution = True
-                                break
-                            print("🔄 Continuing with next command...")
-                        except:
-                            # In case we can't get user input, ask if the command is critical
-                            if "pip install" in cmd or "git clone" in cmd or "setup.py" in cmd:
-                                print("⚠️ Critical command failed and couldn't be fixed")
-                                print("⚠️ Subsequent commands likely to fail, stopping execution")
-                                stop_execution = True
-                                break
-                            else:
-                                print("⚠️ Unable to get user input, continuing with next command...")
-                
-        # 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"✅ 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 handle_interactive_input(prompt, is_password=False):
     """Handle interactive input from the user with optional password masking"""
@@ -2644,7 +1182,6 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
             subprocess.run(["service", "ssh", "start"], check=True)
 
 # Now modify the create_modal_ssh_container function to use the standalone ssh_container_function
-
 def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
                                volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False):
     """Create a Modal SSH container with GPU support and tunneling"""