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

hanzo_mcp/tools/shell/run_background.py

@@ -1,22 +1,19 @@
 """Background process execution tool."""
 
-import asyncio
 import os
-import subprocess
-import time
 import uuid
-from datetime import datetime
+import subprocess
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
+from datetime import datetime
 
-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
 
-
 Command = Annotated[
     str,
     Field(
@@ -70,7 +67,7 @@ class RunBackgroundParams(TypedDict, total=False):
 
 class BackgroundProcess:
     """Represents a running background process."""
-    
+
     def __init__(
         self,
         process_id: str,
@@ -88,34 +85,34 @@ class BackgroundProcess:
         self.process = process
         self.start_time = datetime.now()
         self.end_time: Optional[datetime] = None
-        
+
     @property
     def is_running(self) -> bool:
         """Check if process is still running."""
         return self.process.poll() is None
-    
+
     @property
     def pid(self) -> int:
         """Get process ID."""
         return self.process.pid
-    
+
     @property
     def return_code(self) -> Optional[int]:
         """Get return code if process has finished."""
         return self.process.poll()
-    
+
     def terminate(self) -> None:
         """Terminate the process."""
         if self.is_running:
             self.process.terminate()
             self.end_time = datetime.now()
-    
+
     def kill(self) -> None:
         """Kill the process forcefully."""
         if self.is_running:
             self.process.kill()
             self.end_time = datetime.now()
-    
+
     def to_dict(self) -> dict:
         """Convert to dictionary for display."""
         return {
@@ -135,10 +132,10 @@ class BackgroundProcess:
 @final
 class RunBackgroundTool(BaseTool):
     """Tool for running commands in the background."""
-    
+
     # Class variable to store running processes
     _processes: dict[str, BackgroundProcess] = {}
-    
+
     def __init__(self, permission_manager: PermissionManager):
         """Initialize the background runner tool.
 
@@ -213,7 +210,7 @@ Examples:
 
         # Resolve absolute path for working directory
         abs_working_dir = os.path.abspath(working_dir)
-        
+
         # Check permissions
         if not self.permission_manager.has_permission(abs_working_dir):
             return f"Permission denied: {abs_working_dir}"
@@ -224,7 +221,7 @@ Examples:
 
         # Generate process ID
         process_id = str(uuid.uuid4())[:8]
-        
+
         # Setup logging
         log_file = None
         if log_to_file:
@@ -241,7 +238,7 @@ Examples:
 
             # Open log file for writing
             if log_file:
-                log_handle = open(log_file, 'w')
+                log_handle = open(log_file, "w")
                 stdout = log_handle
                 stderr = subprocess.STDOUT
             else:
@@ -272,11 +269,13 @@ Examples:
 
             # Store in class variable
             RunBackgroundTool._processes[process_id] = bg_process
-            
+
             # Clean up finished processes
             self._cleanup_finished_processes()
 
-            await tool_ctx.info(f"Process started with ID: {process_id}, PID: {process.pid}")
+            await tool_ctx.info(
+                f"Process started with ID: {process_id}, PID: {process.pid}"
+            )
 
             # Return process information
             return f"""Background process started successfully!
@@ -286,7 +285,7 @@ Name: {name}
 PID: {process.pid}
 Command: {command}
 Working Directory: {abs_working_dir}
-Log File: {log_file if log_file else 'Not logging'}
+Log File: {log_file if log_file else "Not logging"}
 
 Use 'processes' to list all running processes
 Use 'pkill --id {process_id}' to stop this process
@@ -311,16 +310,16 @@ Use 'logs --id {process_id}' to view output (if logging enabled)
         """Remove finished processes that have been terminated for a while."""
         now = datetime.now()
         to_remove = []
-        
+
         for process_id, process in RunBackgroundTool._processes.items():
             if not process.is_running and process.end_time:
                 # Keep finished processes for 5 minutes for log access
                 if (now - process.end_time).total_seconds() > 300:
                     to_remove.append(process_id)
-        
+
         for process_id in to_remove:
             del RunBackgroundTool._processes[process_id]
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass

hanzo_mcp/tools/shell/run_command.py

@@ -3,15 +3,15 @@
 This module provides the RunCommandTool for running shell commands.
 """
 
-from typing import Annotated, Any, TypedDict, Unpack, final, override
+from typing import Any, Unpack, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.shell.base import ShellBaseTool
 from hanzo_mcp.tools.common.base import handle_connection_errors
 from hanzo_mcp.tools.common.context import create_tool_context
-from hanzo_mcp.tools.shell.base import ShellBaseTool
 from hanzo_mcp.tools.shell.bash_session_executor import BashSessionExecutor
 
 Command = Annotated[
@@ -344,7 +344,7 @@ Important:
             time_out: TimeOut,
             is_input: IsInput,
             blocking: Blocking,
-            ctx: MCPContext
+            ctx: MCPContext,
         ) -> str:
             return await tool_self.call(
                 ctx,

hanzo_mcp/tools/shell/run_command_windows.py

@@ -4,15 +4,15 @@ This module provides the RunCommandTool for running shell commands on Windows.
 """
 
 import os
-from typing import Annotated, Any, final, override
+from typing import Any, Annotated, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.shell.base import ShellBaseTool
 from hanzo_mcp.tools.common.base import handle_connection_errors
 from hanzo_mcp.tools.common.context import create_tool_context
-from hanzo_mcp.tools.shell.base import ShellBaseTool
 from hanzo_mcp.tools.shell.command_executor import CommandExecutor
 
 
@@ -288,6 +288,7 @@ Important:
         @mcp_server.tool(name=self.name, description=self.description)
         @handle_connection_errors
         async def run_command(
+            ctx: MCPContext,
             command: Annotated[
                 str,
                 Field(
@@ -316,7 +317,6 @@ Important:
                     default=True,
                 ),
             ] = True,
-            ctx: MCPContext
         ) -> str:
             return await tool_self.call(
                 ctx,

hanzo_mcp/tools/shell/session_storage.py

@@ -201,9 +201,9 @@ class SessionStorageInstance:
         return {
             "total_sessions": len(self._sessions),
             "max_sessions": self.max_sessions,
-            "utilization": len(self._sessions) / self.max_sessions
-            if self.max_sessions > 0
-            else 0,
+            "utilization": (
+                len(self._sessions) / self.max_sessions if self.max_sessions > 0 else 0
+            ),
             "default_ttl_seconds": self.default_ttl_seconds,
         }