claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/services/monitor/handlers/dashboard.py

@@ -0,0 +1,299 @@
+"""
+Dashboard Event Handler for Unified Monitor
+===========================================
+
+WHY: This handler manages dashboard-specific Socket.IO events for the unified
+monitor daemon. It handles client connections, status updates, and dashboard
+state management.
+
+DESIGN DECISIONS:
+- Manages client connections and session state
+- Provides dashboard status and health information
+- Handles real-time dashboard updates
+- Integrates with the unified monitor architecture
+"""
+
+import asyncio
+from typing import Dict, Set
+
+import socketio
+
+from ....core.enums import ServiceState
+from ....core.logging_config import get_logger
+
+
+class DashboardHandler:
+    """Event handler for dashboard-specific functionality.
+
+    WHY: Manages dashboard client connections and provides real-time updates
+    for the unified monitor daemon.
+    """
+
+    def __init__(self, sio: socketio.AsyncServer):
+        """Initialize the dashboard handler.
+
+        Args:
+            sio: Socket.IO server instance
+        """
+        self.sio = sio
+        self.logger = get_logger(__name__)
+
+        # Client management
+        self.connected_clients: Set[str] = set()
+        self.client_info: Dict[str, Dict] = {}
+
+    def register(self):
+        """Register Socket.IO event handlers."""
+        try:
+            # Connection events
+            self.sio.on("connect", self.handle_connect)
+            self.sio.on("disconnect", self.handle_disconnect)
+
+            # Dashboard events
+            self.sio.on("dashboard:status", self.handle_get_status)
+            self.sio.on("dashboard:info", self.handle_get_info)
+            self.sio.on("dashboard:ping", self.handle_ping)
+
+            # Client management
+            self.sio.on("client:register", self.handle_client_register)
+            self.sio.on("client:list", self.handle_client_list)
+
+            self.logger.info("Dashboard event handlers registered")
+
+        except Exception as e:
+            self.logger.error(f"Error registering dashboard handlers: {e}")
+            raise
+
+    async def handle_connect(self, sid: str, environ: Dict):
+        """Handle client connection.
+
+        Args:
+            sid: Socket.IO session ID
+            environ: Connection environment
+        """
+        try:
+            self.connected_clients.add(sid)
+
+            # Extract client info
+            client_info = {
+                "connected_at": asyncio.get_event_loop().time(),
+                "user_agent": environ.get("HTTP_USER_AGENT", "Unknown"),
+                "remote_addr": environ.get("REMOTE_ADDR", "Unknown"),
+            }
+            self.client_info[sid] = client_info
+
+            self.logger.info(f"Dashboard client connected: {sid}")
+
+            # Send welcome message
+            await self.sio.emit(
+                "dashboard:welcome",
+                {
+                    "message": "Connected to Claude MPM Unified Monitor",
+                    "session_id": sid,
+                    "server_info": {"service": "unified-monitor", "version": "1.0.0"},
+                },
+                room=sid,
+            )
+
+            # Broadcast client count update
+            await self._broadcast_client_count()
+
+        except Exception as e:
+            self.logger.error(f"Error handling client connection: {e}")
+
+    async def handle_disconnect(self, sid: str):
+        """Handle client disconnection.
+
+        Args:
+            sid: Socket.IO session ID
+        """
+        try:
+            self.connected_clients.discard(sid)
+            self.client_info.pop(sid, None)
+
+            self.logger.info(f"Dashboard client disconnected: {sid}")
+
+            # Broadcast client count update
+            await self._broadcast_client_count()
+
+        except Exception as e:
+            self.logger.error(f"Error handling client disconnection: {e}")
+
+    async def handle_get_status(self, sid: str, data: Dict):
+        """Handle dashboard status request.
+
+        Args:
+            sid: Socket.IO session ID
+            data: Request data
+        """
+        try:
+            status = {
+                "service": "unified-monitor",
+                "status": ServiceState.RUNNING,
+                "clients_connected": len(self.connected_clients),
+                "uptime": asyncio.get_event_loop().time(),
+                "features": {
+                    "code_analysis": True,
+                    "real_ast": True,
+                    "file_monitoring": True,
+                    "dashboard": True,
+                },
+            }
+
+            await self.sio.emit("dashboard:status:response", status, room=sid)
+
+        except Exception as e:
+            self.logger.error(f"Error getting dashboard status: {e}")
+            await self.sio.emit(
+                "dashboard:error", {"error": f"Status error: {e!s}"}, room=sid
+            )
+
+    async def handle_get_info(self, sid: str, data: Dict):
+        """Handle dashboard info request.
+
+        Args:
+            sid: Socket.IO session ID
+            data: Request data
+        """
+        try:
+            info = {
+                "service_name": "Claude MPM Unified Monitor",
+                "description": "Single stable daemon for all monitoring functionality",
+                "features": [
+                    "Real AST Analysis",
+                    "Code Tree Visualization",
+                    "File System Monitoring",
+                    "Socket.IO Events",
+                    "HTTP Dashboard",
+                ],
+                "endpoints": {"dashboard": "/", "health": "/health", "api": "/api/*"},
+                "events": {
+                    "code_analysis": [
+                        "code:analyze:file",
+                        "code:analyze:directory",
+                        "code:get:tree",
+                    ],
+                    "dashboard": [
+                        "dashboard:status",
+                        "dashboard:info",
+                        "dashboard:ping",
+                    ],
+                },
+            }
+
+            await self.sio.emit("dashboard:info:response", info, room=sid)
+
+        except Exception as e:
+            self.logger.error(f"Error getting dashboard info: {e}")
+            await self.sio.emit(
+                "dashboard:error", {"error": f"Info error: {e!s}"}, room=sid
+            )
+
+    async def handle_ping(self, sid: str, data: Dict):
+        """Handle ping request.
+
+        Args:
+            sid: Socket.IO session ID
+            data: Request data
+        """
+        try:
+            timestamp = data.get("timestamp", asyncio.get_event_loop().time())
+
+            await self.sio.emit(
+                "dashboard:pong",
+                {
+                    "timestamp": timestamp,
+                    "server_time": asyncio.get_event_loop().time(),
+                },
+                room=sid,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error handling ping: {e}")
+
+    async def handle_client_register(self, sid: str, data: Dict):
+        """Handle client registration.
+
+        Args:
+            sid: Socket.IO session ID
+            data: Client registration data
+        """
+        try:
+            client_name = data.get("name", f"Client-{sid[:8]}")
+            client_type = data.get("type", "dashboard")
+
+            # Update client info
+            if sid in self.client_info:
+                self.client_info[sid].update(
+                    {"name": client_name, "type": client_type, "registered": True}
+                )
+
+            self.logger.info(f"Client registered: {client_name} ({client_type})")
+
+            await self.sio.emit(
+                "client:registered",
+                {"name": client_name, "type": client_type, "session_id": sid},
+                room=sid,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error registering client: {e}")
+            await self.sio.emit(
+                "dashboard:error", {"error": f"Registration error: {e!s}"}, room=sid
+            )
+
+    async def handle_client_list(self, sid: str, data: Dict):
+        """Handle client list request.
+
+        Args:
+            sid: Socket.IO session ID
+            data: Request data
+        """
+        try:
+            client_list = []
+            for client_sid, info in self.client_info.items():
+                client_list.append(
+                    {
+                        "session_id": client_sid,
+                        "name": info.get("name", f"Client-{client_sid[:8]}"),
+                        "type": info.get("type", "unknown"),
+                        "connected_at": info.get("connected_at"),
+                        "registered": info.get("registered", False),
+                    }
+                )
+
+            await self.sio.emit(
+                "client:list:response",
+                {"clients": client_list, "total": len(client_list)},
+                room=sid,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error getting client list: {e}")
+            await self.sio.emit(
+                "dashboard:error", {"error": f"Client list error: {e!s}"}, room=sid
+            )
+
+    async def _broadcast_client_count(self):
+        """Broadcast client count update to all connected clients."""
+        try:
+            await self.sio.emit(
+                "dashboard:client:count", {"count": len(self.connected_clients)}
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error broadcasting client count: {e}")
+
+    def get_stats(self) -> Dict:
+        """Get handler statistics.
+
+        Returns:
+            Dictionary with handler stats
+        """
+        return {
+            "connected_clients": len(self.connected_clients),
+            "registered_clients": sum(
+                1 for info in self.client_info.values() if info.get("registered", False)
+            ),
+            "client_types": {},
+        }

claude_mpm/services/monitor/handlers/file.py

@@ -0,0 +1,264 @@
+"""
+File Handler for Unified Monitor Server
+========================================
+
+WHY: Provides file reading capabilities for the dashboard file viewer.
+This handler allows the dashboard to display file contents when users
+click on files in the code tree or other file references.
+
+DESIGN DECISIONS:
+- Secure file reading with path validation
+- Size limits to prevent memory issues
+- Compatible with UnifiedMonitorServer architecture
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import socketio
+
+from ....core.logging_config import get_logger
+from ....core.unified_paths import get_project_root
+
+
+class FileHandler:
+    """Socket.IO handler for file operations in the unified monitor server.
+
+    WHY: The dashboard needs to display file contents when users click on files,
+    but we must ensure secure file access with proper validation and size limits.
+    """
+
+    def __init__(self, sio: socketio.AsyncServer):
+        """Initialize the file handler.
+
+        Args:
+            sio: Socket.IO server instance
+        """
+        self.sio = sio
+        self.logger = get_logger(__name__)
+
+    def register(self):
+        """Register Socket.IO event handlers for file operations."""
+        self.logger.info("[FileHandler] Registering file event handlers")
+
+        @self.sio.event
+        async def read_file(sid, data):
+            """Handle file read requests from dashboard clients.
+
+            WHY: The dashboard needs to display file contents when users
+            click on files, but we must ensure secure file access with
+            proper validation and size limits.
+            """
+            self.logger.info(
+                f"[FileHandler] Received read_file event from {sid} with data: {data}"
+            )
+
+            try:
+                file_path = data.get("file_path")
+                working_dir = data.get("working_dir", Path.cwd())
+                max_size = data.get("max_size", 1024 * 1024)  # 1MB default limit
+
+                if not file_path:
+                    self.logger.warning(
+                        f"[FileHandler] Missing file_path in request from {sid}"
+                    )
+                    await self.sio.emit(
+                        "file_content_response",
+                        {
+                            "success": False,
+                            "error": "file_path is required",
+                            "file_path": file_path,
+                        },
+                        room=sid,
+                    )
+                    return
+
+                # Read the file safely
+                self.logger.info(
+                    f"[FileHandler] Reading file: {file_path} from working_dir: {working_dir}"
+                )
+                result = await self._read_file_safely(file_path, working_dir, max_size)
+
+                # Send the result back to the client
+                self.logger.info(
+                    f"[FileHandler] Sending file_content_response to {sid}, success: {result.get('success', False)}"
+                )
+                await self.sio.emit("file_content_response", result, room=sid)
+                self.logger.info(f"[FileHandler] Response sent successfully to {sid}")
+
+            except Exception as e:
+                self.logger.error(
+                    f"[FileHandler] Exception in read_file handler: {e}", exc_info=True
+                )
+                await self.sio.emit(
+                    "file_content_response",
+                    {
+                        "success": False,
+                        "error": str(e),
+                        "file_path": data.get("file_path", "unknown"),
+                    },
+                    room=sid,
+                )
+                self.logger.info(f"[FileHandler] Error response sent to {sid}")
+
+        self.logger.info("[FileHandler] File event handlers registered successfully")
+
+    async def _read_file_safely(
+        self,
+        file_path: str,
+        working_dir: Optional[str] = None,
+        max_size: int = 1024 * 1024,
+    ) -> Dict[str, Any]:
+        """Safely read file content with security checks.
+
+        WHY: File reading must be secure to prevent directory traversal attacks
+        and resource exhaustion. This method centralizes all security checks
+        and provides consistent error handling.
+
+        Args:
+            file_path: Path to the file to read
+            working_dir: Working directory (defaults to current directory)
+            max_size: Maximum file size in bytes
+
+        Returns:
+            dict: Response with success status, content, and metadata
+        """
+        try:
+            if working_dir is None:
+                working_dir = Path.cwd()
+
+            # Resolve absolute path based on working directory
+            file_path_obj = Path(file_path)
+            if not file_path_obj.is_absolute():
+                full_path = Path(working_dir) / file_path
+            else:
+                full_path = file_path_obj
+
+            # Security check: ensure file is within working directory or project
+            try:
+                real_path = full_path.resolve()
+                real_working_dir = Path(working_dir).resolve()
+
+                # Allow access to files within working directory or the project root
+                project_root = Path(get_project_root()).resolve()
+                allowed_paths = [real_working_dir, project_root]
+
+                is_allowed = any(
+                    str(real_path).startswith(str(allowed_path))
+                    for allowed_path in allowed_paths
+                )
+
+                if not is_allowed:
+                    return {
+                        "success": False,
+                        "error": "Access denied: file is outside allowed directories",
+                        "file_path": file_path,
+                    }
+
+            except Exception as path_error:
+                self.logger.error(f"Path validation error: {path_error}")
+                return {
+                    "success": False,
+                    "error": "Invalid file path",
+                    "file_path": file_path,
+                }
+
+            # Check if file exists
+            if not real_path.exists():
+                return {
+                    "success": False,
+                    "error": "File does not exist",
+                    "file_path": file_path,
+                }
+
+            # Check if it's a file (not directory)
+            if not real_path.is_file():
+                return {
+                    "success": False,
+                    "error": "Path is not a file",
+                    "file_path": file_path,
+                }
+
+            # Check file size
+            file_size = real_path.stat().st_size
+            if file_size > max_size:
+                return {
+                    "success": False,
+                    "error": f"File too large ({file_size} bytes). Maximum allowed: {max_size} bytes",
+                    "file_path": file_path,
+                    "file_size": file_size,
+                }
+
+            # Read file content
+            try:
+                with Path(real_path).open(
+                    encoding="utf-8",
+                ) as f:
+                    content = f.read()
+
+                # Get file extension for syntax highlighting hint
+                ext = real_path.suffix
+
+                return {
+                    "success": True,
+                    "file_path": file_path,
+                    "content": content,
+                    "file_size": file_size,
+                    "extension": ext.lower(),
+                    "encoding": "utf-8",
+                }
+
+            except UnicodeDecodeError:
+                # Try reading as binary if UTF-8 fails
+                return self._read_binary_file(real_path, file_path, file_size)
+
+        except Exception as e:
+            self.logger.error(f"Error in _read_file_safely: {e}")
+            return {"success": False, "error": str(e), "file_path": file_path}
+
+    def _read_binary_file(
+        self, real_path: Path, file_path: str, file_size: int
+    ) -> Dict[str, Any]:
+        """Handle binary or non-UTF8 files.
+
+        WHY: Not all files are UTF-8 encoded. We need to handle other
+        encodings gracefully and detect binary files that shouldn't
+        be displayed as text.
+        """
+        try:
+            with real_path.open("rb") as f:
+                binary_content = f.read()
+
+            # Check if it's a text file by looking for common text patterns
+            try:
+                text_content = binary_content.decode("latin-1")
+                if "\x00" in text_content:
+                    # Binary file
+                    return {
+                        "success": False,
+                        "error": "File appears to be binary and cannot be displayed as text",
+                        "file_path": file_path,
+                        "file_size": file_size,
+                    }
+                # Text file with different encoding
+                ext = real_path.suffix
+                return {
+                    "success": True,
+                    "file_path": file_path,
+                    "content": text_content,
+                    "file_size": file_size,
+                    "extension": ext.lower(),
+                    "encoding": "latin-1",
+                }
+            except Exception:
+                return {
+                    "success": False,
+                    "error": "File encoding not supported",
+                    "file_path": file_path,
+                }
+        except Exception as read_error:
+            return {
+                "success": False,
+                "error": f"Failed to read file: {read_error!s}",
+                "file_path": file_path,
+            }