hanzo-mcp 0.9.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

hanzo_mcp/tools/mcp/mcp_add.py

@@ -8,6 +8,8 @@ from pathlib import Path
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
 
@@ -131,6 +133,9 @@ Use 'mcp_stats' to see all added servers and their status.
 """
 
     @override
+    @auto_timeout("mcp_add")
+
+
     async def call(
         self,
         ctx: MCPContext,
@@ -219,8 +224,8 @@ Use 'mcp_stats' to see all added servers and their status.
                     if not shutil.which("uvx"):
                         return "Error: uvx not found. Install uv first."
 
-                # TODO: Actually start and connect to the MCP server
-                # For now, we just store the configuration
+                # Server is validated and ready to be used
+                # The actual connection happens when tools are invoked
                 server_config["status"] = "ready"
 
             except Exception as e:

hanzo_mcp/tools/mcp/mcp_remove.py

@@ -5,6 +5,8 @@ from typing import Unpack, Annotated, TypedDict, final, override
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.mcp.mcp_add import McpAddTool
 from hanzo_mcp.tools.common.context import create_tool_context
@@ -64,6 +66,9 @@ Use 'mcp_stats' to see all servers before removing.
 """
 
     @override
+    @auto_timeout("mcp_remove")
+
+
     async def call(
         self,
         ctx: MCPContext,
@@ -103,8 +108,16 @@ Use 'mcp_stats' to see all servers before removing.
             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}'")
+                # Stop the server process if it's running
+                process_id = server.get("process_id")
+                if process_id:
+                    try:
+                        import signal
+                        import os
+                        os.kill(process_id, signal.SIGTERM)
+                        await tool_ctx.info(f"Stopped running server '{name}' (PID: {process_id})")
+                    except ProcessLookupError:
+                        await tool_ctx.info(f"Server '{name}' process not found (already stopped)")
 
         # Remove from registry
         del McpAddTool._mcp_servers[name]

hanzo_mcp/tools/mcp/mcp_stats.py

@@ -4,6 +4,8 @@ from typing import Unpack, TypedDict, final, override
 
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.mcp.mcp_add import McpAddTool
 from hanzo_mcp.tools.common.context import create_tool_context
@@ -47,6 +49,9 @@ Example:
 """
 
     @override
+    @auto_timeout("mcp_stats")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/mcp/mcp_tool.py

@@ -20,6 +20,8 @@ from pathlib import Path
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
 
@@ -270,6 +272,9 @@ mcp --action enable --name github
 Status: {enabled} enabled, {running} running"""
 
     @override
+    @auto_timeout("mcp")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/memory/knowledge_tools.py

@@ -7,6 +7,8 @@ supporting hierarchical organization (session, project, global).
 from typing import Any, Dict, List, Optional, final, override
 
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
@@ -69,6 +71,9 @@ recall_facts(queries=["company policies"], scope="global", limit=5)
 """
 
     @override
+    @auto_timeout("knowledge_tools")
+
+
     async def call(
         self,
         ctx: MCPContext,
@@ -190,6 +195,9 @@ store_facts(facts=["Company founded in 2020"], scope="global", kb_name="company_
 """
 
     @override
+    @auto_timeout("knowledge_tools")
+
+
     async def call(
         self,
         ctx: MCPContext,
@@ -286,6 +294,9 @@ summarize_to_memory(content="Company guidelines...", topic="Guidelines", scope="
 """
 
     @override
+    @auto_timeout("knowledge_tools")
+
+
     async def call(
         self,
         ctx: MCPContext,
@@ -390,6 +401,9 @@ manage_knowledge_bases(action="delete", kb_name="old_docs")
 """
 
     @override
+    @auto_timeout("knowledge_tools")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/memory/memory_tools.py

@@ -7,6 +7,8 @@ The hanzo-memory package provides embedded database and vector search capabiliti
 from typing import Dict, List, Optional, final, override
 
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
@@ -69,6 +71,9 @@ recall_memories(queries=["coding standards"], scope="global")
 """
 
     @override
+    @auto_timeout("memory_tools")
+
+
     async def call(
         self,
         ctx: MCPContext,
@@ -155,6 +160,9 @@ create_memories(statements=["User prefers dark mode", "User works in Python"])
 """
 
     @override
+    @auto_timeout("memory_tools")
+
+
     async def call(self, ctx: MCPContext, statements: List[str]) -> str:
         """Create new memories.
 
@@ -219,6 +227,9 @@ update_memories(updates=[
 """
 
     @override
+    @auto_timeout("memory_tools")
+
+
     async def call(self, ctx: MCPContext, updates: List[Dict[str, str]]) -> str:
         """Update memories.
 
@@ -283,6 +294,9 @@ delete_memories(ids=["mem_1", "mem_2"])
 """
 
     @override
+    @auto_timeout("memory_tools")
+
+
     async def call(self, ctx: MCPContext, ids: List[str]) -> str:
         """Delete memories.
 
@@ -345,6 +359,9 @@ manage_memories(
 """
 
     @override
+    @auto_timeout("memory_tools")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/search/find_tool.py

@@ -11,6 +11,7 @@ from dataclasses import dataclass
 
 from hanzo_mcp.types import MCPResourceDocument
 from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 
 # Check if ffind command is available
 try:
@@ -75,8 +76,8 @@ class FindTool(BaseTool):
     reading or searching within files.
     """
 
-    def __init__(self, permission_manager=None):
-        super().__init__(permission_manager=permission_manager)
+    def __init__(self):
+        super().__init__()
         self._cache = {}
         self._gitignore_cache = {}
 
@@ -375,7 +376,8 @@ class FindTool(BaseTool):
             }
         )
 
-    async def call(self, **kwargs) -> str:
+    @auto_timeout("find")
+    async def call(self, ctx=None, **kwargs) -> str:
         """Tool interface for MCP - converts result to JSON string."""
         result = await self.run(**kwargs)
         return result.to_json_string()

hanzo_mcp/tools/search/unified_search.py

@@ -14,6 +14,7 @@ from dataclasses import dataclass
 
 from hanzo_mcp.types import MCPResourceDocument
 from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 
 # Import memory tools if available
 try:
@@ -349,7 +350,8 @@ class UnifiedSearch(BaseTool):
 
         return MCPResourceDocument(data=response_data)
 
-    async def call(self, **kwargs) -> str:
+    @auto_timeout("search")
+    async def call(self, ctx=None, **kwargs) -> str:
         """Tool interface for MCP - converts result to JSON string."""
         result = await self.run(**kwargs)
         return result.to_json_string()

hanzo_mcp/tools/shell/__init__.py

@@ -13,7 +13,6 @@ from hanzo_mcp.tools.shell.zsh_tool import zsh_tool, shell_tool
 
 # Import tools
 from hanzo_mcp.tools.shell.bash_tool import bash_tool
-from hanzo_mcp.tools.shell.run_tool import run_tool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.shell.process_tool import process_tool
 
@@ -41,16 +40,14 @@ def get_shell_tools(
     bash_tool.permission_manager = permission_manager
     zsh_tool.permission_manager = permission_manager
     shell_tool.permission_manager = permission_manager
-    run_tool.permission_manager = permission_manager
     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 run_tool first (simplified command execution), then shell_tool (smart default), then specific shells
+    # Return shell_tool first (smart default), then specific shells
     return [
-        run_tool,    # Simplified run command with auto-backgrounding
         shell_tool,  # Smart shell (prefers zsh if available)
         zsh_tool,  # Explicit zsh
         bash_tool,  # Explicit bash
@@ -65,25 +62,16 @@ def get_shell_tools(
 def register_shell_tools(
     mcp_server: FastMCP,
     permission_manager: PermissionManager,
-    enabled_tools: dict[str, bool] | None = None,
 ) -> list[BaseTool]:
     """Register all shell tools with the MCP server.
 
     Args:
         mcp_server: The FastMCP server instance
         permission_manager: Permission manager for access control
-        enabled_tools: Optional dict of tool names to enable/disable
 
     Returns:
         List of registered tools
     """
-    all_tools = get_shell_tools(permission_manager)
-    
-    # Filter tools based on enabled_tools if provided
-    if enabled_tools is not None:
-        tools = [tool for tool in all_tools if enabled_tools.get(tool.name, True)]
-    else:
-        tools = all_tools
-    
+    tools = get_shell_tools(permission_manager)
     ToolRegistry.register_tools(mcp_server, tools)
     return tools

hanzo_mcp/tools/shell/base_process.py

@@ -183,11 +183,13 @@ class BaseProcessTool(BaseTool):
         else:
             if output.startswith("Command failed"):
                 raise RuntimeError(output)
+            # Get configurable max tokens from environment, default to 25000
+            max_tokens = int(os.environ.get("HANZO_MCP_MAX_RESPONSE_TOKENS", "25000"))
             # Truncate output to prevent token limit issues
             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.]",
+                max_tokens=max_tokens,
+                truncation_message=f"\n\n[Command output truncated due to {max_tokens} token limit. Output may be available in logs or files. Set HANZO_MCP_MAX_RESPONSE_TOKENS env var to adjust limit.]",
             )
 
     async def execute_background(

hanzo_mcp/tools/shell/bash_tool.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from hanzo_mcp.tools.shell.base_process import BaseScriptTool
 
 
@@ -30,6 +31,7 @@ class BashTool(BaseScriptTool):
         ) -> str:
             return await tool_self.run(ctx, command=command, cwd=cwd, env=env, timeout=timeout)
 
+    @auto_timeout("bash")
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(

hanzo_mcp/tools/shell/command_executor.py

@@ -109,13 +109,12 @@ class CommandExecutor:
         if shell_basename in ["wsl", "wsl.exe"]:
             # For WSL, handle commands with shell operators differently
             if any(char in command for char in ";&|<>(){}[]$\"'`"):
-                # For commands with special characters, use a more reliable approach
-                # with bash -c and double quotes around the entire command
-                escaped_command = command.replace('"', '\\"')
+                # Use shlex.quote for proper escaping to prevent command injection
+                escaped_command = shlex.quote(command)
                 if use_login_shell:
-                    formatted_command = f'{user_shell} bash -l -c "{escaped_command}"'
+                    formatted_command = f'{user_shell} bash -l -c {escaped_command}'
                 else:
-                    formatted_command = f'{user_shell} bash -c "{escaped_command}"'
+                    formatted_command = f'{user_shell} bash -c {escaped_command}'
             else:
                 # # For simple commands without special characters
                 # # Still respect login shell preference
@@ -125,8 +124,9 @@ class CommandExecutor:
                 formatted_command = f"{user_shell} {command}"
 
         elif shell_basename in ["powershell", "powershell.exe", "pwsh", "pwsh.exe"]:
-            # For PowerShell, escape double quotes with backslash most robust
-            escaped_command = command.replace('"', '\\"')
+            # Use proper escaping for PowerShell to prevent injection
+            # PowerShell requires different escaping than POSIX shells
+            escaped_command = command.replace('"', '`"').replace("'", "``'").replace('$', '`$')
             formatted_command = f'"{user_shell}" -Command "{escaped_command}"'
 
         else:

hanzo_mcp/tools/shell/logs.py

@@ -6,6 +6,8 @@ from pathlib import Path
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -105,6 +107,9 @@ Use run_command with 'tail -f' for continuous monitoring.
 """
 
     @override
+    @auto_timeout("logs")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/npx.py

@@ -7,6 +7,8 @@ from typing import Unpack, Optional, Annotated, TypedDict, final, override
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -103,6 +105,9 @@ For long-running servers, use npx_background instead.
 """
 
     @override
+    @auto_timeout("npx")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/npx_background.py

@@ -8,6 +8,8 @@ from typing import Unpack, Optional, Annotated, TypedDict, final, override
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -120,6 +122,9 @@ Use 'processes' to list running processes and 'pkill' to stop them.
 """
 
     @override
+    @auto_timeout("npx")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/npx_tool.py

@@ -4,6 +4,8 @@ from typing import Optional, override
 from pathlib import Path
 
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.shell.base_process import BaseBinaryTool
@@ -88,6 +90,9 @@ npx json-server db.json  # Auto-backgrounds if needed"""
         ) -> str:
             return await tool_self.run(ctx, package=package, args=args, cwd=cwd, yes=yes)
 
+    @auto_timeout("npx")
+
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(

hanzo_mcp/tools/shell/open.py

@@ -8,6 +8,8 @@ from pathlib import Path
 from urllib.parse import urlparse
 
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
@@ -26,6 +28,9 @@ class OpenTool(BaseTool):
         async def open(path: str, ctx: MCPContext) -> str:
             return await tool_self.run(ctx, path)
 
+    @auto_timeout("open")
+
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(ctx, params["path"])

hanzo_mcp/tools/shell/pkill.py

@@ -7,6 +7,8 @@ import psutil
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -106,6 +108,9 @@ Examples:
 """
 
     @override
+    @auto_timeout("pkill")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/process_tool.py

@@ -4,6 +4,8 @@ import signal
 from typing import Optional, override
 
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
@@ -132,6 +134,9 @@ process --action logs --id bash_ghi789 --lines 50"""
         ) -> str:
             return await tool_self.run(ctx, action=action, id=id, signal_type=signal_type, lines=lines)
 
+    @auto_timeout("process")
+
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(

hanzo_mcp/tools/shell/processes.py

@@ -7,6 +7,8 @@ import psutil
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -90,6 +92,9 @@ Examples:
 """
 
     @override
+    @auto_timeout("processes")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/run_background.py

@@ -10,6 +10,8 @@ from datetime import datetime
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -181,6 +183,9 @@ Examples:
 """
 
     @override
+    @auto_timeout("run")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/run_command.py

@@ -9,6 +9,7 @@ from pydantic import Field
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 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
@@ -269,6 +270,7 @@ Important:
         return tool_ctx
 
     @override
+    @auto_timeout("run_command")
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/run_command_windows.py

@@ -8,6 +8,8 @@ from typing import Any, Annotated, final, override
 
 from pydantic import Field
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.shell.base import ShellBaseTool
@@ -194,6 +196,9 @@ Important:
         return tool_ctx
 
     @override
+    @auto_timeout("run_command_windows")
+
+
     async def call(self, ctx: MCPContext, **params: Any) -> str:
         """Execute the tool with the given parameters.
 

hanzo_mcp/tools/shell/streaming_command.py

@@ -1,3 +1,5 @@
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 """Streaming command execution with disk-based logging and session management."""
 
 import os
@@ -173,6 +175,9 @@ class StreamingCommandTool(BaseProcessTool):
 
         return None
 
+    @auto_timeout("streaming_command")
+
+
     async def call(self, ctx: Any, **kwargs) -> Dict[str, Any]:
         """MCP tool entry point.
 

hanzo_mcp/tools/shell/uvx.py

@@ -7,6 +7,8 @@ from typing import Unpack, Optional, Annotated, TypedDict, final, override
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -100,6 +102,9 @@ For long-running servers, use uvx_background instead.
 """
 
     @override
+    @auto_timeout("uvx")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/uvx_background.py

@@ -8,6 +8,8 @@ from typing import Unpack, Optional, Annotated, TypedDict, final, override
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 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
@@ -119,6 +121,9 @@ Use 'processes' to list running processes and 'pkill' to stop them.
 """
 
     @override
+    @auto_timeout("uvx")
+
+
     async def call(
         self,
         ctx: MCPContext,

hanzo_mcp/tools/shell/uvx_tool.py

@@ -4,6 +4,8 @@ from typing import Optional, override
 from pathlib import Path
 
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.shell.base_process import BaseBinaryTool
@@ -88,6 +90,9 @@ uvx jupyter lab --port 8888  # Auto-backgrounds if needed"""
         ) -> str:
             return await tool_self.run(ctx, package=package, args=args, cwd=cwd, python=python)
 
+    @auto_timeout("uvx")
+
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(