claude-mpm 4.1.1__py3-none-any.whl → 4.1.3__py3-none-any.whl

claude_mpm/services/diagnostics/checks/monitor_check.py

@@ -6,7 +6,6 @@ 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
@@ -14,43 +13,44 @@ 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
-            
+            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
@@ -61,33 +61,36 @@ class MonitorCheck(BaseDiagnosticCheck):
             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 []
+                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)}
+                message=f"Monitor check failed: {e!s}",
+                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")}
+                details={
+                    "available": True,
+                    "version": getattr(socketio, "__version__", "unknown"),
+                },
             )
         except ImportError:
             return DiagnosticResult(
@@ -96,26 +99,26 @@ class MonitorCheck(BaseDiagnosticCheck):
                 message="SocketIO not installed",
                 details={"available": False},
                 fix_command="pip install python-socketio[asyncio]",
-                fix_description="Install SocketIO for real-time monitoring"
+                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()
-            
+
+            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",
@@ -124,11 +127,11 @@ class MonitorCheck(BaseDiagnosticCheck):
                     details={
                         "available": [],
                         "blocked": blocked_ports,
-                        "checked_range": "8765-8785"
+                        "checked_range": "8765-8785",
                     },
-                    fix_description="Free up ports in the 8765-8785 range"
+                    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:
@@ -139,10 +142,10 @@ class MonitorCheck(BaseDiagnosticCheck):
                     details={
                         "available": available_ports,
                         "blocked": blocked_ports,
-                        "default_port": default_port
-                    }
+                        "default_port": default_port,
+                    },
                 )
-            
+
             return DiagnosticResult(
                 category="Port Availability",
                 status=DiagnosticStatus.OK,
@@ -150,64 +153,67 @@ class MonitorCheck(BaseDiagnosticCheck):
                 details={
                     "available": available_ports,
                     "blocked": blocked_ports,
-                    "default_port": default_port
-                }
+                    "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)}
+                message=f"Could not check ports: {e!s}",
+                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))
+            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"
+            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:
+                    with open(config_path) 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")
+                                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}
+                details={"enabled": False},
             )
-        
+
         # Check log directory
         log_dir = Path(log_path).expanduser()
         if not log_dir.exists():
@@ -215,30 +221,23 @@ class MonitorCheck(BaseDiagnosticCheck):
                 category="Response Logging",
                 status=DiagnosticStatus.WARNING,
                 message="Response logging enabled but directory missing",
-                details={
-                    "enabled": True,
-                    "path": str(log_dir),
-                    "exists": False
-                },
+                details={"enabled": True, "path": str(log_dir), "exists": False},
                 fix_command=f"mkdir -p {log_dir}",
-                fix_description="Create response logging directory"
+                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
-                },
+                details={"enabled": True, "path": str(log_dir), "writable": False},
                 fix_command=f"chmod 755 {log_dir}",
-                fix_description="Fix permissions on logging directory"
+                fix_description="Fix permissions on logging directory",
             )
-        
+
         return DiagnosticResult(
             category="Response Logging",
             status=DiagnosticStatus.OK,
@@ -247,36 +246,36 @@ class MonitorCheck(BaseDiagnosticCheck):
                 "enabled": True,
                 "path": str(log_dir),
                 "exists": True,
-                "writable": 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()
-            
+            HookService()
+
             return DiagnosticResult(
                 category="Hook Service",
                 status=DiagnosticStatus.OK,
                 message="Hook service available",
-                details={"available": True}
+                details={"available": True},
             )
-            
+
         except ImportError:
             return DiagnosticResult(
                 category="Hook Service",
                 status=DiagnosticStatus.WARNING,
                 message="Hook service not available",
-                details={"available": False}
+                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)}
-            )
+                message=f"Hook service error: {e!s}",
+                details={"available": False, "error": str(e)},
+            )