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

hanzo_mcp/__init__.py

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

hanzo_mcp/analytics/posthog_analytics.py

@@ -16,6 +16,7 @@ import traceback
 from typing import Any, Dict, TypeVar, Callable, Optional
 from datetime import datetime
 from dataclasses import dataclass
+from importlib.metadata import version, PackageNotFoundError
 
 # Try to import PostHog, but make it optional
 try:
@@ -98,7 +99,7 @@ class Analytics:
                 "timestamp": datetime.utcnow().isoformat(),
                 "platform": platform.system(),
                 "python_version": platform.python_version(),
-                "mcp_version": "0.6.13",  # TODO: Get from package
+                "mcp_version": self._get_package_version(),
                 **(properties or {}),
             }
 
@@ -179,6 +180,18 @@ class Analytics:
             except Exception:
                 pass
 
+    def _get_package_version(self) -> str:
+        """Get the current package version."""
+        try:
+            return version('hanzo-mcp')
+        except PackageNotFoundError:
+            # Fallback to hardcoded version if package not installed
+            try:
+                from hanzo_mcp import __version__
+                return __version__
+            except ImportError:
+                return "0.8.14"
+
     def shutdown(self) -> None:
         """Shutdown analytics client."""
         if self.is_enabled():

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/server.py

@@ -3,6 +3,7 @@
 import os
 import atexit
 import signal
+import secrets
 import logging
 import warnings
 import threading
@@ -53,6 +54,7 @@ class HanzoMCPServer:
         port: int = 8888,
         enabled_tools: dict[str, bool] | None = None,
         disabled_tools: list[str] | None = None,
+        auth_token: str | None = None,
     ):
         """Initialize the Hanzo AI server.
 
@@ -80,6 +82,15 @@ class HanzoMCPServer:
         # Use enhanced server for automatic context normalization
         self.mcp = mcp_instance if mcp_instance is not None else EnhancedFastMCP(name)
 
+        # Initialize authentication token
+        self.auth_token = auth_token or os.environ.get('HANZO_MCP_TOKEN')
+        if not self.auth_token:
+            # Generate a secure random token if none provided
+            self.auth_token = secrets.token_urlsafe(32)
+            logger = logging.getLogger(__name__)
+            logger.warning(f"No auth token provided. Generated token: {self.auth_token}")
+            logger.warning("Set HANZO_MCP_TOKEN environment variable for persistent auth")
+
         # Initialize permissions and command executor
         self.permission_manager = PermissionManager()
 

hanzo_mcp/tools/__init__.py

@@ -226,22 +226,9 @@ def register_all_tools(
         for tool in jupyter_tools:
             all_tools[tool.name] = tool
 
-    # Register shell tools with individual configuration
-    shell_enabled = {
-        "run": is_tool_enabled("run", True),
-        "shell": is_tool_enabled("shell", True),
-        "bash": is_tool_enabled("bash", True),
-        "zsh": is_tool_enabled("zsh", True),
-        "npx": is_tool_enabled("npx", True),
-        "uvx": is_tool_enabled("uvx", True),
-        "process": is_tool_enabled("process", True),
-        "open": is_tool_enabled("open", True),
-        # Legacy name support
-        "run_command": is_tool_enabled("run_command", True),
-    }
-    
-    if any(shell_enabled.values()):
-        shell_tools = register_shell_tools(mcp_server, permission_manager, enabled_tools=shell_enabled)
+    # Register shell tools if enabled
+    if is_tool_enabled("run_command", True):
+        shell_tools = register_shell_tools(mcp_server, permission_manager)
         for tool in shell_tools:
             all_tools[tool.name] = tool
 

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/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/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 (
@@ -103,23 +105,6 @@ from hanzo_mcp.tools.agent.clarification_protocol import (
 
 
 class AgentToolParams(TypedDict, total=False):
-
-    def __init__(self, *args, mode: str = "single", **kwargs):
-        """Initialize agent tool with mode support.
-        
-        Modes:
-        - single: Single agent execution (default)
-        - network: Network of agents (formerly swarm)
-        - dispatch: Dispatch to best agent (legacy compatibility)
-        """
-        super().__init__(*args, **kwargs)
-        self.mode = mode
-        
-        # Handle legacy names
-        if self.name == "dispatch_agent":
-            self.mode = "dispatch"
-        elif self.name in ["network", "swarm"]:
-            self.mode = "network"
     """Parameters for the AgentTool."""
 
     prompts: str | list[str]
@@ -355,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,