gitarsenal-cli 1.6.1 → 1.6.3

package/test_modalSandboxScript.py

@@ -13,7 +13,7 @@ import argparse
 from pathlib import Path
 
 # Parse command-line arguments
-parser = argparse.ArgumentParser(description='Launch a Modal sandbox')
+parser = argparse.ArgumentParser()
 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')
@@ -27,24 +27,35 @@ 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")
+    # 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")
+    # 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 Modal tokens from proxy server...")
+    print("🔄 Fetching tokens from proxy server...")
     from fetch_modal_tokens import get_tokens
-    token_id, token_secret = get_tokens()
-    print(f"✅ Modal tokens fetched successfully")
+    token_id, token_secret, openai_api_key = get_tokens()
+    
+    # Debug print the tokens
+    # print("🔍 DEBUG: Modal Tokens Fetched:")
+    # print(f"🔍 DEBUG: Token ID: {token_id}")
+    # print(f"🔍 DEBUG: Token Secret: {token_secret}")
+    # print(f"🔍 DEBUG: OpenAI API Key: {openai_api_key}")
+    
+    # Check if we got valid tokens
+    if token_id is None or token_secret is None:
+        raise ValueError("Could not get valid 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
-    
+    os.environ["OPENAI_API_KEY"] = openai_api_key
     # Also set the old environment variable for backward compatibility
     os.environ["MODAL_TOKEN"] = token_id
     
@@ -56,26 +67,26 @@ except Exception as e:
     # Apply the comprehensive Modal token solution as fallback
     try:
         # Import the comprehensive solution module
-        print("🔄 Applying comprehensive Modal token solution...")
+        # print("🔄 Applying comprehensive Modal token solution...")
         import modal_token_solution
-        print("✅ Comprehensive Modal token solution applied")
+        # 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}")
+        # 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...")
+            # print("🔄 Falling back to Modal authentication patch...")
             import modal_auth_patch
-            print("✅ Modal authentication patch applied")
+            # 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}")
+            # print(f"⚠️ Error applying Modal authentication patch: {e}")
             
             # Fall back to fix_modal_token.py
             try:
@@ -115,17 +126,17 @@ except Exception as e:
                 token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
 
 # Print debug info
-print(f"🔍 DEBUG: Checking environment variables")
-print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
-print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
-print(f"🔍 MODAL_TOKEN exists: {'Yes' if os.environ.get('MODAL_TOKEN') else 'No'}")
+# 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"🔍 MODAL_TOKEN_ID length: {len(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"🔍 MODAL_TOKEN_SECRET length: {len(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"🔍 MODAL_TOKEN length: {len(os.environ.get('MODAL_TOKEN'))}")
-print(f"✅ Modal token setup completed")
+    print(f"🔍 Token length: {len(os.environ.get('MODAL_TOKEN'))}")
+# print(f"✅ Token setup completed")
 
 # Import modal after token setup
 import modal
@@ -315,17 +326,15 @@ def handle_huggingface_login(sandbox, current_dir):
     
     return exit_code == 0, stdout_buffer, stderr_buffer
 
-def handle_interactive_command(cmd, sandbox, current_dir):
-    """Handle interactive commands by prompting the user for input"""
-    print(f"⚠️ Interactive command detected: {cmd}")
-    print("⚠️ Some prompts may not be visible. If the command appears stuck, it may be waiting for input.")
-    
-    # This is a placeholder for more sophisticated interactive command handling
-    # In a real implementation, you would need to handle specific interactive commands differently
-    return None
 
 def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
     """Call OpenAI to debug a failed command and suggest a fix"""
+    print("\n🔍 DEBUG: Starting LLM debugging...")
+    print(f"🔍 DEBUG: Command: {command}")
+    print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
+    print(f"🔍 DEBUG: Current directory: {current_dir}")
+    print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
+    
     # Define _to_str function locally to avoid NameError
     def _to_str(maybe_bytes):
         try:
@@ -351,22 +360,86 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
         print("⚠️ Error output is empty. Cannot effectively debug the command.")
         print("⚠️ Skipping OpenAI debugging due to lack of error information.")
         return None
-        
+    
+    # Try to get API key from multiple sources
     if not api_key:
-        # Try to get API key from environment
+        print("🔍 DEBUG: No API key provided, searching for one...")
+        
+        # First try environment variable
         api_key = os.environ.get("OPENAI_API_KEY")
+        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
+        if api_key:
+            print(f"🔍 DEBUG: Environment API key value: {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
+        # If not in environment, try to fetch from server using fetch_modal_tokens
+        if not api_key:
+            try:
+                print("🔍 DEBUG: Trying to fetch API key from server...")
+                from fetch_modal_tokens import get_tokens
+                _, _, api_key = get_tokens()
+                if api_key:
+                    # print("✅ Successfully fetched OpenAI API key from server")
+                    # print(f"🔍 DEBUG: Fetched OpenAI API key value: {api_key}")
+                    # Set in environment for this session
+                    os.environ["OPENAI_API_KEY"] = api_key
+                else:
+                    print("⚠️ Could not fetch OpenAI API key from server")
+            except Exception as e:
+                print(f"⚠️ Error fetching API key from server: {e}")
+        
+        # Store the API key in a persistent file if found
+        if api_key:
+            try:
+                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
+                with open(os.path.expanduser("~/.gitarsenal/openai_key"), "w") as f:
+                    f.write(api_key)
+                print("✅ Saved OpenAI API key for future use")
+            except Exception as e:
+                print(f"⚠️ Could not save API key: {e}")
+        
+        # Try to load from saved file if not in environment
+        if not api_key:
+            try:
+                key_file = os.path.expanduser("~/.gitarsenal/openai_key")
+                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
+                if os.path.exists(key_file):
+                    with open(key_file, "r") as f:
+                        api_key = f.read().strip()
+                    if api_key:
+                        print("✅ Loaded OpenAI API key from saved file")
+                        print(f"🔍 DEBUG: API key from file: {api_key}")
+                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
+                        # Also set in environment for this session
+                        os.environ["OPENAI_API_KEY"] = api_key
+                    else:
+                        print("🔍 DEBUG: Saved file exists but is empty")
+                else:
+                    print("🔍 DEBUG: No saved API key file found")
+            except Exception as e:
+                print(f"⚠️ Could not load saved API key: {e}")
+        
+        # Then try credentials manager
+        if not api_key:
+            print("🔍 DEBUG: Trying credentials manager...")
+            try:
+                from credentials_manager import CredentialsManager
+                credentials_manager = CredentialsManager()
+                api_key = credentials_manager.get_openai_api_key()
+                if api_key:
+                    print(f"🔍 DEBUG: API key from credentials manager: Found")
+                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
+                    # Set in environment for this session
+                    os.environ["OPENAI_API_KEY"] = api_key
+                else:
+                    print(f"🔍 DEBUG: API key from credentials manager: Not found")
+            except ImportError as e:
+                print(f"🔍 DEBUG: Credentials manager not available: {e}")
+                # Fall back to direct input if credentials_manager is not available
+                pass
+        
+        # Finally, prompt the user if still no API key
+        if not api_key:
+            print("🔍 DEBUG: No API key found in any source, prompting user...")
             print("\n" + "="*60)
             print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
             print("="*60)
@@ -381,6 +454,9 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                     print("❌ No API key provided. Skipping debugging.")
                     return None
                 print("✅ API key received successfully!")
+                print(f"🔍 DEBUG: User-provided API key: {api_key}")
+                # Save the API key to environment for future use in this session
+                os.environ["OPENAI_API_KEY"] = api_key
             except KeyboardInterrupt:
                 print("\n❌ API key input cancelled by user.")
                 return None
@@ -388,9 +464,19 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                 print(f"❌ Error getting API key: {e}")
                 return None
     
-    # Get current directory context
+    # If we still don't have an API key, we can't proceed
+    if not api_key:
+        print("❌ No OpenAI API key available. Cannot perform LLM debugging.")
+        print("💡 To enable LLM debugging, set the OPENAI_API_KEY environment variable")
+        return None
+    
+    print(f"✅ OpenAI API key available (length: {len(api_key)})")
+    
+    # Gather additional context to help with debugging
     directory_context = ""
     system_info = ""
+    command_history = ""
+    file_context = ""
     
     if sandbox:
         try:
@@ -404,6 +490,7 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
             uname -a
             echo -e "\nPython Information:"
             python --version
+            pip --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"
@@ -458,6 +545,72 @@ Directory contents:
 {parent_context}
 """
             print("✅ Directory context gathered successfully")
+            
+            # Check for relevant files that might provide additional context
+            # For example, if error mentions a specific file, try to get its content
+            relevant_files = []
+            error_files = re.findall(r'(?:No such file or directory|cannot open|not found): ([^\s:]+)', error_output)
+            if error_files:
+                for file_path in error_files:
+                    # Clean up the file path
+                    file_path = file_path.strip("'\"")
+                    if not os.path.isabs(file_path):
+                        file_path = os.path.join(current_dir, file_path)
+                    
+                    # Try to get the parent directory if the file doesn't exist
+                    if '/' in file_path:
+                        parent_file_dir = os.path.dirname(file_path)
+                        relevant_files.append(parent_file_dir)
+            
+            # Look for package.json, requirements.txt, etc.
+            common_config_files = ["package.json", "requirements.txt", "pyproject.toml", "setup.py", 
+                                 "Pipfile", "Dockerfile", "docker-compose.yml", "Makefile"]
+            
+            for config_file in common_config_files:
+                check_cmd = f"test -f {current_dir}/{config_file}"
+                check_result = sandbox.exec("bash", "-c", check_cmd)
+                check_result.wait()
+                if check_result.returncode == 0:
+                    relevant_files.append(f"{current_dir}/{config_file}")
+            
+            # Get content of relevant files
+            if relevant_files:
+                file_context = "\nRelevant file contents:\n"
+                for file_path in relevant_files[:2]:  # Limit to 2 files to avoid too much context
+                    try:
+                        file_check_cmd = f"test -f {file_path}"
+                        file_check = sandbox.exec("bash", "-c", file_check_cmd)
+                        file_check.wait()
+                        
+                        if file_check.returncode == 0:
+                            # It's a file, get its content
+                            cat_cmd = f"cat {file_path}"
+                            cat_result = sandbox.exec("bash", "-c", cat_cmd)
+                            file_content = ""
+                            for line in cat_result.stdout:
+                                file_content += _to_str(line)
+                            cat_result.wait()
+                            
+                            # Truncate if too long
+                            if len(file_content) > 1000:
+                                file_content = file_content[:1000] + "\n... (truncated)"
+                            
+                            file_context += f"\n--- {file_path} ---\n{file_content}\n"
+                        else:
+                            # It's a directory, list its contents
+                            ls_cmd = f"ls -la {file_path}"
+                            ls_dir_result = sandbox.exec("bash", "-c", ls_cmd)
+                            dir_content = ""
+                            for line in ls_dir_result.stdout:
+                                dir_content += _to_str(line)
+                            ls_dir_result.wait()
+                            
+                            file_context += f"\n--- Directory: {file_path} ---\n{dir_content}\n"
+                    except Exception as e:
+                        print(f"⚠️ Error getting content of {file_path}: {e}")
+                
+                print(f"✅ Additional file context gathered from {len(relevant_files)} relevant files")
+            
         except Exception as e:
             print(f"⚠️ Error getting directory context: {e}")
             directory_context = f"\nCurrent directory: {current_dir}\n"
@@ -489,64 +642,262 @@ But it failed with this error:
 ```
 {system_info}
 {directory_context}
+{file_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
+IMPORTANT GUIDELINES:
+1. For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
+   - For apt/apt-get: use -y or --yes
+   - For pip: use --no-input
+   - For rm: use -f or --force
+   - For other commands: check their documentation for the appropriate non-interactive flag
+
+2. If the error indicates a file is not found (e.g., "No such file or directory", "cannot open", "not found"):
+   - FIRST try to search for the file using: find . -name "filename" -type f 2>/dev/null
+   - If found, navigate to that directory using: cd /path/to/directory
+   - If not found, then consider creating the file or installing missing packages
+
+3. For missing packages or dependencies:
+   - Use pip install for Python packages
+   - Use apt-get install for system packages
+   - Use npm install for Node.js packages
+
+4. For authentication issues:
+   - For wandb login: suggest 'wandb login YOUR_API_KEY' (system will prompt for actual key)
+   - For huggingface: suggest 'huggingface-cli login' (system will prompt for token)
 
 Do not provide any explanations, just the exact command to run.
 """
     
     # 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
-    }
+    print("🔍 DEBUG: Preparing API request...")
     
-    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
-        )
+    # Try to use GPT-4 first, but fall back to other models if needed
+    models_to_try = [
+        "gpt-4o-mini",        # First choice: GPT-4o (most widely available)
+    ]
+    
+    # Check if we have a preferred model in environment
+    preferred_model = os.environ.get("OPENAI_MODEL")
+    if preferred_model:
+        # Insert the preferred model at the beginning of the list
+        models_to_try.insert(0, preferred_model)
+        print(f"✅ Using preferred model from environment: {preferred_model}")
+        
+    # Remove duplicates while preserving order
+    models_to_try = list(dict.fromkeys(models_to_try))
+    print(f"🔍 DEBUG: Models to try: {models_to_try}")
+    
+    # Function to make the API call with a specific model
+    def try_api_call(model_name, retries=2, backoff_factor=1.5):
+        print(f"🔍 DEBUG: Attempting API call with model: {model_name}")
+        print(f"🔍 DEBUG: API key available: {'Yes' if api_key else 'No'}")
+        # if api_key:
+        #     print(f"🔍 DEBUG: API key length: {len(api_key)}")
+        #     print(f"🔍 DEBUG: API key starts with: {api_key[:10]}...")
         
-        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
+        payload = {
+            "model": model_name,
+            "messages": [
+                {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue. Analyze the issue first, understand why it's happening, then provide the command to fix it. For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found. For missing packages, use appropriate package managers (pip, apt-get, npm). For authentication, suggest login commands with placeholders."},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": 0.2,
+            "max_tokens": 300
+        }
+        
+        print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
+        
+        # Add specific handling for common errors
+        last_error = None
+        for attempt in range(retries + 1):
+            try:
+                if attempt > 0:
+                    # Exponential backoff
+                    wait_time = backoff_factor * (2 ** (attempt - 1))
+                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
+                    time.sleep(wait_time)
+                
+                print(f"🤖 Calling OpenAI with {model_name} model to debug the failed command...")
+                print(f"🔍 DEBUG: Making POST request to OpenAI API...")
+                response = requests.post(
+                    "https://api.openai.com/v1/chat/completions",
+                    headers=headers,
+                    json=payload,
+                    timeout=45  # Increased timeout for reliability
+                )
+                
+                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
+                
+                # Handle specific status codes
+                if response.status_code == 200:
+                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
+                    return response.json(), None
+                elif response.status_code == 401:
+                    error_msg = "Authentication error: Invalid API key"
+                    print(f"❌ {error_msg}")
+                    print(f"🔍 DEBUG: Response text: {response.text}")
+                    # Don't retry auth errors
+                    return None, error_msg
+                elif response.status_code == 429:
+                    error_msg = "Rate limit exceeded or quota reached"
+                    print(f"⚠️ {error_msg}")
+                    print(f"🔍 DEBUG: Response text: {response.text}")
+                    # Always retry rate limit errors with increasing backoff
+                    last_error = error_msg
+                    continue
+                elif response.status_code == 500:
+                    error_msg = "OpenAI server error"
+                    print(f"⚠️ {error_msg}")
+                    print(f"🔍 DEBUG: Response text: {response.text}")
+                    # Retry server errors
+                    last_error = error_msg
+                    continue
+                else:
+                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
+                    print(f"⚠️ OpenAI API error: {error_msg}")
+                    print(f"🔍 DEBUG: Full response text: {response.text}")
+                    last_error = error_msg
+                    # Only retry if we have attempts left
+                    if attempt < retries:
+                        continue
+                    return None, error_msg
+            except requests.exceptions.Timeout:
+                error_msg = "Request timed out"
+                print(f"⚠️ {error_msg}")
+                print(f"🔍 DEBUG: Timeout after 45 seconds")
+                last_error = error_msg
+                # Always retry timeouts
+                continue
+            except requests.exceptions.ConnectionError:
+                error_msg = "Connection error"
+                print(f"⚠️ {error_msg}")
+                print(f"🔍 DEBUG: Connection failed to api.openai.com")
+                last_error = error_msg
+                # Always retry connection errors
+                continue
+            except Exception as e:
+                error_msg = str(e)
+                print(f"⚠️ Unexpected error: {error_msg}")
+                print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
+                print(f"🔍 DEBUG: Exception details: {str(e)}")
+                last_error = error_msg
+                # Only retry if we have attempts left
+                if attempt < retries:
+                    continue
+                return None, error_msg
+        
+        # If we get here, all retries failed
+        return None, last_error
+    
+    # Try each model in sequence until one works
+    result = None
+    last_error = None
+    
+    for model in models_to_try:
+        result, error = try_api_call(model)
+        if result:
+            # print(f"✅ Successfully got response from {model}")
+            break
         else:
-            print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
-            return None
+            print(f"⚠️ Failed to get response from {model}: {error}")
+            last_error = error
+    
+    if not result:
+        print(f"❌ All model attempts failed. Last error: {last_error}")
+        return None
+    
+    # Process the response
+    try:
+        print(f"🔍 DEBUG: Processing OpenAI response...")
+        # print(f"🔍 DEBUG: Response structure: {list(result.keys())}")
+        print(f"🔍 DEBUG: Choices count: {len(result.get('choices', []))}")
+        
+        fix_command = result["choices"][0]["message"]["content"].strip()
+        print(f"🔍 DEBUG: Raw response content: {fix_command}")
+        
+        # Save the original response for debugging
+        original_response = fix_command
+        
+        # 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()
+                print(f"✅ Extracted command from code block: {fix_command}")
+        
+        # If the response still has explanatory text, try to extract just the command
+        if len(fix_command.split('\n')) > 1:
+            # First try to find lines that look like commands (start with common command prefixes)
+            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
+                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
+                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
+                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
+            
+            # Check for lines that start with common command prefixes
+            command_lines = [line.strip() for line in fix_command.split('\n') 
+                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
+            
+            if command_lines:
+                # Use the first command line found
+                fix_command = command_lines[0]
+                print(f"✅ Identified command by prefix: {fix_command}")
+            else:
+                # Try to find lines that look like commands (contain common shell patterns)
+                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
+                command_lines = [line.strip() for line in fix_command.split('\n') 
+                              if any(pattern in line for pattern in shell_patterns)]
+                
+                if command_lines:
+                    # Use the first command line found
+                    fix_command = command_lines[0]
+                    print(f"✅ Identified command by shell pattern: {fix_command}")
+                else:
+                    # Fall back to 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:
+                        # Exclude very short lines that are likely not commands
+                        valid_lines = [line for line in lines if len(line) > 5]
+                        if valid_lines:
+                            fix_command = min(valid_lines, key=len)
+                        else:
+                            fix_command = min(lines, key=len)
+                        print(f"✅ Selected shortest line as command: {fix_command}")
+        
+        # Clean up the command - remove any trailing periods or quotes
+        fix_command = fix_command.rstrip('.;"\'')
+        
+        # Remove common prefixes that LLMs sometimes add
+        prefixes_to_remove = [
+            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
+            "You should run: ", "You can run: ", "You need to run: "
+        ]
+        for prefix in prefixes_to_remove:
+            if fix_command.startswith(prefix):
+                fix_command = fix_command[len(prefix):].strip()
+                print(f"✅ Removed prefix: {prefix}")
+                break
+        
+        # If the command is still multi-line or very long, it might not be a valid command
+        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
+            print("⚠️ Extracted command appears invalid (multi-line or too long)")
+            print("🔍 Original response from LLM:")
+            print("-" * 60)
+            print(original_response)
+            print("-" * 60)
+            print("⚠️ Using best guess for command")
+        
+        print(f"🔧 Suggested fix: {fix_command}")
+        print(f"🔍 DEBUG: Returning fix command: {fix_command}")
+        return fix_command
     except Exception as e:
-        print(f"❌ Error calling OpenAI API: {e}")
+        print(f"❌ Error processing OpenAI response: {e}")
+        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
+        print(f"🔍 DEBUG: Exception details: {str(e)}")
         return None
 
 def prompt_for_hf_token():
@@ -586,1611 +937,106 @@ def prompt_for_hf_token():
         print(f"❌ Error getting token: {e}")
         return None
 
-def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands=None, volume_name=None):
-    # Import the credentials manager if available
-    try:
-        from credentials_manager import CredentialsManager
-        credentials_manager = CredentialsManager()
-    except ImportError:
-        credentials_manager = None
-        print("⚠️ Credentials manager not found, will use environment variables or prompt for credentials")
+
+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)
     
-    # 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("✅ Modal authentication verified")
-        except modal.exception.AuthError:
-            print("\n" + "="*80)
-            print("🔑 MODAL AUTHENTICATION REQUIRED")
-            print("="*80)
-            print("GitArsenal requires Modal 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 is_password:
+            user_input = getpass.getpass("Input (hidden): ").strip()
+        else:
+            user_input = input("Input: ").strip()
             
-            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)
+        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 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 Modal sandbox with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
-    
-    # Initialize uv_path variable
-    uv_path = ""
-    
-    # Setup volume if specified
-    volume = None
-    volume_mount_path = "/persistent"
-    
-    if volume_name:
-        print(f"📦 Setting up volume: {volume_name}")
-        try:
-            # Try to get existing volume or create new one
-            volume = modal.Volume.from_name(volume_name, create_if_missing=True)
-            print(f"✅ Volume '{volume_name}' ready for use")
-        except Exception as e:
-            print(f"⚠️ Could not setup volume '{volume_name}': {e}")
-            print("⚠️ Continuing without persistent volume")
-            volume = None
-    else:
-        # Create a default volume for this session
-        default_volume_name = f"sandbox-vol-{timestamp}"
-        print(f"📦 Creating default volume: {default_volume_name}")
-        try:
-            volume = modal.Volume.from_name(default_volume_name, create_if_missing=True)
-            volume_name = default_volume_name
-            print(f"✅ Default volume '{default_volume_name}' created")
-        except Exception as e:
-            print(f"⚠️ Could not create default volume: {e}")
-            print("⚠️ Continuing without persistent volume")
-            volume = None
-
-    # Enable output for image building
-    with modal.enable_output():
-        # Create a Modal app and sandbox
-        print(f"🚀 Creating Modal sandbox with GPU: {gpu_type.lower()} (App: {app_name})...")
-        # Always use lookup with create_if_missing=True to properly initialize the app
-        app = modal.App.lookup(app_name, create_if_missing=True)
-        print(f"Created app: {app_name}")
-        
-        # Create the sandbox with increased timeout for long-running operations
-        print("⏱️ Setting 30-minute timeout for long-running installations...")
-        
-        # Setup volume mount if available
-        volumes = {}
-        if volume:
-            volumes[volume_mount_path] = volume
-            print(f"📦 Mounting volume '{volume_name}' at {volume_mount_path}")
-        
-        cuda_image = modal.Image.from_registry("nvidia/cuda:12.8.1-devel-ubuntu24.04", add_python="3.12")
+        print(f"❌ Error getting input: {e}")
+        return None
 
-        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
-        )
+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
 
-    # Get the sandbox ID for reference
-    sandbox_id = sandbox.object_id
-    print(f"📋 Sandbox ID: {sandbox_id}")
+# First, add the standalone ssh_container function at the module level, before the create_modal_ssh_container function
 
-    # Wait a moment for the container to be registered
-    print("⏳ Waiting for container to be registered...")
-    time.sleep(5)  # Increased wait time
+# Define a module-level ssh container function
+ssh_app = modal.App("ssh-container-app")
 
-    # 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}")
+@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", "requests", "openai")  # Fast Python package installer and Modal
+        .run_commands(
+            # Create SSH directory
+            "mkdir -p /var/run/sshd",
+            "mkdir -p /root/.ssh",
+            "chmod 700 /root/.ssh",
             
-            # 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)
+            # 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",
             
-            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}")
+            # SSH keep-alive settings
+            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
             
-            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
+            # Generate SSH host keys
+            "ssh-keygen -A",
             
-            # 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")
+            # Install Modal CLI
+            "pip install modal",
             
-        print("⚠️ Container connection may fail. You may need to connect manually.")
+            # 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, openai_api_key=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\]$ '
+    
+    # Set OpenAI API key if provided
+    if openai_api_key:
+        os.environ['OPENAI_API_KEY'] = openai_api_key
+        print(f"✅ Set OpenAI API key in container environment (length: {len(openai_api_key)})")
     else:
-        print(f"✅ Container ID verified: {container_id}")
-
-    # Function to convert bytes to string
-    def _to_str(maybe_bytes):
-        try:
-            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
-        except UnicodeDecodeError:
-            # Handle non-UTF-8 bytes by replacing invalid characters
-            if isinstance(maybe_bytes, (bytes, bytearray)):
-                return maybe_bytes.decode('utf-8', errors='replace')
-            else:
-                return str(maybe_bytes)
-        except Exception:
-            # Last resort fallback
-            return str(maybe_bytes)
-
-    # Skip the persistent shell approach for now due to async stream complexity
-    print("🔍 Modal's async streams require complex async handling")
-    print("🔄 Switching to individual command execution approach for reliability...")
-    
-    # Initialize state tracking variables
-    current_dir = "/"
-    execution_history = []
-    
-    # Function to run commands using individual sandbox.exec calls
-    def run_command(cmd, show_output=True, retry_count=0, max_retries=3, debug_with_llm=True, timeout=600):
-        """
-        Execute a command in the sandbox with error handling and automatic retries.
-        
-        When a command fails and is fixed by the LLM debugging system, the retry count
-        is reset to 0, so successful fixes don't count against the maximum retry limit.
-        This ensures that a command that's been fixed gets a fresh set of retry attempts.
-        """
-        # Use the outer scope variables
-        nonlocal current_dir, execution_history, sandbox, previous_errors
-        nonlocal conda_installed, python_version_switched, current_python_version
-        
-        # Record command start time
-        command_start_time = datetime.datetime.now().isoformat()
-        start_time = time.time()
-        
-        # Prevent infinite retry loops
-        if retry_count >= max_retries:
-            print(f"⚠️ Maximum retry count ({max_retries}) reached. Stopping retries.")
-            return False, "", f"Maximum retry count ({max_retries}) reached"
-        
-        # Special handling for cd commands to prevent common navigation errors
-        if cmd.strip().startswith("cd "):
-            # Extract the target directory from the cd command
-            cd_parts = cmd.split(None, 1)
-            if len(cd_parts) >= 2:
-                target_dir = cd_parts[1].strip().strip('"\'')
-                
-                # Check if this is a repo name that matches the end of current_dir
-                # This prevents errors like "cd repo-name" when already in "/root/repo-name"
-                # 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"✅ Modal sandbox created successfully!")
-    print(f"📋 Sandbox ID: {sandbox_id}")
-    print(f"📋 Container ID: {container_id}")
-    if volume:
-        print(f"📦 Volume: {volume_name} (mounted at {volume_mount_path})")
-        print(f"💾 Persistent storage available for pip and uv caches")
-        print(f"📂 Repositories will be cloned in home directory (/root) for faster access")
-    print("🔗 To connect to this container, run:")
-    print(f"modal container exec --pty {container_id} bash")
-    print("⏳ Sandbox will remain running until you terminate it with:")
-    print(f"modal sandbox terminate {sandbox_id}")
-
-    # Try to open a new terminal window and connect to the container
-    if container_id:
-        print("🖥️ Attempting to open new terminal window...")
-        # Use osascript to open a new terminal with the modal shell command
-        terminal_script = f'''
-        tell application "Terminal"
-            do script "modal shell {container_id}"
-            activate
-        end tell
-        '''
-        
-        try:
-            result = subprocess.run(['osascript', '-e', terminal_script], 
-                                  capture_output=True, text=True, timeout=30)
-            if result.returncode == 0:
-                print("✅ New terminal window opened successfully")
-            else:
-                print(f"⚠️ Failed to open terminal window: {result.stderr}")
-                
-                # Try alternative approach with iTerm2 if Terminal failed
-                print("🔄 Trying with iTerm2 instead...")
-                iterm_script = f'''
-                tell application "iTerm"
-                    create window with default profile
-                    tell current session of current window
-                        write text "modal shell {container_id}"
-                    end tell
-                end tell
-                '''
-                
-                try:
-                    iterm_result = subprocess.run(['osascript', '-e', iterm_script], 
-                                              capture_output=True, text=True, timeout=30)
-                    if iterm_result.returncode == 0:
-                        print("✅ New iTerm2 window opened successfully")
-                    else:
-                        print(f"⚠️ Failed to open iTerm2 window: {iterm_result.stderr}")
-                        print("📝 You can manually connect using:")
-                        print(f"   modal shell {container_id}")
-                except Exception as e:
-                    print(f"⚠️ Error opening iTerm2: {e}")
-                    print("📝 You can manually connect using:")
-                    print(f"   modal shell {container_id}")
-        except subprocess.TimeoutExpired:
-            print("⚠️ Terminal opening timed out")
-        except Exception as e:
-            print(f"⚠️ Error opening terminal: {e}")
-            print("📝 You can manually connect using:")
-            print(f"   modal shell {container_id}")
-        
-        # Also provide manual connection instructions
-        print("\n" + "="*60)
-        print("🚀 SANDBOX READY!")
-        print("="*60)
-        print(f"📋 Sandbox ID: {sandbox_id}")
-        print(f"🆔 Container ID: {container_id}")
-        if volume:
-            print(f"💾 Volume: {volume_name} mounted at {volume_mount_path}")
-            print("📁 Persistent storage available for caches and repositories")
-        print("\n🔗 To connect to your container, run:")
-        print(f"   modal shell {container_id}")
-        print("="*60)
-    else:
-        print("❌ No container ID available for connection")
-    
-    return {
-        "run_command": run_command,
-        "current_dir": current_dir,
-        "execution_history": execution_history,
-        "container_id": container_id,
-        "sandbox_id": sandbox_id
-    }
-
-
-def 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}")
-        
+        print("⚠️ No OpenAI API key provided to container")
+    
+    # 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}")
@@ -2207,17 +1053,118 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
     # 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}")
+        
+        # First, let's check the current directory structure
+        print("🔍 Checking current directory structure before running setup commands...")
+        try:
+            result = subprocess.run("pwd && ls -la", shell=True, check=True, 
+                                  capture_output=True, text=True)
+            print(f"📂 Current directory: {result.stdout}")
+        except subprocess.CalledProcessError as e:
+            print(f"⚠️ Could not check directory structure: {e}")
+        
+        # Define a simple run_command function for SSH container
+        def run_command_with_llm_debug(cmd, show_output=True, retry_count=0, max_retries=3):
+            """Execute a command with LLM debugging enabled"""
+            print(f"🔧 Executing: {cmd}")
             try:
-                result = subprocess.run(cmd, shell=True, check=True, 
-                                      capture_output=True, text=True)
-                if result.stdout:
+                # Handle special case for source command which doesn't work with subprocess.run
+                if cmd.strip().startswith("source ") or " source " in cmd:
+                    print("⚠️ Detected 'source' command which doesn't work with subprocess.run")
+                    print("🔄 Converting to bash -c with dot (.) instead of source")
+                    # Replace source with . (dot) which is the same as source but works in sh
+                    modified_cmd = cmd.replace("source ", ". ")
+                    # Wrap in bash -c to ensure it runs in bash
+                    bash_cmd = f"bash -c '{modified_cmd}'"
+                    print(f"🔄 Modified command: {bash_cmd}")
+                    result = subprocess.run(bash_cmd, shell=True, check=True, 
+                                          capture_output=True, text=True)
+                else:
+                    result = subprocess.run(cmd, shell=True, check=True, 
+                                          capture_output=True, text=True)
+                
+                if result.stdout and show_output:
                     print(f"✅ Output: {result.stdout}")
+                return True, result.stdout, ""
             except subprocess.CalledProcessError as e:
+                error_output = e.stderr if e.stderr else str(e)
                 print(f"❌ Command failed: {e}")
-                if e.stderr:
-                    print(f"❌ Error: {e.stderr}")
+                print(f"❌ Error: {error_output}")
+                
+                # Call OpenAI for debugging
+                print("🔍 Attempting to debug the failed command with OpenAI...")
+                try:
+                    # Get the current directory for context
+                    current_dir = os.getcwd()
+                    
+                    # Call OpenAI for debugging
+                    print(f"🔍 DEBUG: About to call call_openai_for_debug...")
+                    print(f"🔍 DEBUG: Command: {cmd}")
+                    print(f"🔍 DEBUG: Error output length: {len(error_output)}")
+                    print(f"🔍 DEBUG: Current directory: {current_dir}")
+                    
+                    # Get the API key from environment or use the one that was fetched earlier
+                    api_key = os.environ.get("OPENAI_API_KEY")
+                    fix_command = call_openai_for_debug(cmd, error_output, api_key=api_key, current_dir=current_dir)
+                    
+                    print(f"🔍 DEBUG: call_openai_for_debug returned: {fix_command}")
+                    
+                    if fix_command:
+                        print(f"🔧 OpenAI suggested fix command: {fix_command}")
+                        
+                        # Run the fix command
+                        print(f"🔄 Running suggested fix command: {fix_command}")
+                        try:
+                            fix_result = subprocess.run(fix_command, shell=True, check=True, 
+                                                      capture_output=True, text=True)
+                            if fix_result.stdout:
+                                print(f"✅ Fix command output: {fix_result.stdout}")
+                            
+                            # Retry the original command
+                            print(f"🔄 Retrying original command: {cmd}")
+                            return run_command_with_llm_debug(cmd, show_output, retry_count + 1, max_retries)
+                        except subprocess.CalledProcessError as fix_e:
+                            print(f"❌ Fix command also failed: {fix_e}")
+                            return False, "", error_output
+                    else:
+                        print("❌ No fix suggested by OpenAI")
+                        return False, "", error_output
+                        
+                except Exception as debug_e:
+                    print(f"❌ LLM debugging failed: {debug_e}")
+                    return False, "", error_output
+        
+        for i, cmd in enumerate(setup_commands, 1):
+            print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
+            
+            # Check if this is a cd command and if the directory exists
+            if cmd.strip().startswith("cd "):
+                cd_parts = cmd.split(None, 1)
+                if len(cd_parts) >= 2:
+                    target_dir = cd_parts[1].strip('"\'')
+                    print(f"🔍 Checking if directory exists: {target_dir}")
+                    try:
+                        check_result = subprocess.run(f"test -d '{target_dir}'", shell=True, 
+                                                   capture_output=True, text=True)
+                        if check_result.returncode != 0:
+                            print(f"⚠️ Directory does not exist: {target_dir}")
+                            print(f"🔍 Current directory contents:")
+                            subprocess.run("pwd && ls -la", shell=True, check=False)
+                            
+                            # Try to find similar directories
+                            print(f"🔍 Looking for similar directories...")
+                            subprocess.run("find . -type d -name '*llama*' -o -name '*nano*' 2>/dev/null | head -10", shell=True, check=False)
+                    except Exception as e:
+                        print(f"⚠️ Could not check directory: {e}")
+            
+            success, stdout, stderr = run_command_with_llm_debug(cmd, show_output=True)
+            if not success:
+                print(f"⚠️ Command {i} failed, but continuing with remaining commands...")
+                
+                # If this was a cd command that failed, try to understand the directory structure
+                if cmd.strip().startswith("cd ") and "No such file or directory" in stderr:
+                    print(f"🔍 Analyzing directory structure after failed cd command...")
+                    subprocess.run("pwd && ls -la && echo '--- Parent directory ---' && ls -la ..", shell=True, check=False)
     
     # Get container info
     print("🔍 Container started successfully!")
@@ -2235,23 +1182,56 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
             subprocess.run(["service", "ssh", "start"], check=True)
 
 # Now modify the create_modal_ssh_container function to use the standalone ssh_container_function
-
 def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
-                               volume_name=None, timeout_minutes=60, ssh_password=None):
+                               volume_name=None, timeout_minutes=60, ssh_password=None, interactive=False):
     """Create a Modal SSH container with GPU support and tunneling"""
     
+    # Use interactive mode if specified
+    if interactive:
+        # If GPU type is not specified, prompt for it
+        if not gpu_type:
+            gpu_type = prompt_for_gpu()
+            
+        # If repo URL is not specified, prompt for it
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    return None
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                return None
+                
+        # If volume name is not specified, ask about persistent volume
+        if not volume_name:
+            try:
+                use_volume = input("? Use persistent volume for faster installs? (Y/n): ").strip().lower()
+                if use_volume in ('', 'y', 'yes'):
+                    volume_name = input("? Enter volume name: ").strip()
+                    if not volume_name:
+                        volume_name = "gitarsenal-volume"
+                        print(f"Using default volume name: {volume_name}")
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                return None
+    
     # 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"🔍 MODAL_TOKEN_ID exists: {'Yes' if modal_token_id else 'No'}")
-        print(f"🔍 MODAL_TOKEN exists: {'Yes' if modal_token else 'No'}")
+        openai_api_key = os.environ.get("OPENAI_API_KEY")
+        print(f"🔍 token exists: {'Yes' if modal_token_id else 'No'}")
+        print(f"🔍 token exists: {'Yes' if modal_token else 'No'}")
+        print(f"🔍 openai_api_key exists: {'Yes' if openai_api_key else 'No'}")
         if modal_token_id:
-            print(f"🔍 MODAL_TOKEN_ID length: {len(modal_token_id)}")
+            print(f"🔍 token length: {len(modal_token_id)}")
         if modal_token:
-            print(f"🔍 MODAL_TOKEN length: {len(modal_token)}")
+            print(f"🔍 token length: {len(modal_token)}")
+        if openai_api_key:
+            print(f"🔍 openai_api_key length: {len(openai_api_key)}")
         
         # Try to access Modal token to check authentication
         try:
@@ -2262,13 +1242,13 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 # Try to get from MODAL_TOKEN
                 modal_token = os.environ.get("MODAL_TOKEN")
                 if modal_token:
-                    print("✅ Found token in MODAL_TOKEN environment variable")
+                    print("✅ Found token in environment variable")
                     os.environ["MODAL_TOKEN_ID"] = modal_token
                     modal_token_id = modal_token
-                    print(f"✅ Set MODAL_TOKEN_ID from MODAL_TOKEN (length: {len(modal_token)})")
+                    print(f"✅ Set token (length: {len(modal_token)})")
             
             if modal_token_id:
-                print(f"✅ Modal token found (length: {len(modal_token_id)})")
+                print(f"✅ token found (length: {len(modal_token_id)})")
                 
                 # Use the comprehensive fix_modal_token script
                 try:
@@ -2289,11 +1269,11 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                         if result.stderr:
                             print(f"Error: {result.stderr}")
                             
-                    print(f"✅ Modal token setup completed")
+                    print(f"✅ token setup completed")
                 except Exception as e:
                     print(f"⚠️ Error running fix_modal_token.py: {e}")
             else:
-                print("❌ No Modal token found in environment variables")
+                print("❌ No token found in environment variables")
                 # Try to get from file as a last resort
                 try:
                     home_dir = os.path.expanduser("~")
@@ -2312,7 +1292,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                             else:
                                 print("❌ Token file does not contain token_id")
                     else:
-                        print("❌ Modal token file not found")
+                        print("❌ token file not found")
                 except Exception as e:
                     print(f"❌ Error loading token from file: {e}")
                 
@@ -2326,9 +1306,9 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             modal_token_id = os.environ.get("MODAL_TOKEN_ID")
             modal_token = os.environ.get("MODAL_TOKEN")
             if modal_token_id:
-                print(f"🔄 Using MODAL_TOKEN_ID from environment (length: {len(modal_token_id)})")
+                print(f"🔄 Using token from environment (length: {len(modal_token_id)})")
             elif modal_token:
-                print(f"🔄 Using MODAL_TOKEN from environment (length: {len(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:
@@ -2338,7 +1318,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             # Set it in both environment variables
             os.environ["MODAL_TOKEN_ID"] = modal_token_id
             os.environ["MODAL_TOKEN"] = modal_token_id
-            print("✅ Set both MODAL_TOKEN_ID and MODAL_TOKEN environment variables")
+            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")
@@ -2364,7 +1344,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         gpu_type = 'A10G'
     
     gpu_spec = gpu_configs[gpu_type]
-    print(f"🚀 Creating Modal SSH container with {gpu_spec['gpu']} GPU ({gpu_spec['memory']}GB VRAM)")
+    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:
@@ -2400,16 +1380,16 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     # Print debug info for authentication
     print("🔍 Modal authentication debug info:")
     modal_token = os.environ.get("MODAL_TOKEN_ID")
-    print(f"  - MODAL_TOKEN_ID in env: {'Yes' if modal_token else 'No'}")
+    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 Modal app creation...")
+        print("🔍 Testing app creation...")
         app = modal.App(app_name)
-        print("✅ Created Modal app successfully")
+        print("✅ Created app successfully")
     except Exception as e:
-        print(f"❌ Error creating Modal app: {e}")
+        print(f"❌ Error creating app: {e}")
         return None
 
     # Create SSH-enabled image
@@ -2422,7 +1402,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
                 "gpg", "ca-certificates", "software-properties-common"
             )
-            .pip_install("uv", "modal")  # Fast Python package installer and Modal
+            .pip_install("uv", "modal", "requests", "openai")  # Fast Python package installer and Modal
             .run_commands(
                 # Create SSH directory
                 "mkdir -p /var/run/sshd",
@@ -2465,7 +1445,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         serialized=True,
         volumes=volumes_config if volumes_config else None,
     )
-    def ssh_container_function():
+    def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, setup_commands=None, openai_api_key=None):
         """Start SSH container with password authentication and optional setup."""
         import subprocess
         import time
@@ -2474,6 +1454,13 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # Set root password
         subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
         
+        # Set OpenAI API key if provided
+        if openai_api_key:
+            os.environ['OPENAI_API_KEY'] = openai_api_key
+            print(f"✅ Set OpenAI API key in container environment (length: {len(openai_api_key)})")
+        else:
+            print("⚠️ No OpenAI API key provided to container")
+        
         # Start SSH service
         subprocess.run(["service", "ssh", "start"], check=True)
         
@@ -2498,17 +1485,110 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # 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}")
+            
+            # Define a helper function for running commands with LLM debugging
+            def run_command_with_basic_error_handling(cmd, show_output=True, retry_count=0, max_retries=2):
+                """Execute a command with LLM debugging enabled"""
+                print(f"🔧 Executing: {cmd}")
                 try:
-                    result = subprocess.run(cmd, shell=True, check=True, 
-                                          capture_output=True, text=True)
-                    if result.stdout:
+                    # Handle special case for source command which doesn't work with subprocess.run
+                    if cmd.strip().startswith("source ") or " source " in cmd:
+                        print("⚠️ Detected 'source' command which doesn't work with subprocess.run")
+                        print("🔄 Converting to bash -c with dot (.) instead of source")
+                        # Replace source with . (dot) which is the same as source but works in sh
+                        modified_cmd = cmd.replace("source ", ". ")
+                        # Wrap in bash -c to ensure it runs in bash
+                        bash_cmd = f"bash -c '{modified_cmd}'"
+                        print(f"🔄 Modified command: {bash_cmd}")
+                        result = subprocess.run(bash_cmd, shell=True, check=True, 
+                                              capture_output=True, text=True)
+                    else:
+                        result = subprocess.run(cmd, shell=True, check=True, 
+                                              capture_output=True, text=True)
+                    
+                    if result.stdout and show_output:
                         print(f"✅ Output: {result.stdout}")
+                    return True, result.stdout, ""
                 except subprocess.CalledProcessError as e:
+                    error_output = e.stderr if e.stderr else str(e)
                     print(f"❌ Command failed: {e}")
-                    if e.stderr:
-                        print(f"❌ Error: {e.stderr}")
+                    print(f"❌ Error: {error_output}")
+                    
+                    # Call OpenAI for debugging
+                    print("🔍 Attempting to debug the failed command with OpenAI...")
+                    try:
+                        # Get the current directory for context
+                        current_dir = os.getcwd()
+                        
+                        # Call OpenAI for debugging
+                        print(f"🔍 DEBUG: About to call call_openai_for_debug...")
+                        print(f"🔍 DEBUG: Command: {cmd}")
+                        print(f"🔍 DEBUG: Error output length: {len(error_output)}")
+                        print(f"🔍 DEBUG: Current directory: {current_dir}")
+                        
+                        # Get the API key from environment or use the one that was fetched earlier
+                        api_key = os.environ.get("OPENAI_API_KEY")
+                        fix_command = call_openai_for_debug(cmd, error_output, api_key=api_key, current_dir=current_dir)
+                        
+                        print(f"🔍 DEBUG: call_openai_for_debug returned: {fix_command}")
+                        
+                        if fix_command:
+                            print(f"🔧 OpenAI suggested fix command: {fix_command}")
+                            
+                            # Run the fix command
+                            print(f"🔄 Running suggested fix command: {fix_command}")
+                            try:
+                                fix_result = subprocess.run(fix_command, shell=True, check=True, 
+                                                          capture_output=True, text=True)
+                                if fix_result.stdout:
+                                    print(f"✅ Fix command output: {fix_result.stdout}")
+                                
+                                # Retry the original command
+                                print(f"🔄 Retrying original command: {cmd}")
+                                return run_command_with_basic_error_handling(cmd, show_output, retry_count + 1, max_retries)
+                            except subprocess.CalledProcessError as fix_e:
+                                print(f"❌ Fix command also failed: {fix_e}")
+                                return False, "", error_output
+                        else:
+                            print("❌ No fix suggested by OpenAI")
+                            return False, "", error_output
+                            
+                    except Exception as debug_e:
+                        print(f"❌ LLM debugging failed: {debug_e}")
+                        return False, "", error_output
+            
+            # Run each setup command
+            for i, cmd in enumerate(setup_commands, 1):
+                print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
+                
+                # Check if this is a cd command and if the directory exists
+                if cmd.strip().startswith("cd "):
+                    cd_parts = cmd.split(None, 1)
+                    if len(cd_parts) >= 2:
+                        target_dir = cd_parts[1].strip('"\'')
+                        print(f"🔍 Checking if directory exists: {target_dir}")
+                        try:
+                            check_result = subprocess.run(f"test -d '{target_dir}'", shell=True, 
+                                                       capture_output=True, text=True)
+                            if check_result.returncode != 0:
+                                print(f"⚠️ Directory does not exist: {target_dir}")
+                                print(f"🔍 Current directory contents:")
+                                subprocess.run("pwd && ls -la", shell=True, check=False)
+                                
+                                # Try to find similar directories
+                                print(f"🔍 Looking for similar directories...")
+                                subprocess.run("find . -type d -name '*llama*' -o -name '*nano*' 2>/dev/null | head -10", shell=True, check=False)
+                        except Exception as e:
+                            print(f"⚠️ Could not check directory: {e}")
+                
+                success, stdout, stderr = run_command_with_basic_error_handling(cmd, show_output=True)
+                if not success:
+                    print(f"⚠️ Command {i} failed, but continuing with remaining commands...")
+                    
+                    # If this was a cd command that failed, try to understand the directory structure
+                    if cmd.strip().startswith("cd ") and "No such file or directory" in stderr:
+                        print(f"🔍 Analyzing directory structure after failed cd command...")
+                        subprocess.run("pwd && ls -la && echo '--- Parent directory ---' && ls -la ..", shell=True, check=False)
         
         # Create SSH tunnel
         with modal.forward(22, unencrypted=True) as tunnel:
@@ -2544,7 +1624,9 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # Start the container in a new thread to avoid blocking
         with modal.enable_output():
             with app.run():
-                ssh_container_function.remote()
+                # Get the API key from environment
+                api_key = os.environ.get("OPENAI_API_KEY")
+                ssh_container_function.remote(ssh_password, repo_url, repo_name, setup_commands, api_key)
                 
         # Clean up Modal token after container is successfully created
         cleanup_modal_token()
@@ -2565,8 +1647,13 @@ def fetch_setup_commands_from_api(repo_url):
     import os
     import shutil
     import json
+    import time
+    import requests
     
-    api_url = "https://git-arsenal.vercel.app/api/analyze-with-gitingest"
+    # 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}")
     
@@ -2588,6 +1675,13 @@ def fetch_setup_commands_from_api(repo_url):
     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
@@ -2624,16 +1718,65 @@ def fetch_setup_commands_from_api(repo_url):
                     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": "Unknown",
-                                        "detected_technologies": [],
+                                        "detected_language": detected_language,
+                                        "detected_technologies": detected_technologies,
                                     },
                                     "repository_analysis": {
                                         "summary": content[:5000],  # First 5000 chars as summary
@@ -2641,6 +1784,12 @@ def fetch_setup_commands_from_api(repo_url):
                                     },
                                     "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)
@@ -2660,17 +1809,46 @@ def fetch_setup_commands_from_api(repo_url):
         
         print(f"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
         
-        # Make the API request
-        print(f"🌐 Making POST request to: {api_url}")
-        try:
-            response = requests.post(api_url, json=payload, timeout=60)
+        # 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"]:
@@ -2722,16 +1900,13 @@ def fetch_setup_commands_from_api(repo_url):
                 return generate_fallback_commands(gitingest_data)
             else:
                 print(f"❌ API request failed with status code: {response.status_code}")
-                print(f"Error response: {response.text[:500]}...")
+                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 requests.exceptions.Timeout:
-            print("❌ API request timed out after 60 seconds")
-            print("⚠️ Using fallback commands instead")
-            # Return fallback commands
-            return generate_fallback_commands(gitingest_data)
-        except requests.exceptions.ConnectionError:
-            print(f"❌ Connection error: Could not connect to {api_url}")
+        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)
@@ -2954,232 +2129,73 @@ def generate_basic_repo_analysis(repo_dir):
     # Detect package managers
     package_managers = []
     package_files = {
-        'requirements.txt': 'pip',
-        'setup.py': 'pip',
-        'pyproject.toml': 'pip',
-        'package.json': 'npm',
-        'yarn.lock': 'yarn',
-        'pnpm-lock.yaml': 'pnpm',
-        'Cargo.toml': 'cargo',
-        'go.mod': 'go',
-        'Gemfile': 'bundler',
-        'pom.xml': 'maven',
-        'build.gradle': 'gradle',
-        'composer.json': 'composer'
-    }
-    
-    for file, manager in package_files.items():
-        if os.path.exists(os.path.join(repo_dir, file)):
-            package_managers.append(manager)
-    
-    primary_package_manager = package_managers[0] if package_managers else "Unknown"
-    
-    # Get README content
-    readme_content = ""
-    for readme_name in ['README.md', 'README', 'README.txt', 'readme.md']:
-        readme_path = os.path.join(repo_dir, readme_name)
-        if os.path.exists(readme_path):
-            with open(readme_path, 'r', encoding='utf-8', errors='ignore') as f:
-                readme_content = f.read()
-            break
-    
-    # Try to get repository info
-    repo_info = {}
-    try:
-        # Get remote origin URL
-        cmd = ["git", "config", "--get", "remote.origin.url"]
-        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
-        if result.returncode == 0:
-            repo_info["url"] = result.stdout.strip()
-        
-        # Get commit count as a proxy for activity
-        cmd = ["git", "rev-list", "--count", "HEAD"]
-        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
-        if result.returncode == 0:
-            repo_info["commit_count"] = int(result.stdout.strip())
-    except Exception:
-        pass
-    
-    # Build the analysis data
-    return {
-        "system_info": {
-            "platform": "linux",  # Assuming Linux for container environment
-            "python_version": "3.10",  # Common Python version
-            "detected_language": primary_language,
-            "detected_technologies": list(language_counts.keys()),
-            "file_count": file_count,
-            "repo_stars": repo_info.get("stars", 0),
-            "repo_forks": repo_info.get("forks", 0),
-            "primary_package_manager": primary_package_manager,
-            "complexity_level": "medium"  # Default assumption
-        },
-        "repository_analysis": {
-            "summary": f"Repository analysis for {repo_dir}",
-            "readme_content": readme_content[:5000] if readme_content else "No README found",
-            "package_managers": package_managers,
-            "file_extensions": list(file_extensions.keys())
-        },
-        "success": True
-    }
-
-def get_setup_commands_from_local_api(repo_url, gitingest_data):
-    """Try to get setup commands from the local API."""
-    api_url = "http://localhost:3000/api/analyze-with-gitingest"
-    
-    # Prepare the request payload
-    payload = {
-        "repoUrl": repo_url,
-        "gitingestData": gitingest_data,
-        "userRequest": "Setup and run the repository"
-    }
-    
-    try:
-        # Make the API request
-        print(f"🌐 Making POST request to local API: {api_url}")
-        response = requests.post(api_url, json=payload, timeout=60)
-        
-        if response.status_code == 200:
-            data = response.json()
-            if "setupInstructions" in data and "commands" in data["setupInstructions"]:
-                commands = data["setupInstructions"]["commands"]
-                print(f"✅ Successfully fetched {len(commands)} setup commands from local API")
-                
-                # Print the original commands
-                print("📋 Original commands from local 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
-    except Exception as e:
-        print(f"❌ Error connecting to local API: {e}")
-    
-    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')}")
+        '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()
         
-        # 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
+        # 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 fix_setup_commands(commands):
     """Fix setup commands by removing placeholders and comments."""
@@ -3233,140 +2249,431 @@ def find_entry_point(repo_dir):
     
     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 Modal token files and environment variables after SSH container is started"""
-    print("🧹 Cleaning up Modal token for security...")
+    """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 MODAL_TOKEN_ID from environment")
+            # print("✅ Removed token ID from environment")
         
         if "MODAL_TOKEN" in os.environ:
             del os.environ["MODAL_TOKEN"]
-            print("✅ Removed MODAL_TOKEN from environment")
+            # print("✅ Removed token from environment")
             
         if "MODAL_TOKEN_SECRET" in os.environ:
             del os.environ["MODAL_TOKEN_SECRET"]
-            print("✅ Removed MODAL_TOKEN_SECRET from environment")
+            # 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 Modal token file at {modal_toml}")
+            # print(f"✅ Deleted token file at {modal_toml}")
         
-        print("✅ Modal token cleanup completed successfully")
+        # print("✅ Token cleanup completed successfully")
     except Exception as e:
-        print(f"❌ Error during Modal token cleanup: {e}")
+        print(f"❌ Error during token cleanup: {e}")
 
 def show_usage_examples():
-    """Display usage examples for the command-line interface."""
-    print("\033[92mUsage Examples\033[0m")
-    print("")
-    print("\033[92mBasic Container Creation\033[0m")
-    print("\033[90m┌────────────────────────────────────────────────────────────────────────┐\033[0m")
-    print("\033[90m│\033[0m \033[92mgitarsenal --gpu A10G --repo-url https://github.com/username/repo.git\033[0m  \033[90m│\033[0m")
-    print("\033[90m└────────────────────────────────────────────────────────────────────────┘\033[0m")
-    print("")
-    print("\033[92mWith Setup Commands\033[0m")
-    print("\033[90m┌────────────────────────────────────────────────────────────────────────────────────────────────────┐\033[0m")
-    print("\033[90m│\033[0m \033[92mgitarsenal --gpu A100 --repo-url https://github.com/username/repo.git \\\033[0m           \033[90m│\033[0m")
-    print("\033[90m│\033[0m \033[92m  --setup-commands \"pip install -r requirements.txt\" \"python setup.py install\"\033[0m  \033[90m│\033[0m")
-    print("\033[90m└────────────────────────────────────────────────────────────────────────────────────────────────────┘\033[0m")
-    print("")
-    print("\033[92mWith Persistent Storage\033[0m")
-    print("\033[90m┌────────────────────────────────────────────────────────────────────────────────────┐\033[0m")
-    print("\033[90m│\033[0m \033[92mgitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\\033[0m  \033[90m│\033[0m")
-    print("\033[90m│\033[0m \033[92m  --volume-name my-persistent-volume\033[0m                             \033[90m│\033[0m")
-    print("\033[90m└────────────────────────────────────────────────────────────────────────────────────┘\033[0m")
-    print("")
-    print("\033[92mInteractive Mode\033[0m")
-    print("\033[90m┌────────────────────────────┐\033[0m")
-    print("\033[90m│\033[0m \033[92mgitarsenal --interactive\033[0m  \033[90m│\033[0m")
-    print("\033[90m└────────────────────────────┘\033[0m")
-    print("")
-    print("\033[92mAvailable GPU Options:\033[0m")
+    """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("With GitIngest API (default)")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git             │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("Without GitIngest API")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
+    print("│   --no-gitingest                                                │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("With Original API")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\  │")
+    print("│   --use-api                                                      │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
+    print("Available GPU Options:")
     print("  T4, L4, A10G, A100-40GB, A100-80GB, L40S, H100, H200, B200")
-    print("")
 
+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
+
+def get_setup_commands_from_gitingest(repo_url):
+    """
+    Get repository setup commands using the gitingest approach.
+    
+    This function is inspired by gitingest_setup_client.py and provides a more
+    robust way to get setup commands for a repository.
+    
+    Args:
+        repo_url: URL of the repository to set up
+        
+    Returns:
+        List of setup commands or None if failed
+    """
+    import requests
+    import json
+    import os
+    import sys
+    import tempfile
+    import subprocess
+    
+    print(f"🔍 Getting setup commands for repository: {repo_url}")
+    
+    # Define API endpoints to try in order
+    api_endpoints = [
+        "https://www.gitarsenal.dev/api/gitingest-setup-commands",
+        "https://gitarsenal.dev/api/gitingest-setup-commands",
+        "https://www.gitarsenal.dev/api/analyze-with-gitingest",
+        "http://localhost:3000/api/gitingest-setup-commands"
+    ]
+    
+    # Generate basic gitingest data
+    def generate_basic_gitingest_data():
+        # Extract repo name from URL
+        repo_name = repo_url.split('/')[-1].replace('.git', '')
+        
+        return {
+            "system_info": {
+                "platform": "Unknown",
+                "python_version": "Unknown",
+                "detected_language": "Unknown",
+                "detected_technologies": [],
+                "file_count": 0,
+                "repo_stars": 0,
+                "repo_forks": 0,
+                "primary_package_manager": "Unknown",
+                "complexity_level": "Unknown"
+            },
+            "repository_analysis": {
+                "summary": f"Repository: {repo_name}",
+                "tree": "",
+                "content_preview": ""
+            },
+            "success": True
+        }
+    
+    # Try to generate gitingest data using CLI if available
+    def generate_gitingest_data_from_cli():
+        try:
+            # Check if gitingest CLI is available
+            subprocess.run(["gitingest", "--help"], check=True, capture_output=True, text=True)
+            
+            # Create a temporary file for the output
+            with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as tmp:
+                output_file = tmp.name
+            
+            # Run gitingest command
+            print(f"Running gitingest analysis on {repo_url}...")
+            gitingest_cmd = ["gitingest", repo_url, "-o", output_file]
+            result = subprocess.run(gitingest_cmd, capture_output=True, text=True)
+            
+            if result.returncode != 0:
+                print(f"GitIngest CLI failed: {result.stderr}")
+                return None
+            
+            # Read the output file
+            try:
+                with open(output_file, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                    try:
+                        data = json.loads(content)
+                        return data
+                    except json.JSONDecodeError:
+                        # If not JSON, convert the text output to a basic structure
+                        return {
+                            "system_info": {
+                                "platform": "Unknown",
+                                "python_version": "Unknown",
+                                "detected_language": "Unknown",
+                                "detected_technologies": []
+                            },
+                            "repository_analysis": {
+                                "summary": content[:5000],  # First 5000 chars as summary
+                                "tree": "",
+                                "content_preview": content[:10000]  # First 10000 chars as preview
+                            },
+                            "success": True
+                        }
+            except Exception as e:
+                print(f"Error reading gitingest output: {e}")
+                return None
+            finally:
+                # Clean up the temporary file
+                if os.path.exists(output_file):
+                    os.unlink(output_file)
+        
+        except (subprocess.SubprocessError, FileNotFoundError):
+            print("GitIngest CLI not found")
+            return None
+    
+    # First try to get data from CLI
+    gitingest_data = generate_gitingest_data_from_cli()
+    
+    # If CLI failed, use basic data
+    if not gitingest_data:
+        print("Using basic gitingest data")
+        gitingest_data = generate_basic_gitingest_data()
+    
+    # Try each API endpoint
+    for api_url in api_endpoints:
+        try:
+            print(f"Trying API endpoint: {api_url}")
+            
+            payload = {
+                "repoUrl": repo_url,
+                "gitingestData": gitingest_data
+            }
+            
+            # 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 not response:
+                print(f"Failed to connect to {api_url}")
+                continue
+                
+            if response.status_code != 200:
+                print(f"API request failed with status code: {response.status_code}")
+                continue
+            
+            try:
+                result = response.json()
+                
+                # Check if we have commands in the response
+                commands = None
+                
+                # Check for different response formats
+                if "commands" in result:
+                    commands = result["commands"]
+                elif "setupInstructions" in result and "commands" in result["setupInstructions"]:
+                    commands = result["setupInstructions"]["commands"]
+                
+                if commands:
+                    print(f"✅ Successfully fetched {len(commands)} setup commands from API at {api_url}")
+                    
+                    # Print the commands
+                    print("\n📋 Setup Commands:")
+                    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("No commands found in API response")
+            except json.JSONDecodeError:
+                print(f"Failed to parse API response as JSON")
+        except Exception as e:
+            print(f"Error with API endpoint {api_url}: {e}")
+    
+    print("❌ All API endpoints failed")
+    return generate_fallback_commands(gitingest_data)
+
+def prompt_for_gpu():
+    """
+    Prompt the user to select a GPU type from available options using arrow keys.
+    Returns the selected GPU type.
+    """
+    import sys
+    import tty
+    import termios
+    
+    # Define available GPU types and their specifications
+    gpu_specs = {
+        'T4': {'gpu': 'T4', 'memory': '16GB'},
+        'L4': {'gpu': 'L4', 'memory': '24GB'},
+        'A10G': {'gpu': 'A10G', 'memory': '24GB'},
+        'A100-40': {'gpu': 'A100-40GB', 'memory': '40GB'},
+        'A100-80': {'gpu': 'A100-80GB', 'memory': '80GB'},
+        'L40S': {'gpu': 'L40S', 'memory': '48GB'},
+        'H100': {'gpu': 'H100', 'memory': '80GB'},
+        'H200': {'gpu': 'H200', 'memory': '141GB'},
+        'B200': {'gpu': 'B200', 'memory': '141GB'}
+    }
+    
+    # Create a list of options
+    options = list(gpu_specs.keys())
+    selected_index = 2  # Default to A10G (index 2)
+    
+    def get_key():
+        """Get a single keypress from the user."""
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(sys.stdin.fileno())
+            ch = sys.stdin.read(1)
+            if ch == '\x1b':  # Escape sequence
+                ch2 = sys.stdin.read(1)
+                if ch2 == '[':
+                    ch3 = sys.stdin.read(1)
+                    if ch3 == 'A':
+                        return 'UP'
+                    elif ch3 == 'B':
+                        return 'DOWN'
+            elif ch == '\r' or ch == '\n':
+                return 'ENTER'
+            elif ch == '\x03':  # Ctrl+C
+                return 'CTRL_C'
+            return ch
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+    
+    def display_menu():
+        """Display the GPU selection menu with current selection highlighted."""
+        print("\n📊 Available GPU Options:")
+        print("┌──────────────┬─────────┐")
+        print("│   GPU Type   │  VRAM   │")
+        print("├──────────────┼─────────┤")
+        
+        for i, gpu_type in enumerate(options):
+            specs = gpu_specs[gpu_type]
+            # Calculate proper spacing for alignment
+            number_part = f"{i+1}."
+            if i == selected_index:
+                prefix = "> "
+                suffix = " ←"
+            else:
+                prefix = "  "
+                suffix = ""
+            
+            # Ensure consistent width for GPU type column
+            gpu_display = f"{prefix}{number_part} {gpu_type}"
+            gpu_padded = f"{gpu_display:<12}"  # Fixed width for GPU column
+            
+            print(f"│ {gpu_padded} │ {specs['memory']:<7} │{suffix}")
+        
+        print("└──────────────┴─────────┘")
+        print("Use ↑/↓ arrows to select, Enter to confirm, Ctrl+C to cancel")
+    
+    # Clear screen and show initial menu
+    print("\033[2J\033[H", end="")  # Clear screen and move cursor to top
+    display_menu()
+    
+    while True:
+        try:
+            key = get_key()
+            
+            if key == 'UP':
+                selected_index = (selected_index - 1) % len(options)
+                print("\033[2J\033[H", end="")  # Clear screen
+                display_menu()
+            elif key == 'DOWN':
+                selected_index = (selected_index + 1) % len(options)
+                print("\033[2J\033[H", end="")  # Clear screen
+                display_menu()
+            elif key == 'ENTER':
+                selected_gpu = options[selected_index]
+                print(f"\n✅ Selected GPU: {selected_gpu}")
+                return selected_gpu
+            elif key == 'CTRL_C':
+                print("\n🛑 Selection cancelled.")
+                sys.exit(1)
+                
+        except KeyboardInterrupt:
+            print("\n🛑 Selection cancelled.")
+            sys.exit(1)
+        except Exception as e:
+            print(f"\n❌ Error: {e}")
+            # Fall back to simple input method
+            try:
+                choice = input("\n🔍 Select GPU type (number or name, default is A10G): ").strip()
+                if not choice:
+                    return "A10G"
+                if choice.isdigit():
+                    index = int(choice) - 1
+                    if 0 <= index < len(options):
+                        return options[index]
+                elif choice in options:
+                    return choice
+                return "A10G"
+            except:
+                return "A10G"
+
+# Replace the existing GPU argument parsing in the main section
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
     import argparse
     import sys
     
-    parser = argparse.ArgumentParser(description='Create a Modal SSH container with GPU')
-    parser.add_argument('--gpu', type=str, default='A10G', help='GPU type (default: A10G)')
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--gpu', type=str, help='GPU type (e.g., A10G, T4, A100-80GB)')
     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)')
@@ -3377,169 +2684,257 @@ if __name__ == "__main__":
     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('--interactive', action='store_true', help='Run in interactive mode with prompts')
+    parser.add_argument('--use-api', action='store_true', help='Fetch setup commands from original API')
+    parser.add_argument('--use-gitingest', action='store_true', default=True, help='Use gitingest approach to fetch setup commands (default)')
+    parser.add_argument('--no-gitingest', action='store_true', help='Disable gitingest approach for setup commands')
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
+    parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
+    parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
     
     args = parser.parse_args()
     
+    # If --list-gpus is specified, just show GPU options and exit
+    if args.list_gpus:
+        prompt_for_gpu()
+        sys.exit(0)
+    
     # If no arguments or only --show-examples is provided, show usage examples
     if len(sys.argv) == 1 or args.show_examples:
         show_usage_examples()
         sys.exit(0)
-        
-    # Get setup commands from file if specified
-    setup_commands = args.setup_commands or []
     
-    # If interactive mode is enabled, prompt for options
-    if args.interactive:
-        # If repo URL wasn't provided via command line, ask for it
-        if not args.repo_url:
-            args.repo_url = input("✔ Dependencies checked\n? Enter GitHub repository URL: ").strip()
-            if not args.repo_url:
-                print("❌ No repository URL provided. Exiting.")
+    # Check for dependencies
+    print("⠏ Checking dependencies...")
+    print("--- Dependency Check ---")
+    
+    # Check Python version
+    python_version = sys.version.split()[0]
+    print(f"✓ Python {python_version} found")
+    
+    # Check Modal CLI
+    try:
+        subprocess.run(["modal", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Modal CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Modal CLI not found. Please install with: pip install modal")
+    
+    # Check Gitingest CLI
+    try:
+        subprocess.run(["gitingest", "--help"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Gitingest CLI found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("⚠️ Gitingest CLI not found (optional)")
+    
+    # Check Git
+    try:
+        subprocess.run(["git", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("✓ Git found")
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Git not found. Please install Git.")
+    
+    print("------------------------")
+    print("\n✔ Dependencies checked")
+    
+    # Always prompt for GPU selection regardless of interactive mode
+    gpu_type = prompt_for_gpu()
+    args.gpu = gpu_type
+    
+    # Display configuration after GPU selection
+    print("\n📋 Container Configuration:")
+    print(f"Repository URL: {args.repo_url or 'Not specified'}")
+    print(f"GPU Type: {gpu_type}")
+    print(f"Volume: {args.volume_name or 'None'}")
+    if args.use_api:
+        print("Setup Commands: Auto-detect from repository")
+    elif args.setup_commands:
+        print(f"Setup Commands: {len(args.setup_commands)} custom commands")
+    else:
+        print("Setup Commands: Auto-detect from repository")
+    
+    # Confirm settings
+    try:
+        proceed = input("Proceed with these settings? (Y/n): ").strip().lower()
+        if proceed in ('n', 'no'):
+            print("🛑 Operation cancelled by user.")
+            sys.exit(0)
+    except KeyboardInterrupt:
+        print("\n🛑 Operation cancelled by user.")
+        sys.exit(0)
+    
+    # Interactive mode or missing required arguments
+    if args.interactive or not args.repo_url or not args.volume_name:
+        # Get repository URL if not provided
+        repo_url = args.repo_url
+        if not repo_url:
+            try:
+                repo_url = input("? Enter GitHub repository URL: ").strip()
+                if not repo_url:
+                    print("❌ Repository URL is required.")
+                    sys.exit(1)
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
                 sys.exit(1)
         
         # Ask about persistent volume
-        use_volume = input("? Use persistent volume for faster installs? (Yes/No) [Yes]: ").strip().lower()
-        if not use_volume or use_volume.startswith('y'):
-            if not args.volume_name:
-                args.volume_name = input("? Enter volume name [gitarsenal-volume]: ").strip()
-                if not args.volume_name:
-                    args.volume_name = "gitarsenal-volume"
-        else:
-            args.volume_name = None
+        volume_name = args.volume_name
+        if not volume_name:
+            try:
+                use_volume = input("? Use persistent volume for faster installs? (Y/n): ").strip().lower()
+                if use_volume in ('', 'y', 'yes'):
+                    volume_name = input("? Enter volume name: ").strip()
+                    if not volume_name:
+                        volume_name = "gitarsenal-volume"
+                        print(f"Using default volume name: {volume_name}")
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
         
-        # Ask about auto-detecting setup commands
-        use_api = input("? Automatically detect setup commands for this repository? (Yes/No) [Yes]: ").strip().lower()
-        if not use_api or use_api.startswith('y'):
-            args.use_api = True
-        else:
-            args.use_api = False
+        # Ask about setup commands
+        use_gitingest = args.use_gitingest and not args.no_gitingest
+        if not args.use_api and not args.setup_commands and not args.setup_commands_json:
+            try:
+                auto_detect = input("? Automatically detect setup commands for this repository? (Y/n): ").strip().lower()
+                if auto_detect in ('n', 'no'):
+                    use_gitingest = False
+            except KeyboardInterrupt:
+                print("\n🛑 Setup cancelled.")
+                sys.exit(1)
         
-        # GPU selection
-        gpu_options = ['T4', 'L4', 'A10G', 'A100-40GB', 'A100-80GB', 'L40S', 'H100', 'H200', 'B200']
-        print("\n? Select GPU type:")
-        for i, gpu in enumerate(gpu_options, 1):
-            print(f"  {i}. {gpu}")
+        # Update args with interactive values
+        args.repo_url = repo_url
+        args.volume_name = volume_name
+        args.use_gitingest = use_gitingest
+    
+    try:    
+        # Get setup commands from file if specified
+        setup_commands = args.setup_commands or []
+        
+        # Use gitingest by default unless --no-gitingest is set
+        if args.repo_url and (args.use_gitingest and not args.no_gitingest):
+            print("🔄 Using gitingest approach to fetch setup commands (default)")
+            api_commands = get_setup_commands_from_gitingest(args.repo_url)
+            if api_commands:
+                setup_commands = api_commands
+                print(f"📋 Using {len(setup_commands)} commands from gitingest API")
+            else:
+                print("⚠️ Failed to get commands from gitingest API")
+                if not args.use_api:
+                    print("⚠️ Falling back to basic setup commands")
+                    setup_commands = generate_fallback_commands(None)
+                else:
+                    setup_commands = []
+        # If --use-api flag is set and repo_url is provided, fetch setup commands from API
+        elif args.use_api and args.repo_url:
+            print("🔄 Using original 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 original 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 = []
         
-        gpu_choice = input(f"Enter choice (1-{len(gpu_options)}) [default: 3 for A10G]: ").strip()
-        if not gpu_choice:
-            args.gpu = 'A10G'  # Default
-        else:
+        # Parse setup commands from JSON if provided
+        if args.setup_commands_json:
             try:
-                gpu_index = int(gpu_choice) - 1
-                if 0 <= gpu_index < len(gpu_options):
-                    args.gpu = gpu_options[gpu_index]
+                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("⚠️ Invalid choice. Using default: A10G")
-                    args.gpu = 'A10G'
-            except ValueError:
-                print("⚠️ Invalid input. Using default: A10G")
-                args.gpu = 'A10G'
-        
-        # Show configuration summary
-        print("\n📋 Container Configuration:")
-        print(f"Repository URL: {args.repo_url}")
-        print(f"GPU Type: {args.gpu}")
-        print(f"Volume: {args.volume_name if args.volume_name else 'None'}")
-        print(f"Setup Commands: {'Auto-detect from repository' if args.use_api else 'None'}")
-        
-        # Confirm settings
-        confirm = input("? Proceed with these settings? (Yes/No) [Yes]: ").strip().lower()
-        if confirm and not confirm.startswith('y'):
-            print("❌ Setup cancelled by user.")
-            sys.exit(0)
-    
-    # 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()
+                    print(f"⚠️ Invalid JSON format for setup commands: not a list")
+            except json.JSONDecodeError as e:
+                print(f"⚠️ Error parsing JSON setup commands: {e}")
+                print(f"Received JSON string: {args.setup_commands_json}")
+        
+        # Print received setup commands for debugging
+        if setup_commands:
+            print(f"📋 Using {len(setup_commands)} setup commands:")
+            for i, cmd in enumerate(setup_commands, 1):
+                print(f"  {i}. {cmd}")
                 
-                if 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
+        # 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 fallback)")
-                else:
-                    # Line-by-line format
-                    file_commands = [line.strip() for line in content.split('\n') if line.strip()]
-                    setup_commands.extend(file_commands)
-                    print(f"📋 Loaded {len(file_commands)} commands from file (line-by-line format)")
-                    
-        except Exception as e:
-            print(f"⚠️ Error reading commands file: {e}")
-            
-    try:
-        result = create_modal_ssh_container(
-            args.gpu,
-            args.repo_url,
-            args.repo_name,
-            setup_commands,
-            getattr(args, 'volume_name', None),
-            args.timeout,
-            args.ssh_password
-        )
+                        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}")
         
-        print("\n⏳ Keeping the SSH container alive. Press Ctrl+C to exit (container will continue running)...")
-        try:
-            while True:
-                time.sleep(90)
-                print(".", end="", flush=True)
-        except KeyboardInterrupt:
-            print("\n👋 Script exited. The SSH container will continue running.")
-            sys.exit(0)
-            
+        # 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,
+            interactive=args.interactive
+        )
     except KeyboardInterrupt:
-        # Handle Ctrl+C during container creation
-        print("\n👋 Script interrupted during container creation.")
-        print("📝 You may need to check if a container was created with: modal container list")
-        sys.exit(0)
+        # print("\n\n🛑 Execution interrupted")
+        # print("🧹 Cleaning up resources...")
+        cleanup_modal_token()
+        sys.exit(1)
     except Exception as e:
-        print(f"❌ Error: {e}")
+        # print(f"\n❌ Error: {e}")
+        # print("🧹 Cleaning up resources...")
+        cleanup_modal_token()
         sys.exit(1)