gitarsenal-cli 1.9.21 → 1.9.24

package/python/test_modalSandboxScript.py

@@ -42,2653 +42,51 @@ if args.proxy_url:
 if args.proxy_api_key:
     os.environ["MODAL_PROXY_API_KEY"] = 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):
-        self.working_dir = working_dir
-        self.timeout = timeout
-        self.process = None
-        self.stdout_lines = []  # Use list instead of queue
-        self.stderr_lines = []  # Use list instead of queue
-        self.stdout_lock = threading.Lock()
-        self.stderr_lock = threading.Lock()
-        self.stdout_thread = None
-        self.stderr_thread = None
-        self.command_counter = 0
-        self.is_running = False
-        self.virtual_env_path = None  # Track activated virtual environment
-        self.suggested_alternative = None  # Store suggested alternative commands
-        self.should_remove_command = False  # Flag to indicate if a command should be removed
-        self.removal_reason = None  # Reason for removing a command
-        
-    def start(self):
-        """Start the persistent bash shell."""
-        if self.is_running:
-            return
-            
-        print(f"🐚 Starting persistent bash shell in {self.working_dir}")
-        
-        # Start bash with unbuffered output
-        self.process = subprocess.Popen(
-            ['bash', '-i'],  # Interactive bash
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            bufsize=0,  # Unbuffered
-            cwd=self.working_dir,
-            preexec_fn=os.setsid  # Create new process group
-        )
-        
-        # Start threads to read stdout and stderr
-        self.stdout_thread = threading.Thread(target=self._read_stdout, daemon=True)
-        self.stderr_thread = threading.Thread(target=self._read_stderr, daemon=True)
-        
-        self.stdout_thread.start()
-        self.stderr_thread.start()
-        
-        self.is_running = True
-        
-        # Initial setup commands
-        self._send_command_raw("set +h")  # Disable hash table for commands
-        self._send_command_raw("export PS1='$ '")  # Simpler prompt
-        self._send_command_raw("cd " + self.working_dir)  # Change to working directory
-        time.sleep(0.5)  # Let initial commands settle
-        
-        
-    def _read_stdout(self):
-        """Read stdout in a separate thread."""
-        while self.process and self.process.poll() is None:
-            try:
-                line = self.process.stdout.readline()
-                if line:
-                    with self.stdout_lock:
-                        self.stdout_lines.append(line.rstrip('\n'))
-                else:
-                    time.sleep(0.01)
-            except Exception as e:
-                print(f"Error reading stdout: {e}")
-                break
-                
-    def _read_stderr(self):
-        """Read stderr in a separate thread."""
-        while self.process and self.process.poll() is None:
-            try:
-                line = self.process.stderr.readline()
-                if line:
-                    with self.stderr_lock:
-                        self.stderr_lines.append(line.rstrip('\n'))
-                else:
-                    time.sleep(0.01)
-            except Exception as e:
-                print(f"Error reading stderr: {e}")
-                break
-    
-    def _send_command_raw(self, command):
-        """Send a raw command to the shell without waiting for completion."""
-        if not self.is_running or not self.process:
-            raise RuntimeError("Shell is not running")
-            
-        try:
-            self.process.stdin.write(command + '\n')
-            self.process.stdin.flush()
-        except Exception as e:
-            print(f"Error sending command: {e}")
-            raise
-    
-    def _preprocess_command(self, command):
-        """Preprocess commands to handle special cases like virtual environment activation."""
-        # Handle virtual environment creation and activation
-        if "uv venv" in command and "&&" in command and "source" in command:
-            # Split the compound command into separate parts
-            parts = [part.strip() for part in command.split("&&")]
-            return parts
-        elif command.strip().startswith("source ") and "/bin/activate" in command:
-            # Handle standalone source command
-            venv_path = command.replace("source ", "").replace("/bin/activate", "").strip()
-            self.virtual_env_path = venv_path
-            return [command]
-        elif "source" in command and "activate" in command:
-            # Handle any other source activation pattern
-            return [command]
-        elif "uv pip install" in command and self.is_in_venv():
-            # If we're in a virtual environment, ensure we use the right pip
-            return [command]
-        else:
-            return [command]
-    
-    def execute(self, command, timeout=None):
-        """Execute a command and return (success, stdout, stderr)."""
-        if not self.is_running:
-            self.start()
-            
-        if timeout is None:
-            timeout = self.timeout
-        
-        # Preprocess the command to handle special cases
-        command_parts = self._preprocess_command(command)
-        
-        # If we have multiple parts, execute them sequentially
-        if len(command_parts) > 1:
-            print(f"🔧 Executing compound command in {len(command_parts)} parts")
-            all_stdout = []
-            all_stderr = []
-            
-            for i, part in enumerate(command_parts):
-                print(f"   Part {i+1}/{len(command_parts)}: {part}")
-                success, stdout, stderr = self._execute_single(part, timeout)
-                
-                if stdout:
-                    all_stdout.append(stdout)
-                if stderr:
-                    all_stderr.append(stderr)
-                
-                if not success:
-                    # If any part fails, return the failure
-                    return False, '\n'.join(all_stdout), '\n'.join(all_stderr)
-                
-                # Small delay between parts to let environment changes take effect
-                time.sleep(0.1)
-            
-            return True, '\n'.join(all_stdout), '\n'.join(all_stderr)
-        else:
-            return self._execute_single(command_parts[0], timeout)
-    
-    def _execute_single(self, command, timeout):
-        """Execute a single command and return (success, stdout, stderr)."""
-        self.command_counter += 1
-        marker = f"CMD_DONE_{self.command_counter}_{uuid.uuid4().hex[:8]}"
-        
-        print(f"🔧 Executing: {command}")
-        
-        # Clear any existing output
-        self._clear_lines()
-        
-        # Wait for shell to be ready (prompt should be visible)
-        if not self.wait_for_prompt(timeout=2):
-            # print("⚠️ Shell not ready, waiting...")
-            time.sleep(0.5)
-        
-        # For source commands, we need special handling
-        if command.strip().startswith("source "):
-            # Send the source command in a way that preserves the environment
-            try:
-                # Extract the virtual environment path
-                venv_path = command.replace("source ", "").replace("/bin/activate", "").strip()
-                
-                # Use a more robust approach that actually activates the environment
-                activation_script = f"""
-                if [ -f "{venv_path}/bin/activate" ]; then
-                    source "{venv_path}/bin/activate"
-                    echo "VIRTUAL_ENV=$VIRTUAL_ENV"
-                    echo "PATH=$PATH"
-                    echo 'SOURCE_SUCCESS'
-                else
-                    echo 'SOURCE_FAILED - activation script not found'
-                fi
-                """
-                
-                self._send_command_raw(activation_script)
-                time.sleep(0.3)  # Give more time for environment changes
-                self._send_command_raw(f'echo "EXIT_CODE:$?"')
-                self._send_command_raw(f'echo "{marker}"')
-            except Exception as e:
-                return False, "", f"Failed to send source command: {e}"
-        else:
-            # Send the command followed by markers
-            try:
-                self._send_command_raw(command)
-                # Wait a moment for the command to start
-                time.sleep(0.1)
-                self._send_command_raw(f'echo "EXIT_CODE:$?"')
-                self._send_command_raw(f'echo "{marker}"')
-            except Exception as e:
-                return False, "", f"Failed to send command: {e}"
-        
-        # Collect output until we see the marker
-        command_stdout = []
-        command_stderr = []
-        start_time = time.time()
-        found_marker = False
-        exit_code = None
-        last_stdout_index = 0
-        last_stderr_index = 0
-        source_success = None
-        
-        while time.time() - start_time < timeout:
-            # Check for new stdout lines
-            with self.stdout_lock:
-                current_stdout = self.stdout_lines[last_stdout_index:]
-                last_stdout_index = len(self.stdout_lines)
-            
-            for line in current_stdout:
-                if line == marker:
-                    found_marker = True
-                    break
-                elif line.startswith("EXIT_CODE:"):
-                    try:
-                        exit_code = int(line.split(":", 1)[1])
-                    except (ValueError, IndexError):
-                        exit_code = 1
-                elif line == "SOURCE_SUCCESS":
-                    source_success = True
-                elif line.startswith("SOURCE_FAILED"):
-                    source_success = False
-                    command_stderr.append(line)
-                elif line.startswith("VIRTUAL_ENV="):
-                    # Extract and store the virtual environment path
-                    venv_path = line.split("=", 1)[1]
-                    self.virtual_env_path = venv_path
-                    command_stdout.append(line)
-                elif line.startswith("PATH="):
-                    # Store the updated PATH
-                    command_stdout.append(line)
-                elif line.strip() and not line.startswith("$"):  # Skip empty lines and prompt lines
-                    command_stdout.append(line)
-            
-            if found_marker:
-                break
-            
-            # Check for new stderr lines
-            with self.stderr_lock:
-                current_stderr = self.stderr_lines[last_stderr_index:]
-                last_stderr_index = len(self.stderr_lines)
-            
-            for line in current_stderr:
-                if line.strip():  # Skip empty lines
-                    command_stderr.append(line)
-            
-            # Check if command is waiting for user input
-            if not found_marker and time.time() - start_time > 5:  # Wait at least 5 seconds before checking
-                if self._is_waiting_for_input(command_stdout, command_stderr):
-                    print("⚠️ Command appears to be waiting for user input")
-                    # Try to handle the input requirement
-                    input_handled = self._handle_input_requirement(command, command_stdout, command_stderr)
-                    
-                    if input_handled is True and self.should_remove_command:
-                        # If LLM suggested to remove the command
-                        self._send_command_raw("\x03")  # Send Ctrl+C
-                        time.sleep(0.5)
-                        return False, '\n'.join(command_stdout), f"Command removed - {self.removal_reason}"
-                    elif not input_handled:
-                        # If we couldn't handle the input, abort the command
-                        self._send_command_raw("\x03")  # Send Ctrl+C
-                        time.sleep(0.5)
-                        return False, '\n'.join(command_stdout), "Command aborted - requires user input"
-            
-            time.sleep(0.1)
-        
-        if not found_marker:
-            print(f"⚠️ Command timed out after {timeout} seconds")
-            return False, '\n'.join(command_stdout), f"Command timed out after {timeout} seconds"
-        
-        stdout_text = '\n'.join(command_stdout)
-        stderr_text = '\n'.join(command_stderr)
-        
-        # Determine success based on multiple factors
-        if source_success is not None:
-            success = source_success
-        else:
-            success = exit_code == 0 if exit_code is not None else len(command_stderr) == 0
-        
-        if success:
-            if stdout_text:
-                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}")
-        else:
-            print(f"❌ Command failed with exit code: {exit_code}")
-            if stderr_text:
-                print(f"❌ Error: {stderr_text}")
-        
-        # Wait a moment for the shell to be ready for the next command
-        time.sleep(0.2)
-        
-        return success, stdout_text, stderr_text
-    
-    def _is_waiting_for_input(self, stdout_lines, stderr_lines):
-        """Detect if a command is waiting for user input."""
-        # Common patterns that indicate waiting for user input
-        input_patterns = [
-            r'(?i)(y/n|yes/no)\??\s*$',  # Yes/No prompts
-            r'(?i)password:?\s*$',        # Password prompts
-            r'(?i)continue\??\s*$',       # Continue prompts
-            r'(?i)proceed\??\s*$',        # Proceed prompts
-            r'\[\s*[Yy]/[Nn]\s*\]\s*$',   # [Y/n] style prompts
-            r'(?i)username:?\s*$',        # Username prompts
-            r'(?i)token:?\s*$',           # Token prompts
-            r'(?i)api key:?\s*$',         # API key prompts
-            r'(?i)press enter to continue', # Press enter prompts
-            r'(?i)select an option:?\s*$', # Selection prompts
-            r'(?i)choose an option:?\s*$', # Choice prompts
-        ]
-        
-        # Check the last few lines of stdout and stderr for input patterns
-        last_lines = []
-        if stdout_lines:
-            last_lines.extend(stdout_lines[-3:])  # Check last 3 lines of stdout
-        if stderr_lines:
-            last_lines.extend(stderr_lines[-3:])  # Check last 3 lines of stderr
-        
-        for line in last_lines:
-            for pattern in input_patterns:
-                if re.search(pattern, line):
-                    print(f"🔍 Detected input prompt: {line}")
-                    return True
-                
-        # Check if there's no output for a while but the command is still running
-        if len(stdout_lines) == 0 and len(stderr_lines) == 0:
-            # This might be a command waiting for input without a prompt
-            # We'll be cautious and only return True if we're sure
-            return False
-            
-        return False
-        
-    def _handle_input_requirement(self, command, stdout_lines, stderr_lines):
-        """Attempt to handle commands that require input."""
-        # Extract the last few lines to analyze what kind of input is needed
-        last_lines = []
-        if stdout_lines:
-            last_lines.extend(stdout_lines[-3:])
-        if stderr_lines:
-            last_lines.extend(stderr_lines[-3:])
-        
-        last_line = last_lines[-1] if last_lines else ""
-        
-        # Try to determine what kind of input is needed
-        if re.search(r'(?i)(y/n|yes/no|\[y/n\])', last_line):
-            # For yes/no prompts, usually 'yes' is safer
-            print("🔧 Auto-responding with 'y' to yes/no prompt")
-            self._send_command_raw("y")
-            return True
-            
-        elif re.search(r'(?i)password', last_line):
-            # For password prompts, check if we have stored credentials
-            stored_creds = get_stored_credentials()
-            if stored_creds and 'ssh_password' in stored_creds:
-                print("🔧 Auto-responding with stored SSH password")
-                self._send_command_raw(stored_creds['ssh_password'])
-                return True
-            else:
-                print("⚠️ Password prompt detected but no stored password available")
-                return False
-                
-        elif re.search(r'(?i)token|api.key', last_line):
-            # For token/API key prompts
-            stored_creds = get_stored_credentials()
-            if stored_creds:
-                if 'openai_api_key' in stored_creds and re.search(r'(?i)openai|api.key', last_line):
-                    print("🔧 Auto-responding with stored OpenAI API key")
-                    self._send_command_raw(stored_creds['openai_api_key'])
-                    return True
-                elif 'hf_token' in stored_creds and re.search(r'(?i)hugg|hf|token', last_line):
-                    print("🔧 Auto-responding with stored Hugging Face token")
-                    self._send_command_raw(stored_creds['hf_token'])
-                    return True
-            
-            print("⚠️ Token/API key prompt detected but no matching stored credentials")
-            return False
-            
-        elif re.search(r'(?i)press enter|continue|proceed', last_line):
-            # For "press enter to continue" prompts
-            print("🔧 Auto-responding with Enter to continue")
-            self._send_command_raw("")  # Empty string sends just Enter
-            return True
-            
-        # If we can't determine the type of input needed
-        print("⚠️ Couldn't determine the type of input needed")
-        
-        # Try to use LLM to suggest an alternative command
-        try:
-            # Get current working directory for context
-            cwd = self.get_cwd()
-            
-            # Reset command removal flags
-            self.should_remove_command = False
-            self.removal_reason = None
-            
-            # Call LLM to suggest an alternative
-            alternative = self._suggest_alternative_command(command, stdout_lines, stderr_lines, cwd)
-            
-            # Check if LLM suggested to remove the command
-            if self.should_remove_command:
-                print(f"🚫 Command will be removed: {self.removal_reason}")
-                return True  # Return True to indicate the command has been handled (by removing it)
-            
-            if alternative:
-                print(f"🔧 LLM suggested alternative command: {alternative}")
-                # We don't execute the alternative here, but return False so the calling code
-                # can handle it (e.g., by adding it to the command list)
-                
-                # Store the suggested alternative for later use
-                self.suggested_alternative = alternative
-                return False
-        except Exception as e:
-            print(f"⚠️ Error getting LLM suggestion: {e}")
-        
-        return False
-        
-    def _suggest_alternative_command(self, command, stdout_lines, stderr_lines, current_dir):
-        """Use LLM to suggest an alternative command that doesn't require user input."""
-        try:
-            # Get API key
-            api_key = os.environ.get("OPENAI_API_KEY")
-            if not api_key:
-                # Try to load from saved file
-                key_file = os.path.expanduser("~/.gitarsenal/openai_key")
-                if os.path.exists(key_file):
-                    with open(key_file, "r") as f:
-                        api_key = f.read().strip()
-            
-            if not api_key:
-                print("⚠️ No OpenAI API key available for suggesting alternative command")
-                return None
-                
-            # Prepare the prompt
-            stdout_text = '\n'.join(stdout_lines[-10:]) if stdout_lines else ""
-            stderr_text = '\n'.join(stderr_lines[-10:]) if stderr_lines else ""
-            
-            prompt = f"""
-            The command '{command}' appears to be waiting for user input.
-            
-            Current directory: {current_dir}
-            
-            Last stdout output:
-            {stdout_text}
-            
-            Last stderr output:
-            {stderr_text}
-            
-            Please analyze this command and determine if it's useful to continue with it.
-            If it's useful, suggest an alternative command that achieves the same goal but doesn't require user input.
-            For example, add flags like -y, --yes, --no-input, etc., or provide the required input in the command.
-            
-            If the command is not useful or cannot be executed non-interactively, respond with "REMOVE_COMMAND" and explain why.
-            
-            Format your response as:
-            ALTERNATIVE: <alternative command>
-            or
-            REMOVE_COMMAND: <reason>
-            """
-            
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
-            
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that suggests alternative commands that don't require user input."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=150,
-                temperature=0.7
-            )
-            
-            response_text = response.choices[0].message.content.strip()
-            
-            # Check if the response suggests removing the command
-            if response_text.startswith("REMOVE_COMMAND:"):
-                reason = response_text.replace("REMOVE_COMMAND:", "").strip()
-                print(f"🚫 LLM suggests removing command: {reason}")
-                self.should_remove_command = True
-                self.removal_reason = reason
-                return None
-            
-            # Extract the alternative command
-            if response_text.startswith("ALTERNATIVE:"):
-                alternative_command = response_text.replace("ALTERNATIVE:", "").strip()
-            else:
-                # Try to extract the command from a free-form response
-                lines = response_text.split('\n')
-                for line in lines:
-                    line = line.strip()
-                    if line and not line.startswith(('Here', 'I', 'You', 'The', 'This', 'Use', 'Try')):
-                        alternative_command = line
-                        break
-                else:
-                    alternative_command = lines[0].strip()
-            
-            return alternative_command
-            
-        except Exception as e:
-            print(f"⚠️ Error suggesting alternative command: {e}")
-            return None
-    
-    def _clear_lines(self):
-        """Clear both output line lists."""
-        with self.stdout_lock:
-            self.stdout_lines.clear()
-        with self.stderr_lock:
-            self.stderr_lines.clear()
-    
-    def get_cwd(self):
-        """Get current working directory."""
-        success, output, _ = self._execute_single("pwd", 10)
-        if success:
-            return output.strip()
-        return self.working_dir
-    
-    def get_virtual_env(self):
-        """Get the currently activated virtual environment path."""
-        return self.virtual_env_path
-    
-    def is_in_venv(self):
-        """Check if we're currently in a virtual environment."""
-        return self.virtual_env_path is not None and self.virtual_env_path != ""
-    
-    def get_venv_name(self):
-        """Get the name of the current virtual environment if active."""
-        if self.is_in_venv():
-            return os.path.basename(self.virtual_env_path)
-        return None
-    
-    def exec(self, *args, **kwargs):
-        """Compatibility method to make PersistentShell work with call_openai_for_debug."""
-        # Convert exec call to execute method
-        if len(args) >= 2 and args[0] == "bash" and args[1] == "-c":
-            command = args[2]
-            success, stdout, stderr = self.execute(command)
-            
-            # Create a mock result object that mimics the expected interface
-            class MockResult:
-                def __init__(self, stdout, stderr, returncode):
-                    self.stdout = [stdout] if stdout else []
-                    self.stderr = [stderr] if stderr else []
-                    self.returncode = 0 if returncode else 1
-                
-                def wait(self):
-                    pass
-            
-            return MockResult(stdout, stderr, success)
-        else:
-            raise NotImplementedError("exec method only supports bash -c commands")
-    
-    def wait_for_prompt(self, timeout=5):
-        """Wait for the shell prompt to appear, indicating readiness for next command."""
-        start_time = time.time()
-        while time.time() - start_time < timeout:
-            with self.stdout_lock:
-                if self.stdout_lines and self.stdout_lines[-1].strip().endswith('$'):
-                    return True
-            time.sleep(0.1)
-        return False
-    
-    def cleanup(self):
-        """Clean up the shell process."""
-        print("🧹 Cleaning up persistent shell...")
-        self.is_running = False
-        
-        if self.process:
-            try:
-                # Send exit command
-                self._send_command_raw("exit")
-                
-                # Wait for process to terminate
-                try:
-                    self.process.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    # Force kill if it doesn't exit gracefully
-                    os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
-                    try:
-                        self.process.wait(timeout=2)
-                    except subprocess.TimeoutExpired:
-                        os.killpg(os.getpgid(self.process.pid), signal.SIGKILL)
-                        
-            except Exception as e:
-                print(f"Error during cleanup: {e}")
-            finally:
-                self.process = None
-        
-        print("✅ Shell cleanup completed")
-
-
-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
-        }
-        
-        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
-                })
-                
-                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")
-                
-                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
-                })
-                
-                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 unified batch debugging for efficiency
-        fixes = call_llm_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
-    
-    def should_skip_original_command(self, original_command, fix_command, fix_stdout, fix_stderr, api_key=None):
-        """
-        Use LLM to determine if the original command should be skipped after a successful fix.
-        
-        Args:
-            original_command: The original command that failed
-            fix_command: The fix command that succeeded
-            fix_stdout: The stdout from the fix command
-            fix_stderr: The stderr from the fix command
-            api_key: OpenAI API key
-            
-        Returns:
-            tuple: (should_skip, reason)
-        """
-        try:
-            # Get API key if not provided
-            if not api_key:
-                api_key = os.environ.get("OPENAI_API_KEY")
-                if not api_key:
-                    # Try to load from saved file
-                    key_file = os.path.expanduser("~/.gitarsenal/openai_key")
-                    if os.path.exists(key_file):
-                        with open(key_file, "r") as f:
-                            api_key = f.read().strip()
-            
-            if not api_key:
-                print("⚠️ No OpenAI API key available for command list analysis")
-                return False, "No API key available"
-            
-            # Get all commands for context
-            all_commands = self.get_all_commands()
-            commands_context = "\n".join([f"{i+1}. {cmd['command']} - {cmd['status']}" for i, cmd in enumerate(all_commands)])
-            
-            # Prepare the prompt
-            prompt = f"""
-            I need to determine if an original command should be skipped after a successful fix command.
-            
-            Original command (failed): {original_command}
-            Fix command (succeeded): {fix_command}
-            
-            Fix command stdout:
-            {fix_stdout}
-            
-            Fix command stderr:
-            {fix_stderr}
-            
-            Current command list:
-            {commands_context}
-            
-            Based on this information, should I skip running the original command again?
-            Consider:
-            1. If the fix command already accomplished what the original command was trying to do
-            2. If running the original command again would be redundant or cause errors
-            3. If the original command is still necessary after the fix
-            
-            Respond with ONLY:
-            SKIP: <reason>
-            or
-            RUN: <reason>
-            """
-            
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing if original command should be skipped...")
-            
-            response = client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes command execution."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=100,
-                temperature=0.3
-            )
-            
-            response_text = response.choices[0].message.content.strip()
-            
-            # Parse the response
-            if response_text.startswith("SKIP:"):
-                reason = response_text.replace("SKIP:", "").strip()
-                print(f"🔍 LLM suggests skipping original command: {reason}")
-                return True, reason
-            elif response_text.startswith("RUN:"):
-                reason = response_text.replace("RUN:", "").strip()
-                print(f"🔍 LLM suggests running original command: {reason}")
-                return False, reason
-            else:
-                # Try to interpret a free-form response
-                if "skip" in response_text.lower() and "should" in response_text.lower():
-                    print(f"🔍 Interpreting response as SKIP: {response_text}")
-                    return True, response_text
-                else:
-                    print(f"🔍 Interpreting response as RUN: {response_text}")
-                    return False, response_text
-                
-        except Exception as e:
-            print(f"⚠️ Error analyzing command skip decision: {e}")
-            return False, f"Error: {e}"
-    
-    def replace_command(self, command_index, new_command, reason=""):
-        """
-        Replace a command in the list with a new command.
-        
-        Args:
-            command_index: The index of the command to replace
-            new_command: The new command to use
-            reason: The reason for the replacement
-            
-        Returns:
-            bool: True if the command was replaced, False otherwise
-        """
-        if 0 <= command_index < len(self.commands):
-            old_command = self.commands[command_index]['command']
-            self.commands[command_index]['command'] = new_command
-            self.commands[command_index]['status'] = 'pending'  # Reset status
-            self.commands[command_index]['stdout'] = ''
-            self.commands[command_index]['stderr'] = ''
-            self.commands[command_index]['execution_time'] = None
-            self.commands[command_index]['replacement_reason'] = reason
-            
-            print(f"🔄 Replaced command {command_index + 1}: '{old_command}' with '{new_command}'")
-            print(f"🔍 Reason: {reason}")
-            return True
-        else:
-            print(f"❌ Invalid command index for replacement: {command_index}")
-            return False
-    
-    def update_command_list_with_llm(self, api_key=None):
-        """
-        Use LLM to analyze and update the entire command list.
-        
-        Args:
-            api_key: OpenAI API key
-            
-        Returns:
-            bool: True if the list was updated, False otherwise
-        """
-        try:
-            # Get API key if not provided
-            if not api_key:
-                api_key = os.environ.get("OPENAI_API_KEY")
-                if not api_key:
-                    # Try to load from saved file
-                    key_file = os.path.expanduser("~/.gitarsenal/openai_key")
-                    if os.path.exists(key_file):
-                        with open(key_file, "r") as f:
-                            api_key = f.read().strip()
-            
-            if not api_key:
-                print("⚠️ No OpenAI API key available for command list analysis")
-                return False
-            
-            # Get all commands for context
-            all_commands = self.get_all_commands()
-            commands_context = "\n".join([f"{i+1}. {cmd['command']} - {cmd['status']}" 
-                                         for i, cmd in enumerate(all_commands)])
-            
-            # Get executed commands with their outputs for context
-            executed_context = ""
-            for cmd in self.executed_commands:
-                executed_context += f"Command: {cmd['command']}\n"
-                executed_context += f"Status: {cmd['status']}\n"
-                if cmd['stdout']:
-                    executed_context += f"Stdout: {cmd['stdout'][:500]}...\n" if len(cmd['stdout']) > 500 else f"Stdout: {cmd['stdout']}\n"
-                if cmd['stderr']:
-                    executed_context += f"Stderr: {cmd['stderr'][:500]}...\n" if len(cmd['stderr']) > 500 else f"Stderr: {cmd['stderr']}\n"
-                executed_context += "\n"
-            
-            # Prepare the prompt
-            prompt = f"""
-            I need you to analyze and optimize this command list. Some commands have been executed, 
-            and some are still pending. Based on what has already been executed, I need you to:
-            
-            1. Identify any pending commands that are now redundant or unnecessary
-            2. Identify any pending commands that should be modified based on previous command results
-            3. Suggest any new commands that should be added
-            
-            Current command list:
-            {commands_context}
-            
-            Details of executed commands:
-            {executed_context}
-            
-            For each pending command (starting from the next command to be executed), tell me if it should be:
-            1. KEEP: Keep the command as is
-            2. SKIP: Skip the command (mark as completed without running)
-            3. MODIFY: Modify the command (provide the new command)
-            4. ADD_AFTER: Add a new command after this one
-            
-            Format your response as a JSON array of actions:
-            [
-                {{
-                    "command_index": <index>,
-                    "action": "KEEP|SKIP|MODIFY|ADD_AFTER",
-                    "new_command": "<new command if MODIFY or ADD_AFTER>",
-                    "reason": "<reason for this action>"
-                }},
-                ...
-            ]
-            
-            Only include commands that need changes (SKIP, MODIFY, ADD_AFTER), not KEEP actions.
-            """
-            
-            # Call OpenAI API
-            import openai
-            import json
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing command list for optimizations...")
-            
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",  # Use a more capable model for this complex task
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes and optimizes command lists."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=1000,
-                temperature=0.2
-            )
-            
-            response_text = response.choices[0].message.content.strip()
-            
-            # Extract JSON from the response
-            try:
-                # Find JSON array in the response
-                json_match = re.search(r'\[\s*\{.*\}\s*\]', response_text, re.DOTALL)
-                if json_match:
-                    json_str = json_match.group(0)
-                    actions = json.loads(json_str)
-                else:
-                    # Try to parse the entire response as JSON
-                    actions = json.loads(response_text)
-                
-                if not isinstance(actions, list):
-                    print("❌ Invalid response format from LLM - not a list")
-                    return False
-                
-                # Apply the suggested changes
-                changes_made = 0
-                commands_added = 0
-                
-                # Process in reverse order to avoid index shifting issues
-                for action in sorted(actions, key=lambda x: x.get('command_index', 0), reverse=True):
-                    cmd_idx = action.get('command_index')
-                    action_type = action.get('action')
-                    new_cmd = action.get('new_command', '')
-                    reason = action.get('reason', 'No reason provided')
-                    
-                    if cmd_idx is None or action_type is None:
-                        continue
-                    
-                    # Convert to 0-based index if needed
-                    if cmd_idx > 0:  # Assume 1-based index from LLM
-                        cmd_idx -= 1
-                    
-                    # Skip if the command index is invalid
-                    if cmd_idx < 0 or cmd_idx >= len(self.commands):
-                        print(f"❌ Invalid command index: {cmd_idx}")
-                        continue
-                    
-                    # Skip if the command has already been executed
-                    if self.commands[cmd_idx]['status'] != 'pending':
-                        print(f"⚠️ Command {cmd_idx + 1} already executed, skipping action")
-                        continue
-                    
-                    if action_type == "SKIP":
-                        # Mark the command as successful without running it
-                        self.mark_command_executed(
-                            cmd_idx, 'main', True, 
-                            f"Command skipped: {reason}", 
-                            "", 0
-                        )
-                        print(f"🔄 Skipped command {cmd_idx + 1}: {reason}")
-                        changes_made += 1
-                    
-                    elif action_type == "MODIFY":
-                        if new_cmd:
-                            if self.replace_command(cmd_idx, new_cmd, reason):
-                                changes_made += 1
-                        else:
-                            print(f"❌ No new command provided for MODIFY action on command {cmd_idx + 1}")
-                    
-                    elif action_type == "ADD_AFTER":
-                        if new_cmd:
-                            # Add new command after the current one
-                            insert_idx = cmd_idx + 1
-                            new_cmd_obj = {
-                                'command': new_cmd,
-                                'status': 'pending',
-                                'index': insert_idx,
-                                'stdout': '',
-                                'stderr': '',
-                                'execution_time': None,
-                                'fix_attempts': 0,
-                                'max_fix_attempts': 3,
-                                'added_reason': reason
-                            }
-                            
-                            # Insert the new command
-                            self.commands.insert(insert_idx, new_cmd_obj)
-                            
-                            # Update indices for all commands after insertion
-                            for i in range(insert_idx + 1, len(self.commands)):
-                                self.commands[i]['index'] = i
-                            
-                            print(f"➕ Added new command after {cmd_idx + 1}: '{new_cmd}'")
-                            print(f"🔍 Reason: {reason}")
-                            commands_added += 1
-                        else:
-                            print(f"❌ No new command provided for ADD_AFTER action on command {cmd_idx + 1}")
-                
-                # Update total commands count
-                self.total_commands = len(self.commands)
-                
-                print(f"✅ Command list updated: {changes_made} changes made, {commands_added} commands added")
-                return changes_made > 0 or commands_added > 0
-                
-            except json.JSONDecodeError as e:
-                print(f"❌ Failed to parse LLM response as JSON: {e}")
-                print(f"Raw response: {response_text}")
-                return False
-            except Exception as e:
-                print(f"❌ Error updating command list: {e}")
-                return False
-                
-        except Exception as e:
-            print(f"⚠️ Error analyzing command list: {e}")
-            return False
-
-
-# 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 get_stored_credentials():
-    """Load stored credentials from ~/.gitarsenal/credentials.json"""
-    import json
-    from pathlib import Path
-    
-    try:
-        credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
-        if credentials_file.exists():
-            with open(credentials_file, 'r') as f:
-                credentials = json.load(f)
-            return credentials
-        else:
-            return {}
-    except Exception as e:
-        print(f"⚠️ Error loading stored credentials: {e}")
-        return {}
-
-def generate_auth_context(stored_credentials):
-    """Generate simple authentication context for the OpenAI prompt"""
-    if not stored_credentials:
-        return "No stored credentials available."
-    
-    auth_context = "Available stored credentials (use actual values in commands):\n"
-    
-    for key, value in stored_credentials.items():
-        # Mask the actual value for security in logs, but provide the real value
-        masked_value = value[:8] + "..." if len(value) > 8 else "***"
-        auth_context += f"- {key}: {masked_value} (actual value: {value})\n"
-    
-    return auth_context
-
-def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
-    """Call OpenAI to debug a failed command and suggest a fix"""
-    print("\n🔍 DEBUG: Starting LLM debugging...")
-    print(f"🔍 DEBUG: Command: {command}")
-    print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
-    print(f"🔍 DEBUG: Current directory: {current_dir}")
-    print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
-    
-    # Define _to_str function locally to avoid NameError
-    def _to_str(maybe_bytes):
-        try:
-            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
-        except UnicodeDecodeError:
-            # Handle non-UTF-8 bytes by replacing invalid characters
-            if isinstance(maybe_bytes, (bytes, bytearray)):
-                return maybe_bytes.decode('utf-8', errors='replace')
-            else:
-                return str(maybe_bytes)
-        except Exception:
-            # Last resort fallback
-            return str(maybe_bytes)
-            
-    # Skip debugging for certain commands that commonly return non-zero exit codes
-    # but aren't actually errors (like test commands)
-    if command.strip().startswith("test "):
-        print("🔍 Skipping debugging for test command - non-zero exit code is expected behavior")
-        return None
-        
-    # Validate error_output - if it's empty, we can't debug effectively
-    if not error_output or not error_output.strip():
-        print("⚠️ Error output is empty. Cannot effectively debug the command.")
-        print("⚠️ Skipping OpenAI debugging due to lack of error information.")
-        return None
-    
-    # Try to get API key from multiple sources
-    if not api_key:
-        print("🔍 DEBUG: No API key provided, searching for one...")
-        
-        # First try environment variable
-        api_key = os.environ.get("OPENAI_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
-        
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                _, _, api_key, _ = get_tokens()
-                if api_key:
-                    # Set in environment for this session
-                    os.environ["OPENAI_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch OpenAI API key from server")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from server: {e}")
-        
-        # Store the API key in a persistent file if found
-        if api_key:
-            try:
-                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
-                with open(os.path.expanduser("~/.gitarsenal/openai_key"), "w") as f:
-                    f.write(api_key)
-                print("✅ Saved OpenAI API key for future use")
-            except Exception as e:
-                print(f"⚠️ Could not save API key: {e}")
-        
-        # Try to load from saved file if not in environment
-        if not api_key:
-            try:
-                key_file = os.path.expanduser("~/.gitarsenal/openai_key")
-                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
-                if os.path.exists(key_file):
-                    with open(key_file, "r") as f:
-                        api_key = f.read().strip()
-                    if api_key:
-                        print("✅ Loaded OpenAI API key from saved file")
-                        print(f"🔍 DEBUG: API key from file: {api_key}")
-                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
-                        # Also set in environment for this session
-                        os.environ["OPENAI_API_KEY"] = api_key
-                    else:
-                        print("🔍 DEBUG: Saved file exists but is empty")
-                else:
-                    print("🔍 DEBUG: No saved API key file found")
-            except Exception as e:
-                print(f"⚠️ Could not load saved API key: {e}")
-        
-        # Then try credentials manager
-        if not api_key:
-            print("🔍 DEBUG: Trying credentials manager...")
-            try:
-                from credentials_manager import CredentialsManager
-                credentials_manager = CredentialsManager()
-                api_key = credentials_manager.get_openai_api_key()
-                if api_key:
-                    print(f"🔍 DEBUG: API key from credentials manager: Found")
-                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
-                    # Set in environment for this session
-                    os.environ["OPENAI_API_KEY"] = api_key
-                else:
-                    print(f"🔍 DEBUG: API key from credentials manager: Not found")
-            except ImportError as e:
-                print(f"🔍 DEBUG: Credentials manager not available: {e}")
-                # Fall back to direct input if credentials_manager is not available
-                pass
-        
-        # Finally, prompt the user if still no API key
-        if not api_key:
-            print("🔍 DEBUG: No API key found in any source, prompting user...")
-            print("\n" + "="*60)
-            print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
-            print("="*60)
-            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!")
-                print(f"🔍 DEBUG: User-provided API key: {api_key}")
-                # Save the API key to environment for future use in this session
-                os.environ["OPENAI_API_KEY"] = api_key
-            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
-    
-    # If we still don't have an API key, we can't proceed
-    if not api_key:
-        print("❌ No OpenAI API key available. Cannot perform LLM debugging.")
-        print("💡 To enable LLM debugging, set the OPENAI_API_KEY environment variable")
-        return None
-    
-    # print(f"✅ OpenAI API key available (length: {len(api_key)})")
-    
-    # Gather additional context to help with debugging
-    directory_context = ""
-    system_info = ""
-    command_history = ""
-    file_context = ""
-    
-    if sandbox:
-        try:
-            print("🔍 Getting system information for better debugging...")
-            
-            # Get OS information
-            os_info_cmd = """
-            echo "OS Information:"
-            cat /etc/os-release 2>/dev/null || echo "OS release info not available"
-            echo -e "\nKernel Information:"
-            uname -a
-            echo -e "\nPython Information:"
-            python --version
-            pip --version
-            echo -e "\nPackage Manager:"
-            which apt 2>/dev/null && echo "apt available" || echo "apt not available"
-            which yum 2>/dev/null && echo "yum available" || echo "yum not available"
-            which dnf 2>/dev/null && echo "dnf available" || echo "dnf not available"
-            which apk 2>/dev/null && echo "apk available" || echo "apk not available"
-            echo -e "\nEnvironment Variables:"
-            env | grep -E "^(PATH|PYTHON|VIRTUAL_ENV|HOME|USER|SHELL|LANG)" || echo "No relevant env vars found"
-            """
-            
-            os_result = sandbox.exec("bash", "-c", os_info_cmd)
-            os_output = ""
-            for line in os_result.stdout:
-                os_output += _to_str(line)
-            os_result.wait()
-            
-            system_info = f"""
-System Information:
-{os_output}
-"""
-            print("✅ System information gathered successfully")
-        except Exception as e:
-            print(f"⚠️ Error getting system information: {e}")
-            system_info = "System information not available\n"
-    
-    if current_dir and sandbox:
-        try:
-            # print("🔍 Getting directory context for better debugging...")
-            
-            # Get current directory contents
-            ls_result = sandbox.exec("bash", "-c", "ls -la")
-            ls_output = ""
-            for line in ls_result.stdout:
-                ls_output += _to_str(line)
-            ls_result.wait()
-            
-            # Get parent directory contents
-            parent_result = sandbox.exec("bash", "-c", "ls -la ../")
-            parent_ls = ""
-            for line in parent_result.stdout:
-                parent_ls += _to_str(line)
-            parent_result.wait()
-                
-            directory_context = f"""
-Current directory contents:
-{ls_output}
-
-Parent directory contents:
-{parent_ls}
-"""
-            print("✅ Directory context gathered successfully")
-            
-            # Check for relevant files that might provide additional context
-            # For example, if error mentions a specific file, try to get its content
-            relevant_files = []
-            error_files = re.findall(r'(?:No such file or directory|cannot open|not found): ([^\s:]+)', error_output)
-            if error_files:
-                for file_path in error_files:
-                    # Clean up the file path
-                    file_path = file_path.strip("'\"")
-                    if not os.path.isabs(file_path):
-                        file_path = os.path.join(current_dir, file_path)
-                
-                # Try to get the parent directory if the file doesn't exist
-                if '/' in file_path:
-                    parent_file_dir = os.path.dirname(file_path)
-                    relevant_files.append(parent_file_dir)
-            
-            # Look for package.json, requirements.txt, etc.
-            common_config_files = ["package.json", "requirements.txt", "pyproject.toml", "setup.py", 
-                                 "Pipfile", "Dockerfile", "docker-compose.yml", "Makefile"]
-            
-            for config_file in common_config_files:
-                check_cmd = f"test -f {current_dir}/{config_file}"
-                check_result = sandbox.exec("bash", "-c", check_cmd)
-                check_result.wait()
-                if check_result.returncode == 0:
-                    relevant_files.append(f"{current_dir}/{config_file}")
-            
-            # Get content of relevant files
-            if relevant_files:
-                file_context = "\nRelevant file contents:\n"
-                for file_path in relevant_files[:2]:  # Limit to 2 files to avoid too much context
-                    try:
-                        file_check_cmd = f"test -f {file_path}"
-                        file_check = sandbox.exec("bash", "-c", file_check_cmd)
-                        file_check.wait()
-                        
-                        if file_check.returncode == 0:
-                            # It's a file, get its content
-                            cat_cmd = f"cat {file_path}"
-                            cat_result = sandbox.exec("bash", "-c", cat_cmd)
-                            file_content = ""
-                            for line in cat_result.stdout:
-                                file_content += _to_str(line)
-                            cat_result.wait()
-                            
-                            # Truncate if too long
-                            if len(file_content) > 1000:
-                                file_content = file_content[:1000] + "\n... (truncated)"
-                            
-                            file_context += f"\n--- {file_path} ---\n{file_content}\n"
-                        else:
-                            # It's a directory, list its contents
-                            ls_cmd = f"ls -la {file_path}"
-                            ls_dir_result = sandbox.exec("bash", "-c", ls_cmd)
-                            dir_content = ""
-                            for line in ls_dir_result.stdout:
-                                dir_content += _to_str(line)
-                            ls_dir_result.wait()
-                            
-                            file_context += f"\n--- Directory: {file_path} ---\n{dir_content}\n"
-                    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")
-            
-        except Exception as e:
-            print(f"⚠️ Error getting directory context: {e}")
-            directory_context = f"\nCurrent directory: {current_dir}\n"
-    
-    # Prepare the API request
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}"
-    }
-
-    stored_credentials = get_stored_credentials()
-    auth_context = generate_auth_context(stored_credentials)
-    
-    # Create a prompt for the LLM
-    print("\n" + "="*60)
-    print("DEBUG: ERROR_OUTPUT SENT TO LLM:")
-    print("="*60)
-    print(f"{error_output}")
-    print("="*60 + "\n")
-    
-    prompt = f"""
-I'm trying to run the following command in a Linux environment:
-
-```
-{command}
-```
-
-But it failed with this error:
-
-```
-{error_output}
-```
-{system_info}
-{directory_context}
-{file_context}
-
-AVAILABLE CREDENTIALS:
-{auth_context}
-
-Please analyze the error and provide ONLY a single terminal command that would fix the issue.
-Consider the current directory, system information, directory contents, and available credentials carefully before suggesting a solution.
-
-IMPORTANT GUIDELINES:
-1. For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
-   - For apt/apt-get: use -y or --yes
-   - For rm: use -f or --force
-
-2. If the error indicates a file is not found:
-   - FIRST try to search for the file using: find . -name "filename" -type f 2>/dev/null
-   - If found, navigate to that directory using: cd /path/to/directory
-   - If not found, then consider creating the file or installing missing packages
-
-3. For missing packages or dependencies:
-   - Use pip install for Python packages
-   - Use apt-get install -y for system packages
-   - Use npm install for Node.js packages
-
-4. For authentication issues:
-   - Analyze the error to determine what type of authentication is needed
-   - ALWAYS use the actual credential values from the AVAILABLE CREDENTIALS section above (NOT placeholders)
-   - Look for the specific API key or token needed in the auth_context and use its exact value
-   - Common patterns:
-     * wandb errors: use wandb login with the actual WANDB_API_KEY value from auth_context
-     * huggingface errors: use huggingface-cli login with the actual HF_TOKEN or HUGGINGFACE_TOKEN value from auth_context
-     * github errors: configure git credentials with the actual GITHUB_TOKEN value from auth_context
-     * kaggle errors: create ~/.kaggle/kaggle.json with the actual KAGGLE_USERNAME and KAGGLE_KEY values from auth_context
-     * API errors: export the appropriate API key as environment variable using the actual value from auth_context
-
-5. Environment variable exports:
-   - Use export commands for API keys that need to be in environment
-   - ALWAYS use the actual credential values from auth_context, never use placeholders like "YOUR_API_KEY"
-   - Example: export OPENAI_API_KEY="sk-..." (using the actual key from auth_context)
-
-6. CRITICAL: When using any API key, token, or credential:
-   - Find the exact value in the AVAILABLE CREDENTIALS section
-   - Use that exact value in your command
-   - 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...")
-    
-    # Try to use GPT-4 first, but fall back to other models if needed
-    models_to_try = [
-        "gpt-4o-mini",        # First choice: GPT-4o (most widely available)
-    ]
-    
-    # Check if we have a preferred model in environment
-    preferred_model = os.environ.get("OPENAI_MODEL")
-    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}")
-        
-    # Remove duplicates while preserving order
-    models_to_try = list(dict.fromkeys(models_to_try))
-    # print(f"🔍 DEBUG: Models to try: {models_to_try}")
-    
-    # Function to make the API call with a specific model
-    def try_api_call(model_name, retries=2, backoff_factor=1.5):
-        # print(f"🔍 DEBUG: Attempting API call with model: {model_name}")
-        # print(f"🔍 DEBUG: API key available: {'Yes' if api_key else 'No'}")
-        # if api_key:
-        #     print(f"🔍 DEBUG: API key length: {len(api_key)}")
-        #     print(f"🔍 DEBUG: API key starts with: {api_key[:10]}...")
-        
-        payload = {
-            "model": model_name,
-            "messages": [
-                {"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)}")
-        
-        # Add specific handling for common errors
-        last_error = None
-        for attempt in range(retries + 1):
-            try:
-                if attempt > 0:
-                    # Exponential backoff
-                    wait_time = backoff_factor * (2 ** (attempt - 1))
-                    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...")
-                response = requests.post(
-                    "https://api.openai.com/v1/chat/completions",
-                    headers=headers,
-                    json=payload,
-                    timeout=45  # Increased timeout for reliability
-                )
-                
-                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
-                
-                # Handle specific status codes
-                if response.status_code == 200:
-                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
-                    return response.json(), None
-                elif response.status_code == 401:
-                    error_msg = "Authentication error: Invalid API key"
-                    print(f"❌ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Don't retry auth errors
-                    return None, error_msg
-                elif response.status_code == 429:
-                    error_msg = "Rate limit exceeded or quota reached"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Always retry rate limit errors with increasing backoff
-                    last_error = error_msg
-                    continue
-                elif response.status_code == 500:
-                    error_msg = "OpenAI server error"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Retry server errors
-                    last_error = error_msg
-                    continue
-                else:
-                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
-                    print(f"⚠️ OpenAI API error: {error_msg}")
-                    print(f"🔍 DEBUG: Full response text: {response.text}")
-                    last_error = error_msg
-                    # Only retry if we have attempts left
-                    if attempt < retries:
-                        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")
-                last_error = error_msg
-                # Always retry timeouts
-                continue
-            except requests.exceptions.ConnectionError:
-                error_msg = "Connection error"
-                print(f"⚠️ {error_msg}")
-                print(f"🔍 DEBUG: Connection failed to api.openai.com")
-                last_error = error_msg
-                # Always retry connection errors
-                continue
-            except Exception as e:
-                error_msg = str(e)
-                print(f"⚠️ Unexpected error: {error_msg}")
-                print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-                print(f"🔍 DEBUG: Exception details: {str(e)}")
-                last_error = error_msg
-                # Only retry if we have attempts left
-                if attempt < retries:
-                    continue
-                return None, error_msg
-        
-        # If we get here, all retries failed
-        return None, last_error
-    
-    # Try each model in sequence until one works
-    result = None
-    last_error = None
-    
-    for model in models_to_try:
-        result, error = try_api_call(model)
-        if result:
-            # print(f"✅ Successfully got response from {model}")
-            break
-        else:
-            print(f"⚠️ Failed to get response from {model}: {error}")
-            last_error = error
-    
-    if not result:
-        print(f"❌ All model attempts failed. Last error: {last_error}")
-        return None
-    
-    # Process the response
-    try:
-        print(f"🔍 DEBUG: Processing OpenAI response...")
-        # print(f"🔍 DEBUG: Response structure: {list(result.keys())}")
-        print(f"🔍 DEBUG: Choices count: {len(result.get('choices', []))}")
-        
-        fix_command = result["choices"][0]["message"]["content"].strip()
-        print(f"🔍 DEBUG: Raw response content: {fix_command}")
-        
-        # Save the original response for debugging
-        original_response = fix_command
-        
-        # Extract just the command if it's wrapped in backticks or explanation
-        if "```" in fix_command:
-            # Extract content between backticks
-            import re
-            code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
-            if code_blocks:
-                fix_command = code_blocks[0].strip()
-                print(f"✅ Extracted command from code block: {fix_command}")
-        
-        # If the response still has explanatory text, try to extract just the command
-        if len(fix_command.split('\n')) > 1:
-            # First try to find lines that look like commands (start with common command prefixes)
-            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
-                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
-                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
-                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
-            
-            # Check for lines that start with common command prefixes
-            command_lines = [line.strip() for line in fix_command.split('\n') 
-                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
-            
-            if command_lines:
-                # Use the first command line found
-                fix_command = command_lines[0]
-                print(f"✅ Identified command by prefix: {fix_command}")
-            else:
-                # Try to find lines that look like commands (contain common shell patterns)
-                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
-                command_lines = [line.strip() for line in fix_command.split('\n') 
-                              if any(pattern in line for pattern in shell_patterns)]
-                
-                if command_lines:
-                    # Use the first command line found
-                    fix_command = command_lines[0]
-                    print(f"✅ Identified command by shell pattern: {fix_command}")
-                else:
-                    # Fall back to the shortest non-empty line as it's likely the command
-                    lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
-                    if lines:
-                        # Exclude very short lines that are likely not commands
-                        valid_lines = [line for line in lines if len(line) > 5]
-                        if valid_lines:
-                            fix_command = min(valid_lines, key=len)
-                        else:
-                            fix_command = min(lines, key=len)
-                        print(f"✅ Selected shortest line as command: {fix_command}")
-        
-        # Clean up the command - remove any trailing periods or quotes
-        fix_command = fix_command.rstrip('.;"\'')
-        
-        # Remove common prefixes that LLMs sometimes add
-        prefixes_to_remove = [
-            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
-            "You should run: ", "You can run: ", "You need to run: "
-        ]
-        for prefix in prefixes_to_remove:
-            if fix_command.startswith(prefix):
-                fix_command = fix_command[len(prefix):].strip()
-                print(f"✅ Removed prefix: {prefix}")
-                break
-        
-        # If the command is still multi-line or very long, it might not be a valid command
-        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
-            print("⚠️ Extracted command appears invalid (multi-line or too long)")
-            print("🔍 Original response from LLM:")
-            print("-" * 60)
-            print(original_response)
-            print("-" * 60)
-            print("⚠️ Using best guess for command")
-        
-        print(f"🔧 Suggested fix: {fix_command}")
-        print(f"🔍 DEBUG: Returning fix command: {fix_command}")
-        return fix_command
-    except Exception as e:
-        print(f"❌ Error processing OpenAI response: {e}")
-        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-        print(f"🔍 DEBUG: Exception details: {str(e)}")
-        return None
-
-def 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 call_anthropic_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
-    """Call Anthropic Claude to debug a failed command and suggest a fix"""
-    print("\n🔍 DEBUG: Starting Anthropic Claude debugging...")
-    print(f"🔍 DEBUG: Command: {command}")
-    print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
-    print(f"🔍 DEBUG: Current directory: {current_dir}")
-    print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
-    
-    # Define _to_str function locally to avoid NameError
-    def _to_str(maybe_bytes):
-        try:
-            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
-        except UnicodeDecodeError:
-            # Handle non-UTF-8 bytes by replacing invalid characters
-            if isinstance(maybe_bytes, (bytes, bytearray)):
-                return maybe_bytes.decode('utf-8', errors='replace')
-            else:
-                return str(maybe_bytes)
-        except Exception:
-            # Last resort fallback
-            return str(maybe_bytes)
-            
-    # Skip debugging for certain commands that commonly return non-zero exit codes
-    # but aren't actually errors (like test commands)
-    if command.strip().startswith("test "):
-        print("🔍 Skipping debugging for test command - non-zero exit code is expected behavior")
-        return None
-        
-    # Validate error_output - if it's empty, we can't debug effectively
-    if not error_output or not error_output.strip():
-        print("⚠️ Error output is empty. Cannot effectively debug the command.")
-        print("⚠️ Skipping Anthropic debugging due to lack of error information.")
-        return None
-    
-    # Try to get API key from multiple sources
-    if not api_key:
-        print("🔍 DEBUG: No Anthropic API key provided, searching for one...")
-        
-        # First try environment variable
-        api_key = os.environ.get("ANTHROPIC_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
-        
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                _, _, _, api_key = get_tokens()
-                if api_key:
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from server")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from server: {e}")
-        
-        # Then try credentials manager
-        if not api_key:
-            print("🔍 DEBUG: Trying credentials manager...")
-            try:
-                from credentials_manager import CredentialsManager
-                credentials_manager = CredentialsManager()
-                api_key = credentials_manager.get_anthropic_api_key()
-                if api_key:
-                    print(f"🔍 DEBUG: API key from credentials manager: Found")
-                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from credentials manager")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from credentials manager: {e}")
-        
-        # Store the API key in a persistent file if found
-        if api_key:
-            try:
-                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
-                with open(os.path.expanduser("~/.gitarsenal/anthropic_key"), "w") as f:
-                    f.write(api_key)
-                print("✅ Saved Anthropic API key for future use")
-            except Exception as e:
-                print(f"⚠️ Could not save API key: {e}")
-        
-        # Try to load from saved file if not in environment
-        if not api_key:
-            try:
-                key_file = os.path.expanduser("~/.gitarsenal/anthropic_key")
-                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
-                if os.path.exists(key_file):
-                    with open(key_file, "r") as f:
-                        api_key = f.read().strip()
-                    if api_key:
-                        print("✅ Loaded Anthropic API key from saved file")
-                        print(f"🔍 DEBUG: API key from file: {api_key}")
-                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
-                        # Also set in environment for this session
-                        os.environ["ANTHROPIC_API_KEY"] = api_key
-                    else:
-                        print("🔍 DEBUG: Saved file exists but is empty")
-                else:
-                    print("🔍 DEBUG: No saved API key file found")
-            except Exception as e:
-                print(f"⚠️ Could not load saved API key: {e}")
-    
-    if not api_key:
-        print("❌ No Anthropic API key available for debugging")
-        return None
-    
-    # Prepare the prompt for debugging
-    error_str = _to_str(error_output)
-    prompt = f"""You are a debugging assistant. Provide only the terminal command to fix the issue. 
-
-Context:
-- Current directory: {current_dir}
-- Sandbox available: {sandbox is not None}
-- Failed command: {command}
-- Error output: {error_str}
-
-Analyze the issue first, understand why it's happening, then provide the command to fix it. 
-
-Guidelines:
-- 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
-- For permission errors, suggest commands with sudo if appropriate
-- For network issues, suggest retry commands or alternative URLs
-
-Return only the command to fix the issue, nothing else."""
-
-    # Set up headers for Anthropic API
-    headers = {
-        "x-api-key": api_key,
-        "anthropic-version": "2023-06-01",
-        "content-type": "application/json"
-    }
-    
-    # Models to try in order of preference
-    models_to_try = ["claude-4-sonnet"]
-    
-    def try_api_call(model_name, retries=2, backoff_factor=1.5):
-        payload = {
-            "model": model_name,
-            "max_tokens": 300,
-            "messages": [
-                {"role": "user", "content": prompt}
-            ]
-        }
-        
-        print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
-        
-        # Add specific handling for common errors
-        last_error = None
-        for attempt in range(retries + 1):
-            try:
-                if attempt > 0:
-                    # Exponential backoff
-                    wait_time = backoff_factor * (2 ** (attempt - 1))
-                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
-                    time.sleep(wait_time)
-                
-                print(f"🤖 Calling Anthropic Claude with {model_name} model to debug the failed command...")
-                print(f"🔍 DEBUG: Making POST request to Anthropic API...")
-                response = requests.post(
-                    "https://api.anthropic.com/v1/messages",
-                    headers=headers,
-                    json=payload,
-                    timeout=45  # Increased timeout for reliability
-                )
-                
-                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
-                
-                # Handle specific status codes
-                if response.status_code == 200:
-                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
-                    return response.json(), None
-                elif response.status_code == 401:
-                    error_msg = "Authentication error: Invalid API key"
-                    print(f"❌ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Don't retry auth errors
-                    return None, error_msg
-                elif response.status_code == 429:
-                    error_msg = "Rate limit exceeded or quota reached"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Always retry rate limit errors with increasing backoff
-                    last_error = error_msg
-                    continue
-                elif response.status_code == 500:
-                    error_msg = "Anthropic 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"⚠️ Anthropic 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"
-                last_error = error_msg
-                # Always retry timeouts
-                continue
-            except requests.exceptions.ConnectionError:
-                error_msg = "Connection error"
-                print(f"⚠️ {error_msg}")
-                print(f"🔍 DEBUG: Connection failed to api.anthropic.com")
-                last_error = error_msg
-                # Always retry connection errors
-                continue
-            except Exception as e:
-                error_msg = str(e)
-                print(f"⚠️ Unexpected error: {error_msg}")
-                print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-                print(f"🔍 DEBUG: Exception details: {str(e)}")
-                last_error = error_msg
-                # Only retry if we have attempts left
-                if attempt < retries:
-                    continue
-                return None, error_msg
-        
-        # If we get here, all retries failed
-        return None, last_error
-    
-    # Try each model in sequence until one works
-    result = None
-    last_error = None
-    
-    for model in models_to_try:
-        result, error = try_api_call(model)
-        if result:
-            break
-        else:
-            print(f"⚠️ Failed to get response from {model}: {error}")
-            last_error = error
-    
-    if not result:
-        print(f"❌ All model attempts failed. Last error: {last_error}")
-        return None
-    
-    # Process the response
-    try:
-        print(f"🔍 DEBUG: Processing Anthropic response...")
-        print(f"🔍 DEBUG: Choices count: {len(result.get('content', []))}")
-        
-        fix_command = result["content"][0]["text"].strip()
-        print(f"🔍 DEBUG: Raw response content: {fix_command}")
-        
-        # Save the original response for debugging
-        original_response = fix_command
-        
-        # Extract just the command if it's wrapped in backticks or explanation
-        if "```" in fix_command:
-            # Extract content between backticks
-            import re
-            code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
-            if code_blocks:
-                fix_command = code_blocks[0].strip()
-                print(f"✅ Extracted command from code block: {fix_command}")
-        
-        # If the response still has explanatory text, try to extract just the command
-        if len(fix_command.split('\n')) > 1:
-            # First try to find lines that look like commands (start with common command prefixes)
-            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
-                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
-                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
-                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
-            
-            # Check for lines that start with common command prefixes
-            command_lines = [line.strip() for line in fix_command.split('\n') 
-                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
-            
-            if command_lines:
-                # Use the first command line found
-                fix_command = command_lines[0]
-                print(f"✅ Identified command by prefix: {fix_command}")
-            else:
-                # Try to find lines that look like commands (contain common shell patterns)
-                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
-                command_lines = [line.strip() for line in fix_command.split('\n') 
-                              if any(pattern in line for pattern in shell_patterns)]
-                
-                if command_lines:
-                    # Use the first command line found
-                    fix_command = command_lines[0]
-                    print(f"✅ Identified command by shell pattern: {fix_command}")
-                else:
-                    # Fall back to the shortest non-empty line as it's likely the command
-                    lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
-                    if lines:
-                        # Exclude very short lines that are likely not commands
-                        valid_lines = [line for line in lines if len(line) > 5]
-                        if valid_lines:
-                            fix_command = min(valid_lines, key=len)
-                        else:
-                            fix_command = min(lines, key=len)
-                        print(f"✅ Selected shortest line as command: {fix_command}")
-        
-        # Clean up the command - remove any trailing periods or quotes
-        fix_command = fix_command.rstrip('.;"\'')
-        
-        # Remove common prefixes that LLMs sometimes add
-        prefixes_to_remove = [
-            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
-            "You should run: ", "You can run: ", "You need to run: "
-        ]
-        for prefix in prefixes_to_remove:
-            if fix_command.startswith(prefix):
-                fix_command = fix_command[len(prefix):].strip()
-                print(f"✅ Removed prefix: {prefix}")
-                break
-        
-        # If the command is still multi-line or very long, it might not be a valid command
-        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
-            print("⚠️ Extracted command appears invalid (multi-line or too long)")
-            print("🔍 Original response from LLM:")
-            print("-" * 60)
-            print(original_response)
-            print("-" * 60)
-            print("⚠️ Using best guess for command")
-        
-        print(f"🔧 Suggested fix: {fix_command}")
-        print(f"🔍 DEBUG: Returning fix command: {fix_command}")
-        return fix_command
-    except Exception as e:
-        print(f"❌ Error processing Anthropic response: {e}")
-        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-        print(f"🔍 DEBUG: Exception details: {str(e)}")
-        return None
-
-def switch_to_anthropic_models():
-    """Switch the debugging system to use Anthropic Claude models instead of OpenAI"""
-    print("\n🔄 Switching to Anthropic Claude models for debugging...")
-    
-    # Set environment variable to indicate Anthropic preference
-    os.environ["GITARSENAL_DEBUG_MODEL"] = "anthropic"
-    
-    # Try to get Anthropic API key
-    try:
-        from credentials_manager import CredentialsManager
-        credentials_manager = CredentialsManager()
-        api_key = credentials_manager.get_anthropic_api_key()
-        if api_key:
-            os.environ["ANTHROPIC_API_KEY"] = api_key
-            print("✅ Anthropic API key configured")
-            print("✅ Debugging will now use Anthropic Claude models")
-            return True
-        else:
-            print("⚠️ No Anthropic API key found")
-            print("💡 You can set your Anthropic API key using:")
-            print("   export ANTHROPIC_API_KEY='your-key'")
-            print("   Or run the credentials manager to set it up")
-            return False
-    except Exception as e:
-        print(f"❌ Error configuring Anthropic: {e}")
-        return False
-
-def switch_to_openai_models():
-    """Switch the debugging system to use OpenAI models (default)"""
-    print("\n🔄 Switching to OpenAI models for debugging...")
-    
-    # Set environment variable to indicate OpenAI preference
-    os.environ["GITARSENAL_DEBUG_MODEL"] = "openai"
-    
-    # Try to get OpenAI API key
-    try:
-        from credentials_manager import CredentialsManager
-        credentials_manager = CredentialsManager()
-        api_key = credentials_manager.get_openai_api_key()
-        if api_key:
-            os.environ["OPENAI_API_KEY"] = api_key
-            print("✅ OpenAI API key configured")
-            print("✅ Debugging will now use OpenAI models")
-            return True
-        else:
-            print("⚠️ No OpenAI API key found")
-            print("💡 You can set your OpenAI API key using:")
-            print("   export OPENAI_API_KEY='your-key'")
-            print("   Or run the credentials manager to set it up")
-            return False
-    except Exception as e:
-        print(f"❌ Error configuring OpenAI: {e}")
-        return False
-
-def get_current_debug_model():
-    """Get the currently configured debugging model preference"""
-    return os.environ.get("GITARSENAL_DEBUG_MODEL", "anthropic")
-
-def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
-    """Unified function to call LLM for debugging - routes to OpenAI or Anthropic based on configuration"""
-    current_model = get_current_debug_model()
-    
-    print(f"🔍 DEBUG: Using {current_model.upper()} for debugging...")
-    
-    if current_model == "anthropic":
-        # Try to get Anthropic API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("ANTHROPIC_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, _, api_key = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_anthropic_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
-        
-        return call_anthropic_for_debug(command, error_output, api_key, current_dir, sandbox)
-    else:
-        # Default to OpenAI
-        # Try to get OpenAI API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("OPENAI_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, api_key, _ = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching OpenAI API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openai_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
-        
-        return call_openai_for_debug(command, error_output, api_key, current_dir, sandbox)
+# 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()
 
-def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
-    """Unified function to call LLM for batch debugging - routes to OpenAI or Anthropic based on configuration"""
-    current_model = get_current_debug_model()
-    
-    print(f"🔍 DEBUG: Using {current_model.upper()} for batch debugging...")
-    
-    if current_model == "anthropic":
-        # Try to get Anthropic API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("ANTHROPIC_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, _, api_key = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_anthropic_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
-        
-        return call_anthropic_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
-    else:
-        # Default to OpenAI
-        # Try to get OpenAI API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("OPENAI_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, api_key, _ = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching OpenAI API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openai_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
-        
-        return call_openai_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+# Check if we got valid tokens
+if token_id is None or token_secret is None:
+    raise ValueError("Could not get valid tokens")
 
-def call_anthropic_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
-    """Call Anthropic Claude to debug multiple failed commands and suggest fixes for all of them at once"""
-    print("\n🔍 DEBUG: Starting batch Anthropic Claude 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("🔍 DEBUG: No Anthropic API key provided, searching for one...")
-        
-        # First try environment variable
-        api_key = os.environ.get("ANTHROPIC_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
-        
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                _, _, _, api_key = get_tokens()
-                if api_key:
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from server")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from server: {e}")
-        
-        # Then try credentials manager
-        if not api_key:
-            print("🔍 DEBUG: Trying credentials manager...")
-            try:
-                from credentials_manager import CredentialsManager
-                credentials_manager = CredentialsManager()
-                api_key = credentials_manager.get_anthropic_api_key()
-                if api_key:
-                    print(f"🔍 DEBUG: API key from credentials manager: Found")
-                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from credentials manager")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from credentials manager: {e}")
-        
-        if not api_key:
-            print("❌ No Anthropic API key available 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. 
+print(f"✅ Tokens fetched successfully")
 
-Context:
-{chr(10).join(context_parts)}
+# 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
 
-Please analyze each failed command and provide a fix command for each one. For each failed command, respond with:
+# Set token variables for later use
+token = token_id  # For backward compatibility
 
-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
+def generate_random_password(length=16):
+    """Generate a random password for SSH access"""
+    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
+    password = ''.join(secrets.choice(alphabet) for i in range(length))
+    return password
 
-Provide fixes for all {len(failed_commands)} failed commands:"""
 
-    # Set up headers for Anthropic API
-    headers = {
-        "x-api-key": api_key,
-        "anthropic-version": "2023-06-01",
-        "content-type": "application/json"
-    }
-    
-    payload = {
-        "model": "claude-3-5-sonnet-20241022",  # Use a more capable model for batch analysis
-        "max_tokens": 1000,
-        "messages": [
-            {"role": "user", "content": prompt}
-        ]
-    }
+def get_stored_credentials():
+    """Load stored credentials from ~/.gitarsenal/credentials.json"""
+    import json
+    from pathlib import Path
     
     try:
-        print(f"🤖 Calling Anthropic Claude for batch debugging of {len(failed_commands)} commands...")
-        response = requests.post(
-            "https://api.anthropic.com/v1/messages",
-            headers=headers,
-            json=payload,
-            timeout=60
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            content = result['content'][0]['text']
-            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 "Anthropic Claude 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
+        credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
+        if credentials_file.exists():
+            with open(credentials_file, 'r') as f:
+                credentials = json.load(f)
+            return credentials
         else:
-            print(f"❌ Anthropic API error: {response.status_code} - {response.text}")
-            return []
-            
+            return {}
     except Exception as e:
-        print(f"❌ Error during batch debugging: {e}")
-        return []
-
-def generate_random_password(length=16):
-    """Generate a random password for SSH access"""
-    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
-    password = ''.join(secrets.choice(alphabet) for i in range(length))
-    return password
+        print(f"⚠️ Error loading stored credentials: {e}")
+        return {}
 
 
 # Now modify the create_modal_ssh_container function to use the PersistentShell
@@ -2900,6 +298,10 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     try:
         print("📦 Building SSH-enabled image...")
         
+        # Get the current directory path for mounting local Python sources
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        print(f"🔍 Current directory for mounting: {current_dir}")
+        
         # Use a more stable CUDA base image and avoid problematic packages
         ssh_image = (
             # modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
@@ -2909,7 +311,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
                 "gpg", "ca-certificates", "software-properties-common"
             )
-            .uv_pip_install("uv", "modal", "requests", "openai")  # Remove problematic CUDA packages
+            .uv_pip_install("uv", "modal", "requests", "openai", "anthropic")  # Remove problematic CUDA packages
             .run_commands(
                 # Create SSH directory
                 "mkdir -p /var/run/sshd",
@@ -2931,6 +333,12 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 # Set up a nice bash prompt
                 "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
             )
+            .add_local_file(os.path.join(current_dir, "shell.py"), "/python/shell.py")  # Mount shell.py
+            .add_local_file(os.path.join(current_dir, "command_manager.py"), "/python/command_manager.py")  # Mount command_manager.py
+            .add_local_file(os.path.join(current_dir, "fetch_modal_tokens.py"), "/python/fetch_modal_tokens.py")  # Mount fetch_modal_token.py
+            .add_local_file(os.path.join(current_dir, "llm_debugging.py"), "/python/llm_debugging.py")  # Mount llm_debugging.py
+            .add_local_file(os.path.join(current_dir, "credentials_manager.py"), "/python/credentials_manager.py")  # Mount credentials_manager.py
+
         )
         print("✅ SSH image built successfully")
     except Exception as e:
@@ -2964,6 +372,31 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         import time
         import os
         import json
+        import sys
+        
+        # Add the mounted python directory to the Python path
+        sys.path.insert(0, "/python")
+        
+        # Import the required classes from the mounted modules
+        try:
+            from command_manager import CommandListManager
+            from shell import PersistentShell
+            from llm_debugging import get_stored_credentials, generate_auth_context, call_llm_for_debug, call_llm_for_batch_debug, call_anthropic_for_debug, call_openai_for_debug, call_openai_for_batch_debug, call_anthropic_for_batch_debug, get_current_debug_model
+            
+            print("✅ Successfully imported CommandListManager, PersistentShell, and all llm_debugging functions from mounted modules")
+        except ImportError as e:
+            print(f"❌ Failed to import modules from mounted directory: {e}")
+            print("🔍 Available files in /python:")
+            try:
+                import os
+                if os.path.exists("/python"):
+                    for file in os.listdir("/python"):
+                        print(f"  - {file}")
+                else:
+                    print("  /python directory does not exist")
+            except Exception as list_error:
+                print(f"  Error listing files: {list_error}")
+            raise
         
         # Set root password
         subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
@@ -4684,8 +2117,6 @@ if __name__ == "__main__":
     import sys
     
     parser = argparse.ArgumentParser()
-    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)')
     parser.add_argument('--setup-commands-json', type=str, help='Setup commands as JSON array')
@@ -4701,6 +2132,11 @@ if __name__ == "__main__":
     parser.add_argument('--show-examples', action='store_true', help='Show usage examples')
     parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
     parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
+
+    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')
     
     # Authentication-related arguments
     parser.add_argument('--auth', action='store_true', help='Manage authentication (login, register, logout)')
@@ -5001,4 +2437,4 @@ if __name__ == "__main__":
         # print(f"\n❌ Error: {e}")
         # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
-        sys.exit(1)
+