hanzo-mcp 0.3.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

hanzo_mcp/tools/shell/command_executor.py

@@ -7,19 +7,16 @@ comprehensive error handling, permissions checking, and progress tracking.
 import asyncio
 import base64
 import os
+import re
 import shlex
+import shutil
 import sys
 import tempfile
 from collections.abc import Awaitable, Callable
-from pathlib import Path
-from typing import Dict, Optional, final
+from typing import final
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
 
-from hanzo_mcp.tools.common.context import create_tool_context
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.common.session import SessionManager
 from hanzo_mcp.tools.shell.base import CommandResult
 
 
@@ -43,111 +40,135 @@ class CommandExecutor:
         self.permission_manager: PermissionManager = permission_manager
         self.verbose: bool = verbose
 
-        # Session management (initialized on first use with session ID)
-        self.session_manager: Optional[SessionManager] = None
-
         # Excluded commands or patterns
         self.excluded_commands: list[str] = ["rm"]
 
         # Map of supported interpreters with special handling
-        self.special_interpreters: Dict[
+        self.special_interpreters: dict[
             str,
-            Callable[
-                [str, str, str], dict[str, str]], Optional[float | None | None,
-                Awaitable[CommandResult],
-            ],
+            Callable[[str, str, str], dict[str, str]] | Awaitable[CommandResult],
         ] = {
             "fish": self._handle_fish_script,
         }
 
-    def allow_command(self, command: str) -> None:
-        """Allow a specific command that might otherwise be excluded.
+    def _get_shell_by_type(self, shell_type: str) -> tuple[str, str]:
+        """Get shell information for a specified shell type.
 
         Args:
-            command: The command to allow
+            shell_type: The shell name to use (e.g., "bash", "cmd", "powershell")
+
+        Returns:
+            Tuple of (shell_basename, shell_path)
         """
-        if command in self.excluded_commands:
-            self.excluded_commands.remove(command)
+        shell_path = shutil.which(shell_type)
+        if shell_path is None:
+            # Shell not found, fall back to default
+            self._log(f"Requested shell '{shell_type}' not found, using system default")
+            return self._get_system_shell()
 
-    def deny_command(self, command: str) -> None:
-        """Deny a specific command, adding it to the excluded list.
+        if sys.platform == "win32":
+            shell_path = shell_path.lower()
+
+        shell_basename = os.path.basename(shell_path).lower()
+        return shell_basename, shell_path
+
+    def _get_system_shell(self, shell_type: str | None = None) -> tuple[str, str]:
+        """Get the system's default shell based on the platform.
 
         Args:
-            command: The command to deny
-        """
-        if command not in self.excluded_commands:
-            self.excluded_commands.append(command)
+            shell_type: Optional specific shell to use instead of system default
 
-    def _get_preferred_shell(self) -> str:
-        """Get the best available shell for the current environment.
-        
-        Tries to find the best shell in this order:
-        1. User's SHELL environment variable
-        2. zsh
-        3. bash
-        4. fish
-        5. sh (fallback)
-        
         Returns:
-            Path to the preferred shell
+            Tuple of (shell_basename, shell_path)
         """
-        # First check the SHELL environment variable
-        user_shell = os.environ.get("SHELL")
-        if user_shell and os.path.exists(user_shell):
-            return user_shell
-        
-        # Try common shells in order of preference
-        shell_paths = [
-            "/bin/zsh",
-            "/usr/bin/zsh",
-            "/bin/bash",
-            "/usr/bin/bash",
-            "/bin/fish",
-            "/usr/bin/fish",
-            "/bin/sh",
-            "/usr/bin/sh",
-        ]
-        
-        for shell_path in shell_paths:
-            if os.path.exists(shell_path) and os.access(shell_path, os.X_OK):
-                return shell_path
-        
-        # Fallback to /bin/sh which should exist on most systems
-        return "/bin/sh"
-
-    def get_session_manager(self, session_id: str) -> SessionManager:
-        """Get the session manager for the given session ID.
+        # If a specific shell is requested, use that
+        if shell_type is not None:
+            return self._get_shell_by_type(shell_type)
+
+        # Otherwise use system default
+        if sys.platform == "win32":
+            # On Windows, default to Command Prompt
+            comspec = os.environ.get("COMSPEC", "cmd.exe").lower()
+            return "cmd", comspec
+        else:
+            # Unix systems
+            user_shell = os.environ.get("SHELL", "/bin/bash")
+            return os.path.basename(user_shell).lower(), user_shell
+
+    def _format_win32_shell_command(
+        self, shell_basename, user_shell, command, use_login_shell=True
+    ):
+        """Format a command for execution with the appropriate Windows shell.
 
         Args:
-            session_id: The session ID
+            shell_basename: The basename of the shell
+            user_shell: The full path to the shell
+            command: The command to execute
+            use_login_shell: Whether to use login shell settings
 
         Returns:
-            The session manager instance
+            Formatted shell command string
         """
-        return SessionManager.get_instance(session_id)
+        formatted_command = ""
+
+        if shell_basename in ["wsl", "wsl.exe"]:
+            # For WSL, handle commands with shell operators differently
+            if any(char in command for char in ";&|<>(){}[]$\"'`"):
+                # For commands with special characters, use a more reliable approach
+                # with bash -c and double quotes around the entire command
+                escaped_command = command.replace('"', '\\"')
+                if use_login_shell:
+                    formatted_command = f'{user_shell} bash -l -c "{escaped_command}"'
+                else:
+                    formatted_command = f'{user_shell} bash -c "{escaped_command}"'
+            else:
+                # # For simple commands without special characters
+                # # Still respect login shell preference
+                # if use_login_shell:
+                #     formatted_command = f"{user_shell} bash -l -c \"{command}\""
+                # else:
+                formatted_command = f"{user_shell} {command}"
+
+        elif shell_basename in ["powershell", "powershell.exe", "pwsh", "pwsh.exe"]:
+            # For PowerShell, escape double quotes with backslash most robust
+            escaped_command = command.replace('"', '\\"')
+            formatted_command = f'"{user_shell}" -Command "{escaped_command}"'
 
-    def set_working_dir(self, session_id: str, path: str) -> None:
-        """Set the current working directory for the session.
+        else:
+            # For CMD, use the /c parameter and wrap in double quotes
+            # CMD doesn't have an explicit login shell concept
+            formatted_command = f'"{user_shell}" /c "{command}"'
+
+        self._log(
+            "Win32 Shell Results",
+            {
+                "shell_basename": shell_basename,
+                "user_shell": user_shell,
+                "command": command,
+                "use_login_shell": use_login_shell,
+                "formatted_command": formatted_command,
+            },
+        )
+
+        return formatted_command
+
+    def allow_command(self, command: str) -> None:
+        """Allow a specific command that might otherwise be excluded.
 
         Args:
-            session_id: The session ID
-            path: The path to set as the current working directory
+            command: The command to allow
         """
-        session = self.get_session_manager(session_id)
-        expanded_path = os.path.expanduser(path)
-        session.set_working_dir(Path(expanded_path))
+        if command in self.excluded_commands:
+            self.excluded_commands.remove(command)
 
-    def get_working_dir(self, session_id: str) -> str:
-        """Get the current working directory for the session.
+    def deny_command(self, command: str) -> None:
+        """Deny a specific command, adding it to the excluded list.
 
         Args:
-            session_id: The session ID
-
-        Returns:
-            The current working directory
+            command: The command to deny
         """
-        session = self.get_session_manager(session_id)
-        return str(session.current_working_dir)
+        if command not in self.excluded_commands:
+            self.excluded_commands.append(command)
 
     def _log(self, message: str, data: object | None = None) -> None:
         """Log a message if verbose logging is enabled.
@@ -155,9 +176,6 @@ class CommandExecutor:
         Args:
             message: The message to log
             data: Optional data to include with the message
-
-        Note:
-            Always logs to stderr to avoid interfering with stdio transport
         """
         if not self.verbose:
             return
@@ -208,20 +226,20 @@ class CommandExecutor:
         self,
         command: str,
         cwd: str | None = None,
+        shell_type: str | None = None,
         env: dict[str, str] | None = None,
         timeout: float | None = 60.0,
         use_login_shell: bool = True,
-        session_id: str | None = None,
     ) -> CommandResult:
         """Execute a shell command with safety checks.
 
         Args:
             command: The command to execute
-            cwd: Optional working directory (if None, uses session's current working directory)
+            cwd: Optional working directory
             env: Optional environment variables
             timeout: Optional timeout in seconds
             use_login_shell: Whether to use login shell. default true (loads ~/.zshrc, ~/.bashrc, etc.)
-            session_id: Optional session ID for persistent working directory
+            shell_type: Optional shell to use (e.g., "cmd", "powershell", "wsl", "bash")
 
         Returns:
             CommandResult containing execution results
@@ -234,50 +252,17 @@ class CommandExecutor:
                 return_code=1, error_message=f"Command not allowed: {command}"
             )
 
-        # Use session working directory if no cwd specified and session_id provided
-        effective_cwd = cwd
-        if session_id and not cwd:
-            effective_cwd = self.get_working_dir(session_id)
-            self._log(f"Using session working directory: {effective_cwd}")
-
-        # Check if it's a cd command and update session working directory
-        is_cd_command = False
-        if session_id and command.strip().startswith("cd "):
-            is_cd_command = True
-            args = shlex.split(command)
-            if len(args) > 1:
-                target_dir = args[1]
-                # Handle relative paths
-                if not os.path.isabs(target_dir):
-                    session_cwd = self.get_working_dir(session_id)
-                    target_dir = os.path.join(session_cwd, target_dir)
-                
-                # Expand user paths
-                target_dir = os.path.expanduser(target_dir)
-                
-                # Normalize path
-                target_dir = os.path.normpath(target_dir)
-                
-                if os.path.isdir(target_dir):
-                    self.set_working_dir(session_id, target_dir)
-                    self._log(f"Updated session working directory: {target_dir}")
-                    return CommandResult(return_code=0, stdout="")
-                else:
-                    return CommandResult(
-                        return_code=1, error_message=f"Directory does not exist: {target_dir}"
-                    )
-
         # Check working directory permissions if specified
-        if effective_cwd:
-            if not os.path.isdir(effective_cwd):
+        if cwd:
+            if not os.path.isdir(cwd):
                 return CommandResult(
                     return_code=1,
-                    error_message=f"Working directory does not exist: {effective_cwd}",
+                    error_message=f"Working directory does not exist: {cwd}",
                 )
 
-            if not self.permission_manager.is_path_allowed(effective_cwd):
+            if not self.permission_manager.is_path_allowed(cwd):
                 return CommandResult(
-                    return_code=1, error_message=f"Working directory not allowed: {effective_cwd}"
+                    return_code=1, error_message=f"Working directory not allowed: {cwd}"
                 )
 
         # Set up environment
@@ -286,56 +271,84 @@ class CommandExecutor:
             command_env.update(env)
 
         try:
-            # Check if command uses shell features like &&, ||, |, etc. or $ for env vars
-            shell_operators = ["&&", "||", "|", ";", ">", "<", "$(", "`", "$"]
-            needs_shell = any(op in command for op in shell_operators)
+            # Get shell information
+            shell_basename, user_shell = self._get_system_shell(shell_type)
 
-            if needs_shell or use_login_shell:
-                # Determine which shell to use
-                shell_cmd = command
+            if sys.platform == "win32":
+                # On Windows, always use shell execution
+                self._log(f"Using shell on Windows: {user_shell} ({shell_basename})")
 
-                if use_login_shell:
-                    # Try to find the best available shell
-                    user_shell = self._get_preferred_shell()
-                    shell_basename = os.path.basename(user_shell)
-
-                    self._log(f"Using login shell: {user_shell}")
-
-                    # Wrap command with appropriate shell invocation
-                    if shell_basename == "zsh":
-                        shell_cmd = f"{user_shell} -l -c '{command}'"
-                    elif shell_basename == "bash":
-                        shell_cmd = f"{user_shell} -l -c '{command}'"
-                    elif shell_basename == "fish":
-                        shell_cmd = f"{user_shell} -l -c '{command}'"
-                    else:
-                        # Default fallback
-                        shell_cmd = f"{user_shell} -c '{command}'"
-                else:
-                    self._log(
-                        f"Using shell for command with shell operators: {command}"
-                    )
+                # Format command using helper method
+                shell_cmd = self._format_win32_shell_command(
+                    shell_basename, user_shell, command, use_login_shell
+                )
 
                 # Use shell for command execution
                 process = await asyncio.create_subprocess_shell(
                     shell_cmd,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=effective_cwd,
+                    cwd=cwd,
                     env=command_env,
                 )
             else:
-                # Split the command into arguments for regular commands
-                args: list[str] = shlex.split(command)
-
-                # Create and run the process without shell
-                process = await asyncio.create_subprocess_exec(
-                    *args,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                    cwd=effective_cwd,
-                    env=command_env,
-                )
+                # Unix systems - original logic
+                shell_operators = ["&&", "||", "|", ";", ">", "<", "$(", "`", "$"]
+                needs_shell = any(op in command for op in shell_operators)
+
+                if needs_shell or use_login_shell:
+                    # Determine which shell to use
+                    shell_cmd = command
+
+                    if use_login_shell:
+                        self._log(f"Using login shell: {user_shell} ({shell_basename})")
+
+                        # Escape single quotes in command for shell -c wrapper
+                        # The standard way to escape a single quote within a single-quoted string in POSIX shells is '\''
+                        escaped_command = command.replace("'", "'\\''")
+                        self._log(f"Original command: {command}")
+                        self._log(f"Escaped command: {escaped_command}")
+
+                        # Wrap command with appropriate shell invocation
+                        if shell_basename == "zsh":
+                            shell_cmd = f"{user_shell} -l -c '{escaped_command}'"
+                        elif shell_basename == "bash":
+                            shell_cmd = f"{user_shell} -l -c '{escaped_command}'"
+                        elif shell_basename == "fish":
+                            shell_cmd = f"{user_shell} -l -c '{escaped_command}'"
+                        else:
+                            # Default fallback
+                            shell_cmd = f"{user_shell} -c '{escaped_command}'"
+                    else:
+                        self._log(
+                            f"Using shell for command with shell operators: {command}"
+                        )
+                        # Escape single quotes in command for shell execution
+                        escaped_command = command.replace("'", "'\\''")
+                        self._log(f"Original command: {command}")
+                        self._log(f"Escaped command: {escaped_command}")
+                        shell_cmd = f"{user_shell} -c '{escaped_command}'"
+
+                    # Use shell for command execution
+                    process = await asyncio.create_subprocess_shell(
+                        shell_cmd,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                        cwd=cwd,
+                        env=command_env,
+                    )
+                else:
+                    # Split the command into arguments for regular commands
+                    args: list[str] = shlex.split(command)
+
+                    # Create and run the process without shell
+                    process = await asyncio.create_subprocess_exec(
+                        *args,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                        cwd=cwd,
+                        env=command_env,
+                    )
 
             # Wait for the process to complete with timeout
             try:
@@ -370,44 +383,38 @@ class CommandExecutor:
         script: str,
         interpreter: str = "bash",
         cwd: str | None = None,
+        shell_type: str | None = None,
         env: dict[str, str] | None = None,
         timeout: float | None = 60.0,
         use_login_shell: bool = True,
-        session_id: str | None = None,
     ) -> CommandResult:
         """Execute a script with the specified interpreter.
 
         Args:
             script: The script content to execute
             interpreter: The interpreter to use (bash, python, etc.)
-            cwd: Optional working directory (if None, uses session's current working directory)
+            cwd: Optional working directory
+            shell_type: Optional shell to use (e.g., "cmd", "powershell", "wsl", "bash")
             env: Optional environment variables
             timeout: Optional timeout in seconds
             use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
-            session_id: Optional session ID for persistent working directory
 
         Returns:
             CommandResult containing execution results
         """
         self._log(f"Executing script with interpreter: {interpreter}")
 
-        # Use session working directory if no cwd specified and session_id provided
-        effective_cwd = cwd
-        if session_id and not cwd:
-            effective_cwd = self.get_working_dir(session_id)
-            self._log(f"Using session working directory: {effective_cwd}")
-
         # Check working directory permissions if specified
-        if effective_cwd:
-            if not os.path.isdir(effective_cwd):
+        if cwd:
+            if not os.path.isdir(cwd):
                 return CommandResult(
                     return_code=1,
-                    error_message=f"Working directory does not exist: {effective_cwd}",
+                    error_message=f"Working directory does not exist: {cwd}",
                 )
 
-            if not self.permission_manager.is_path_allowed(effective_cwd):
+            if not self.permission_manager.is_path_allowed(cwd):
                 return CommandResult(
-                    return_code=1, error_message=f"Working directory not allowed: {effective_cwd}"
+                    return_code=1, error_message=f"Working directory not allowed: {cwd}"
                 )
 
         # Check if we need special handling for this interpreter
@@ -415,11 +422,11 @@ class CommandExecutor:
         if interpreter_name in self.special_interpreters:
             self._log(f"Using special handler for interpreter: {interpreter_name}")
             special_handler = self.special_interpreters[interpreter_name]
-            return await special_handler(interpreter, script, effective_cwd, env, timeout)
+            return await special_handler(interpreter, script, cwd, env, timeout)
 
         # Regular execution
         return await self._execute_script_with_stdin(
-            interpreter, script, effective_cwd, env, timeout, use_login_shell
+            interpreter, script, cwd, shell_type, env, timeout, use_login_shell
         )
 
     async def _execute_script_with_stdin(
@@ -427,6 +434,7 @@ class CommandExecutor:
         interpreter: str,
         script: str,
         cwd: str | None = None,
+        shell_type: str | None = None,
         env: dict[str, str] | None = None,
         timeout: float | None = 60.0,
         use_login_shell: bool = True,
@@ -437,6 +445,7 @@ class CommandExecutor:
             interpreter: The interpreter command
             script: The script content
             cwd: Optional working directory
+            shell_type: Optional shell to use (e.g., "cmd", "powershell", "wsl", "bash")
             env: Optional environment variables
             timeout: Optional timeout in seconds
             use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
@@ -450,38 +459,57 @@ class CommandExecutor:
             command_env.update(env)
 
         try:
-            # Determine if we should use a login shell
-            if use_login_shell:
-                # Try to find the best available shell
-                user_shell = self._get_preferred_shell()
-                shell_basename = os.path.basename(user_shell)
+            # Get shell information
+            shell_basename, user_shell = self._get_system_shell(shell_type)
 
-                self._log(f"Using login shell for interpreter: {user_shell}")
+            if sys.platform == "win32":
+                # On Windows, always use shell
+                self._log(f"Using shell on Windows for interpreter: {user_shell}")
 
-                # Create command that pipes script to interpreter through login shell
-                shell_cmd = f"{user_shell} -l -c '{interpreter}'"
+                # Format command using helper method for the interpreter
+                shell_cmd = self._format_win32_shell_command(
+                    shell_basename, user_shell, interpreter, use_login_shell
+                )
 
                 # Create and run the process with shell
                 process = await asyncio.create_subprocess_shell(
                     shell_cmd,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                    cwd=effective_cwd,
-                    env=command_env,
-                )
-            else:
-                # Parse the interpreter command to get arguments
-                interpreter_parts = shlex.split(interpreter)
-
-                # Create and run the process normally
-                process = await asyncio.create_subprocess_exec(
-                    *interpreter_parts,
                     stdin=asyncio.subprocess.PIPE,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=effective_cwd,
+                    cwd=cwd,
                     env=command_env,
                 )
+            else:
+                # Unix systems - original logic
+                if use_login_shell:
+                    self._log(f"Using login shell for interpreter: {user_shell}")
+
+                    # Create command that pipes script to interpreter through login shell
+                    shell_cmd = f"{user_shell} -l -c '{interpreter}'"
+
+                    # Create and run the process with shell
+                    process = await asyncio.create_subprocess_shell(
+                        shell_cmd,
+                        stdin=asyncio.subprocess.PIPE,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                        cwd=cwd,
+                        env=command_env,
+                    )
+                else:
+                    # Parse the interpreter command to get arguments
+                    interpreter_parts = shlex.split(interpreter)
+
+                    # Create and run the process normally
+                    process = await asyncio.create_subprocess_exec(
+                        *interpreter_parts,
+                        stdin=asyncio.subprocess.PIPE,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                        cwd=cwd,
+                        env=command_env,
+                    )
 
             # Wait for the process to complete with timeout
             try:
@@ -592,11 +620,11 @@ class CommandExecutor:
         script: str,
         language: str,
         cwd: str | None = None,
+        shell_type: str | None = None,
         env: dict[str, str] | None = None,
         timeout: float | None = 60.0,
         args: list[str] | None = None,
         use_login_shell: bool = True,
-        session_id: str | None = None,
     ) -> CommandResult:
         """Execute a script by writing it to a temporary file and executing it.
 
@@ -606,60 +634,18 @@ class CommandExecutor:
         Args:
             script: The script content
             language: The script language (determines file extension and interpreter)
-            cwd: Optional working directory (if None, uses session's current working directory)
+            cwd: Optional working directory
+            shell_type: Optional shell to use (e.g., "cmd", "powershell", "wsl", "bash")
             env: Optional environment variables
             timeout: Optional timeout in seconds
             args: Optional command-line arguments
             use_login_shell: Whether to use login shell. default true (loads ~/.zshrc, ~/.bashrc, etc.)
-            session_id: Optional session ID for persistent working directory
 
         Returns:
             CommandResult containing execution results
         """
-        # Use session working directory if no cwd specified and session_id provided
-        effective_cwd = cwd
-        if session_id and not cwd:
-            effective_cwd = self.get_working_dir(session_id)
-            self._log(f"Using session working directory: {effective_cwd}")
-        # Language to interpreter mapping
-        language_map: dict[str, dict[str, str]] = {
-            "python": {
-                "command": "python",
-                "extension": ".py",
-            },
-            "javascript": {
-                "command": "node",
-                "extension": ".js",
-            },
-            "typescript": {
-                "command": "ts-node",
-                "extension": ".ts",
-            },
-            "bash": {
-                "command": "bash",
-                "extension": ".sh",
-            },
-            "fish": {
-                "command": "fish",
-                "extension": ".fish",
-            },
-            "ruby": {
-                "command": "ruby",
-                "extension": ".rb",
-            },
-            "php": {
-                "command": "php",
-                "extension": ".php",
-            },
-            "perl": {
-                "command": "perl",
-                "extension": ".pl",
-            },
-            "r": {
-                "command": "Rscript",
-                "extension": ".R",
-            },
-        }
+        # Get language info from the centralized language map
+        language_map = self._get_language_map()
 
         # Check if the language is supported
         if language not in language_map:
@@ -670,9 +656,13 @@ class CommandExecutor:
 
         # Get language info
         language_info = language_map[language]
-        command = language_info["command"]
         extension = language_info["extension"]
 
+        # Get interpreter command with full path if possible
+        command, language_args = self._get_interpreter_path(language, shell_type)
+
+        self._log(f"Interpreter path: {command} :: {language_args}")
+
         # Set up environment
         command_env: dict[str, str] = os.environ.copy()
         if env:
@@ -686,48 +676,97 @@ class CommandExecutor:
             _ = temp.write(script)  # Explicitly ignore the return value
 
         try:
-            # Determine if we should use a login shell
-            if use_login_shell:
-                # Try to find the best available shell
-                user_shell = self._get_preferred_shell()
-                shell_basename = os.path.basename(user_shell)
+            # Normalize path for the current OS
+            temp_path = os.path.normpath(temp_path)
+            original_temp_path = temp_path
+
+            if sys.platform == "win32":
+                # Windows always uses shell
+                shell_basename, user_shell = self._get_system_shell(shell_type)
+
+                # Convert Windows path to WSL path if using WSL
+                if shell_basename in ["wsl", "wsl.exe"]:
+                    match = re.match(r"([a-zA-Z]):\\(.*)", temp_path)
+                    if match:
+                        drive, path = match.groups()
+                        wsl_path = f"/mnt/{drive.lower()}/{path.replace('\\', '/')}"
+                    else:
+                        wsl_path = temp_path.replace("\\", "/")
+                        self._log(f"WSL path conversion may be incomplete: {wsl_path}")
 
-                self._log(f"Using login shell for script execution: {user_shell}")
+                    self._log(
+                        f"Converted Windows path '{temp_path}' to WSL path '{wsl_path}'"
+                    )
+                    temp_path = wsl_path
 
                 # Build the command including args
                 cmd = f"{command} {temp_path}"
+                if language_args:
+                    cmd = f"{command} {' '.join(language_args)} {temp_path}"
                 if args:
                     cmd += " " + " ".join(args)
 
-                # Create command that runs script through login shell
-                shell_cmd = f"{user_shell} -l -c '{cmd}'"
+                # Format command using helper method
+                shell_cmd = self._format_win32_shell_command(
+                    shell_basename, user_shell, cmd, use_login_shell
+                )
 
-                self._log(f"Executing script from file with login shell: {shell_cmd}")
+                self._log(
+                    f"Executing script from file on Windows with shell: {shell_cmd}"
+                )
 
                 # Create and run the process with shell
                 process = await asyncio.create_subprocess_shell(
                     shell_cmd,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=effective_cwd,
+                    cwd=cwd,
                     env=command_env,
                 )
             else:
-                # Build command arguments
-                cmd_args = [command, temp_path]
-                if args:
-                    cmd_args.extend(args)
+                # Unix systems - original logic
+                if use_login_shell:
+                    # Get the user's login shell
+                    shell_basename, user_shell = self._get_system_shell(shell_type)
 
-                self._log(f"Executing script from file with: {' '.join(cmd_args)}")
+                    # Build the command including args
+                    cmd = f"{command} {temp_path}"
+                    if language_args:
+                        cmd = f"{command} {' '.join(language_args)} {temp_path}"
+                    if args:
+                        cmd += " " + " ".join(args)
 
-                # Create and run the process normally
-                process = await asyncio.create_subprocess_exec(
-                    *cmd_args,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                    cwd=effective_cwd,
-                    env=command_env,
-                )
+                    # Create command that runs script through login shell
+                    shell_cmd = f"{user_shell} -l -c '{cmd}'"
+
+                    self._log(
+                        f"Executing script from file with login shell: {shell_cmd}"
+                    )
+
+                    # Create and run the process with shell
+                    process = await asyncio.create_subprocess_shell(
+                        shell_cmd,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                        cwd=cwd,
+                        env=command_env,
+                    )
+                else:
+                    # Build command arguments
+                    cmd_args = [command] + language_args + [temp_path]
+                    if args:
+                        cmd_args.extend(args)
+
+                    self._log(f"Executing script from file with: {' '.join(cmd_args)}")
+
+                    # Create and run the process normally
+                    process = await asyncio.create_subprocess_exec(
+                        *cmd_args,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                        cwd=cwd,
+                        env=command_env,
+                    )
 
             # Wait for the process to complete with timeout
             try:
@@ -759,127 +798,139 @@ class CommandExecutor:
         finally:
             # Clean up temporary file
             try:
-                os.unlink(temp_path)
+                os.unlink(original_temp_path)
             except Exception as e:
                 self._log(f"Error cleaning up temporary file: {str(e)}")
 
-    def get_available_languages(self) -> list[str]:
-        """Get a list of available script languages.
+    def _get_language_map(self) -> dict[str, dict[str, str | list[str]]]:
+        """Get the mapping of languages to interpreter information.
+
+        This is a single source of truth for language mappings used by
+        both execute_script_from_file and get_available_languages.
 
         Returns:
-            List of supported language names
+            Dictionary mapping language names to interpreter information
         """
-        # Use the same language map as in execute_script_from_file method
-        language_map = {
-            "python": {"command": "python", "extension": ".py"},
-            "javascript": {"command": "node", "extension": ".js"},
-            "typescript": {"command": "ts-node", "extension": ".ts"},
-            "bash": {"command": "bash", "extension": ".sh"},
-            "fish": {"command": "fish", "extension": ".fish"},
-            "ruby": {"command": "ruby", "extension": ".rb"},
-            "php": {"command": "php", "extension": ".php"},
-            "perl": {"command": "perl", "extension": ".pl"},
-            "r": {"command": "Rscript", "extension": ".R"},
+        return {
+            "python": {
+                "command": "python",
+                "extension": ".py",
+                "alternatives": ["python3"],  # Alternative command names to try
+            },
+            "javascript": {
+                "command": "node",
+                "extension": ".js",
+                "alternatives": ["nodejs"],
+            },
+            "typescript": {
+                "command": "ts-node",
+                "extension": ".ts",
+            },
+            "bash": {
+                "command": "bash",
+                "extension": ".sh",
+            },
+            "fish": {
+                "command": "fish",
+                "extension": ".fish",
+            },
+            "ruby": {
+                "command": "ruby",
+                "extension": ".rb",
+            },
+            "php": {
+                "command": "php",
+                "extension": ".php",
+            },
+            "perl": {
+                "command": "perl",
+                "extension": ".pl",
+            },
+            "r": {"command": "Rscript", "extension": ".R", "alternatives": ["R"]},
+            # Windows-specific languages
+            "batch": {
+                "command": "cmd.exe",
+                "extension": ".bat",
+                "args": ["/c"],
+            },
+            "powershell": {
+                "command": "powershell.exe",
+                "extension": ".ps1",
+                "args": ["-ExecutionPolicy", "Bypass", "-File"],
+                "alternatives": ["pwsh.exe", "pwsh"],
+            },
         }
-        return list(language_map.keys())
 
-    # Legacy method to keep backwards compatibility with tests
-    def register_tools(self, mcp_server: FastMCP) -> None:
-        """Register command execution tools with the MCP server.
-        
-        Legacy method for backwards compatibility with existing tests.
-        New code should use the modular tool classes instead.
+    def _get_interpreter_path(
+        self, language: str, shell_type: str | None = None
+    ) -> tuple[str, list[str]]:
+        """Get the full path to the interpreter for the given language.
+
+        Attempts to find the full path to the interpreter command, but only for
+        Windows shell types (cmd, powershell). For WSL, just returns the command name.
 
         Args:
-            mcp_server: The FastMCP server instance
+            language: The language name (e.g., "python", "javascript")
+            shell_type: Optional shell type (e.g., "wsl", "cmd", "powershell")
+
+        Returns:
+            Tuple of (interpreter_command, args) where:
+              - interpreter_command is either the full path to the interpreter or the command name
+              - args is a list of additional arguments to pass to the interpreter
         """
-        # Run Command Tool - keep original method names for test compatibility
-        @mcp_server.tool()
-        async def run_command(
-            command: str,
-            cwd: str,
-            ctx: MCPContext,
-            use_login_shell: bool = True,
-        ) -> str:
-            tool_ctx = create_tool_context(ctx)
-            tool_ctx.set_tool_info("run_command")
-            await tool_ctx.info(f"Executing command: {command}")
-
-            # Use request_id as session_id for persistent working directory
-            session_id = ctx.request_id
-
-            # Run validations and execute
-            result = await self.execute_command(
-                command, 
-                cwd, 
-                timeout=30.0, 
-                use_login_shell=use_login_shell,
-                session_id=session_id
-            )
-            
-            if result.is_success:
-                return result.stdout
-            else:
-                return result.format_output()
-                
-        # Run Script Tool
-        @mcp_server.tool()
-        async def run_script(
-            script: str,
-            cwd: str,
-            ctx: MCPContext,
-            interpreter: str = "bash",
-            use_login_shell: bool = True,
-        ) -> str:
-            tool_ctx = create_tool_context(ctx)
-            tool_ctx.set_tool_info("run_script")
-            
-            # Use request_id as session_id for persistent working directory
-            session_id = ctx.request_id
-            
-            # Execute the script
-            result = await self.execute_script(
-                script=script,
-                interpreter=interpreter,
-                cwd=cwd,
-                timeout=30.0,
-                use_login_shell=use_login_shell,
-                session_id=session_id,
-            )
-            
-            if result.is_success:
-                return result.stdout
-            else:
-                return result.format_output()
-                
-        # Script tool for executing scripts in various languages
-        @mcp_server.tool()
-        async def script_tool(
-            language: str,
-            script: str,
-            cwd: str,
-            ctx: MCPContext,
-            args: list[str] | None = None,
-            use_login_shell: bool = True,
-        ) -> str:
-            tool_ctx = create_tool_context(ctx)
-            tool_ctx.set_tool_info("script_tool")
-            
-            # Use request_id as session_id for persistent working directory
-            session_id = ctx.request_id
-            
-            # Execute the script
-            result = await self.execute_script_from_file(
-                script=script,
-                language=language,
-                cwd=cwd,
-                timeout=30.0,
-                args=args,
-                use_login_shell=use_login_shell,
-                session_id=session_id
-            )
-            
-            if result.is_success:
-                return result.stdout
-            else:
-                return result.format_output()
+        language_map = self._get_language_map()
+
+        if language not in language_map:
+            # Return the language name itself as a fallback
+            return language, []
+
+        language_info = language_map[language]
+        command = language_info["command"]
+        args = language_info.get("args", [])
+        alternatives = language_info.get("alternatives", [])
+
+        # Special handling for WSL - use command name directly (not Windows paths)
+        if shell_type and shell_type.lower() in ["wsl", "wsl.exe"]:
+            # For Python specifically, use python3 in WSL environments
+            if language.lower() == "python":
+                return "python3", args
+            # For other languages, just use the command name
+            return command, args
+
+        # For Windows shell types, try to find the full path
+        if sys.platform == "win32" and (
+            not shell_type
+            or shell_type.lower() in ["cmd", "powershell", "cmd.exe", "powershell.exe"]
+        ):
+            try:
+                # Try to find the full path to the command
+                full_path = shutil.which(command)
+                if full_path:
+                    self._log(
+                        f"Found full path for {language} interpreter: {full_path}"
+                    )
+                    return full_path, args
+
+                # If primary command not found, try alternatives
+                for alt_command in alternatives:
+                    alt_path = shutil.which(alt_command)
+                    if alt_path:
+                        self._log(
+                            f"Found alternative path for {language} interpreter: {alt_path}"
+                        )
+                        return alt_path, args
+            except Exception as e:
+                self._log(f"Error finding path for {language} interpreter: {str(e)}")
+
+        # If we can't find the full path or it's not appropriate, return the command name
+        self._log(f"Using command name for {language} interpreter: {command}")
+        return command, args
+
+    def get_available_languages(self) -> list[str]:
+        """Get a list of available script languages.
+
+        Returns:
+            List of supported language names
+        """
+        # Use the centralized language map
+        return list(self._get_language_map().keys())