claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/socketio/handlers/connection.py

@@ -8,11 +8,15 @@ from other handlers makes connection management more maintainable.
 import asyncio
 import functools
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional
 
+from claude_mpm.core.logging_utils import get_logger
+
 from .base import BaseEventHandler
 
+logger = get_logger(__name__)
+
 
 def timeout_handler(timeout_seconds: float = 5.0):
     """Decorator to add timeout protection to async handlers.
@@ -39,49 +43,26 @@ def timeout_handler(timeout_seconds: float = 5.0):
 
                 elapsed = time.time() - start_time
                 if elapsed > timeout_seconds * 0.8:  # Warn if close to timeout
-                    # Try to get logger from closure scope or fallback to print
-                    try:
-                        import logging
-
-                        logger = logging.getLogger(__name__)
-                        logger.warning(
-                            f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
-                            f"(close to {timeout_seconds}s timeout)"
-                        )
-                    except:
-                        print(
-                            f"⚠️ Handler {handler_name} took {elapsed:.2f}s (close to {timeout_seconds}s timeout)"
-                        )
+                    logger.warning(
+                        f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
+                        f"(close to {timeout_seconds}s timeout)"
+                    )
 
                 return result
 
             except asyncio.TimeoutError:
                 elapsed = time.time() - start_time
-                # Try to get logger from closure scope or fallback to print
-                try:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.error(
-                        f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
-                    )
-                except:
-                    print(f"❌ Handler {handler_name} timed out after {elapsed:.2f}s")
+                logger.error(
+                    f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
+                )
 
                 return None
 
             except Exception as e:
                 elapsed = time.time() - start_time
-                # Try to get logger from closure scope or fallback to print
-                try:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.error(
-                        f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
-                    )
-                except:
-                    print(f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}")
+                logger.error(
+                    f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
+                )
                 raise
 
         return wrapper
@@ -274,7 +255,7 @@ class ConnectionEventHandler(BaseEventHandler):
             # Force disconnect if still connected
             try:
                 await self.sio.disconnect(sid)
-            except:
+            except Exception:
                 pass  # Already disconnected
 
             self.logger.info(f"🔌 Cleaned up stale connection: {sid}")
@@ -326,7 +307,7 @@ class ConnectionEventHandler(BaseEventHandler):
             status_data = {
                 "type": "connection",
                 "subtype": "status",
-                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                 "source": "server",
                 "session_id": self.server.session_id,
                 "data": {
@@ -348,13 +329,13 @@ class ConnectionEventHandler(BaseEventHandler):
                     {
                         "type": "connection",
                         "subtype": "welcome",
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                         "source": "server",
                         "session_id": self.server.session_id,
                         "data": {
                             "message": "Connected to Claude MPM Socket.IO server",
                             "client_id": sid,
-                            "server_time": datetime.utcnow().isoformat() + "Z",
+                            "server_time": datetime.now(timezone.utc).isoformat() + "Z",
                             "build_info": monitor_build_info,
                         },
                     },
@@ -401,7 +382,7 @@ class ConnectionEventHandler(BaseEventHandler):
             status_data = {
                 "type": "connection",
                 "subtype": "status",
-                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                 "source": "server",
                 "session_id": self.server.session_id,
                 "data": {
@@ -456,7 +437,7 @@ class ConnectionEventHandler(BaseEventHandler):
                 {
                     "type": "connection",
                     "subtype": "subscribed",
-                    "timestamp": datetime.utcnow().isoformat() + "Z",
+                    "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                     "source": "server",
                     "data": {"channels": channels},
                 },

claude_mpm/services/socketio/handlers/connection_handler.py

@@ -8,7 +8,7 @@ DESIGN DECISION: Centralized connection event handling ensures consistent
 state management and provides resilient event delivery across reconnections.
 """
 
-from datetime import datetime
+from datetime import datetime, timezone
 
 from .base import BaseEventHandler
 
@@ -50,7 +50,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     # Store client info
                     self.server.client_info[sid] = {
                         "client_id": conn.client_id,
-                        "connected_at": datetime.now().isoformat(),
+                        "connected_at": datetime.now(timezone.utc).isoformat(),
                         "user_agent": environ.get("HTTP_USER_AGENT", "unknown"),
                         "remote_addr": environ.get("REMOTE_ADDR", "unknown"),
                     }
@@ -61,7 +61,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                         {
                             "client_id": conn.client_id,
                             "sid": sid,
-                            "timestamp": datetime.now().isoformat(),
+                            "timestamp": datetime.now(timezone.utc).isoformat(),
                             "server_version": self.get_server_version(),
                         },
                         room=sid,
@@ -120,7 +120,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     self.server.stats["connections_total"] += 1
 
                     self.server.client_info[sid] = {
-                        "connected_at": datetime.now().isoformat(),
+                        "connected_at": datetime.now(timezone.utc).isoformat(),
                         "user_agent": environ.get("HTTP_USER_AGENT", "unknown"),
                         "remote_addr": environ.get("REMOTE_ADDR", "unknown"),
                     }
@@ -177,7 +177,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
         async def ping(sid):
             """Handle ping from client for health monitoring."""
             try:
-                # Update activity in connection manager
+                # Update activity in connection manager - CRITICAL for preventing stale connections
                 if self.server.connection_manager:
                     await self.server.connection_manager.update_activity(sid, "ping")
 
@@ -185,8 +185,8 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                 await sio.emit(
                     "pong",
                     {
-                        "timestamp": datetime.now().isoformat(),
-                        "server_time": datetime.now().timestamp(),
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                        "server_time": datetime.now(timezone.utc).timestamp(),
                     },
                     room=sid,
                 )
@@ -210,7 +210,10 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     # Optional: Send confirmation
                     await sio.emit(
                         "ack_confirmed",
-                        {"sequence": sequence, "timestamp": datetime.now().isoformat()},
+                        {
+                            "sequence": sequence,
+                            "timestamp": datetime.now(timezone.utc).isoformat(),
+                        },
                         room=sid,
                     )
 
@@ -263,7 +266,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
             """Get connection statistics for debugging."""
             try:
                 stats = {
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "total_connections": len(self.server.connected_clients),
                     "server_stats": self.server.stats,
                 }
@@ -293,23 +296,8 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
             except Exception as e:
                 self.logger.error(f"Error getting connection stats for {sid}: {e}")
 
-        @sio.event
-        async def heartbeat(sid):
-            """Handle client heartbeat for connection monitoring."""
-            try:
-                # Update activity
-                if self.server.connection_manager:
-                    await self.server.connection_manager.update_activity(sid, "event")
-
-                # Send heartbeat response
-                await sio.emit(
-                    "heartbeat_response",
-                    {"timestamp": datetime.now().isoformat(), "status": "alive"},
-                    room=sid,
-                )
-
-            except Exception as e:
-                self.logger.error(f"Error handling heartbeat from {sid}: {e}")
+        # Heartbeat handler removed - Using Socket.IO's built-in ping/pong instead
+        # This prevents conflicting heartbeat systems that can cause disconnections
 
         self.logger.info("Enhanced connection event handlers registered")
 
@@ -327,7 +315,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     if self.server.stats.get("start_time")
                     else None
                 ),
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             }
 
             await self.server.core.sio.emit("server_status", status_data, room=sid)
@@ -341,5 +329,5 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
             from claude_mpm.services.version_service import VersionService
 
             return VersionService().get_version()
-        except:
+        except Exception:
             return "unknown"

claude_mpm/services/socketio/handlers/file.py

@@ -5,7 +5,6 @@ safely with security checks. Separating file operations improves security
 auditing and makes it easier to add file-related features.
 """
 
-import os
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -24,6 +23,12 @@ class FileEventHandler(BaseEventHandler):
 
     def register_events(self) -> None:
         """Register file operation event handlers."""
+        self.logger.info(
+            "[FileEventHandler] Starting registration of read_file event handler"
+        )
+
+        # Capture self reference to avoid closure issues
+        handler_self = self
 
         @self.sio.event
         async def read_file(sid, data):
@@ -33,13 +38,19 @@ class FileEventHandler(BaseEventHandler):
             click on files, but we must ensure secure file access with
             proper validation and size limits.
             """
+            handler_self.logger.info(
+                f"[FileEventHandler] Received read_file event from {sid} with data: {data}"
+            )
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
                 max_size = data.get("max_size", 1024 * 1024)  # 1MB default limit
 
                 if not file_path:
-                    await self.emit_to_client(
+                    handler_self.logger.warning(
+                        f"[FileEventHandler] Missing file_path in request from {sid}"
+                    )
+                    await handler_self.emit_to_client(
                         sid,
                         "file_content_response",
                         {
@@ -51,14 +62,29 @@ class FileEventHandler(BaseEventHandler):
                     return
 
                 # Use the shared file reading logic
-                result = await self._read_file_safely(file_path, working_dir, max_size)
+                handler_self.logger.info(
+                    f"[FileEventHandler] Reading file: {file_path} from working_dir: {working_dir}"
+                )
+                result = await handler_self._read_file_safely(
+                    file_path, working_dir, max_size
+                )
 
                 # Send the result back to the client
-                await self.emit_to_client(sid, "file_content_response", result)
+                handler_self.logger.info(
+                    f"[FileEventHandler] Sending file_content_response to {sid}, success: {result.get('success', False)}"
+                )
+                await handler_self.emit_to_client(sid, "file_content_response", result)
+                handler_self.logger.info(
+                    f"[FileEventHandler] Response sent successfully to {sid}"
+                )
 
             except Exception as e:
-                self.log_error("read_file", e, data)
-                await self.emit_to_client(
+                handler_self.logger.error(
+                    f"[FileEventHandler] Exception in read_file handler: {e}",
+                    exc_info=True,
+                )
+                handler_self.log_error("read_file", e, data)
+                await handler_self.emit_to_client(
                     sid,
                     "file_content_response",
                     {
@@ -67,6 +93,14 @@ class FileEventHandler(BaseEventHandler):
                         "file_path": data.get("file_path", "unknown"),
                     },
                 )
+                handler_self.logger.info(
+                    f"[FileEventHandler] Error response sent to {sid}"
+                )
+
+        # Log successful registration
+        self.logger.info(
+            "[FileEventHandler] read_file event handler registered successfully"
+        )
 
     async def _read_file_safely(
         self,
@@ -90,7 +124,7 @@ class FileEventHandler(BaseEventHandler):
         """
         try:
             if working_dir is None:
-                working_dir = os.getcwd()
+                working_dir = Path.cwd()
 
             # Resolve absolute path based on working directory
             file_path_obj = Path(file_path)
@@ -156,7 +190,9 @@ class FileEventHandler(BaseEventHandler):
 
             # Read file content
             try:
-                with open(real_path, encoding="utf-8") as f:
+                with Path(real_path).open(
+                    encoding="utf-8",
+                ) as f:
                     content = f.read()
 
                 # Get file extension for syntax highlighting hint
@@ -189,7 +225,7 @@ class FileEventHandler(BaseEventHandler):
         be displayed as text.
         """
         try:
-            with open(real_path, "rb") as f:
+            with real_path.open("rb") as f:
                 binary_content = f.read()
 
             # Check if it's a text file by looking for common text patterns

claude_mpm/services/socketio/handlers/git.py

@@ -106,7 +106,7 @@ class GitEventHandler(BaseEventHandler):
             """
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
 
                 if not file_path:
                     await self.emit_to_client(
@@ -162,7 +162,7 @@ class GitEventHandler(BaseEventHandler):
             """
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
 
                 # Debug: check_git_status called
 
@@ -287,7 +287,7 @@ class GitEventHandler(BaseEventHandler):
             """
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
 
                 # Debug: git_add_file called
 
@@ -389,7 +389,7 @@ class GitEventHandler(BaseEventHandler):
         if working_dir in invalid_states or (
             isinstance(working_dir, str) and working_dir.strip() == ""
         ):
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
             self.logger.info(
                 f"[{operation}] working_dir was invalid ({original_working_dir!r}), using cwd: {working_dir}"
             )
@@ -404,7 +404,7 @@ class GitEventHandler(BaseEventHandler):
                 self.logger.warning(
                     f"[{operation}] working_dir contains null bytes, using cwd instead"
                 )
-                working_dir = os.getcwd()
+                working_dir = Path.cwd()
 
         return working_dir
 
@@ -640,7 +640,7 @@ class GitEventHandler(BaseEventHandler):
 
             # Handle case where working_dir is None, empty string, or 'Unknown'
             if not working_dir or working_dir == "Unknown" or working_dir.strip() == "":
-                working_dir = os.getcwd()
+                working_dir = Path.cwd()
                 # Debug: working_dir was invalid, using cwd
             else:
                 # Debug: Using provided working_dir
@@ -648,7 +648,7 @@ class GitEventHandler(BaseEventHandler):
 
             # For read-only git operations, we can work from any directory
             # by passing the -C flag to git commands instead of changing directories
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             try:
                 # We'll use git -C <working_dir> for all commands instead of chdir
 
@@ -792,7 +792,7 @@ class GitEventHandler(BaseEventHandler):
                         stdout=asyncio.subprocess.PIPE,
                         stderr=asyncio.subprocess.PIPE,
                     )
-                    diff_output, diff_error = await diff_proc.communicate()
+                    diff_output, _diff_error = await diff_proc.communicate()
 
                     if diff_proc.returncode == 0:
                         return {

claude_mpm/services/socketio/handlers/hook.py

@@ -4,9 +4,10 @@ WHY: This module handles hook events from Claude to track session information,
 agent delegations, and other hook-based activity for the system heartbeat.
 """
 
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict
 
+from ....core.enums import ServiceState
 from .base import BaseEventHandler
 
 
@@ -60,13 +61,18 @@ class HookEventHandler(BaseEventHandler):
 
         hook_data = data.get("data", {})
 
+        # Log hook event processing
+        tool_name = hook_data.get("tool_name", "N/A")
+        self.logger.info(f"Processing hook event: {hook_event} - tool: {tool_name}")
+
         # Create properly formatted event for history
         # Note: add_to_history expects the event data directly, not wrapped
         history_event = {
             "type": "hook",
             "event": hook_event,
             "data": hook_data,
-            "timestamp": data.get("timestamp") or datetime.now().isoformat(),
+            "timestamp": data.get("timestamp")
+            or datetime.now(timezone.utc).isoformat(),
         }
 
         # Add the event to history for replay
@@ -75,6 +81,12 @@ class HookEventHandler(BaseEventHandler):
 
         # Broadcast the original event to all connected clients
         # (preserves all original fields)
+        connected_clients = (
+            len(self.server.clients) if hasattr(self.server, "clients") else 0
+        )
+        self.logger.info(
+            f"Broadcasting claude_event to {connected_clients} clients: {hook_event}"
+        )
         await self.broadcast_event("claude_event", data)
 
         # Track sessions based on hook events
@@ -105,11 +117,11 @@ class HookEventHandler(BaseEventHandler):
         if hasattr(self.server, "active_sessions"):
             self.server.active_sessions[session_id] = {
                 "session_id": session_id,
-                "start_time": datetime.now().isoformat(),
+                "start_time": datetime.now(timezone.utc).isoformat(),
                 "agent": agent_type,
-                "status": "active",
+                "status": ServiceState.RUNNING,
                 "prompt": data.get("prompt", "")[:100],  # First 100 chars
-                "last_activity": datetime.now().isoformat(),
+                "last_activity": datetime.now(timezone.utc).isoformat(),
             }
 
             self.logger.debug(
@@ -132,9 +144,9 @@ class HookEventHandler(BaseEventHandler):
             if session_id in self.server.active_sessions:
                 # Mark as completed rather than removing immediately
                 self.server.active_sessions[session_id]["status"] = "completed"
-                self.server.active_sessions[session_id][
-                    "last_activity"
-                ] = datetime.now().isoformat()
+                self.server.active_sessions[session_id]["last_activity"] = datetime.now(
+                    timezone.utc
+                ).isoformat()
 
                 self.logger.debug(
                     f"Marked session completed: session={session_id[:8]}..."
@@ -156,18 +168,18 @@ class HookEventHandler(BaseEventHandler):
             if session_id not in self.server.active_sessions:
                 self.server.active_sessions[session_id] = {
                     "session_id": session_id,
-                    "start_time": datetime.now().isoformat(),
+                    "start_time": datetime.now(timezone.utc).isoformat(),
                     "agent": "pm",  # Default to PM
-                    "status": "active",
+                    "status": ServiceState.RUNNING,
                     "prompt": data.get("prompt_text", "")[:100],
                     "working_directory": data.get("working_directory", ""),
-                    "last_activity": datetime.now().isoformat(),
+                    "last_activity": datetime.now(timezone.utc).isoformat(),
                 }
             else:
                 # Update last activity
-                self.server.active_sessions[session_id][
-                    "last_activity"
-                ] = datetime.now().isoformat()
+                self.server.active_sessions[session_id]["last_activity"] = datetime.now(
+                    timezone.utc
+                ).isoformat()
 
     async def _handle_pre_tool(self, data: Dict[str, Any]):
         """Handle pre-tool events.
@@ -190,9 +202,9 @@ class HookEventHandler(BaseEventHandler):
             if session_id in self.server.active_sessions:
                 self.server.active_sessions[session_id]["agent"] = agent_type
                 self.server.active_sessions[session_id]["status"] = "delegated"
-                self.server.active_sessions[session_id][
-                    "last_activity"
-                ] = datetime.now().isoformat()
+                self.server.active_sessions[session_id]["last_activity"] = datetime.now(
+                    timezone.utc
+                ).isoformat()
 
                 self.logger.debug(
                     f"Updated session delegation: session={session_id[:8]}..., agent={agent_type}"

claude_mpm/services/socketio/handlers/registry.py

@@ -15,6 +15,8 @@ if TYPE_CHECKING:
 
     from ..server import SocketIOServer
 
+# DISABLED: File Tree interface removed from dashboard
+# from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -37,6 +39,8 @@ class EventHandlerRegistry:
         HookEventHandler,  # Hook events for session tracking
         GitEventHandler,  # Git operations
         FileEventHandler,  # File operations
+        # DISABLED: File Tree interface removed from dashboard
+        # CodeAnalysisEventHandler,  # Code analysis for dashboard
         ProjectEventHandler,  # Project management (future)
         MemoryEventHandler,  # Memory management (future)
     ]