claude-mpm 4.0.17__py3-none-any.whl → 4.0.19__py3-none-any.whl

claude_mpm/services/mcp_gateway/tools/health_check_tool.py

@@ -0,0 +1,453 @@
+"""
+Health Check Tool for MCP Gateway
+=================================
+
+Provides comprehensive health checking and diagnostic capabilities for the
+MCP Gateway and claude-mpm system.
+
+WHY: A dedicated health check tool provides centralized diagnostics for
+troubleshooting and system monitoring, essential for maintaining a reliable
+MCP gateway service.
+
+DESIGN DECISIONS:
+- Comprehensive system checks (gateway, tools, configuration)
+- Structured output for easy parsing
+- Non-blocking checks with timeouts
+- Detailed error reporting for troubleshooting
+"""
+
+import asyncio
+import os
+import platform
+import psutil
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from claude_mpm.config.paths import paths
+from claude_mpm.core.logger import get_logger
+from claude_mpm.services.mcp_gateway.core.interfaces import (
+    MCPToolDefinition,
+    MCPToolInvocation,
+    MCPToolResult,
+)
+from claude_mpm.services.mcp_gateway.tools.base_adapter import BaseToolAdapter
+
+
+class HealthCheckTool(BaseToolAdapter):
+    """
+    Comprehensive health check tool for MCP Gateway diagnostics.
+    
+    Provides system health, gateway status, tool availability, and
+    configuration validation checks.
+    """
+    
+    def __init__(self):
+        """Initialize the health check tool."""
+        definition = MCPToolDefinition(
+            name="health_check",
+            description="Comprehensive health check and diagnostics for MCP Gateway and claude-mpm system",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "check_type": {
+                        "type": "string",
+                        "enum": ["all", "system", "gateway", "tools", "config"],
+                        "description": "Type of health check to perform",
+                        "default": "all",
+                    },
+                    "detailed": {
+                        "type": "boolean",
+                        "description": "Include detailed diagnostic information",
+                        "default": False,
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Timeout for checks in seconds",
+                        "default": 30,
+                        "minimum": 5,
+                        "maximum": 120,
+                    },
+                },
+                "required": [],
+            },
+        )
+        super().__init__(definition)
+        self.logger = get_logger("HealthCheckTool")
+    
+    async def invoke(self, invocation: MCPToolInvocation) -> MCPToolResult:
+        """
+        Perform health checks based on the requested type.
+        
+        Args:
+            invocation: Tool invocation request
+            
+        Returns:
+            Tool execution result with health check results
+        """
+        start_time = datetime.now()
+        
+        try:
+            # Get parameters
+            check_type = invocation.parameters.get("check_type", "all")
+            detailed = invocation.parameters.get("detailed", False)
+            timeout = invocation.parameters.get("timeout", 30)
+            
+            # Perform health checks
+            results = await self._perform_health_checks(check_type, detailed, timeout)
+            
+            # Calculate execution time
+            execution_time = (datetime.now() - start_time).total_seconds()
+            
+            # Update metrics
+            self._update_metrics(True, execution_time)
+            
+            return MCPToolResult(
+                success=True,
+                data=results,
+                execution_time=execution_time,
+                metadata={
+                    "tool": "health_check",
+                    "check_type": check_type,
+                    "detailed": detailed,
+                },
+            )
+            
+        except Exception as e:
+            execution_time = (datetime.now() - start_time).total_seconds()
+            self._update_metrics(False, execution_time)
+            
+            return MCPToolResult(
+                success=False,
+                error=f"Health check failed: {str(e)}",
+                execution_time=execution_time,
+                metadata={"tool": "health_check", "error": str(e)},
+            )
+    
+    async def _perform_health_checks(
+        self, check_type: str, detailed: bool, timeout: int
+    ) -> Dict[str, Any]:
+        """Perform the requested health checks."""
+        results = {
+            "timestamp": datetime.now().isoformat(),
+            "check_type": check_type,
+            "detailed": detailed,
+            "overall_status": "unknown",
+            "checks": {},
+            "summary": {},
+        }
+        
+        # Determine which checks to run
+        checks_to_run = []
+        if check_type == "all":
+            checks_to_run = ["system", "gateway", "tools", "config"]
+        else:
+            checks_to_run = [check_type]
+        
+        # Run checks with timeout
+        try:
+            check_tasks = []
+            for check in checks_to_run:
+                if check == "system":
+                    check_tasks.append(self._check_system_health(detailed))
+                elif check == "gateway":
+                    check_tasks.append(self._check_gateway_health(detailed))
+                elif check == "tools":
+                    check_tasks.append(self._check_tools_health(detailed))
+                elif check == "config":
+                    check_tasks.append(self._check_config_health(detailed))
+            
+            # Run all checks concurrently with timeout
+            check_results = await asyncio.wait_for(
+                asyncio.gather(*check_tasks, return_exceptions=True),
+                timeout=timeout
+            )
+            
+            # Process results
+            for i, check_name in enumerate(checks_to_run):
+                if i < len(check_results):
+                    if isinstance(check_results[i], Exception):
+                        results["checks"][check_name] = {
+                            "status": "error",
+                            "error": str(check_results[i]),
+                        }
+                    else:
+                        results["checks"][check_name] = check_results[i]
+                else:
+                    results["checks"][check_name] = {
+                        "status": "timeout",
+                        "error": "Check timed out",
+                    }
+            
+        except asyncio.TimeoutError:
+            results["checks"]["timeout"] = {
+                "status": "error",
+                "error": f"Health checks timed out after {timeout} seconds",
+            }
+        
+        # Calculate overall status and summary
+        results["overall_status"] = self._calculate_overall_status(results["checks"])
+        results["summary"] = self._generate_summary(results["checks"])
+        
+        return results
+    
+    async def _check_system_health(self, detailed: bool) -> Dict[str, Any]:
+        """Check system health (CPU, memory, disk, etc.)."""
+        check_result = {
+            "status": "healthy",
+            "checks": {},
+            "warnings": [],
+            "errors": [],
+        }
+        
+        try:
+            # Basic system info
+            check_result["checks"]["platform"] = {
+                "system": platform.system(),
+                "release": platform.release(),
+                "python_version": sys.version,
+            }
+            
+            # Memory check
+            memory = psutil.virtual_memory()
+            memory_usage = memory.percent
+            check_result["checks"]["memory"] = {
+                "usage_percent": memory_usage,
+                "available_gb": round(memory.available / (1024**3), 2),
+                "total_gb": round(memory.total / (1024**3), 2),
+            }
+            
+            if memory_usage > 90:
+                check_result["errors"].append("High memory usage detected")
+                check_result["status"] = "unhealthy"
+            elif memory_usage > 80:
+                check_result["warnings"].append("Elevated memory usage")
+            
+            # CPU check
+            cpu_usage = psutil.cpu_percent(interval=1)
+            check_result["checks"]["cpu"] = {
+                "usage_percent": cpu_usage,
+                "count": psutil.cpu_count(),
+            }
+            
+            if cpu_usage > 95:
+                check_result["errors"].append("High CPU usage detected")
+                check_result["status"] = "unhealthy"
+            elif cpu_usage > 80:
+                check_result["warnings"].append("Elevated CPU usage")
+            
+            # Disk check for claude-mpm data directory
+            if paths.data_dir.exists():
+                disk_usage = psutil.disk_usage(str(paths.data_dir))
+                disk_usage_percent = (disk_usage.used / disk_usage.total) * 100
+                check_result["checks"]["disk"] = {
+                    "usage_percent": round(disk_usage_percent, 2),
+                    "free_gb": round(disk_usage.free / (1024**3), 2),
+                    "total_gb": round(disk_usage.total / (1024**3), 2),
+                }
+                
+                if disk_usage_percent > 95:
+                    check_result["errors"].append("Disk space critically low")
+                    check_result["status"] = "unhealthy"
+                elif disk_usage_percent > 85:
+                    check_result["warnings"].append("Disk space running low")
+            
+            # Process check
+            current_process = psutil.Process()
+            check_result["checks"]["process"] = {
+                "pid": current_process.pid,
+                "memory_mb": round(current_process.memory_info().rss / (1024**2), 2),
+                "cpu_percent": current_process.cpu_percent(),
+                "threads": current_process.num_threads(),
+            }
+            
+        except Exception as e:
+            check_result["status"] = "error"
+            check_result["errors"].append(f"System health check failed: {e}")
+        
+        return check_result
+    
+    async def _check_gateway_health(self, detailed: bool) -> Dict[str, Any]:
+        """Check MCP Gateway health."""
+        check_result = {
+            "status": "healthy",
+            "checks": {},
+            "warnings": [],
+            "errors": [],
+        }
+        
+        try:
+            # Check singleton manager
+            from ..core.singleton_manager import get_gateway_manager, is_gateway_running
+            
+            manager = get_gateway_manager()
+            check_result["checks"]["singleton_manager"] = {
+                "available": True,
+                "gateway_running": is_gateway_running(),
+            }
+            
+            # Check gateway instance info
+            instance_info = manager.get_running_instance_info()
+            if instance_info:
+                check_result["checks"]["instance"] = instance_info
+            else:
+                check_result["warnings"].append("No gateway instance currently running")
+            
+            # Check MCP directories
+            mcp_dir = paths.data_dir / "mcp"
+            check_result["checks"]["directories"] = {
+                "mcp_dir_exists": mcp_dir.exists(),
+                "mcp_dir_writable": mcp_dir.exists() and os.access(mcp_dir, os.W_OK),
+            }
+            
+            if not mcp_dir.exists():
+                check_result["errors"].append("MCP directory does not exist")
+                check_result["status"] = "unhealthy"
+            
+        except Exception as e:
+            check_result["status"] = "error"
+            check_result["errors"].append(f"Gateway health check failed: {e}")
+        
+        return check_result
+    
+    async def _check_tools_health(self, detailed: bool) -> Dict[str, Any]:
+        """Check MCP tools health."""
+        check_result = {
+            "status": "healthy",
+            "checks": {},
+            "warnings": [],
+            "errors": [],
+        }
+        
+        try:
+            # Try to import and check tool registry
+            from ..registry.tool_registry import ToolRegistry
+            
+            registry = ToolRegistry()
+            await registry.initialize()
+            
+            # Get tool list
+            tools = registry.list_tools()
+            check_result["checks"]["tool_count"] = len(tools)
+            check_result["checks"]["tools"] = [tool.name for tool in tools]
+            
+            # Check essential tools
+            essential_tools = ["echo", "calculator", "system_info"]
+            available_essential = []
+            missing_essential = []
+            
+            for tool_name in essential_tools:
+                if registry.get_tool(tool_name):
+                    available_essential.append(tool_name)
+                else:
+                    missing_essential.append(tool_name)
+            
+            check_result["checks"]["essential_tools"] = {
+                "available": available_essential,
+                "missing": missing_essential,
+            }
+            
+            if missing_essential:
+                check_result["warnings"].append(f"Missing essential tools: {missing_essential}")
+            
+            if len(available_essential) == 0:
+                check_result["status"] = "unhealthy"
+                check_result["errors"].append("No essential tools available")
+            
+        except Exception as e:
+            check_result["status"] = "error"
+            check_result["errors"].append(f"Tools health check failed: {e}")
+        
+        return check_result
+    
+    async def _check_config_health(self, detailed: bool) -> Dict[str, Any]:
+        """Check configuration health."""
+        check_result = {
+            "status": "healthy",
+            "checks": {},
+            "warnings": [],
+            "errors": [],
+        }
+        
+        try:
+            # Check configuration files
+            config_dir = paths.data_dir / "mcp"
+            config_file = config_dir / "gateway_config.json"
+            
+            check_result["checks"]["config_dir"] = config_dir.exists()
+            check_result["checks"]["config_file"] = config_file.exists()
+            
+            if config_file.exists():
+                # Try to load configuration
+                import json
+                with open(config_file, 'r') as f:
+                    config_data = json.load(f)
+                
+                check_result["checks"]["config_valid"] = True
+                if detailed:
+                    check_result["checks"]["config_content"] = config_data
+            else:
+                check_result["warnings"].append("Gateway configuration file not found")
+            
+            # Check paths
+            check_result["checks"]["paths"] = {
+                "data_dir": str(paths.data_dir),
+                "logs_dir": str(paths.logs_dir),
+                "data_dir_exists": paths.data_dir.exists(),
+                "logs_dir_exists": paths.logs_dir.exists(),
+            }
+            
+        except Exception as e:
+            check_result["status"] = "error"
+            check_result["errors"].append(f"Config health check failed: {e}")
+        
+        return check_result
+    
+    def _calculate_overall_status(self, checks: Dict[str, Any]) -> str:
+        """Calculate overall health status from individual checks."""
+        if not checks:
+            return "unknown"
+        
+        statuses = [check.get("status", "unknown") for check in checks.values()]
+        
+        if "error" in statuses:
+            return "error"
+        elif "unhealthy" in statuses:
+            return "unhealthy"
+        elif "warning" in statuses:
+            return "warning"
+        elif all(status == "healthy" for status in statuses):
+            return "healthy"
+        else:
+            return "unknown"
+    
+    def _generate_summary(self, checks: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a summary of health check results."""
+        summary = {
+            "total_checks": len(checks),
+            "healthy": 0,
+            "warnings": 0,
+            "errors": 0,
+            "issues": [],
+        }
+        
+        for check_name, check_result in checks.items():
+            status = check_result.get("status", "unknown")
+            
+            if status == "healthy":
+                summary["healthy"] += 1
+            elif status in ["warning", "unhealthy"]:
+                summary["warnings"] += 1
+                # Collect warning messages
+                warnings = check_result.get("warnings", [])
+                for warning in warnings:
+                    summary["issues"].append(f"{check_name}: {warning}")
+            elif status == "error":
+                summary["errors"] += 1
+                # Collect error messages
+                errors = check_result.get("errors", [])
+                for error in errors:
+                    summary["issues"].append(f"{check_name}: {error}")
+        
+        return summary

{claude_mpm-4.0.17.dist-info → claude_mpm-4.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.0.17
+Version: 4.0.19
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

{claude_mpm-4.0.17.dist-info → claude_mpm-4.0.19.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=lClFCBcT1eNYIwcwgsxZcVeZ3Ebeb7-A7a1Zx8FU8xQ,4
-claude_mpm/VERSION,sha256=UevrCvMCjcZ1T4kWpSB5zmJ2ILIq9IaKarohvUdVpm4,7
+claude_mpm/VERSION,sha256=Z-JqRBA-lg5d3JWZYUWbiCNR9q8mM3cObebQWlEvUTQ,7
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Lfi2z17WSKiMrTAhA0LNsdLJRiV-J2dAezXPt0R9Qis,643
 claude_mpm/constants.py,sha256=cwfhDsstU5KK7esKnoq0PtSUg7LjneujdHjR-o5dX00,5597
@@ -30,7 +30,7 @@ claude_mpm/agents/templates/engineer.json,sha256=cxES5OiUT9UcI8npqpFrDo9doOyVJXY
 claude_mpm/agents/templates/memory_manager.json,sha256=XgXZYJFXFsNHRzwl_qyIKF6jzBa0dv6DqoiU8uuzHvw,12613
 claude_mpm/agents/templates/ops.json,sha256=QVlUNxE6ohwUYLj9nGG7_E9J3NA4Q8re22WXa8Zg-U4,13779
 claude_mpm/agents/templates/project_organizer.json,sha256=MpnwngqsKb4bEfTsnwOJCs1AMV29FEkx2sf2f_PZo5Y,17162
-claude_mpm/agents/templates/qa.json,sha256=bWmPWJ3iFVC-UBJ3yAaeFlpq4r2dwSK46RhPaTolKj4,10808
+claude_mpm/agents/templates/qa.json,sha256=4ej-Cw3ypjZCxkm42_odXsXmySBnM5nhhVJvZRn9IyA,14890
 claude_mpm/agents/templates/refactoring_engineer.json,sha256=02FSPaBHJW5Oc6jVp9BM10dbMfXXhVZRTE4gHaq557Y,17216
 claude_mpm/agents/templates/research.json,sha256=eSIjZXOlwn8N4ldiK84YsMpZeMmRYf8RvNQjNPkFd8Y,10909
 claude_mpm/agents/templates/security.json,sha256=VqJfSmc7HtKdima7CGPAbZ1hkOarrQ8_R_pV43utwBA,12350
@@ -48,7 +48,7 @@ claude_mpm/agents/templates/backup/research_agent_20250726_234551.json,sha256=o4
 claude_mpm/agents/templates/backup/research_memory_efficient.json,sha256=WlPnKlojeiCBZ4H75nWexLl_dHU5cSORIqLCDp4tCMM,8419
 claude_mpm/agents/templates/backup/security_agent_20250726_234551.json,sha256=l5YuD-27CxKSOsRLv0bDY_tCZyds0yGbeizLb8paeFY,2322
 claude_mpm/agents/templates/backup/version_control_agent_20250726_234551.json,sha256=too38RPTLJ9HutCMn0nfmEdCj2me241dx5tUYDFtu94,2143
-claude_mpm/cli/__init__.py,sha256=SFSCqi8t4f72uT3OflmaaNWJQxJqYkR9Ayb2xae3e5A,8629
+claude_mpm/cli/__init__.py,sha256=j8VD88hQjRr0THMih9HVjirQR_XFv_K_FzUNrHAZYi4,10994
 claude_mpm/cli/__main__.py,sha256=kTFfTFeGzMIj-LPJY6wkJby8jCHt0UnapS7J7P83y7w,767
 claude_mpm/cli/parser.py,sha256=Kv2d4JJMVIag1Q_YJimJdjzrnEN_jetKW-hGuEW67Uo,1438
 claude_mpm/cli/ticket_cli.py,sha256=Cco0riIeo-PuzBslX3-5LAtLUcsLvexSRtVlheb7-cQ,916
@@ -62,8 +62,8 @@ claude_mpm/cli/commands/info.py,sha256=UgAwH97Zbr0tFhxqPj4dIFEsrlmPrgSzxvicue_oQ
 claude_mpm/cli/commands/mcp.py,sha256=572RW4RaIxa2XLiv6QK2KwxLjdYqreWD1hVQQScURkk,7137
 claude_mpm/cli/commands/mcp_command_router.py,sha256=l_FbI8kyfMcjWMTdTKsbIkugcPvGPy3Bl9VAYv95KdU,5026
 claude_mpm/cli/commands/mcp_config_commands.py,sha256=TnTg7-erE5Z6O8C84o4lZITco72Wnu0FVlVF8tNVsP0,695
-claude_mpm/cli/commands/mcp_install_commands.py,sha256=aAHgHWbZ7ma1OtwkknVEQbZuXYSD8sSptqJ2ujfCMlk,684
-claude_mpm/cli/commands/mcp_server_commands.py,sha256=MV3mLDf1F2c_YpCw0UNqLwlFJoW3J_dc5l5S0eKFhrU,7248
+claude_mpm/cli/commands/mcp_install_commands.py,sha256=mrrCtvWZeSVyGxivSSTPMpo2wWGsNNAsPM3-IZjY9Ms,2931
+claude_mpm/cli/commands/mcp_server_commands.py,sha256=_5iC8Iuroz_OwJCsMQ1CJKNNaGJl2616rf9s9xYb-_o,6503
 claude_mpm/cli/commands/mcp_tool_commands.py,sha256=q17GzlFT3JiLTrDqwPO2tz1-fKmPO5QU449syTnKTz4,1283
 claude_mpm/cli/commands/memory.py,sha256=UqMSrwFhXEt4lsOOcgHDOKWmlwLe0rwCuc4E2FNi3BE,36807
 claude_mpm/cli/commands/monitor.py,sha256=L8ID5Z2CAgPhGBWh85rmwrM3ZgHNOZj2nKNHvZEkcps,23148
@@ -198,6 +198,8 @@ claude_mpm/models/__init__.py,sha256=QamAtAaqCqZIjh_9VxURft6DubbinbWwJdM2tbwVNeA
 claude_mpm/models/agent_definition.py,sha256=LC7EwihixF2Gw4QqOxiCNchsEzzyQJPR6AgPrcTrWTM,6674
 claude_mpm/models/agent_session.py,sha256=DQp7nkCUBQf3IaGV5DjCduTHoo-8tNxjn2ZpISHlrhc,20051
 claude_mpm/scripts/__init__.py,sha256=IffMdVD99Pxyw85yluRa0VDPi4dRQecIWce764pcfZE,553
+claude_mpm/scripts/mcp_server.py,sha256=TiAZwuznT9Io_qeAWAuW9eWGoNm8_Y9u2D3cX1do90k,2260
+claude_mpm/scripts/mcp_wrapper.py,sha256=OPqjuQMLMZBDt84Dktt9KPwsEaIN-UM49OgcKrDwr0U,1125
 claude_mpm/scripts/socketio_daemon.py,sha256=qB_q6y8cqaGJMnEmCJ9zXdr8xbeZV27Y79f7cUs8qlY,12958
 claude_mpm/scripts/socketio_server_manager.py,sha256=AUFNCsgRzvvZeazjsybocM-sxYm7S3cMoP0B4DdICNw,13958
 claude_mpm/scripts/start_activity_logging.py,sha256=1G9bFYiBSkpxSRXyKht73nL5gH-4zwukLutWWKAipGg,2869
@@ -335,7 +337,7 @@ claude_mpm/services/infrastructure/daemon_manager.py,sha256=ZfEmSSwyP7nYRfdpEl7G
 claude_mpm/services/infrastructure/logging.py,sha256=3bYMJi-qzpPNgs1-Epfp6EAuRm5iP-hypIluSpgy0Eg,6473
 claude_mpm/services/infrastructure/monitoring.py,sha256=NXF3Z2SWz42KdSBdlIN5ADGgyNY6DS_qCYKKg2YYS5E,35871
 claude_mpm/services/mcp_gateway/__init__.py,sha256=sZ8qtuIle4U9N4j3YZCTmikz1DMK68VvLPhhpvfNxiU,4503
-claude_mpm/services/mcp_gateway/main.py,sha256=8pFHR1EOcwZJ1wZbTHlEvUfdujR7t0fPaqk3SX4crHs,15490
+claude_mpm/services/mcp_gateway/main.py,sha256=W66_lakqn_yG92DMeygtZfulOjbHK2sfdYfWSCeLN0E,15756
 claude_mpm/services/mcp_gateway/config/__init__.py,sha256=noKmcSovlfAN8I50QMDZA5fLdBedLY58N2JkNNT-HFc,386
 claude_mpm/services/mcp_gateway/config/config_loader.py,sha256=qP5Ilm6KnQa_H5Ksy1Dz-wADj4OLonGyTQzP115-VcY,7279
 claude_mpm/services/mcp_gateway/config/config_schema.py,sha256=5iCUDqW_HEGQtU5zBkRk9g6p0xQMkQtRSXvdz_YjoL4,9485
@@ -344,16 +346,19 @@ claude_mpm/services/mcp_gateway/core/__init__.py,sha256=OXWSuKX93Zqjzd_3f-aGN-iR
 claude_mpm/services/mcp_gateway/core/base.py,sha256=41salIURBpVM1YewWuWOwPcyASswsLTuToepjpUlLKM,10277
 claude_mpm/services/mcp_gateway/core/exceptions.py,sha256=oRCvGhGgXeqzzybiBz3KNBud5Dn6feBO9MQQUHuqyT0,6795
 claude_mpm/services/mcp_gateway/core/interfaces.py,sha256=-lb1e3Dkt4hzk6GRtLQonoPCvC5lWSxkUJptHWUacZU,10610
+claude_mpm/services/mcp_gateway/core/singleton_manager.py,sha256=QQrbOB7XukhXdF3U3AH_gSb_IsuwYILRBn4x0W2lB04,9820
+claude_mpm/services/mcp_gateway/core/startup_verification.py,sha256=odn_nsqNgFUGLAXj9zCLN5hWZICdGoSYns6stcAx9Gw,11369
 claude_mpm/services/mcp_gateway/registry/__init__.py,sha256=6qjyfcCgW7sd_S82gY7G4DPZp3nL7tMHzyaxiz3G2Zc,195
 claude_mpm/services/mcp_gateway/registry/service_registry.py,sha256=POSzxP4F3HmAFUvgBJnQ9TZEAbMWekWaTZdaZuLA3lU,12969
 claude_mpm/services/mcp_gateway/registry/tool_registry.py,sha256=rWlkYToIe_d4STrRM3ws576ofW7sbIlwiBDgqfnwSVM,15922
 claude_mpm/services/mcp_gateway/server/__init__.py,sha256=w1gDtjRPsuDP6zT84ZnbxI20m6oq_SJlndLv3T5sRL4,294
 claude_mpm/services/mcp_gateway/server/mcp_gateway.py,sha256=cv9gx2gxdR3QI2J1N7F7PAbBbmZPP_l8NQBes509zdg,13757
 claude_mpm/services/mcp_gateway/server/stdio_handler.py,sha256=qO9V5W9Dhyi7SqnhXmjD4kcUuy46JF2gFM_huNH7SPw,11419
-claude_mpm/services/mcp_gateway/server/stdio_server.py,sha256=QSwS8LDlVxjHLk5k_wy-hZYvUqO2g6_MHZcv9UvQxrc,25229
+claude_mpm/services/mcp_gateway/server/stdio_server.py,sha256=6z7ZrxEZMb9bmLVqpAlPmdSSQ6_eHt3-3Z8qqeoPrUc,30699
 claude_mpm/services/mcp_gateway/tools/__init__.py,sha256=YyWtIgU5m8Y-6JNQwd7HZBkzzBjxdLbJkU9jcp9mCv8,530
 claude_mpm/services/mcp_gateway/tools/base_adapter.py,sha256=0HMEx1ZlEWuyEHiQ-iDYKXgcnAi4jfQ19MitlNEpfqM,15890
 claude_mpm/services/mcp_gateway/tools/document_summarizer.py,sha256=PZCREg5Kdvj1b5RHF7KfsEW-eo49NHcKS4uLeSg9WvU,28324
+claude_mpm/services/mcp_gateway/tools/health_check_tool.py,sha256=piqtMFKmw1orrNh75K55JVr8pvw0TAK_o43YiqRwJMI,17083
 claude_mpm/services/mcp_gateway/tools/hello_world.py,sha256=vSEW3x8Sy23ag6BzHYvuex3b6tgKDtOOjXwg6hOWPr4,20248
 claude_mpm/services/mcp_gateway/tools/ticket_tools.py,sha256=XYbn0vvrqszwO3-OynGQdbPcL_8seMjJtxfw7blQ3bs,23492
 claude_mpm/services/mcp_gateway/tools/unified_ticket_tool.py,sha256=vlxPo2uld6ZkKzSO3it5pXN4FipWaq93t802tuR-N-Y,22626
@@ -411,9 +416,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=e74VlIPozCljZss_0SwLO3J1ZuIKRT9FrrFi
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=szbK9d29v_T6xE_KvW845WLKXbS_yYpXQscrSrSeldI,20937
 claude_mpm/validation/frontmatter_validator.py,sha256=Q_aTyjigfKZQG7eSwLtwMfd0h_eyS9FQAm59ZFf5VYA,7036
-claude_mpm-4.0.17.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.0.17.dist-info/METADATA,sha256=ynXMCyCT6W5wjAubwGM2GdIBCuvb7eassAeb7ZC1Tfc,11883
-claude_mpm-4.0.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.0.17.dist-info/entry_points.txt,sha256=uafLVeHm4AXrzvdR77fXO3a2MmvvfGtmVU2iY8uIPt8,403
-claude_mpm-4.0.17.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.0.17.dist-info/RECORD,,
+claude_mpm-4.0.19.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.0.19.dist-info/METADATA,sha256=GQYzhZo3VMzA-OnUVZ2mWuQEECfF0ierB2Yebyc5KIg,11883
+claude_mpm-4.0.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.0.19.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.0.19.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.0.19.dist-info/RECORD,,

{claude_mpm-4.0.17.dist-info → claude_mpm-4.0.19.dist-info}/entry_points.txt

@@ -1,6 +1,7 @@
 [console_scripts]
 claude-mpm = claude_mpm.cli:main
 claude-mpm-mcp = claude_mpm.services.mcp_gateway.server.stdio_server:main_sync
+claude-mpm-mcp-wrapper = claude_mpm.scripts.mcp_wrapper:entry_point
 claude-mpm-monitor = claude_mpm.scripts.launch_monitor:main
 claude-mpm-socketio = claude_mpm.scripts.socketio_daemon:main
 claude-mpm-ticket = claude_mpm.cli.ticket_cli:main