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

hanzo_mcp/tools/shell/base_process.py

@@ -1,51 +1,48 @@
 """Base classes for process execution tools."""
 
-import asyncio
 import os
-import subprocess
-import tempfile
-import time
 import uuid
+import tempfile
+import subprocess
 from abc import abstractmethod
+from typing import Any, Dict, List, Optional, override
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, override
-
-from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
-from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.common.truncate import truncate_response
+from hanzo_mcp.tools.common.permissions import PermissionManager
+
 # Import moved to __init__ to avoid circular import
 
 
 class ProcessManager:
     """Singleton manager for background processes."""
-    
+
     _instance = None
     _processes: Dict[str, Any] = {}
     _logs: Dict[str, str] = {}
     _log_dir = Path(tempfile.gettempdir()) / "hanzo_mcp_logs"
-    
+
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
             cls._instance._log_dir.mkdir(exist_ok=True)
         return cls._instance
-    
+
     def add_process(self, process_id: str, process: Any, log_file: str) -> None:
         """Add a process to track."""
         self._processes[process_id] = process
         self._logs[process_id] = log_file
-    
+
     def get_process(self, process_id: str) -> Optional[Any]:
         """Get a tracked process."""
         return self._processes.get(process_id)
-    
+
     def remove_process(self, process_id: str) -> None:
         """Remove a process from tracking."""
         self._processes.pop(process_id, None)
         self._logs.pop(process_id, None)
-    
+
     def list_processes(self) -> Dict[str, Dict[str, Any]]:
         """List all tracked processes."""
         result = {}
@@ -54,45 +51,45 @@ class ProcessManager:
                 result[pid] = {
                     "pid": proc.pid,
                     "running": True,
-                    "log_file": self._logs.get(pid)
+                    "log_file": self._logs.get(pid),
                 }
             else:
                 result[pid] = {
                     "pid": proc.pid,
                     "running": False,
                     "return_code": proc.returncode,
-                    "log_file": self._logs.get(pid)
+                    "log_file": self._logs.get(pid),
                 }
                 # Clean up finished processes
                 self.remove_process(pid)
         return result
-    
+
     def get_log_file(self, process_id: str) -> Optional[Path]:
         """Get log file path for a process."""
         log_path = self._logs.get(process_id)
         return Path(log_path) if log_path else None
-    
+
     @property
     def log_dir(self) -> Path:
         """Get the log directory."""
         return self._log_dir
-    
+
     def create_log_file(self, process_id: str) -> Path:
         """Create a log file for a process.
-        
+
         Args:
             process_id: Process identifier
-            
+
         Returns:
             Path to the created log file
         """
         log_file = self._log_dir / f"{process_id}.log"
         log_file.touch()
         return log_file
-    
+
     def mark_completed(self, process_id: str, return_code: int) -> None:
         """Mark a process as completed with the given return code.
-        
+
         Args:
             process_id: Process identifier
             return_code: Process exit code
@@ -104,10 +101,10 @@ class ProcessManager:
 
 class BaseProcessTool(BaseTool):
     """Base class for all process execution tools."""
-    
+
     def __init__(self, permission_manager: Optional[PermissionManager] = None):
         """Initialize the process tool.
-        
+
         Args:
             permission_manager: Optional permission manager for access control
         """
@@ -116,46 +113,47 @@ class BaseProcessTool(BaseTool):
         self.process_manager = ProcessManager()
         # Import here to avoid circular import
         from hanzo_mcp.tools.shell.auto_background import AutoBackgroundExecutor
+
         self.auto_background_executor = AutoBackgroundExecutor(self.process_manager)
-    
+
     @abstractmethod
     def get_command_args(self, command: str, **kwargs) -> List[str]:
         """Get the command arguments for subprocess.
-        
+
         Args:
             command: The command or script to run
             **kwargs: Additional arguments specific to the tool
-            
+
         Returns:
             List of command arguments for subprocess
         """
         pass
-    
+
     @abstractmethod
     def get_tool_name(self) -> str:
         """Get the name of the tool being used (e.g., 'bash', 'uvx', 'npx')."""
         pass
-    
+
     async def execute_sync(
         self,
         command: str,
         cwd: Optional[Path] = None,
         env: Optional[Dict[str, str]] = None,
         timeout: Optional[int] = None,
-        **kwargs
+        **kwargs,
     ) -> str:
         """Execute a command with auto-backgrounding after 2 minutes.
-        
+
         Args:
             command: Command to execute
             cwd: Working directory
             env: Environment variables
             timeout: Timeout in seconds (ignored - auto-backgrounds after 2 minutes)
             **kwargs: Additional tool-specific arguments
-            
+
         Returns:
             Command output or background status
-            
+
         Raises:
             RuntimeError: If command fails
         """
@@ -163,23 +161,25 @@ class BaseProcessTool(BaseTool):
         if self.permission_manager and cwd:
             if not self.permission_manager.is_path_allowed(str(cwd)):
                 raise PermissionError(f"Access denied to path: {cwd}")
-        
+
         # Get command arguments
         cmd_args = self.get_command_args(command, **kwargs)
-        
+
         # Prepare environment
         process_env = os.environ.copy()
         if env:
             process_env.update(env)
-        
+
         # Execute with auto-backgrounding
-        output, was_backgrounded, process_id = await self.auto_background_executor.execute_with_auto_background(
-            cmd_args=cmd_args,
-            tool_name=self.get_tool_name(),
-            cwd=cwd,
-            env=process_env
+        output, was_backgrounded, process_id = (
+            await self.auto_background_executor.execute_with_auto_background(
+                cmd_args=cmd_args,
+                tool_name=self.get_tool_name(),
+                cwd=cwd,
+                env=process_env,
+            )
         )
-        
+
         if was_backgrounded:
             return output
         else:
@@ -189,24 +189,24 @@ class BaseProcessTool(BaseTool):
             return truncate_response(
                 output,
                 max_tokens=25000,
-                truncation_message="\n\n[Command output truncated due to token limit. Output may be available in logs or files.]"
+                truncation_message="\n\n[Command output truncated due to token limit. Output may be available in logs or files.]",
             )
-    
+
     async def execute_background(
         self,
         command: str,
         cwd: Optional[Path] = None,
         env: Optional[Dict[str, str]] = None,
-        **kwargs
+        **kwargs,
     ) -> Dict[str, Any]:
         """Execute a command in the background.
-        
+
         Args:
             command: Command to execute
             cwd: Working directory
             env: Environment variables
             **kwargs: Additional tool-specific arguments
-            
+
         Returns:
             Dict with process_id and log_file
         """
@@ -214,19 +214,19 @@ class BaseProcessTool(BaseTool):
         if self.permission_manager and cwd:
             if not self.permission_manager.is_path_allowed(str(cwd)):
                 raise PermissionError(f"Access denied to path: {cwd}")
-        
+
         # Generate process ID and log file
         process_id = f"{self.get_tool_name()}_{uuid.uuid4().hex[:8]}"
         log_file = self.process_manager.log_dir / f"{process_id}.log"
-        
+
         # Get command arguments
         cmd_args = self.get_command_args(command, **kwargs)
-        
+
         # Prepare environment
         process_env = os.environ.copy()
         if env:
             process_env.update(env)
-        
+
         # Start process with output to log file
         with open(log_file, "w") as f:
             process = subprocess.Popen(
@@ -235,57 +235,57 @@ class BaseProcessTool(BaseTool):
                 env=process_env,
                 stdout=f,
                 stderr=subprocess.STDOUT,
-                text=True
+                text=True,
             )
-        
+
         # Track the process
         self.process_manager.add_process(process_id, process, log_file)
-        
+
         return {
             "process_id": process_id,
             "pid": process.pid,
             "log_file": str(log_file),
-            "status": "started"
+            "status": "started",
         }
 
 
 class BaseBinaryTool(BaseProcessTool):
     """Base class for binary execution tools (like npx, uvx)."""
-    
+
     @abstractmethod
     def get_binary_name(self) -> str:
         """Get the name of the binary to execute."""
         pass
-    
+
     @override
     def get_command_args(self, command: str, **kwargs) -> List[str]:
         """Get command arguments for binary execution.
-        
+
         Args:
             command: The package or command to run
             **kwargs: Additional arguments (args, flags, etc.)
-            
+
         Returns:
             List of command arguments
         """
         cmd_args = [self.get_binary_name()]
-        
+
         # Add any binary-specific flags
         if "flags" in kwargs:
             cmd_args.extend(kwargs["flags"])
-        
+
         # Add the command/package
         cmd_args.append(command)
-        
+
         # Add any additional arguments
         if "args" in kwargs:
             if isinstance(kwargs["args"], str):
                 cmd_args.extend(kwargs["args"].split())
             else:
                 cmd_args.extend(kwargs["args"])
-        
+
         return cmd_args
-    
+
     @override
     def get_tool_name(self) -> str:
         """Get the tool name (same as binary name by default)."""
@@ -294,44 +294,44 @@ class BaseBinaryTool(BaseProcessTool):
 
 class BaseScriptTool(BaseProcessTool):
     """Base class for script execution tools (like bash, python)."""
-    
+
     @abstractmethod
     def get_interpreter(self) -> str:
         """Get the interpreter to use."""
         pass
-    
+
     @abstractmethod
     def get_script_flags(self) -> List[str]:
         """Get default flags for the interpreter."""
         pass
-    
+
     @override
     def get_command_args(self, command: str, **kwargs) -> List[str]:
         """Get command arguments for script execution.
-        
+
         Args:
             command: The script content to execute
             **kwargs: Additional arguments
-            
+
         Returns:
             List of command arguments
         """
         cmd_args = [self.get_interpreter()]
         cmd_args.extend(self.get_script_flags())
-        
+
         # For inline scripts, use -c flag
         if not kwargs.get("is_file", False):
             cmd_args.extend(["-c", command])
         else:
             cmd_args.append(command)
-        
+
         return cmd_args
-    
-    @override  
+
+    @override
     def get_tool_name(self) -> str:
         """Get the tool name (interpreter name by default)."""
         return self.get_interpreter()
 
 
 # Import os at the top of the file
-import os
+import os

hanzo_mcp/tools/shell/bash_session.py

@@ -14,8 +14,8 @@ import bashlex  # type: ignore
 import libtmux
 
 from hanzo_mcp.tools.shell.base import (
-    BashCommandStatus,
     CommandResult,
+    BashCommandStatus,
 )
 
 
@@ -355,7 +355,7 @@ class BashSession:
                 error_message=(
                     f"ERROR: Cannot execute multiple commands at once.\n"
                     f"Please run each command separately OR chain them into a single command via && or ;\n"
-                    f"Provided commands:\n{'\n'.join(f'({i + 1}) {cmd}' for i, cmd in enumerate(splited_commands))}"
+                    f"Provided commands:\n{chr(10).join(f'({i + 1}) {cmd}' for i, cmd in enumerate(splited_commands))}"
                 ),
                 command=command,
                 status=BashCommandStatus.COMPLETED,

hanzo_mcp/tools/shell/bash_session_executor.py

@@ -4,15 +4,14 @@ This module provides a BashSessionExecutor class that replaces the old CommandEx
 implementation with the new BashSession-based approach for better persistent execution.
 """
 
-import asyncio
-import logging
 import os
 import shlex
-import subprocess
+import asyncio
+import logging
 from typing import final
 
+from hanzo_mcp.tools.shell.base import CommandResult, BashCommandStatus
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.shell.base import BashCommandStatus, CommandResult
 from hanzo_mcp.tools.shell.session_manager import SessionManager
 
 
@@ -65,6 +64,7 @@ class BashSessionExecutor:
         if data is not None:
             try:
                 import json
+
                 logger = logging.getLogger(__name__)
                 if isinstance(data, (dict, list)):
                     data_str = json.dumps(data)

hanzo_mcp/tools/shell/bash_tool.py

@@ -2,40 +2,36 @@
 
 import os
 import platform
-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 BaseScriptTool
-from mcp.server import FastMCP
 
 
 class BashTool(BaseScriptTool):
     """Tool for running shell commands."""
-    
+
     name = "bash"
-    
+
     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 bash(
             ctx: MCPContext,
             command: str,
             cwd: Optional[str] = None,
             env: Optional[dict[str, str]] = None,
-            timeout: Optional[int] = None
+            timeout: Optional[int] = None,
         ) -> str:
             return await tool_self.run(
-                ctx,
-                command=command,
-                cwd=cwd,
-                env=env,
-                timeout=timeout
+                ctx, command=command, cwd=cwd, env=env, timeout=timeout
             )
-    
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(
@@ -43,9 +39,9 @@ class BashTool(BaseScriptTool):
             command=params["command"],
             cwd=params.get("cwd"),
             env=params.get("env"),
-            timeout=params.get("timeout")
+            timeout=params.get("timeout"),
         )
-    
+
     @property
     @override
     def description(self) -> str:
@@ -60,19 +56,19 @@ bash "ls -la"
 bash "python server.py"  # Auto-backgrounds after 2 minutes
 bash "git status && git diff"
 bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
-    
+
     @override
     def get_interpreter(self) -> str:
         """Get the shell interpreter."""
         if platform.system() == "Windows":
             return "cmd.exe"
-        
+
         # Check for user's preferred shell from environment
         shell = os.environ.get("SHELL", "/bin/bash")
-        
+
         # Extract just the shell name from the path
         shell_name = os.path.basename(shell)
-        
+
         # Check if it's a supported shell and the config file exists
         if shell_name == "zsh":
             # Check for .zshrc
@@ -84,27 +80,27 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
             fish_config = Path.home() / ".config" / "fish" / "config.fish"
             if fish_config.exists():
                 return shell  # Use full path to fish
-        
+
         # Default to bash if no special shell config found
         return "bash"
-    
+
     @override
     def get_script_flags(self) -> list[str]:
         """Get interpreter flags."""
         if platform.system() == "Windows":
             return ["/c"]
         return ["-c"]
-    
+
     @override
     def get_tool_name(self) -> str:
         """Get the tool name."""
         if platform.system() == "Windows":
             return "shell"
-        
+
         # Return the actual shell being used
         interpreter = self.get_interpreter()
         return os.path.basename(interpreter)
-    
+
     @override
     async def run(
         self,
@@ -115,29 +111,26 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
         timeout: Optional[int] = None,
     ) -> str:
         """Run a shell command with auto-backgrounding.
-        
+
         Args:
             ctx: MCP context
             command: Shell command to execute
             cwd: Working directory
             env: Environment variables
             timeout: Command timeout in seconds (ignored - auto-backgrounds after 2 minutes)
-            
+
         Returns:
             Command output or background status
         """
         # Prepare working directory
         work_dir = Path(cwd).resolve() if cwd else Path.cwd()
-        
+
         # Always use execute_sync which now has auto-backgrounding
         output = await self.execute_sync(
-            command,
-            cwd=work_dir,
-            env=env,
-            timeout=timeout
+            command, cwd=work_dir, env=env, timeout=timeout
         )
         return output if output else "Command completed successfully (no output)"
 
 
 # Create tool instance
-bash_tool = BashTool()
+bash_tool = BashTool()

hanzo_mcp/tools/shell/command_executor.py

@@ -4,20 +4,19 @@ This module provides tools for executing shell commands and scripts with
 comprehensive error handling, permissions checking, and progress tracking.
 """
 
-import asyncio
-import base64
 import os
 import re
+import sys
 import shlex
+import base64
 import shutil
-import sys
+import asyncio
 import tempfile
-from collections.abc import Awaitable, Callable
 from typing import final
+from collections.abc import Callable, Awaitable
 
-
-from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.shell.base import CommandResult
+from hanzo_mcp.tools.common.permissions import PermissionManager
 
 
 @final
@@ -183,6 +182,7 @@ class CommandExecutor:
         if data is not None:
             try:
                 import json
+
                 logger = logging.getLogger(__name__)
                 if isinstance(data, (dict, list)):
                     data_str = json.dumps(data)
@@ -312,11 +312,11 @@ class CommandExecutor:
                         self._log(f"Escaped command: {escaped_command}")
 
                         # Wrap command with appropriate shell invocation
-                        if shell_basename == "zsh":
-                            shell_cmd = f"{user_shell} -l -c '{escaped_command}'"
-                        elif shell_basename == "bash":
-                            shell_cmd = f"{user_shell} -l -c '{escaped_command}'"
-                        elif shell_basename == "fish":
+                        if (
+                            shell_basename == "zsh"
+                            or shell_basename == "bash"
+                            or shell_basename == "fish"
+                        ):
                             shell_cmd = f"{user_shell} -l -c '{escaped_command}'"
                         else:
                             # Default fallback
@@ -691,7 +691,7 @@ class CommandExecutor:
                     match = re.match(r"([a-zA-Z]):\\(.*)", temp_path)
                     if match:
                         drive, path = match.groups()
-                        wsl_path = f"/mnt/{drive.lower()}/{path.replace('\\', '/')}"
+                        wsl_path = f"/mnt/{drive.lower()}/{path.replace(chr(92), '/')}"
                     else:
                         wsl_path = temp_path.replace("\\", "/")
                         self._log(f"WSL path conversion may be incomplete: {wsl_path}")