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

claude_mpm/services/socketio/server/connection_manager.py

@@ -10,10 +10,11 @@ of client states, proper event delivery, and automatic recovery mechanisms.
 """
 
 import asyncio
+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
@@ -71,20 +72,28 @@ class ClientConnection:
     metadata: Dict[str, Any] = field(default_factory=dict)
 
     def is_healthy(self, timeout: float = 90.0) -> bool:
-        """Check if connection is healthy based on activity."""
+        """Check if connection is healthy based on activity.
+
+        Args:
+            timeout: Seconds before considering connection unhealthy (default 90s)
+        """
         if self.state != ConnectionState.CONNECTED:
             return False
 
         now = time.time()
 
         # Check last activity (ping, pong, or event)
+        # Include metrics.last_activity for more comprehensive tracking
         last_activity = max(
             self.last_ping or 0,
             self.last_pong or 0,
             self.last_event or 0,
+            self.metrics.last_activity or 0,
             self.connected_at,
         )
 
+        # More aggressive timeout for stale detection (no grace period)
+        # This helps identify truly stale connections faster
         return (now - last_activity) < timeout
 
     def calculate_quality(self) -> float:
@@ -140,22 +149,30 @@ class ConnectionManager:
     - Automatic event replay on reconnection
     """
 
-    def __init__(self, max_buffer_size: int = 1000, event_ttl: int = 300):
+    def __init__(
+        self, max_buffer_size: Optional[int] = None, event_ttl: Optional[int] = None
+    ):
         """
-        Initialize connection manager.
+        Initialize connection manager with centralized configuration.
 
         Args:
-            max_buffer_size: Maximum events to buffer per client
-            event_ttl: Time-to-live for buffered events in seconds
+            max_buffer_size: Maximum events to buffer per client (uses config if None)
+            event_ttl: Time-to-live for buffered events in seconds (uses config if None)
         """
+        from ....config.socketio_config import CONNECTION_CONFIG
+
         self.logger = get_logger(__name__)
         self.connections: Dict[str, ClientConnection] = {}
         self.client_mapping: Dict[str, str] = {}  # client_id -> current sid
-        self.max_buffer_size = max_buffer_size
-        self.event_ttl = event_ttl
+
+        # Use centralized configuration with optional overrides
+        self.max_buffer_size = max_buffer_size or CONNECTION_CONFIG["max_events_buffer"]
+        self.event_ttl = event_ttl or CONNECTION_CONFIG["event_ttl"]
         self.global_sequence = 0
-        self.health_check_interval = 30  # seconds
-        self.stale_timeout = 90  # seconds
+        self.health_check_interval = CONNECTION_CONFIG[
+            "health_check_interval"
+        ]  # 30 seconds
+        self.stale_timeout = CONNECTION_CONFIG["stale_timeout"]  # 180 seconds (was 90)
         self.health_task = None
         self._lock = asyncio.Lock()
 
@@ -163,7 +180,7 @@ class ConnectionManager:
         self, sid: str, client_id: Optional[str] = None
     ) -> ClientConnection:
         """
-        Register a new connection or reconnection.
+        Register a new connection or reconnection with retry logic.
 
         Args:
             sid: Socket ID
@@ -172,54 +189,84 @@ class ConnectionManager:
         Returns:
             ClientConnection object
         """
-        async with self._lock:
-            now = time.time()
+        max_retries = 3
+        retry_delay = 0.1  # Start with 100ms
+
+        for attempt in range(max_retries):
+            try:
+                async with self._lock:
+                    now = time.time()
+
+                    # Check if this is a reconnection
+                    if client_id and client_id in self.client_mapping:
+                        old_sid = self.client_mapping[client_id]
+                        if old_sid in self.connections:
+                            old_conn = self.connections[old_sid]
+
+                            # Create new connection with history
+                            conn = ClientConnection(
+                                sid=sid,
+                                client_id=client_id,
+                                state=ConnectionState.CONNECTED,
+                                connected_at=now,
+                                event_buffer=old_conn.event_buffer,
+                                event_sequence=old_conn.event_sequence,
+                                last_acked_sequence=old_conn.last_acked_sequence,
+                                metrics=old_conn.metrics,
+                            )
+
+                            # Update metrics
+                            conn.metrics.reconnect_count += 1
+                            conn.metrics.connect_count += 1
+                            if old_conn.disconnected_at:
+                                conn.metrics.total_downtime += (
+                                    now - old_conn.disconnected_at
+                                )
+
+                            # Clean up old connection
+                            del self.connections[old_sid]
+
+                            self.logger.info(
+                                f"Client {client_id} reconnected (new sid: {sid}, "
+                                f"buffered events: {len(conn.event_buffer)})"
+                            )
+                        else:
+                            # No old connection found, create new
+                            client_id = client_id or str(uuid4())
+                            conn = self._create_new_connection(sid, client_id, now)
+                    else:
+                        # New client
+                        client_id = client_id or str(uuid4())
+                        conn = self._create_new_connection(sid, client_id, now)
 
-            # Check if this is a reconnection
-            if client_id and client_id in self.client_mapping:
-                old_sid = self.client_mapping[client_id]
-                if old_sid in self.connections:
-                    old_conn = self.connections[old_sid]
+                    # Register connection with validation
+                    if conn and conn.state == ConnectionState.CONNECTED:
+                        self.connections[sid] = conn
+                        self.client_mapping[client_id] = sid
+                        return conn
+                    raise ValueError(f"Invalid connection state for {sid}")
 
-                    # Create new connection with history
+            except Exception as e:
+                self.logger.warning(
+                    f"Failed to register connection {sid} (attempt {attempt + 1}/{max_retries}): {e}"
+                )
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(retry_delay)
+                    retry_delay *= 2  # Exponential backoff
+                else:
+                    # Final attempt failed, create minimal connection
+                    self.logger.error(
+                        f"All attempts failed for {sid}, creating minimal connection"
+                    )
                     conn = ClientConnection(
                         sid=sid,
-                        client_id=client_id,
+                        client_id=client_id or str(uuid4()),
                         state=ConnectionState.CONNECTED,
-                        connected_at=now,
-                        event_buffer=old_conn.event_buffer,
-                        event_sequence=old_conn.event_sequence,
-                        last_acked_sequence=old_conn.last_acked_sequence,
-                        metrics=old_conn.metrics,
-                    )
-
-                    # Update metrics
-                    conn.metrics.reconnect_count += 1
-                    conn.metrics.connect_count += 1
-                    if old_conn.disconnected_at:
-                        conn.metrics.total_downtime += now - old_conn.disconnected_at
-
-                    # Clean up old connection
-                    del self.connections[old_sid]
-
-                    self.logger.info(
-                        f"Client {client_id} reconnected (new sid: {sid}, "
-                        f"buffered events: {len(conn.event_buffer)})"
+                        connected_at=time.time(),
                     )
-                else:
-                    # No old connection found, create new
-                    client_id = client_id or str(uuid4())
-                    conn = self._create_new_connection(sid, client_id, now)
-            else:
-                # New client
-                client_id = client_id or str(uuid4())
-                conn = self._create_new_connection(sid, client_id, now)
-
-            # Register connection
-            self.connections[sid] = conn
-            self.client_mapping[client_id] = sid
-
-            return conn
+                    self.connections[sid] = conn
+                    return conn
+        return None
 
     def _create_new_connection(
         self, sid: str, client_id: str, now: float
@@ -391,10 +438,8 @@ class ConnectionManager:
         """Stop the health monitoring task."""
         if self.health_task:
             self.health_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self.health_task
-            except asyncio.CancelledError:
-                pass
             self.health_task = None
             self.logger.info("Stopped connection health monitoring")
 
@@ -419,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,
@@ -439,21 +484,39 @@ class ConnectionManager:
                     if conn.is_healthy(self.stale_timeout):
                         report["healthy"] += 1
                     else:
-                        # Mark as stale
-                        conn.state = ConnectionState.STALE
-                        report["stale"] += 1
-                        self.logger.warning(
-                            f"Connection {conn.client_id} marked as stale "
-                            f"(last activity: {now - conn.metrics.last_activity:.1f}s ago)"
+                        # Mark as stale only if really stale (no grace period activity)
+                        last_activity = max(
+                            conn.last_ping or 0,
+                            conn.last_pong or 0,
+                            conn.last_event or 0,
+                            conn.metrics.last_activity or 0,
+                            conn.connected_at,
                         )
+                        time_since_activity = now - last_activity
+
+                        # Only mark as stale if significantly over timeout (2x)
+                        if time_since_activity > (self.stale_timeout * 2):
+                            conn.state = ConnectionState.STALE
+                            report["stale"] += 1
+                            self.logger.warning(
+                                f"Connection {conn.client_id} marked as stale "
+                                f"(last activity: {time_since_activity:.1f}s ago)"
+                            )
+                        else:
+                            # Connection is borderline - keep it alive but log
+                            report["healthy"] += 1
+                            self.logger.debug(
+                                f"Connection {conn.client_id} borderline "
+                                f"(last activity: {time_since_activity:.1f}s ago)"
+                            )
+
                 elif conn.state == ConnectionState.DISCONNECTED:
                     report["disconnected"] += 1
 
-                    # Clean up old disconnected connections
-                    if (
-                        conn.disconnected_at
-                        and (now - conn.disconnected_at) > self.event_ttl
-                    ):
+                    # Clean up old disconnected connections (be conservative)
+                    if conn.disconnected_at and (now - conn.disconnected_at) > (
+                        self.event_ttl * 2
+                    ):  # Double the TTL
                         to_clean.append(sid)
 
             # Clean up old connections

claude_mpm/services/socketio/server/core.py

@@ -13,7 +13,7 @@ import asyncio
 import threading
 import time
 from collections import deque
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Set
 
@@ -158,23 +158,46 @@ class SocketIOServerCore:
     async def _start_server(self):
         """Start the Socket.IO server with aiohttp."""
         try:
-            # Create Socket.IO server with proper ping/pong configuration
+            # Import centralized configuration for consistency
+            from ....config.socketio_config import CONNECTION_CONFIG
+
+            # Create Socket.IO server with centralized configuration
+            # CRITICAL: These values MUST match client settings to prevent disconnections
             self.sio = socketio.AsyncServer(
                 cors_allowed_origins="*",
                 logger=False,  # Disable Socket.IO's own logging
                 engineio_logger=False,
-                ping_interval=25,  # Send ping every 25 seconds
-                ping_timeout=60,  # Wait 60 seconds for pong response
-                max_http_buffer_size=1e8,  # 100MB max buffer
+                ping_interval=CONNECTION_CONFIG[
+                    "ping_interval"
+                ],  # 45 seconds from config
+                ping_timeout=CONNECTION_CONFIG[
+                    "ping_timeout"
+                ],  # 20 seconds from config
+                max_http_buffer_size=CONNECTION_CONFIG[
+                    "max_http_buffer_size"
+                ],  # 100MB from config
             )
 
             # Create aiohttp application
             self.app = web.Application()
             self.sio.attach(self.app)
 
+            # CRITICAL: Register event handlers BEFORE starting the server
+            # This ensures handlers are ready when clients connect
+            if self.main_server and hasattr(self.main_server, "_register_events_async"):
+                self.logger.info(
+                    "Registering Socket.IO event handlers before server start"
+                )
+                await self.main_server._register_events_async()
+            else:
+                self.logger.warning("Main server not available for event registration")
+
             # Setup HTTP API endpoints for receiving events from hook handlers
             self._setup_http_api()
 
+            # Setup simple directory API
+            self._setup_directory_api()
+
             # Find and serve static files
             self._setup_static_files()
 
@@ -188,7 +211,7 @@ class SocketIOServerCore:
             await self.site.start()
 
             self.running = True
-            self.stats["start_time"] = datetime.now()
+            self.stats["start_time"] = datetime.now(timezone.utc)
 
             self.logger.info(
                 f"Socket.IO server listening on http://{self.host}:{self.port}"
@@ -196,9 +219,16 @@ class SocketIOServerCore:
             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")
+            # Conditionally start heartbeat task based on configuration
+            from ....config.socketio_config import CONNECTION_CONFIG
+
+            if CONNECTION_CONFIG.get("enable_extra_heartbeat", False):
+                self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+                self.logger.info("Started system heartbeat task")
+            else:
+                self.logger.info(
+                    "System heartbeat disabled (using Socket.IO ping/pong instead)"
+                )
 
             # Keep the server running
             while self.running:
@@ -246,24 +276,113 @@ class SocketIOServerCore:
                 # Parse JSON payload
                 event_data = await request.json()
 
-                # Log receipt if debugging
-                event_type = event_data.get("subtype", "unknown")
-                self.logger.debug(f"Received HTTP event: {event_type}")
+                # Log receipt with more detail
+                event_type = (
+                    event_data.get("subtype")
+                    or event_data.get("hook_event_name")
+                    or "unknown"
+                )
+                self.logger.info(f"📨 Received HTTP event: {event_type}")
+                self.logger.debug(f"Event data keys: {list(event_data.keys())}")
+                self.logger.debug(f"Connected clients: {len(self.connected_clients)}")
+
+                # Transform hook event format to claude_event format if needed
+                if "hook_event_name" in event_data and "event" not in event_data:
+                    # This is a raw hook event, transform it
+                    from claude_mpm.services.socketio.event_normalizer import (
+                        EventNormalizer,
+                    )
+
+                    normalizer = EventNormalizer()
+
+                    # Create the format expected by normalizer
+                    raw_event = {
+                        "type": "hook",
+                        "subtype": event_data.get("hook_event_name", "unknown")
+                        .lower()
+                        .replace("submit", "")
+                        .replace("use", "_use"),
+                        "timestamp": event_data.get("timestamp"),
+                        "data": event_data.get("hook_input_data", {}),
+                        "source": "claude_hooks",
+                        "session_id": event_data.get("session_id"),
+                    }
+
+                    # Map hook event names to dashboard subtypes
+                    subtype_map = {
+                        "UserPromptSubmit": "user_prompt",
+                        "PreToolUse": "pre_tool",
+                        "PostToolUse": "post_tool",
+                        "Stop": "stop",
+                        "SubagentStop": "subagent_stop",
+                        "AssistantResponse": "assistant_response",
+                    }
+                    raw_event["subtype"] = subtype_map.get(
+                        event_data.get("hook_event_name"), "unknown"
+                    )
+
+                    normalized = normalizer.normalize(raw_event, source="hook")
+                    event_data = normalized.to_dict()
+                    self.logger.debug(
+                        f"Normalized event: type={event_data.get('type')}, subtype={event_data.get('subtype')}"
+                    )
 
                 # Broadcast to all connected dashboard clients via SocketIO
                 if self.sio:
-                    # The event is already in claude_event format from the hook handler
-                    await self.sio.emit("claude_event", event_data)
+                    # CRITICAL: Use the main server's broadcaster for proper event handling
+                    # The broadcaster handles retries, connection management, and buffering
+                    if (
+                        self.main_server
+                        and hasattr(self.main_server, "broadcaster")
+                        and self.main_server.broadcaster
+                    ):
+                        # The broadcaster expects raw event data and will normalize it
+                        # Since we already normalized it, we need to pass it in a way that won't double-normalize
+                        # We'll emit directly through the broadcaster's sio with proper handling
+
+                        # Add to event buffer and history
+                        with self.buffer_lock:
+                            self.event_buffer.append(event_data)
+                            self.stats["events_buffered"] = len(self.event_buffer)
+
+                        # Add to main server's event history
+                        if hasattr(self.main_server, "event_history"):
+                            self.main_server.event_history.append(event_data)
+
+                        # Use the broadcaster's sio to emit (it's the same as self.sio)
+                        # This ensures the event goes through the proper channels
+                        await self.sio.emit("claude_event", event_data)
+
+                        # Update broadcaster stats
+                        if hasattr(self.main_server.broadcaster, "stats"):
+                            self.main_server.broadcaster.stats["events_sent"] = (
+                                self.main_server.broadcaster.stats.get("events_sent", 0)
+                                + 1
+                            )
+
+                        self.logger.info(
+                            f"✅ Event broadcasted: {event_data.get('subtype', 'unknown')} to {len(self.connected_clients)} clients"
+                        )
+                        self.logger.debug(
+                            f"Connected client IDs: {list(self.connected_clients) if self.connected_clients else 'None'}"
+                        )
+                    else:
+                        # Fallback: Direct emit if broadcaster not available (shouldn't happen)
+                        self.logger.warning(
+                            "Broadcaster not available, using direct emit"
+                        )
+                        await self.sio.emit("claude_event", event_data)
 
-                    # Update stats
-                    self.stats["events_sent"] = self.stats.get("events_sent", 0) + 1
+                        # Update stats manually if using fallback
+                        self.stats["events_sent"] = self.stats.get("events_sent", 0) + 1
 
-                    # Add to event buffer for late-joining clients
-                    with self.buffer_lock:
-                        self.event_buffer.append(event_data)
-                        self.stats["events_buffered"] = len(self.event_buffer)
+                        # Add to event buffer for late-joining clients
+                        with self.buffer_lock:
+                            self.event_buffer.append(event_data)
+                            self.stats["events_buffered"] = len(self.event_buffer)
 
                 # Return 204 No Content for success
+                self.logger.debug(f"✅ HTTP event processed successfully: {event_type}")
                 return web.Response(status=204)
 
             except Exception as e:
@@ -274,6 +393,118 @@ class SocketIOServerCore:
         self.app.router.add_post("/api/events", api_events_handler)
         self.logger.info("✅ HTTP API endpoint registered at /api/events")
 
+        # Add working directory endpoint
+        async def working_directory_handler(request):
+            """Handle GET /api/working-directory to provide current working directory."""
+            from pathlib import Path
+
+            try:
+                working_dir = Path.cwd()
+                home_dir = str(Path.home())
+
+                return web.json_response(
+                    {
+                        "working_directory": working_dir,
+                        "home_directory": home_dir,
+                        "process_cwd": working_dir,
+                        "session_id": getattr(self, "session_id", None),
+                    }
+                )
+            except Exception as e:
+                self.logger.error(f"Error getting working directory: {e}")
+                return web.json_response(
+                    {
+                        "working_directory": "/Users/masa/Projects/claude-mpm",
+                        "home_directory": "/Users/masa",
+                        "error": str(e),
+                    },
+                    status=500,
+                )
+
+        self.app.router.add_get("/api/working-directory", working_directory_handler)
+        self.logger.info(
+            "✅ Working directory endpoint registered at /api/working-directory"
+        )
+
+        # Add file reading endpoint for source viewer
+        async def file_read_handler(request):
+            """Handle GET /api/file/read for reading source files."""
+
+            file_path = request.query.get("path", "")
+
+            if not file_path:
+                return web.json_response({"error": "No path provided"}, status=400)
+
+            abs_path = Path(Path(file_path).resolve().expanduser())
+
+            # Security check - ensure file is within the project
+            try:
+                project_root = Path.cwd()
+                if not abs_path.startswith(project_root):
+                    return web.json_response({"error": "Access denied"}, status=403)
+            except Exception:
+                pass
+
+            if not Path(abs_path).exists():
+                return web.json_response({"error": "File not found"}, status=404)
+
+            if not Path(abs_path).is_file():
+                return web.json_response({"error": "Not a file"}, status=400)
+
+            try:
+                # Read file with appropriate encoding
+                encodings = ["utf-8", "latin-1", "cp1252"]
+                content = None
+
+                for encoding in encodings:
+                    try:
+                        with Path(abs_path).open(
+                            encoding=encoding,
+                        ) as f:
+                            content = f.read()
+                        break
+                    except UnicodeDecodeError:
+                        continue
+
+                if content is None:
+                    return web.json_response(
+                        {"error": "Could not decode file"}, status=400
+                    )
+
+                return web.json_response(
+                    {
+                        "path": abs_path,
+                        "name": Path(abs_path).name,
+                        "content": content,
+                        "lines": len(content.splitlines()),
+                        "size": Path(abs_path).stat().st_size,
+                    }
+                )
+
+            except PermissionError:
+                return web.json_response({"error": "Permission denied"}, status=403)
+            except Exception as e:
+                return web.json_response({"error": str(e)}, status=500)
+
+        self.app.router.add_get("/api/file/read", file_read_handler)
+        self.logger.info("✅ File reading API registered at /api/file/read")
+
+    def _setup_directory_api(self):
+        """Setup simple directory listing API.
+
+        WHY: Provides a dead-simple way to list directory contents via HTTP GET
+        without complex WebSocket interactions.
+        """
+        try:
+            from claude_mpm.dashboard.api.simple_directory import register_routes
+
+            register_routes(self.app)
+            self.logger.info(
+                "✅ Simple directory API registered at /api/directory/list"
+            )
+        except Exception as e:
+            self.logger.error(f"Failed to setup directory API: {e}")
+
     def _setup_static_files(self):
         """Setup static file serving for the dashboard."""
         try:
@@ -324,6 +555,26 @@ class SocketIOServerCore:
 
                 self.app.router.add_get("/dashboard", dashboard_handler)
 
+                # Serve simple code view template at /code-simple
+                async def code_simple_handler(request):
+                    code_simple_template = (
+                        self.dashboard_path.parent / "templates" / "code_simple.html"
+                    )
+                    if code_simple_template.exists():
+                        self.logger.debug(
+                            f"Serving code simple template from: {code_simple_template}"
+                        )
+                        return web.FileResponse(code_simple_template)
+                    # Return error if template doesn't exist
+                    self.logger.warning(
+                        f"Code simple template not found at: {code_simple_template}"
+                    )
+                    return web.Response(
+                        text="Simple code view not available", status=404
+                    )
+
+                self.app.router.add_get("/code-simple", code_simple_handler)
+
                 # Serve version.json from dashboard directory
                 async def version_handler(request):
                     version_file = self.dashboard_path / "version.json"
@@ -498,7 +749,9 @@ class SocketIOServerCore:
                 uptime_seconds = 0
                 if self.stats.get("start_time"):
                     uptime_seconds = int(
-                        (datetime.now() - self.stats["start_time"]).total_seconds()
+                        (
+                            datetime.now(timezone.utc) - self.stats["start_time"]
+                        ).total_seconds()
                     )
 
                 # Get active sessions from main server if available
@@ -515,7 +768,7 @@ class SocketIOServerCore:
                 heartbeat_data = {
                     "type": "system",
                     "subtype": "heartbeat",
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "source": "server",
                     "data": {
                         "uptime_seconds": uptime_seconds,