claude-mpm 3.9.11__py3-none-any.whl → 4.0.4__py3-none-any.whl

claude_mpm/services/socketio/server/broadcaster.py

@@ -0,0 +1,252 @@
+"""
+SocketIO Event Broadcaster for claude-mpm.
+
+WHY: This module contains all the broadcasting methods extracted from the
+monolithic socketio_server.py file. It handles sending events to connected
+clients for various Claude MPM activities.
+
+DESIGN DECISION: Separated broadcasting logic from core server management
+to create focused, testable modules with single responsibilities.
+"""
+
+import asyncio
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Set
+
+from ....core.logging_config import get_logger
+
+
+class SocketIOEventBroadcaster:
+    """Handles broadcasting events to connected Socket.IO clients.
+
+    WHY: This class encapsulates all the event broadcasting logic that was
+    scattered throughout the monolithic SocketIOServer class.
+    """
+
+    def __init__(
+        self,
+        sio,
+        connected_clients: Set[str],
+        event_buffer,
+        buffer_lock,
+        stats: Dict[str, Any],
+        logger,
+        server=None,  # Add server reference for event history access
+    ):
+        self.sio = sio
+        self.connected_clients = connected_clients
+        self.event_buffer = event_buffer
+        self.buffer_lock = buffer_lock
+        self.stats = stats
+        self.logger = logger
+        self.loop = None  # Will be set by main server
+        self.server = server  # Reference to main server for event history
+
+    def broadcast_event(self, event_type: str, data: Dict[str, Any]):
+        """Broadcast an event to all connected clients."""
+        if not self.sio:
+            return
+
+        event = {
+            "type": event_type,
+            "timestamp": datetime.now().isoformat(),
+            "data": data,
+        }
+
+        # Buffer the event for reliability AND add to event history for new clients
+        with self.buffer_lock:
+            self.event_buffer.append(event)
+            self.stats["events_buffered"] += 1
+            
+            # Also add to event history if available (for client replay)
+            # Access through server reference to maintain single history source
+            if hasattr(self, 'server') and hasattr(self.server, 'event_history'):
+                self.server.event_history.append(event)
+                self.logger.debug(f"Added {event_type} to history (total: {len(self.server.event_history)})")
+
+        # Broadcast to all connected clients
+        try:
+            # Use run_coroutine_threadsafe to safely call from any thread
+            if hasattr(self, "loop") and self.loop and not self.loop.is_closed():
+                future = asyncio.run_coroutine_threadsafe(
+                    self.sio.emit("claude_event", event), self.loop
+                )
+                # Don't wait for the result to avoid blocking
+                self.stats["events_sent"] += 1
+                self.logger.debug(f"Broadcasted event: {event_type}")
+            else:
+                self.logger.warning(
+                    f"Cannot broadcast {event_type}: server loop not available"
+                )
+
+        except Exception as e:
+            self.logger.error(f"Failed to broadcast event {event_type}: {e}")
+
+    def session_started(self, session_id: str, launch_method: str, working_dir: str):
+        """Notify that a session has started."""
+        self.broadcast_event(
+            "session_started",
+            {
+                "session_id": session_id,
+                "launch_method": launch_method,
+                "working_dir": working_dir,
+                "timestamp": datetime.now().isoformat(),
+            },
+        )
+
+    def session_ended(self):
+        """Notify that a session has ended."""
+        self.broadcast_event("session_ended", {"timestamp": datetime.now().isoformat()})
+
+    def claude_status_changed(
+        self, status: str, pid: Optional[int] = None, message: str = ""
+    ):
+        """Notify Claude status change."""
+        self.broadcast_event(
+            "claude_status", {"status": status, "pid": pid, "message": message}
+        )
+
+    def claude_output(self, content: str, stream: str = "stdout"):
+        """Broadcast Claude output."""
+        self.broadcast_event("claude_output", {"content": content, "stream": stream})
+
+    def agent_delegated(self, agent: str, task: str, status: str = "started"):
+        """Notify agent delegation."""
+        self.broadcast_event(
+            "agent_delegated", {"agent": agent, "task": task, "status": status}
+        )
+
+    def todo_updated(self, todos: List[Dict[str, Any]]):
+        """Notify todo list update."""
+        # Limit the size of todo data to prevent large payloads
+        limited_todos = todos[:50] if len(todos) > 50 else todos
+
+        self.broadcast_event(
+            "todo_updated",
+            {
+                "todos": limited_todos,
+                "total_count": len(todos),
+                "truncated": len(todos) > 50,
+            },
+        )
+
+    def ticket_created(self, ticket_id: str, title: str, priority: str = "medium"):
+        """Notify ticket creation."""
+        self.broadcast_event(
+            "ticket_created",
+            {"ticket_id": ticket_id, "title": title, "priority": priority},
+        )
+
+    def memory_loaded(self, agent_id: str, memory_size: int, sections_count: int):
+        """Notify when agent memory is loaded from file."""
+        self.broadcast_event(
+            "memory_loaded",
+            {
+                "agent_id": agent_id,
+                "memory_size": memory_size,
+                "sections_count": sections_count,
+            },
+        )
+
+    def memory_created(self, agent_id: str, template_type: str):
+        """Notify when new agent memory is created from template."""
+        self.broadcast_event(
+            "memory_created", {"agent_id": agent_id, "template_type": template_type}
+        )
+
+    def memory_updated(
+        self, agent_id: str, learning_type: str, content: str, section: str
+    ):
+        """Notify when learning is added to agent memory."""
+        # Truncate content if too long to prevent large payloads
+        truncated_content = content[:500] + "..." if len(content) > 500 else content
+
+        self.broadcast_event(
+            "memory_updated",
+            {
+                "agent_id": agent_id,
+                "learning_type": learning_type,
+                "content": truncated_content,
+                "section": section,
+                "content_length": len(content),
+                "truncated": len(content) > 500,
+            },
+        )
+
+    def memory_injected(self, agent_id: str, context_size: int):
+        """Notify when agent memory is injected into context."""
+        self.broadcast_event(
+            "memory_injected", {"agent_id": agent_id, "context_size": context_size}
+        )
+
+    def file_changed(
+        self, file_path: str, change_type: str, content: Optional[str] = None
+    ):
+        """Notify file system changes."""
+        event_data = {"file_path": file_path, "change_type": change_type}
+
+        # Include content for small files only
+        if content and len(content) < 1000:
+            event_data["content"] = content
+        elif content:
+            event_data["content_preview"] = content[:200] + "..."
+            event_data["content_length"] = len(content)
+
+        self.broadcast_event("file_changed", event_data)
+
+    def git_operation(self, operation: str, details: Dict[str, Any]):
+        """Notify Git operations."""
+        self.broadcast_event(
+            "git_operation", {"operation": operation, "details": details}
+        )
+
+    def error_occurred(
+        self, error_type: str, message: str, details: Optional[Dict[str, Any]] = None
+    ):
+        """Notify when errors occur."""
+        self.broadcast_event(
+            "error",
+            {"error_type": error_type, "message": message, "details": details or {}},
+        )
+
+    def performance_metric(self, metric_name: str, value: float, unit: str = ""):
+        """Broadcast performance metrics."""
+        self.broadcast_event(
+            "performance", {"metric": metric_name, "value": value, "unit": unit}
+        )
+
+    def system_status(self, status: Dict[str, Any]):
+        """Broadcast system status information."""
+        self.broadcast_event("system_status", status)
+    
+    def broadcast_system_heartbeat(self, heartbeat_data: Dict[str, Any]):
+        """Broadcast system heartbeat event.
+        
+        WHY: System events are separate from hook events to provide
+        server health monitoring independent of Claude activity.
+        """
+        if not self.sio:
+            return
+            
+        # Create system event with consistent format
+        event = {
+            "type": "system",
+            "event": "heartbeat",
+            "timestamp": datetime.now().isoformat(),
+            "data": heartbeat_data,
+        }
+        
+        # Broadcast to all connected clients
+        try:
+            if self.loop and not self.loop.is_closed():
+                future = asyncio.run_coroutine_threadsafe(
+                    self.sio.emit("system_event", event), self.loop
+                )
+                self.logger.debug(
+                    f"Broadcasted system heartbeat - clients: {len(self.connected_clients)}, "
+                    f"uptime: {heartbeat_data.get('uptime_seconds', 0)}s"
+                )
+            else:
+                self.logger.warning("Cannot broadcast heartbeat: server loop not available")
+        except Exception as e:
+            self.logger.error(f"Failed to broadcast system heartbeat: {e}")

claude_mpm/services/socketio/server/core.py

@@ -0,0 +1,399 @@
+"""
+SocketIO Server Core for claude-mpm.
+
+WHY: This module contains the core server management functionality extracted from
+the monolithic socketio_server.py file. It handles server lifecycle, static file
+serving, and basic server setup.
+
+DESIGN DECISION: Separated core server logic from event handling and broadcasting
+to create focused, maintainable modules.
+"""
+
+import asyncio
+import logging
+import os
+import threading
+import time
+from collections import deque
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+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.constants import (
+    NetworkConfig,
+    PerformanceConfig,
+    SystemLimits,
+    TimeoutConfig,
+)
+from ....core.interfaces import SocketIOServiceInterface
+from ....core.logging_config import get_logger, log_operation, log_performance_context
+from ....core.unified_paths import get_project_root, get_scripts_dir
+from ...exceptions import SocketIOServerError as MPMConnectionError
+
+
+class SocketIOServerCore:
+    """Core server management functionality for SocketIO server.
+
+    WHY: This class handles the basic server lifecycle, static file serving,
+    and core server setup. It's separated from event handling to reduce complexity.
+    """
+
+    def __init__(self, host: str = "localhost", port: int = 8765):
+        self.host = host
+        self.port = port
+        self.logger = get_logger(__name__ + ".SocketIOServer")
+        self.running = False
+        self.server_thread = None
+        self.loop = None
+        self.app = None
+        self.runner = None
+        self.site = None
+
+        # Socket.IO server instance
+        self.sio = None
+
+        # Connection tracking
+        self.connected_clients: Set[str] = set()
+        self.client_info: Dict[str, Dict[str, Any]] = {}
+
+        # Event buffering for reliability
+        self.event_buffer = deque(
+            maxlen=getattr(SystemLimits, "MAX_EVENTS_BUFFER", 1000)
+        )
+        self.buffer_lock = threading.Lock()
+
+        # Performance tracking
+        self.stats = {
+            "events_sent": 0,
+            "events_buffered": 0,
+            "connections_total": 0,
+            "start_time": None,
+        }
+
+        # Static files path
+        self.static_path = None
+        
+        # Heartbeat task
+        self.heartbeat_task = None
+        self.heartbeat_interval = 60  # seconds
+        self.main_server = None  # Reference to main server for session data
+
+    def start_sync(self):
+        """Start the Socket.IO server in a background thread (synchronous version)."""
+        if not SOCKETIO_AVAILABLE:
+            self.logger.warning("Socket.IO not available - server not started")
+            return
+
+        if self.running:
+            self.logger.warning("Socket.IO server already running")
+            return
+
+        self.logger.info(f"Starting Socket.IO server on {self.host}:{self.port}")
+
+        # Start server in background thread
+        self.server_thread = threading.Thread(target=self._run_server, daemon=True)
+        self.server_thread.start()
+
+        # Wait for server to start
+        max_wait = getattr(TimeoutConfig, "SERVER_START_TIMEOUT", 30)
+        wait_time = 0
+        while not self.running and wait_time < max_wait:
+            time.sleep(0.1)
+            wait_time += 0.1
+
+        if not self.running:
+            raise MPMConnectionError(
+                f"Failed to start Socket.IO server within {max_wait}s"
+            )
+
+        self.logger.info(
+            f"Socket.IO server started successfully on {self.host}:{self.port}"
+        )
+
+    def stop_sync(self):
+        """Stop the Socket.IO server (synchronous version)."""
+        if not self.running:
+            return
+
+        self.logger.info("Stopping Socket.IO server...")
+        self.running = False
+
+        # Stop the server gracefully
+        if self.loop and not self.loop.is_closed():
+            asyncio.run_coroutine_threadsafe(self._stop_server(), self.loop)
+
+    def _run_server(self):
+        """Run the server event loop."""
+        try:
+            # Create new event loop for this thread
+            self.loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self.loop)
+
+            # Run the server
+            self.loop.run_until_complete(self._start_server())
+
+        except Exception as e:
+            self.logger.error(f"Socket.IO server error: {e}")
+            self.running = False
+        finally:
+            if self.loop and not self.loop.is_closed():
+                self.loop.close()
+
+    async def _start_server(self):
+        """Start the Socket.IO server with aiohttp."""
+        try:
+            # Create Socket.IO server
+            self.sio = socketio.AsyncServer(
+                cors_allowed_origins="*",
+                logger=False,  # Disable Socket.IO's own logging
+                engineio_logger=False,
+            )
+
+            # Create aiohttp application
+            self.app = web.Application()
+            self.sio.attach(self.app)
+
+            # Find and serve static files
+            self._setup_static_files()
+
+            # Create and start the server
+            self.runner = web.AppRunner(self.app)
+            await self.runner.setup()
+
+            self.site = web.TCPSite(
+                self.runner, self.host, self.port, reuse_address=True, reuse_port=True
+            )
+            await self.site.start()
+
+            self.running = True
+            self.stats["start_time"] = datetime.now()
+
+            self.logger.info(
+                f"Socket.IO server listening on http://{self.host}:{self.port}"
+            )
+            if self.static_path:
+                self.logger.info(f"Serving static files from: {self.static_path}")
+
+            # Start heartbeat task
+            self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+            self.logger.info("Started system heartbeat task")
+
+            # Keep the server running
+            while self.running:
+                await asyncio.sleep(1)
+
+        except Exception as e:
+            self.logger.error(f"Failed to start Socket.IO server: {e}")
+            self.running = False
+            raise
+
+    async def _stop_server(self):
+        """Stop the server gracefully."""
+        try:
+            # Cancel heartbeat task
+            if self.heartbeat_task and not self.heartbeat_task.done():
+                self.heartbeat_task.cancel()
+                try:
+                    await self.heartbeat_task
+                except asyncio.CancelledError:
+                    pass
+                self.logger.info("Stopped system heartbeat task")
+
+            if self.site:
+                await self.site.stop()
+                self.site = None
+
+            if self.runner:
+                await self.runner.cleanup()
+                self.runner = None
+
+            self.logger.info("Socket.IO server stopped")
+
+        except Exception as e:
+            self.logger.error(f"Error stopping Socket.IO server: {e}")
+
+    def _setup_static_files(self):
+        """Setup static file serving for the dashboard."""
+        try:
+            self.dashboard_path = self._find_static_path()
+
+            if self.dashboard_path and self.dashboard_path.exists():
+                # Serve index.html at root
+                async def index_handler(request):
+                    index_file = self.dashboard_path / "index.html"
+                    if index_file.exists():
+                        return web.FileResponse(index_file)
+                    else:
+                        return web.Response(text="Dashboard not available", status=404)
+
+                self.app.router.add_get("/", index_handler)
+
+                # Serve static assets (CSS, JS) from the dashboard static directory
+                dashboard_static_path = (
+                    get_project_root() / "src" / "claude_mpm" / "dashboard" / "static"
+                )
+                if dashboard_static_path.exists():
+                    self.app.router.add_static(
+                        "/static/", dashboard_static_path, name="dashboard_static"
+                    )
+                else:
+                    self.logger.debug(f"Static assets directory not found at: {dashboard_static_path}")
+
+            else:
+                # Fallback handler
+                async def fallback_handler(request):
+                    return web.Response(
+                        text="Socket.IO server running - Dashboard not available",
+                        status=200,
+                    )
+
+                self.app.router.add_get("/", fallback_handler)
+                
+        except Exception as e:
+            self.logger.warning(f"Error setting up static files: {e}")
+            # Ensure we always have a basic handler
+            async def error_handler(request):
+                return web.Response(
+                    text="Socket.IO server running - Static files unavailable",
+                    status=200,
+                )
+            self.app.router.add_get("/", error_handler)
+
+    def _find_static_path(self):
+        """Find the static files directory using multiple approaches.
+
+        WHY: The static files location varies depending on how the application
+        is installed and run. We try multiple common locations to find them.
+        """
+        # Try multiple possible locations for static files and dashboard
+        possible_paths = [
+            # Dashboard template directory (primary location)
+            get_project_root() / "src" / "claude_mpm" / "dashboard" / "templates",
+            get_project_root() / "dashboard" / "templates",
+            # Static file directories
+            get_project_root() / "src" / "claude_mpm" / "services" / "static",
+            get_project_root()
+            / "src"
+            / "claude_mpm"
+            / "services"
+            / "socketio"
+            / "static",
+            get_project_root() / "static",
+            get_project_root() / "src" / "static",
+            # Package installation locations
+            Path(__file__).parent.parent / "static",
+            Path(__file__).parent / "static",
+            # Scripts directory (for standalone installations)
+            get_scripts_dir() / "static",
+            get_scripts_dir() / "socketio" / "static",
+            # Current working directory
+            Path.cwd() / "static",
+            Path.cwd() / "socketio" / "static",
+        ]
+
+        for path in possible_paths:
+            if path.exists() and path.is_dir():
+                # Check if it contains expected files
+                if (path / "index.html").exists():
+                    self.logger.debug(f"Found static files at: {path}")
+                    return path
+
+        self.logger.warning("Static files not found - dashboard will not be available")
+        return None
+
+    def get_connection_count(self) -> int:
+        """Get number of connected clients.
+
+        WHY: Provides interface compliance for monitoring.
+
+        Returns:
+            Number of connected clients
+        """
+        return len(self.connected_clients)
+
+    def is_running(self) -> bool:
+        """Check if server is running.
+
+        WHY: Provides interface compliance for status checking.
+
+        Returns:
+            True if server is active
+        """
+        return self.running
+    
+    async def _heartbeat_loop(self):
+        """Send periodic heartbeat events to connected clients.
+        
+        WHY: This provides a way to verify the event flow is working and
+        track server health and active sessions without relying on hook events.
+        """
+        while self.running:
+            try:
+                # Wait for the interval
+                await asyncio.sleep(self.heartbeat_interval)
+                
+                if not self.sio:
+                    continue
+                    
+                # Calculate uptime
+                uptime_seconds = 0
+                if self.stats.get("start_time"):
+                    uptime_seconds = int((datetime.now() - self.stats["start_time"]).total_seconds())
+                
+                # Get active sessions from main server if available
+                active_sessions = []
+                if self.main_server and hasattr(self.main_server, 'get_active_sessions'):
+                    try:
+                        active_sessions = self.main_server.get_active_sessions()
+                    except Exception as e:
+                        self.logger.debug(f"Could not get active sessions: {e}")
+                
+                # Prepare heartbeat data
+                heartbeat_data = {
+                    "type": "system",
+                    "event": "heartbeat",
+                    "timestamp": datetime.now().isoformat(),
+                    "data": {
+                        "uptime_seconds": uptime_seconds,
+                        "connected_clients": len(self.connected_clients),
+                        "total_events": self.stats.get("events_sent", 0),
+                        "active_sessions": active_sessions,
+                        "server_info": {
+                            "version": "4.0.2",
+                            "port": self.port,
+                        },
+                    },
+                }
+                
+                # Add to event history if main server is available
+                if self.main_server and hasattr(self.main_server, 'event_history'):
+                    self.main_server.event_history.append(heartbeat_data)
+                
+                # Emit heartbeat to all connected clients
+                await self.sio.emit("system_event", heartbeat_data)
+                
+                self.logger.info(
+                    f"System heartbeat sent - clients: {len(self.connected_clients)}, "
+                    f"uptime: {uptime_seconds}s, events: {self.stats.get('events_sent', 0)}, "
+                    f"sessions: {len(active_sessions)}"
+                )
+                
+            except asyncio.CancelledError:
+                # Task was cancelled, exit gracefully
+                break
+            except Exception as e:
+                self.logger.error(f"Error in heartbeat loop: {e}")
+                # Continue running even if one heartbeat fails
+                await asyncio.sleep(5)  # Short delay before retry