hanzo-mcp 0.5.2__py3-none-any.whl → 0.6.2__py3-none-any.whl

hanzo_mcp/tools/shell/base_process.py

@@ -0,0 +1,303 @@
+"""Base classes for process execution tools."""
+
+import asyncio
+import subprocess
+import tempfile
+import uuid
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional, override
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
+
+
+class ProcessManager:
+    """Singleton manager for background processes."""
+    
+    _instance = None
+    _processes: Dict[str, subprocess.Popen] = {}
+    _logs: Dict[str, List[str]] = {}
+    _log_dir = Path(tempfile.gettempdir()) / "hanzo_mcp_logs"
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._log_dir.mkdir(exist_ok=True)
+        return cls._instance
+    
+    def add_process(self, process_id: str, process: subprocess.Popen, log_file: Path) -> None:
+        """Add a process to track."""
+        self._processes[process_id] = process
+        self._logs[process_id] = str(log_file)
+    
+    def get_process(self, process_id: str) -> Optional[subprocess.Popen]:
+        """Get a tracked process."""
+        return self._processes.get(process_id)
+    
+    def remove_process(self, process_id: str) -> None:
+        """Remove a process from tracking."""
+        self._processes.pop(process_id, None)
+        self._logs.pop(process_id, None)
+    
+    def list_processes(self) -> Dict[str, Dict[str, Any]]:
+        """List all tracked processes."""
+        result = {}
+        for pid, proc in list(self._processes.items()):
+            if proc.poll() is None:
+                result[pid] = {
+                    "pid": proc.pid,
+                    "running": True,
+                    "log_file": self._logs.get(pid)
+                }
+            else:
+                result[pid] = {
+                    "pid": proc.pid,
+                    "running": False,
+                    "return_code": proc.returncode,
+                    "log_file": self._logs.get(pid)
+                }
+                # Clean up finished processes
+                self.remove_process(pid)
+        return result
+    
+    def get_log_file(self, process_id: str) -> Optional[Path]:
+        """Get log file path for a process."""
+        log_path = self._logs.get(process_id)
+        return Path(log_path) if log_path else None
+    
+    @property
+    def log_dir(self) -> Path:
+        """Get the log directory."""
+        return self._log_dir
+
+
+class BaseProcessTool(BaseTool):
+    """Base class for all process execution tools."""
+    
+    def __init__(self, permission_manager: Optional[PermissionManager] = None):
+        """Initialize the process tool.
+        
+        Args:
+            permission_manager: Optional permission manager for access control
+        """
+        super().__init__()
+        self.permission_manager = permission_manager
+        self.process_manager = ProcessManager()
+    
+    @abstractmethod
+    def get_command_args(self, command: str, **kwargs) -> List[str]:
+        """Get the command arguments for subprocess.
+        
+        Args:
+            command: The command or script to run
+            **kwargs: Additional arguments specific to the tool
+            
+        Returns:
+            List of command arguments for subprocess
+        """
+        pass
+    
+    @abstractmethod
+    def get_tool_name(self) -> str:
+        """Get the name of the tool being used (e.g., 'bash', 'uvx', 'npx')."""
+        pass
+    
+    async def execute_sync(
+        self,
+        command: str,
+        cwd: Optional[Path] = None,
+        env: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        **kwargs
+    ) -> str:
+        """Execute a command synchronously and return output.
+        
+        Args:
+            command: Command to execute
+            cwd: Working directory
+            env: Environment variables
+            timeout: Timeout in seconds
+            **kwargs: Additional tool-specific arguments
+            
+        Returns:
+            Command output
+            
+        Raises:
+            RuntimeError: If command fails
+        """
+        # Check permissions if manager is available
+        if self.permission_manager and cwd:
+            self.permission_manager.check_permission(cwd)
+        
+        # Get command arguments
+        cmd_args = self.get_command_args(command, **kwargs)
+        
+        # Prepare environment
+        process_env = os.environ.copy()
+        if env:
+            process_env.update(env)
+        
+        try:
+            result = subprocess.run(
+                cmd_args,
+                cwd=cwd,
+                env=process_env,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                check=True
+            )
+            return result.stdout
+        except subprocess.TimeoutExpired:
+            raise RuntimeError(f"{self.get_tool_name()} command timed out after {timeout} seconds")
+        except subprocess.CalledProcessError as e:
+            error_msg = f"{self.get_tool_name()} command failed with exit code {e.returncode}"
+            if e.stderr:
+                error_msg += f"\nError: {e.stderr}"
+            raise RuntimeError(error_msg)
+    
+    async def execute_background(
+        self,
+        command: str,
+        cwd: Optional[Path] = None,
+        env: Optional[Dict[str, str]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Execute a command in the background.
+        
+        Args:
+            command: Command to execute
+            cwd: Working directory
+            env: Environment variables
+            **kwargs: Additional tool-specific arguments
+            
+        Returns:
+            Dict with process_id and log_file
+        """
+        # Check permissions if manager is available
+        if self.permission_manager and cwd:
+            self.permission_manager.check_permission(cwd)
+        
+        # Generate process ID and log file
+        process_id = f"{self.get_tool_name()}_{uuid.uuid4().hex[:8]}"
+        log_file = self.process_manager.log_dir / f"{process_id}.log"
+        
+        # Get command arguments
+        cmd_args = self.get_command_args(command, **kwargs)
+        
+        # Prepare environment
+        process_env = os.environ.copy()
+        if env:
+            process_env.update(env)
+        
+        # Start process with output to log file
+        with open(log_file, "w") as f:
+            process = subprocess.Popen(
+                cmd_args,
+                cwd=cwd,
+                env=process_env,
+                stdout=f,
+                stderr=subprocess.STDOUT,
+                text=True
+            )
+        
+        # Track the process
+        self.process_manager.add_process(process_id, process, log_file)
+        
+        return {
+            "process_id": process_id,
+            "pid": process.pid,
+            "log_file": str(log_file),
+            "status": "started"
+        }
+
+
+class BaseBinaryTool(BaseProcessTool):
+    """Base class for binary execution tools (like npx, uvx)."""
+    
+    @abstractmethod
+    def get_binary_name(self) -> str:
+        """Get the name of the binary to execute."""
+        pass
+    
+    @override
+    def get_command_args(self, command: str, **kwargs) -> List[str]:
+        """Get command arguments for binary execution.
+        
+        Args:
+            command: The package or command to run
+            **kwargs: Additional arguments (args, flags, etc.)
+            
+        Returns:
+            List of command arguments
+        """
+        cmd_args = [self.get_binary_name()]
+        
+        # Add any binary-specific flags
+        if "flags" in kwargs:
+            cmd_args.extend(kwargs["flags"])
+        
+        # Add the command/package
+        cmd_args.append(command)
+        
+        # Add any additional arguments
+        if "args" in kwargs:
+            if isinstance(kwargs["args"], str):
+                cmd_args.extend(kwargs["args"].split())
+            else:
+                cmd_args.extend(kwargs["args"])
+        
+        return cmd_args
+    
+    @override
+    def get_tool_name(self) -> str:
+        """Get the tool name (same as binary name by default)."""
+        return self.get_binary_name()
+
+
+class BaseScriptTool(BaseProcessTool):
+    """Base class for script execution tools (like bash, python)."""
+    
+    @abstractmethod
+    def get_interpreter(self) -> str:
+        """Get the interpreter to use."""
+        pass
+    
+    @abstractmethod
+    def get_script_flags(self) -> List[str]:
+        """Get default flags for the interpreter."""
+        pass
+    
+    @override
+    def get_command_args(self, command: str, **kwargs) -> List[str]:
+        """Get command arguments for script execution.
+        
+        Args:
+            command: The script content to execute
+            **kwargs: Additional arguments
+            
+        Returns:
+            List of command arguments
+        """
+        cmd_args = [self.get_interpreter()]
+        cmd_args.extend(self.get_script_flags())
+        
+        # For inline scripts, use -c flag
+        if not kwargs.get("is_file", False):
+            cmd_args.extend(["-c", command])
+        else:
+            cmd_args.append(command)
+        
+        return cmd_args
+    
+    @override  
+    def get_tool_name(self) -> str:
+        """Get the tool name (interpreter name by default)."""
+        return self.get_interpreter()
+
+
+# Import os at the top of the file
+import os

hanzo_mcp/tools/shell/bash_unified.py

@@ -0,0 +1,134 @@
+"""Bash/Shell tool for command execution."""
+
+import os
+import platform
+from pathlib import Path
+from typing import Optional, override
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.shell.base_process import BaseScriptTool
+from mcp.server import FastMCP
+
+
+class BashTool(BaseScriptTool):
+    """Tool for running shell commands."""
+    
+    name = "bash"
+    
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        server.tool(name=self.name, description=self.description)(self.call)
+    
+    async def call(self, **kwargs) -> str:
+        """Call the tool with arguments."""
+        return await self.run(None, **kwargs)
+    
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Run shell commands. Actions: run (default), background.
+
+Usage:
+bash "ls -la"
+bash --action background "python server.py"
+bash "git status && git diff"
+bash --action background "npm run dev" --cwd ./frontend"""
+    
+    @override
+    def get_interpreter(self) -> str:
+        """Get the shell 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
+        return "bash"
+    
+    @override
+    def get_script_flags(self) -> list[str]:
+        """Get interpreter flags."""
+        if platform.system() == "Windows":
+            return ["/c"]
+        return ["-c"]
+    
+    @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)
+    
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        command: str,
+        action: str = "run",
+        cwd: Optional[str] = None,
+        env: Optional[dict[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> str:
+        """Run a shell command.
+        
+        Args:
+            ctx: MCP context
+            command: Shell command to execute
+            action: Action to perform (run, background)
+            cwd: Working directory
+            env: Environment variables
+            timeout: Command timeout in seconds
+            
+        Returns:
+            Command output or process info
+        """
+        # Prepare working directory
+        work_dir = Path(cwd).resolve() if cwd else Path.cwd()
+        
+        if action == "background":
+            result = await self.execute_background(
+                command,
+                cwd=work_dir,
+                env=env
+            )
+            return (
+                f"Started command in background\n"
+                f"Process ID: {result['process_id']}\n"
+                f"PID: {result['pid']}\n"
+                f"Log file: {result['log_file']}\n"
+                f"Command: {command}"
+            )
+        else:
+            # Default to sync execution
+            output = await self.execute_sync(
+                command,
+                cwd=work_dir,
+                env=env,
+                timeout=timeout or 120  # Default 2 minute timeout
+            )
+            return output if output else "Command completed successfully (no output)"
+
+
+# Create tool instance
+bash_tool = BashTool()

hanzo_mcp/tools/shell/logs.py

@@ -4,7 +4,7 @@ import os
 from pathlib import Path
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/shell/npx.py

@@ -4,7 +4,7 @@ import subprocess
 import shutil
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/shell/npx_background.py

@@ -5,7 +5,7 @@ import shutil
 import uuid
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/shell/npx_unified.py

@@ -0,0 +1,101 @@
+"""NPX tool for both sync and background execution."""
+
+from pathlib import Path
+from typing import Optional, override
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.shell.base_process import BaseBinaryTool
+from mcp.server import FastMCP
+
+
+class NpxTool(BaseBinaryTool):
+    """Tool for running npx commands."""
+    
+    name = "npx"
+    
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Run npx packages. Actions: run (default), background.
+
+Usage:
+npx create-react-app my-app
+npx --action background http-server -p 8080
+npx prettier --write "**/*.js"
+npx --action background json-server db.json"""
+    
+    @override
+    def get_binary_name(self) -> str:
+        """Get the binary name."""
+        return "npx"
+    
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        package: str,
+        args: str = "",
+        action: str = "run",
+        cwd: Optional[str] = None,
+        yes: bool = True,
+    ) -> str:
+        """Run an npx command.
+        
+        Args:
+            ctx: MCP context
+            package: NPX package to run
+            args: Additional arguments
+            action: Action to perform (run, background)
+            cwd: Working directory
+            yes: Auto-confirm package installation
+            
+        Returns:
+            Command output or process info
+        """
+        # Prepare working directory
+        work_dir = Path(cwd).resolve() if cwd else Path.cwd()
+        
+        # Prepare flags
+        flags = []
+        if yes:
+            flags.append("-y")
+        
+        # Build full command
+        full_args = args.split() if args else []
+        
+        if action == "background":
+            result = await self.execute_background(
+                package,
+                cwd=work_dir,
+                flags=flags,
+                args=full_args
+            )
+            return (
+                f"Started npx process in background\n"
+                f"Process ID: {result['process_id']}\n"
+                f"PID: {result['pid']}\n"
+                f"Log file: {result['log_file']}"
+            )
+        else:
+            # Default to sync execution
+            return await self.execute_sync(
+                package,
+                cwd=work_dir,
+                flags=flags,
+                args=full_args,
+                timeout=300  # 5 minute timeout for npx
+            )
+
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        server.tool(name=self.name, description=self.description)(self.call)
+    
+    async def call(self, **kwargs) -> str:
+        """Call the tool with arguments."""
+        return await self.run(None, **kwargs)
+
+
+# Create tool instance
+npx_tool = NpxTool()

hanzo_mcp/tools/shell/open.py

@@ -0,0 +1,107 @@
+"""Open files or URLs in the default application."""
+
+import platform
+import subprocess
+import webbrowser
+from pathlib import Path
+from typing import override
+from urllib.parse import urlparse
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from mcp.server import FastMCP
+
+
+class OpenTool(BaseTool):
+    """Tool for opening files or URLs in the default application."""
+
+    name = "open"
+    
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        server.tool(name=self.name, description=self.description)(self.call)
+    
+    async def call(self, **kwargs) -> str:
+        """Call the tool with arguments."""
+        return await self.run(None, **kwargs)
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Open files or URLs. Platform-aware.
+
+Usage:
+open https://example.com
+open ./document.pdf
+open /path/to/image.png"""
+
+    @override
+    async def run(self, ctx: MCPContext, path: str) -> str:
+        """Open a file or URL in the default application.
+        
+        Args:
+            ctx: MCP context
+            path: File path or URL to open
+            
+        Returns:
+            Success message
+            
+        Raises:
+            RuntimeError: If opening fails
+        """
+        # Check if it's a URL
+        parsed = urlparse(path)
+        is_url = parsed.scheme in ('http', 'https', 'ftp', 'file')
+        
+        if is_url:
+            # Open URL in default browser
+            try:
+                webbrowser.open(path)
+                return f"Opened URL in browser: {path}"
+            except Exception as e:
+                raise RuntimeError(f"Failed to open URL: {e}")
+        
+        # It's a file path
+        file_path = Path(path).expanduser().resolve()
+        
+        if not file_path.exists():
+            raise RuntimeError(f"File not found: {file_path}")
+        
+        system = platform.system().lower()
+        
+        try:
+            if system == "darwin":  # macOS
+                subprocess.run(["open", str(file_path)], check=True)
+            elif system == "linux":
+                # Try xdg-open first (most common)
+                try:
+                    subprocess.run(["xdg-open", str(file_path)], check=True)
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    # Fallback to other common openers
+                    for opener in ["gnome-open", "kde-open", "exo-open"]:
+                        try:
+                            subprocess.run([opener, str(file_path)], check=True)
+                            break
+                        except (subprocess.CalledProcessError, FileNotFoundError):
+                            continue
+                    else:
+                        raise RuntimeError("No suitable file opener found on Linux")
+            elif system == "windows":
+                # Use os.startfile on Windows
+                import os
+                os.startfile(str(file_path))
+            else:
+                raise RuntimeError(f"Unsupported platform: {system}")
+                
+            return f"Opened file: {file_path}"
+            
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to open file: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Error opening file: {e}")
+
+
+# Create tool instance
+open_tool = OpenTool()

hanzo_mcp/tools/shell/pkill.py

@@ -6,7 +6,7 @@ import psutil
 from datetime import datetime
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool