hanzo-mcp 0.5.1__py3-none-any.whl → 0.6.1__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

@@ -0,0 +1,265 @@
+"""Tool for viewing process logs."""
+
+import os
+from pathlib import Path
+from typing import Annotated, Optional, TypedDict, Unpack, final, override
+
+from mcp.server.fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.shell.run_background import RunBackgroundTool
+
+
+ProcessId = Annotated[
+    Optional[str],
+    Field(
+        description="Process ID from run_background",
+        default=None,
+    ),
+]
+
+LogFile = Annotated[
+    Optional[str],
+    Field(
+        description="Path to specific log file",
+        default=None,
+    ),
+]
+
+Lines = Annotated[
+    int,
+    Field(
+        description="Number of lines to show (default: 50, -1 for all)",
+        default=50,
+    ),
+]
+
+Follow = Annotated[
+    bool,
+    Field(
+        description="Follow log output (tail -f)",
+        default=False,
+    ),
+]
+
+ListLogs = Annotated[
+    bool,
+    Field(
+        description="List all available log files",
+        default=False,
+    ),
+]
+
+
+class LogsParams(TypedDict, total=False):
+    """Parameters for viewing logs."""
+
+    id: Optional[str]
+    file: Optional[str]
+    lines: int
+    follow: bool
+    list: bool
+
+
+@final
+class LogsTool(BaseTool):
+    """Tool for viewing process logs."""
+
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize the logs tool.
+
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        self.permission_manager = permission_manager
+        self.log_dir = Path.home() / ".hanzo" / "logs"
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "logs"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """View logs from background processes.
+
+Options:
+- id: Process ID to view logs for
+- file: Specific log file path
+- lines: Number of lines to show (default: 50, -1 for all)
+- list: List all available log files
+
+Examples:
+- logs --id abc123              # View logs for specific process
+- logs --id abc123 --lines 100  # View last 100 lines
+- logs --id abc123 --lines -1   # View entire log
+- logs --list                   # List all log files
+- logs --file /path/to/log      # View specific log file
+
+Note: Follow mode (--follow) is not supported in MCP context.
+Use run_command with 'tail -f' for continuous monitoring.
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[LogsParams],
+    ) -> str:
+        """View process logs.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Log content or list of logs
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        process_id = params.get("id")
+        log_file = params.get("file")
+        lines = params.get("lines", 50)
+        follow = params.get("follow", False)
+        list_logs = params.get("list", False)
+
+        try:
+            # List available logs
+            if list_logs:
+                return await self._list_logs(tool_ctx)
+
+            # Determine log file to read
+            if process_id:
+                # Find log file for process ID
+                process = RunBackgroundTool.get_process(process_id)
+                if not process:
+                    return f"Process with ID '{process_id}' not found."
+                
+                if not process.log_file:
+                    return f"Process '{process_id}' does not have logging enabled."
+                
+                log_path = process.log_file
+                
+            elif log_file:
+                # Use specified log file
+                log_path = Path(log_file)
+                
+                # Check if it's in the logs directory
+                if not log_path.is_absolute():
+                    log_path = self.log_dir / log_path
+                
+            else:
+                return "Error: Must specify --id or --file"
+
+            # Check permissions
+            if not self.permission_manager.has_permission(str(log_path)):
+                return f"Permission denied: {log_path}"
+
+            # Check if file exists
+            if not log_path.exists():
+                return f"Log file not found: {log_path}"
+
+            # Note about follow mode
+            if follow:
+                await tool_ctx.warning("Follow mode not supported in MCP. Showing latest lines instead.")
+
+            # Read log file
+            await tool_ctx.info(f"Reading log file: {log_path}")
+            
+            try:
+                with open(log_path, 'r') as f:
+                    if lines == -1:
+                        # Read entire file
+                        content = f.read()
+                    else:
+                        # Read last N lines
+                        all_lines = f.readlines()
+                        if len(all_lines) <= lines:
+                            content = ''.join(all_lines)
+                        else:
+                            content = ''.join(all_lines[-lines:])
+                
+                if not content:
+                    return f"Log file is empty: {log_path}"
+                
+                # Add header
+                header = f"=== Log: {log_path.name} ===\n"
+                if process_id:
+                    process = RunBackgroundTool.get_process(process_id)
+                    if process:
+                        header += f"Process: {process.name} (ID: {process_id})\n"
+                        header += f"Command: {process.command}\n"
+                        status = "running" if process.is_running else f"finished (code: {process.return_code})"
+                        header += f"Status: {status}\n"
+                header += f"{'=' * 50}\n"
+                
+                return header + content
+                
+            except Exception as e:
+                return f"Error reading log file: {str(e)}"
+
+        except Exception as e:
+            await tool_ctx.error(f"Failed to view logs: {str(e)}")
+            return f"Error viewing logs: {str(e)}"
+
+    async def _list_logs(self, tool_ctx) -> str:
+        """List all available log files."""
+        await tool_ctx.info("Listing available log files")
+        
+        if not self.log_dir.exists():
+            return "No logs directory found."
+        
+        # Get all log files
+        log_files = list(self.log_dir.glob("*.log"))
+        
+        if not log_files:
+            return "No log files found."
+        
+        # Sort by modification time (newest first)
+        log_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
+        
+        # Check which logs belong to active processes
+        active_processes = RunBackgroundTool.get_processes()
+        active_log_files = {str(p.log_file): (pid, p) for pid, p in active_processes.items() if p.log_file}
+        
+        # Build output
+        output = []
+        output.append("=== Available Log Files ===\n")
+        
+        for log_file in log_files[:50]:  # Limit to 50 most recent
+            size = log_file.stat().st_size
+            size_str = self._format_size(size)
+            
+            # Check if this belongs to an active process
+            if str(log_file) in active_log_files:
+                pid, process = active_log_files[str(log_file)]
+                status = "active" if process.is_running else "finished"
+                output.append(f"{log_file.name:<50} {size_str:>10} [{status}] (ID: {pid})")
+            else:
+                output.append(f"{log_file.name:<50} {size_str:>10}")
+        
+        output.append(f"\nTotal: {len(log_files)} log file(s)")
+        output.append("\nUse 'logs --file <filename>' to view a specific log")
+        output.append("Use 'logs --id <process-id>' to view logs for a running process")
+        
+        return "\n".join(output)
+
+    def _format_size(self, size: int) -> str:
+        """Format file size in human-readable format."""
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size < 1024.0:
+                return f"{size:.1f} {unit}"
+            size /= 1024.0
+        return f"{size:.1f} TB"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass