hanzo-mcp 0.6.13__py3-none-any.whl → 0.7.0__py3-none-any.whl

hanzo_mcp/tools/shell/__init__.py

@@ -14,6 +14,7 @@ from hanzo_mcp.tools.shell.npx_tool import npx_tool
 from hanzo_mcp.tools.shell.uvx_tool import uvx_tool
 from hanzo_mcp.tools.shell.process_tool import process_tool
 from hanzo_mcp.tools.shell.open import open_tool
+# from hanzo_mcp.tools.shell.streaming_command import StreamingCommandTool
 
 # Export all tool classes
 __all__ = [
@@ -38,12 +39,16 @@ def get_shell_tools(
     npx_tool.permission_manager = permission_manager
     uvx_tool.permission_manager = permission_manager
     
+    # Note: StreamingCommandTool is abstract and shouldn't be instantiated directly
+    # It's used as a base class for other streaming tools
+    
     return [
         bash_tool,
         npx_tool,
         uvx_tool,
         process_tool,
         open_tool,
+        # streaming_command_tool,  # Removed as it's abstract
     ]
 
 

hanzo_mcp/tools/shell/auto_background.py

@@ -0,0 +1,203 @@
+"""Auto-backgrounding shell execution.
+
+This module provides automatic backgrounding of long-running processes.
+Commands that take more than 2 minutes automatically continue in background.
+"""
+
+import asyncio
+import os
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Optional, Tuple
+
+from hanzo_mcp.tools.shell.base_process import ProcessManager
+
+
+class AutoBackgroundExecutor:
+    """Executor that automatically backgrounds long-running processes."""
+    
+    # Default timeout before auto-backgrounding (2 minutes)
+    DEFAULT_TIMEOUT = 120.0
+    
+    def __init__(self, process_manager: ProcessManager, timeout: float = DEFAULT_TIMEOUT):
+        """Initialize the auto-background executor.
+        
+        Args:
+            process_manager: Process manager for tracking background processes
+            timeout: Timeout in seconds before auto-backgrounding (default: 120s)
+        """
+        self.process_manager = process_manager
+        self.timeout = timeout
+    
+    async def execute_with_auto_background(
+        self,
+        cmd_args: list[str],
+        tool_name: str,
+        cwd: Optional[Path] = None,
+        env: Optional[dict[str, str]] = None,
+    ) -> Tuple[str, bool, Optional[str]]:
+        """Execute a command with automatic backgrounding if it takes too long.
+        
+        Args:
+            cmd_args: Command arguments list
+            tool_name: Name of the tool (for process ID generation)
+            cwd: Working directory
+            env: Environment variables
+            
+        Returns:
+            Tuple of (output/status, was_backgrounded, process_id)
+        """
+        # Generate process ID
+        process_id = f"{tool_name}_{uuid.uuid4().hex[:8]}"
+        
+        # Create log file
+        log_file = self.process_manager.create_log_file(process_id)
+        
+        # Start the process
+        process = await asyncio.create_subprocess_exec(
+            *cmd_args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            cwd=cwd,
+            env=env,
+        )
+        
+        # Track in process manager
+        self.process_manager.add_process(process_id, process, str(log_file))
+        
+        # Try to wait for completion with timeout
+        start_time = time.time()
+        output_lines = []
+        
+        try:
+            # Create tasks for reading output and waiting for process
+            async def read_output():
+                """Read output from process."""
+                if process.stdout:
+                    async for line in process.stdout:
+                        line_str = line.decode('utf-8', errors='replace')
+                        output_lines.append(line_str)
+                        # Also write to log file
+                        with open(log_file, 'a') as f:
+                            f.write(line_str)
+            
+            async def wait_for_process():
+                """Wait for process to complete."""
+                return await process.wait()
+            
+            # Run both tasks with timeout
+            read_task = asyncio.create_task(read_output())
+            wait_task = asyncio.create_task(wait_for_process())
+            
+            # Wait for either timeout or completion
+            done, pending = await asyncio.wait(
+                [read_task, wait_task],
+                timeout=self.timeout,
+                return_when=asyncio.FIRST_COMPLETED
+            )
+            
+            # Check if process completed
+            if wait_task in done:
+                # Process completed within timeout
+                return_code = await wait_task
+                await read_task  # Ensure all output is read
+                
+                # Mark process as completed
+                self.process_manager.mark_completed(process_id, return_code)
+                
+                output = ''.join(output_lines)
+                if return_code != 0:
+                    return f"Command failed with exit code {return_code}:\n{output}", False, None
+                else:
+                    return output, False, None
+            
+            else:
+                # Timeout reached - background the process
+                # Cancel the tasks we were waiting on
+                for task in pending:
+                    task.cancel()
+                
+                # Continue reading output in background
+                asyncio.create_task(self._background_reader(process, process_id, log_file))
+                
+                # Return status message
+                elapsed = time.time() - start_time
+                partial_output = ''.join(output_lines[-50:])  # Last 50 lines
+                
+                return (
+                    f"Process automatically backgrounded after {elapsed:.1f}s\n"
+                    f"Process ID: {process_id}\n"
+                    f"Log file: {log_file}\n\n"
+                    f"Use 'process --action logs --id {process_id}' to view full output\n"
+                    f"Use 'process --action kill --id {process_id}' to stop the process\n\n"
+                    f"=== Last output ===\n{partial_output}",
+                    True,
+                    process_id
+                )
+                
+        except Exception as e:
+            # Handle errors
+            self.process_manager.mark_completed(process_id, -1)
+            return f"Error executing command: {str(e)}", False, None
+    
+    async def _background_reader(self, process, process_id: str, log_file: Path):
+        """Continue reading output from a backgrounded process.
+        
+        Args:
+            process: The subprocess
+            process_id: Process identifier
+            log_file: Log file path
+        """
+        try:
+            # Continue reading output
+            if process.stdout:
+                async for line in process.stdout:
+                    with open(log_file, 'a') as f:
+                        f.write(line.decode('utf-8', errors='replace'))
+            
+            # Wait for process to complete
+            return_code = await process.wait()
+            
+            # Mark as completed
+            self.process_manager.mark_completed(process_id, return_code)
+            
+            # Add completion marker to log
+            with open(log_file, 'a') as f:
+                f.write(f"\n\n=== Process completed with exit code {return_code} ===\n")
+                
+        except Exception as e:
+            # Log error
+            with open(log_file, 'a') as f:
+                f.write(f"\n\n=== Background reader error: {str(e)} ===\n")
+            
+            self.process_manager.mark_completed(process_id, -1)
+
+
+def format_auto_background_message(
+    process_id: str,
+    elapsed_time: float,
+    log_file: str,
+    partial_output: str = "",
+) -> str:
+    """Format a user-friendly message for auto-backgrounded processes.
+    
+    Args:
+        process_id: Process identifier
+        elapsed_time: Time elapsed before backgrounding
+        log_file: Path to log file
+        partial_output: Partial output to show
+        
+    Returns:
+        Formatted message
+    """
+    return (
+        f"🔄 Process automatically backgrounded after {elapsed_time:.1f}s\n\n"
+        f"📋 Process ID: {process_id}\n"
+        f"📄 Log file: {log_file}\n\n"
+        f"Commands:\n"
+        f"  • View logs: process --action logs --id {process_id}\n"
+        f"  • Check status: process\n"
+        f"  • Stop process: process --action kill --id {process_id}\n"
+        f"{f'\\n=== Recent output ===\\n{partial_output}' if partial_output else ''}"
+    )

hanzo_mcp/tools/shell/base_process.py

@@ -1,25 +1,28 @@
 """Base classes for process execution tools."""
 
 import asyncio
+import os
 import subprocess
 import tempfile
+import time
 import uuid
 from abc import abstractmethod
 from pathlib import Path
-from typing import Any, Dict, List, Optional, override
+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
+# Import moved to __init__ to avoid circular import
 
 
 class ProcessManager:
     """Singleton manager for background processes."""
     
     _instance = None
-    _processes: Dict[str, subprocess.Popen] = {}
-    _logs: Dict[str, List[str]] = {}
+    _processes: Dict[str, Any] = {}
+    _logs: Dict[str, str] = {}
     _log_dir = Path(tempfile.gettempdir()) / "hanzo_mcp_logs"
     
     def __new__(cls):
@@ -28,12 +31,12 @@ class ProcessManager:
             cls._instance._log_dir.mkdir(exist_ok=True)
         return cls._instance
     
-    def add_process(self, process_id: str, process: subprocess.Popen, log_file: Path) -> None:
+    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] = str(log_file)
+        self._logs[process_id] = log_file
     
-    def get_process(self, process_id: str) -> Optional[subprocess.Popen]:
+    def get_process(self, process_id: str) -> Optional[Any]:
         """Get a tracked process."""
         return self._processes.get(process_id)
     
@@ -72,6 +75,30 @@ class ProcessManager:
     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
+        """
+        # For now, just remove from tracking
+        # In the future, we might want to keep a history
+        self.remove_process(process_id)
 
 
 class BaseProcessTool(BaseTool):
@@ -86,6 +113,9 @@ class BaseProcessTool(BaseTool):
         super().__init__()
         self.permission_manager = permission_manager
         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]:
@@ -113,17 +143,17 @@ class BaseProcessTool(BaseTool):
         timeout: Optional[int] = None,
         **kwargs
     ) -> str:
-        """Execute a command synchronously and return output.
+        """Execute a command with auto-backgrounding after 2 minutes.
         
         Args:
             command: Command to execute
             cwd: Working directory
             env: Environment variables
-            timeout: Timeout in seconds
+            timeout: Timeout in seconds (ignored - auto-backgrounds after 2 minutes)
             **kwargs: Additional tool-specific arguments
             
         Returns:
-            Command output
+            Command output or background status
             
         Raises:
             RuntimeError: If command fails
@@ -141,24 +171,20 @@ class BaseProcessTool(BaseTool):
         if env:
             process_env.update(env)
         
-        try:
-            result = subprocess.run(
-                cmd_args,
-                cwd=cwd,
-                env=process_env,
-                capture_output=True,
-                text=True,
-                timeout=timeout,
-                check=True
-            )
-            return result.stdout
-        except subprocess.TimeoutExpired:
-            raise RuntimeError(f"{self.get_tool_name()} command timed out after {timeout} seconds")
-        except subprocess.CalledProcessError as e:
-            error_msg = f"{self.get_tool_name()} command failed with exit code {e.returncode}"
-            if e.stderr:
-                error_msg += f"\nError: {e.stderr}"
-            raise RuntimeError(error_msg)
+        # 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
+        )
+        
+        if was_backgrounded:
+            return output
+        else:
+            if output.startswith("Command failed"):
+                raise RuntimeError(output)
+            return output
     
     async def execute_background(
         self,

hanzo_mcp/tools/shell/bash_tool.py

@@ -24,7 +24,6 @@ class BashTool(BaseScriptTool):
         async def bash(
             ctx: MCPContext,
             command: str,
-            action: str = "run",
             cwd: Optional[str] = None,
             env: Optional[dict[str, str]] = None,
             timeout: Optional[int] = None
@@ -32,7 +31,6 @@ class BashTool(BaseScriptTool):
             return await tool_self.run(
                 ctx,
                 command=command,
-                action=action,
                 cwd=cwd,
                 env=env,
                 timeout=timeout
@@ -43,7 +41,6 @@ class BashTool(BaseScriptTool):
         return await self.run(
             ctx,
             command=params["command"],
-            action=params.get("action", "run"),
             cwd=params.get("cwd"),
             env=params.get("env"),
             timeout=params.get("timeout")
@@ -53,13 +50,16 @@ class BashTool(BaseScriptTool):
     @override
     def description(self) -> str:
         """Get the tool description."""
-        return """Run shell commands. Actions: run (default), background.
+        return """Run shell commands with automatic backgrounding for long-running processes.
+
+Commands that run for more than 2 minutes will automatically continue in the background.
+You can check their status and logs using the 'process' tool.
 
 Usage:
 bash "ls -la"
-bash --action background "python server.py"
+bash "python server.py"  # Auto-backgrounds after 2 minutes
 bash "git status && git diff"
-bash --action background "npm run dev" --cwd ./frontend"""
+bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
     
     @override
     def get_interpreter(self) -> str:
@@ -110,49 +110,33 @@ bash --action background "npm run dev" --cwd ./frontend"""
         self,
         ctx: MCPContext,
         command: str,
-        action: str = "run",
         cwd: Optional[str] = None,
         env: Optional[dict[str, str]] = None,
         timeout: Optional[int] = None,
     ) -> str:
-        """Run a shell command.
+        """Run a shell command with auto-backgrounding.
         
         Args:
             ctx: MCP context
             command: Shell command to execute
-            action: Action to perform (run, background)
             cwd: Working directory
             env: Environment variables
-            timeout: Command timeout in seconds
+            timeout: Command timeout in seconds (ignored - auto-backgrounds after 2 minutes)
             
         Returns:
-            Command output or process info
+            Command output or background status
         """
         # Prepare working directory
         work_dir = Path(cwd).resolve() if cwd else Path.cwd()
         
-        if action == "background":
-            result = await self.execute_background(
-                command,
-                cwd=work_dir,
-                env=env
-            )
-            return (
-                f"Started command in background\n"
-                f"Process ID: {result['process_id']}\n"
-                f"PID: {result['pid']}\n"
-                f"Log file: {result['log_file']}\n"
-                f"Command: {command}"
-            )
-        else:
-            # Default to sync execution
-            output = await self.execute_sync(
-                command,
-                cwd=work_dir,
-                env=env,
-                timeout=timeout or 120  # Default 2 minute timeout
-            )
-            return output if output else "Command completed successfully (no output)"
+        # Always use execute_sync which now has auto-backgrounding
+        output = await self.execute_sync(
+            command,
+            cwd=work_dir,
+            env=env,
+            timeout=timeout
+        )
+        return output if output else "Command completed successfully (no output)"
 
 
 # Create tool instance

hanzo_mcp/tools/shell/npx_tool.py

@@ -18,13 +18,15 @@ class NpxTool(BaseBinaryTool):
     @override
     def description(self) -> str:
         """Get the tool description."""
-        return """Run npx packages. Actions: run (default), background.
+        return """Run npx packages with automatic backgrounding for long-running processes.
+
+Commands that run for more than 2 minutes will automatically continue in the background.
 
 Usage:
 npx create-react-app my-app
-npx --action background http-server -p 8080
+npx http-server -p 8080  # Auto-backgrounds after 2 minutes
 npx prettier --write "**/*.js"
-npx --action background json-server db.json"""
+npx json-server db.json  # Auto-backgrounds if needed"""
     
     @override
     def get_binary_name(self) -> str:
@@ -37,22 +39,20 @@ npx --action background json-server db.json"""
         ctx: MCPContext,
         package: str,
         args: str = "",
-        action: str = "run",
         cwd: Optional[str] = None,
         yes: bool = True,
     ) -> str:
-        """Run an npx command.
+        """Run an npx command with auto-backgrounding.
         
         Args:
             ctx: MCP context
             package: NPX package to run
             args: Additional arguments
-            action: Action to perform (run, background)
             cwd: Working directory
             yes: Auto-confirm package installation
             
         Returns:
-            Command output or process info
+            Command output or background status
         """
         # Prepare working directory
         work_dir = Path(cwd).resolve() if cwd else Path.cwd()
@@ -65,28 +65,14 @@ npx --action background json-server db.json"""
         # Build full command
         full_args = args.split() if args else []
         
-        if action == "background":
-            result = await self.execute_background(
-                package,
-                cwd=work_dir,
-                flags=flags,
-                args=full_args
-            )
-            return (
-                f"Started npx process in background\n"
-                f"Process ID: {result['process_id']}\n"
-                f"PID: {result['pid']}\n"
-                f"Log file: {result['log_file']}"
-            )
-        else:
-            # Default to sync execution
-            return await self.execute_sync(
-                package,
-                cwd=work_dir,
-                flags=flags,
-                args=full_args,
-                timeout=300  # 5 minute timeout for npx
-            )
+        # 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
+        )
 
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
@@ -97,7 +83,6 @@ npx --action background json-server db.json"""
             ctx: MCPContext,
             package: str,
             args: str = "",
-            action: str = "run",
             cwd: Optional[str] = None,
             yes: bool = True
         ) -> str:
@@ -105,7 +90,6 @@ npx --action background json-server db.json"""
                 ctx,
                 package=package,
                 args=args,
-                action=action,
                 cwd=cwd,
                 yes=yes
             )
@@ -116,7 +100,6 @@ npx --action background json-server db.json"""
             ctx,
             package=params["package"],
             args=params.get("args", ""),
-            action=params.get("action", "run"),
             cwd=params.get("cwd"),
             yes=params.get("yes", True)
         )