hanzo-mcp 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

hanzo_mcp/tools/shell/pkill.py

@@ -0,0 +1,262 @@
+"""Tool for terminating background processes."""
+
+import os
+import signal
+import psutil
+from datetime import datetime
+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 (use 'processes' to list)",
+        default=None,
+    ),
+]
+
+Pid = Annotated[
+    Optional[int],
+    Field(
+        description="System process ID (PID)",
+        default=None,
+    ),
+]
+
+Name = Annotated[
+    Optional[str],
+    Field(
+        description="Kill all processes matching this name",
+        default=None,
+    ),
+]
+
+Force = Annotated[
+    bool,
+    Field(
+        description="Force kill (SIGKILL instead of SIGTERM)",
+        default=False,
+    ),
+]
+
+All = Annotated[
+    bool,
+    Field(
+        description="Kill all background processes",
+        default=False,
+    ),
+]
+
+
+class PkillParams(TypedDict, total=False):
+    """Parameters for killing processes."""
+
+    id: Optional[str]
+    pid: Optional[int]
+    name: Optional[str]
+    force: bool
+    all: bool
+
+
+@final
+class PkillTool(BaseTool):
+    """Tool for terminating processes."""
+
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize the pkill tool.
+
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        self.permission_manager = permission_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "pkill"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Terminate running processes.
+
+Can kill processes by:
+- ID: Process ID from run_background (recommended)
+- PID: System process ID
+- Name: All processes matching name
+- All: Terminate all background processes
+
+Options:
+- force: Use SIGKILL instead of SIGTERM
+- all: Kill all background processes
+
+Examples:
+- pkill --id abc123            # Kill specific background process
+- pkill --name "npm"           # Kill all npm processes
+- pkill --pid 12345            # Kill by system PID
+- pkill --all                  # Kill all background processes
+- pkill --id abc123 --force    # Force kill
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[PkillParams],
+    ) -> str:
+        """Kill processes.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Result of kill operation
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        process_id = params.get("id")
+        pid = params.get("pid")
+        name = params.get("name")
+        force = params.get("force", False)
+        kill_all = params.get("all", False)
+
+        # Validate that at least one target is specified
+        if not any([process_id, pid, name, kill_all]):
+            return "Error: Must specify --id, --pid, --name, or --all"
+
+        killed_count = 0
+        errors = []
+
+        try:
+            # Kill all background processes
+            if kill_all:
+                await tool_ctx.info("Killing all background processes")
+                processes = RunBackgroundTool.get_processes()
+                
+                for proc_id, process in list(processes.items()):
+                    if process.is_running:
+                        try:
+                            if force:
+                                process.kill()
+                            else:
+                                process.terminate()
+                            killed_count += 1
+                            await tool_ctx.info(f"Killed process {proc_id} ({process.name})")
+                        except Exception as e:
+                            errors.append(f"Failed to kill {proc_id}: {str(e)}")
+                
+                if killed_count == 0:
+                    return "No running background processes to kill."
+
+            # Kill by process ID
+            elif process_id:
+                await tool_ctx.info(f"Killing process with ID: {process_id}")
+                process = RunBackgroundTool.get_process(process_id)
+                
+                if not process:
+                    return f"Process with ID '{process_id}' not found."
+                
+                if not process.is_running:
+                    return f"Process '{process_id}' is not running (return code: {process.return_code})."
+                
+                try:
+                    if force:
+                        process.kill()
+                    else:
+                        process.terminate()
+                    killed_count += 1
+                    await tool_ctx.info(f"Successfully killed process {process_id}")
+                except Exception as e:
+                    return f"Failed to kill process: {str(e)}"
+
+            # Kill by PID
+            elif pid:
+                await tool_ctx.info(f"Killing process with PID: {pid}")
+                try:
+                    p = psutil.Process(pid)
+                    
+                    if force:
+                        p.kill()
+                    else:
+                        p.terminate()
+                    
+                    killed_count += 1
+                    await tool_ctx.info(f"Successfully killed PID {pid}")
+                    
+                    # Check if this was a background process and update it
+                    for proc_id, process in RunBackgroundTool.get_processes().items():
+                        if process.pid == pid:
+                            process.end_time = datetime.now()
+                            break
+                            
+                except psutil.NoSuchProcess:
+                    return f"Process with PID {pid} not found."
+                except psutil.AccessDenied:
+                    return f"Permission denied to kill PID {pid}."
+                except Exception as e:
+                    return f"Failed to kill PID {pid}: {str(e)}"
+
+            # Kill by name
+            elif name:
+                await tool_ctx.info(f"Killing all processes matching: {name}")
+                
+                # First check background processes
+                bg_processes = RunBackgroundTool.get_processes()
+                for proc_id, process in list(bg_processes.items()):
+                    if name.lower() in process.name.lower() and process.is_running:
+                        try:
+                            if force:
+                                process.kill()
+                            else:
+                                process.terminate()
+                            killed_count += 1
+                            await tool_ctx.info(f"Killed background process {proc_id} ({process.name})")
+                        except Exception as e:
+                            errors.append(f"Failed to kill {proc_id}: {str(e)}")
+                
+                # Also check system processes
+                for proc in psutil.process_iter(['pid', 'name']):
+                    try:
+                        if name.lower() in proc.info['name'].lower():
+                            if force:
+                                proc.kill()
+                            else:
+                                proc.terminate()
+                            killed_count += 1
+                            await tool_ctx.info(f"Killed {proc.info['name']} (PID: {proc.info['pid']})")
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                        continue
+                    except Exception as e:
+                        errors.append(f"Failed to kill PID {proc.info['pid']}: {str(e)}")
+
+            # Build result message
+            if killed_count > 0:
+                result = f"Successfully killed {killed_count} process(es)."
+            else:
+                result = "No processes were killed."
+            
+            if errors:
+                result += f"\n\nErrors:\n" + "\n".join(errors)
+            
+            return result
+
+        except Exception as e:
+            await tool_ctx.error(f"Failed to kill processes: {str(e)}")
+            return f"Error killing processes: {str(e)}"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/shell/process_unified.py

@@ -0,0 +1,131 @@
+"""Process management tool."""
+
+import signal
+from typing import Optional, override
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.shell.base_process import ProcessManager
+from mcp.server import FastMCP
+
+
+class ProcessTool(BaseTool):
+    """Tool for process management."""
+    
+    name = "process"
+    
+    def __init__(self):
+        """Initialize the process tool."""
+        super().__init__()
+        self.process_manager = ProcessManager()
+    
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Manage background processes. Actions: list (default), kill, logs.
+
+Usage:
+process
+process --action list
+process --action kill --id npx_abc123
+process --action logs --id uvx_def456
+process --action logs --id bash_ghi789 --lines 50"""
+    
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        action: str = "list",
+        id: Optional[str] = None,
+        signal_type: str = "TERM",
+        lines: int = 100,
+    ) -> str:
+        """Manage background processes.
+        
+        Args:
+            ctx: MCP context
+            action: Action to perform (list, kill, logs)
+            id: Process ID (for kill/logs actions)
+            signal_type: Signal type for kill (TERM, KILL, INT)
+            lines: Number of log lines to show
+            
+        Returns:
+            Action result
+        """
+        if action == "list":
+            processes = self.process_manager.list_processes()
+            if not processes:
+                return "No background processes running"
+            
+            output = ["Background processes:"]
+            for proc_id, info in processes.items():
+                status = "running" if info["running"] else f"stopped (exit code: {info.get('return_code', 'unknown')})"
+                output.append(f"- {proc_id}: PID {info['pid']} - {status}")
+                if info.get("log_file"):
+                    output.append(f"  Log: {info['log_file']}")
+            
+            return "\n".join(output)
+        
+        elif action == "kill":
+            if not id:
+                return "Error: Process ID required for kill action"
+            
+            process = self.process_manager.get_process(id)
+            if not process:
+                return f"Process {id} not found"
+            
+            # Map signal names to signal numbers
+            signal_map = {
+                "TERM": signal.SIGTERM,
+                "KILL": signal.SIGKILL,
+                "INT": signal.SIGINT,
+            }
+            
+            sig = signal_map.get(signal_type.upper(), signal.SIGTERM)
+            
+            try:
+                process.send_signal(sig)
+                return f"Sent {signal_type} signal to process {id} (PID: {process.pid})"
+            except Exception as e:
+                return f"Failed to kill process {id}: {e}"
+        
+        elif action == "logs":
+            if not id:
+                return "Error: Process ID required for logs action"
+            
+            log_file = self.process_manager.get_log_file(id)
+            if not log_file or not log_file.exists():
+                return f"No log file found for process {id}"
+            
+            try:
+                with open(log_file, "r") as f:
+                    log_lines = f.readlines()
+                
+                # Get last N lines
+                if len(log_lines) > lines:
+                    log_lines = log_lines[-lines:]
+                
+                output = [f"Logs for process {id} (last {lines} lines):"]
+                output.append("-" * 50)
+                output.extend(line.rstrip() for line in log_lines)
+                
+                return "\n".join(output)
+            except Exception as e:
+                return f"Error reading logs: {e}"
+        
+        else:
+            return f"Unknown action: {action}. Use 'list', 'kill', or 'logs'"
+
+    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
+process_tool = ProcessTool()

hanzo_mcp/tools/shell/processes.py

@@ -0,0 +1,279 @@
+"""Tool for listing running background processes."""
+
+import psutil
+from datetime import datetime
+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
+
+
+ShowAll = Annotated[
+    bool,
+    Field(
+        description="Show all system processes (not just background processes)",
+        default=False,
+    ),
+]
+
+FilterName = Annotated[
+    Optional[str],
+    Field(
+        description="Filter processes by name",
+        default=None,
+    ),
+]
+
+ShowDetails = Annotated[
+    bool,
+    Field(
+        description="Show detailed process information",
+        default=False,
+    ),
+]
+
+
+class ProcessesParams(TypedDict, total=False):
+    """Parameters for listing processes."""
+
+    show_all: bool
+    filter_name: Optional[str]
+    show_details: bool
+
+
+@final
+class ProcessesTool(BaseTool):
+    """Tool for listing running processes."""
+
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize the processes tool.
+
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        self.permission_manager = permission_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "processes"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """List running background processes started with run_background.
+
+Shows:
+- Process ID (for use with pkill)
+- Process name
+- Command
+- PID (system process ID)
+- Status (running/finished)
+- Start time
+- Log file location
+
+Options:
+- show_all: Show all system processes (requires permissions)
+- filter_name: Filter by process name
+- show_details: Show CPU, memory usage
+
+Examples:
+- processes                     # List background processes
+- processes --show-details      # Include resource usage
+- processes --filter-name npm   # Show only npm processes
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ProcessesParams],
+    ) -> str:
+        """List running processes.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Process listing
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        show_all = params.get("show_all", False)
+        filter_name = params.get("filter_name")
+        show_details = params.get("show_details", False)
+
+        try:
+            if show_all:
+                # Show all system processes
+                await tool_ctx.info("Listing all system processes")
+                return self._list_system_processes(filter_name, show_details)
+            else:
+                # Show only background processes
+                await tool_ctx.info("Listing background processes")
+                return self._list_background_processes(filter_name, show_details)
+
+        except Exception as e:
+            await tool_ctx.error(f"Failed to list processes: {str(e)}")
+            return f"Error listing processes: {str(e)}"
+
+    def _list_background_processes(
+        self, filter_name: Optional[str], show_details: bool
+    ) -> str:
+        """List background processes started with run_background."""
+        processes = RunBackgroundTool.get_processes()
+        
+        if not processes:
+            return "No background processes are currently running."
+        
+        # Filter if requested
+        filtered_processes = []
+        for proc_id, process in processes.items():
+            if filter_name:
+                if filter_name.lower() not in process.name.lower():
+                    continue
+            filtered_processes.append((proc_id, process))
+        
+        if not filtered_processes:
+            return f"No background processes found matching '{filter_name}'."
+        
+        # Build output
+        output = []
+        output.append("=== Background Processes ===\n")
+        
+        # Sort by start time (newest first)
+        filtered_processes.sort(key=lambda x: x[1].start_time, reverse=True)
+        
+        for proc_id, process in filtered_processes:
+            status = "running" if process.is_running else f"finished (code: {process.return_code})"
+            runtime = datetime.now() - process.start_time
+            runtime_str = str(runtime).split('.')[0]  # Remove microseconds
+            
+            output.append(f"ID: {proc_id}")
+            output.append(f"Name: {process.name}")
+            output.append(f"Status: {status}")
+            output.append(f"PID: {process.pid}")
+            output.append(f"Runtime: {runtime_str}")
+            output.append(f"Command: {process.command}")
+            output.append(f"Working Dir: {process.working_dir}")
+            
+            if process.log_file:
+                output.append(f"Log File: {process.log_file}")
+            
+            if show_details and process.is_running:
+                try:
+                    # Get process details using psutil
+                    p = psutil.Process(process.pid)
+                    output.append(f"CPU: {p.cpu_percent(interval=0.1):.1f}%")
+                    output.append(f"Memory: {p.memory_info().rss / 1024 / 1024:.1f} MB")
+                    output.append(f"Threads: {p.num_threads()}")
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    output.append("Process details unavailable")
+            
+            output.append("-" * 40)
+        
+        output.append(f"\nTotal: {len(filtered_processes)} process(es)")
+        output.append("\nUse 'pkill --id <ID>' to stop a process")
+        output.append("Use 'logs --id <ID>' to view process logs")
+        
+        return "\n".join(output)
+
+    def _list_system_processes(
+        self, filter_name: Optional[str], show_details: bool
+    ) -> str:
+        """List all system processes."""
+        try:
+            processes = []
+            
+            # Get all running processes
+            for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'create_time']):
+                try:
+                    info = proc.info
+                    name = info['name']
+                    
+                    # Filter if requested
+                    if filter_name:
+                        if filter_name.lower() not in name.lower():
+                            continue
+                    
+                    # Get command line
+                    cmdline = info.get('cmdline')
+                    if cmdline:
+                        cmd = ' '.join(cmdline)
+                    else:
+                        cmd = name
+                    
+                    # Truncate long commands
+                    if len(cmd) > 80:
+                        cmd = cmd[:77] + "..."
+                    
+                    process_info = {
+                        'pid': info['pid'],
+                        'name': name,
+                        'cmd': cmd,
+                        'create_time': info['create_time'],
+                    }
+                    
+                    if show_details:
+                        process_info['cpu'] = proc.cpu_percent(interval=0.1)
+                        process_info['memory'] = proc.memory_info().rss / 1024 / 1024  # MB
+                    
+                    processes.append(process_info)
+                    
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    continue
+            
+            if not processes:
+                return f"No processes found matching '{filter_name}'."
+            
+            # Sort by PID
+            processes.sort(key=lambda x: x['pid'])
+            
+            # Build output
+            output = []
+            output.append("=== System Processes ===\n")
+            
+            # Header
+            if show_details:
+                output.append(f"{'PID':>7} {'CPU%':>5} {'MEM(MB)':>8} {'NAME':<20} COMMAND")
+                output.append("-" * 80)
+                
+                for proc in processes:
+                    output.append(
+                        f"{proc['pid']:>7} "
+                        f"{proc['cpu']:>5.1f} "
+                        f"{proc['memory']:>8.1f} "
+                        f"{proc['name']:<20} "
+                        f"{proc['cmd']}"
+                    )
+            else:
+                output.append(f"{'PID':>7} {'NAME':<20} COMMAND")
+                output.append("-" * 80)
+                
+                for proc in processes:
+                    output.append(
+                        f"{proc['pid']:>7} "
+                        f"{proc['name']:<20} "
+                        f"{proc['cmd']}"
+                    )
+            
+            output.append(f"\nTotal: {len(processes)} process(es)")
+            
+            return "\n".join(output)
+            
+        except Exception as e:
+            return f"Error listing system processes: {str(e)}\nYou may need elevated permissions."
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass