hanzo-mcp 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

hanzo_mcp/cli.py

@@ -1,4 +1,10 @@
-"""Command-line interface for the Hanzo AI server."""
+"""Command-line interface for the Hanzo AI server.
+
+This module intentionally defers heavy imports (like the server and its
+dependencies) until after we determine the transport and configure logging.
+This prevents any stdout/stderr noise from imports that would corrupt the
+MCP stdio transport used by Claude Desktop and other MCP clients.
+"""
 
 import os
 import sys
@@ -9,52 +15,62 @@ import argparse
 from typing import Any, cast
 from pathlib import Path
 
-from hanzo_mcp.server import HanzoMCPServer
-
 
 def main() -> None:
     """Run the CLI for the Hanzo AI server."""
-
-    # Pre-parse arguments to check transport type early
-    import sys
-
+    # Pre-parse arguments to check transport type early, BEFORE importing server
     early_parser = argparse.ArgumentParser(add_help=False)
     early_parser.add_argument("--transport", choices=["stdio", "sse"], default="stdio")
     early_args, _ = early_parser.parse_known_args()
 
     # Configure logging VERY early based on transport
+    suppress_stdout = False
+    original_stdout = sys.stdout
     if early_args.transport == "stdio":
-        # Set environment variable for server to detect stdio mode
-        import os
-
+        # Set environment variable for server to detect stdio mode as early as possible
         os.environ["HANZO_MCP_TRANSPORT"] = "stdio"
+        # Aggressively quiet common dependency loggers/warnings in stdio mode
+        os.environ.setdefault("PYTHONWARNINGS", "ignore")
+        os.environ.setdefault("LITELLM_LOG", "ERROR")
+        os.environ.setdefault("LITELLM_LOGGING_LEVEL", "ERROR")
+        os.environ.setdefault("FASTMCP_LOG_LEVEL", "ERROR")
 
-        # For stdio transport, disable ALL logging immediately
-        from fastmcp.utilities.logging import configure_logging
+        # Suppress FastMCP logging (if available) and all standard logging
+        try:
+            from fastmcp.utilities.logging import configure_logging  # type: ignore
 
-        # Set to ERROR to suppress INFO/WARNING messages from FastMCP
-        configure_logging(level="ERROR")
+            configure_logging(level="ERROR")
+        except Exception:
+            pass
 
-        # Also configure standard logging to ERROR level
         logging.basicConfig(
             level=logging.ERROR,  # Only show errors
             handlers=[],  # No handlers for stdio to prevent protocol corruption
         )
 
         # Redirect stderr to devnull for stdio transport to prevent any output
-        import sys
-
         sys.stderr = open(os.devnull, "w")
 
-    from hanzo_mcp import __version__
+        # Suppress stdout during potentially noisy imports unless user requested help/version
+        if not any(flag in sys.argv for flag in ("--version", "-h", "--help")):
+            sys.stdout = open(os.devnull, "w")
+            suppress_stdout = True
+
+    # Import the server only AFTER transport/logging have been configured to avoid import-time noise
+    from hanzo_mcp.server import HanzoMCPServer
+
+    # Avoid importing hanzo_mcp package just to get version (it can have side-effects).
+    try:
+        from importlib.metadata import version as _pkg_version  # py3.8+
+        _version = _pkg_version("hanzo-mcp")
+    except Exception:
+        _version = "unknown"
 
     parser = argparse.ArgumentParser(
         description="MCP server implementing Hanzo AI capabilities"
     )
 
-    parser.add_argument(
-        "--version", action="version", version=f"hanzo-mcp {__version__}"
-    )
+    parser.add_argument("--version", action="version", version=f"hanzo-mcp {_version}")
 
     _ = parser.add_argument(
         "--transport",
@@ -199,6 +215,14 @@ def main() -> None:
 
     args = parser.parse_args()
 
+    # Restore stdout after parsing, before any explicit output or server start
+    if suppress_stdout:
+        try:
+            sys.stdout.close()  # Close devnull handle
+        except Exception:
+            pass
+        sys.stdout = original_stdout
+
     # Cast args attributes to appropriate types to avoid 'Any' warnings
     name: str = cast(str, args.name)
     install: bool = cast(bool, args.install)

hanzo_mcp/compute_nodes.py

@@ -8,33 +8,39 @@ from typing import Any, Dict, List
 
 class ComputeNodeDetector:
     """Detect available compute nodes (GPUs, WebGPU, CPUs) for distributed work."""
-    
+
     @staticmethod
     def detect_local_gpus() -> List[Dict[str, Any]]:
         """Detect local GPU devices."""
         gpus = []
-        
+
         # Try NVIDIA GPUs
         try:
             result = subprocess.run(
-                ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
+                [
+                    "nvidia-smi",
+                    "--query-gpu=name,memory.total",
+                    "--format=csv,noheader",
+                ],
                 capture_output=True,
                 text=True,
-                timeout=2
+                timeout=2,
             )
             if result.returncode == 0:
-                for line in result.stdout.strip().split('\n'):
+                for line in result.stdout.strip().split("\n"):
                     if line:
-                        name, memory = line.split(', ')
-                        gpus.append({
-                            "type": "cuda",
-                            "name": name,
-                            "memory": memory,
-                            "id": f"cuda:{len(gpus)}"
-                        })
+                        name, memory = line.split(", ")
+                        gpus.append(
+                            {
+                                "type": "cuda",
+                                "name": name,
+                                "memory": memory,
+                                "id": f"cuda:{len(gpus)}",
+                            }
+                        )
         except (FileNotFoundError, subprocess.TimeoutExpired):
             pass
-        
+
         # Try Metal GPUs (macOS)
         if platform.system() == "Darwin":
             try:
@@ -43,96 +49,103 @@ class ComputeNodeDetector:
                     ["system_profiler", "SPDisplaysDataType"],
                     capture_output=True,
                     text=True,
-                    timeout=2
+                    timeout=2,
                 )
                 if result.returncode == 0 and "Metal" in result.stdout:
                     # Parse GPU info from system_profiler
-                    lines = result.stdout.split('\n')
+                    lines = result.stdout.split("\n")
                     for i, line in enumerate(lines):
-                        if 'Chipset Model:' in line:
-                            gpu_name = line.split(':')[1].strip()
-                            gpus.append({
-                                "type": "metal",
-                                "name": gpu_name,
-                                "memory": "Shared",
-                                "id": f"metal:{len(gpus)}"
-                            })
+                        if "Chipset Model:" in line:
+                            gpu_name = line.split(":")[1].strip()
+                            gpus.append(
+                                {
+                                    "type": "metal",
+                                    "name": gpu_name,
+                                    "memory": "Shared",
+                                    "id": f"metal:{len(gpus)}",
+                                }
+                            )
             except (FileNotFoundError, subprocess.TimeoutExpired):
                 pass
-        
+
         return gpus
-    
+
     @staticmethod
     def detect_webgpu_nodes() -> List[Dict[str, Any]]:
         """Detect connected WebGPU nodes (from browsers)."""
         webgpu_nodes = []
-        
+
         # Check for WebGPU connections (would need actual WebSocket/server to track)
         # For now, check if a WebGPU server is running
         webgpu_port = os.environ.get("HANZO_WEBGPU_PORT", "8765")
         try:
             import socket
+
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            result = sock.connect_ex(('localhost', int(webgpu_port)))
+            result = sock.connect_ex(("localhost", int(webgpu_port)))
             sock.close()
             if result == 0:
-                webgpu_nodes.append({
-                    "type": "webgpu",
-                    "name": "Chrome WebGPU",
-                    "memory": "Browser",
-                    "id": "webgpu:0"
-                })
+                webgpu_nodes.append(
+                    {
+                        "type": "webgpu",
+                        "name": "Chrome WebGPU",
+                        "memory": "Browser",
+                        "id": "webgpu:0",
+                    }
+                )
         except Exception:
             pass
-        
+
         return webgpu_nodes
-    
+
     @staticmethod
     def detect_cpu_nodes() -> List[Dict[str, Any]]:
         """Detect CPU compute nodes."""
         import multiprocessing
-        
-        return [{
-            "type": "cpu",
-            "name": f"{platform.processor() or 'CPU'}",
-            "cores": multiprocessing.cpu_count(),
-            "id": "cpu:0"
-        }]
-    
+
+        return [
+            {
+                "type": "cpu",
+                "name": f"{platform.processor() or 'CPU'}",
+                "cores": multiprocessing.cpu_count(),
+                "id": "cpu:0",
+            }
+        ]
+
     @classmethod
     def get_all_nodes(cls) -> List[Dict[str, Any]]:
         """Get all available compute nodes."""
         nodes = []
-        
+
         # Detect GPUs
         gpus = cls.detect_local_gpus()
         nodes.extend(gpus)
-        
+
         # Detect WebGPU connections
         webgpu = cls.detect_webgpu_nodes()
         nodes.extend(webgpu)
-        
+
         # If no GPUs/WebGPU, add CPU as compute node
         if not nodes:
             nodes.extend(cls.detect_cpu_nodes())
-        
+
         return nodes
-    
+
     @classmethod
     def get_node_count(cls) -> int:
         """Get total number of available compute nodes."""
         return len(cls.get_all_nodes())
-    
+
     @classmethod
     def get_node_summary(cls) -> str:
         """Get a summary string of available nodes."""
         nodes = cls.get_all_nodes()
         if not nodes:
             return "No compute nodes available"
-        
+
         count = len(nodes)
         node_word = "node" if count == 1 else "nodes"
-        
+
         # Group by type
         types = {}
         for node in nodes:
@@ -140,7 +153,7 @@ class ComputeNodeDetector:
             if node_type not in types:
                 types[node_type] = 0
             types[node_type] += 1
-        
+
         # Build summary
         parts = []
         for node_type, type_count in types.items():
@@ -152,7 +165,7 @@ class ComputeNodeDetector:
                 parts.append(f"{type_count} WebGPU")
             elif node_type == "cpu":
                 parts.append(f"{type_count} CPU")
-        
+
         type_str = ", ".join(parts)
         return f"{count} {node_word} available ({type_str})"
 
@@ -161,7 +174,7 @@ def print_node_status():
     """Print current node status."""
     detector = ComputeNodeDetector()
     nodes = detector.get_all_nodes()
-    
+
     print(f"\n🖥️  Compute Nodes: {len(nodes)}")
     for node in nodes:
         if node["type"] in ["cuda", "metal"]:
@@ -176,4 +189,4 @@ def print_node_status():
 if __name__ == "__main__":
     # Test the detector
     print_node_status()
-    print(ComputeNodeDetector.get_node_summary())
+    print(ComputeNodeDetector.get_node_summary())

hanzo_mcp/config/settings.py

@@ -514,6 +514,17 @@ def _merge_config(
 
     merged = deep_merge(base_dict, config_dict)
 
+    # Backwards/forwards compatibility: support a structured "tools" section
+    # where each tool can define { enabled: bool, ...options } and map it to
+    # the existing enabled_tools/disabled_tools layout.
+    tools_cfg = merged.get("tools", {})
+    if isinstance(tools_cfg, dict):
+        enabled_tools = dict(merged.get("enabled_tools", {}))
+        for tool_name, tool_data in tools_cfg.items():
+            if isinstance(tool_data, dict) and "enabled" in tool_data:
+                enabled_tools[tool_name] = bool(tool_data.get("enabled"))
+        merged["enabled_tools"] = enabled_tools
+
     # Reconstruct the settings object
     mcp_servers = {}
     for name, server_data in merged.get("mcp_servers", {}).items():