hanzo-mcp 0.8.15__tar.gz → 0.9.1__tar.gz

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.8.15
+Version: 0.9.1
 Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/__init__.py

@@ -26,4 +26,4 @@ if os.environ.get("HANZO_MCP_TRANSPORT") == "stdio":
     except ImportError:
         pass
 
-__version__ = "0.8.13"
+__version__ = "0.8.16"

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/cli.py

@@ -15,6 +15,19 @@ import argparse
 from typing import Any, cast
 from pathlib import Path
 
+# Import timeout parser (deferred to avoid early imports)
+def _parse_timeout_arg(timeout_str: str) -> float:
+    """Parse timeout argument with human-readable format support."""
+    try:
+        from hanzo_mcp.tools.common.timeout_parser import parse_timeout
+        return parse_timeout(timeout_str)
+    except ImportError:
+        # Fallback if parser not available
+        try:
+            return float(timeout_str)
+        except ValueError:
+            raise ValueError(f"Invalid timeout format: '{timeout_str}'")
+
 
 def main() -> None:
     """Run the CLI for the Hanzo AI server."""
@@ -150,9 +163,37 @@ def main() -> None:
     _ = parser.add_argument(
         "--command-timeout",
         dest="command_timeout",
-        type=float,
-        default=120.0,
-        help="Default timeout for command execution in seconds (default: 120.0)",
+        type=str,
+        default="120s",
+        help="Default timeout for command execution (default: 120s). Supports: 2min, 5m, 120s, 30sec, 1.5h",
+    )
+
+    _ = parser.add_argument(
+        "--timeout", "-t",
+        dest="tool_timeout",
+        type=str,
+        help="Default timeout for MCP tool operations (default: 2min). Supports: 2min, 5m, 120s, 30sec, 1.5h",
+    )
+
+    _ = parser.add_argument(
+        "--search-timeout",
+        dest="search_timeout",
+        type=str,
+        help="Timeout specifically for search operations. Supports: 2min, 5m, 120s, 30sec, 1.5h",
+    )
+
+    _ = parser.add_argument(
+        "--find-timeout",
+        dest="find_timeout",
+        type=str,
+        help="Timeout specifically for find operations. Supports: 2min, 5m, 120s, 30sec, 1.5h",
+    )
+
+    _ = parser.add_argument(
+        "--ast-timeout",
+        dest="ast_timeout",
+        type=str,
+        help="Timeout specifically for AST operations. Supports: 2min, 5m, 120s, 30sec, 1.5h",
     )
 
     _ = parser.add_argument(
@@ -206,6 +247,27 @@ def main() -> None:
         help="Run in development mode with hot reload",
     )
 
+    _ = parser.add_argument(
+        "--daemon",
+        action="store_true",
+        help="Run as daemon process for multiple agent connections",
+    )
+
+    _ = parser.add_argument(
+        "--socket-path",
+        dest="socket_path",
+        default="/tmp/hanzo-mcp.sock",
+        help="Unix socket path for daemon mode (default: /tmp/hanzo-mcp.sock)",
+    )
+
+    _ = parser.add_argument(
+        "--max-connections",
+        dest="max_connections",
+        type=int,
+        default=100,
+        help="Maximum number of concurrent connections in daemon mode (default: 100)",
+    )
+
     _ = parser.add_argument(
         "--install",
         action="store_true",
@@ -222,10 +284,33 @@ def main() -> None:
             pass
         sys.stdout = original_stdout
 
+    # Parse timeout arguments with human-readable format support
+    command_timeout = _parse_timeout_arg(str(args.command_timeout))
+
+    # Set timeout environment variables from CLI args
+    if hasattr(args, 'tool_timeout') and args.tool_timeout:
+        tool_timeout = _parse_timeout_arg(args.tool_timeout)
+        os.environ["HANZO_MCP_TOOL_TIMEOUT"] = str(tool_timeout)
+
+    if hasattr(args, 'search_timeout') and args.search_timeout:
+        search_timeout = _parse_timeout_arg(args.search_timeout)
+        os.environ["HANZO_MCP_SEARCH_TIMEOUT"] = str(search_timeout)
+
+    if hasattr(args, 'find_timeout') and args.find_timeout:
+        find_timeout = _parse_timeout_arg(args.find_timeout)
+        os.environ["HANZO_MCP_FIND_TIMEOUT"] = str(find_timeout)
+
+    if hasattr(args, 'ast_timeout') and args.ast_timeout:
+        ast_timeout = _parse_timeout_arg(args.ast_timeout)
+        os.environ["HANZO_MCP_AST_TIMEOUT"] = str(ast_timeout)
+
     # Cast args attributes to appropriate types to avoid 'Any' warnings
     name: str = cast(str, args.name)
     install: bool = cast(bool, args.install)
     dev: bool = cast(bool, args.dev)
+    daemon: bool = cast(bool, args.daemon)
+    socket_path: str = cast(str, args.socket_path)
+    max_connections: int = cast(int, args.max_connections)
     transport: str = cast(str, args.transport)
     agent_model: str | None = cast(str | None, args.agent_model)
     agent_max_tokens: int | None = cast(int | None, args.agent_max_tokens)
@@ -234,7 +319,6 @@ def main() -> None:
     agent_max_iterations: int = cast(int, args.agent_max_iterations)
     agent_max_tool_uses: int = cast(int, args.agent_max_tool_uses)
     enable_agent_tool: bool = cast(bool, args.enable_agent_tool)
-    command_timeout: float = cast(float, args.command_timeout)
     disable_write_tools: bool = cast(bool, args.disable_write_tools)
     disable_search_tools: bool = cast(bool, args.disable_search_tools)
     host: str = cast(str, args.host)
@@ -285,6 +369,26 @@ def main() -> None:
     if not allowed_paths:
         allowed_paths = [os.path.expanduser("~")]
 
+    # Set daemon mode environment variables
+    if daemon:
+        os.environ["HANZO_MCP_DAEMON"] = "true"
+        os.environ["HANZO_MCP_SOCKET_PATH"] = socket_path
+        os.environ["HANZO_MCP_MAX_CONNECTIONS"] = str(max_connections)
+
+        if transport != "stdio":
+            logger.info(f"Starting Hanzo MCP daemon on {socket_path}")
+            logger.info(f"Max connections: {max_connections}")
+
+        # Ensure only one daemon runs per socket
+        try:
+            import fcntl
+            lock_file = f"{socket_path}.lock"
+            with open(lock_file, 'w') as f:
+                fcntl.flock(f.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except (ImportError, IOError):
+            # Fallback for systems without fcntl or if lock fails
+            pass
+
     # Run in dev mode if requested
     if dev:
         from hanzo_mcp.dev_server import DevServer

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/__init__.py

@@ -6,6 +6,8 @@ enabling concurrent execution of multiple operations and specialized processing.
 
 from mcp.server import FastMCP
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 
 # Import unified CLI tools (single source of truth)
@@ -78,6 +80,9 @@ def register_agent_tools(
         def __init__(self, agent_tool: AgentTool):
             self._agent = agent_tool
 
+        @auto_timeout("__init__")
+
+
         async def call(self, ctx, **params):  # type: ignore[override]
             # Default to 5 agents unless explicitly provided
             params = dict(params)

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/agent.py

@@ -30,6 +30,8 @@ from pydantic import Field
 from openai.types.chat import ChatCompletionMessageParam
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 from hanzo_mcp.tools.jupyter import get_read_only_jupyter_tools
 from hanzo_mcp.tools.filesystem import get_read_only_filesystem_tools
 from hanzo_mcp.tools.common.base import BaseTool
@@ -212,6 +214,9 @@ Modes:
 - rpc: Long-running agent for multiple calls (A2A support)"""
 
     @override
+    @auto_timeout("agent")
+
+
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/agent_tool.py

@@ -20,6 +20,8 @@ from typing import (
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 # Import hanzo-agents SDK
 try:
     from hanzo_agents import (
@@ -338,6 +340,7 @@ Usage notes:
         self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
     @override
+    @auto_timeout("agent")
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/agent_tool_v1_deprecated.py

@@ -19,6 +19,8 @@ with warnings.catch_warnings():
     import litellm
 from pydantic import Field
 from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 from openai.types.chat import ChatCompletionToolParam, ChatCompletionMessageParam
 from mcp.server.fastmcp import Context as MCPContext
 
@@ -177,6 +179,9 @@ Usage notes:
         self.review_protocol = ReviewProtocol()
 
     @override
+    @auto_timeout("agent_tool_v1_deprecated")
+
+
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/clarification_tool.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, override
 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.common.base import BaseTool
 
 
@@ -42,6 +43,7 @@ request_clarification(
     options=["github.com/luxfi/node/common", "github.com/project/common"]
 )"""
 
+    @auto_timeout("clarification")
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/claude_desktop_auth.py

@@ -1,3 +1,5 @@
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 """Claude Desktop authentication management.
 
 This module provides tools to automate Claude Desktop login/logout,
@@ -448,6 +450,9 @@ claude_auth ensure_agent swarm_agent_1"""
         """Initialize the auth tool."""
         self.auth = ClaudeDesktopAuth()
 
+    @auto_timeout("claude_desktop_auth")
+
+
     async def call(self, ctx, action: str = "status", **kwargs) -> str:
         """Execute auth action."""
         tool_ctx = create_tool_context(ctx)

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/cli_agent_base.py

@@ -13,6 +13,8 @@ from typing import List, Optional
 
 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
@@ -166,6 +168,9 @@ class CLIAgentBase(BaseTool):
             await tool_ctx.error(f"{self.provider_name} error: {str(e)}")
             return f"Error: {str(e)}"
 
+    @auto_timeout("cli_agent_base")
+
+
     async def call(self, ctx: MCPContext, prompts: str, **kwargs) -> str:
         """Execute the CLI agent.
 

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/cli_tools.py

@@ -13,6 +13,8 @@ from pathlib import Path
 
 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
 
 from hanzo_mcp.tools.common.base import BaseTool
@@ -186,6 +188,9 @@ class ClaudeCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute Claude CLI for AI assistance using Anthropic's models"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt: str = params.get("prompt", "")
         model: Optional[str] = params.get("model") or self.default_model
@@ -236,6 +241,9 @@ class CodexCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute OpenAI Codex/GPT-4 CLI for code generation and AI assistance"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt: str = params.get("prompt", "")
         model: Optional[str] = params.get("model") or self.default_model
@@ -274,6 +282,9 @@ class GeminiCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute Google Gemini CLI for multimodal AI assistance"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt: str = params.get("prompt", "")
         model: Optional[str] = params.get("model") or self.default_model
@@ -312,6 +323,9 @@ class GrokCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute xAI Grok CLI for real-time AI assistance"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt: str = params.get("prompt", "")
         model: Optional[str] = params.get("model") or self.default_model
@@ -350,6 +364,9 @@ class OpenHandsCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute OpenHands (OpenDevin) for autonomous coding assistance"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt = params.get("prompt", "")
         model = params.get("model") or self.default_model
@@ -400,6 +417,9 @@ class HanzoDevCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute Hanzo Dev for AI-powered code editing and development"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt = params.get("prompt", "")
         model = params.get("model") or self.default_model
@@ -438,6 +458,9 @@ class ClineCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute Cline for autonomous coding with Claude"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt = params.get("prompt", "")
         working_dir: str = params.get("working_dir") or os.getcwd()
@@ -473,6 +496,9 @@ class AiderCLITool(BaseCLITool):
     def description(self) -> str:
         return "Execute Aider for AI pair programming"
 
+    @auto_timeout("cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         prompt = params.get("prompt", "")
         model = params.get("model") or self.default_model

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/code_auth_tool.py

@@ -6,6 +6,8 @@ This tool manages API keys and accounts for Claude Code and other AI coding tool
 from typing import Unpack, Optional, TypedDict, 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
@@ -67,6 +69,9 @@ Providers: claude, openai, azure, deepseek, google, groq"""
         self.auth_manager = CodeAuthManager()
 
     @override
+    @auto_timeout("code_auth")
+
+
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/critic_tool.py

@@ -6,6 +6,7 @@ from typing import List, Optional, override
 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.common.base import BaseTool
 
 
@@ -57,6 +58,7 @@ critic(
     specific_concerns="Are the imports in the correct format and location?"
 )"""
 
+    @auto_timeout("critic")
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/iching_tool.py

@@ -5,6 +5,8 @@ from enum import Enum
 from typing import List, 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
@@ -599,6 +601,9 @@ Use this when you need:
         super().__init__()
         self.oracle = IChing()
 
+    @auto_timeout("iching")
+
+
     async def call(self, ctx: MCPContext, challenge: str) -> str:
         """Cast I Ching and provide guidance."""
         # Cast hexagram

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/network_tool.py

@@ -18,6 +18,8 @@ from typing import (
 
 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.common.base import BaseTool
@@ -104,6 +106,9 @@ class NetworkTool(BaseTool):
         return self._cluster
 
     @override
+    @auto_timeout("network")
+
+
     async def call(self, ctx: MCPContext, **params: Unpack[NetworkToolParams]) -> str:
         """Execute a task on the agent network.
 

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/review_tool.py

@@ -6,6 +6,7 @@ from typing import List, Optional, override
 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.common.base import BaseTool
 
 
@@ -57,6 +58,7 @@ review(
     context="This will be used to automatically fix missing imports in Go files"
 )"""
 
+    @auto_timeout("review")
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/swarm_alias.py

@@ -1,3 +1,5 @@
+
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 """Swarm tool as an alias to Network tool for backward compatibility.
 
 This module makes swarm an alias to the network tool, as network is the
@@ -63,6 +65,9 @@ For new code, prefer using 'network' directly."""
         # Just pass through to NetworkTool
         super().__init__(permission_manager=permission_manager, default_mode=default_mode, **kwargs)
 
+    @auto_timeout("swarm_alias")
+
+
     async def call(self, **kwargs) -> str:
         """Execute swarm via network tool.
 

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/swarm_tool.py

@@ -19,6 +19,8 @@ from typing import (
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
+
 # Import hanzo-agents SDK with fallback
 try:
     from hanzo_agents import (
@@ -508,6 +510,7 @@ Models can be specified as:
         self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
     @override
+    @auto_timeout("swarm")
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/swarm_tool_v1_deprecated.py

@@ -18,6 +18,8 @@ from typing import (
 )
 
 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
@@ -203,6 +205,9 @@ Models can be specified as:
         self.agent_max_tool_uses = agent_max_tool_uses
 
     @override
+    @auto_timeout("swarm_tool_v1_deprecated")
+
+
     async def call(
         self,
         ctx: MCPContext,

{hanzo_mcp-0.8.15 → hanzo_mcp-0.9.1}/hanzo_mcp/tools/agent/unified_cli_tools.py

@@ -11,6 +11,8 @@ from typing import Any, Dict, List, Optional
 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
 
 from ..common.base import BaseTool
@@ -142,6 +144,9 @@ class UnifiedCLITool(BaseTool, CLIAgent):
         command.append(prompt)
         return command
 
+    @auto_timeout("unified_cli_tools")
+
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         """Execute the CLI tool via MCP interface.