claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/services/socketio/__init__.py

@@ -0,0 +1,25 @@
+"""Socket.IO service module.
+
+WHY: This module provides the modular Socket.IO server implementation
+with separated event handlers for improved maintainability.
+"""
+
+from .handlers import (
+    BaseEventHandler,
+    ConnectionEventHandler,
+    EventHandlerRegistry,
+    FileEventHandler,
+    GitEventHandler,
+    MemoryEventHandler,
+    ProjectEventHandler,
+)
+
+__all__ = [
+    "BaseEventHandler",
+    "ConnectionEventHandler",
+    "EventHandlerRegistry",
+    "FileEventHandler",
+    "GitEventHandler",
+    "MemoryEventHandler",
+    "ProjectEventHandler",
+]

claude_mpm/services/socketio/client_proxy.py

@@ -0,0 +1,229 @@
+"""
+SocketIO Client Proxy for claude-mpm.
+
+WHY: This module contains the SocketIOClientProxy class that was extracted from
+the monolithic socketio_server.py file. In exec mode, a persistent Socket.IO
+server runs in a separate process, and this proxy provides a Socket.IO-like
+interface without starting another server.
+
+DESIGN DECISION: Separated client proxy logic from server logic for better
+organization and to reduce the complexity of the main server file.
+"""
+
+import asyncio
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+try:
+    import socketio
+
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+
+import contextlib
+
+from ...core.logging_config import get_logger
+
+
+class SocketIOClientProxy:
+    """Proxy that connects to an existing Socket.IO server as a client.
+
+    WHY: In exec mode, a persistent Socket.IO server runs in a separate process.
+    The hook handler in the Claude process needs a Socket.IO-like interface
+    but shouldn't start another server. This proxy provides that interface
+    while the actual events are handled by the persistent server.
+    """
+
+    def __init__(self, host: str = "localhost", port: int = 8765):
+        self.host = host
+        self.port = port
+        self.logger = get_logger(__name__ + ".SocketIOClientProxy")
+        self.running = True  # Always "running" for compatibility
+        self._sio_client = None
+        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(
+            f"SocketIOClientProxy: Connecting to server on {self.host}:{self.port}"
+        )
+        if SOCKETIO_AVAILABLE:
+            self._start_client()
+
+    def stop_sync(self):
+        """Stop the Socket.IO client connection."""
+        self.logger.debug("SocketIOClientProxy: Disconnecting from server")
+        if self._sio_client:
+            self._sio_client.disconnect()
+
+    def _start_client(self):
+        """Start Socket.IO client in a background thread."""
+
+        def run_client():
+            self._client_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._client_loop)
+            try:
+                self._client_loop.run_until_complete(self._connect_and_run())
+            except Exception as e:
+                self.logger.error(f"SocketIOClientProxy client thread error: {e}")
+            finally:
+                self._client_loop.close()
+
+        self._client_thread = threading.Thread(target=run_client, daemon=True)
+        self._client_thread.start()
+        # Give it a moment to connect
+        time.sleep(0.2)
+
+    async def _connect_and_run(self):
+        """Connect to the persistent Socket.IO server and keep connection alive."""
+        try:
+            self._sio_client = socketio.AsyncClient()
+
+            @self._sio_client.event
+            async def connect():
+                self.logger.info(
+                    f"SocketIOClientProxy: Connected to server at http://{self.host}:{self.port}"
+                )
+
+            @self._sio_client.event
+            async def disconnect():
+                self.logger.info("SocketIOClientProxy: Disconnected from server")
+
+            # 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: Unexpected error: {e}")
+            self._sio_client = None
+
+    def broadcast_event(self, event_type: str, data: Dict[str, Any]):
+        """Send event to the persistent Socket.IO server."""
+        if not SOCKETIO_AVAILABLE:
+            return
+
+        # Ensure client is started
+        if not self._client_thread or not self._client_thread.is_alive():
+            self.logger.debug(f"SocketIOClientProxy: Starting client for {event_type}")
+            self._start_client()
+
+        if self._sio_client and self._sio_client.connected:
+            try:
+                event = {
+                    "type": event_type,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "data": data,
+                }
+
+                # Send event safely using run_coroutine_threadsafe
+                if (
+                    hasattr(self, "_client_loop")
+                    and self._client_loop
+                    and not self._client_loop.is_closed()
+                ):
+                    try:
+                        asyncio.run_coroutine_threadsafe(
+                            self._sio_client.emit("claude_event", event),
+                            self._client_loop,
+                        )
+                        # Don't wait for the result to avoid blocking
+                        self.logger.debug(
+                            f"SocketIOClientProxy: Scheduled emit for {event_type}"
+                        )
+                    except Exception as e:
+                        self.logger.error(
+                            f"SocketIOClientProxy: Failed to schedule emit for {event_type}: {e}"
+                        )
+                else:
+                    self.logger.warning(
+                        f"SocketIOClientProxy: Client event loop not available for {event_type}"
+                    )
+
+                self.logger.debug(f"SocketIOClientProxy: Sent event {event_type}")
+            except Exception as e:
+                self.logger.error(
+                    f"SocketIOClientProxy: Failed to send event {event_type}: {e}"
+                )
+        else:
+            self.logger.warning(
+                f"SocketIOClientProxy: Client not ready for {event_type}"
+            )
+
+    # Compatibility methods for WebSocketServer interface
+    def session_started(self, session_id: str, launch_method: str, working_dir: str):
+        self.logger.debug(f"SocketIOClientProxy: Session started {session_id}")
+
+    def session_ended(self):
+        self.logger.debug("SocketIOClientProxy: Session ended")
+
+    def claude_status_changed(
+        self, status: str, pid: Optional[int] = None, message: str = ""
+    ):
+        self.logger.debug(f"SocketIOClientProxy: Claude status {status}")
+
+    def agent_delegated(self, agent: str, task: str, status: str = "started"):
+        self.logger.debug(f"SocketIOClientProxy: Agent {agent} delegated")
+
+    def todo_updated(self, todos: List[Dict[str, Any]]):
+        self.logger.debug(f"SocketIOClientProxy: Todo updated ({len(todos)} todos)")

claude_mpm/services/socketio/dashboard_server.py

@@ -0,0 +1,362 @@
+"""
+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 = [
+            "claude_event",  # Tool events from Claude Code hooks
+            "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)