gitarsenal-cli 1.4.11 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.4.11",
+  "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_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/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
     
@@ -1742,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():
@@ -2559,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", "requests", "openai")  # Install required packages for LLM debugging
+        .pip_install("uv", "modal", "requests", "openai")  # Fast Python package installer and Modal
         .run_commands(
             # Create SSH directory
             "mkdir -p /var/run/sshd",
@@ -2663,62 +2511,6 @@ def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_co
                 print(f"❌ Command failed: {e}")
                 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:
@@ -3025,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", "requests")  # Fast Python package installer, Modal, and requests for API calls
+            .pip_install("uv", "modal", "requests", "openai")  # Fast Python package installer and Modal
             .run_commands(
                 # Create SSH directory
                 "mkdir -p /var/run/sshd",
@@ -3058,7 +2850,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 with all necessary imports
+    # Define the SSH container function
     @app.function(
         image=ssh_image,
         timeout=timeout_minutes * 60,  # Convert to seconds
@@ -3067,8 +2859,6 @@ 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."""
@@ -3132,62 +2922,6 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     print(f"❌ Command failed: {e}")
                     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:
@@ -3949,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", "requests", "openai")  # Install required packages for LLM debugging
+        .pip_install("uv", "modal", "requests", "openai")  # Fast Python package installer and Modal
         .run_commands(
             # Create SSH directory
             "mkdir -p /var/run/sshd",
@@ -3987,8 +3721,6 @@ 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