hanzo-mcp 0.7.7__py3-none-any.whl → 0.8.1__py3-none-any.whl

hanzo_mcp/tools/shell/logs.py

@@ -1,18 +1,16 @@
 """Tool for viewing process logs."""
 
-import os
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 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 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(
@@ -142,20 +140,20 @@ Use run_command with 'tail -f' for continuous monitoring.
                 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"
 
@@ -169,13 +167,15 @@ Use run_command with 'tail -f' for continuous monitoring.
 
             # Note about follow mode
             if follow:
-                await tool_ctx.warning("Follow mode not supported in MCP. Showing latest lines instead.")
+                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:
+                with open(log_path, "r") as f:
                     if lines == -1:
                         # Read entire file
                         content = f.read()
@@ -183,13 +183,13 @@ Use run_command with 'tail -f' for continuous monitoring.
                         # Read last N lines
                         all_lines = f.readlines()
                         if len(all_lines) <= lines:
-                            content = ''.join(all_lines)
+                            content = "".join(all_lines)
                         else:
-                            content = ''.join(all_lines[-lines:])
-                
+                            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:
@@ -197,12 +197,16 @@ Use run_command with 'tail -f' for continuous monitoring.
                     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})"
+                        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)}"
 
@@ -213,48 +217,54 @@ Use run_command with 'tail -f' for continuous monitoring.
     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}
-        
+        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})")
+                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']:
+        for unit in ["B", "KB", "MB", "GB"]:
             if size < 1024.0:
                 return f"{size:.1f} {unit}"
             size /= 1024.0
@@ -262,4 +272,4 @@ Use run_command with 'tail -f' for continuous monitoring.
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass

hanzo_mcp/tools/shell/npx.py

@@ -1,17 +1,16 @@
 """Run Node.js packages with npx."""
 
-import subprocess
 import shutil
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
+import subprocess
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 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
 
-
 Package = Annotated[
     str,
     Field(
@@ -144,16 +143,17 @@ Or download from: https://nodejs.org/"""
 
         # Build command
         cmd = ["npx"]
-        
+
         if yes:
             cmd.append("--yes")
-        
+
         cmd.append(package)
-        
+
         # Add package arguments
         if args:
             # Split args properly (basic parsing)
             import shlex
+
             cmd.extend(shlex.split(args))
 
         await tool_ctx.info(f"Running: {' '.join(cmd)}")
@@ -161,11 +161,7 @@ Or download from: https://nodejs.org/"""
         try:
             # Execute command
             result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=timeout,
-                check=True
+                cmd, capture_output=True, text=True, timeout=timeout, check=True
             )
 
             output = []
@@ -174,7 +170,11 @@ Or download from: https://nodejs.org/"""
             if result.stderr:
                 output.append(f"\nSTDERR:\n{result.stderr}")
 
-            return "\n".join(output) if output else "Command completed successfully with no output."
+            return (
+                "\n".join(output)
+                if output
+                else "Command completed successfully with no output."
+            )
 
         except subprocess.TimeoutExpired:
             return f"Error: Command timed out after {timeout} seconds. Use npx_background for long-running processes."

hanzo_mcp/tools/shell/npx_background.py

@@ -1,19 +1,18 @@
 """Run Node.js packages in background with npx."""
 
-import subprocess
-import shutil
 import uuid
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
+import shutil
+import subprocess
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 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 BackgroundProcess, RunBackgroundTool
 
-
 Package = Annotated[
     str,
     Field(
@@ -163,25 +162,27 @@ Or download from: https://nodejs.org/"""
 
         # Build command
         cmd = ["npx"]
-        
+
         if yes:
             cmd.append("--yes")
-        
+
         cmd.append(package)
-        
+
         # Add package arguments
         if args:
             # Split args properly (basic parsing)
             import shlex
+
             cmd.extend(shlex.split(args))
 
         # Generate process ID
         process_id = str(uuid.uuid4())[:8]
-        
+
         # Prepare log file if needed
         log_file = None
         if log_output:
             from pathlib import Path
+
             log_dir = Path.home() / ".hanzo" / "logs"
             log_dir.mkdir(parents=True, exist_ok=True)
             log_file = log_dir / f"{name}_{process_id}.log"
@@ -197,7 +198,7 @@ Or download from: https://nodejs.org/"""
                         stdout=f,
                         stderr=subprocess.STDOUT,
                         cwd=working_dir,
-                        start_new_session=True
+                        start_new_session=True,
                     )
             else:
                 process = subprocess.Popen(
@@ -205,7 +206,7 @@ Or download from: https://nodejs.org/"""
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                     cwd=working_dir,
-                    start_new_session=True
+                    start_new_session=True,
                 )
 
             # Create background process object
@@ -215,7 +216,7 @@ Or download from: https://nodejs.org/"""
                 name=name,
                 process=process,
                 log_file=str(log_file) if log_file else None,
-                working_dir=working_dir
+                working_dir=working_dir,
             )
 
             # Register with RunBackgroundTool
@@ -229,19 +230,21 @@ Or download from: https://nodejs.org/"""
                 f"  PID: {process.pid}",
                 f"  Command: {' '.join(cmd)}",
             ]
-            
+
             if working_dir:
                 output.append(f"  Working Dir: {working_dir}")
-            
+
             if log_file:
                 output.append(f"  Log: {log_file}")
-            
-            output.extend([
-                "",
-                "Use 'processes' to list running processes.",
-                f"Use 'logs --process-id {process_id}' to view output.",
-                f"Use 'pkill --process-id {process_id}' to stop."
-            ])
+
+            output.extend(
+                [
+                    "",
+                    "Use 'processes' to list running processes.",
+                    f"Use 'logs --process-id {process_id}' to view output.",
+                    f"Use 'pkill --process-id {process_id}' to stop.",
+                ]
+            )
 
             return "\n".join(output)
 

hanzo_mcp/tools/shell/npx_tool.py

@@ -1,19 +1,19 @@
 """NPX tool for both sync and background execution."""
 
-from pathlib import Path
 from typing import Optional, override
+from pathlib import Path
 
+from mcp.server import FastMCP
 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:
@@ -27,12 +27,12 @@ npx create-react-app my-app
 npx http-server -p 8080  # Auto-backgrounds after 2 minutes
 npx prettier --write "**/*.js"
 npx json-server db.json  # Auto-backgrounds if needed"""
-    
+
     @override
     def get_binary_name(self) -> str:
         """Get the binary name."""
         return "npx"
-    
+
     @override
     async def run(
         self,
@@ -43,57 +43,53 @@ npx json-server db.json  # Auto-backgrounds if needed"""
         yes: bool = True,
     ) -> str:
         """Run an npx command with auto-backgrounding.
-        
+
         Args:
             ctx: MCP context
             package: NPX package to run
             args: Additional arguments
             cwd: Working directory
             yes: Auto-confirm package installation
-            
+
         Returns:
             Command output or background status
         """
         # 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 []
-        
+
         # Always use execute_sync which now has auto-backgrounding
         return await self.execute_sync(
             package,
             cwd=work_dir,
             flags=flags,
             args=full_args,
-            timeout=None  # Let auto-backgrounding handle timeout
+            timeout=None,  # Let auto-backgrounding handle timeout
         )
 
     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 npx(
             ctx: MCPContext,
             package: str,
             args: str = "",
             cwd: Optional[str] = None,
-            yes: bool = True
+            yes: bool = True,
         ) -> str:
             return await tool_self.run(
-                ctx,
-                package=package,
-                args=args,
-                cwd=cwd,
-                yes=yes
+                ctx, package=package, args=args, cwd=cwd, yes=yes
             )
-    
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(
@@ -101,9 +97,9 @@ npx json-server db.json  # Auto-backgrounds if needed"""
             package=params["package"],
             args=params.get("args", ""),
             cwd=params.get("cwd"),
-            yes=params.get("yes", True)
+            yes=params.get("yes", True),
         )
 
 
 # Create tool instance
-npx_tool = NpxTool()
+npx_tool = NpxTool()

hanzo_mcp/tools/shell/open.py

@@ -3,32 +3,29 @@
 import platform
 import subprocess
 import webbrowser
-from pathlib import Path
 from typing import override
+from pathlib import Path
 from urllib.parse import urlparse
 
+from mcp.server import FastMCP
 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."""
         tool_self = self
-        
+
         @server.tool(name=self.name, description=self.description)
-        async def open(
-            path: str,
-            ctx: MCPContext
-        ) -> str:
+        async def open(path: str, ctx: MCPContext) -> str:
             return await tool_self.run(ctx, path)
-    
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(ctx, params["path"])
@@ -47,21 +44,21 @@ 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')
-        
+        is_url = parsed.scheme in ("http", "https", "ftp", "file")
+
         if is_url:
             # Open URL in default browser
             try:
@@ -69,15 +66,15 @@ open /path/to/image.png"""
                 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)
@@ -98,12 +95,13 @@ open /path/to/image.png"""
             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:
@@ -111,4 +109,4 @@ open /path/to/image.png"""
 
 
 # Create tool instance
-open_tool = OpenTool()
+open_tool = OpenTool()