hanzo-mcp 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/shell/pkill.py

@@ -1,20 +1,17 @@
 """Tool for terminating background processes."""
 
-import os
-import signal
-import psutil
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 from datetime import datetime
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
+import psutil
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 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(
@@ -145,7 +142,7 @@ Examples:
             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:
@@ -154,10 +151,12 @@ Examples:
                             else:
                                 process.terminate()
                             killed_count += 1
-                            await tool_ctx.info(f"Killed process {proc_id} ({process.name})")
+                            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."
 
@@ -165,13 +164,13 @@ Examples:
             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()
@@ -187,21 +186,21 @@ Examples:
                 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:
@@ -212,7 +211,7 @@ Examples:
             # 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()):
@@ -223,34 +222,40 @@ Examples:
                             else:
                                 process.terminate()
                             killed_count += 1
-                            await tool_ctx.info(f"Killed background process {proc_id} ({process.name})")
+                            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']):
+                for proc in psutil.process_iter(["pid", "name"]):
                     try:
-                        if name.lower() in proc.info['name'].lower():
+                        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']})")
+                            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)}")
+                        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:
@@ -259,4 +264,4 @@ Examples:
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass

hanzo_mcp/tools/shell/process_tool.py

@@ -3,23 +3,23 @@
 import signal
 from typing import Optional, override
 
+from mcp.server import FastMCP
 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:
@@ -32,7 +32,7 @@ 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,
@@ -43,14 +43,14 @@ process --action logs --id bash_ghi789 --lines 50"""
         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
         """
@@ -58,86 +58,86 @@ process --action logs --id bash_ghi789 --lines 50"""
             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')})"
+                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."""
         tool_self = self
-        
+
         @server.tool(name=self.name, description=self.description)
         async def process(
             ctx: MCPContext,
             action: str = "list",
             id: Optional[str] = None,
             signal_type: str = "TERM",
-            lines: int = 100
+            lines: int = 100,
         ) -> str:
             return await tool_self.run(
-                ctx,
-                action=action,
-                id=id,
-                signal_type=signal_type,
-                lines=lines
+                ctx, action=action, id=id, signal_type=signal_type, lines=lines
             )
-    
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(
@@ -145,9 +145,9 @@ process --action logs --id bash_ghi789 --lines 50"""
             action=params.get("action", "list"),
             id=params.get("id"),
             signal_type=params.get("signal_type", "TERM"),
-            lines=params.get("lines", 100)
+            lines=params.get("lines", 100),
         )
 
 
 # Create tool instance
-process_tool = ProcessTool()
+process_tool = ProcessTool()

hanzo_mcp/tools/shell/processes.py

@@ -1,18 +1,17 @@
 """Tool for listing running background processes."""
 
-import psutil
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 from datetime import datetime
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
+import psutil
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 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(
@@ -132,10 +131,10 @@ Examples:
     ) -> 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():
@@ -143,22 +142,26 @@ Examples:
                 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})"
+            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
-            
+            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}")
@@ -166,10 +169,10 @@ Examples:
             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
@@ -179,13 +182,13 @@ Examples:
                     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(
@@ -194,86 +197,82 @@ Examples:
         """List all system processes."""
         try:
             processes = []
-            
+
             # Get all running processes
-            for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'create_time']):
+            for proc in psutil.process_iter(["pid", "name", "cmdline", "create_time"]):
                 try:
                     info = proc.info
-                    name = info['name']
-                    
+                    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')
+                    cmdline = info.get("cmdline")
                     if cmdline:
-                        cmd = ' '.join(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'],
+                        "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
-                    
+                        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'])
-            
+            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(
+                    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']}"
+                        f"{proc['pid']:>7} {proc['cpu']:>5.1f} {proc['memory']:>8.1f} {proc['name']:<20} {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"{proc['pid']:>7} {proc['name']:<20} {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
+        pass