gitarsenal-cli 1.4.9 → 1.4.11

package/bin/gitarsenal.js

@@ -225,24 +225,7 @@ async function runContainerCommand(options) {
       }
     }
 
-    // Show configuration summary
-    console.log(chalk.bold('\n📋 Container Configuration:'));
-    console.log(chalk.cyan('Repository URL: ') + repoUrl);
-    console.log(chalk.cyan('GPU Type: ') + gpuType);
-    console.log(chalk.cyan('Volume: ') + (volumeName || 'None'));
-    
-    if (useApi) {
-      console.log(chalk.cyan('Setup Commands: ') + 'Auto-detect from repository');
-    } else if (setupCommands.length > 0) {
-      console.log(chalk.cyan('Setup Commands:'));
-      setupCommands.forEach((cmd, i) => {
-        console.log(`  ${i + 1}. ${cmd}`);
-      });
-    } else {
-      console.log(chalk.cyan('Setup Commands: ') + 'None');
-    }
-
-    // Confirm settings
+    // Confirm settings (configuration will be shown by Python script after GPU selection)
     if (!skipConfirmation) {
       const confirmAnswers = await inquirer.prompt([
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.4.9",
+  "version": "1.4.11",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

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_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

@@ -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")
@@ -1848,8 +1911,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 +2559,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")  # Install required packages for LLM debugging
         .run_commands(
             # Create SSH directory
             "mkdir -p /var/run/sshd",
@@ -2553,17 +2625,172 @@ 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}")
+                
+                # Check for common errors that we can fix automatically
+                common_errors = [
+                    # Source command not found
+                    {
+                        "pattern": "source: not found",
+                        "fix": lambda cmd: cmd.replace("source ", ". ")
+                    },
+                    # Conda not found
+                    {
+                        "pattern": "conda: not found",
+                        "fix": lambda cmd: "apt-get update && 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 && export PATH=/opt/conda/bin:$PATH && echo 'export PATH=/opt/conda/bin:$PATH' >> ~/.bashrc && source ~/.bashrc && " + cmd
+                    },
+                    # File not found for chmod
+                    {
+                        "pattern": "chmod: cannot access",
+                        "fix": lambda cmd: "pwd && ls -la && echo 'File not found, checking current directory and contents'"
+                    },
+                    # No such file or directory
+                    {
+                        "pattern": "No such file or directory",
+                        "fix": lambda cmd: "pwd && ls -la && echo 'Checking current directory and contents'"
+                    },
+                    # Directory navigation issues
+                    {
+                        "pattern": "cd: no such file or directory",
+                        "fix": lambda cmd: "pwd && ls -la && echo 'Directory not found, checking current location'"
+                    },
+                    # File not found for execution
+                    {
+                        "pattern": "not found",
+                        "fix": lambda cmd: "pwd && ls -la && echo 'File not found, checking current location'"
+                    }
+                ]
+                
+                # Check if any of the common errors match and apply automatic fix
+                for error_info in common_errors:
+                    if error_info["pattern"] in error_output:
+                        print(f"🔍 Detected common error: {error_info['pattern']}")
+                        fix_func = error_info["fix"]
+                        fixed_cmd = fix_func(cmd)
+                        print(f"🔧 Applying automatic fix: {fixed_cmd}")
+                        
+                        # Run the fixed command
+                        try:
+                            fix_result = subprocess.run(fixed_cmd, shell=True, check=True, 
+                                                      capture_output=True, text=True)
+                            if fix_result.stdout:
+                                print(f"✅ Automatic fix 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"❌ Automatic fix failed: {fix_e}")
+                            # Continue with LLM debugging
+                
+                # 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 +3025,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")  # Fast Python package installer, Modal, and requests for API calls
             .run_commands(
                 # Create SSH directory
                 "mkdir -p /var/run/sshd",
@@ -2831,7 +3058,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     if volume:
         volumes_config[volume_mount_path] = volume
         
-    # Define the SSH container function
+    # Define the SSH container function with all necessary imports
     @app.function(
         image=ssh_image,
         timeout=timeout_minutes * 60,  # Convert to seconds
@@ -2840,6 +3067,8 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         memory=8192,
         serialized=True,
         volumes=volumes_config if volumes_config else None,
+        # Include all required modules in container
+        mounts=[modal.Mount.from_local_python_packages("requests", "openai")]
     )
     def ssh_container_function():
         """Start SSH container with password authentication and optional setup."""
@@ -2874,17 +3103,164 @@ 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}")
+                    
+                    # Check for common errors that we can fix automatically
+                    common_errors = [
+                        # Source command not found
+                        {
+                            "pattern": "source: not found",
+                            "fix": lambda cmd: cmd.replace("source ", ". ")
+                        },
+                        # Conda not found
+                        {
+                            "pattern": "conda: not found",
+                            "fix": lambda cmd: "apt-get update && 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 && export PATH=/opt/conda/bin:$PATH && echo 'export PATH=/opt/conda/bin:$PATH' >> ~/.bashrc && source ~/.bashrc && " + cmd
+                        },
+                        # File not found for chmod
+                        {
+                            "pattern": "chmod: cannot access",
+                            "fix": lambda cmd: "pwd && ls -la && echo 'File not found, checking current directory and contents'"
+                        },
+                        # No such file or directory
+                        {
+                            "pattern": "No such file or directory",
+                            "fix": lambda cmd: "pwd && ls -la && echo 'Checking current directory and contents'"
+                        },
+                        # Directory navigation issues
+                        {
+                            "pattern": "cd: no such file or directory",
+                            "fix": lambda cmd: "pwd && ls -la && echo 'Directory not found, checking current location'"
+                        },
+                        # File not found for execution
+                        {
+                            "pattern": "not found",
+                            "fix": lambda cmd: "pwd && ls -la && echo 'File not found, checking current location'"
+                        }
+                    ]
+                    
+                    # Check if any of the common errors match and apply automatic fix
+                    for error_info in common_errors:
+                        if error_info["pattern"] in error_output:
+                            print(f"🔍 Detected common error: {error_info['pattern']}")
+                            fix_func = error_info["fix"]
+                            fixed_cmd = fix_func(cmd)
+                            print(f"🔧 Applying automatic fix: {fixed_cmd}")
+                            
+                            # Run the fixed command
+                            try:
+                                fix_result = subprocess.run(fixed_cmd, shell=True, check=True, 
+                                                          capture_output=True, text=True)
+                                if fix_result.stdout:
+                                    print(f"✅ Automatic fix 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"❌ Automatic fix failed: {fix_e}")
+                                # Continue with LLM debugging
+                    
+                    # 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 +3949,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")  # Install required packages for LLM debugging
         .run_commands(
             # Create SSH directory
             "mkdir -p /var/run/sshd",
@@ -3611,6 +3987,8 @@ def create_ssh_container_function(gpu_type="a10g", timeout_minutes=60, volume=No
         memory=8192,
         serialized=True,
         volumes=volumes if volumes else None,
+        # Include all required modules in container
+        mounts=[modal.Mount.from_local_python_packages("requests", "openai")]
     )
     def ssh_container(ssh_password, repo_url=None, repo_name=None, setup_commands=None):
         import subprocess
@@ -4147,7 +4525,7 @@ def prompt_for_gpu():
         """Display the GPU selection menu with current selection highlighted."""
         print("\n📊 Available GPU Options:")
         print("┌──────────────┬─────────┐")
-        print("│ GPU Type     │ Memory  │")
+        print("│   GPU Type   │  VRAM   │")
         print("├──────────────┼─────────┤")
         
         for i, gpu_type in enumerate(options):
@@ -4299,6 +4677,16 @@ if __name__ == "__main__":
     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