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

hanzo_mcp/tools/mcp/mcp_remove.py

@@ -0,0 +1,127 @@
+"""Remove MCP servers."""
+
+from typing import Annotated, TypedDict, Unpack, final, override
+
+from 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.mcp.mcp_add import McpAddTool
+
+
+ServerName = Annotated[
+    str,
+    Field(
+        description="Name of the server to remove",
+        min_length=1,
+    ),
+]
+
+Force = Annotated[
+    bool,
+    Field(
+        description="Force removal even if server is running",
+        default=False,
+    ),
+]
+
+
+class McpRemoveParams(TypedDict, total=False):
+    """Parameters for MCP remove tool."""
+
+    name: str
+    force: bool
+
+
+@final
+class McpRemoveTool(BaseTool):
+    """Tool for removing MCP servers."""
+
+    def __init__(self):
+        """Initialize the MCP remove tool."""
+        pass
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "mcp_remove"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Remove previously added MCP servers.
+
+This removes MCP servers that were added with mcp_add.
+If the server is running, it will be stopped first.
+
+Examples:
+- mcp_remove --name filesystem
+- mcp_remove --name github --force
+
+Use 'mcp_stats' to see all servers before removing.
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[McpRemoveParams],
+    ) -> str:
+        """Remove an MCP server.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Result of removing the server
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        name = params.get("name")
+        if not name:
+            return "Error: name is required"
+
+        force = params.get("force", False)
+
+        # Get current servers
+        servers = McpAddTool.get_servers()
+        
+        if name not in servers:
+            return f"Error: Server '{name}' not found. Use 'mcp_stats' to see available servers."
+
+        server = servers[name]
+        
+        await tool_ctx.info(f"Removing MCP server '{name}'")
+
+        # Check if server is running
+        if server.get("status") == "running" and server.get("process_id"):
+            if not force:
+                return f"Error: Server '{name}' is currently running. Use --force to remove anyway."
+            else:
+                # TODO: Stop the server process
+                await tool_ctx.info(f"Stopping running server '{name}'")
+
+        # Remove from registry
+        del McpAddTool._mcp_servers[name]
+        McpAddTool._save_servers()
+
+        output = [
+            f"Successfully removed MCP server '{name}'",
+            f"  Type: {server.get('type', 'unknown')}",
+            f"  Command: {' '.join(server.get('command', []))}",
+        ]
+        
+        if server.get("tools"):
+            output.append(f"  Tools removed: {len(server['tools'])}")
+        
+        return "\n".join(output)
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/mcp/mcp_stats.py

@@ -0,0 +1,165 @@
+"""MCP server statistics."""
+
+import json
+from typing import TypedDict, Unpack, final, override
+from datetime import datetime
+
+from 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.mcp.mcp_add import McpAddTool
+
+
+class McpStatsParams(TypedDict, total=False):
+    """Parameters for MCP stats tool."""
+    pass
+
+
+@final
+class McpStatsTool(BaseTool):
+    """Tool for showing MCP server statistics."""
+
+    def __init__(self):
+        """Initialize the MCP stats tool."""
+        pass
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "mcp_stats"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Show statistics about added MCP servers.
+
+Displays:
+- Total number of servers
+- Server types (Python, Node.js)
+- Server status (running, stopped, error)
+- Available tools from each server
+- Resource usage per server
+
+Example:
+- mcp_stats
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[McpStatsParams],
+    ) -> str:
+        """Get MCP server statistics.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            MCP server statistics
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Get all servers
+        servers = McpAddTool.get_servers()
+        
+        if not servers:
+            return "No MCP servers have been added yet.\n\nUse 'mcp_add' to add servers."
+
+        output = []
+        output.append("=== MCP Server Statistics ===")
+        output.append(f"Total Servers: {len(servers)}")
+        output.append("")
+        
+        # Count by type
+        type_counts = {}
+        status_counts = {}
+        total_tools = 0
+        total_resources = 0
+        
+        for server in servers.values():
+            # Count types
+            server_type = server.get("type", "unknown")
+            type_counts[server_type] = type_counts.get(server_type, 0) + 1
+            
+            # Count status
+            status = server.get("status", "unknown")
+            status_counts[status] = status_counts.get(status, 0) + 1
+            
+            # Count tools and resources
+            total_tools += len(server.get("tools", []))
+            total_resources += len(server.get("resources", []))
+        
+        # Server types
+        output.append("Server Types:")
+        for stype, count in sorted(type_counts.items()):
+            output.append(f"  {stype}: {count}")
+        output.append("")
+        
+        # Server status
+        output.append("Server Status:")
+        for status, count in sorted(status_counts.items()):
+            output.append(f"  {status}: {count}")
+        output.append("")
+        
+        # Tools and resources
+        output.append(f"Total Tools Available: {total_tools}")
+        output.append(f"Total Resources Available: {total_resources}")
+        output.append("")
+        
+        # Individual server details
+        output.append("=== Server Details ===")
+        
+        for name, server in sorted(servers.items()):
+            output.append(f"\n{name}:")
+            output.append(f"  Type: {server.get('type', 'unknown')}")
+            output.append(f"  Status: {server.get('status', 'unknown')}")
+            output.append(f"  Command: {' '.join(server.get('command', []))}")
+            
+            if server.get("process_id"):
+                output.append(f"  Process ID: {server['process_id']}")
+            
+            if server.get("error"):
+                output.append(f"  Error: {server['error']}")
+            
+            tools = server.get("tools", [])
+            if tools:
+                output.append(f"  Tools ({len(tools)}):")
+                for tool in tools[:5]:  # Show first 5
+                    output.append(f"    - {tool}")
+                if len(tools) > 5:
+                    output.append(f"    ... and {len(tools) - 5} more")
+            
+            resources = server.get("resources", [])
+            if resources:
+                output.append(f"  Resources ({len(resources)}):")
+                for resource in resources[:5]:  # Show first 5
+                    output.append(f"    - {resource}")
+                if len(resources) > 5:
+                    output.append(f"    ... and {len(resources) - 5} more")
+            
+            if server.get("env"):
+                output.append(f"  Environment vars: {list(server['env'].keys())}")
+        
+        # Common MCP servers hint
+        output.append("\n=== Available MCP Servers ===")
+        output.append("Common servers you can add:")
+        output.append("  - @modelcontextprotocol/server-filesystem")
+        output.append("  - @modelcontextprotocol/server-github")
+        output.append("  - mcp-server-git")
+        output.append("  - @modelcontextprotocol/server-postgres")
+        output.append("  - @modelcontextprotocol/server-browser-use")
+        output.append("  - @modelcontextprotocol/server-iterm2")
+        output.append("  - @modelcontextprotocol/server-linear")
+        output.append("  - @modelcontextprotocol/server-slack")
+        
+        return "\n".join(output)
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/shell/__init__.py

@@ -11,6 +11,14 @@ from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.shell.bash_session_executor import BashSessionExecutor
 from hanzo_mcp.tools.shell.command_executor import CommandExecutor
+from hanzo_mcp.tools.shell.run_background import RunBackgroundTool
+from hanzo_mcp.tools.shell.processes import ProcessesTool
+from hanzo_mcp.tools.shell.pkill import PkillTool
+from hanzo_mcp.tools.shell.logs import LogsTool
+from hanzo_mcp.tools.shell.uvx import UvxTool
+from hanzo_mcp.tools.shell.uvx_background import UvxBackgroundTool
+from hanzo_mcp.tools.shell.npx import NpxTool
+from hanzo_mcp.tools.shell.npx_background import NpxBackgroundTool
 
 # Export all tool classes
 __all__ = [
@@ -30,23 +38,35 @@ def get_shell_tools(
     Returns:
         List of shell tool instances
     """
-    # Detect tmux availability and choose appropriate implementation
+    tools = []
+    
+    # Add platform-specific command tool
     if shutil.which("tmux") is not None:
         # Use tmux-based implementation for interactive sessions
         from hanzo_mcp.tools.shell.run_command import RunCommandTool
 
         command_executor = BashSessionExecutor(permission_manager)
-        return [
-            RunCommandTool(permission_manager, command_executor),
-        ]
+        tools.append(RunCommandTool(permission_manager, command_executor))
     else:
         # Use Windows-compatible implementation
         from hanzo_mcp.tools.shell.run_command_windows import RunCommandTool
 
         command_executor = CommandExecutor(permission_manager)
-        return [
-            RunCommandTool(permission_manager, command_executor),
-        ]
+        tools.append(RunCommandTool(permission_manager, command_executor))
+    
+    # Add other shell tools
+    tools.extend([
+        RunBackgroundTool(permission_manager),
+        ProcessesTool(),
+        PkillTool(),
+        LogsTool(),
+        UvxTool(permission_manager),
+        UvxBackgroundTool(permission_manager),
+        NpxTool(permission_manager),
+        NpxBackgroundTool(permission_manager),
+    ])
+    
+    return tools
 
 
 def register_shell_tools(

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 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