gitarsenal-cli 1.4.10 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.4.10",
+  "version": "1.5.1",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {
@@ -21,15 +21,16 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "boxen": "^5.1.2",
     "chalk": "^4.1.2",
-    "inquirer": "^8.2.4",
-    "ora": "^5.4.1",
     "commander": "^9.4.1",
-    "which": "^3.0.0",
-    "fs-extra": "^11.1.0",
     "execa": "^5.1.1",
-    "boxen": "^5.1.2",
-    "update-notifier": "^5.1.0"
+    "fs-extra": "^11.1.0",
+    "g": "^2.0.1",
+    "inquirer": "^8.2.4",
+    "ora": "^5.4.1",
+    "update-notifier": "^5.1.0",
+    "which": "^3.0.0"
   },
   "engines": {
     "node": ">=14.0.0"

package/python/fetch_modal_tokens.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
-Fetch Modal Tokens
+Fetch Modal Tokens and OpenAI API Key
 
-This script fetches Modal tokens from the proxy server.
+This script fetches Modal tokens and OpenAI API key from the proxy server.
 """
 
 import os
@@ -14,10 +14,10 @@ from pathlib import Path
 
 def fetch_default_tokens_from_gitarsenal():
     """
-    Fetch default Modal tokens from gitarsenal.dev API.
+    Fetch default Modal tokens and OpenAI API key from gitarsenal.dev API.
     
     Returns:
-        tuple: (token_id, token_secret) if successful, (None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key) if successful, (None, None, None) otherwise
     """
     endpoint = "https://gitarsenal.dev/api/credentials"
     
@@ -38,40 +38,41 @@ def fetch_default_tokens_from_gitarsenal():
                 data = response.json()
                 token_id = data.get("modalTokenId")
                 token_secret = data.get("modalTokenSecret")
+                openai_api_key = data.get("openaiApiKey")
                 
                 if token_id and token_secret:
                     print("✅ Successfully fetched default tokens from gitarsenal.dev")
-                    return token_id, token_secret
+                    return token_id, token_secret, openai_api_key
                 else:
                     print("❌ Modal tokens not found in gitarsenal.dev response")
-                    return None, None
+                    return None, None, None
             except json.JSONDecodeError:
                 print("❌ Invalid JSON response from gitarsenal.dev")
-                return None, None
+                return None, None, None
         else:
             print(f"❌ Failed to fetch from gitarsenal.dev: {response.status_code} - {response.text[:200]}")
-            return None, None
+            return None, None, None
             
     except requests.exceptions.Timeout:
         print("❌ Request timeout when fetching from gitarsenal.dev")
-        return None, None
+        return None, None, None
     except requests.exceptions.ConnectionError:
         print("❌ Connection failed to gitarsenal.dev")
-        return None, None
+        return None, None, None
     except requests.exceptions.RequestException as e:
         print(f"❌ Request failed to gitarsenal.dev: {e}")
-        return None, None
+        return None, None, None
 
 def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     """
-    Fetch Modal tokens from the proxy server.
+    Fetch Modal tokens and OpenAI API key from the proxy server.
     
     Args:
         proxy_url: URL of the proxy server
         api_key: API key for authentication
         
     Returns:
-        tuple: (token_id, token_secret) if successful, (None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key) if successful, (None, None, None) otherwise
     """
     # Use environment variables if not provided
     if not proxy_url:
@@ -88,12 +89,12 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     if not proxy_url:
         # print("❌ No proxy URL provided or found in environment")
         print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
-        return None, None
+        return None, None, None
         
     if not api_key:
         print("❌ No API key provided or found in environment")
         print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
-        return None, None
+        return None, None, None
     
     # Ensure the URL ends with a slash
     if not proxy_url.endswith("/"):
@@ -115,54 +116,60 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
             data = response.json()
             token_id = data.get("token_id")
             token_secret = data.get("token_secret")
+            openai_api_key = data.get("openai_api_key")
             
             if token_id and token_secret:
                 print("✅ Successfully fetched tokens from proxy server")
-                return token_id, token_secret
+                return token_id, token_secret, openai_api_key
             else:
                 print("❌ Tokens not found in response")
-                return None, None
+                return None, None, None
         else:
             print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
-            return None, None
+            return None, None, None
     except Exception as e:
         print(f"❌ Error fetching tokens: {e}")
-        return None, None
+        return None, None, None
 
 def get_tokens():
     """
-    Get Modal tokens, trying to fetch from the proxy server first.
+    Get Modal tokens and OpenAI API key, trying to fetch from the proxy server first.
     Also sets the tokens in environment variables.
     
     Returns:
-        tuple: (token_id, token_secret)
+        tuple: (token_id, token_secret, openai_api_key)
     """
     # Try to fetch from the proxy server
-    token_id, token_secret = fetch_tokens_from_proxy()
+    token_id, token_secret, openai_api_key = fetch_tokens_from_proxy()
     
     # If we couldn't fetch from the server, try to get default tokens from gitarsenal.dev
     if not token_id or not token_secret:
         print("⚠️ Proxy server failed, trying to fetch default tokens from gitarsenal.dev")
-        token_id, token_secret = fetch_default_tokens_from_gitarsenal()
+        token_id, token_secret, openai_api_key = fetch_default_tokens_from_gitarsenal()
     
     # If we still don't have tokens, we can't proceed
     if not token_id or not token_secret:
         print("❌ Failed to fetch tokens from both proxy server and gitarsenal.dev")
         print("💡 Please check your network connection and API endpoints")
-        return None, None
+        return None, None, None
     
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
     os.environ["MODAL_TOKEN_SECRET"] = token_secret
     # print(f"✅ Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET environment variables")
     
-    return token_id, token_secret
+    # Set OpenAI API key if available
+    if openai_api_key:
+        os.environ["OPENAI_API_KEY"] = openai_api_key
+        print(f"✅ Set OPENAI_API_KEY environment variable")
+    
+    return token_id, token_secret, openai_api_key
 
 if __name__ == "__main__":
     # Parse command-line arguments if run directly
     import argparse
     
-    parser = argparse.ArgumentParser(description='Fetch Modal tokens from the proxy server')
+    parser = argparse.ArgumentParser(description='Fetch Modal tokens and OpenAI API key from the proxy server')
     parser.add_argument('--proxy-url', help='URL of the proxy server')
     parser.add_argument('--proxy-api-key', help='API key for the proxy server')
     args = parser.parse_args()
@@ -177,25 +184,30 @@ if __name__ == "__main__":
         print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
-    token_id, token_secret = get_tokens()
+    token_id, token_secret, openai_api_key = get_tokens()
     print(f"Token ID: {token_id}")
     print(f"Token Secret: {token_secret}")
+    print(f"OpenAI API Key: {openai_api_key[:5] + '...' if openai_api_key else None}")
     
     # Check if tokens are set in environment variables
     print(f"\n🔍 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"🔍 OPENAI_API_KEY exists: {'Yes' if os.environ.get('OPENAI_API_KEY') else 'No'}")
     if os.environ.get('MODAL_TOKEN_ID'):
         print(f"🔍 MODAL_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'))}")
+    if os.environ.get('OPENAI_API_KEY'):
+        print(f"🔍 OPENAI_API_KEY length: {len(os.environ.get('OPENAI_API_KEY'))}")
     
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"
     with open(tokens_file, 'w') as f:
         json.dump({
             "token_id": token_id,
-            "token_secret": token_secret
+            "token_secret": token_secret,
+            "openai_api_key": openai_api_key
         }, f)
     print(f"\n✅ Tokens written to {tokens_file}")
     
@@ -216,6 +228,27 @@ if __name__ == "__main__":
         f.write(f"token_secret = {token_secret}\n")
     print(f"✅ Created .modalconfig file at {modalconfig_file}")
     
+    # Create or update .env file with OpenAI API key
+    env_file = Path.home() / ".env"
+    env_content = ""
+    if env_file.exists():
+        with open(env_file, 'r') as f:
+            env_content = f.read()
+    
+    # Update or add OPENAI_API_KEY
+    if openai_api_key:
+        if "OPENAI_API_KEY" in env_content:
+            # Replace existing key
+            import re
+            env_content = re.sub(r'OPENAI_API_KEY=.*\n', f'OPENAI_API_KEY={openai_api_key}\n', env_content)
+        else:
+            # Add new key
+            env_content += f'\nOPENAI_API_KEY={openai_api_key}\n'
+        
+        with open(env_file, 'w') as f:
+            f.write(env_content)
+        print(f"✅ Updated OpenAI API key in {env_file}")
+    
     # Try to use the Modal CLI to set the token
     try:
         print(f"\n🔄 Setting token via Modal CLI...")

package/python/fix_commands.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+Fix commands for Modal SSH container
+This script fixes common issues with commands in the Modal SSH container
+"""
+
+import os
+import sys
+import subprocess
+
+def fix_command(cmd):
+    """Fix common issues with commands"""
+    # Replace 'source' with '.' for sh shell
+    if 'source' in cmd:
+        cmd = cmd.replace('source', '.')
+        print(f"✅ Fixed: Replaced 'source' with '.' for sh shell")
+    
+    # Fix uv venv and activation in one command
+    if 'uv venv' in cmd and '&&' in cmd:
+        # The command is already trying to create and activate a venv
+        # Just need to make sure 'source' is replaced with '.'
+        pass
+    
+    # Fix uv pip install without active venv
+    if 'uv pip install' in cmd and 'venv' not in cmd:
+        # Create and activate a venv first
+        cmd = f"uv venv .venv && . .venv/bin/activate && {cmd}"
+        print(f"✅ Fixed: Added venv creation and activation before pip install")
+    
+    return cmd
+
+def run_fixed_command(cmd):
+    """Run the fixed command"""
+    fixed_cmd = fix_command(cmd)
+    print(f"\n🔧 Running fixed command: {fixed_cmd}")
+    
+    # Run the command
+    result = subprocess.run(fixed_cmd, shell=True, text=True, capture_output=True)
+    
+    # Print the output
+    if result.stdout:
+        print(f"\n--- Output ---\n{result.stdout}")
+    if result.stderr:
+        print(f"\n--- Error ---\n{result.stderr}")
+    
+    # Return the result
+    return result.returncode == 0
+
+def main():
+    """Main function"""
+    if len(sys.argv) < 2:
+        print("Usage: python fix_commands.py 'command to fix'")
+        return 1
+    
+    # Get the command from command line
+    cmd = ' '.join(sys.argv[1:])
+    print(f"🔍 Original command: {cmd}")
+    
+    # Run the fixed command
+    success = run_fixed_command(cmd)
+    
+    # Print the result
+    if success:
+        print("\n✅ Command executed successfully")
+    else:
+        print("\n❌ Command failed")
+    
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    sys.exit(main()) 

package/python/fix_modal_token.py

@@ -35,7 +35,7 @@ try:
         # Fall back to the basic implementation
         print("🔄 Falling back to basic implementation")
 except Exception as e:
-    print(f"❌ Error running advanced Modal token fixer: {e}")
+    # print(f"❌ Error running advanced Modal token fixer: {e}")
     print("🔄 Falling back to basic implementation")
 
 # Try to get tokens from the proxy server

package/python/fix_setup_commands.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Fix setup commands for open-r1 repository
+"""
+
+import os
+import sys
+import subprocess
+
+# Original problematic commands
+original_commands = [
+    "git clone https://github.com/huggingface/open-r1.git",
+    "cd open-r1",
+    "uv venv openr1 --python 3.11 && source openr1/bin/activate && uv pip install --upgrade pip",
+    "uv pip install vllm==0.8.5.post1",
+    "uv pip install setuptools && uv pip install flash-attn --no-build-isolation"
+]
+
+# Fixed commands
+fixed_commands = [
+    "git clone https://github.com/huggingface/open-r1.git",
+    "cd open-r1",
+    "uv venv openr1 --python 3.11 && . openr1/bin/activate && uv pip install --upgrade pip",
+    ". openr1/bin/activate && uv pip install vllm==0.8.5.post1",
+    ". openr1/bin/activate && uv pip install setuptools && uv pip install flash-attn --no-build-isolation"
+]
+
+def run_command(cmd, cwd=None):
+    """Run a command and return the result"""
+    print(f"\n▶ {cmd}")
+    
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            text=True,
+            capture_output=True,
+            cwd=cwd
+        )
+        
+        # Print output
+        if result.stdout:
+            print(result.stdout)
+        
+        # Print error
+        if result.stderr:
+            print(f"Error: {result.stderr}")
+        
+        # Return success/failure
+        return result.returncode == 0, result.stdout, result.stderr
+    except Exception as e:
+        print(f"Error executing command: {e}")
+        return False, "", str(e)
+
+def main():
+    """Main function"""
+    print("🔧 Fixing setup commands for open-r1 repository")
+    
+    # Check if we're in the right directory
+    cwd = os.getcwd()
+    print(f"📂 Current directory: {cwd}")
+    
+    # Check if we need to change directory
+    if not cwd.endswith('open-r1'):
+        parent_dir = cwd
+        # Check if open-r1 exists in the current directory
+        if os.path.exists(os.path.join(cwd, 'open-r1')):
+            print(f"📂 Found open-r1 directory, changing to it")
+            os.chdir(os.path.join(cwd, 'open-r1'))
+            cwd = os.getcwd()
+            print(f"📂 New current directory: {cwd}")
+    
+    # Run the fixed commands
+    for i, cmd in enumerate(fixed_commands):
+        print(f"\n📋 Running command {i+1}/{len(fixed_commands)}: {cmd}")
+        
+        # Skip git clone if the directory already exists
+        if cmd.startswith("git clone") and os.path.exists("open-r1"):
+            print("✅ Repository already cloned, skipping")
+            continue
+        
+        # Skip cd if we're already in the right directory
+        if cmd.startswith("cd "):
+            target_dir = cmd.split(" ", 1)[1]
+            if cwd.endswith(target_dir):
+                print(f"✅ Already in {target_dir}, skipping")
+                continue
+        
+        # Run the command
+        success, stdout, stderr = run_command(cmd)
+        
+        # Check if the command succeeded
+        if not success:
+            print(f"❌ Command failed: {cmd}")
+            print(f"❌ Error: {stderr}")
+            
+            # If this is a cd command, try to continue
+            if cmd.startswith("cd "):
+                print("⚠️ Directory change failed, but continuing with next command")
+                continue
+                
+            # For other commands, ask if the user wants to continue
+            try:
+                choice = input("Continue with next command? (y/n): ").strip().lower()
+                if choice != 'y':
+                    print("🛑 Stopping execution")
+                    return 1
+            except:
+                print("🛑 Stopping execution due to error")
+                return 1
+    
+    print("\n✅ All commands executed")
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main()) 

package/python/patch_modal_script.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Patch the test_modalSandboxScript.py file to fix issues with LLM debugging
+"""
+
+import os
+import sys
+import re
+
+def read_file(filename):
+    """Read a file and return its contents"""
+    with open(filename, 'r') as f:
+        return f.read()
+
+def write_file(filename, content):
+    """Write content to a file"""
+    with open(filename, 'w') as f:
+        f.write(content)
+
+def patch_file(filename):
+    """Patch the file to fix issues with LLM debugging"""
+    print(f"🔧 Patching {filename}...")
+    
+    # Read the file
+    content = read_file(filename)
+    
+    # Make a backup
+    backup_filename = f"{filename}.bak"
+    write_file(backup_filename, content)
+    print(f"✅ Created backup: {backup_filename}")
+    
+    # Fix 1: Replace 'source' with '.' in commands
+    pattern1 = r'(uv venv.*?)source(.*?activate)'
+    replacement1 = r'\1.\2'
+    content = re.sub(pattern1, replacement1, content)
+    print("✅ Fixed 'source' commands")
+    
+    # Fix 2: Add environment activation before uv pip commands
+    pattern2 = r'(uv pip install.*?)(?!\. .*?activate)'
+    replacement2 = r'. openr1/bin/activate && \1'
+    content = re.sub(pattern2, replacement2, content)
+    print("✅ Added environment activation before pip commands")
+    
+    # Write the patched file
+    write_file(filename, content)
+    print(f"✅ Patched file written: {filename}")
+    
+    return True
+
+def main():
+    """Main function"""
+    # Get the file to patch
+    if len(sys.argv) > 1:
+        filename = sys.argv[1]
+    else:
+        # Default to the test_modalSandboxScript.py in the current directory
+        filename = "test_modalSandboxScript.py"
+    
+    # Check if the file exists
+    if not os.path.exists(filename):
+        print(f"❌ File not found: {filename}")
+        return 1
+    
+    # Patch the file
+    success = patch_file(filename)
+    
+    if success:
+        print("\n✅ Patching completed successfully")
+        return 0
+    else:
+        print("\n❌ Patching failed")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main()) 

package/python/test_llm_debug.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Test script to verify LLM debugging functionality
+"""
+
+import os
+import sys
+import requests
+import getpass
+
+def test_openai_connection():
+    """Test if we can connect to OpenAI API"""
+    print("🔍 Testing OpenAI API connection...")
+    
+    # Try to get API key
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ No OPENAI_API_KEY environment variable found")
+        print("💡 Please set your OpenAI API key:")
+        print("   export OPENAI_API_KEY='your-api-key-here'")
+        return False
+    
+    print(f"✅ Found API key (length: {len(api_key)})")
+    
+    # Test API connection
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+    
+    payload = {
+        "model": "gpt-4o-mini",
+        "messages": [
+            {"role": "user", "content": "Say 'Hello, LLM debugging is working!'"}
+        ],
+        "max_tokens": 50
+    }
+    
+    try:
+        print("🤖 Testing API call...")
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            message = result["choices"][0]["message"]["content"]
+            print(f"✅ API test successful: {message}")
+            return True
+        else:
+            print(f"❌ API test failed with status code: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ API test failed with exception: {e}")
+        return False
+
+def test_llm_debug_function():
+    """Test the LLM debug function from the main script"""
+    print("\n🔍 Testing LLM debug function...")
+    
+    # Import the function from the main script
+    try:
+        # Add the current directory to Python path
+        sys.path.insert(0, os.path.dirname(__file__))
+        
+        # Import the function
+        from test_modalSandboxScript import call_openai_for_debug
+        
+        # Test with a simple command failure
+        test_command = "ls /nonexistent/directory"
+        test_error = "ls: cannot access '/nonexistent/directory': No such file or directory"
+        
+        print(f"🧪 Testing with command: {test_command}")
+        print(f"🧪 Error: {test_error}")
+        
+        result = call_openai_for_debug(test_command, test_error)
+        
+        if result:
+            print(f"✅ LLM debug function returned: {result}")
+            return True
+        else:
+            print("❌ LLM debug function returned None")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error testing LLM debug function: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🧪 Testing LLM debugging functionality...")
+    print("=" * 60)
+    
+    # Test 1: OpenAI API connection
+    api_ok = test_openai_connection()
+    
+    # Test 2: LLM debug function
+    if api_ok:
+        debug_ok = test_llm_debug_function()
+    else:
+        debug_ok = False
+    
+    print("\n" + "=" * 60)
+    print("📊 Test Results:")
+    print(f"   OpenAI API Connection: {'✅ PASS' if api_ok else '❌ FAIL'}")
+    print(f"   LLM Debug Function: {'✅ PASS' if debug_ok else '❌ FAIL'}")
+    
+    if api_ok and debug_ok:
+        print("\n🎉 All tests passed! LLM debugging should work.")
+    else:
+        print("\n⚠️ Some tests failed. LLM debugging may not work properly.")
+        if not api_ok:
+            print("💡 To fix OpenAI API issues:")
+            print("   1. Get an API key from https://platform.openai.com/api-keys")
+            print("   2. Set it as environment variable: export OPENAI_API_KEY='your-key'")
+            print("   3. Run this test again") 

package/python/test_modalSandboxScript.py

@@ -38,7 +38,7 @@ try:
     # Import the fetch_modal_tokens module
     # print("🔄 Fetching tokens from proxy server...")
     from fetch_modal_tokens import get_tokens
-    token_id, token_secret = get_tokens()
+    token_id, token_secret, openai_api_key = get_tokens()
     
     # Check if we got valid tokens
     if token_id is None or token_secret is None:
@@ -49,7 +49,7 @@ try:
     # 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
     
@@ -331,6 +331,12 @@ def handle_interactive_command(cmd, sandbox, current_dir):
 
 def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
     """Call OpenAI to debug a failed command and suggest a fix"""
+    print("\n🔍 DEBUG: Starting OpenAI LLM debugging...")
+    print(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:
@@ -359,8 +365,11 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
     
     # Try to get API key from multiple sources
     if not api_key:
+        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'}")
         
         # Store the API key in a persistent file if found
         if api_key:
@@ -376,28 +385,38 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
         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 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()
-            except ImportError:
+                print(f"🔍 DEBUG: API key from credentials manager: {'Found' if api_key else '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)
@@ -421,6 +440,14 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                 print(f"❌ Error getting API key: {e}")
                 return None
     
+    # 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 = ""
@@ -606,6 +633,8 @@ Do not provide any explanations, just the exact command to run.
 """
     
     # Prepare the API request payload
+    print("🔍 DEBUG: Preparing API request...")
+    
     # 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)
@@ -620,9 +649,16 @@ Do not provide any explanations, just the exact command to run.
         
     # 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]}...")
+        
         payload = {
             "model": model_name,
             "messages": [
@@ -633,6 +669,8 @@ Do not provide any explanations, just the exact command to run.
             "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):
@@ -644,6 +682,7 @@ Do not provide any explanations, just the exact command to run.
                     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,
@@ -651,29 +690,36 @@ Do not provide any explanations, just the exact command to run.
                     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:
@@ -682,18 +728,22 @@ Do not provide any explanations, just the exact command to run.
             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:
@@ -722,7 +772,12 @@ Do not provide any explanations, just the exact command to run.
     
     # Process the response
     try:
+        print(f"🔍 DEBUG: Processing OpenAI response...")
+        print(f"🔍 DEBUG: Response structure: {list(result.keys())}")
+        print(f"🔍 DEBUG: 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
@@ -798,9 +853,12 @@ Do not provide any explanations, just the exact command to run.
             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 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():
@@ -1646,6 +1704,11 @@ cd "{current_dir}"
             # If command failed and we're debugging with LLM
             if debug_with_llm:
                 print("🔍 Attempting to debug the failed command with OpenAI...")
+                print(f"🔍 DEBUG: Command that failed: {cmd_to_execute}")
+                print(f"🔍 DEBUG: Exit code: {exit_code}")
+                print(f"🔍 DEBUG: stderr length: {len(stderr_buffer)}")
+                print(f"🔍 DEBUG: stdout length: {len(stdout_buffer)}")
+                
                 # Ensure we have a non-empty error message to debug
                 if not stderr_buffer.strip() and stdout_buffer.strip():
                     print("⚠️ stderr is empty but stdout contains content, using stdout for debugging")
@@ -1679,158 +1742,6 @@ cd "{current_dir}"
                         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 common errors that we can fix automatically
-                common_errors = [
-                    # Source command not found in sh shell
-                    {
-                        "pattern": "source: not found",
-                        "fix": lambda cmd: cmd.replace("source ", ". ")
-                    },
-                    # No virtual environment found for uv
-                    {
-                        "pattern": "No virtual environment found; run `uv venv`",
-                        "fix": lambda cmd: "uv venv .venv && . .venv/bin/activate && " + cmd
-                    }
-                ]
-                
-                # Check if any of the common errors match and apply automatic fix
-                for error_info in common_errors:
-                    if error_info["pattern"] in stderr_buffer:
-                        print(f"🔍 Detected common error: {error_info['pattern']}")
-                        fix_func = error_info["fix"]
-                        fixed_cmd = fix_func(cmd_to_execute)
-                        print(f"🔧 Applying automatic fix: {fixed_cmd}")
-                        
-                        # Run the fixed command
-                        fix_success, fix_stdout, fix_stderr = run_command(fixed_cmd, show_output=True, debug_with_llm=False)
-                        if fix_success:
-                            print("✅ Automatic fix succeeded!")
-                            return True, fix_stdout, ""
-                        else:
-                            print("❌ Automatic fix failed, continuing with LLM debugging")
-                
-                # 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():
@@ -1848,8 +1759,17 @@ cd "{current_dir}"
                 print(debug_output if debug_output else "[EMPTY]")
                 print("="*60)
                 
+                print(f"🔍 DEBUG: About to call call_openai_for_debug...")
+                print(f"🔍 DEBUG: Command: {cmd_to_execute}")
+                print(f"🔍 DEBUG: Debug output length: {len(debug_output)}")
+                print(f"🔍 DEBUG: Current directory: {current_dir}")
+                print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
+                print(f"🔍 DEBUG: Debug output preview: {debug_output[:200]}...")
+                
                 fix_command = call_openai_for_debug(cmd_to_execute, debug_output, current_dir=current_dir, sandbox=sandbox)
                 
+                print(f"🔍 DEBUG: call_openai_for_debug returned: {fix_command}")
+                
                 if fix_command:
                     print(f"🔧 OpenAI suggested fix command: {fix_command}")
                     
@@ -2487,7 +2407,7 @@ ssh_app = modal.App("ssh-container-app")
             "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",
@@ -2553,17 +2473,116 @@ 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}")
+                    
+                    fix_command = call_openai_for_debug(cmd, error_output, 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!")
@@ -2798,7 +2817,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",
@@ -2874,17 +2893,108 @@ 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=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}")
+                        
+                        fix_command = call_openai_for_debug(cmd, error_output, 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:
@@ -3573,7 +3683,7 @@ def create_ssh_container_function(gpu_type="a10g", timeout_minutes=60, volume=No
             "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",