gitarsenal-cli 1.5.4 → 1.5.6

package/python/test_modalSandboxScript.py.bak

@@ -1,3672 +0,0 @@
-import os
-import sys
-import time
-import subprocess
-import json
-import re
-import datetime
-import getpass
-import requests
-import secrets
-import string
-import argparse
-from pathlib import Path
-
-# Parse command-line arguments
-parser = argparse.ArgumentParser(description='Launch a Modal sandbox')
-parser.add_argument('--proxy-url', help='URL of the proxy server')
-parser.add_argument('--proxy-api-key', help='API key for the proxy server')
-parser.add_argument('--gpu', default='A10G', help='GPU type to use')
-parser.add_argument('--repo-url', help='Repository URL')
-parser.add_argument('--volume-name', help='Volume name')
-parser.add_argument('--use-api', action='store_true', help='Use API to fetch setup commands')
-
-# Parse only known args to avoid conflicts with other arguments
-args, unknown = parser.parse_known_args()
-
-# Set proxy URL and API key in environment variables if provided
-if args.proxy_url:
-    os.environ["MODAL_PROXY_URL"] = args.proxy_url
-    # print(f"✅ Set MODAL_PROXY_URL from command line")
-    
-if args.proxy_api_key:
-    os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
-    # print(f"✅ Set MODAL_PROXY_API_KEY from command line")
-
-# First, try to fetch tokens from the proxy server
-try:
-    # Import the fetch_modal_tokens module
-    # print("🔄 Fetching tokens from proxy server...")
-    from fetch_modal_tokens import get_tokens
-    token_id, token_secret = get_tokens()
-    # print(f"✅ Tokens fetched successfully")
-    
-    # Explicitly set the environment variables again to be sure
-    os.environ["MODAL_TOKEN_ID"] = token_id
-    os.environ["MODAL_TOKEN_SECRET"] = token_secret
-    
-    # Also set the old environment variable for backward compatibility
-    os.environ["MODAL_TOKEN"] = token_id
-    
-    # Set token variables for later use
-    token = token_id  # For backward compatibility
-except Exception as e:
-    print(f"⚠️ Error fetching Modal tokens: {e}")
-    
-    # Apply the comprehensive Modal token solution as fallback
-    try:
-        # Import the comprehensive solution module
-        # print("🔄 Applying comprehensive Modal token solution...")
-        import modal_token_solution
-        # print("✅ Comprehensive Modal token solution applied")
-        
-        # Set token variables for later use
-        token = modal_token_solution.TOKEN_ID  # For backward compatibility
-    except Exception as e:
-        # print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
-        
-        # Fall back to the authentication patch
-        try:
-            # Import the patch module
-            # print("🔄 Falling back to Modal authentication patch...")
-            import modal_auth_patch
-            # print("✅ Modal authentication patch applied")
-            
-            # Set token variables for later use
-            token = modal_auth_patch.TOKEN_ID  # For backward compatibility
-        except Exception as e:
-            # print(f"⚠️ Error applying Modal authentication patch: {e}")
-            
-            # Fall back to fix_modal_token.py
-            try:
-                # Execute the fix_modal_token.py script
-                print("🔄 Falling back to fix_modal_token.py...")
-                result = subprocess.run(
-                    ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
-                    capture_output=True,
-                    text=True
-                )
-                
-                # Print the output but hide sensitive information
-                output_lines = result.stdout.split('\n')
-                for line in output_lines:
-                    if 'TOKEN_ID' in line or 'TOKEN_SECRET' in line or 'token_id' in line or 'token_secret' in line:
-                        # Hide the actual token values
-                        if '=' in line:
-                            parts = line.split('=', 1)
-                            if len(parts) == 2:
-                                print(f"{parts[0]}= [HIDDEN]")
-                        else:
-                            print(line.replace('ak-sLhYqCjkvixiYcb9LAuCHp', '[HIDDEN]').replace('as-fPzD0Zm0dl6IFAEkhaH9pq', '[HIDDEN]'))
-                    else:
-                        print(line)
-                
-                if result.returncode != 0:
-                    print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
-                    if result.stderr:
-                        print(f"Error: {result.stderr}")
-                
-                # Set token variables for later use
-                token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
-            except Exception as e:
-                print(f"⚠️ Error running fix_modal_token.py: {e}")
-                
-                # Last resort: use hardcoded tokens
-                token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
-
-# Print debug info
-# print(f"🔍 DEBUG: Checking environment variables")
-# print(f"🔍 Token ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
-# print(f"🔍 Token secret exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
-# print(f"🔍 Token exists: {'Yes' if os.environ.get('MODAL_TOKEN') else 'No'}")
-if os.environ.get('MODAL_TOKEN_ID'):
-    print(f"🔍 Token ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
-if os.environ.get('MODAL_TOKEN_SECRET'):
-    print(f"🔍 Token secret length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
-if os.environ.get('MODAL_TOKEN'):
-    print(f"🔍 Token length: {len(os.environ.get('MODAL_TOKEN'))}")
-# print(f"✅ Token setup completed")
-
-# Import modal after token setup
-import modal
-
-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")
-    
-    # Try to use credentials manager first
-    api_key = None
-    try:
-        from credentials_manager import CredentialsManager
-        credentials_manager = CredentialsManager()
-        api_key = credentials_manager.get_wandb_api_key()
-    except ImportError:
-        # Fall back to direct input if credentials_manager is not available
-        pass
-    
-    # If credentials manager didn't provide a key, use direct input
-    if not api_key:
-        # 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:
-        # Use the CredentialsManager to get the API key
-        try:
-            from credentials_manager import CredentialsManager
-            credentials_manager = CredentialsManager()
-            api_key = credentials_manager.get_openai_api_key()
-            if not api_key:
-                print("❌ No API key provided. Skipping debugging.")
-                return None
-        except ImportError:
-            # Fall back to direct input if credentials_manager module is not available
-            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"""
-    # Try to use credentials manager first
-    try:
-        from credentials_manager import CredentialsManager
-        credentials_manager = CredentialsManager()
-        token = credentials_manager.get_huggingface_token()
-        if token:
-            return token
-    except ImportError:
-        # Fall back to direct input if credentials_manager is not available
-        pass
-    
-    # Traditional direct input method as fallback
-    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):
-    # 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-40GB': {'gpu': 'A100-SXM4-40GB', 'memory': 40},
-        'A100-80GB': {'gpu': 'A100-80GB', 'memory': 80},
-        'L40S': {'gpu': 'L40S', 'memory': 48},
-        'H100': {'gpu': 'H100', 'memory': 80},
-        'H200': {'gpu': 'H200', 'memory': 141},
-        'B200': {'gpu': 'B200', 'memory': 96}
-    }
-    
-    if gpu_type not in gpu_configs:
-        print(f"⚠️ Unknown GPU type: {gpu_type}. Using A10G as default.")
-        gpu_type = 'A10G'
-    
-    gpu_spec = gpu_configs[gpu_type]
-    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.
-        """
-        # 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...")
-                
-                # 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"✅ 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"""
-    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 generate_random_password(length=16):
-    """Generate a random password for SSH access"""
-    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
-    password = ''.join(secrets.choice(alphabet) for i in range(length))
-    return password
-
-# First, add the standalone ssh_container function at the module level, before the create_modal_ssh_container function
-
-# Define a module-level ssh container function
-ssh_app = modal.App("ssh-container-app")
-
-@ssh_app.function(
-    image=modal.Image.debian_slim()
-        .apt_install(
-            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
-            "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
-            "gpg", "ca-certificates", "software-properties-common"
-        )
-        .pip_install("uv", "modal")  # Fast Python package installer and Modal
-        .run_commands(
-            # Create SSH directory
-            "mkdir -p /var/run/sshd",
-            "mkdir -p /root/.ssh",
-            "chmod 700 /root/.ssh",
-            
-            # Configure SSH server
-            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
-            
-            # SSH keep-alive settings
-            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
-            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
-            
-            # Generate SSH host keys
-            "ssh-keygen -A",
-            
-            # Install Modal CLI
-            "pip install modal",
-            
-            # Set up a nice bash prompt
-            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
-        ),
-    timeout=3600,  # Default 1 hour timeout
-    gpu="a10g",    # Default GPU - this will be overridden when called
-    cpu=2,
-    memory=8192,
-    serialized=True,
-)
-def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_commands=None):
-    import subprocess
-    import time
-    import os
-    
-    # Set root password
-    subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
-    
-    # Start SSH service
-    subprocess.run(["service", "ssh", "start"], check=True)
-    
-    # Setup environment
-    os.environ['PS1'] = r'\[\e[1;32m\]modal:\[\e[1;34m\]\w\[\e[0m\]$ '
-    
-    # Clone repository if provided
-    if repo_url:
-        repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
-        print(f"📥 Cloning repository: {repo_url}")
-        
-        try:
-            subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
-            print(f"✅ Repository cloned successfully: {repo_name_from_url}")
-            
-            # Change to repository directory
-            repo_dir = f"/root/{repo_name_from_url}"
-            if os.path.exists(repo_dir):
-                os.chdir(repo_dir)
-                print(f"📂 Changed to repository directory: {repo_dir}")
-            
-        except subprocess.CalledProcessError as e:
-            print(f"❌ Failed to clone repository: {e}")
-    
-    # Run setup commands if provided
-    if setup_commands:
-        print(f"⚙️ Running {len(setup_commands)} setup commands...")
-        for i, cmd in enumerate(setup_commands, 1):
-            print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
-            try:
-                result = subprocess.run(cmd, shell=True, check=True, 
-                                      capture_output=True, text=True)
-                if result.stdout:
-                    print(f"✅ Output: {result.stdout}")
-            except subprocess.CalledProcessError as e:
-                print(f"❌ Command failed: {e}")
-                if e.stderr:
-                    print(f"❌ Error: {e.stderr}")
-    
-    # Get container info
-    print("🔍 Container started successfully!")
-    print(f"🆔 Container ID: {os.environ.get('MODAL_TASK_ID', 'unknown')}")
-    
-    # Keep the container running
-    while True:
-        time.sleep(30)
-        # Check if SSH service is still running
-        try:
-            subprocess.run(["service", "ssh", "status"], check=True, 
-                         capture_output=True)
-        except subprocess.CalledProcessError:
-            print("⚠️ SSH service stopped, restarting...")
-            subprocess.run(["service", "ssh", "start"], check=True)
-
-# 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):
-    """Create a Modal SSH container with GPU support and tunneling"""
-    
-    # Check if Modal is authenticated
-    try:
-        # Print all environment variables for debugging
-        print("🔍 DEBUG: Checking environment variables")
-        modal_token_id = os.environ.get("MODAL_TOKEN_ID")
-        modal_token = os.environ.get("MODAL_TOKEN")
-        print(f"🔍 token exists: {'Yes' if modal_token_id else 'No'}")
-        print(f"🔍 token exists: {'Yes' if modal_token else 'No'}")
-        if modal_token_id:
-            print(f"🔍 token length: {len(modal_token_id)}")
-        if modal_token:
-            print(f"🔍 token length: {len(modal_token)}")
-        
-        # Try to access Modal token to check authentication
-        try:
-            # Check if token is set in environment
-            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
-            if not modal_token_id:
-                print("⚠️ MODAL_TOKEN_ID not found in environment.")
-                # Try to get from MODAL_TOKEN
-                modal_token = os.environ.get("MODAL_TOKEN")
-                if modal_token:
-                    print("✅ Found token in environment variable")
-                    os.environ["MODAL_TOKEN_ID"] = modal_token
-                    modal_token_id = modal_token
-                    print(f"✅ Set token (length: {len(modal_token)})")
-            
-            if modal_token_id:
-                print(f"✅ token found (length: {len(modal_token_id)})")
-                
-                # Use the comprehensive fix_modal_token script
-                try:
-                    # Execute the fix_modal_token.py script
-                    import subprocess
-                    print(f"🔄 Running fix_modal_token.py to set up Modal token...")
-                    result = subprocess.run(
-                        ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
-                        capture_output=True,
-                        text=True
-                    )
-                    
-                    # Print the output
-                    print(result.stdout)
-                    
-                    if result.returncode != 0:
-                        print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
-                        if result.stderr:
-                            print(f"Error: {result.stderr}")
-                            
-                    print(f"✅ token setup completed")
-                except Exception as e:
-                    print(f"⚠️ Error running fix_modal_token.py: {e}")
-            else:
-                print("❌ No token found in environment variables")
-                # Try to get from file as a last resort
-                try:
-                    home_dir = os.path.expanduser("~")
-                    modal_dir = os.path.join(home_dir, ".modal")
-                    token_file = os.path.join(modal_dir, "token.json")
-                    if os.path.exists(token_file):
-                        print(f"🔍 Found Modal token file at {token_file}")
-                        with open(token_file, 'r') as f:
-                            import json
-                            token_data = json.load(f)
-                            if "token_id" in token_data:
-                                modal_token_id = token_data["token_id"]
-                                os.environ["MODAL_TOKEN_ID"] = modal_token_id
-                                os.environ["MODAL_TOKEN"] = modal_token_id
-                                print(f"✅ Loaded token from file (length: {len(modal_token_id)})")
-                            else:
-                                print("❌ Token file does not contain token_id")
-                    else:
-                        print("❌ token file not found")
-                except Exception as e:
-                    print(f"❌ Error loading token from file: {e}")
-                
-                if not os.environ.get("MODAL_TOKEN_ID"):
-                    print("❌ Could not find Modal token in any location")
-                    return None
-                
-        except Exception as e:
-            print(f"⚠️ Error checking Modal token: {e}")
-            # Try to use the token from environment
-            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
-            modal_token = os.environ.get("MODAL_TOKEN")
-            if modal_token_id:
-                print(f"🔄 Using token from environment (length: {len(modal_token_id)})")
-            elif modal_token:
-                print(f"🔄 Using token from environment (length: {len(modal_token)})")
-                os.environ["MODAL_TOKEN_ID"] = modal_token
-                modal_token_id = modal_token
-            else:
-                print("❌ No Modal token available. Cannot proceed.")
-                return None
-            
-            # Set it in both environment variables
-            os.environ["MODAL_TOKEN_ID"] = modal_token_id
-            os.environ["MODAL_TOKEN"] = modal_token_id
-            print("✅ Set both token and id environment variables")
-    except Exception as e:
-        print(f"⚠️ Error checking Modal authentication: {e}")
-        print("Continuing anyway, but Modal operations may fail")
-    
-    # Generate a unique app name with timestamp to avoid conflicts
-    timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
-    app_name = f"ssh-container-{timestamp}"
-    
-    gpu_configs = {
-        'T4': {'gpu': 't4', 'memory': 16},
-        'L4': {'gpu': 'l4', 'memory': 24},
-        'A10G': {'gpu': 'a10g', 'memory': 24},
-        'A100-40GB': {'gpu': 'a100', 'memory': 40},
-        'A100-80GB': {'gpu': 'a100-80gb', 'memory': 80},
-        'L40S': {'gpu': 'l40s', 'memory': 48},
-        'H100': {'gpu': 'h100', 'memory': 80},
-        'H200': {'gpu': 'h200', 'memory': 141},
-        'B200': {'gpu': 'b200', 'memory': 96}
-    }
-    
-    if gpu_type not in gpu_configs:
-        print(f"⚠️ Unknown GPU type: {gpu_type}. Using A10G as default.")
-        gpu_type = 'A10G'
-    
-    gpu_spec = gpu_configs[gpu_type]
-    print(f"🚀 Creating SSH container with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
-    
-    # Generate or use provided SSH password
-    if not ssh_password:
-        ssh_password = generate_random_password()
-        print(f"🔐 Generated SSH password: {ssh_password}")
-    
-    # Setup volume if specified
-    volume = None
-    volume_mount_path = "/persistent"
-    
-    if volume_name:
-        print(f"📦 Setting up volume: {volume_name}")
-        try:
-            volume = modal.Volume.from_name(volume_name, create_if_missing=True)
-            print(f"✅ Volume '{volume_name}' ready for use")
-        except Exception as e:
-            print(f"⚠️ Could not setup volume '{volume_name}': {e}")
-            print("⚠️ Continuing without persistent volume")
-            volume = None
-    else:
-        # Create a default volume for this session
-        default_volume_name = f"ssh-vol-{timestamp}"
-        print(f"📦 Creating default volume: {default_volume_name}")
-        try:
-            volume = modal.Volume.from_name(default_volume_name, create_if_missing=True)
-            volume_name = default_volume_name
-            print(f"✅ Default volume '{default_volume_name}' created")
-        except Exception as e:
-            print(f"⚠️ Could not create default volume: {e}")
-            print("⚠️ Continuing without persistent volume")
-            volume = None
-    
-    # Print debug info for authentication
-    print("🔍 Modal authentication debug info:")
-    modal_token = os.environ.get("MODAL_TOKEN_ID")
-    print(f"  - token in env: {'Yes' if modal_token else 'No'}")
-    print(f"  - Token length: {len(modal_token) if modal_token else 'N/A'}")
-    
-    # Verify we can create a Modal app
-    try:
-        print("🔍 Testing app creation...")
-        app = modal.App(app_name)
-        print("✅ Created app successfully")
-    except Exception as e:
-        print(f"❌ Error creating app: {e}")
-        return None
-
-    # Create SSH-enabled image
-    try:
-        print("📦 Building SSH-enabled image...")
-        ssh_image = (
-            modal.Image.debian_slim()
-            .apt_install(
-                "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
-                "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
-                "gpg", "ca-certificates", "software-properties-common"
-            )
-            .pip_install("uv", "modal")  # Fast Python package installer and Modal
-            .run_commands(
-                # Create SSH directory
-                "mkdir -p /var/run/sshd",
-                "mkdir -p /root/.ssh",
-                "chmod 700 /root/.ssh",
-                
-                # Configure SSH server
-                "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
-                "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-                "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
-                
-                # SSH keep-alive settings
-                "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
-                "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
-                
-                # Generate SSH host keys
-                "ssh-keygen -A",
-                
-                # Set up a nice bash prompt
-                "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
-            )
-        )
-        print("✅ SSH image built successfully")
-    except Exception as e:
-        print(f"❌ Error building SSH image: {e}")
-        return None
-        
-    # Configure volumes if available
-    volumes_config = {}
-    if volume:
-        volumes_config[volume_mount_path] = volume
-        
-    # Define the SSH container function
-    @app.function(
-        image=ssh_image,
-        timeout=timeout_minutes * 60,  # Convert to seconds
-        gpu=gpu_spec['gpu'],
-        cpu=2,
-        memory=8192,
-        serialized=True,
-        volumes=volumes_config if volumes_config else None,
-    )
-    def ssh_container_function():
-        """Start SSH container with password authentication and optional setup."""
-        import subprocess
-        import time
-        import os
-        
-        # Set root password
-        subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
-        
-        # Start SSH service
-        subprocess.run(["service", "ssh", "start"], check=True)
-        
-        # Clone repository if provided
-        if repo_url:
-            repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
-            print(f"📥 Cloning repository: {repo_url}")
-            
-            try:
-                subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
-                print(f"✅ Repository cloned successfully: {repo_name_from_url}")
-                
-                # Change to repository directory
-                repo_dir = f"/root/{repo_name_from_url}"
-                if os.path.exists(repo_dir):
-                    os.chdir(repo_dir)
-                    print(f"📂 Changed to repository directory: {repo_dir}")
-                
-            except subprocess.CalledProcessError as e:
-                print(f"❌ Failed to clone repository: {e}")
-        
-        # Run setup commands if provided
-        if setup_commands:
-            print(f"⚙️ Running {len(setup_commands)} setup commands...")
-            for i, cmd in enumerate(setup_commands, 1):
-                print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
-                try:
-                    result = subprocess.run(cmd, shell=True, check=True, 
-                                          capture_output=True, text=True)
-                    if result.stdout:
-                        print(f"✅ Output: {result.stdout}")
-                except subprocess.CalledProcessError as e:
-                    print(f"❌ Command failed: {e}")
-                    if e.stderr:
-                        print(f"❌ Error: {e.stderr}")
-        
-        # Create SSH tunnel
-        with modal.forward(22, unencrypted=True) as tunnel:
-            host, port = tunnel.tcp_socket
-            
-            print("\n" + "=" * 80)
-            print("🎉 SSH CONTAINER IS READY!")
-            print("=" * 80)
-            print(f"🌐 SSH Host: {host}")
-            print(f"🔌 SSH Port: {port}")
-            print(f"👤 Username: root")
-            print(f"🔐 Password: {ssh_password}")
-            print()
-            print("🔗 CONNECT USING THIS COMMAND:")
-            print(f"ssh -p {port} root@{host}")
-            print("=" * 80)
-            
-            # Keep the container running
-            while True:
-                time.sleep(30)
-                # Check if SSH service is still running
-                try:
-                    subprocess.run(["service", "ssh", "status"], check=True, 
-                                 capture_output=True)
-                except subprocess.CalledProcessError:
-                    print("⚠️ SSH service stopped, restarting...")
-                    subprocess.run(["service", "ssh", "start"], check=True)
-    
-    # Run the container
-    try:
-        print("⏳ Starting container... This may take 1-2 minutes...")
-        
-        # Start the container in a new thread to avoid blocking
-        with modal.enable_output():
-            with app.run():
-                ssh_container_function.remote()
-                
-        # Clean up Modal token after container is successfully created
-        cleanup_modal_token()
-        
-        return {
-            "app_name": app_name,
-            "ssh_password": ssh_password,
-            "volume_name": volume_name
-        }
-    except Exception as e:
-        print(f"❌ Error running container: {e}")
-        return None
-
-def is_local_server_running(url, timeout=2):
-    """Check if a local server is running by attempting a connection."""
-    import requests
-    try:
-        response = requests.get(url, timeout=timeout)
-        return True
-    except requests.exceptions.RequestException:
-        return False
-
-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
-    import time
-    import requests
-    
-    # Define API endpoints to try in order - using only online endpoints
-    api_endpoints = [
-        "https://www.gitarsenal.dev/api/analyze-with-gitingest"  # Working endpoint with www prefix
-    ]
-    
-    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")
-    
-    # Create a directory to save GitIngest results
-    save_dir = os.path.join(os.path.expanduser("~"), "gitarsenal_results")
-    os.makedirs(save_dir, exist_ok=True)
-    timestamp = time.strftime("%Y%m%d_%H%M%S")
-    repo_name = repo_url.split("/")[-1].replace(".git", "")
-    save_file = os.path.join(save_dir, f"gitingest_{repo_name}_{timestamp}.txt")
-    
-    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()
-                            
-                            # Save the GitIngest output to the results directory
-                            with open(save_file, 'w', encoding='utf-8') as save_f:
-                                save_f.write(content)
-                            print(f"📁 GitIngest output saved to: {save_file}")
-                            
-                            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")
-                                
-                                # Process the text to extract useful information
-                                import re
-                                
-                                # Try to identify language
-                                language_match = re.search(r"(?i)language[s]?:?\s*(\w+)", content)
-                                detected_language = language_match.group(1) if language_match else "Unknown"
-                                
-                                # Try to identify technologies with stronger evidence requirements
-                                tech_patterns = {
-                                    "python": r"(?i)(python|\.py\b|pip\b|requirements\.txt|setup\.py)",
-                                    "javascript": r"(?i)(javascript|\.js\b|node|npm|yarn|package\.json)",
-                                    "typescript": r"(?i)(typescript|\.ts\b|tsc\b|tsconfig\.json)",
-                                    "go": r"(?i)(\bgo\b|golang|\.go\b|go\.mod|go\.sum)",
-                                    "rust": r"(?i)(rust|\.rs\b|cargo|Cargo\.toml)",
-                                    "java": r"(?i)(java\b|\.java\b|maven|gradle|pom\.xml)",
-                                    "c++": r"(?i)(c\+\+|\.cpp\b|\.hpp\b|cmake\b|CMakeLists\.txt)",
-                                    "pytorch": r"(?i)(pytorch|torch\b|nn\.Module)",
-                                    "tensorflow": r"(?i)(tensorflow|tf\.|keras\b)",
-                                }
-                                
-                                # Count occurrences to filter out false positives
-                                tech_counts = {}
-                                for tech, pattern in tech_patterns.items():
-                                    matches = re.findall(pattern, content)
-                                    if matches:
-                                        tech_counts[tech] = len(matches)
-                                
-                                # Filter technologies based on threshold
-                                thresholds = {
-                                    "javascript": 3,  # Higher threshold for JavaScript
-                                    "go": 3,          # Higher threshold for Go
-                                    "default": 2      # Default threshold
-                                }
-                                
-                                detected_technologies = []
-                                for tech, count in tech_counts.items():
-                                    threshold = thresholds.get(tech, thresholds["default"])
-                                    if count >= threshold:
-                                        detected_technologies.append(tech)
-                                        print(f"📊 Detected {tech} with confidence score {count}")
-                                
-                                # Create a structured representation
-                                gitingest_data = {
-                                    "system_info": {
-                                        "detected_language": detected_language,
-                                        "detected_technologies": detected_technologies,
-                                    },
-                                    "repository_analysis": {
-                                        "summary": content[:5000],  # First 5000 chars as summary
-                                        "content_preview": content[:10000]  # First 10000 chars as preview
-                                    },
-                                    "success": True
-                                }
-                                
-                                # Save the processed data
-                                processed_file = os.path.join(save_dir, f"gitingest_processed_{repo_name}_{timestamp}.json")
-                                with open(processed_file, 'w', encoding='utf-8') as proc_f:
-                                    json.dump(gitingest_data, proc_f, indent=2)
-                                print(f"📁 Processed GitIngest data saved to: {processed_file}")
-                    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)")
-        
-        # Try each endpoint in sequence until one succeeds
-        response = None
-        for api_url in api_endpoints:
-            # Use the retry mechanism for more reliable requests
-            response = make_api_request_with_retry(
-                url=api_url,
-                payload=payload,
-                max_retries=2,
-                timeout=180  # 3 minute timeout
-            )
-            
-            # If we got a response and it's successful, break out of the loop
-            if response and response.status_code == 200:
-                print(f"✅ Successful response from {api_url}")
-                break
-                
-            if response:
-                print(f"⚠️ Endpoint {api_url} returned status code {response.status_code}, trying next endpoint...")
-            else:
-                print(f"⚠️ Failed to connect to {api_url}, trying next endpoint...")
-        
-        # If we've tried all endpoints and still don't have a response, use fallback
-        if response is None:
-            print("❌ All API endpoints failed")
-            return generate_fallback_commands(gitingest_data)
-            
-        # Continue with the response we got from the successful endpoint
-        if not response:
-            print("❌ No valid response received from any endpoint")
-            return generate_fallback_commands(gitingest_data)
-            
-        try:
-            print(f"📥 API Response status code: {response.status_code}")
-            
-            if response.status_code == 200:
-                try:
-                    data = response.json()
-                    print(f"📄 API Response data received")
-                    print(f"📄 Response size: {len(response.text)} bytes")
-                    print(f"📄 Response URL: {response.url}")
-                    
-                    # 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 original commands for reference
-                        print("📋 Original commands from API:")
-                        for i, cmd in enumerate(commands, 1):
-                            print(f"  {i}. {cmd}")
-                        
-                        # Fix the commands by removing placeholders and comments
-                        fixed_commands = fix_setup_commands(commands)
-                        
-                        # If we have a temp_dir with the cloned repo, try to find the entry point
-                        # and replace any placeholder entry points
-                        for i, cmd in enumerate(fixed_commands):
-                            if "python main.py" in cmd or "python3 main.py" in cmd:
-                                try:
-                                    entry_point = find_entry_point(temp_dir)
-                                    if entry_point and entry_point != "main.py":
-                                        fixed_commands[i] = cmd.replace("main.py", entry_point)
-                                        print(f"🔄 Replaced main.py with detected entry point: {entry_point}")
-                                except Exception as e:
-                                    print(f"⚠️ Error finding entry point: {e}")
-                        
-                        # Print the fixed commands
-                        print("\n📋 Fixed commands:")
-                        for i, cmd in enumerate(fixed_commands, 1):
-                            print(f"  {i}. {cmd}")
-                        
-                        return fixed_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 fallback commands
-                        return generate_fallback_commands(gitingest_data)
-                except json.JSONDecodeError as e:
-                    print(f"❌ Failed to parse API response as JSON: {e}")
-                    print(f"Raw response: {response.text[:500]}...")
-                    # Return fallback commands
-                    return generate_fallback_commands(gitingest_data)
-            elif response.status_code == 504:
-                print(f"❌ API request timed out (504 Gateway Timeout)")
-                print("⚠️ The server took too long to respond. Using fallback commands instead.")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
-            else:
-                print(f"❌ API request failed with status code: {response.status_code}")
-                print(f"❌ Response URL: {response.url}")
-                print(f"❌ Response headers: {dict(response.headers)}")
-                print(f"❌ Error response: {response.text[:500]}...")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
-        except Exception as e:
-            print(f"❌ Error processing API response: {str(e)}")
-            print("⚠️ Using fallback commands instead")
-            # Return fallback commands
-            return generate_fallback_commands(gitingest_data)
-    except Exception as e:
-        print(f"❌ Error fetching setup commands from API: {e}")
-        import traceback
-        traceback.print_exc()
-        # Return fallback commands
-        return generate_fallback_commands(None)
-    finally:
-        # Clean up the temporary directory
-        print(f"🧹 Cleaning up temporary directory...")
-        shutil.rmtree(temp_dir, ignore_errors=True)
-
-def generate_fallback_commands(gitingest_data):
-    """Generate fallback setup commands based on repository analysis"""
-    print("\n" + "="*80)
-    print("📋 GENERATING FALLBACK SETUP COMMANDS")
-    print("="*80)
-    print("Using basic repository analysis to generate setup commands")
-    
-    # Default commands that work for most repositories
-    default_commands = [
-        "apt-get update -y",
-        "apt-get install -y git curl wget",
-        "pip install --upgrade pip setuptools wheel"
-    ]
-    
-    # If we don't have any analysis data, return default commands
-    if not gitingest_data:
-        print("⚠️ No repository analysis data available. Using default commands.")
-        return default_commands
-    
-    # Extract language and technologies information
-    detected_language = gitingest_data.get("system_info", {}).get("detected_language", "Unknown")
-    detected_technologies = gitingest_data.get("system_info", {}).get("detected_technologies", [])
-    primary_package_manager = gitingest_data.get("system_info", {}).get("primary_package_manager", "Unknown")
-    
-    # Add language-specific commands
-    language_commands = []
-    
-    print(f"📋 Detected primary language: {detected_language}")
-    print(f"📋 Detected technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
-    print(f"📋 Detected package manager: {primary_package_manager}")
-    
-    # Python-specific commands
-    if detected_language == "Python" or primary_package_manager == "pip":
-        print("📦 Adding Python-specific setup commands")
-        
-        # Check for requirements.txt
-        requirements_check = [
-            "if [ -f requirements.txt ]; then",
-            "  echo 'Installing from requirements.txt'",
-            "  pip install -r requirements.txt",
-            "elif [ -f setup.py ]; then",
-            "  echo 'Installing from setup.py'",
-            "  pip install -e .",
-            "fi"
-        ]
-        language_commands.extend(requirements_check)
-        
-        # Add common Python packages
-        language_commands.append("pip install pytest numpy pandas matplotlib")
-    
-    # JavaScript/Node.js specific commands
-    elif detected_language in ["JavaScript", "TypeScript"] or primary_package_manager in ["npm", "yarn", "pnpm"]:
-        print("📦 Adding JavaScript/Node.js-specific setup commands")
-        
-        # Install Node.js if not available
-        language_commands.append("apt-get install -y nodejs npm")
-        
-        # Check for package.json
-        package_json_check = [
-            "if [ -f package.json ]; then",
-            "  echo 'Installing from package.json'",
-            "  npm install",
-            "fi"
-        ]
-        language_commands.extend(package_json_check)
-    
-    # Java specific commands
-    elif detected_language == "Java" or primary_package_manager in ["maven", "gradle"]:
-        print("📦 Adding Java-specific setup commands")
-        
-        language_commands.append("apt-get install -y openjdk-11-jdk maven gradle")
-        
-        # Check for Maven or Gradle
-        build_check = [
-            "if [ -f pom.xml ]; then",
-            "  echo 'Building with Maven'",
-            "  mvn clean install -DskipTests",
-            "elif [ -f build.gradle ]; then",
-            "  echo 'Building with Gradle'",
-            "  gradle build --no-daemon",
-            "fi"
-        ]
-        language_commands.extend(build_check)
-    
-    # Go specific commands
-    elif detected_language == "Go" or primary_package_manager == "go":
-        print("📦 Adding Go-specific setup commands")
-        
-        language_commands.append("apt-get install -y golang-go")
-        language_commands.append("go mod tidy")
-    
-    # Rust specific commands
-    elif detected_language == "Rust" or primary_package_manager == "cargo":
-        print("📦 Adding Rust-specific setup commands")
-        
-        language_commands.append("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y")
-        language_commands.append("source $HOME/.cargo/env")
-        language_commands.append("cargo build")
-    
-    # Combine all commands
-    all_commands = default_commands + language_commands
-    
-    # Fix the commands
-    fixed_commands = fix_setup_commands(all_commands)
-    
-    print("\n📋 Generated fallback setup commands:")
-    for i, cmd in enumerate(fixed_commands, 1):
-        print(f"  {i}. {cmd}")
-    
-    return fixed_commands
-
-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 API."""
-    # Use only online endpoints
-    api_endpoints = [
-        "https://www.gitarsenal.dev/api/analyze-with-gitingest"  # Working endpoint with www prefix
-    ]
-    
-    # Prepare the request payload
-    payload = {
-        "repoUrl": repo_url,
-        "gitingestData": gitingest_data,
-        "userRequest": "Setup and run the repository"
-    }
-    
-    # Try each API endpoint
-    for api_url in api_endpoints:
-        # Use the retry mechanism for more reliable requests
-        response = make_api_request_with_retry(
-            url=api_url,
-            payload=payload,
-            max_retries=2,
-            timeout=180  # 3 minute timeout
-        )
-        
-        if response and response.status_code == 200:
-            try:
-                data = response.json()
-                print(f"📄 Response size: {len(response.text)} bytes")
-                print(f"📄 Response URL: {response.url}")
-                if "setupInstructions" in data and "commands" in data["setupInstructions"]:
-                    commands = data["setupInstructions"]["commands"]
-                    print(f"✅ Successfully fetched {len(commands)} setup commands from API at {api_url}")
-                    
-                    # Print the original commands
-                    print("📋 Original commands from API:")
-                    for i, cmd in enumerate(commands, 1):
-                        print(f"  {i}. {cmd}")
-                    
-                    # Fix the commands
-                    fixed_commands = fix_setup_commands(commands)
-                    
-                    # Print the fixed commands
-                    print("\n📋 Fixed commands:")
-                    for i, cmd in enumerate(fixed_commands, 1):
-                        print(f"  {i}. {cmd}")
-                    
-                    return fixed_commands
-                else:
-                    print("⚠️ API response did not contain setupInstructions.commands field")
-            except json.JSONDecodeError:
-                print(f"❌ Failed to parse API response as JSON")
-        elif response:
-            print(f"❌ API request failed with status code: {response.status_code}")
-        else:
-            print(f"❌ Failed to connect to {api_url}")
-    
-    print("❌ All API endpoints failed")
-    return None
-            print(f"❌ Failed to connect to {api_url}")
-    
-    print("❌ All API endpoints failed")
-    return None
-
-# Define a function to create and return a properly configured ssh container function
-def create_ssh_container_function(gpu_type="a10g", timeout_minutes=60, volume=None, volume_mount_path="/persistent"):
-    # Create a new app for this specific container
-    app_name = f"ssh-container-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
-    ssh_app = modal.App.lookup(app_name, create_if_missing=True)
-    
-    # Create SSH-enabled image
-    ssh_image = (
-        modal.Image.debian_slim()
-        .apt_install(
-            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
-            "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
-            "gpg", "ca-certificates", "software-properties-common"
-        )
-        .pip_install("uv", "modal")  # Fast Python package installer and Modal
-        .run_commands(
-            # Create SSH directory
-            "mkdir -p /var/run/sshd",
-            "mkdir -p /root/.ssh",
-            "chmod 700 /root/.ssh",
-            
-            # Configure SSH server
-            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
-            
-            # SSH keep-alive settings
-            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
-            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
-            
-            # Generate SSH host keys
-            "ssh-keygen -A",
-            
-            # Set up a nice bash prompt
-            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
-        )
-    )
-    
-    # Setup volume mount if available
-    volumes = {}
-    if volume:
-        volumes[volume_mount_path] = volume
-    
-    # Define the function with the specific configuration
-    @ssh_app.function(
-        image=ssh_image,
-        timeout=timeout_minutes * 60,  # Convert to seconds
-        gpu=gpu_type,
-        cpu=2,
-        memory=8192,
-        serialized=True,
-        volumes=volumes if volumes else None,
-    )
-    def ssh_container(ssh_password, repo_url=None, repo_name=None, setup_commands=None):
-        import subprocess
-        import time
-        import os
-        
-        # Set root password
-        subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
-        
-        # Start SSH service
-        subprocess.run(["service", "ssh", "start"], check=True)
-        
-        # Setup environment
-        os.environ['PS1'] = r'\[\e[1;32m\]modal:\[\e[1;34m\]\w\[\e[0m\]$ '
-        
-        # Clone repository if provided
-        if repo_url:
-            repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
-            print(f"📥 Cloning repository: {repo_url}")
-            
-            try:
-                subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
-                print(f"✅ Repository cloned successfully: {repo_name_from_url}")
-                
-                # Change to repository directory
-                repo_dir = f"/root/{repo_name_from_url}"
-                if os.path.exists(repo_dir):
-                    os.chdir(repo_dir)
-                    print(f"📂 Changed to repository directory: {repo_dir}")
-                
-            except subprocess.CalledProcessError as e:
-                print(f"❌ Failed to clone repository: {e}")
-        
-        # Run setup commands if provided
-        if setup_commands:
-            print(f"⚙️ Running {len(setup_commands)} setup commands...")
-            for i, cmd in enumerate(setup_commands, 1):
-                print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
-                try:
-                    result = subprocess.run(cmd, shell=True, check=True, 
-                                          capture_output=True, text=True)
-                    if result.stdout:
-                        print(f"✅ Output: {result.stdout}")
-                except subprocess.CalledProcessError as e:
-                    print(f"❌ Command failed: {e}")
-                    if e.stderr:
-                        print(f"❌ Error: {e.stderr}")
-        
-        # Get container info
-        print("🔍 Container started successfully!")
-        print(f"🆔 Container ID: {os.environ.get('MODAL_TASK_ID', 'unknown')}")
-        
-        # Keep the container running
-        while True:
-            time.sleep(30)
-            # Check if SSH service is still running
-            try:
-                subprocess.run(["service", "ssh", "status"], check=True, 
-                             capture_output=True)
-            except subprocess.CalledProcessError:
-                print("⚠️ SSH service stopped, restarting...")
-                subprocess.run(["service", "ssh", "start"], check=True)
-    
-    # Return the configured function
-    return ssh_container, app_name
-
-def fix_setup_commands(commands):
-    """Fix setup commands by removing placeholders and comments."""
-    fixed_commands = []
-    
-    for cmd in commands:
-        # Remove placeholders like "(or the appropriate entry point...)"
-        cmd = re.sub(r'\([^)]*\)', '', cmd).strip()
-        
-        # Skip empty commands or pure comments
-        if not cmd or cmd.startswith('#'):
-            continue
-            
-        # Remove trailing comments
-        cmd = re.sub(r'#.*$', '', cmd).strip()
-        
-        if cmd:
-            fixed_commands.append(cmd)
-    
-    return fixed_commands
-
-def find_entry_point(repo_dir):
-    """Find the entry point script for a repository."""
-    # Common entry point files to check
-    common_entry_points = [
-        "main.py", "app.py", "run.py", "train.py", "start.py", 
-        "server.py", "cli.py", "demo.py", "example.py"
-    ]
-    
-    # Check if any of the common entry points exist
-    for entry_point in common_entry_points:
-        if os.path.exists(os.path.join(repo_dir, entry_point)):
-            return entry_point
-    
-    # Look for Python files in the root directory
-    python_files = [f for f in os.listdir(repo_dir) if f.endswith('.py')]
-    if python_files:
-        # Prioritize files with main function or if_name_main pattern
-        for py_file in python_files:
-            file_path = os.path.join(repo_dir, py_file)
-            try:
-                with open(file_path, 'r') as f:
-                    content = f.read()
-                    if "def main" in content or "if __name__ == '__main__'" in content or 'if __name__ == "__main__"' in content:
-                        return py_file
-            except:
-                pass
-        
-        # If no main function found, return the first Python file
-        return python_files[0]
-    
-    return None
-
-def analyze_directory_navigation_with_llm(current_dir, target_dir, current_contents, target_contents, api_key=None):
-    """Use LLM to analyze if directory navigation makes sense"""
-    if not api_key:
-        # Try to get API key from environment
-        api_key = os.environ.get("OPENAI_API_KEY")
-        
-    if not api_key:
-        print("⚠️ No OpenAI API key available for directory analysis")
-        return None
-        
-    # Create analysis prompt
-    analysis_prompt = f"""
-I'm trying to determine if a 'cd {target_dir}' command makes sense.
-
-CURRENT DIRECTORY: {current_dir}
-Current directory contents:
-{current_contents}
-
-TARGET DIRECTORY: {target_dir}
-Target directory contents:
-{target_contents}
-
-Please analyze if navigating to the target directory makes sense by considering:
-1. Are the contents significantly different?
-2. Does the target directory contain important files (like source code, config files, etc.)?
-3. Is this likely a nested project directory or just a duplicate?
-4. Would navigating provide access to different functionality or files?
-
-Respond with only 'NAVIGATE' if navigation makes sense, or 'SKIP' if it's redundant.
-"""
-    
-    # Prepare the API request
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}"
-    }
-    
-    payload = {
-        "model": "gpt-4",
-        "messages": [
-            {"role": "system", "content": "You are a directory navigation assistant. Analyze if navigating to a target directory makes sense based on the contents of both directories. Respond with only 'NAVIGATE' or 'SKIP'."},
-            {"role": "user", "content": analysis_prompt}
-        ],
-        "temperature": 0.1,
-        "max_tokens": 50
-    }
-    
-    try:
-        print("🤖 Calling OpenAI for directory navigation analysis...")
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            llm_response = result["choices"][0]["message"]["content"].strip()
-            print(f"🤖 LLM Response: {llm_response}")
-            return llm_response
-        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 cleanup_modal_token():
-    """Delete token files and environment variables after SSH container is started"""
-    print("🧹 Cleaning up tokens for security...")
-    
-    try:
-        # Remove token from environment variables
-        if "MODAL_TOKEN_ID" in os.environ:
-            del os.environ["MODAL_TOKEN_ID"]
-            # print("✅ Removed token ID from environment")
-        
-        if "MODAL_TOKEN" in os.environ:
-            del os.environ["MODAL_TOKEN"]
-            # print("✅ Removed token from environment")
-            
-        if "MODAL_TOKEN_SECRET" in os.environ:
-            del os.environ["MODAL_TOKEN_SECRET"]
-            # print("✅ Removed token secret from environment")
-        
-        # Delete ~/.modal.toml file
-        home_dir = os.path.expanduser("~")
-        modal_toml = os.path.join(home_dir, ".modal.toml")
-        if os.path.exists(modal_toml):
-            os.remove(modal_toml)
-            # print(f"✅ Deleted token file at {modal_toml}")
-        
-        # print("✅ Token cleanup completed successfully")
-    except Exception as e:
-        print(f"❌ Error during token cleanup: {e}")
-
-def show_usage_examples():
-    """Display usage examples for the script."""
-    print("Usage Examples\n")
-    
-    print("Basic Container Creation")
-    print("┌────────────────────────────────────────────────────────────────────────┐")
-    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git  │")
-    print("└────────────────────────────────────────────────────────────────────────┘\n")
-    
-    print("With Setup Commands")
-    print("┌────────────────────────────────────────────────────────────────────────────────────────────────────┐")
-    print("│ gitarsenal --gpu A100 --repo-url https://github.com/username/repo.git \\           │")
-    print("│   --setup-commands \"pip install -r requirements.txt\" \"python setup.py install\"  │")
-    print("└────────────────────────────────────────────────────────────────────────────────────────────────────┘\n")
-    
-    print("With Persistent Storage")
-    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
-    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
-    print("│   --volume-name my-persistent-volume                             │")
-    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
-    
-    print("Available GPU Options:")
-    print("  T4, L4, A10G, A100-40GB, A100-80GB, L40S, H100, H200, B200")
-
-def make_api_request_with_retry(url, payload, max_retries=2, timeout=180):
-    """Make an API request with retry mechanism."""
-    import requests
-    import time
-    
-    for attempt in range(max_retries + 1):
-        try:
-            if attempt > 0:
-                print(f"🔄 Retry attempt {attempt}/{max_retries}...")
-                
-            print(f"🌐 Making POST request to: {url}")
-            print(f"⏳ Waiting up to {timeout//60} minutes for response...")
-            
-            # Set allow_redirects=True to follow redirects automatically
-            response = requests.post(
-                url, 
-                json=payload, 
-                timeout=timeout,
-                allow_redirects=True,
-                headers={
-                    'Content-Type': 'application/json',
-                    'User-Agent': 'GitArsenal-CLI/1.0'
-                }
-            )
-            
-            # Print redirect info if any
-            if response.history:
-                print(f"✅ Request was redirected {len(response.history)} times")
-                for resp in response.history:
-                    print(f"  - Redirect: {resp.status_code} from {resp.url}")
-                print(f"✅ Final URL: {response.url}")
-            
-            return response
-        except requests.exceptions.RequestException as e:
-            if attempt < max_retries:
-                retry_delay = 2 ** attempt  # Exponential backoff
-                print(f"⚠️ Request failed: {str(e)}")
-                print(f"⏳ Waiting {retry_delay} seconds before retrying...")
-                time.sleep(retry_delay)
-            else:
-                print(f"❌ All retry attempts failed: {str(e)}")
-                return None
-    
-    return None
-
-if __name__ == "__main__":
-    # Parse command line arguments when script is run directly
-    import argparse
-    import sys
-    
-    parser = argparse.ArgumentParser(description='Create a Modal SSH container 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('--timeout', type=int, default=60, help='Container timeout in minutes (default: 60)')
-    parser.add_argument('--ssh-password', type=str, help='SSH password (random if not provided)')
-    parser.add_argument('--use-api', action='store_true', help='Fetch setup commands from API')
-    parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
-    
-    args = parser.parse_args()
-    
-    # If no arguments or only --show-examples is provided, show usage examples
-    if len(sys.argv) == 1 or args.show_examples:
-        show_usage_examples()
-        sys.exit(0)
-    
-    try:    
-        # 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 --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}")
-                
-        # Load commands from file if specified
-        if args.commands_file and os.path.exists(args.commands_file):
-            try:
-                with open(args.commands_file, 'r') as f:
-                    # Check if the file contains JSON or line-by-line commands
-                    content = f.read().strip()
-                    
-                    if content.startswith('[') and content.endswith(']'):
-                        # JSON format
-                        try:
-                            json_commands = json.loads(content)
-                            if isinstance(json_commands, list):
-                                setup_commands.extend(json_commands)
-                                print(f"📋 Loaded {len(json_commands)} commands from JSON file {args.commands_file}")
-                            else:
-                                print(f"⚠️ Invalid JSON format in commands file: not a list")
-                        except json.JSONDecodeError as json_err:
-                            print(f"⚠️ Error parsing JSON commands file: {json_err}")
-                            # Fall back to line-by-line parsing
-                            file_commands = [line.strip() for line in content.split('\n') if line.strip()]
-                            setup_commands.extend(file_commands)
-                            print(f"📋 Loaded {len(file_commands)} commands from file (line-by-line fallback)")
-                    else:
-                        # Line-by-line format
-                        file_commands = [line.strip() for line in content.split('\n') if line.strip()]
-                        setup_commands.extend(file_commands)
-                        print(f"📋 Loaded {len(file_commands)} commands from file (line-by-line format)")
-            except Exception as e:
-                print(f"⚠️ Error loading commands from file: {e}")
-        
-        # Load commands from setup script if specified
-        if args.setup_script and os.path.exists(args.setup_script):
-            try:
-                with open(args.setup_script, 'r') as f:
-                    script_content = f.read().strip()
-                    # Convert script to individual commands
-                    script_commands = [line.strip() for line in script_content.split('\n') 
-                                    if line.strip() and not line.strip().startswith('#')]
-                    setup_commands.extend(script_commands)
-                    print(f"📋 Loaded {len(script_commands)} commands from script {args.setup_script}")
-            except Exception as e:
-                print(f"⚠️ Error loading commands from script: {e}")
-        
-        # Create the container with the specified options
-        if args.ssh_password:
-            print(f"🔑 Using provided SSH password")
-            ssh_password = args.ssh_password
-        else:
-            ssh_password = generate_random_password()
-            print(f"🔑 Generated random SSH password: {ssh_password}")
-        
-        # Extract repository name from URL if not provided
-        repo_name = args.repo_name
-        if not repo_name and args.repo_url:
-            # Try to extract repo name from URL
-            url_parts = args.repo_url.rstrip('/').split('/')
-            if url_parts:
-                repo_name = url_parts[-1]
-                if repo_name.endswith('.git'):
-                    repo_name = repo_name[:-4]
-        
-        # Create the container
-        create_modal_ssh_container(
-            gpu_type=args.gpu,
-            repo_url=args.repo_url,
-            repo_name=repo_name,
-            setup_commands=setup_commands,
-            volume_name=args.volume_name,
-            timeout_minutes=args.timeout,
-            ssh_password=ssh_password
-        )
-    except KeyboardInterrupt:
-        # print("\n\n🛑 Execution interrupted")
-        # print("🧹 Cleaning up resources...")
-        cleanup_modal_token()
-        sys.exit(1)
-    except Exception as e:
-        # print(f"\n❌ Error: {e}")
-        # print("🧹 Cleaning up resources...")
-        cleanup_modal_token()
-        sys.exit(1)