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

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

claude_mpm/services/socketio/monitor_client.py

@@ -0,0 +1,364 @@
+"""
+SocketIO Monitor Client for claude-mpm dashboard.
+
+WHY: This module provides a SocketIO client that connects the dashboard to the
+independent monitor server, allowing the dashboard to receive events even when
+running as a separate service.
+
+DESIGN DECISIONS:
+- Asynchronous client using python-socketio AsyncClient
+- Automatic reconnection with exponential backoff
+- Event relay from monitor to dashboard UI
+- Graceful degradation when monitor is not available
+- Health monitoring and connection status reporting
+"""
+
+import asyncio
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict
+
+try:
+    import socketio
+
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+
+import contextlib
+
+from ...core.logging_config import get_logger
+
+
+class MonitorClient:
+    """SocketIO client for connecting dashboard to monitor server.
+
+    WHY: This client allows the dashboard service to receive events from
+    the monitor server, enabling decoupled architecture where:
+    - Monitor server (port 8766) collects events from hooks
+    - Dashboard service (port 8765) provides UI and connects to monitor
+    - Dashboard can restart without affecting event collection
+    - Multiple dashboards can connect to the same monitor
+    """
+
+    def __init__(
+        self,
+        monitor_host: str = "localhost",
+        monitor_port: int = 8766,
+        auto_reconnect: bool = True,
+    ):
+        self.monitor_host = monitor_host
+        self.monitor_port = monitor_port
+        self.monitor_url = f"http://{monitor_host}:{monitor_port}"
+        self.auto_reconnect = auto_reconnect
+
+        self.logger = get_logger(__name__ + ".MonitorClient")
+
+        # Client state
+        self.client = None
+        self.connected = False
+        self.connecting = False
+        self.should_stop = False
+        self.connection_thread = None
+        self.reconnect_task = None
+
+        # Event handlers - functions to call when events are received
+        self.event_handlers: Dict[str, Callable] = {}
+
+        # Connection statistics
+        self.stats = {
+            "connection_attempts": 0,
+            "successful_connections": 0,
+            "events_received": 0,
+            "last_connected": None,
+            "last_disconnected": None,
+            "auto_reconnect_enabled": auto_reconnect,
+        }
+
+        # Reconnection settings
+        self.reconnect_delay = 1.0  # Start with 1 second
+        self.max_reconnect_delay = 30.0  # Max 30 seconds between attempts
+        self.reconnect_backoff = 1.5  # Exponential backoff multiplier
+
+    def start(self) -> bool:
+        """Start the monitor client and connect to monitor server."""
+        if not SOCKETIO_AVAILABLE:
+            self.logger.error("SocketIO not available - monitor client cannot start")
+            return False
+
+        if self.connected or self.connecting:
+            self.logger.info("Monitor client already connected or connecting")
+            return True
+
+        self.logger.info(f"Starting monitor client connection to {self.monitor_url}")
+        self.should_stop = False
+
+        # Start connection in background thread
+        self.connection_thread = threading.Thread(
+            target=self._run_client, daemon=True, name="MonitorClient"
+        )
+        self.connection_thread.start()
+
+        # Wait a moment for initial connection attempt
+        time.sleep(1)
+        return self.connecting or self.connected
+
+    def stop(self):
+        """Stop the monitor client and disconnect."""
+        self.logger.info("Stopping monitor client")
+        self.should_stop = True
+
+        if self.reconnect_task:
+            with contextlib.suppress(Exception):
+                self.reconnect_task.cancel()
+
+        if self.client and self.connected:
+            try:
+                # Use the event loop from the client thread
+                if hasattr(self.client, "disconnect"):
+                    asyncio.run(self.client.disconnect())
+            except Exception:
+                pass
+
+        self.connected = False
+        self.connecting = False
+
+        # Wait for thread to finish
+        if self.connection_thread and self.connection_thread.is_alive():
+            self.connection_thread.join(timeout=5)
+
+    def add_event_handler(self, event_name: str, handler: Callable):
+        """Add an event handler for a specific event type."""
+        self.event_handlers[event_name] = handler
+        self.logger.debug(f"Added event handler for '{event_name}'")
+
+    def remove_event_handler(self, event_name: str):
+        """Remove an event handler."""
+        if event_name in self.event_handlers:
+            del self.event_handlers[event_name]
+            self.logger.debug(f"Removed event handler for '{event_name}'")
+
+    def is_connected(self) -> bool:
+        """Check if client is connected to monitor."""
+        return self.connected
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get client connection statistics."""
+        return {
+            **self.stats,
+            "connected": self.connected,
+            "monitor_url": self.monitor_url,
+            "uptime": (
+                (
+                    datetime.now(timezone.utc)
+                    - datetime.fromisoformat(self.stats["last_connected"])
+                ).total_seconds()
+                if self.stats["last_connected"] and self.connected
+                else 0
+            ),
+        }
+
+    def _run_client(self):
+        """Run the client in its own event loop."""
+        try:
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            # Run the async client
+            loop.run_until_complete(self._run_client_async())
+
+        except Exception as e:
+            self.logger.error(f"Error in monitor client thread: {e}")
+        finally:
+            self.connected = False
+            self.connecting = False
+
+    async def _run_client_async(self):
+        """Run the async client with reconnection logic."""
+        while not self.should_stop:
+            try:
+                await self._connect_to_monitor()
+
+                if self.connected:
+                    # Wait for disconnection or stop signal
+                    while self.connected and not self.should_stop:
+                        await asyncio.sleep(1)
+
+                # Handle reconnection
+                if not self.should_stop and self.auto_reconnect:
+                    await self._handle_reconnection()
+                else:
+                    break
+
+            except Exception as e:
+                self.logger.error(f"Error in monitor client loop: {e}")
+                if not self.auto_reconnect:
+                    break
+                await asyncio.sleep(self.reconnect_delay)
+
+    async def _connect_to_monitor(self):
+        """Establish connection to monitor server."""
+        try:
+            self.connecting = True
+            self.stats["connection_attempts"] += 1
+
+            self.logger.info(f"Connecting to monitor server at {self.monitor_url}")
+
+            # Create new SocketIO client
+            self.client = socketio.AsyncClient(
+                logger=False,
+                engineio_logger=False,
+                reconnection=False,  # We handle reconnection ourselves
+            )
+
+            # Register event handlers
+            self._register_client_events()
+
+            # Connect to monitor server
+            await self.client.connect(self.monitor_url)
+
+            # Connection successful
+            self.connected = True
+            self.connecting = False
+            self.stats["successful_connections"] += 1
+            self.stats["last_connected"] = datetime.now(timezone.utc).isoformat()
+            self.reconnect_delay = 1.0  # Reset reconnect delay on successful connection
+
+            self.logger.info(f"Connected to monitor server at {self.monitor_url}")
+
+            # Request status from monitor
+            await self.client.emit("get_status")
+
+        except Exception as e:
+            self.logger.error(f"Failed to connect to monitor server: {e}")
+            self.connected = False
+            self.connecting = False
+
+            if self.client:
+                with contextlib.suppress(Exception):
+                    await self.client.disconnect()
+                self.client = None
+
+    def _register_client_events(self):
+        """Register client-side event handlers."""
+
+        @self.client.event
+        async def connect():
+            """Handle successful connection."""
+            self.logger.info("Successfully connected to monitor server")
+
+        @self.client.event
+        async def disconnect():
+            """Handle disconnection."""
+            self.logger.info("Disconnected from monitor server")
+            self.connected = False
+            self.stats["last_disconnected"] = datetime.now(timezone.utc).isoformat()
+
+        @self.client.event
+        async def connect_error(data):
+            """Handle connection error."""
+            self.logger.error(f"Connection error: {data}")
+            self.connected = False
+
+        @self.client.event
+        async def status_response(data):
+            """Handle status response from monitor."""
+            self.logger.debug(f"Monitor server status: {data}")
+
+        # Register handlers for all monitor events that we want to relay
+        monitor_events = [
+            "session_started",
+            "session_ended",
+            "claude_status",
+            "claude_output",
+            "agent_delegated",
+            "todos_updated",
+            "ticket_created",
+            "memory_loaded",
+            "memory_created",
+            "memory_updated",
+            "memory_injected",
+            "file_changed",
+            "git_status_changed",
+            "project_analyzed",
+            "connection_status",
+            "heartbeat",
+        ]
+
+        for event_name in monitor_events:
+            # Create a closure to capture the event name
+            def make_handler(event_name):
+                async def handler(data):
+                    await self._handle_monitor_event(event_name, data)
+
+                return handler
+
+            self.client.on(event_name, make_handler(event_name))
+
+    async def _handle_monitor_event(self, event_name: str, data: Any):
+        """Handle event received from monitor server."""
+        self.stats["events_received"] += 1
+        self.logger.debug(f"Received event from monitor: {event_name}")
+
+        # Call registered event handler if available
+        if event_name in self.event_handlers:
+            try:
+                handler = self.event_handlers[event_name]
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(data)
+                else:
+                    handler(data)
+            except Exception as e:
+                self.logger.error(f"Error in event handler for {event_name}: {e}")
+
+    async def _handle_reconnection(self):
+        """Handle reconnection with exponential backoff."""
+        if self.should_stop:
+            return
+
+        self.logger.info(
+            f"Attempting to reconnect in {self.reconnect_delay:.1f} seconds"
+        )
+
+        try:
+            await asyncio.sleep(self.reconnect_delay)
+
+            # Increase reconnect delay for next attempt (exponential backoff)
+            self.reconnect_delay = min(
+                self.reconnect_delay * self.reconnect_backoff, self.max_reconnect_delay
+            )
+
+        except asyncio.CancelledError:
+            # Sleep was cancelled, probably due to stop()
+            pass
+
+    def send_to_monitor(self, event_name: str, data: Any = None) -> bool:
+        """Send an event to the monitor server."""
+        if not self.connected or not self.client:
+            self.logger.warning(
+                f"Cannot send event '{event_name}' - not connected to monitor"
+            )
+            return False
+
+        try:
+            # Schedule the emission in the client's event loop
+            if hasattr(self.client, "emit"):
+                # Create a simple coroutine to emit the event
+                async def emit_event():
+                    await self.client.emit(event_name, data)
+
+                # Run it in the client's event loop if available
+                if hasattr(self.client, "eio") and hasattr(self.client.eio, "loop"):
+                    loop = self.client.eio.loop
+                    if loop and not loop.is_closed():
+                        asyncio.run_coroutine_threadsafe(emit_event(), loop)
+                        return True
+
+            return False
+
+        except Exception as e:
+            self.logger.error(f"Error sending event to monitor: {e}")
+            return False

claude_mpm/services/socketio/server/broadcaster.py

@@ -13,7 +13,7 @@ import asyncio
 import time
 from collections import deque
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Deque, Dict, List, Optional, Set
 
 from ..event_normalizer import EventNormalizer
@@ -284,7 +284,7 @@ class SocketIOEventBroadcaster:
             # Reconstruct the raw event
             raw_event = {
                 "type": event.event_type,
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "data": {**event.data, "retry_attempt": event.attempt_count + 1},
             }
 
@@ -323,7 +323,7 @@ class SocketIOEventBroadcaster:
         # Create raw event for normalization
         raw_event = {
             "type": event_type,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "data": data,
         }
 
@@ -388,11 +388,11 @@ class SocketIOEventBroadcaster:
                             asyncio.run_coroutine_threadsafe(
                                 update_activities(), self.loop
                             )
-                        except:
+                        except Exception:
                             pass  # Non-critical
 
                     self.logger.debug(f"Broadcasted event: {event_type}")
-                except:
+                except Exception:
                     # Will be added to retry queue below
                     pass
             else:
@@ -426,13 +426,15 @@ class SocketIOEventBroadcaster:
                 "session_id": session_id,
                 "launch_method": launch_method,
                 "working_dir": working_dir,
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             },
         )
 
     def session_ended(self):
         """Notify that a session has ended."""
-        self.broadcast_event("session_ended", {"timestamp": datetime.now().isoformat()})
+        self.broadcast_event(
+            "session_ended", {"timestamp": datetime.now(timezone.utc).isoformat()}
+        )
 
     def claude_status_changed(
         self, status: str, pid: Optional[int] = None, message: str = ""

claude_mpm/services/socketio/server/connection_manager.py

@@ -14,7 +14,7 @@ import contextlib
 import time
 from collections import deque
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from typing import Any, Deque, Dict, List, Optional
 from uuid import uuid4
@@ -464,7 +464,7 @@ class ConnectionManager:
         async with self._lock:
             now = time.time()
             report = {
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "total_connections": len(self.connections),
                 "healthy": 0,
                 "stale": 0,