hanzo-mcp 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

hanzo_mcp/tools/shell/__init__.py

@@ -9,6 +9,7 @@ from hanzo_mcp.tools.shell.open import open_tool
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.shell.npx_tool import npx_tool
 from hanzo_mcp.tools.shell.uvx_tool import uvx_tool
+from hanzo_mcp.tools.shell.zsh_tool import zsh_tool, shell_tool
 
 # Import tools
 from hanzo_mcp.tools.shell.bash_tool import bash_tool
@@ -37,14 +38,19 @@ def get_shell_tools(
     """
     # Set permission manager for tools that need it
     bash_tool.permission_manager = permission_manager
+    zsh_tool.permission_manager = permission_manager
+    shell_tool.permission_manager = permission_manager
     npx_tool.permission_manager = permission_manager
     uvx_tool.permission_manager = permission_manager
 
     # Note: StreamingCommandTool is abstract and shouldn't be instantiated directly
     # It's used as a base class for other streaming tools
 
+    # Return shell_tool first (smart default), then specific shells
     return [
-        bash_tool,
+        shell_tool,  # Smart shell (prefers zsh if available)
+        zsh_tool,    # Explicit zsh
+        bash_tool,   # Explicit bash
         npx_tool,
         uvx_tool,
         process_tool,

hanzo_mcp/tools/shell/auto_background.py

@@ -49,6 +49,30 @@ class AutoBackgroundExecutor:
         Returns:
             Tuple of (output/status, was_backgrounded, process_id)
         """
+        # Fast path for tests/offline: run synchronously
+        import os
+
+        if os.getenv("HANZO_MCP_FAST_TESTS") == "1":
+            import subprocess
+
+            try:
+                proc = subprocess.run(
+                    cmd_args,
+                    cwd=str(cwd) if cwd else None,
+                    env=env,
+                    capture_output=True,
+                    text=True,
+                )
+                if proc.returncode != 0:
+                    return (
+                        f"Command failed with exit code {proc.returncode}:\n{proc.stdout}{proc.stderr}",
+                        False,
+                        None,
+                    )
+                return proc.stdout, False, None
+            except Exception as e:  # pragma: no cover
+                return f"Error executing command: {e}", False, None
+
         # Generate process ID
         process_id = f"{tool_name}_{uuid.uuid4().hex[:8]}"
 

hanzo_mcp/tools/shell/bash_tool.py

@@ -59,29 +59,20 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
 
     @override
     def get_interpreter(self) -> str:
-        """Get the shell interpreter."""
+        """Get the bash interpreter."""
         if platform.system() == "Windows":
-            return "cmd.exe"
-
-        # Check for user's preferred shell from environment
-        shell = os.environ.get("SHELL", "/bin/bash")
-
-        # Extract just the shell name from the path
-        shell_name = os.path.basename(shell)
-
-        # Check if it's a supported shell and the config file exists
-        if shell_name == "zsh":
-            # Check for .zshrc
-            zshrc_path = Path.home() / ".zshrc"
-            if zshrc_path.exists():
-                return shell  # Use full path to zsh
-        elif shell_name == "fish":
-            # Check for fish config
-            fish_config = Path.home() / ".config" / "fish" / "config.fish"
-            if fish_config.exists():
-                return shell  # Use full path to fish
-
-        # Default to bash if no special shell config found
+            # Try to find bash on Windows (Git Bash, WSL, etc.)
+            bash_paths = [
+                "C:\\Program Files\\Git\\bin\\bash.exe",
+                "C:\\cygwin64\\bin\\bash.exe",
+                "C:\\msys64\\usr\\bin\\bash.exe",
+            ]
+            for path in bash_paths:
+                if Path(path).exists():
+                    return path
+            return "cmd.exe"  # Fall back to cmd if no bash found
+        
+        # On Unix-like systems, always use bash
         return "bash"
 
     @override
@@ -94,12 +85,7 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
     @override
     def get_tool_name(self) -> str:
         """Get the tool name."""
-        if platform.system() == "Windows":
-            return "shell"
-
-        # Return the actual shell being used
-        interpreter = self.get_interpreter()
-        return os.path.basename(interpreter)
+        return "bash"
 
     @override
     async def run(

hanzo_mcp/tools/shell/zsh_tool.py

@@ -0,0 +1,266 @@
+"""Zsh shell tool for command execution with enhanced features."""
+
+import os
+import shutil
+import platform
+from typing import Optional, override
+from pathlib import Path
+
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.shell.base_process import BaseScriptTool
+
+
+class ZshTool(BaseScriptTool):
+    """Tool for running commands in Zsh shell with enhanced features."""
+
+    name = "zsh"
+
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        tool_self = self
+
+        @server.tool(name=self.name, description=self.description)
+        async def zsh(
+            ctx: MCPContext,
+            command: str,
+            cwd: Optional[str] = None,
+            env: Optional[dict[str, str]] = None,
+            timeout: Optional[int] = None,
+        ) -> str:
+            return await tool_self.run(
+                ctx, command=command, cwd=cwd, env=env, timeout=timeout
+            )
+
+    async def call(self, ctx: MCPContext, **params) -> str:
+        """Call the tool with arguments."""
+        return await self.run(
+            ctx,
+            command=params["command"],
+            cwd=params.get("cwd"),
+            env=params.get("env"),
+            timeout=params.get("timeout"),
+        )
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Run commands in Zsh shell with enhanced features like better globbing and completion.
+
+Zsh provides advanced features over bash:
+- Extended globbing patterns
+- Better tab completion
+- Array and associative array support
+- Powerful command line editing
+- Plugin ecosystem (oh-my-zsh, etc.)
+
+Commands that run for more than 2 minutes will automatically continue in the background.
+
+Usage:
+zsh "ls -la"
+zsh "echo $ZSH_VERSION"
+zsh "git status && git diff"
+zsh "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
+
+    @override
+    def get_interpreter(self) -> str:
+        """Get the zsh interpreter path."""
+        if platform.system() == "Windows":
+            # Try to find zsh on Windows (WSL, Git Bash, etc.)
+            zsh_paths = [
+                "C:\\Program Files\\Git\\usr\\bin\\zsh.exe",
+                "C:\\cygwin64\\bin\\zsh.exe",
+                "C:\\msys64\\usr\\bin\\zsh.exe",
+            ]
+            for path in zsh_paths:
+                if Path(path).exists():
+                    return path
+            # Fall back to bash if no zsh found
+            return "bash"
+        
+        # On Unix-like systems, check for zsh
+        zsh_path = shutil.which("zsh")
+        if zsh_path:
+            return zsh_path
+        
+        # Fall back to bash if zsh not found
+        return "bash"
+
+    @override
+    def get_script_flags(self) -> list[str]:
+        """Get interpreter flags."""
+        if platform.system() == "Windows" and self.get_interpreter().endswith(".exe"):
+            return ["-c"]
+        return ["-c"]
+
+    @override
+    def get_tool_name(self) -> str:
+        """Get the tool name."""
+        return "zsh"
+
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        command: str,
+        cwd: Optional[str] = None,
+        env: Optional[dict[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> str:
+        """Run a zsh command with auto-backgrounding.
+
+        Args:
+            ctx: MCP context
+            command: Zsh command to execute
+            cwd: Working directory
+            env: Environment variables
+            timeout: Command timeout in seconds (ignored - auto-backgrounds after 2 minutes)
+
+        Returns:
+            Command output or background status
+        """
+        # Check if zsh is available
+        if not shutil.which("zsh") and platform.system() != "Windows":
+            return "Error: Zsh is not installed. Please install zsh first."
+        
+        # Prepare working directory
+        work_dir = Path(cwd).resolve() if cwd else Path.cwd()
+
+        # Use execute_sync which has auto-backgrounding
+        output = await self.execute_sync(
+            command, cwd=work_dir, env=env, timeout=timeout
+        )
+        return output if output else "Command completed successfully (no output)"
+
+
+class ShellTool(BaseScriptTool):
+    """Smart shell tool that uses the best available shell (zsh > bash)."""
+
+    name = "shell"
+
+    def __init__(self):
+        """Initialize and detect the best shell."""
+        super().__init__()
+        self._best_shell = self._detect_best_shell()
+
+    def _detect_best_shell(self) -> str:
+        """Detect the best available shell."""
+        # Check for zsh first
+        if shutil.which("zsh"):
+            # Also check if .zshrc exists
+            if (Path.home() / ".zshrc").exists():
+                return "zsh"
+        
+        # Check for user's preferred shell
+        user_shell = os.environ.get("SHELL", "")
+        if user_shell and Path(user_shell).exists():
+            return user_shell
+        
+        # Default to bash
+        return "bash"
+
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        tool_self = self
+
+        @server.tool(name=self.name, description=self.description)
+        async def shell(
+            ctx: MCPContext,
+            command: str,
+            cwd: Optional[str] = None,
+            env: Optional[dict[str, str]] = None,
+            timeout: Optional[int] = None,
+        ) -> str:
+            return await tool_self.run(
+                ctx, command=command, cwd=cwd, env=env, timeout=timeout
+            )
+
+    async def call(self, ctx: MCPContext, **params) -> str:
+        """Call the tool with arguments."""
+        return await self.run(
+            ctx,
+            command=params["command"],
+            cwd=params.get("cwd"),
+            env=params.get("env"),
+            timeout=params.get("timeout"),
+        )
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return f"""Run shell commands using the best available shell (currently: {os.path.basename(self._best_shell)}).
+
+Automatically selects:
+- Zsh if available (with .zshrc)
+- User's preferred shell ($SHELL)
+- Bash as fallback
+
+Commands that run for more than 2 minutes will automatically continue in the background.
+
+Usage:
+shell "ls -la"
+shell "echo $SHELL"  # Shows which shell is being used
+shell "git status && git diff"
+shell "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
+
+    @override
+    def get_interpreter(self) -> str:
+        """Get the best shell interpreter."""
+        return self._best_shell
+
+    @override
+    def get_script_flags(self) -> list[str]:
+        """Get interpreter flags."""
+        if platform.system() == "Windows":
+            return ["/c"] if self._best_shell == "cmd.exe" else ["-c"]
+        return ["-c"]
+
+    @override
+    def get_tool_name(self) -> str:
+        """Get the tool name."""
+        return "shell"
+
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        command: str,
+        cwd: Optional[str] = None,
+        env: Optional[dict[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> str:
+        """Run a shell command with auto-backgrounding.
+
+        Args:
+            ctx: MCP context
+            command: Shell command to execute
+            cwd: Working directory
+            env: Environment variables
+            timeout: Command timeout in seconds (ignored - auto-backgrounds after 2 minutes)
+
+        Returns:
+            Command output or background status
+        """
+        # Prepare working directory
+        work_dir = Path(cwd).resolve() if cwd else Path.cwd()
+
+        # Add shell info to output if verbose
+        shell_name = os.path.basename(self._best_shell)
+        
+        # Use execute_sync which has auto-backgrounding
+        output = await self.execute_sync(
+            command, cwd=work_dir, env=env, timeout=timeout
+        )
+        
+        if output:
+            return output
+        else:
+            return f"Command completed successfully in {shell_name} (no output)"
+
+
+# Create tool instances
+zsh_tool = ZshTool()
+shell_tool = ShellTool()  # Smart shell that prefers zsh