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

hanzo_mcp/tools/shell/__init__.py

@@ -3,21 +3,17 @@
 This package provides tools for executing shell commands and scripts.
 """
 
-from mcp.server.fastmcp import FastMCP
+import shutil
+
+from fastmcp import FastMCP
 
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.shell.bash_session_executor import BashSessionExecutor
 from hanzo_mcp.tools.shell.command_executor import CommandExecutor
-from hanzo_mcp.tools.shell.run_command import RunCommandTool
-from hanzo_mcp.tools.shell.run_script import RunScriptTool
-from hanzo_mcp.tools.shell.script_tool import ScriptTool
 
 # Export all tool classes
 __all__ = [
-    "RunCommandTool",
-    "RunScriptTool",
-    "ScriptTool",
-    "CommandExecutor",
     "get_shell_tools",
     "register_shell_tools",
 ]
@@ -27,32 +23,45 @@ def get_shell_tools(
     permission_manager: PermissionManager,
 ) -> list[BaseTool]:
     """Create instances of all shell tools.
-    
+
     Args:
         permission_manager: Permission manager for access control
-        
+
     Returns:
         List of shell tool instances
     """
-    # Initialize the command executor
-    command_executor = CommandExecutor(permission_manager)
-    
-    return [
-        RunCommandTool(permission_manager, command_executor),
-        RunScriptTool(permission_manager, command_executor),
-        ScriptTool(permission_manager, command_executor),
-    ]
+    # Detect tmux availability and choose appropriate implementation
+    if shutil.which("tmux") is not None:
+        # Use tmux-based implementation for interactive sessions
+        from hanzo_mcp.tools.shell.run_command import RunCommandTool
+
+        command_executor = BashSessionExecutor(permission_manager)
+        return [
+            RunCommandTool(permission_manager, command_executor),
+        ]
+    else:
+        # Use Windows-compatible implementation
+        from hanzo_mcp.tools.shell.run_command_windows import RunCommandTool
+
+        command_executor = CommandExecutor(permission_manager)
+        return [
+            RunCommandTool(permission_manager, command_executor),
+        ]
 
 
 def register_shell_tools(
     mcp_server: FastMCP,
     permission_manager: PermissionManager,
-) -> None:
+) -> list[BaseTool]:
     """Register all shell tools with the MCP server.
-    
+
     Args:
         mcp_server: The FastMCP server instance
         permission_manager: Permission manager for access control
+
+    Returns:
+        List of registered tools
     """
     tools = get_shell_tools(permission_manager)
     ToolRegistry.register_tools(mcp_server, tools)
+    return tools

hanzo_mcp/tools/shell/base.py

@@ -5,19 +5,27 @@ including command execution, script running, and process management.
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, final
-from typing_extensions import override
+from enum import Enum
+from typing import Any, Self, final
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
+from fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 
 
+class BashCommandStatus(Enum):
+    """Status of bash command execution."""
+
+    CONTINUE = "continue"
+    COMPLETED = "completed"
+    NO_CHANGE_TIMEOUT = "no_change_timeout"
+    HARD_TIMEOUT = "hard_timeout"
+
+
 @final
 class CommandResult:
-    """Represents the result of a command execution."""
+    """Represents the result of a command execution with rich metadata."""
 
     def __init__(
         self,
@@ -25,6 +33,9 @@ class CommandResult:
         stdout: str = "",
         stderr: str = "",
         error_message: str | None = None,
+        session_id: str | None = None,
+        status: BashCommandStatus = BashCommandStatus.COMPLETED,
+        command: str = "",
     ):
         """Initialize a command result.
 
@@ -33,11 +44,17 @@ class CommandResult:
             stdout: Standard output from the command
             stderr: Standard error from the command
             error_message: Optional error message for failure cases
+            session_id: Optional session ID used for the command execution
+            status: Command execution status
+            command: The original command that was executed
         """
         self.return_code: int = return_code
         self.stdout: str = stdout
         self.stderr: str = stderr
         self.error_message: str | None = error_message
+        self.session_id: str | None = session_id
+        self.status: BashCommandStatus = status
+        self.command: str = command
 
     @property
     def is_success(self) -> bool:
@@ -46,7 +63,41 @@ class CommandResult:
         Returns:
             True if the command succeeded, False otherwise
         """
-        return self.return_code == 0
+        return (
+            self.return_code == 0
+            and self.status == BashCommandStatus.COMPLETED
+            and not self.error_message
+        )
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the command is still running.
+
+        Returns:
+            True if the command is still running, False otherwise
+        """
+        return self.status in {
+            BashCommandStatus.CONTINUE,
+            BashCommandStatus.NO_CHANGE_TIMEOUT,
+            BashCommandStatus.HARD_TIMEOUT,
+        }
+
+    @property
+    def exit_code(self) -> int:
+        """Get the exit code (alias for return_code for compatibility)."""
+        return self.return_code
+
+    @property
+    def error(self) -> bool:
+        """Check if there was an error."""
+        return not self.is_success
+
+    @property
+    def message(self) -> str:
+        """Get a human-readable message about the command result."""
+        if self.error_message:
+            return f"Command `{self.command}` failed: {self.error_message}"
+        return f"Command `{self.command}` executed with exit code {self.return_code}."
 
     def format_output(self, include_exit_code: bool = True) -> str:
         """Format the command output as a string.
@@ -59,6 +110,14 @@ class CommandResult:
         """
         result_parts: list[str] = []
 
+        # Add session ID if present
+        if self.session_id:
+            result_parts.append(f"Session ID: {self.session_id}")
+
+        # Add command status
+        if self.status != BashCommandStatus.COMPLETED:
+            result_parts.append(f"Status: {self.status.value}")
+
         # Add error message if present
         if self.error_message:
             result_parts.append(f"Error: {self.error_message}")
@@ -78,71 +137,54 @@ class CommandResult:
         # Join with newlines
         return "\n\n".join(result_parts)
 
+    def to_agent_observation(self) -> str:
+        """Format the result for agent consumption."""
+        content = self.stdout
+
+        additional_info: list[str] = []
+        if self.session_id:
+            additional_info.append(f"[Session ID: {self.session_id}]")
+
+        if additional_info:
+            content += "\n" + "\n".join(additional_info)
+
+        return content
+
 
 class ShellBaseTool(BaseTool, ABC):
     """Base class for shell-related tools.
-    
+
     Provides common functionality for executing commands and scripts,
     including permissions checking.
     """
-    
+
     def __init__(self, permission_manager: PermissionManager) -> None:
         """Initialize the shell base tool.
-        
+
         Args:
             permission_manager: Permission manager for access control
         """
         self.permission_manager: PermissionManager = permission_manager
-        
+
     def is_path_allowed(self, path: str) -> bool:
         """Check if a path is allowed according to permission settings.
-        
+
         Args:
             path: Path to check
-            
+
         Returns:
             True if the path is allowed, False otherwise
         """
         return self.permission_manager.is_path_allowed(path)
-    
+
     @abstractmethod
     async def prepare_tool_context(self, ctx: MCPContext) -> Any:
         """Create and prepare the tool context.
-        
+
         Args:
             ctx: MCP context
-            
+
         Returns:
             Prepared tool context
         """
         pass
-        
-    @override 
-    def register(self, mcp_server: FastMCP) -> None:
-        """Register this shell tool with the MCP server.
-        
-        This provides a default implementation that derived classes should override
-        with more specific parameter definitions. This implementation uses generic
-        **kwargs which doesn't provide proper parameter definitions to MCP.
-        
-        Args:
-            mcp_server: The FastMCP server instance
-        """
-        tool_self = self  # Create a reference to self for use in the closure
-        
-        # Each derived class should override this with a more specific signature
-        # that explicitly defines the parameters expected by the tool
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def generic_wrapper(**kwargs: Any) -> str:
-            """Generic wrapper for shell tool.
-            
-            This wrapper should be overridden by derived classes to provide
-            explicit parameter definitions.
-            
-            Returns:
-                Tool execution result
-            """
-            # Extract context from kwargs
-            ctx = kwargs.pop("ctx")
-            # Call the actual tool implementation
-            return await tool_self.call(ctx, **kwargs)