gitarsenal-cli 1.3.1 → 1.3.2

package/test_modalSandboxScript.py

@@ -1,6 +1,5 @@
 import os
 import sys
-import modal
 import time
 import subprocess
 import json
@@ -10,6 +9,126 @@ import getpass
 import requests
 import secrets
 import string
+import argparse
+from pathlib import Path
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser(description='Launch a Modal sandbox')
+parser.add_argument('--proxy-url', help='URL of the proxy server')
+parser.add_argument('--proxy-api-key', help='API key for the proxy server')
+parser.add_argument('--gpu', default='A10G', help='GPU type to use')
+parser.add_argument('--repo-url', help='Repository URL')
+parser.add_argument('--volume-name', help='Volume name')
+parser.add_argument('--use-api', action='store_true', help='Use API to fetch setup commands')
+
+# Parse only known args to avoid conflicts with other arguments
+args, unknown = parser.parse_known_args()
+
+# Set proxy URL and API key in environment variables if provided
+if args.proxy_url:
+    os.environ["MODAL_PROXY_URL"] = args.proxy_url
+    print(f"✅ Set MODAL_PROXY_URL from command line")
+    
+if args.proxy_api_key:
+    os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
+    print(f"✅ Set MODAL_PROXY_API_KEY from command line")
+
+# First, try to fetch tokens from the proxy server
+try:
+    # Import the fetch_modal_tokens module
+    print("🔄 Fetching Modal tokens from proxy server...")
+    from fetch_modal_tokens import get_tokens
+    token_id, token_secret = get_tokens()
+    print(f"✅ Modal tokens fetched successfully")
+    
+    # Explicitly set the environment variables again to be sure
+    os.environ["MODAL_TOKEN_ID"] = token_id
+    os.environ["MODAL_TOKEN_SECRET"] = token_secret
+    
+    # Also set the old environment variable for backward compatibility
+    os.environ["MODAL_TOKEN"] = token_id
+    
+    # Set token variables for later use
+    token = token_id  # For backward compatibility
+except Exception as e:
+    print(f"⚠️ Error fetching Modal tokens: {e}")
+    
+    # Apply the comprehensive Modal token solution as fallback
+    try:
+        # Import the comprehensive solution module
+        print("🔄 Applying comprehensive Modal token solution...")
+        import modal_token_solution
+        print("✅ Comprehensive Modal token solution applied")
+        
+        # Set token variables for later use
+        token = modal_token_solution.TOKEN_ID  # For backward compatibility
+    except Exception as e:
+        print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
+        
+        # Fall back to the authentication patch
+        try:
+            # Import the patch module
+            print("🔄 Falling back to Modal authentication patch...")
+            import modal_auth_patch
+            print("✅ Modal authentication patch applied")
+            
+            # Set token variables for later use
+            token = modal_auth_patch.TOKEN_ID  # For backward compatibility
+        except Exception as e:
+            print(f"⚠️ Error applying Modal authentication patch: {e}")
+            
+            # Fall back to fix_modal_token.py
+            try:
+                # Execute the fix_modal_token.py script
+                print("🔄 Falling back to fix_modal_token.py...")
+                result = subprocess.run(
+                    ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
+                    capture_output=True,
+                    text=True
+                )
+                
+                # Print the output but hide sensitive information
+                output_lines = result.stdout.split('\n')
+                for line in output_lines:
+                    if 'TOKEN_ID' in line or 'TOKEN_SECRET' in line or 'token_id' in line or 'token_secret' in line:
+                        # Hide the actual token values
+                        if '=' in line:
+                            parts = line.split('=', 1)
+                            if len(parts) == 2:
+                                print(f"{parts[0]}= [HIDDEN]")
+                        else:
+                            print(line.replace('ak-sLhYqCjkvixiYcb9LAuCHp', '[HIDDEN]').replace('as-fPzD0Zm0dl6IFAEkhaH9pq', '[HIDDEN]'))
+                    else:
+                        print(line)
+                
+                if result.returncode != 0:
+                    print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
+                    if result.stderr:
+                        print(f"Error: {result.stderr}")
+                
+                # Set token variables for later use
+                token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
+            except Exception as e:
+                print(f"⚠️ Error running fix_modal_token.py: {e}")
+                
+                # Last resort: use hardcoded tokens
+                token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
+
+# Print debug info
+print(f"🔍 DEBUG: Checking environment variables")
+print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
+print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
+print(f"🔍 MODAL_TOKEN exists: {'Yes' if os.environ.get('MODAL_TOKEN') else 'No'}")
+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('MODAL_TOKEN'):
+    print(f"🔍 MODAL_TOKEN length: {len(os.environ.get('MODAL_TOKEN'))}")
+print(f"✅ Modal token setup completed")
+
+# Import modal after token setup
+import modal
 
 def handle_interactive_input(prompt, is_password=False):
     """Handle interactive input from the user with optional password masking"""
@@ -56,13 +175,25 @@ def handle_wandb_login(sandbox, current_dir):
     print("Setting up Weights & Biases credentials")
     print("You can get your API key from: https://wandb.ai/authorize")
     
-    # Get API key from user
-    api_key = handle_interactive_input(
-        "🔑 WEIGHTS & BIASES API KEY REQUIRED\n" +
-        "Please paste your W&B API key below:\n" +
-        "(Your API key should be 40 characters long)",
-        is_password=True
-    )
+    # Try to use credentials manager first
+    api_key = None
+    try:
+        from credentials_manager import CredentialsManager
+        credentials_manager = CredentialsManager()
+        api_key = credentials_manager.get_wandb_api_key()
+    except ImportError:
+        # Fall back to direct input if credentials_manager is not available
+        pass
+    
+    # If credentials manager didn't provide a key, use direct input
+    if not api_key:
+        # Get API key from user
+        api_key = handle_interactive_input(
+            "🔑 WEIGHTS & BIASES API KEY REQUIRED\n" +
+            "Please paste your W&B API key below:\n" +
+            "(Your API key should be 40 characters long)",
+            is_password=True
+        )
     
     if not api_key:
         print("❌ No API key provided. Cannot continue with W&B login.")
@@ -226,26 +357,36 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
         api_key = os.environ.get("OPENAI_API_KEY")
         
     if not api_key:
-        print("\n" + "="*60)
-        print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
-        print("="*60)
-        print("To debug failed commands, an OpenAI API key is needed.")
-        print("📝 Please paste your OpenAI API key below:")
-        print("   (Your input will be hidden for security)")
-        print("-" * 60)
-        
+        # Use the CredentialsManager to get the API key
         try:
-            api_key = getpass.getpass("OpenAI API Key: ").strip()
+            from credentials_manager import CredentialsManager
+            credentials_manager = CredentialsManager()
+            api_key = credentials_manager.get_openai_api_key()
             if not api_key:
                 print("❌ No API key provided. Skipping debugging.")
                 return None
-            print("✅ API key received successfully!")
-        except KeyboardInterrupt:
-            print("\n❌ API key input cancelled by user.")
-            return None
-        except Exception as e:
-            print(f"❌ Error getting API key: {e}")
-            return None
+        except ImportError:
+            # Fall back to direct input if credentials_manager module is not available
+            print("\n" + "="*60)
+            print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
+            print("="*60)
+            print("To debug failed commands, an OpenAI API key is needed.")
+            print("📝 Please paste your OpenAI API key below:")
+            print("   (Your input will be hidden for security)")
+            print("-" * 60)
+            
+            try:
+                api_key = getpass.getpass("OpenAI API Key: ").strip()
+                if not api_key:
+                    print("❌ No API key provided. Skipping debugging.")
+                    return None
+                print("✅ API key received successfully!")
+            except KeyboardInterrupt:
+                print("\n❌ API key input cancelled by user.")
+                return None
+            except Exception as e:
+                print(f"❌ Error getting API key: {e}")
+                return None
     
     # Get current directory context
     directory_context = ""
@@ -410,6 +551,18 @@ Do not provide any explanations, just the exact command to run.
 
 def prompt_for_hf_token():
     """Prompt user for Hugging Face token when needed"""
+    # Try to use credentials manager first
+    try:
+        from credentials_manager import CredentialsManager
+        credentials_manager = CredentialsManager()
+        token = credentials_manager.get_huggingface_token()
+        if token:
+            return token
+    except ImportError:
+        # Fall back to direct input if credentials_manager is not available
+        pass
+    
+    # Traditional direct input method as fallback
     print("\n" + "="*60)
     print("🔑 HUGGING FACE TOKEN REQUIRED")
     print("="*60)
@@ -434,6 +587,87 @@ def prompt_for_hf_token():
         return None
 
 def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands=None, volume_name=None):
+    # Import the credentials manager if available
+    try:
+        from credentials_manager import CredentialsManager
+        credentials_manager = CredentialsManager()
+    except ImportError:
+        credentials_manager = None
+        print("⚠️ Credentials manager not found, will use environment variables or prompt for credentials")
+    
+    # Check if Modal is authenticated
+    try:
+        # Try to import modal first to check if it's installed
+        import modal
+        
+        # Try to access Modal token to check authentication
+        try:
+            # This will raise an exception if not authenticated
+            modal.config.get_current_workspace_name()
+            print("✅ Modal authentication verified")
+        except modal.exception.AuthError:
+            print("\n" + "="*80)
+            print("🔑 MODAL AUTHENTICATION REQUIRED")
+            print("="*80)
+            print("GitArsenal requires Modal authentication to create cloud environments.")
+            
+            # Try to get token from credentials manager
+            modal_token = None
+            if credentials_manager:
+                try:
+                    modal_token = credentials_manager.get_modal_token()
+                    if modal_token:
+                        # Set the token in the environment
+                        os.environ["MODAL_TOKEN_ID"] = modal_token
+                        print("✅ Modal token set from credentials manager")
+                        
+                        # Try to authenticate with the token
+                        try:
+                            import subprocess
+                            token_result = subprocess.run(
+                                ["modal", "token", "set", "--from-env"], 
+                                capture_output=True, text=True
+                            )
+                            if token_result.returncode == 0:
+                                print("✅ Successfully authenticated with Modal")
+                            else:
+                                print(f"⚠️ Failed to authenticate with Modal: {token_result.stderr}")
+                                print("\nPlease authenticate manually:")
+                                print("1. Run 'modal token new' to get a new token")
+                                print("2. Then restart this command")
+                                return None
+                        except Exception as e:
+                            print(f"⚠️ Error setting Modal token: {e}")
+                            return None
+                except Exception as e:
+                    print(f"⚠️ Error getting Modal token: {e}")
+            
+            if not modal_token:
+                print("\nTo authenticate with Modal, you need to:")
+                print("1. Create a Modal account at https://modal.com if you don't have one")
+                print("2. Run the following command to get a token:")
+                print("   modal token new")
+                print("3. Then set up your credentials in GitArsenal:")
+                print("   ./gitarsenal.py credentials set modal_token")
+                print("\nAfter completing these steps, try your command again.")
+                print("="*80)
+                return None
+    except ImportError:
+        print("\n" + "="*80)
+        print("❌ MODAL PACKAGE NOT INSTALLED")
+        print("="*80)
+        print("GitArsenal requires the Modal package to be installed.")
+        print("\nTo install Modal, run:")
+        print("   pip install modal")
+        print("\nAfter installation, authenticate with Modal:")
+        print("1. Run 'modal token new'")
+        print("2. Then run './gitarsenal.py credentials set modal_token'")
+        print("="*80)
+        return None
+    except Exception as e:
+        print(f"⚠️ Error checking Modal authentication: {e}")
+        print("Continuing anyway, but Modal operations may fail")
+    
     # Execution history for tracking all commands and their results in this session
     execution_history = []
     
@@ -453,11 +687,15 @@ def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands
     app_name = f"sandbox-{timestamp}"
     
     gpu_configs = {
+        'T4': {'gpu': 'T4', 'memory': 16},
+        'L4': {'gpu': 'L4', 'memory': 24},
         'A10G': {'gpu': 'A10G', 'memory': 24},
-        'A100': {'gpu': 'A100-SXM4-40GB', 'memory': 40},
+        'A100-40GB': {'gpu': 'A100-SXM4-40GB', 'memory': 40},
+        'A100-80GB': {'gpu': 'A100-80GB', 'memory': 80},
+        'L40S': {'gpu': 'L40S', 'memory': 48},
         'H100': {'gpu': 'H100', 'memory': 80},
-        'T4': {'gpu': 'T4', 'memory': 16},
-        'V100': {'gpu': 'V100-SXM2-16GB', 'memory': 16}
+        'H200': {'gpu': 'H200', 'memory': 141},
+        'B200': {'gpu': 'B200', 'memory': 96}
     }
     
     if gpu_type not in gpu_configs:
@@ -752,18 +990,52 @@ def create_modal_sandbox(gpu_type, repo_url=None, repo_name=None, setup_commands
                     not target_dir.startswith("/") and not target_dir.startswith("./") and 
                     not target_dir.startswith("../") and current_dir.endswith("/" + target_dir)):
                     
-                    # Additional check: verify if there's actually a nested directory with this name
-                    # This prevents skipping legitimate navigation to nested directories
+                    # Advanced check: analyze directory contents to determine if navigation makes sense
+                    print(f"🔍 Analyzing directory contents to determine navigation necessity...")
+                    
+                    # Get current directory contents
+                    current_contents_cmd = "ls -la"
+                    current_result = sandbox.exec("bash", "-c", current_contents_cmd)
+                    current_result.wait()
+                    current_contents = _to_str(current_result.stdout) if current_result.stdout else ""
+                    
+                    # Check if target directory exists
                     test_cmd = f"test -d \"{target_dir}\""
                     test_result = sandbox.exec("bash", "-c", test_cmd)
                     test_result.wait()
                     
                     if test_result.returncode == 0:
-                        # The nested directory exists, so this is NOT redundant
-                        print(f"🔍 Detected nested directory '{target_dir}' exists in current location")
-                        print(f"📂 Current: {current_dir}")
-                        print(f"🎯 Target: {target_dir}")
-                        print(f"🔄 Proceeding with navigation to nested directory...")
+                        # Target directory exists, get its contents
+                        target_contents_cmd = f"ls -la \"{target_dir}\""
+                        target_result = sandbox.exec("bash", "-c", target_contents_cmd)
+                        target_result.wait()
+                        target_contents = _to_str(target_result.stdout) if target_result.stdout else ""
+                        
+                        try:
+                            # Call LLM for analysis with the dedicated function
+                            llm_response = analyze_directory_navigation_with_llm(current_dir, target_dir, current_contents, target_contents, api_key)
+                            
+                            # Extract decision from LLM response
+                            if llm_response and "NAVIGATE" in llm_response.upper():
+                                print(f"🤖 LLM Analysis: Navigation makes sense - contents are different")
+                                print(f"📂 Current: {current_dir}")
+                                print(f"🎯 Target: {target_dir}")
+                                print(f"🔄 Proceeding with navigation...")
+                            else:
+                                print(f"🤖 LLM Analysis: Navigation is redundant - contents are similar")
+                                print(f"⚠️ Detected redundant directory navigation: {cmd}")
+                                print(f"📂 Already in the correct directory: {current_dir}")
+                                print(f"✅ Skipping unnecessary navigation command")
+                                return True, f"Already in directory {current_dir}", ""
+                                
+                        except Exception as e:
+                            print(f"⚠️ LLM analysis failed: {e}")
+                            print(f"🔄 Falling back to simple directory existence check...")
+                            # Fallback to simple check
+                            print(f"🔍 Detected nested directory '{target_dir}' exists in current location")
+                            print(f"📂 Current: {current_dir}")
+                            print(f"🎯 Target: {target_dir}")
+                            print(f"🔄 Proceeding with navigation to nested directory...")
                     else:
                         # No nested directory exists, so this is truly redundant
                         print(f"⚠️ Detected redundant directory navigation: {cmd}")
@@ -1857,22 +2129,234 @@ def generate_random_password(length=16):
     password = ''.join(secrets.choice(alphabet) for i in range(length))
     return password
 
+# First, add the standalone ssh_container function at the module level, before the create_modal_ssh_container function
+
+# Define a module-level ssh container function
+ssh_app = modal.App("ssh-container-app")
+
+@ssh_app.function(
+    image=modal.Image.debian_slim()
+        .apt_install(
+            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
+            "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
+            "gpg", "ca-certificates", "software-properties-common"
+        )
+        .pip_install("uv", "modal")  # Fast Python package installer and Modal
+        .run_commands(
+            # Create SSH directory
+            "mkdir -p /var/run/sshd",
+            "mkdir -p /root/.ssh",
+            "chmod 700 /root/.ssh",
+            
+            # Configure SSH server
+            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
+            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
+            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
+            
+            # SSH keep-alive settings
+            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+            
+            # Generate SSH host keys
+            "ssh-keygen -A",
+            
+            # Install Modal CLI
+            "pip install modal",
+            
+            # Set up a nice bash prompt
+            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+        ),
+    timeout=3600,  # Default 1 hour timeout
+    gpu="a10g",    # Default GPU - this will be overridden when called
+    cpu=2,
+    memory=8192,
+    serialized=True,
+)
+def ssh_container_function(ssh_password, repo_url=None, repo_name=None, setup_commands=None):
+    import subprocess
+    import time
+    import os
+    
+    # Set root password
+    subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
+    
+    # Start SSH service
+    subprocess.run(["service", "ssh", "start"], check=True)
+    
+    # Setup environment
+    os.environ['PS1'] = r'\[\e[1;32m\]modal:\[\e[1;34m\]\w\[\e[0m\]$ '
+    
+    # Clone repository if provided
+    if repo_url:
+        repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
+        print(f"📥 Cloning repository: {repo_url}")
+        
+        try:
+            subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
+            print(f"✅ Repository cloned successfully: {repo_name_from_url}")
+            
+            # Change to repository directory
+            repo_dir = f"/root/{repo_name_from_url}"
+            if os.path.exists(repo_dir):
+                os.chdir(repo_dir)
+                print(f"📂 Changed to repository directory: {repo_dir}")
+            
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Failed to clone repository: {e}")
+    
+    # Run setup commands if provided
+    if setup_commands:
+        print(f"⚙️ Running {len(setup_commands)} setup commands...")
+        for i, cmd in enumerate(setup_commands, 1):
+            print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
+            try:
+                result = subprocess.run(cmd, shell=True, check=True, 
+                                      capture_output=True, text=True)
+                if result.stdout:
+                    print(f"✅ Output: {result.stdout}")
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Command failed: {e}")
+                if e.stderr:
+                    print(f"❌ Error: {e.stderr}")
+    
+    # Get container info
+    print("🔍 Container started successfully!")
+    print(f"🆔 Container ID: {os.environ.get('MODAL_TASK_ID', 'unknown')}")
+    
+    # Keep the container running
+    while True:
+        time.sleep(30)
+        # Check if SSH service is still running
+        try:
+            subprocess.run(["service", "ssh", "status"], check=True, 
+                         capture_output=True)
+        except subprocess.CalledProcessError:
+            print("⚠️ SSH service stopped, restarting...")
+            subprocess.run(["service", "ssh", "start"], check=True)
 
+# Now modify the create_modal_ssh_container function to use the standalone ssh_container_function
 
 def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_commands=None, 
                                volume_name=None, timeout_minutes=60, ssh_password=None):
-    """Create a Modal SSH container with GPU support"""
+    """Create a Modal SSH container with GPU support and tunneling"""
+    
+    # Check if Modal is authenticated
+    try:
+        # Print all environment variables for debugging
+        print("🔍 DEBUG: Checking environment variables")
+        modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+        modal_token = os.environ.get("MODAL_TOKEN")
+        print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if modal_token_id else 'No'}")
+        print(f"🔍 MODAL_TOKEN exists: {'Yes' if modal_token else 'No'}")
+        if modal_token_id:
+            print(f"🔍 MODAL_TOKEN_ID length: {len(modal_token_id)}")
+        if modal_token:
+            print(f"🔍 MODAL_TOKEN length: {len(modal_token)}")
+        
+        # Try to access Modal token to check authentication
+        try:
+            # Check if token is set in environment
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            if not modal_token_id:
+                print("⚠️ MODAL_TOKEN_ID not found in environment.")
+                # Try to get from MODAL_TOKEN
+                modal_token = os.environ.get("MODAL_TOKEN")
+                if modal_token:
+                    print("✅ Found token in MODAL_TOKEN environment variable")
+                    os.environ["MODAL_TOKEN_ID"] = modal_token
+                    modal_token_id = modal_token
+                    print(f"✅ Set MODAL_TOKEN_ID from MODAL_TOKEN (length: {len(modal_token)})")
+            
+            if modal_token_id:
+                print(f"✅ Modal token found (length: {len(modal_token_id)})")
+                
+                # Use the comprehensive fix_modal_token script
+                try:
+                    # Execute the fix_modal_token.py script
+                    import subprocess
+                    print(f"🔄 Running fix_modal_token.py to set up Modal token...")
+                    result = subprocess.run(
+                        ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
+                        capture_output=True,
+                        text=True
+                    )
+                    
+                    # Print the output
+                    print(result.stdout)
+                    
+                    if result.returncode != 0:
+                        print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
+                        if result.stderr:
+                            print(f"Error: {result.stderr}")
+                            
+                    print(f"✅ Modal token setup completed")
+                except Exception as e:
+                    print(f"⚠️ Error running fix_modal_token.py: {e}")
+            else:
+                print("❌ No Modal token found in environment variables")
+                # Try to get from file as a last resort
+                try:
+                    home_dir = os.path.expanduser("~")
+                    modal_dir = os.path.join(home_dir, ".modal")
+                    token_file = os.path.join(modal_dir, "token.json")
+                    if os.path.exists(token_file):
+                        print(f"🔍 Found Modal token file at {token_file}")
+                        with open(token_file, 'r') as f:
+                            import json
+                            token_data = json.load(f)
+                            if "token_id" in token_data:
+                                modal_token_id = token_data["token_id"]
+                                os.environ["MODAL_TOKEN_ID"] = modal_token_id
+                                os.environ["MODAL_TOKEN"] = modal_token_id
+                                print(f"✅ Loaded token from file (length: {len(modal_token_id)})")
+                            else:
+                                print("❌ Token file does not contain token_id")
+                    else:
+                        print("❌ Modal token file not found")
+                except Exception as e:
+                    print(f"❌ Error loading token from file: {e}")
+                
+                if not os.environ.get("MODAL_TOKEN_ID"):
+                    print("❌ Could not find Modal token in any location")
+                    return None
+                
+        except Exception as e:
+            print(f"⚠️ Error checking Modal token: {e}")
+            # Try to use the token from environment
+            modal_token_id = os.environ.get("MODAL_TOKEN_ID")
+            modal_token = os.environ.get("MODAL_TOKEN")
+            if modal_token_id:
+                print(f"🔄 Using MODAL_TOKEN_ID from environment (length: {len(modal_token_id)})")
+            elif modal_token:
+                print(f"🔄 Using MODAL_TOKEN from environment (length: {len(modal_token)})")
+                os.environ["MODAL_TOKEN_ID"] = modal_token
+                modal_token_id = modal_token
+            else:
+                print("❌ No Modal token available. Cannot proceed.")
+                return None
+            
+            # Set it in both environment variables
+            os.environ["MODAL_TOKEN_ID"] = modal_token_id
+            os.environ["MODAL_TOKEN"] = modal_token_id
+            print("✅ Set both MODAL_TOKEN_ID and MODAL_TOKEN environment variables")
+    except Exception as e:
+        print(f"⚠️ Error checking Modal authentication: {e}")
+        print("Continuing anyway, but Modal operations may fail")
     
     # Generate a unique app name with timestamp to avoid conflicts
     timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
     app_name = f"ssh-container-{timestamp}"
     
     gpu_configs = {
+        'T4': {'gpu': 't4', 'memory': 16},
+        'L4': {'gpu': 'l4', 'memory': 24},
         'A10G': {'gpu': 'a10g', 'memory': 24},
-        'A100': {'gpu': 'a100', 'memory': 40},
+        'A100-40GB': {'gpu': 'a100', 'memory': 40},
+        'A100-80GB': {'gpu': 'a100-80gb', 'memory': 80},
+        'L40S': {'gpu': 'l40s', 'memory': 48},
         'H100': {'gpu': 'h100', 'memory': 80},
-        'T4': {'gpu': 't4', 'memory': 16},
-        'V100': {'gpu': 'v100', 'memory': 16}
+        'H200': {'gpu': 'h200', 'memory': 141},
+        'B200': {'gpu': 'b200', 'memory': 96}
     }
     
     if gpu_type not in gpu_configs:
@@ -1912,109 +2396,135 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             print(f"⚠️ Could not create default volume: {e}")
             print("⚠️ Continuing without persistent volume")
             volume = None
+    
+    # Print debug info for authentication
+    print("🔍 Modal authentication debug info:")
+    modal_token = os.environ.get("MODAL_TOKEN_ID")
+    print(f"  - MODAL_TOKEN_ID in env: {'Yes' if modal_token else 'No'}")
+    print(f"  - Token length: {len(modal_token) if modal_token else 'N/A'}")
+    
+    # Verify we can create a Modal app
+    try:
+        print("🔍 Testing Modal app creation...")
+        app = modal.App(app_name)
+        print("✅ Created Modal app successfully")
+    except Exception as e:
+        print(f"❌ Error creating Modal app: {e}")
+        return None
 
     # Create SSH-enabled image
-    ssh_image = (
-        modal.Image.debian_slim()
-        .apt_install(
-            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
-            "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
-            "gpg", "ca-certificates", "software-properties-common"
-        )
-        .pip_install("uv")  # Fast Python package installer
-        .run_commands(
-            # Create SSH directory
-            "mkdir -p /var/run/sshd",
-            "mkdir -p /root/.ssh",
-            "chmod 700 /root/.ssh",
-            
-            # Configure SSH server
-            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
-            
-            # SSH keep-alive settings
-            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
-            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
-            
-            # Generate SSH host keys
-            "ssh-keygen -A",
-            
-            # Set up a nice bash prompt
-            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+    try:
+        print("📦 Building SSH-enabled image...")
+        ssh_image = (
+            modal.Image.debian_slim()
+            .apt_install(
+                "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
+                "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
+                "gpg", "ca-certificates", "software-properties-common"
+            )
+            .pip_install("uv", "modal")  # Fast Python package installer and Modal
+            .run_commands(
+                # Create SSH directory
+                "mkdir -p /var/run/sshd",
+                "mkdir -p /root/.ssh",
+                "chmod 700 /root/.ssh",
+                
+                # Configure SSH server
+                "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
+                "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
+                "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
+                
+                # SSH keep-alive settings
+                "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+                "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+                
+                # Generate SSH host keys
+                "ssh-keygen -A",
+                
+                # Set up a nice bash prompt
+                "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+            )
         )
+        print("✅ SSH image built successfully")
+    except Exception as e:
+        print(f"❌ Error building SSH image: {e}")
+        return None
+        
+    # Configure volumes if available
+    volumes_config = {}
+    if volume:
+        volumes_config[volume_mount_path] = volume
+        
+    # Define the SSH container function
+    @app.function(
+        image=ssh_image,
+        timeout=timeout_minutes * 60,  # Convert to seconds
+        gpu=gpu_spec['gpu'],
+        cpu=2,
+        memory=8192,
+        serialized=True,
+        volumes=volumes_config if volumes_config else None,
     )
-
-    # Create Modal app
-    with modal.enable_output():
-        print(f"🚀 Creating Modal app: {app_name}")
-        app = modal.App.lookup(app_name, create_if_missing=True)
+    def ssh_container_function():
+        """Start SSH container with password authentication and optional setup."""
+        import subprocess
+        import time
+        import os
         
-        # Setup volume mount if available
-        volumes = {}
-        if volume:
-            volumes[volume_mount_path] = volume
-            print(f"📦 Mounting volume '{volume_name}' at {volume_mount_path}")
+        # Set root password
+        subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
         
-        @app.function(
-            image=ssh_image,
-            timeout=timeout_minutes * 60,  # Convert to seconds
-            gpu=gpu_spec['gpu'],
-            cpu=2,
-            memory=8192,
-            serialized=True,
-            volumes=volumes if volumes else None,
-        )
-        def ssh_container():
-            import subprocess
-            import time
-            import os
-            
-            # Set root password
-            subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
-            
-            # Start SSH service
-            subprocess.run(["service", "ssh", "start"], check=True)
-            
-            # Setup environment
-            os.environ['PS1'] = r'\[\e[1;32m\]modal:\[\e[1;34m\]\w\[\e[0m\]$ '
+        # Start SSH service
+        subprocess.run(["service", "ssh", "start"], check=True)
+        
+        # Clone repository if provided
+        if repo_url:
+            repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
+            print(f"📥 Cloning repository: {repo_url}")
             
-            # Clone repository if provided
-            if repo_url:
-                repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
-                print(f"📥 Cloning repository: {repo_url}")
+            try:
+                subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
+                print(f"✅ Repository cloned successfully: {repo_name_from_url}")
                 
+                # Change to repository directory
+                repo_dir = f"/root/{repo_name_from_url}"
+                if os.path.exists(repo_dir):
+                    os.chdir(repo_dir)
+                    print(f"📂 Changed to repository directory: {repo_dir}")
+                
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Failed to clone repository: {e}")
+        
+        # Run setup commands if provided
+        if setup_commands:
+            print(f"⚙️ Running {len(setup_commands)} setup commands...")
+            for i, cmd in enumerate(setup_commands, 1):
+                print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
                 try:
-                    subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
-                    print(f"✅ Repository cloned successfully: {repo_name_from_url}")
-                    
-                    # Change to repository directory
-                    repo_dir = f"/root/{repo_name_from_url}"
-                    if os.path.exists(repo_dir):
-                        os.chdir(repo_dir)
-                        print(f"📂 Changed to repository directory: {repo_dir}")
-                    
+                    result = subprocess.run(cmd, shell=True, check=True, 
+                                          capture_output=True, text=True)
+                    if result.stdout:
+                        print(f"✅ Output: {result.stdout}")
                 except subprocess.CalledProcessError as e:
-                    print(f"❌ Failed to clone repository: {e}")
-            
-            # Run setup commands if provided
-            if setup_commands:
-                print(f"⚙️ Running {len(setup_commands)} setup commands...")
-                for i, cmd in enumerate(setup_commands, 1):
-                    print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
-                    try:
-                        result = subprocess.run(cmd, shell=True, check=True, 
-                                              capture_output=True, text=True)
-                        if result.stdout:
-                            print(f"✅ Output: {result.stdout}")
-                    except subprocess.CalledProcessError as e:
-                        print(f"❌ Command failed: {e}")
-                        if e.stderr:
-                            print(f"❌ Error: {e.stderr}")
-            
-            # Get container info
-            print("🔍 Container started successfully!")
-            print(f"🆔 Container ID: {os.environ.get('MODAL_TASK_ID', 'unknown')}")
+                    print(f"❌ Command failed: {e}")
+                    if e.stderr:
+                        print(f"❌ Error: {e.stderr}")
+        
+        # Create SSH tunnel
+        with modal.forward(22, unencrypted=True) as tunnel:
+            host, port = tunnel.tcp_socket
+            
+            print("\n" + "=" * 80)
+            print("🎉 SSH CONTAINER IS READY!")
+            print("=" * 80)
+            print(f"🌐 SSH Host: {host}")
+            print(f"🔌 SSH Port: {port}")
+            print(f"👤 Username: root")
+            print(f"🔐 Password: {ssh_password}")
+            print()
+            print("🔗 CONNECT USING THIS COMMAND:")
+            print(f"ssh -p {port} root@{host}")
+            print("=" * 80)
             
             # Keep the container running
             while True:
@@ -2026,123 +2536,27 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 except subprocess.CalledProcessError:
                     print("⚠️ SSH service stopped, restarting...")
                     subprocess.run(["service", "ssh", "start"], check=True)
+    
+    # Run the container
+    try:
+        print("⏳ Starting container... This may take 1-2 minutes...")
         
-        # Start the container
-        print("🚀 Starting SSH container...")
-        
-        # Use spawn to run the container in the background
-        container_handle = ssh_container.spawn()
-        
-        # Wait a moment for the container to start
-        print("⏳ Waiting for container to initialize...")
-        time.sleep(10)
-        
-        # Get container information
-        try:
-            # Try to get the container ID from Modal
-            container_id = None
-            
-            # Get container list to find our container
-            print("🔍 Looking for container information...")
-            result = subprocess.run(["modal", "container", "list", "--json"], 
-                                  capture_output=True, text=True)
-            
-            if result.returncode == 0:
-                try:
-                    containers = json.loads(result.stdout)
-                    if containers and isinstance(containers, list):
-                        # Find the most recent container
-                        for container in containers:
-                            if container.get("App") == app_name:
-                                container_id = container.get("Container ID")
-                                break
-                        
-                        if not container_id and containers:
-                            # Fall back to the first container
-                            container_id = containers[0].get("Container ID")
-                            
-                except json.JSONDecodeError:
-                    pass
-            
-            if not container_id:
-                # Try text parsing
-                result = subprocess.run(["modal", "container", "list"], 
-                                      capture_output=True, text=True)
-                if result.returncode == 0:
-                    lines = result.stdout.split('\n')
-                    for line in lines:
-                        if app_name in line or ('ta-' in line and '│' in line):
-                            parts = line.split('│')
-                            if len(parts) >= 2:
-                                possible_id = parts[1].strip()
-                                if possible_id.startswith('ta-'):
-                                    container_id = possible_id
-                                    break
-            
-            if container_id:
-                print(f"📋 Container ID: {container_id}")
-                
-                # Get the external IP for SSH access
-                print("🔍 Getting container connection info...")
+        # Start the container in a new thread to avoid blocking
+        with modal.enable_output():
+            with app.run():
+                ssh_container_function.remote()
                 
-                # Try to get SSH connection details
-                try:
-                    # Modal containers typically expose SSH on port 22
-                    ssh_info = f"ssh root@{container_id}.modal.run"
-                    
-                    print("\n" + "="*80)
-                    print("🚀 SSH CONTAINER READY!")
-                    print("="*80)
-                    print(f"🆔 Container ID: {container_id}")
-                    print(f"🔐 SSH Password: {ssh_password}")
-                    print(f"📱 App Name: {app_name}")
-                    if volume:
-                        print(f"💾 Volume: {volume_name} (mounted at {volume_mount_path})")
-                    print("\n🔗 SSH Connection:")
-                    print(f"   {ssh_info}")
-                    print(f"   Password: {ssh_password}")
-                    print("\n💡 Alternative connection methods:")
-                    print(f"   modal container exec --pty {container_id} bash")
-                    print(f"   modal shell {container_id}")
-                    print("="*80)
-                    
-                    # Try to open SSH connection in a new terminal
-                    try:
-                        terminal_script = f'''
-                        tell application "Terminal"
-                            do script "echo 'Connecting to Modal SSH container...'; echo 'Password: {ssh_password}'; {ssh_info}"
-                            activate
-                        end tell
-                        '''
-                        
-                        subprocess.run(['osascript', '-e', terminal_script], 
-                                      capture_output=True, text=True, timeout=30)
-                        print("✅ New terminal window opened with SSH connection")
-                        
-                    except Exception as e:
-                        print(f"⚠️ Could not open terminal window: {e}")
-                        print("📝 You can manually connect using the SSH command above")
-                    
-                except Exception as e:
-                    print(f"⚠️ Error getting SSH connection info: {e}")
-                    print("📝 You can connect using:")
-                    print(f"   modal container exec --pty {container_id} bash")
-            else:
-                print("⚠️ Could not determine container ID")
-                print("📝 Check running containers with: modal container list")
-        
-        except Exception as e:
-            print(f"❌ Error getting container information: {e}")
+        # Clean up Modal token after container is successfully created
+        cleanup_modal_token()
         
-        # Return container information
         return {
-            "container_handle": container_handle,
-            "container_id": container_id,
             "app_name": app_name,
             "ssh_password": ssh_password,
-            "volume_name": volume_name,
-            "volume_mount_path": volume_mount_path if volume else None
+            "volume_name": volume_name
         }
+    except Exception as e:
+        print(f"❌ Error running container: {e}")
+        return None
 
 def fetch_setup_commands_from_api(repo_url):
     """Fetch setup commands from the GitIngest API using real repository analysis."""
@@ -2152,7 +2566,7 @@ def fetch_setup_commands_from_api(repo_url):
     import shutil
     import json
     
-    api_url = "http://localhost:3000/api/analyze-with-gitingest"
+    api_url = "https://git-arsenal.vercel.app/api/analyze-with-gitingest"
     
     print(f"🔍 Fetching setup commands from API for repository: {repo_url}")
     
@@ -2248,53 +2662,201 @@ def fetch_setup_commands_from_api(repo_url):
         
         # Make the API request
         print(f"🌐 Making POST request to: {api_url}")
-        response = requests.post(api_url, json=payload, timeout=60)
-        
-        print(f"📥 API Response status code: {response.status_code}")
-        
-        if response.status_code == 200:
-            try:
-                data = response.json()
-                print(f"📄 API Response data received")
-                
-                # Extract setup commands from the response
-                if "setupInstructions" in data and "commands" in data["setupInstructions"]:
-                    commands = data["setupInstructions"]["commands"]
-                    print(f"✅ Successfully fetched {len(commands)} setup commands from API")
-                    
-                    # Print the commands for reference
-                    for i, cmd in enumerate(commands, 1):
-                        print(f"  {i}. {cmd}")
+        try:
+            response = requests.post(api_url, json=payload, timeout=60)
+            
+            print(f"📥 API Response status code: {response.status_code}")
+            
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+                    print(f"📄 API Response data received")
                     
-                    return commands
-                else:
-                    print("⚠️ API response did not contain setupInstructions.commands field")
-                    print("📋 Available fields in response:")
-                    for key in data.keys():
-                        print(f"  - {key}")
-                    return []
-            except json.JSONDecodeError as e:
-                print(f"❌ Failed to parse API response as JSON: {e}")
-                print(f"Raw response: {response.text[:500]}...")
-                return []
-        else:
-            print(f"❌ API request failed with status code: {response.status_code}")
-            print(f"Error response: {response.text[:500]}...")
-            return []
-    except requests.exceptions.ConnectionError:
-        print(f"❌ Connection error: Could not connect to {api_url}")
-        print("⚠️ Make sure the API server is running at localhost:3000")
-        return []
+                    # Extract setup commands from the response
+                    if "setupInstructions" in data and "commands" in data["setupInstructions"]:
+                        commands = data["setupInstructions"]["commands"]
+                        print(f"✅ Successfully fetched {len(commands)} setup commands from API")
+                        
+                        # Print the original commands for reference
+                        print("📋 Original commands from API:")
+                        for i, cmd in enumerate(commands, 1):
+                            print(f"  {i}. {cmd}")
+                        
+                        # Fix the commands by removing placeholders and comments
+                        fixed_commands = fix_setup_commands(commands)
+                        
+                        # If we have a temp_dir with the cloned repo, try to find the entry point
+                        # and replace any placeholder entry points
+                        for i, cmd in enumerate(fixed_commands):
+                            if "python main.py" in cmd or "python3 main.py" in cmd:
+                                try:
+                                    entry_point = find_entry_point(temp_dir)
+                                    if entry_point and entry_point != "main.py":
+                                        fixed_commands[i] = cmd.replace("main.py", entry_point)
+                                        print(f"🔄 Replaced main.py with detected entry point: {entry_point}")
+                                except Exception as e:
+                                    print(f"⚠️ Error finding entry point: {e}")
+                        
+                        # Print the fixed commands
+                        print("\n📋 Fixed commands:")
+                        for i, cmd in enumerate(fixed_commands, 1):
+                            print(f"  {i}. {cmd}")
+                        
+                        return fixed_commands
+                    else:
+                        print("⚠️ API response did not contain setupInstructions.commands field")
+                        print("📋 Available fields in response:")
+                        for key in data.keys():
+                            print(f"  - {key}")
+                        # Return fallback commands
+                        return generate_fallback_commands(gitingest_data)
+                except json.JSONDecodeError as e:
+                    print(f"❌ Failed to parse API response as JSON: {e}")
+                    print(f"Raw response: {response.text[:500]}...")
+                    # Return fallback commands
+                    return generate_fallback_commands(gitingest_data)
+            elif response.status_code == 504:
+                print(f"❌ API request timed out (504 Gateway Timeout)")
+                print("⚠️ The server took too long to respond. Using fallback commands instead.")
+                # Return fallback commands
+                return generate_fallback_commands(gitingest_data)
+            else:
+                print(f"❌ API request failed with status code: {response.status_code}")
+                print(f"Error response: {response.text[:500]}...")
+                # Return fallback commands
+                return generate_fallback_commands(gitingest_data)
+        except requests.exceptions.Timeout:
+            print("❌ API request timed out after 60 seconds")
+            print("⚠️ Using fallback commands instead")
+            # Return fallback commands
+            return generate_fallback_commands(gitingest_data)
+        except requests.exceptions.ConnectionError:
+            print(f"❌ Connection error: Could not connect to {api_url}")
+            print("⚠️ Using fallback commands instead")
+            # Return fallback commands
+            return generate_fallback_commands(gitingest_data)
     except Exception as e:
         print(f"❌ Error fetching setup commands from API: {e}")
         import traceback
         traceback.print_exc()
-        return []
+        # Return fallback commands
+        return generate_fallback_commands(None)
     finally:
         # Clean up the temporary directory
         print(f"🧹 Cleaning up temporary directory...")
         shutil.rmtree(temp_dir, ignore_errors=True)
 
+def generate_fallback_commands(gitingest_data):
+    """Generate fallback setup commands based on repository analysis"""
+    print("\n" + "="*80)
+    print("📋 GENERATING FALLBACK SETUP COMMANDS")
+    print("="*80)
+    print("Using basic repository analysis to generate setup commands")
+    
+    # Default commands that work for most repositories
+    default_commands = [
+        "apt-get update -y",
+        "apt-get install -y git curl wget",
+        "pip install --upgrade pip setuptools wheel"
+    ]
+    
+    # If we don't have any analysis data, return default commands
+    if not gitingest_data:
+        print("⚠️ No repository analysis data available. Using default commands.")
+        return default_commands
+    
+    # Extract language and technologies information
+    detected_language = gitingest_data.get("system_info", {}).get("detected_language", "Unknown")
+    detected_technologies = gitingest_data.get("system_info", {}).get("detected_technologies", [])
+    primary_package_manager = gitingest_data.get("system_info", {}).get("primary_package_manager", "Unknown")
+    
+    # Add language-specific commands
+    language_commands = []
+    
+    print(f"📋 Detected primary language: {detected_language}")
+    print(f"📋 Detected technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
+    print(f"📋 Detected package manager: {primary_package_manager}")
+    
+    # Python-specific commands
+    if detected_language == "Python" or primary_package_manager == "pip":
+        print("📦 Adding Python-specific setup commands")
+        
+        # Check for requirements.txt
+        requirements_check = [
+            "if [ -f requirements.txt ]; then",
+            "  echo 'Installing from requirements.txt'",
+            "  pip install -r requirements.txt",
+            "elif [ -f setup.py ]; then",
+            "  echo 'Installing from setup.py'",
+            "  pip install -e .",
+            "fi"
+        ]
+        language_commands.extend(requirements_check)
+        
+        # Add common Python packages
+        language_commands.append("pip install pytest numpy pandas matplotlib")
+    
+    # JavaScript/Node.js specific commands
+    elif detected_language in ["JavaScript", "TypeScript"] or primary_package_manager in ["npm", "yarn", "pnpm"]:
+        print("📦 Adding JavaScript/Node.js-specific setup commands")
+        
+        # Install Node.js if not available
+        language_commands.append("apt-get install -y nodejs npm")
+        
+        # Check for package.json
+        package_json_check = [
+            "if [ -f package.json ]; then",
+            "  echo 'Installing from package.json'",
+            "  npm install",
+            "fi"
+        ]
+        language_commands.extend(package_json_check)
+    
+    # Java specific commands
+    elif detected_language == "Java" or primary_package_manager in ["maven", "gradle"]:
+        print("📦 Adding Java-specific setup commands")
+        
+        language_commands.append("apt-get install -y openjdk-11-jdk maven gradle")
+        
+        # Check for Maven or Gradle
+        build_check = [
+            "if [ -f pom.xml ]; then",
+            "  echo 'Building with Maven'",
+            "  mvn clean install -DskipTests",
+            "elif [ -f build.gradle ]; then",
+            "  echo 'Building with Gradle'",
+            "  gradle build --no-daemon",
+            "fi"
+        ]
+        language_commands.extend(build_check)
+    
+    # Go specific commands
+    elif detected_language == "Go" or primary_package_manager == "go":
+        print("📦 Adding Go-specific setup commands")
+        
+        language_commands.append("apt-get install -y golang-go")
+        language_commands.append("go mod tidy")
+    
+    # Rust specific commands
+    elif detected_language == "Rust" or primary_package_manager == "cargo":
+        print("📦 Adding Rust-specific setup commands")
+        
+        language_commands.append("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y")
+        language_commands.append("source $HOME/.cargo/env")
+        language_commands.append("cargo build")
+    
+    # Combine all commands
+    all_commands = default_commands + language_commands
+    
+    # Fix the commands
+    fixed_commands = fix_setup_commands(all_commands)
+    
+    print("\n📋 Generated fallback setup commands:")
+    for i, cmd in enumerate(fixed_commands, 1):
+        print(f"  {i}. {cmd}")
+    
+    return fixed_commands
+
 def generate_basic_repo_analysis_from_url(repo_url):
     """Generate basic repository analysis data from a repository URL."""
     import tempfile
@@ -2481,17 +3043,327 @@ def get_setup_commands_from_local_api(repo_url, gitingest_data):
             if "setupInstructions" in data and "commands" in data["setupInstructions"]:
                 commands = data["setupInstructions"]["commands"]
                 print(f"✅ Successfully fetched {len(commands)} setup commands from local API")
+                
+                # Print the original commands
+                print("📋 Original commands from local API:")
                 for i, cmd in enumerate(commands, 1):
                     print(f"  {i}. {cmd}")
-                return commands
+                
+                # Fix the commands
+                fixed_commands = fix_setup_commands(commands)
+                
+                # Print the fixed commands
+                print("\n📋 Fixed commands:")
+                for i, cmd in enumerate(fixed_commands, 1):
+                    print(f"  {i}. {cmd}")
+                
+                return fixed_commands
     except Exception as e:
         print(f"❌ Error connecting to local API: {e}")
     
     return None
 
+# Define a function to create and return a properly configured ssh container function
+def create_ssh_container_function(gpu_type="a10g", timeout_minutes=60, volume=None, volume_mount_path="/persistent"):
+    # Create a new app for this specific container
+    app_name = f"ssh-container-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+    ssh_app = modal.App.lookup(app_name, create_if_missing=True)
+    
+    # Create SSH-enabled image
+    ssh_image = (
+        modal.Image.debian_slim()
+        .apt_install(
+            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
+            "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
+            "gpg", "ca-certificates", "software-properties-common"
+        )
+        .pip_install("uv", "modal")  # Fast Python package installer and Modal
+        .run_commands(
+            # Create SSH directory
+            "mkdir -p /var/run/sshd",
+            "mkdir -p /root/.ssh",
+            "chmod 700 /root/.ssh",
+            
+            # Configure SSH server
+            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
+            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
+            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
+            
+            # SSH keep-alive settings
+            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+            
+            # Generate SSH host keys
+            "ssh-keygen -A",
+            
+            # Set up a nice bash prompt
+            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+        )
+    )
+    
+    # Setup volume mount if available
+    volumes = {}
+    if volume:
+        volumes[volume_mount_path] = volume
+    
+    # Define the function with the specific configuration
+    @ssh_app.function(
+        image=ssh_image,
+        timeout=timeout_minutes * 60,  # Convert to seconds
+        gpu=gpu_type,
+        cpu=2,
+        memory=8192,
+        serialized=True,
+        volumes=volumes if volumes else None,
+    )
+    def ssh_container(ssh_password, repo_url=None, repo_name=None, setup_commands=None):
+        import subprocess
+        import time
+        import os
+        
+        # Set root password
+        subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
+        
+        # Start SSH service
+        subprocess.run(["service", "ssh", "start"], check=True)
+        
+        # Setup environment
+        os.environ['PS1'] = r'\[\e[1;32m\]modal:\[\e[1;34m\]\w\[\e[0m\]$ '
+        
+        # Clone repository if provided
+        if repo_url:
+            repo_name_from_url = repo_name or repo_url.split('/')[-1].replace('.git', '')
+            print(f"📥 Cloning repository: {repo_url}")
+            
+            try:
+                subprocess.run(["git", "clone", repo_url], check=True, cwd="/root")
+                print(f"✅ Repository cloned successfully: {repo_name_from_url}")
+                
+                # Change to repository directory
+                repo_dir = f"/root/{repo_name_from_url}"
+                if os.path.exists(repo_dir):
+                    os.chdir(repo_dir)
+                    print(f"📂 Changed to repository directory: {repo_dir}")
+                
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Failed to clone repository: {e}")
+        
+        # Run setup commands if provided
+        if setup_commands:
+            print(f"⚙️ Running {len(setup_commands)} setup commands...")
+            for i, cmd in enumerate(setup_commands, 1):
+                print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
+                try:
+                    result = subprocess.run(cmd, shell=True, check=True, 
+                                          capture_output=True, text=True)
+                    if result.stdout:
+                        print(f"✅ Output: {result.stdout}")
+                except subprocess.CalledProcessError as e:
+                    print(f"❌ Command failed: {e}")
+                    if e.stderr:
+                        print(f"❌ Error: {e.stderr}")
+        
+        # Get container info
+        print("🔍 Container started successfully!")
+        print(f"🆔 Container ID: {os.environ.get('MODAL_TASK_ID', 'unknown')}")
+        
+        # Keep the container running
+        while True:
+            time.sleep(30)
+            # Check if SSH service is still running
+            try:
+                subprocess.run(["service", "ssh", "status"], check=True, 
+                             capture_output=True)
+            except subprocess.CalledProcessError:
+                print("⚠️ SSH service stopped, restarting...")
+                subprocess.run(["service", "ssh", "start"], check=True)
+    
+    # Return the configured function
+    return ssh_container, app_name
+
+def fix_setup_commands(commands):
+    """Fix setup commands by removing placeholders and comments."""
+    fixed_commands = []
+    
+    for cmd in commands:
+        # Remove placeholders like "(or the appropriate entry point...)"
+        cmd = re.sub(r'\([^)]*\)', '', cmd).strip()
+        
+        # Skip empty commands or pure comments
+        if not cmd or cmd.startswith('#'):
+            continue
+            
+        # Remove trailing comments
+        cmd = re.sub(r'#.*$', '', cmd).strip()
+        
+        if cmd:
+            fixed_commands.append(cmd)
+    
+    return fixed_commands
+
+def find_entry_point(repo_dir):
+    """Find the entry point script for a repository."""
+    # Common entry point files to check
+    common_entry_points = [
+        "main.py", "app.py", "run.py", "train.py", "start.py", 
+        "server.py", "cli.py", "demo.py", "example.py"
+    ]
+    
+    # Check if any of the common entry points exist
+    for entry_point in common_entry_points:
+        if os.path.exists(os.path.join(repo_dir, entry_point)):
+            return entry_point
+    
+    # Look for Python files in the root directory
+    python_files = [f for f in os.listdir(repo_dir) if f.endswith('.py')]
+    if python_files:
+        # Prioritize files with main function or if_name_main pattern
+        for py_file in python_files:
+            file_path = os.path.join(repo_dir, py_file)
+            try:
+                with open(file_path, 'r') as f:
+                    content = f.read()
+                    if "def main" in content or "if __name__ == '__main__'" in content or 'if __name__ == "__main__"' in content:
+                        return py_file
+            except:
+                pass
+        
+        # If no main function found, return the first Python file
+        return python_files[0]
+    
+    return None
+
+def analyze_directory_navigation_with_llm(current_dir, target_dir, current_contents, target_contents, api_key=None):
+    """Use LLM to analyze if directory navigation makes sense"""
+    if not api_key:
+        # Try to get API key from environment
+        api_key = os.environ.get("OPENAI_API_KEY")
+        
+    if not api_key:
+        print("⚠️ No OpenAI API key available for directory analysis")
+        return None
+        
+    # Create analysis prompt
+    analysis_prompt = f"""
+I'm trying to determine if a 'cd {target_dir}' command makes sense.
+
+CURRENT DIRECTORY: {current_dir}
+Current directory contents:
+{current_contents}
+
+TARGET DIRECTORY: {target_dir}
+Target directory contents:
+{target_contents}
+
+Please analyze if navigating to the target directory makes sense by considering:
+1. Are the contents significantly different?
+2. Does the target directory contain important files (like source code, config files, etc.)?
+3. Is this likely a nested project directory or just a duplicate?
+4. Would navigating provide access to different functionality or files?
+
+Respond with only 'NAVIGATE' if navigation makes sense, or 'SKIP' if it's redundant.
+"""
+    
+    # Prepare the API request
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+    
+    payload = {
+        "model": "gpt-4",
+        "messages": [
+            {"role": "system", "content": "You are a directory navigation assistant. Analyze if navigating to a target directory makes sense based on the contents of both directories. Respond with only 'NAVIGATE' or 'SKIP'."},
+            {"role": "user", "content": analysis_prompt}
+        ],
+        "temperature": 0.1,
+        "max_tokens": 50
+    }
+    
+    try:
+        print("🤖 Calling OpenAI for directory navigation analysis...")
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            llm_response = result["choices"][0]["message"]["content"].strip()
+            print(f"🤖 LLM Response: {llm_response}")
+            return llm_response
+        else:
+            print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
+            return None
+    except Exception as e:
+        print(f"❌ Error calling OpenAI API: {e}")
+        return None
+
+def cleanup_modal_token():
+    """Delete Modal token files and environment variables after SSH container is started"""
+    print("🧹 Cleaning up Modal token for security...")
+    
+    try:
+        # Remove token from environment variables
+        if "MODAL_TOKEN_ID" in os.environ:
+            del os.environ["MODAL_TOKEN_ID"]
+            print("✅ Removed MODAL_TOKEN_ID from environment")
+        
+        if "MODAL_TOKEN" in os.environ:
+            del os.environ["MODAL_TOKEN"]
+            print("✅ Removed MODAL_TOKEN from environment")
+            
+        if "MODAL_TOKEN_SECRET" in os.environ:
+            del os.environ["MODAL_TOKEN_SECRET"]
+            print("✅ Removed MODAL_TOKEN_SECRET from environment")
+        
+        # Delete ~/.modal.toml file
+        home_dir = os.path.expanduser("~")
+        modal_toml = os.path.join(home_dir, ".modal.toml")
+        if os.path.exists(modal_toml):
+            os.remove(modal_toml)
+            print(f"✅ Deleted Modal token file at {modal_toml}")
+        
+        print("✅ Modal token cleanup completed successfully")
+    except Exception as e:
+        print(f"❌ Error during Modal token cleanup: {e}")
+
+def show_usage_examples():
+    """Display usage examples for the command-line interface."""
+    print("\033[92mUsage Examples\033[0m")
+    print("")
+    print("\033[92mBasic Container Creation\033[0m")
+    print("\033[90m┌────────────────────────────────────────────────────────────────────────┐\033[0m")
+    print("\033[90m│\033[0m \033[92mgitarsenal --gpu A10G --repo-url https://github.com/username/repo.git\033[0m  \033[90m│\033[0m")
+    print("\033[90m└────────────────────────────────────────────────────────────────────────┘\033[0m")
+    print("")
+    print("\033[92mWith Setup Commands\033[0m")
+    print("\033[90m┌────────────────────────────────────────────────────────────────────────────────────────────────────┐\033[0m")
+    print("\033[90m│\033[0m \033[92mgitarsenal --gpu A100 --repo-url https://github.com/username/repo.git \\\033[0m           \033[90m│\033[0m")
+    print("\033[90m│\033[0m \033[92m  --setup-commands \"pip install -r requirements.txt\" \"python setup.py install\"\033[0m  \033[90m│\033[0m")
+    print("\033[90m└────────────────────────────────────────────────────────────────────────────────────────────────────┘\033[0m")
+    print("")
+    print("\033[92mWith Persistent Storage\033[0m")
+    print("\033[90m┌────────────────────────────────────────────────────────────────────────────────────┐\033[0m")
+    print("\033[90m│\033[0m \033[92mgitarsenal --gpu A10G --repo-url https://github.com/username/repo.git \\\033[0m  \033[90m│\033[0m")
+    print("\033[90m│\033[0m \033[92m  --volume-name my-persistent-volume\033[0m                             \033[90m│\033[0m")
+    print("\033[90m└────────────────────────────────────────────────────────────────────────────────────┘\033[0m")
+    print("")
+    print("\033[92mInteractive Mode\033[0m")
+    print("\033[90m┌────────────────────────────┐\033[0m")
+    print("\033[90m│\033[0m \033[92mgitarsenal --interactive\033[0m  \033[90m│\033[0m")
+    print("\033[90m└────────────────────────────┘\033[0m")
+    print("")
+    print("\033[92mAvailable GPU Options:\033[0m")
+    print("  T4, L4, A10G, A100-40GB, A100-80GB, L40S, H100, H200, B200")
+    print("")
+
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
     import argparse
+    import sys
     
     parser = argparse.ArgumentParser(description='Create a Modal SSH container with GPU')
     parser.add_argument('--gpu', type=str, default='A10G', help='GPU type (default: A10G)')
@@ -2506,12 +3378,79 @@ if __name__ == "__main__":
     parser.add_argument('--timeout', type=int, default=60, help='Container timeout in minutes (default: 60)')
     parser.add_argument('--ssh-password', type=str, help='SSH password (random if not provided)')
     parser.add_argument('--use-api', action='store_true', help='Fetch setup commands from API')
+    parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
+    parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
     
     args = parser.parse_args()
     
+    # If no arguments or only --show-examples is provided, show usage examples
+    if len(sys.argv) == 1 or args.show_examples:
+        show_usage_examples()
+        sys.exit(0)
+        
     # Get setup commands from file if specified
     setup_commands = args.setup_commands or []
     
+    # If interactive mode is enabled, prompt for options
+    if args.interactive:
+        # If repo URL wasn't provided via command line, ask for it
+        if not args.repo_url:
+            args.repo_url = input("✔ Dependencies checked\n? Enter GitHub repository URL: ").strip()
+            if not args.repo_url:
+                print("❌ No repository URL provided. Exiting.")
+                sys.exit(1)
+        
+        # Ask about persistent volume
+        use_volume = input("? Use persistent volume for faster installs? (Yes/No) [Yes]: ").strip().lower()
+        if not use_volume or use_volume.startswith('y'):
+            if not args.volume_name:
+                args.volume_name = input("? Enter volume name [gitarsenal-volume]: ").strip()
+                if not args.volume_name:
+                    args.volume_name = "gitarsenal-volume"
+        else:
+            args.volume_name = None
+        
+        # Ask about auto-detecting setup commands
+        use_api = input("? Automatically detect setup commands for this repository? (Yes/No) [Yes]: ").strip().lower()
+        if not use_api or use_api.startswith('y'):
+            args.use_api = True
+        else:
+            args.use_api = False
+        
+        # GPU selection
+        gpu_options = ['T4', 'L4', 'A10G', 'A100-40GB', 'A100-80GB', 'L40S', 'H100', 'H200', 'B200']
+        print("\n? Select GPU type:")
+        for i, gpu in enumerate(gpu_options, 1):
+            print(f"  {i}. {gpu}")
+        
+        gpu_choice = input(f"Enter choice (1-{len(gpu_options)}) [default: 3 for A10G]: ").strip()
+        if not gpu_choice:
+            args.gpu = 'A10G'  # Default
+        else:
+            try:
+                gpu_index = int(gpu_choice) - 1
+                if 0 <= gpu_index < len(gpu_options):
+                    args.gpu = gpu_options[gpu_index]
+                else:
+                    print("⚠️ Invalid choice. Using default: A10G")
+                    args.gpu = 'A10G'
+            except ValueError:
+                print("⚠️ Invalid input. Using default: A10G")
+                args.gpu = 'A10G'
+        
+        # Show configuration summary
+        print("\n📋 Container Configuration:")
+        print(f"Repository URL: {args.repo_url}")
+        print(f"GPU Type: {args.gpu}")
+        print(f"Volume: {args.volume_name if args.volume_name else 'None'}")
+        print(f"Setup Commands: {'Auto-detect from repository' if args.use_api else 'None'}")
+        
+        # Confirm settings
+        confirm = input("? Proceed with these settings? (Yes/No) [Yes]: ").strip().lower()
+        if confirm and not confirm.startswith('y'):
+            print("❌ Setup cancelled by user.")
+            sys.exit(0)
+    
     # If --use-api flag is set and repo_url is provided, fetch setup commands from API
     if args.use_api and args.repo_url:
         print("🔄 Using API to fetch setup commands")
@@ -2575,70 +3514,7 @@ if __name__ == "__main__":
                     
         except Exception as e:
             print(f"⚠️ Error reading commands file: {e}")
-    
-    # Execute setup script if provided
-    if args.setup_script:
-        print(f"📜 Setup script path: {args.setup_script}")
-        
-        # Verify script exists
-        if os.path.exists(args.setup_script):
-            print(f"✅ Script exists at: {args.setup_script}")
-            
-            # Check if script is executable
-            if not os.access(args.setup_script, os.X_OK):
-                print(f"⚠️ Script is not executable, setting permissions...")
-                try:
-                    os.chmod(args.setup_script, 0o755)
-                    print(f"✅ Set executable permissions on script")
-                except Exception as e:
-                    print(f"❌ Failed to set permissions: {e}")
-            
-            working_dir = args.working_dir or os.getcwd()
-            print(f"📂 Using working directory: {working_dir}")
-            
-            # Execute the script directly instead of through container
-            try:
-                print(f"🔄 Executing script directly: bash {args.setup_script} {working_dir}")
-                result = subprocess.run(['bash', args.setup_script, working_dir], 
-                                       capture_output=True, text=True)
-                
-                print(f"📋 Script output:")
-                print(result.stdout)
-                
-                if result.returncode != 0:
-                    print(f"❌ Script execution failed with error code {result.returncode}")
-                    print(f"Error output: {result.stderr}")
-                else:
-                    print(f"✅ Script executed successfully")
-                    
-                # Skip the regular setup commands since we executed the script directly
-                setup_commands = []
-            except Exception as e:
-                print(f"❌ Failed to execute script: {e}")
-                # Fall back to running the script through container
-                setup_commands = [f"bash {args.setup_script} {working_dir}"]
-                print("🔄 Falling back to running script through container")
-        else:
-            print(f"❌ Script not found at: {args.setup_script}")
-            # Try to find the script in common locations
-            possible_paths = [
-                os.path.join(os.path.expanduser('~'), os.path.basename(args.setup_script)),
-                os.path.join('/tmp', os.path.basename(args.setup_script)),
-                os.path.join('/var/tmp', os.path.basename(args.setup_script))
-            ]
-            
-            found = False
-            for test_path in possible_paths:
-                if os.path.exists(test_path):
-                    print(f"🔍 Found script at alternative location: {test_path}")
-                    setup_commands = [f"bash {test_path} {args.working_dir or os.getcwd()}"]
-                    found = True
-                    break
             
-            if not found:
-                print("❌ Could not find script in any location")
-                setup_commands = []
-    
     try:
         result = create_modal_ssh_container(
             args.gpu,
@@ -2657,79 +3533,6 @@ if __name__ == "__main__":
                 print(".", end="", flush=True)
         except KeyboardInterrupt:
             print("\n👋 Script exited. The SSH container will continue running.")
-            if 'result' in locals() and result:
-                container_id = None
-                ssh_password = None
-                
-                # Try to get container ID and SSH password from the result dictionary
-                if isinstance(result, dict):
-                    container_id = result.get('container_id')
-                    ssh_password = result.get('ssh_password')
-                elif hasattr(result, 'container_id'):
-                    container_id = result.container_id
-                    ssh_password = getattr(result, 'ssh_password', None)
-                
-                # If we still don't have the container ID, try to read it from the file
-                if not container_id:
-                    try:
-                        with open(os.path.expanduser("~/.modal_last_container_id"), "r") as f:
-                            container_id = f.read().strip()
-                        print(f"📋 Retrieved container ID from file: {container_id}")
-                    except Exception as e:
-                        print(f"⚠️ Could not read container ID from file: {e}")
-                
-                if container_id:
-                    print(f"🚀 SSH connection information:")
-                    print(f"   ssh root@{container_id}.modal.run")
-                    if ssh_password:
-                        print(f"   Password: {ssh_password}")
-                    
-                    # Try to open a new terminal window with SSH connection
-                    try:
-                        terminal_script = f'''
-                        tell application "Terminal"
-                            do script "echo 'Connecting to Modal SSH container...'; echo 'Password: {ssh_password or 'unknown'}'; ssh root@{container_id}.modal.run"
-                            activate
-                        end tell
-                        '''
-                        
-                        subprocess.run(['osascript', '-e', terminal_script], 
-                                      capture_output=True, text=True, timeout=30)
-                        print("✅ New terminal window opened with SSH connection")
-                        
-                    except Exception as e:
-                        print(f"⚠️ Failed to open terminal window: {e}")
-                        
-                        # Try alternative approach with iTerm2
-                        try:
-                            iterm_script = f'''
-                            tell application "iTerm"
-                                create window with default profile
-                                tell current session of current window
-                                    write text "echo 'Connecting to Modal SSH container...'; echo 'Password: {ssh_password or 'unknown'}'; ssh root@{container_id}.modal.run"
-                                end tell
-                            end tell
-                            '''
-                            
-                            subprocess.run(['osascript', '-e', iterm_script], 
-                                          capture_output=True, text=True, timeout=30)
-                            print("✅ New iTerm2 window opened with SSH connection")
-                            
-                        except Exception as e2:
-                            print(f"⚠️ Failed to open iTerm2 window: {e2}")
-                            print("📝 You can manually connect using:")
-                            print(f"   ssh root@{container_id}.modal.run")
-                            if ssh_password:
-                                print(f"   Password: {ssh_password}")
-                            print("   Or use Modal exec:")
-                            print(f"   modal container exec --pty {container_id} bash")
-                else:
-                    print("⚠️ Could not determine container ID")
-                    print("📝 You can manually connect using:")
-                    print("   modal container list")
-                    print("   modal container exec --pty <CONTAINER_ID> bash")
-            
-            # Exit cleanly
             sys.exit(0)
             
     except KeyboardInterrupt: