hanzo-mcp 0.1.25__py3-none-any.whl → 0.1.30__py3-none-any.whl

hanzo_mcp/tools/shell/command_executor.py

@@ -11,77 +11,16 @@ import shlex
 import sys
 import tempfile
 from collections.abc import Awaitable, Callable
-from typing import final
+from pathlib import Path
+from typing import Dict, Optional, 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
-
-
-@final
-class CommandResult:
-    """Represents the result of a command execution."""
-
-    def __init__(
-        self,
-        return_code: int = 0,
-        stdout: str = "",
-        stderr: str = "",
-        error_message: str | None = None,
-    ):
-        """Initialize a command result.
-
-        Args:
-            return_code: The command's return code (0 for success)
-            stdout: Standard output from the command
-            stderr: Standard error from the command
-            error_message: Optional error message for failure cases
-        """
-        self.return_code: int = return_code
-        self.stdout: str = stdout
-        self.stderr: str = stderr
-        self.error_message: str | None = error_message
-
-    @property
-    def is_success(self) -> bool:
-        """Check if the command executed successfully.
-
-        Returns:
-            True if the command succeeded, False otherwise
-        """
-        return self.return_code == 0
-
-    def format_output(self, include_exit_code: bool = True) -> str:
-        """Format the command output as a string.
-
-        Args:
-            include_exit_code: Whether to include the exit code in the output
-
-        Returns:
-            Formatted output string
-        """
-        result_parts: list[str] = []
-
-        # Add error message if present
-        if self.error_message:
-            result_parts.append(f"Error: {self.error_message}")
-
-        # Add exit code if requested and not zero (for non-errors)
-        if include_exit_code and (self.return_code != 0 or not self.error_message):
-            result_parts.append(f"Exit code: {self.return_code}")
-
-        # Add stdout if present
-        if self.stdout:
-            result_parts.append(f"STDOUT:\n{self.stdout}")
-
-        # Add stderr if present
-        if self.stderr:
-            result_parts.append(f"STDERR:\n{self.stderr}")
-
-        # Join with newlines
-        return "\n\n".join(result_parts)
+from hanzo_mcp.tools.common.session import SessionManager
+from hanzo_mcp.tools.shell.base import CommandResult
 
 
 @final
@@ -104,14 +43,17 @@ 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 | None, dict[str, str] | None, float | None],
+                [str, str, str], dict[str, str]], Optional[float | None | None,
                 Awaitable[CommandResult],
             ],
         ] = {
@@ -136,7 +78,78 @@ class CommandExecutor:
         if command not in self.excluded_commands:
             self.excluded_commands.append(command)
 
-    def _log(self, message: str, data: object = None) -> None:
+    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
+        """
+        # 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.
+
+        Args:
+            session_id: The session ID
+
+        Returns:
+            The session manager instance
+        """
+        return SessionManager.get_instance(session_id)
+
+    def set_working_dir(self, session_id: str, path: str) -> None:
+        """Set the current working directory for the session.
+
+        Args:
+            session_id: The session ID
+            path: The path to set as the current working directory
+        """
+        session = self.get_session_manager(session_id)
+        expanded_path = os.path.expanduser(path)
+        session.set_working_dir(Path(expanded_path))
+
+    def get_working_dir(self, session_id: str) -> str:
+        """Get the current working directory for the session.
+
+        Args:
+            session_id: The session ID
+
+        Returns:
+            The current working directory
+        """
+        session = self.get_session_manager(session_id)
+        return str(session.current_working_dir)
+
+    def _log(self, message: str, data: object | None = None) -> None:
         """Log a message if verbose logging is enabled.
 
         Args:
@@ -193,17 +206,19 @@ class CommandExecutor:
         command: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 600.0,
+        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
+            cwd: Optional working directory (if None, uses session's current 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
 
         Returns:
             CommandResult containing execution results
@@ -216,17 +231,50 @@ 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 cwd:
-            if not os.path.isdir(cwd):
+        if effective_cwd:
+            if not os.path.isdir(effective_cwd):
                 return CommandResult(
                     return_code=1,
-                    error_message=f"Working directory does not exist: {cwd}",
+                    error_message=f"Working directory does not exist: {effective_cwd}",
                 )
 
-            if not self.permission_manager.is_path_allowed(cwd):
+            if not self.permission_manager.is_path_allowed(effective_cwd):
                 return CommandResult(
-                    return_code=1, error_message=f"Working directory not allowed: {cwd}"
+                    return_code=1, error_message=f"Working directory not allowed: {effective_cwd}"
                 )
 
         # Set up environment
@@ -244,8 +292,8 @@ class CommandExecutor:
                 shell_cmd = command
 
                 if use_login_shell:
-                    # Get the user's login shell
-                    user_shell = os.environ.get("SHELL", "/bin/bash")
+                    # 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}")
@@ -270,7 +318,7 @@ class CommandExecutor:
                     shell_cmd,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=cwd,
+                    cwd=effective_cwd,
                     env=command_env,
                 )
             else:
@@ -282,7 +330,7 @@ class CommandExecutor:
                     *args,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=cwd,
+                    cwd=effective_cwd,
                     env=command_env,
                 )
 
@@ -320,34 +368,43 @@ class CommandExecutor:
         interpreter: str = "bash",
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 600.0,
+        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
+            cwd: Optional working directory (if None, uses session's current working directory)
             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 cwd:
-            if not os.path.isdir(cwd):
+        if effective_cwd:
+            if not os.path.isdir(effective_cwd):
                 return CommandResult(
                     return_code=1,
-                    error_message=f"Working directory does not exist: {cwd}",
+                    error_message=f"Working directory does not exist: {effective_cwd}",
                 )
 
-            if not self.permission_manager.is_path_allowed(cwd):
+            if not self.permission_manager.is_path_allowed(effective_cwd):
                 return CommandResult(
-                    return_code=1, error_message=f"Working directory not allowed: {cwd}"
+                    return_code=1, error_message=f"Working directory not allowed: {effective_cwd}"
                 )
 
         # Check if we need special handling for this interpreter
@@ -355,11 +412,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, cwd, env, timeout)
+            return await special_handler(interpreter, script, effective_cwd, env, timeout)
 
         # Regular execution
         return await self._execute_script_with_stdin(
-            interpreter, script, cwd, env, timeout, use_login_shell
+            interpreter, script, effective_cwd, env, timeout, use_login_shell
         )
 
     async def _execute_script_with_stdin(
@@ -368,7 +425,7 @@ class CommandExecutor:
         script: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 600.0,
+        timeout: float | None = 60.0,
         use_login_shell: bool = True,
     ) -> CommandResult:
         """Execute a script by passing it to stdin of the interpreter.
@@ -379,6 +436,7 @@ class CommandExecutor:
             cwd: Optional working directory
             env: Optional environment variables
             timeout: Optional timeout in seconds
+            use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
 
         Returns:
             CommandResult containing execution results
@@ -391,9 +449,9 @@ class CommandExecutor:
         try:
             # Determine if we should use a login shell
             if use_login_shell:
-                # Get the user's login shell
-                user_shell = os.environ.get("SHELL", "/bin/bash")
-                os.path.basename(user_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 for interpreter: {user_shell}")
 
@@ -403,10 +461,9 @@ class CommandExecutor:
                 # 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,
+                    cwd=effective_cwd,
                     env=command_env,
                 )
             else:
@@ -419,7 +476,7 @@ class CommandExecutor:
                     stdin=asyncio.subprocess.PIPE,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=cwd,
+                    cwd=effective_cwd,
                     env=command_env,
                 )
 
@@ -458,7 +515,7 @@ class CommandExecutor:
         script: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 600.0,
+        timeout: float | None = 60.0,
     ) -> CommandResult:
         """Special handler for Fish shell scripts.
 
@@ -533,9 +590,10 @@ class CommandExecutor:
         language: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 600.0,
+        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.
 
@@ -545,16 +603,21 @@ class CommandExecutor:
         Args:
             script: The script content
             language: The script language (determines file extension and interpreter)
-            cwd: Optional working directory
+            cwd: Optional working directory (if None, uses session's current working directory)
             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": {
@@ -622,9 +685,9 @@ class CommandExecutor:
         try:
             # Determine if we should use a login shell
             if use_login_shell:
-                # Get the user's login shell
-                user_shell = os.environ.get("SHELL", "/bin/bash")
-                os.path.basename(user_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 for script execution: {user_shell}")
 
@@ -643,7 +706,7 @@ class CommandExecutor:
                     shell_cmd,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=cwd,
+                    cwd=effective_cwd,
                     env=command_env,
                 )
             else:
@@ -659,7 +722,7 @@ class CommandExecutor:
                     *cmd_args,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
-                    cwd=cwd,
+                    cwd=effective_cwd,
                     env=command_env,
                 )
 
@@ -717,14 +780,17 @@ class CommandExecutor:
         }
         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.
 
         Args:
             mcp_server: The FastMCP server instance
         """
-
-        # Run Command Tool
+        # Run Command Tool - keep original method names for test compatibility
         @mcp_server.tool()
         async def run_command(
             command: str,
@@ -732,68 +798,27 @@ class CommandExecutor:
             ctx: MCPContext,
             use_login_shell: bool = True,
         ) -> str:
-            """Execute a shell command.
-
-            Args:
-                command: The shell command to execute
-                cwd: Working directory for the command
-
-                use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
-
-            Returns:
-                The output of the command
-            """
             tool_ctx = create_tool_context(ctx)
             tool_ctx.set_tool_info("run_command")
             await tool_ctx.info(f"Executing command: {command}")
 
-            # Check if command is allowed
-            if not self.is_command_allowed(command):
-                await tool_ctx.error(f"Command not allowed: {command}")
-                return f"Error: Command not allowed: {command}"
-
-            # Validate required cwd parameter
-            if not cwd:
-                await tool_ctx.error("Parameter 'cwd' is required but was None")
-                return "Error: Parameter 'cwd' is required but was None"
-
-            if cwd.strip() == "":
-                await tool_ctx.error("Parameter 'cwd' cannot be empty")
-                return "Error: Parameter 'cwd' cannot be empty"
-
-            # Check if working directory is allowed
-            if not self.permission_manager.is_path_allowed(cwd):
-                await tool_ctx.error(f"Working directory not allowed: {cwd}")
-                return f"Error: Working directory not allowed: {cwd}"
-
-            # Check if working directory exists
-            if not os.path.isdir(cwd):
-                await tool_ctx.error(f"Working directory does not exist: {cwd}")
-                return f"Error: Working directory does not exist: {cwd}"
-
-            # Execute the command
-            result: CommandResult = await self.execute_command(
-                command, cwd=cwd, timeout=600.0, use_login_shell=use_login_shell
-            )
-
-            # Report result
-            if result.is_success:
-                await tool_ctx.info("Command executed successfully")
-            else:
-                await tool_ctx.error(
-                    f"Command failed with exit code {result.return_code}"
-                )
+            # Use request_id as session_id for persistent working directory
+            session_id = ctx.request_id
 
-            # Format the result
+            # 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:
-                # For successful commands, just return stdout unless stderr has content
-                if result.stderr:
-                    return f"Command executed successfully.\n\nSTDOUT:\n{result.stdout}\n\nSTDERR:\n{result.stderr}"
                 return result.stdout
             else:
-                # For failed commands, include all available information
                 return result.format_output()
-
+                
         # Run Script Tool
         @mcp_server.tool()
         async def run_script(
@@ -803,94 +828,27 @@ class CommandExecutor:
             interpreter: str = "bash",
             use_login_shell: bool = True,
         ) -> str:
-            """Execute a script with the specified interpreter.
-
-            Args:
-                script: The script content to execute
-                cwd: Working directory for script execution
-
-                interpreter: The interpreter to use (bash, python, etc.)
-                use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
-
-            Returns:
-                The output of the script
-            """
             tool_ctx = create_tool_context(ctx)
             tool_ctx.set_tool_info("run_script")
-
-            # Validate script parameter
-            if not script:
-                await tool_ctx.error("Parameter 'script' is required but was None")
-                return "Error: Parameter 'script' is required but was None"
-
-            if script.strip() == "":
-                await tool_ctx.error("Parameter 'script' cannot be empty")
-                return "Error: Parameter 'script' cannot be empty"
-
-            # interpreter can be None safely as it has a default value
-            if not interpreter:
-                interpreter = "bash"  # Use default if None
-            elif interpreter.strip() == "":
-                await tool_ctx.error("Parameter 'interpreter' cannot be empty")
-                return "Error: Parameter 'interpreter' cannot be empty"
-
-            # Validate required cwd parameter
-            if not cwd:
-                await tool_ctx.error("Parameter 'cwd' is required but was None")
-                return "Error: Parameter 'cwd' is required but was None"
-
-            if cwd.strip() == "":
-                await tool_ctx.error("Parameter 'cwd' cannot be empty")
-                return "Error: Parameter 'cwd' cannot be empty"
-
-            await tool_ctx.info(f"Executing script with interpreter: {interpreter}")
-
-            # Validate required cwd parameter
-            if not cwd:
-                await tool_ctx.error("Parameter 'cwd' is required but was None")
-                return "Error: Parameter 'cwd' is required but was None"
-
-            if cwd.strip() == "":
-                await tool_ctx.error("Parameter 'cwd' cannot be empty")
-                return "Error: Parameter 'cwd' cannot be empty"
-
-            # Check if working directory is allowed
-            if not self.permission_manager.is_path_allowed(cwd):
-                await tool_ctx.error(f"Working directory not allowed: {cwd}")
-                return f"Error: Working directory not allowed: {cwd}"
-
-            # Check if working directory exists
-            if not os.path.isdir(cwd):
-                await tool_ctx.error(f"Working directory does not exist: {cwd}")
-                return f"Error: Working directory does not exist: {cwd}"
-
+            
+            # Use request_id as session_id for persistent working directory
+            session_id = ctx.request_id
+            
             # Execute the script
-            result: CommandResult = await self.execute_script(
+            result = await self.execute_script(
                 script=script,
                 interpreter=interpreter,
-                cwd=cwd,  # cwd is now a required parameter
-                timeout=600.0,
+                cwd=cwd,
+                timeout=30.0,
                 use_login_shell=use_login_shell,
+                session_id=session_id,
             )
-
-            # Report result
-            if result.is_success:
-                await tool_ctx.info("Script executed successfully")
-            else:
-                await tool_ctx.error(
-                    f"Script execution failed with exit code {result.return_code}"
-                )
-
-            # Format the result
+            
             if result.is_success:
-                # For successful scripts, just return stdout unless stderr has content
-                if result.stderr:
-                    return f"Script executed successfully.\n\nSTDOUT:\n{result.stdout}\n\nSTDERR:\n{result.stderr}"
                 return result.stdout
             else:
-                # For failed scripts, include all available information
                 return result.format_output()
-
+                
         # Script tool for executing scripts in various languages
         @mcp_server.tool()
         async def script_tool(
@@ -901,101 +859,24 @@ class CommandExecutor:
             args: list[str] | None = None,
             use_login_shell: bool = True,
         ) -> str:
-            """Execute a script in the specified language.
-
-            Args:
-                language: The programming language (python, javascript, etc.)
-                script: The script code to execute
-                cwd: Working directory for script execution
-
-                args: Optional command-line arguments
-                use_login_shell: Whether to use login shell (loads ~/.zshrc, ~/.bashrc, etc.)
-
-            Returns:
-                Script execution results
-            """
             tool_ctx = create_tool_context(ctx)
             tool_ctx.set_tool_info("script_tool")
-
-            # Validate required parameters
-            if not language:
-                await tool_ctx.error("Parameter 'language' is required but was None")
-                return "Error: Parameter 'language' is required but was None"
-
-            if language.strip() == "":
-                await tool_ctx.error("Parameter 'language' cannot be empty")
-                return "Error: Parameter 'language' cannot be empty"
-
-            if not script:
-                await tool_ctx.error("Parameter 'script' is required but was None")
-                return "Error: Parameter 'script' is required but was None"
-
-            if script.strip() == "":
-                await tool_ctx.error("Parameter 'script' cannot be empty")
-                return "Error: Parameter 'script' cannot be empty"
-
-            # args can be None as it's optional
-            # Check for empty list but still allow None
-            if args is not None and len(args) == 0:
-                await tool_ctx.warning("Parameter 'args' is an empty list")
-                # We don't return error for this as empty args is acceptable
-
-            # Validate required cwd parameter
-            if not cwd:
-                await tool_ctx.error("Parameter 'cwd' is required but was None")
-                return "Error: Parameter 'cwd' is required but was None"
-
-            if cwd.strip() == "":
-                await tool_ctx.error("Parameter 'cwd' cannot be empty")
-                return "Error: Parameter 'cwd' cannot be empty"
-
-            await tool_ctx.info(f"Executing {language} script")
-
-            # Check if the language is supported
-            if language not in self.get_available_languages():
-                await tool_ctx.error(f"Unsupported language: {language}")
-                return f"Error: Unsupported language: {language}. Supported languages: {', '.join(self.get_available_languages())}"
-
-            # Check if working directory is allowed
-            if not self.permission_manager.is_path_allowed(cwd):
-                await tool_ctx.error(f"Working directory not allowed: {cwd}")
-                return f"Error: Working directory not allowed: {cwd}"
-
-            # Check if working directory exists
-            if not os.path.isdir(cwd):
-                await tool_ctx.error(f"Working directory does not exist: {cwd}")
-                return f"Error: Working directory does not exist: {cwd}"
-
-            # Proceed with execution
-            await tool_ctx.info(f"Executing {language} script in {cwd}")
-
+            
+            # 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,  # cwd is now a required parameter
-                timeout=600.0,
+                cwd=cwd,
+                timeout=30.0,
                 args=args,
                 use_login_shell=use_login_shell,
+                session_id=session_id
             )
-
-            # Report result
-            if result.is_success:
-                await tool_ctx.info(f"{language} script executed successfully")
-            else:
-                await tool_ctx.error(
-                    f"{language} script execution failed with exit code {result.return_code}"
-                )
-
-            # Format the result
+            
             if result.is_success:
-                # Format the successful result
-                output = f"{language} script executed successfully.\n\n"
-                if result.stdout:
-                    output += f"STDOUT:\n{result.stdout}\n\n"
-                if result.stderr:
-                    output += f"STDERR:\n{result.stderr}"
-                return output.strip()
+                return result.stdout
             else:
-                # For failed scripts, include all available information
                 return result.format_output()