gitarsenal-cli 1.7.7 → 1.7.9

package/python/test_modalSandboxScript.py

@@ -14,6 +14,7 @@ import threading
 import uuid
 import signal
 from pathlib import Path
+import modal
 
 # Parse command-line arguments
 parser = argparse.ArgumentParser()
@@ -37,7 +38,7 @@ if args.proxy_api_key:
 class PersistentShell:
     """A persistent bash shell using subprocess.Popen for executing commands with state persistence."""
     
-    def __init__(self, working_dir="/root", timeout=60):
+    def __init__(self, working_dir="/root", timeout=200):
         self.working_dir = working_dir
         self.timeout = timeout
         self.process = None
@@ -85,7 +86,6 @@ class PersistentShell:
         self._send_command_raw("cd " + self.working_dir)  # Change to working directory
         time.sleep(0.5)  # Let initial commands settle
         
-        print("✅ Persistent shell started successfully")
         
     def _read_stdout(self):
         """Read stdout in a separate thread."""
@@ -306,12 +306,13 @@ class PersistentShell:
         
         if success:
             if stdout_text:
+                print("")
                 print(f"✅ Output: {stdout_text}")
             # Track virtual environment activation
             if command.strip().startswith("source ") and "/bin/activate" in command:
                 venv_path = command.replace("source ", "").replace("/bin/activate", "").strip()
                 self.virtual_env_path = venv_path
-                print(f"✅ Virtual environment activated: {venv_path}")
+                # print(f"✅ Virtual environment activated: {venv_path}")
         else:
             print(f"❌ Command failed with exit code: {exit_code}")
             if stderr_text:
@@ -410,123 +411,296 @@ class PersistentShell:
         print("✅ Shell cleanup completed")
 
 
-# First, try to fetch tokens from the proxy server
-try:
-    # Import the fetch_modal_tokens module
-    print("🔄 Fetching tokens from proxy server...")
-    from fetch_modal_tokens import get_tokens
-    token_id, token_secret, openai_api_key = get_tokens()
-    
-    # Debug print the tokens
-    # print("🔍 DEBUG: Modal Tokens Fetched:")
-    # print(f"🔍 DEBUG: Token ID: {token_id}")
-    # print(f"🔍 DEBUG: Token Secret: {token_secret}")
-    # print(f"🔍 DEBUG: OpenAI API Key: {openai_api_key}")
-    
-    # Check if we got valid tokens
-    if token_id is None or token_secret is None:
-        raise ValueError("Could not get valid tokens")
-    
-    print(f"✅ Tokens fetched successfully")
-    
-    # Explicitly set the environment variables again to be sure
-    os.environ["MODAL_TOKEN_ID"] = token_id
-    os.environ["MODAL_TOKEN_SECRET"] = token_secret
-    os.environ["OPENAI_API_KEY"] = openai_api_key
-    # Also set the old environment variable for backward compatibility
-    os.environ["MODAL_TOKEN"] = token_id
-    
-    # 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
-        import modal_token_solution
-        
-        # Set token variables for later use
-        token = modal_token_solution.TOKEN_ID  # For backward compatibility
-    except Exception as e:
+class CommandListManager:
+    """Manages a dynamic list of setup commands with status tracking and LLM-suggested fixes."""
+    
+    def __init__(self, initial_commands=None):
+        self.commands = []
+        self.executed_commands = []
+        self.failed_commands = []
+        self.suggested_fixes = []
+        self.current_index = 0
+        self.total_commands = 0
+        
+        if initial_commands:
+            self.add_commands(initial_commands)
+    
+    def add_commands(self, commands):
+        """Add new commands to the list."""
+        if isinstance(commands, str):
+            commands = [commands]
+        
+        added_count = 0
+        for cmd in commands:
+            if cmd and cmd.strip():
+                self.commands.append({
+                    'command': cmd.strip(),
+                    'status': 'pending',
+                    'index': len(self.commands),
+                    'stdout': '',
+                    'stderr': '',
+                    'execution_time': None,
+                    'fix_attempts': 0,
+                    'max_fix_attempts': 3
+                })
+                added_count += 1
+        
+        self.total_commands = len(self.commands)
+        if added_count > 0:
+            print(f"📋 Added {added_count} commands to list. Total: {self.total_commands}")
+    
+    def add_command_dynamically(self, command, priority='normal'):
+        """Add a single command dynamically during execution."""
+        if not command or not command.strip():
+            return False
+        
+        new_command = {
+            'command': command.strip(),
+            'status': 'pending',
+            'index': len(self.commands),
+            'stdout': '',
+            'stderr': '',
+            'execution_time': None,
+            'fix_attempts': 0,
+            'max_fix_attempts': 3,
+            'priority': priority
+        }
         
-        # Fall back to the authentication patch
-        try:
-            # Import the patch module
-            import modal_auth_patch
-            
-            # Set token variables for later use
-            token = modal_auth_patch.TOKEN_ID  # For backward compatibility
-        except Exception as 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
-                )
+        if priority == 'high':
+            # Insert at the beginning of pending commands
+            self.commands.insert(self.current_index, new_command)
+            # Update indices for all commands after insertion
+            for i in range(self.current_index + 1, len(self.commands)):
+                self.commands[i]['index'] = i
+        else:
+            # Add to the end
+            self.commands.append(new_command)
+        
+        self.total_commands = len(self.commands)
+        print(f"📋 Added dynamic command: {command.strip()}")
+        return True
+    
+    def add_suggested_fix(self, original_command, fix_command, reason=""):
+        """Add a LLM-suggested fix for a failed command."""
+        fix_entry = {
+            'original_command': original_command,
+            'fix_command': fix_command,
+            'reason': reason,
+            'status': 'pending',
+            'index': len(self.suggested_fixes),
+            'stdout': '',
+            'stderr': '',
+            'execution_time': None
+        }
+        self.suggested_fixes.append(fix_entry)
+        print(f"🔧 Added suggested fix: {fix_command}")
+        return len(self.suggested_fixes) - 1
+    
+    def get_next_command(self):
+        """Get the next pending command to execute."""
+        # First, try to get a pending command from the main list
+        for i in range(self.current_index, len(self.commands)):
+            if self.commands[i]['status'] == 'pending':
+                return self.commands[i], 'main'
+        
+        # If no pending commands in main list, check suggested fixes
+        for fix in self.suggested_fixes:
+            if fix['status'] == 'pending':
+                return fix, 'fix'
+        
+        return None, None
+    
+    def mark_command_executed(self, command_index, command_type='main', success=True, stdout='', stderr='', execution_time=None):
+        """Mark a command as executed with results."""
+        if command_type == 'main':
+            if 0 <= command_index < len(self.commands):
+                self.commands[command_index].update({
+                    'status': 'success' if success else 'failed',
+                    'stdout': stdout,
+                    'stderr': stderr,
+                    'execution_time': execution_time
+                })
                 
-                # 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 success:
+                    self.executed_commands.append(self.commands[command_index])
+                    print(f"✅ Command {command_index + 1}/{self.total_commands} completed successfully")
+                else:
+                    self.failed_commands.append(self.commands[command_index])
+                    print(f"❌ Command {command_index + 1}/{self.total_commands} failed")
                 
-                if result.returncode != 0:
-                    print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
-                    if result.stderr:
-                        print(f"Error: {result.stderr}")
+                self.current_index = max(self.current_index, command_index + 1)
+        
+        elif command_type == 'fix':
+            if 0 <= command_index < len(self.suggested_fixes):
+                self.suggested_fixes[command_index].update({
+                    'status': 'success' if success else 'failed',
+                    'stdout': stdout,
+                    'stderr': stderr,
+                    'execution_time': execution_time
+                })
                 
-                # 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}")
-                token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
+                if success:
+                    print(f"✅ Fix command {command_index + 1} completed successfully")
+                else:
+                    print(f"❌ Fix command {command_index + 1} failed")
+    
+    def get_status_summary(self):
+        """Get a summary of command execution status."""
+        total_main = len(self.commands)
+        total_fixes = len(self.suggested_fixes)
+        executed_main = len([c for c in self.commands if c['status'] == 'success'])
+        failed_main = len([c for c in self.commands if c['status'] == 'failed'])
+        pending_main = len([c for c in self.commands if c['status'] == 'pending'])
+        executed_fixes = len([f for f in self.suggested_fixes if f['status'] == 'success'])
+        failed_fixes = len([f for f in self.suggested_fixes if f['status'] == 'failed'])
+        
+        return {
+            'total_main_commands': total_main,
+            'executed_main_commands': executed_main,
+            'failed_main_commands': failed_main,
+            'pending_main_commands': pending_main,
+            'total_fix_commands': total_fixes,
+            'executed_fix_commands': executed_fixes,
+            'failed_fix_commands': failed_fixes,
+            'progress_percentage': (executed_main / total_main * 100) if total_main > 0 else 0
+        }
+    
+    def print_status(self):
+        """Print current status of all commands."""
+        summary = self.get_status_summary()
+        
+        print("\n" + "="*60)
+        print("📋 COMMAND EXECUTION STATUS")
+        print("="*60)
+        
+        # Main commands status
+        print(f"📋 Main Commands: {summary['executed_main_commands']}/{summary['total_main_commands']} completed")
+        print(f"   ✅ Successful: {summary['executed_main_commands']}")
+        print(f"   ❌ Failed: {summary['failed_main_commands']}")
+        print(f"   ⏳ Pending: {summary['pending_main_commands']}")
+        
+        # Fix commands status
+        if summary['total_fix_commands'] > 0:
+            print(f"🔧 Fix Commands: {summary['executed_fix_commands']}/{summary['total_fix_commands']} completed")
+            print(f"   ✅ Successful: {summary['executed_fix_commands']}")
+            print(f"   ❌ Failed: {summary['failed_fix_commands']}")
+        
+        # Progress bar
+        progress = summary['progress_percentage']
+        bar_length = 30
+        filled_length = int(bar_length * progress / 100)
+        bar = '█' * filled_length + '░' * (bar_length - filled_length)
+        print(f"📊 Progress: [{bar}] {progress:.1f}%")
+        
+        # Show current command if any
+        next_cmd, cmd_type = self.get_next_command()
+        if next_cmd:
+            cmd_type_str = "main" if cmd_type == 'main' else "fix"
+            cmd_text = next_cmd.get('command', next_cmd.get('fix_command', 'Unknown command'))
+            print(f"🔄 Current: {cmd_type_str} command - {cmd_text[:50]}...")
+        
+        print("="*60)
+    
+    def get_failed_commands_for_llm(self):
+        """Get failed commands for LLM analysis."""
+        failed_commands = []
+        
+        # Get failed main commands
+        for cmd in self.commands:
+            if cmd['status'] == 'failed':
+                failed_commands.append({
+                    'command': cmd['command'],
+                    'stderr': cmd['stderr'],
+                    'stdout': cmd['stdout'],
+                    'type': 'main'
+                })
+        
+        # Get failed fix commands
+        for fix in self.suggested_fixes:
+            if fix['status'] == 'failed':
+                failed_commands.append({
+                    'command': fix['fix_command'],
+                    'stderr': fix['stderr'],
+                    'stdout': fix['stdout'],
+                    'type': 'fix',
+                    'original_command': fix['original_command']
+                })
+        
+        return failed_commands
+    
+    def has_pending_commands(self):
+        """Check if there are any pending commands."""
+        return any(cmd['status'] == 'pending' for cmd in self.commands) or \
+               any(fix['status'] == 'pending' for fix in self.suggested_fixes)
+    
+    def get_all_commands(self):
+        """Get all commands (main + fixes) in execution order."""
+        all_commands = []
+        
+        # Add main commands
+        for cmd in self.commands:
+            all_commands.append({
+                **cmd,
+                'type': 'main'
+            })
+        
+        # Add fix commands
+        for fix in self.suggested_fixes:
+            all_commands.append({
+                **fix,
+                'type': 'fix'
+            })
+        
+        return all_commands
+    
+    def analyze_failed_commands_with_llm(self, api_key=None, current_dir=None, sandbox=None):
+        """Analyze all failed commands using LLM and add suggested fixes."""
+        failed_commands = self.get_failed_commands_for_llm()
+        
+        if not failed_commands:
+            print("✅ No failed commands to analyze")
+            return []
+        
+        print(f"🔍 Analyzing {len(failed_commands)} failed commands with LLM...")
+        
+        # Use batch debugging for efficiency
+        fixes = call_openai_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+        
+        # Add the fixes to the command list
+        added_fixes = []
+        for fix in fixes:
+            fix_index = self.add_suggested_fix(
+                fix['original_command'], 
+                fix['fix_command'], 
+                fix['reason']
+            )
+            added_fixes.append(fix_index)
+        
+        print(f"🔧 Added {len(added_fixes)} LLM-suggested fixes to command list")
+        return added_fixes
 
-if os.environ.get('MODAL_TOKEN_ID'):
-    print(f"🔍 Token ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
-if os.environ.get('MODAL_TOKEN_SECRET'):
-    print(f"🔍 Token secret length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
-if os.environ.get('MODAL_TOKEN'):
-    print(f"🔍 Token length: {len(os.environ.get('MODAL_TOKEN'))}")
 
-# Import modal after token setup
-import modal
+# Import the fetch_modal_tokens module
+# print("🔄 Fetching tokens from proxy server...")
+from fetch_modal_tokens import 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:
+    raise ValueError("Could not get valid tokens")
+
+print(f"✅ Tokens fetched successfully")
+
+# Explicitly set the environment variables again to be sure
+os.environ["MODAL_TOKEN_ID"] = token_id
+os.environ["MODAL_TOKEN_SECRET"] = token_secret
+os.environ["OPENAI_API_KEY"] = openai_api_key
+# Also set the old environment variable for backward compatibility
+os.environ["MODAL_TOKEN"] = token_id
+
+# Set token variables for later use
+token = token_id  # For backward compatibility
 
-def handle_interactive_input(prompt, is_password=False):
-    """Handle interactive input from the user with optional password masking"""
-    print("\n" + "="*60)
-    print(f"{prompt}")
-    print("="*60)
-    
-    try:
-        if is_password:
-            user_input = getpass.getpass("Input (hidden): ").strip()
-        else:
-            user_input = input("Input: ").strip()
-            
-        if not user_input:
-            print("❌ No input provided.")
-            return None
-        print("✅ Input received successfully!")
-        return user_input
-    except KeyboardInterrupt:
-        print("\n❌ Input cancelled by user.")
-        return None
-    except Exception as e:
-        print(f"❌ Error getting input: {e}")
-        return None
 
 def get_stored_credentials():
     """Load stored credentials from ~/.gitarsenal/credentials.json"""
@@ -747,7 +921,7 @@ System Information:
     
     if current_dir and sandbox:
         try:
-            print("🔍 Getting directory context for better debugging...")
+            # print("🔍 Getting directory context for better debugging...")
             
             # Get current directory contents
             ls_result = sandbox.exec("bash", "-c", "ls -la")
@@ -835,7 +1009,7 @@ Parent directory contents:
                     except Exception as e:
                         print(f"⚠️ Error getting content of {file_path}: {e}")
                 
-                print(f"✅ Additional file context gathered from {len(relevant_files)} relevant files")
+                # print(f"✅ Additional file context gathered from {len(relevant_files)} relevant files")
             
         except Exception as e:
             print(f"⚠️ Error getting directory context: {e}")
@@ -849,12 +1023,6 @@ Parent directory contents:
 
     stored_credentials = get_stored_credentials()
     auth_context = generate_auth_context(stored_credentials)
-
-
-    print("DEBUG: AUTH_CONTEXT SENT TO LLM:")
-    print("="*60)
-    print(auth_context)
-    print("="*60 + "\n")
     
     # Create a prompt for the LLM
     print("\n" + "="*60)
@@ -923,11 +1091,18 @@ IMPORTANT GUIDELINES:
    - Do not use generic placeholders or dummy values
    - The auth_context contains real, usable credentials
 
+7. For Git SSH authentication failures:
+   - If the error contains "Host key verification failed" or "Could not read from remote repository"
+   - ALWAYS convert SSH URLs to HTTPS URLs for public repositories
+   - Replace git@github.com:username/repo.git with https://github.com/username/repo.git
+   - This works for public repositories without authentication
+   - Example: git clone https://github.com/xg-chu/ARTalk.git
+
 Do not provide any explanations, just the exact command to run.
 """
     
     # Prepare the API request payload
-    print("🔍 DEBUG: Preparing API request...")
+    # print("🔍 DEBUG: Preparing API request...")
     
     # Try to use GPT-4 first, but fall back to other models if needed
     models_to_try = [
@@ -939,16 +1114,16 @@ Do not provide any explanations, just the exact command to run.
     if preferred_model:
         # Insert the preferred model at the beginning of the list
         models_to_try.insert(0, preferred_model)
-        print(f"✅ Using preferred model from environment: {preferred_model}")
+        # print(f"✅ Using preferred model from environment: {preferred_model}")
         
     # Remove duplicates while preserving order
     models_to_try = list(dict.fromkeys(models_to_try))
-    print(f"🔍 DEBUG: Models to try: {models_to_try}")
+    # print(f"🔍 DEBUG: Models to try: {models_to_try}")
     
     # Function to make the API call with a specific model
     def try_api_call(model_name, retries=2, backoff_factor=1.5):
-        print(f"🔍 DEBUG: Attempting API call with model: {model_name}")
-        print(f"🔍 DEBUG: API key available: {'Yes' if api_key else 'No'}")
+        # print(f"🔍 DEBUG: Attempting API call with model: {model_name}")
+        # print(f"🔍 DEBUG: API key available: {'Yes' if api_key else 'No'}")
         # if api_key:
         #     print(f"🔍 DEBUG: API key length: {len(api_key)}")
         #     print(f"🔍 DEBUG: API key starts with: {api_key[:10]}...")
@@ -956,14 +1131,14 @@ Do not provide any explanations, just the exact command to run.
         payload = {
             "model": model_name,
             "messages": [
-                {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue. Analyze the issue first, understand why it's happening, then provide the command to fix it. For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found. For missing packages, use appropriate package managers (pip, apt-get, npm). For authentication, suggest login commands with placeholders."},
+                {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue. Analyze the issue first, understand why it's happening, then provide the command to fix it. For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found. For missing packages, use appropriate package managers (pip, apt-get, npm). For Git SSH authentication failures, always convert SSH URLs to HTTPS URLs (git@github.com:user/repo.git -> https://github.com/user/repo.git). For authentication, suggest login commands with placeholders."},
                 {"role": "user", "content": prompt}
             ],
             "temperature": 0.2,
             "max_tokens": 300
         }
         
-        print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
+        # print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
         
         # Add specific handling for common errors
         last_error = None
@@ -975,8 +1150,8 @@ Do not provide any explanations, just the exact command to run.
                     print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
                     time.sleep(wait_time)
                 
-                print(f"🤖 Calling OpenAI with {model_name} model to debug the failed command...")
-                print(f"🔍 DEBUG: Making POST request to OpenAI API...")
+                # print(f"🤖 Calling OpenAI with {model_name} model to debug the failed command...")
+                # print(f"🔍 DEBUG: Making POST request to OpenAI API...")
                 response = requests.post(
                     "https://api.openai.com/v1/chat/completions",
                     headers=headers,
@@ -984,45 +1159,12 @@ Do not provide any explanations, just the exact command to run.
                     timeout=45  # Increased timeout for reliability
                 )
                 
-                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
+                # print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
                 
-                # Handle specific status codes
-                if response.status_code == 200:
-                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
-                    return response.json(), None
-                elif response.status_code == 401:
-                    error_msg = "Authentication error: Invalid API key"
-                    print(f"❌ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Don't retry auth errors
-                    return None, error_msg
-                elif response.status_code == 429:
-                    error_msg = "Rate limit exceeded or quota reached"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Always retry rate limit errors with increasing backoff
-                    last_error = error_msg
-                    continue
-                elif response.status_code == 500:
-                    error_msg = "OpenAI server error"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Retry server errors
-                    last_error = error_msg
-                    continue
-                else:
-                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
-                    print(f"⚠️ OpenAI API error: {error_msg}")
-                    print(f"🔍 DEBUG: Full response text: {response.text}")
-                    last_error = error_msg
-                    # Only retry if we have attempts left
-                    if attempt < retries:
-                        continue
-                    return None, error_msg
             except requests.exceptions.Timeout:
                 error_msg = "Request timed out"
-                print(f"⚠️ {error_msg}")
-                print(f"🔍 DEBUG: Timeout after 45 seconds")
+                # print(f"⚠️ {error_msg}")
+                # print(f"🔍 DEBUG: Timeout after 45 seconds")
                 last_error = error_msg
                 # Always retry timeouts
                 continue
@@ -1155,6 +1297,126 @@ Do not provide any explanations, just the exact command to run.
         print(f"🔍 DEBUG: Exception details: {str(e)}")
         return None
 
+def call_openai_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Call OpenAI to debug multiple failed commands and suggest fixes for all of them at once"""
+    print("\n🔍 DEBUG: Starting batch LLM debugging...")
+    print(f"🔍 DEBUG: Analyzing {len(failed_commands)} failed commands")
+    
+    if not failed_commands:
+        print("⚠️ No failed commands to analyze")
+        return []
+    
+    if not api_key:
+        print("❌ No OpenAI API key provided for batch debugging")
+        return []
+    
+    # Prepare context for batch analysis
+    context_parts = []
+    context_parts.append(f"Current directory: {current_dir}")
+    context_parts.append(f"Sandbox available: {sandbox is not None}")
+    
+    # Add failed commands with their errors
+    for i, failed_cmd in enumerate(failed_commands, 1):
+        cmd_type = failed_cmd.get('type', 'main')
+        original_cmd = failed_cmd.get('original_command', '')
+        cmd_text = failed_cmd['command']
+        stderr = failed_cmd.get('stderr', '')
+        stdout = failed_cmd.get('stdout', '')
+        
+        context_parts.append(f"\n--- Failed Command {i} ({cmd_type}) ---")
+        context_parts.append(f"Command: {cmd_text}")
+        if original_cmd and original_cmd != cmd_text:
+            context_parts.append(f"Original Command: {original_cmd}")
+        if stderr:
+            context_parts.append(f"Error Output: {stderr}")
+        if stdout:
+            context_parts.append(f"Standard Output: {stdout}")
+    
+    # Create the prompt for batch analysis
+    prompt = f"""You are a debugging assistant analyzing multiple failed commands. 
+
+Context:
+{chr(10).join(context_parts)}
+
+Please analyze each failed command and provide a fix command for each one. For each failed command, respond with:
+
+FIX_COMMAND_{i}: <the fix command>
+REASON_{i}: <brief explanation of why the original command failed and how the fix addresses it>
+
+Guidelines:
+- For file not found errors, first search for the file using 'find . -name filename -type f'
+- For missing packages, use appropriate package managers (pip, apt-get, npm)
+- For Git SSH authentication failures, convert SSH URLs to HTTPS URLs
+- For permission errors, suggest commands with sudo if appropriate
+- For network issues, suggest retry commands or alternative URLs
+- Keep each fix command simple and focused on the specific error
+
+Provide fixes for all {len(failed_commands)} failed commands:"""
+
+    # Make the API call
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": "gpt-4o-mini",  # Use a more capable model for batch analysis
+        "messages": [
+            {"role": "system", "content": "You are a debugging assistant. Analyze failed commands and provide specific fix commands. Return only the fix commands and reasons in the specified format."},
+            {"role": "user", "content": prompt}
+        ],
+        "temperature": 0.1,
+        "max_tokens": 1000
+    }
+    
+    try:
+        print(f"🤖 Calling OpenAI for batch debugging of {len(failed_commands)} commands...")
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result['choices'][0]['message']['content']
+            print(f"✅ Batch analysis completed")
+            
+            # Parse the response to extract fix commands
+            fixes = []
+            for i in range(1, len(failed_commands) + 1):
+                fix_pattern = f"FIX_COMMAND_{i}: (.+)"
+                reason_pattern = f"REASON_{i}: (.+)"
+                
+                fix_match = re.search(fix_pattern, content, re.MULTILINE)
+                reason_match = re.search(reason_pattern, content, re.MULTILINE)
+                
+                if fix_match:
+                    fix_command = fix_match.group(1).strip()
+                    reason = reason_match.group(1).strip() if reason_match else "LLM suggested fix"
+                    
+                    # Clean up the fix command
+                    if fix_command.startswith('`') and fix_command.endswith('`'):
+                        fix_command = fix_command[1:-1]
+                    
+                    fixes.append({
+                        'original_command': failed_commands[i-1]['command'],
+                        'fix_command': fix_command,
+                        'reason': reason,
+                        'command_index': i-1
+                    })
+            
+            print(f"🔧 Generated {len(fixes)} fix commands from batch analysis")
+            return fixes
+        else:
+            print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
+            return []
+            
+    except Exception as e:
+        print(f"❌ Error during batch debugging: {e}")
+        return []
+
 def prompt_for_hf_token():
     """Prompt user for Hugging Face token when needed"""
     # Try to use credentials manager first
@@ -1209,6 +1471,8 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # If GPU type is not specified, prompt for it
         if not gpu_type:
             gpu_type = prompt_for_gpu()
+        else:
+            print(f"✅ Using provided GPU type: {gpu_type}")
             
         # If repo URL is not specified, prompt for it
         if not repo_url:
@@ -1516,66 +1780,150 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # Start SSH service
         subprocess.run(["service", "ssh", "start"], check=True)
         
-        # Run setup commands if provided using PersistentShell
+        # Run setup commands if provided using PersistentShell and CommandListManager
         if setup_commands:
-            print(f"⚙️ Running {len(setup_commands)} setup commands with persistent shell...")
+            print(f"⚙️ Running {len(setup_commands)} setup commands with dynamic command list...")
+            
+            # Create command list manager
+            cmd_manager = CommandListManager(setup_commands)
             
             # Create persistent shell instance starting in /root
-            shell = PersistentShell(working_dir="/root", timeout=120)
+            shell = PersistentShell(working_dir="/root", timeout=200)
             
             try:
                 # Start the persistent shell
                 shell.start()
                 
-                # Execute each setup command
-                for i, cmd in enumerate(setup_commands, 1):
-                    print(f"📋 Executing command {i}/{len(setup_commands)}: {cmd}")
+                # Execute commands using the command list manager
+                while cmd_manager.has_pending_commands():
+                    # Get next command to execute
+                    next_cmd, cmd_type = cmd_manager.get_next_command()
                     
-                    success, stdout, stderr = shell.execute(cmd, timeout=120)
+                    if not next_cmd:
+                        break
                     
-                    if not success:
-                        print(f"⚠️ Command {i} failed, attempting LLM debugging...")
+                    # Print status before executing
+                    cmd_manager.print_status()
+                    
+                    # Execute the command
+                    if cmd_type == 'main':
+                        cmd_text = next_cmd['command']
+                        cmd_index = next_cmd['index']
+                        print(f"📋 Executing main command {cmd_index + 1}/{cmd_manager.total_commands}: {cmd_text}")
                         
-                        # Call OpenAI for debugging
-                        try:
-                            current_dir = shell.get_cwd()
-                            api_key = os.environ.get("OPENAI_API_KEY")
-                            
-                            # Use your existing call_openai_for_debug function
-                            fix_command = call_openai_for_debug(cmd, stderr, api_key=api_key, current_dir=current_dir, sandbox=shell)
+                        start_time = time.time()
+                        success, stdout, stderr = shell.execute(cmd_text, timeout=200)
+                        execution_time = time.time() - start_time
+                        
+                        # Mark command as executed
+                        cmd_manager.mark_command_executed(
+                            cmd_index, 'main', success, stdout, stderr, execution_time
+                        )
+                        
+                        if not success:
+                            print(f"⚠️ Command failed, attempting LLM debugging...")
                             
-                            if fix_command:
-                                print(f"🔧 OpenAI suggested fix command: {fix_command}")
+                            # Call OpenAI for debugging
+                            try:
+                                current_dir = shell.get_cwd()
+                                api_key = os.environ.get("OPENAI_API_KEY")
                                 
-                                # Run the fix command in the persistent shell
-                                print(f"🔄 Running suggested fix command: {fix_command}")
-                                fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=120)
+                                # Use existing call_openai_for_debug function
+                                fix_command = call_openai_for_debug(cmd_text, stderr, api_key=api_key, current_dir=current_dir, sandbox=shell)
                                 
-                                if fix_success:
-                                    print(f"✅ Fix command succeeded")
+                                if fix_command:
+                                    print(f"🔧 OpenAI suggested fix command: {fix_command}")
                                     
-                                    # Retry the original command
-                                    print(f"🔄 Retrying original command: {cmd}")
-                                    retry_success, retry_stdout, retry_stderr = shell.execute(cmd, timeout=120)
+                                    # Add the fix to the command list manager
+                                    fix_index = cmd_manager.add_suggested_fix(cmd_text, fix_command, "LLM suggested fix")
                                     
-                                    if retry_success:
-                                        print(f"✅ Original command succeeded after fix!")
+                                    # Execute the fix command
+                                    print(f"🔄 Running suggested fix command: {fix_command}")
+                                    fix_start_time = time.time()
+                                    fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=200)
+                                    fix_execution_time = time.time() - fix_start_time
+                                    
+                                    # Mark fix command as executed
+                                    cmd_manager.mark_command_executed(
+                                        fix_index, 'fix', fix_success, fix_stdout, fix_stderr, fix_execution_time
+                                    )
+                                    
+                                    if fix_success:
+                                        print(f"✅ Fix command succeeded")
+                                        
+                                        # Retry the original command
+                                        print(f"🔄 Retrying original command: {cmd_text}")
+                                        retry_start_time = time.time()
+                                        retry_success, retry_stdout, retry_stderr = shell.execute(cmd_text, timeout=200)
+                                        retry_execution_time = time.time() - retry_start_time
+                                        
+                                        # Update the original command status
+                                        cmd_manager.mark_command_executed(
+                                            cmd_index, 'main', retry_success, retry_stdout, retry_stderr, retry_execution_time
+                                        )
+                                        
+                                        if retry_success:
+                                            print(f"✅ Original command succeeded after fix!")
+                                        else:
+                                            print(f"⚠️ Original command still failed after fix, continuing...")
                                     else:
-                                        print(f"⚠️ Original command still failed after fix, continuing...")
+                                        print(f"❌ Fix command failed: {fix_stderr}")
+                                        print(f"⚠️ Continuing with remaining commands...")
                                 else:
-                                    print(f"❌ Fix command failed: {fix_stderr}")
+                                    print("❌ No fix suggested by OpenAI")
                                     print(f"⚠️ Continuing with remaining commands...")
-                            else:
-                                print("❌ No fix suggested by OpenAI")
+                                    
+                            except Exception as debug_e:
+                                print(f"❌ LLM debugging failed: {debug_e}")
                                 print(f"⚠️ Continuing with remaining commands...")
-                                
-                        except Exception as debug_e:
-                            print(f"❌ LLM debugging failed: {debug_e}")
-                            print(f"⚠️ Continuing with remaining commands...")
-                    else:
-                        print(f"✅ Command {i} completed successfully")
+                    
+                    elif cmd_type == 'fix':
+                        cmd_text = next_cmd['fix_command']
+                        cmd_index = next_cmd['index']
+                        print(f"🔧 Executing fix command {cmd_index + 1}: {cmd_text}")
+                        
+                        start_time = time.time()
+                        success, stdout, stderr = shell.execute(cmd_text, timeout=200)
+                        execution_time = time.time() - start_time
+                        
+                        # Mark fix command as executed
+                        cmd_manager.mark_command_executed(
+                            cmd_index, 'fix', success, stdout, stderr, execution_time
+                        )
+                
+                # After all commands are processed, do a final batch analysis of any remaining failed commands
+                failed_commands = cmd_manager.get_failed_commands_for_llm()
+                if failed_commands:
+                    print(f"\n🔍 Final batch analysis of {len(failed_commands)} failed commands...")
+                    current_dir = shell.get_cwd()
+                    api_key = os.environ.get("OPENAI_API_KEY")
+                    
+                    # Use batch analysis to get additional fixes
+                    additional_fixes = cmd_manager.analyze_failed_commands_with_llm(api_key, current_dir, shell)
+                    
+                    if additional_fixes:
+                        print(f"🔧 Executing {len(additional_fixes)} additional fix commands...")
+                        
+                        # Execute the additional fix commands
+                        for fix_index in additional_fixes:
+                            fix_cmd = cmd_manager.suggested_fixes[fix_index]
+                            cmd_text = fix_cmd['fix_command']
+                            print(f"🔧 Executing additional fix: {cmd_text}")
+                            
+                            start_time = time.time()
+                            success, stdout, stderr = shell.execute(cmd_text, timeout=200)
+                            execution_time = time.time() - start_time
+                            
+                            # Mark fix command as executed
+                            cmd_manager.mark_command_executed(
+                                fix_index, 'fix', success, stdout, stderr, execution_time
+                            )
                 
-                print("✅ All setup commands processed")
+                # Print final status
+                print("\n" + "="*60)
+                print("🎉 SETUP COMMANDS EXECUTION COMPLETED")
+                print("="*60)
+                cmd_manager.print_status()
                 
             except Exception as e:
                 print(f"❌ Error during setup command execution: {e}")
@@ -2250,35 +2598,6 @@ def find_entry_point(repo_dir):
     
     return None
 
-def cleanup_modal_token():
-    """Delete token files and environment variables after SSH container is started"""
-    print("🧹 Cleaning up tokens for security...")
-    
-    try:
-        # Remove token from environment variables
-        if "MODAL_TOKEN_ID" in os.environ:
-            del os.environ["MODAL_TOKEN_ID"]
-            # print("✅ Removed token ID from environment")
-        
-        if "MODAL_TOKEN" in os.environ:
-            del os.environ["MODAL_TOKEN"]
-            # print("✅ Removed token from environment")
-            
-        if "MODAL_TOKEN_SECRET" in os.environ:
-            del os.environ["MODAL_TOKEN_SECRET"]
-            # print("✅ Removed token secret from environment")
-        
-        # Delete ~/.modal.toml file
-        home_dir = os.path.expanduser("~")
-        modal_toml = os.path.join(home_dir, ".modal.toml")
-        if os.path.exists(modal_toml):
-            os.remove(modal_toml)
-            # print(f"✅ Deleted token file at {modal_toml}")
-        
-        # print("✅ Token cleanup completed successfully")
-    except Exception as e:
-        print(f"❌ Error during token cleanup: {e}")
-
 def cleanup_security_tokens():
     """Delete all security tokens and API keys after SSH container is started"""
     print("🧹 Cleaning up security tokens and API keys...")
@@ -2358,6 +2677,17 @@ def show_usage_examples():
     
     print("Available GPU Options:")
     print("  T4, L4, A10G, A100-40GB, A100-80GB, L40S, H100, H200, B200")
+    print()
+    print("GPU Selection Behavior:")
+    print("  • With --gpu: Uses specified GPU without prompting")
+    print("  • Without --gpu: Shows interactive GPU selection menu")
+    print()
+    print("Examples:")
+    print("  # Uses A10G without prompting:")
+    print("  gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git")
+    print()
+    print("  # Shows interactive GPU selection menu:")
+    print("  gitarsenal --repo-url https://github.com/username/repo.git")
 
 def make_api_request_with_retry(url, payload, max_retries=2, timeout=180):
     """Make an API request with retry mechanism."""
@@ -2709,6 +3039,10 @@ def prompt_for_gpu():
     import tty
     import termios
     
+    print("\n🔧 GPU Selection Required")
+    print("No GPU type was specified with --gpu flag.")
+    print("Please select a GPU type for your container:")
+    
     # Define available GPU types and their specifications
     gpu_specs = {
         'T4': {'gpu': 'T4', 'memory': '16GB'},
@@ -2804,20 +3138,41 @@ def prompt_for_gpu():
             print("\n🛑 Selection cancelled.")
             sys.exit(1)
         except Exception as e:
-            print(f"\n❌ Error: {e}")
+            print(f"\n❌ Error with interactive menu: {e}")
+            print("🔄 Falling back to simple text input...")
             # Fall back to simple input method
             try:
+                print("\n📊 Available GPU Options:")
+                for i, gpu_type in enumerate(options, 1):
+                    specs = gpu_specs[gpu_type]
+                    print(f"  {i}. {gpu_type} ({specs['memory']})")
+                print(f"  Default: A10G")
+                
                 choice = input("\n🔍 Select GPU type (number or name, default is A10G): ").strip()
                 if not choice:
+                    print("✅ Using default GPU: A10G")
                     return "A10G"
                 if choice.isdigit():
                     index = int(choice) - 1
                     if 0 <= index < len(options):
-                        return options[index]
+                        selected = options[index]
+                        print(f"✅ Selected GPU: {selected}")
+                        return selected
+                    else:
+                        print(f"⚠️ Invalid number. Using default: A10G")
+                        return "A10G"
                 elif choice in options:
+                    print(f"✅ Selected GPU: {choice}")
                     return choice
-                return "A10G"
-            except:
+                else:
+                    print(f"⚠️ Invalid choice '{choice}'. Using default: A10G")
+                    return "A10G"
+            except KeyboardInterrupt:
+                print("\n🛑 Selection cancelled.")
+                sys.exit(1)
+            except Exception as fallback_error:
+                print(f"❌ Error in fallback input: {fallback_error}")
+                print("✅ Using default GPU: A10G")
                 return "A10G"
 
 # Replace the existing GPU argument parsing in the main section
@@ -2827,7 +3182,7 @@ if __name__ == "__main__":
     import sys
     
     parser = argparse.ArgumentParser()
-    parser.add_argument('--gpu', type=str, help='GPU type (e.g., A10G, T4, A100-80GB)')
+    parser.add_argument('--gpu', type=str, help='GPU type (e.g., A10G, T4, A100-80GB). If not provided, will prompt for GPU selection.')
     parser.add_argument('--repo-url', type=str, help='Repository URL to clone')
     parser.add_argument('--repo-name', type=str, help='Repository name override')
     parser.add_argument('--setup-commands', type=str, nargs='+', help='Setup commands to run (deprecated)')
@@ -2889,9 +3244,22 @@ if __name__ == "__main__":
     print("------------------------")
     print("\n✔ Dependencies checked")
     
-    # Always prompt for GPU selection regardless of interactive mode
-    gpu_type = prompt_for_gpu()
-    args.gpu = gpu_type
+    # Use provided GPU argument or prompt for selection
+    if args.gpu:
+        gpu_type = args.gpu
+        # Validate the provided GPU type
+        valid_gpus = ['T4', 'L4', 'A10G', 'A100-40', 'A100-80', 'L40S', 'H100', 'H200', 'B200']
+        if gpu_type not in valid_gpus:
+            print(f"⚠️ Warning: '{gpu_type}' is not in the list of known GPU types.")
+            print(f"Available GPU types: {', '.join(valid_gpus)}")
+            print(f"Proceeding with '{gpu_type}' anyway...")
+        else:
+            print(f"✅ Using specified GPU: {gpu_type}")
+    else:
+        print("\n📋 No GPU type specified with --gpu flag.")
+        print("🔄 Prompting for GPU selection...")
+        gpu_type = prompt_for_gpu()
+        args.gpu = gpu_type
     
     # Display configuration after GPU selection
     print("\n📋 Container Configuration:")