claude-mpm 4.0.29__py3-none-any.whl → 4.0.31__py3-none-any.whl

claude_mpm/services/diagnostics/checks/mcp_check.py

@@ -0,0 +1,315 @@
+"""
+Check MCP (Model Context Protocol) server status.
+
+WHY: Verify that the MCP gateway is properly installed, configured,
+and functioning for enhanced Claude Desktop capabilities.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Dict, Any
+
+from ..models import DiagnosticResult, DiagnosticStatus
+from .base_check import BaseDiagnosticCheck
+
+
+class MCPCheck(BaseDiagnosticCheck):
+    """Check MCP server installation and configuration."""
+    
+    @property
+    def name(self) -> str:
+        return "mcp_check"
+    
+    @property
+    def category(self) -> str:
+        return "MCP Server"
+    
+    def run(self) -> DiagnosticResult:
+        """Run MCP diagnostics."""
+        try:
+            from ....services.mcp_gateway.core.startup_verification import MCPGatewayStartupVerifier
+            
+            sub_results = []
+            details = {}
+            
+            # Check if MCP is installed
+            install_result = self._check_installation()
+            sub_results.append(install_result)
+            details["installed"] = install_result.status == DiagnosticStatus.OK
+            
+            if install_result.status == DiagnosticStatus.OK:
+                # Check MCP configuration
+                config_result = self._check_configuration()
+                sub_results.append(config_result)
+                details["configured"] = config_result.status == DiagnosticStatus.OK
+                
+                # Check MCP server status
+                status_result = self._check_server_status()
+                sub_results.append(status_result)
+                details["running"] = status_result.details.get("running", False)
+                
+                # Verify startup
+                startup_result = self._check_startup_verification()
+                sub_results.append(startup_result)
+            
+            # Determine overall status
+            if any(r.status == DiagnosticStatus.ERROR for r in sub_results):
+                status = DiagnosticStatus.ERROR
+                message = "MCP server has critical issues"
+            elif not details.get("installed", False):
+                status = DiagnosticStatus.WARNING
+                message = "MCP server not installed"
+            elif any(r.status == DiagnosticStatus.WARNING for r in sub_results):
+                status = DiagnosticStatus.WARNING
+                message = "MCP server needs configuration"
+            else:
+                status = DiagnosticStatus.OK
+                message = "MCP server properly configured"
+            
+            return DiagnosticResult(
+                category=self.category,
+                status=status,
+                message=message,
+                details=details,
+                sub_results=sub_results if self.verbose else []
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category=self.category,
+                status=DiagnosticStatus.ERROR,
+                message=f"MCP check failed: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_installation(self) -> DiagnosticResult:
+        """Check if MCP server is installed."""
+        # Check for MCP binary
+        mcp_paths = [
+            Path("/usr/local/bin/claude-mpm-mcp"),
+            Path.home() / ".local/bin/claude-mpm-mcp",
+            Path("/opt/claude-mpm/bin/claude-mpm-mcp")
+        ]
+        
+        for mcp_path in mcp_paths:
+            if mcp_path.exists():
+                return DiagnosticResult(
+                    category="MCP Installation",
+                    status=DiagnosticStatus.OK,
+                    message="MCP server installed",
+                    details={"path": str(mcp_path), "installed": True}
+                )
+        
+        # Check if it's available via command
+        try:
+            result = subprocess.run(
+                ["which", "claude-mpm-mcp"],
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+            if result.returncode == 0:
+                path = result.stdout.strip()
+                return DiagnosticResult(
+                    category="MCP Installation",
+                    status=DiagnosticStatus.OK,
+                    message="MCP server installed",
+                    details={"path": path, "installed": True}
+                )
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+        
+        return DiagnosticResult(
+            category="MCP Installation",
+            status=DiagnosticStatus.WARNING,
+            message="MCP server not installed",
+            details={"installed": False},
+            fix_command="claude-mpm mcp install",
+            fix_description="Install MCP server for enhanced capabilities"
+        )
+    
+    def _check_configuration(self) -> DiagnosticResult:
+        """Check MCP configuration in Claude Desktop."""
+        config_paths = [
+            Path.home() / ".config/claude/claude_desktop_config.json",
+            Path.home() / "Library/Application Support/Claude/claude_desktop_config.json",
+            Path.home() / "AppData/Roaming/Claude/claude_desktop_config.json"
+        ]
+        
+        config_path = None
+        for path in config_paths:
+            if path.exists():
+                config_path = path
+                break
+        
+        if not config_path:
+            return DiagnosticResult(
+                category="MCP Configuration",
+                status=DiagnosticStatus.WARNING,
+                message="Claude Desktop config not found",
+                details={"configured": False},
+                fix_command="claude-mpm mcp config",
+                fix_description="Configure MCP server in Claude Desktop"
+            )
+        
+        try:
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+                
+                mcp_servers = config.get("mcpServers", {})
+                gateway = mcp_servers.get("claude-mpm-gateway", {})
+                
+                if not gateway:
+                    return DiagnosticResult(
+                        category="MCP Configuration",
+                        status=DiagnosticStatus.WARNING,
+                        message="MCP gateway not configured",
+                        details={"configured": False, "config_path": str(config_path)},
+                        fix_command="claude-mpm mcp config",
+                        fix_description="Add MCP gateway to Claude Desktop configuration"
+                    )
+                
+                # Check configuration validity
+                command = gateway.get("command")
+                if not command:
+                    return DiagnosticResult(
+                        category="MCP Configuration",
+                        status=DiagnosticStatus.ERROR,
+                        message="MCP gateway misconfigured (no command)",
+                        details={
+                            "configured": True,
+                            "valid": False,
+                            "config_path": str(config_path)
+                        },
+                        fix_command="claude-mpm mcp config --force",
+                        fix_description="Fix MCP gateway configuration"
+                    )
+                
+                return DiagnosticResult(
+                    category="MCP Configuration",
+                    status=DiagnosticStatus.OK,
+                    message="MCP gateway configured",
+                    details={
+                        "configured": True,
+                        "command": command,
+                        "config_path": str(config_path)
+                    }
+                )
+                
+        except json.JSONDecodeError as e:
+            return DiagnosticResult(
+                category="MCP Configuration",
+                status=DiagnosticStatus.ERROR,
+                message="Invalid JSON in config file",
+                details={"error": str(e), "config_path": str(config_path)},
+                fix_description="Fix JSON syntax in Claude Desktop config"
+            )
+        except Exception as e:
+            return DiagnosticResult(
+                category="MCP Configuration",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check configuration: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_server_status(self) -> DiagnosticResult:
+        """Check if MCP server is running."""
+        try:
+            # Try to connect to the MCP server
+            result = subprocess.run(
+                ["claude-mpm", "mcp", "status"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            if result.returncode == 0:
+                if "running" in result.stdout.lower():
+                    return DiagnosticResult(
+                        category="MCP Server Status",
+                        status=DiagnosticStatus.OK,
+                        message="MCP server is running",
+                        details={"running": True}
+                    )
+                else:
+                    return DiagnosticResult(
+                        category="MCP Server Status",
+                        status=DiagnosticStatus.WARNING,
+                        message="MCP server not running",
+                        details={"running": False},
+                        fix_command="claude-mpm mcp start",
+                        fix_description="Start the MCP server"
+                    )
+            else:
+                return DiagnosticResult(
+                    category="MCP Server Status",
+                    status=DiagnosticStatus.WARNING,
+                    message="Could not determine server status",
+                    details={"running": "unknown", "error": result.stderr}
+                )
+                
+        except subprocess.TimeoutExpired:
+            return DiagnosticResult(
+                category="MCP Server Status",
+                status=DiagnosticStatus.WARNING,
+                message="Server status check timed out",
+                details={"running": "unknown", "error": "timeout"}
+            )
+        except Exception as e:
+            return DiagnosticResult(
+                category="MCP Server Status",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check server status: {str(e)}",
+                details={"running": "unknown", "error": str(e)}
+            )
+    
+    def _check_startup_verification(self) -> DiagnosticResult:
+        """Run MCP startup verification."""
+        try:
+            from ....services.mcp_gateway.core.startup_verification import MCPGatewayStartupVerifier
+            
+            verifier = MCPGatewayStartupVerifier()
+            issues = verifier.verify_startup()
+            
+            if not issues:
+                return DiagnosticResult(
+                    category="MCP Startup Verification",
+                    status=DiagnosticStatus.OK,
+                    message="Startup verification passed",
+                    details={"issues": []}
+                )
+            
+            # Categorize issues by severity
+            errors = [i for i in issues if "error" in i.lower() or "critical" in i.lower()]
+            warnings = [i for i in issues if i not in errors]
+            
+            if errors:
+                return DiagnosticResult(
+                    category="MCP Startup Verification",
+                    status=DiagnosticStatus.ERROR,
+                    message=f"{len(errors)} critical issue(s) found",
+                    details={"errors": errors, "warnings": warnings}
+                )
+            elif warnings:
+                return DiagnosticResult(
+                    category="MCP Startup Verification",
+                    status=DiagnosticStatus.WARNING,
+                    message=f"{len(warnings)} warning(s) found",
+                    details={"warnings": warnings}
+                )
+            else:
+                return DiagnosticResult(
+                    category="MCP Startup Verification",
+                    status=DiagnosticStatus.OK,
+                    message="Startup verification passed",
+                    details={"issues": []}
+                )
+                
+        except Exception as e:
+            return DiagnosticResult(
+                category="MCP Startup Verification",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not verify startup: {str(e)}",
+                details={"error": str(e)}
+            )

claude_mpm/services/diagnostics/checks/monitor_check.py

@@ -0,0 +1,282 @@
+"""
+Check monitoring and SocketIO server status.
+
+WHY: Verify that the monitoring system and SocketIO server are
+properly configured and accessible for real-time updates.
+"""
+
+import socket
+from typing import Dict, Any
+
+from ..models import DiagnosticResult, DiagnosticStatus
+from .base_check import BaseDiagnosticCheck
+
+
+class MonitorCheck(BaseDiagnosticCheck):
+    """Check monitoring and SocketIO server."""
+    
+    @property
+    def name(self) -> str:
+        return "monitor_check"
+    
+    @property
+    def category(self) -> str:
+        return "Monitor"
+    
+    def run(self) -> DiagnosticResult:
+        """Run monitor diagnostics."""
+        try:
+            from ....services.port_manager import PortManager
+            
+            sub_results = []
+            details = {}
+            
+            # Check SocketIO availability
+            socketio_result = self._check_socketio()
+            sub_results.append(socketio_result)
+            details["socketio_available"] = socketio_result.status == DiagnosticStatus.OK
+            
+            # Check port availability
+            port_result = self._check_ports()
+            sub_results.append(port_result)
+            details["ports"] = port_result.details
+            
+            # Check response logging
+            logging_result = self._check_response_logging()
+            sub_results.append(logging_result)
+            details["response_logging"] = logging_result.details.get("enabled", False)
+            
+            # Check hook service
+            hook_result = self._check_hook_service()
+            sub_results.append(hook_result)
+            details["hooks_enabled"] = hook_result.status == DiagnosticStatus.OK
+            
+            # Determine overall status
+            if any(r.status == DiagnosticStatus.ERROR for r in sub_results):
+                status = DiagnosticStatus.ERROR
+                message = "Monitoring has critical issues"
+            elif any(r.status == DiagnosticStatus.WARNING for r in sub_results):
+                status = DiagnosticStatus.WARNING
+                message = "Monitoring has minor issues"
+            else:
+                status = DiagnosticStatus.OK
+                message = "Monitoring properly configured"
+            
+            return DiagnosticResult(
+                category=self.category,
+                status=status,
+                message=message,
+                details=details,
+                sub_results=sub_results if self.verbose else []
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category=self.category,
+                status=DiagnosticStatus.ERROR,
+                message=f"Monitor check failed: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_socketio(self) -> DiagnosticResult:
+        """Check if SocketIO is available."""
+        try:
+            import socketio
+            
+            return DiagnosticResult(
+                category="SocketIO",
+                status=DiagnosticStatus.OK,
+                message="SocketIO library available",
+                details={"available": True, "version": getattr(socketio, "__version__", "unknown")}
+            )
+        except ImportError:
+            return DiagnosticResult(
+                category="SocketIO",
+                status=DiagnosticStatus.WARNING,
+                message="SocketIO not installed",
+                details={"available": False},
+                fix_command="pip install python-socketio[asyncio]",
+                fix_description="Install SocketIO for real-time monitoring"
+            )
+    
+    def _check_ports(self) -> DiagnosticResult:
+        """Check port availability for monitoring services."""
+        try:
+            from ....services.port_manager import PortManager
+            
+            port_manager = PortManager()
+            
+            # Check default monitoring port range
+            available_ports = []
+            blocked_ports = []
+            
+            for port in range(8765, 8786):
+                if self._is_port_available(port):
+                    available_ports.append(port)
+                else:
+                    blocked_ports.append(port)
+            
+            if not available_ports:
+                return DiagnosticResult(
+                    category="Port Availability",
+                    status=DiagnosticStatus.ERROR,
+                    message="No monitoring ports available (8765-8785)",
+                    details={
+                        "available": [],
+                        "blocked": blocked_ports,
+                        "checked_range": "8765-8785"
+                    },
+                    fix_description="Free up ports in the 8765-8785 range"
+                )
+            
+            # Check if default port is available
+            default_port = 8765
+            if default_port not in available_ports:
+                return DiagnosticResult(
+                    category="Port Availability",
+                    status=DiagnosticStatus.WARNING,
+                    message=f"Default port {default_port} in use, but alternatives available",
+                    details={
+                        "available": available_ports,
+                        "blocked": blocked_ports,
+                        "default_port": default_port
+                    }
+                )
+            
+            return DiagnosticResult(
+                category="Port Availability",
+                status=DiagnosticStatus.OK,
+                message=f"{len(available_ports)} monitoring port(s) available",
+                details={
+                    "available": available_ports,
+                    "blocked": blocked_ports,
+                    "default_port": default_port
+                }
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category="Port Availability",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check ports: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _is_port_available(self, port: int) -> bool:
+        """Check if a specific port is available."""
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(0.1)
+        try:
+            result = sock.connect_ex(('localhost', port))
+            return result != 0
+        finally:
+            sock.close()
+    
+    def _check_response_logging(self) -> DiagnosticResult:
+        """Check response logging configuration."""
+        from pathlib import Path
+        import yaml
+        
+        # Check user config
+        config_paths = [
+            Path.home() / ".claude" / "claude-mpm.yaml",
+            Path.cwd() / ".claude" / "claude-mpm.yaml"
+        ]
+        
+        response_logging_enabled = False
+        log_path = None
+        
+        for config_path in config_paths:
+            if config_path.exists():
+                try:
+                    with open(config_path, 'r') as f:
+                        config = yaml.safe_load(f)
+                        if config and isinstance(config, dict):
+                            response_config = config.get("response_logging", {})
+                            if response_config.get("enabled", False):
+                                response_logging_enabled = True
+                                log_path = response_config.get("path", "~/.claude/responses")
+                                break
+                except Exception:
+                    pass
+        
+        if not response_logging_enabled:
+            return DiagnosticResult(
+                category="Response Logging",
+                status=DiagnosticStatus.OK,
+                message="Response logging disabled (default)",
+                details={"enabled": False}
+            )
+        
+        # Check log directory
+        log_dir = Path(log_path).expanduser()
+        if not log_dir.exists():
+            return DiagnosticResult(
+                category="Response Logging",
+                status=DiagnosticStatus.WARNING,
+                message="Response logging enabled but directory missing",
+                details={
+                    "enabled": True,
+                    "path": str(log_dir),
+                    "exists": False
+                },
+                fix_command=f"mkdir -p {log_dir}",
+                fix_description="Create response logging directory"
+            )
+        
+        import os
+        if not os.access(log_dir, os.W_OK):
+            return DiagnosticResult(
+                category="Response Logging",
+                status=DiagnosticStatus.WARNING,
+                message="Response logging directory not writable",
+                details={
+                    "enabled": True,
+                    "path": str(log_dir),
+                    "writable": False
+                },
+                fix_command=f"chmod 755 {log_dir}",
+                fix_description="Fix permissions on logging directory"
+            )
+        
+        return DiagnosticResult(
+            category="Response Logging",
+            status=DiagnosticStatus.OK,
+            message="Response logging enabled and configured",
+            details={
+                "enabled": True,
+                "path": str(log_dir),
+                "exists": True,
+                "writable": True
+            }
+        )
+    
+    def _check_hook_service(self) -> DiagnosticResult:
+        """Check hook service configuration."""
+        try:
+            from ....services.hook_service import HookService
+            
+            # Try to create hook service instance
+            hook_service = HookService()
+            
+            return DiagnosticResult(
+                category="Hook Service",
+                status=DiagnosticStatus.OK,
+                message="Hook service available",
+                details={"available": True}
+            )
+            
+        except ImportError:
+            return DiagnosticResult(
+                category="Hook Service",
+                status=DiagnosticStatus.WARNING,
+                message="Hook service not available",
+                details={"available": False}
+            )
+        except Exception as e:
+            return DiagnosticResult(
+                category="Hook Service",
+                status=DiagnosticStatus.WARNING,
+                message=f"Hook service error: {str(e)}",
+                details={"available": False, "error": str(e)}
+            )