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

claude_mpm/services/socketio/client_proxy.py

@@ -13,7 +13,7 @@ organization and to reduce the complexity of the main server file.
 import asyncio
 import threading
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 try:
@@ -24,6 +24,8 @@ except ImportError:
     SOCKETIO_AVAILABLE = False
     socketio = None
 
+import contextlib
+
 from ...core.logging_config import get_logger
 
 
@@ -45,6 +47,22 @@ class SocketIOClientProxy:
         self._client_thread = None
         self._client_loop = None
 
+    def start(self):
+        """Start the Socket.IO client connection (compatibility wrapper).
+
+        This method exists for backward compatibility with code that expects
+        a start() method. It simply calls start_sync().
+        """
+        return self.start_sync()
+
+    def stop(self):
+        """Stop the Socket.IO client connection (compatibility wrapper).
+
+        This method exists for backward compatibility with code that expects
+        a stop() method. It simply calls stop_sync().
+        """
+        return self.stop_sync()
+
     def start_sync(self):
         """Start the Socket.IO client connection to the persistent server."""
         self.logger.debug(
@@ -92,15 +110,52 @@ class SocketIOClientProxy:
             async def disconnect():
                 self.logger.info("SocketIOClientProxy: Disconnected from server")
 
-            # Connect to the server
-            await self._sio_client.connect(f"http://127.0.0.1:{self.port}")
+            # Try connecting with different hostname formats
+            # Some systems resolve localhost differently than 127.0.0.1
+            connection_urls = [
+                f"http://{self.host}:{self.port}",  # Use the provided host (usually "localhost")
+                f"http://127.0.0.1:{self.port}",  # Try IP address
+                f"http://localhost:{self.port}",  # Try localhost explicitly
+            ]
+
+            connected = False
+            last_error = None
+
+            for url in connection_urls:
+                try:
+                    self.logger.debug(
+                        f"SocketIOClientProxy: Attempting connection to {url}"
+                    )
+                    await self._sio_client.connect(url)
+                    connected = True
+                    self.logger.info(
+                        f"SocketIOClientProxy: Successfully connected to {url}"
+                    )
+                    break
+                except Exception as e:
+                    last_error = e
+                    # Only log as debug to avoid confusion when fallback succeeds
+                    self.logger.debug(
+                        f"SocketIOClientProxy: Failed to connect to {url}: {e}"
+                    )
+                    # Disconnect any partial connection before trying next URL
+                    with contextlib.suppress(Exception):
+                        await self._sio_client.disconnect()
+
+            if not connected:
+                # Only show error if all attempts failed
+                self.logger.error(
+                    f"SocketIOClientProxy: Connection error after trying all addresses: {last_error}"
+                )
+                self._sio_client = None
+                return
 
             # Keep the connection alive until stopped
             while self.running:
                 await asyncio.sleep(1)
 
         except Exception as e:
-            self.logger.error(f"SocketIOClientProxy: Connection error: {e}")
+            self.logger.error(f"SocketIOClientProxy: Unexpected error: {e}")
             self._sio_client = None
 
     def broadcast_event(self, event_type: str, data: Dict[str, Any]):
@@ -117,7 +172,7 @@ class SocketIOClientProxy:
             try:
                 event = {
                     "type": event_type,
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "data": data,
                 }
 

claude_mpm/services/socketio/dashboard_server.py

@@ -0,0 +1,361 @@
+"""
+Dashboard Server with Monitor Client Integration for claude-mpm.
+
+WHY: This module provides a dashboard server that connects to the independent
+monitor server as a client, enabling decoupled architecture where:
+- Dashboard provides UI on port 8765
+- Dashboard connects to monitor server on port 8766 for events
+- Dashboard can restart without affecting event collection
+- Multiple dashboards can connect to the same monitor
+
+DESIGN DECISIONS:
+- Extends existing SocketIOServer with monitor client integration
+- Provides UI functionality (HTTP server, static files, dashboard endpoints)
+- Graceful degradation when monitor server is unavailable
+- Event relay from monitor client to dashboard clients
+- Maintains backward compatibility with existing dashboard clients
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+try:
+    import aiohttp
+    import socketio
+    from aiohttp import web
+
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+    aiohttp = None
+    web = None
+
+from ...core.config import Config
+from ...core.logging_config import get_logger
+from ..core.interfaces.communication import SocketIOServiceInterface
+from .monitor_client import MonitorClient
+from .server.main import SocketIOServer
+
+
+class DashboardServer(SocketIOServiceInterface):
+    """Dashboard server that connects to monitor server and provides UI.
+
+    WHY: This server provides the dashboard UI while staying connected to
+    the monitor server for event data. This decoupling allows:
+    - Stable event collection in monitor server
+    - Dashboard can be restarted for updates without losing events
+    - Multiple dashboard instances can share the same monitor
+    - Dashboard focuses on UI, monitor focuses on event collection
+    """
+
+    def __init__(
+        self,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        monitor_host: Optional[str] = None,
+        monitor_port: Optional[int] = None,
+    ):
+        # Load configuration
+        config = Config()
+        dashboard_config = config.get("dashboard_server", {})
+
+        self.host = host or dashboard_config.get("host", "localhost")
+        self.port = port or dashboard_config.get("port", 8765)
+        self.monitor_host = monitor_host or dashboard_config.get(
+            "monitor_host", "localhost"
+        )
+        self.monitor_port = monitor_port or dashboard_config.get("monitor_port", 8766)
+
+        # Configuration-based settings
+        self.auto_connect_monitor = dashboard_config.get("auto_connect_monitor", True)
+        self.monitor_reconnect = dashboard_config.get("monitor_reconnect", True)
+        self.fallback_standalone = dashboard_config.get("fallback_standalone", True)
+
+        self.logger = get_logger(__name__ + ".DashboardServer")
+
+        # Dashboard server (provides UI and serves dashboard clients)
+        self.dashboard_server = SocketIOServer(host=self.host, port=self.port)
+
+        # Monitor client (connects to monitor server for events)
+        self.monitor_client = MonitorClient(
+            monitor_host=self.monitor_host,
+            monitor_port=self.monitor_port,
+            auto_reconnect=self.monitor_reconnect,
+        )
+
+        # Server state
+        self.running = False
+        self.stats = {
+            "start_time": None,
+            "dashboard_clients": 0,
+            "monitor_connected": False,
+            "events_relayed": 0,
+        }
+
+        # Setup event relay from monitor client to dashboard clients
+        self._setup_event_relay()
+
+    def start_sync(self):
+        """Start the dashboard server and connect to monitor."""
+        if not SOCKETIO_AVAILABLE:
+            self.logger.error("SocketIO not available - dashboard server cannot start")
+            return False
+
+        self.logger.info(f"Starting dashboard server on {self.host}:{self.port}")
+        self.logger.info(
+            f"Connecting to monitor server at {self.monitor_host}:{self.monitor_port}"
+        )
+
+        # Start the dashboard server (UI server)
+        self.dashboard_server.start_sync()
+
+        # Connect to monitor server for events (if auto-connect enabled)
+        monitor_connected = False
+        if self.auto_connect_monitor:
+            monitor_connected = self.monitor_client.start()
+        else:
+            self.logger.info("Auto-connect to monitor disabled by configuration")
+
+        if not monitor_connected:
+            self.logger.warning(
+                "Could not connect to monitor server - dashboard will run in standalone mode"
+            )
+
+        # Update state
+        self.running = self.dashboard_server.is_running()
+        if self.running:
+            self.stats["start_time"] = datetime.now(timezone.utc).isoformat()
+            self.stats["monitor_connected"] = monitor_connected
+
+        self.logger.info(
+            f"Dashboard server started successfully on {self.host}:{self.port} "
+            f"(monitor connected: {monitor_connected})"
+        )
+        return self.running
+
+    def stop_sync(self):
+        """Stop the dashboard server and disconnect from monitor."""
+        self.logger.info("Stopping dashboard server")
+
+        # Stop monitor client first
+        self.monitor_client.stop()
+
+        # Stop dashboard server
+        self.dashboard_server.stop_sync()
+
+        self.running = False
+        self.logger.info("Dashboard server stopped")
+
+    def _setup_event_relay(self):
+        """Setup event relay from monitor client to dashboard clients."""
+
+        # Register handlers for all events we want to relay from monitor to dashboard
+        relay_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 relay_events:
+            self.monitor_client.add_event_handler(
+                event_name, self._create_relay_handler(event_name)
+            )
+
+    def _create_relay_handler(self, event_name: str):
+        """Create a relay handler for a specific event."""
+
+        def relay_handler(data):
+            """Relay event from monitor to dashboard clients."""
+            self.stats["events_relayed"] += 1
+            self.logger.debug(f"Relaying event from monitor to dashboard: {event_name}")
+
+            # Broadcast to all dashboard clients
+            self.dashboard_server.broadcast_event(event_name, data)
+
+        return relay_handler
+
+    # Delegate SocketIOServiceInterface methods to dashboard server
+    def broadcast_event(self, event_type: str, data: Dict[str, Any]):
+        """Broadcast an event to all connected dashboard clients."""
+        self.dashboard_server.broadcast_event(event_type, data)
+
+    def send_to_client(
+        self, client_id: str, event_type: str, data: Dict[str, Any]
+    ) -> bool:
+        """Send an event to a specific dashboard client."""
+        return self.dashboard_server.send_to_client(client_id, event_type, data)
+
+    def get_connection_count(self) -> int:
+        """Get number of connected dashboard clients."""
+        return self.dashboard_server.get_connection_count()
+
+    def is_running(self) -> bool:
+        """Check if dashboard server is running."""
+        return self.running
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get dashboard server statistics."""
+        dashboard_stats = (
+            self.dashboard_server.get_stats()
+            if hasattr(self.dashboard_server, "get_stats")
+            else {}
+        )
+        monitor_stats = self.monitor_client.get_stats()
+
+        return {
+            **self.stats,
+            "dashboard_clients": self.get_connection_count(),
+            "monitor_connected": self.monitor_client.is_connected(),
+            "dashboard_stats": dashboard_stats,
+            "monitor_stats": monitor_stats,
+            "uptime": (
+                (
+                    datetime.now(timezone.utc)
+                    - datetime.fromisoformat(self.stats["start_time"])
+                ).total_seconds()
+                if self.stats["start_time"]
+                else 0
+            ),
+        }
+
+    # Session tracking methods - these now send events to monitor server
+    def session_started(self, session_id: str, launch_method: str, working_dir: str):
+        """Track session start - send to monitor server."""
+        # Send to monitor server if connected
+        self.monitor_client.send_to_monitor(
+            "session_started",
+            {
+                "session_id": session_id,
+                "launch_method": launch_method,
+                "working_dir": working_dir,
+            },
+        )
+
+        # Also update dashboard server for local tracking
+        self.dashboard_server.session_started(session_id, launch_method, working_dir)
+
+    def session_ended(self):
+        """Track session end - send to monitor server."""
+        self.monitor_client.send_to_monitor("session_ended", {})
+        self.dashboard_server.session_ended()
+
+    def claude_status_changed(
+        self, status: str, pid: Optional[int] = None, message: str = ""
+    ):
+        """Track Claude status changes - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "claude_status", {"status": status, "pid": pid, "message": message}
+        )
+        self.dashboard_server.claude_status_changed(status, pid, message)
+
+    def claude_output(self, content: str, stream: str = "stdout"):
+        """Relay Claude output - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "claude_output", {"content": content, "stream": stream}
+        )
+        self.dashboard_server.claude_output(content, stream)
+
+    def agent_delegated(self, agent: str, task: str, status: str = "started"):
+        """Track agent delegation - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "agent_delegated", {"agent": agent, "task": task, "status": status}
+        )
+        self.dashboard_server.agent_delegated(agent, task, status)
+
+    def todo_updated(self, todos: List[Dict[str, Any]]):
+        """Relay todo updates - send to monitor server."""
+        self.monitor_client.send_to_monitor("todos_updated", {"todos": todos})
+        self.dashboard_server.todo_updated(todos)
+
+    def ticket_created(self, ticket_id: str, title: str, priority: str = "medium"):
+        """Relay ticket creation - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "ticket_created",
+            {"ticket_id": ticket_id, "title": title, "priority": priority},
+        )
+        self.dashboard_server.ticket_created(ticket_id, title, priority)
+
+    def memory_loaded(self, agent_id: str, memory_size: int, sections_count: int):
+        """Relay memory loaded event - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "memory_loaded",
+            {
+                "agent_id": agent_id,
+                "memory_size": memory_size,
+                "sections_count": sections_count,
+            },
+        )
+        self.dashboard_server.memory_loaded(agent_id, memory_size, sections_count)
+
+    def memory_created(self, agent_id: str, template_type: str):
+        """Relay memory created event - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "memory_created", {"agent_id": agent_id, "template_type": template_type}
+        )
+        self.dashboard_server.memory_created(agent_id, template_type)
+
+    def memory_updated(
+        self, agent_id: str, learning_type: str, content: str, section: str
+    ):
+        """Relay memory update event - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "memory_updated",
+            {
+                "agent_id": agent_id,
+                "learning_type": learning_type,
+                "content": content,
+                "section": section,
+            },
+        )
+        self.dashboard_server.memory_updated(agent_id, learning_type, content, section)
+
+    def memory_injected(self, agent_id: str, context_size: int):
+        """Relay memory injection event - send to monitor server."""
+        self.monitor_client.send_to_monitor(
+            "memory_injected", {"agent_id": agent_id, "context_size": context_size}
+        )
+        self.dashboard_server.memory_injected(agent_id, context_size)
+
+    def get_active_sessions(self) -> List[Dict[str, Any]]:
+        """Get list of active sessions from dashboard server."""
+        return self.dashboard_server.get_active_sessions()
+
+    # Provide access to underlying dashboard server properties
+    @property
+    def sio(self):
+        """Access to the dashboard Socket.IO server instance."""
+        return self.dashboard_server.sio
+
+    @property
+    def clients(self):
+        """Access to connected dashboard clients."""
+        return getattr(self.dashboard_server, "connected_clients", set())
+
+    @property
+    def connected_clients(self):
+        """Access to connected dashboard clients set."""
+        return getattr(self.dashboard_server, "connected_clients", set())
+
+    @property
+    def file_handler(self):
+        """Access to file handler for HTTP endpoints."""
+        return getattr(self.dashboard_server, "file_handler", None)
+
+    @property
+    def git_handler(self):
+        """Access to git handler for HTTP endpoints."""
+        return getattr(self.dashboard_server, "git_handler", None)

claude_mpm/services/socketio/event_normalizer.py

@@ -15,7 +15,7 @@ DESIGN DECISION: Transform all events to a consistent schema:
 
 import re
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from typing import Any, Dict, Optional, Tuple
 
@@ -59,6 +59,7 @@ class EventType(Enum):
     PERFORMANCE = "performance"  # Performance metrics
     CLAUDE = "claude"  # Claude process events
     TEST = "test"  # Test events
+    CODE = "code"  # Code analysis events
     TOOL = "tool"  # Tool events
     SUBAGENT = "subagent"  # Subagent events
 
@@ -242,7 +243,7 @@ class EventNormalizer:
                 source="system",
                 type="unknown",
                 subtype="error",
-                timestamp=datetime.now().isoformat(),
+                timestamp=datetime.now(timezone.utc).isoformat(),
                 data={"original": str(event_data), "error": str(e)},
             )
 
@@ -276,7 +277,9 @@ class EventNormalizer:
             source=source,
             type=event_data.get("type", "unknown"),
             subtype=event_data.get("subtype", "generic"),
-            timestamp=event_data.get("timestamp", datetime.now().isoformat()),
+            timestamp=event_data.get(
+                "timestamp", datetime.now(timezone.utc).isoformat()
+            ),
             data=event_data.get("data", {}),
         )
 
@@ -351,6 +354,41 @@ class EventNormalizer:
                 event_type.value if isinstance(event_type, EventType) else event_type
             ), subtype
 
+        # Handle colon-separated event names (e.g., "code:analysis:queued", "code:progress")
+        # These are commonly used by the code analysis system
+        if ":" in event_name:
+            parts = event_name.split(":", 2)  # Split into max 3 parts
+            if len(parts) >= 2:
+                type_part = parts[0].lower()
+                # For events like "code:analysis:queued", combine the last parts as subtype
+                # Replace colons with underscores for clean subtypes
+                if len(parts) == 3:
+                    subtype_part = f"{parts[1]}_{parts[2]}"
+                else:
+                    subtype_part = parts[1].replace(":", "_")
+
+                # Map the type part to known types
+                if type_part in [
+                    "code",  # Code analysis events
+                    "hook",
+                    "session",
+                    "file",
+                    "system",
+                    "connection",
+                    "memory",
+                    "git",
+                    "todo",
+                    "ticket",
+                    "agent",
+                    "claude",
+                    "error",
+                    "performance",
+                    "test",
+                    "tool",
+                    "subagent",
+                ]:
+                    return type_part, subtype_part
+
         # Handle dotted event names (e.g., "connection.status", "session.started")
         if "." in event_name:
             parts = event_name.split(".", 1)
@@ -443,6 +481,34 @@ class EventNormalizer:
                 return EventType.MEMORY.value, "injected"
             return EventType.MEMORY.value, "generic"
 
+        # Code analysis events - using underscores for clean subtypes
+        if "code" in event_lower:
+            if "analysis" in event_lower:
+                if "queue" in event_lower:
+                    return EventType.CODE.value, "analysis_queued"
+                if "start" in event_lower:
+                    return EventType.CODE.value, "analysis_start"
+                if "complete" in event_lower:
+                    return EventType.CODE.value, "analysis_complete"
+                if "error" in event_lower:
+                    return EventType.CODE.value, "analysis_error"
+                if "cancel" in event_lower:
+                    return EventType.CODE.value, "analysis_cancelled"
+                return EventType.CODE.value, "analysis_generic"
+            if "progress" in event_lower:
+                return EventType.CODE.value, "progress"
+            if "file" in event_lower:
+                if "discovered" in event_lower:
+                    return EventType.CODE.value, "file_discovered"
+                if "analyzed" in event_lower:
+                    return EventType.CODE.value, "file_analyzed"
+                return EventType.CODE.value, "file_complete"
+            if "directory" in event_lower:
+                return EventType.CODE.value, "directory_discovered"
+            if "node" in event_lower:
+                return EventType.CODE.value, "node_found"
+            return EventType.CODE.value, "generic"
+
         # Default to unknown with lowercase subtype
         return "unknown", event_name.lower() if event_name else ""
 
@@ -489,12 +555,14 @@ class EventNormalizer:
                     # Convert other formats
                     try:
                         if isinstance(timestamp, (int, float)):
-                            return datetime.fromtimestamp(timestamp).isoformat()
-                    except:
+                            return datetime.fromtimestamp(
+                                timestamp, tz=timezone.utc
+                            ).isoformat()
+                    except Exception:
                         pass
 
         # Generate new timestamp if not found
-        return datetime.now().isoformat()
+        return datetime.now(timezone.utc).isoformat()
 
     def _determine_source(
         self, event_data: Any, event_type: str, source_override: Optional[str] = None

claude_mpm/services/socketio/handlers/__init__.py

@@ -7,6 +7,9 @@ and maintainability.
 """
 
 from .base import BaseEventHandler
+
+# DISABLED: File Tree interface removed from dashboard
+# from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -16,6 +19,8 @@ from .registry import EventHandlerRegistry
 
 __all__ = [
     "BaseEventHandler",
+    # DISABLED: File Tree interface removed from dashboard
+    # "CodeAnalysisEventHandler",
     "ConnectionEventHandler",
     "EventHandlerRegistry",
     "FileEventHandler",

claude_mpm/services/socketio/handlers/base.py

@@ -5,7 +5,7 @@ logging, error handling, and access to the server instance. All handler
 classes inherit from this to ensure consistent behavior.
 """
 
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from ....core.logger import get_logger
@@ -107,7 +107,7 @@ class BaseEventHandler:
         """
         event = {
             "type": event_type,
-            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
             "data": data,
         }
         self.event_history.append(event)