claude-mpm 4.2.9__py3-none-any.whl → 4.2.12__py3-none-any.whl

claude_mpm/services/monitor/server.py

@@ -0,0 +1,596 @@
+"""
+Unified Monitor Server for Claude MPM
+====================================
+
+WHY: This server combines HTTP dashboard serving and Socket.IO event handling
+into a single, stable process. It uses real AST analysis instead of mock data
+and provides all monitoring functionality on a single port.
+
+DESIGN DECISIONS:
+- Combines aiohttp HTTP server with Socket.IO server
+- Uses real CodeTreeAnalyzer for AST analysis
+- Single port (8765) for all functionality
+- Event-driven architecture with proper handler registration
+- Built for stability and daemon operation
+"""
+
+import asyncio
+import threading
+from pathlib import Path
+from typing import Dict
+
+import socketio
+from aiohttp import web
+
+from ...core.logging_config import get_logger
+from ...dashboard.api.simple_directory import list_directory
+from .event_emitter import get_event_emitter
+from .handlers.code_analysis import CodeAnalysisHandler
+from .handlers.dashboard import DashboardHandler
+from .handlers.hooks import HookHandler
+
+# EventBus integration
+try:
+    from ...services.event_bus import EventBus
+
+    EVENTBUS_AVAILABLE = True
+except ImportError:
+    EventBus = None
+    EVENTBUS_AVAILABLE = False
+
+
+class UnifiedMonitorServer:
+    """Unified server that combines HTTP dashboard and Socket.IO functionality.
+
+    WHY: Provides a single server process that handles all monitoring needs.
+    Replaces multiple competing server implementations with one stable solution.
+    """
+
+    def __init__(self, host: str = "localhost", port: int = 8765):
+        """Initialize the unified monitor server.
+
+        Args:
+            host: Host to bind to
+            port: Port to bind to
+        """
+        self.host = host
+        self.port = port
+        self.logger = get_logger(__name__)
+
+        # Core components
+        self.app = None
+        self.sio = None
+        self.runner = None
+        self.site = None
+
+        # Event handlers
+        self.code_analysis_handler = None
+        self.dashboard_handler = None
+        self.hook_handler = None
+
+        # High-performance event emitter
+        self.event_emitter = None
+
+        # State
+        self.running = False
+        self.loop = None
+        self.server_thread = None
+
+    def start(self) -> bool:
+        """Start the unified monitor server.
+
+        Returns:
+            True if started successfully, False otherwise
+        """
+        try:
+            self.logger.info(
+                f"Starting unified monitor server on {self.host}:{self.port}"
+            )
+
+            # Start in a separate thread to avoid blocking
+            self.server_thread = threading.Thread(target=self._run_server, daemon=True)
+            self.server_thread.start()
+
+            # Wait for server to start
+            import time
+
+            for _ in range(50):  # Wait up to 5 seconds
+                if self.running:
+                    break
+                time.sleep(0.1)
+
+            if not self.running:
+                self.logger.error("Server failed to start within timeout")
+                return False
+
+            self.logger.info("Unified monitor server started successfully")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to start unified monitor server: {e}")
+            return False
+
+    def _run_server(self):
+        """Run the server in its own event loop."""
+        loop = None
+        try:
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self.loop = loop
+
+            # Run the async server
+            loop.run_until_complete(self._start_async_server())
+
+        except Exception as e:
+            self.logger.error(f"Error in server thread: {e}")
+        finally:
+            # Always ensure loop cleanup happens
+            if loop is not None:
+                try:
+                    # Cancel all pending tasks first
+                    self._cancel_all_tasks(loop)
+
+                    # Give tasks a moment to cancel gracefully
+                    if not loop.is_closed():
+                        try:
+                            loop.run_until_complete(asyncio.sleep(0.1))
+                        except RuntimeError:
+                            # Loop might be stopped already, that's ok
+                            pass
+
+                except Exception as e:
+                    self.logger.debug(f"Error during task cancellation: {e}")
+                finally:
+                    try:
+                        # Clear the loop reference from the instance first
+                        self.loop = None
+
+                        # Stop the loop if it's still running
+                        if loop.is_running():
+                            loop.stop()
+
+                        # CRITICAL: Wait a moment for the loop to stop
+                        import time
+
+                        time.sleep(0.1)
+
+                        # Clear the event loop from the thread BEFORE closing
+                        # This prevents other code from accidentally using it
+                        asyncio.set_event_loop(None)
+
+                        # Now close the loop - this is critical to prevent the kqueue error
+                        if not loop.is_closed():
+                            loop.close()
+                            # Wait for the close to complete
+                            time.sleep(0.05)
+
+                    except Exception as e:
+                        self.logger.debug(f"Error during event loop cleanup: {e}")
+
+    async def _start_async_server(self):
+        """Start the async server components."""
+        try:
+            # Create Socket.IO server
+            self.sio = socketio.AsyncServer(
+                cors_allowed_origins="*", logger=False, engineio_logger=False
+            )
+
+            # Create aiohttp application
+            self.app = web.Application()
+
+            # Attach Socket.IO to the app
+            self.sio.attach(self.app)
+
+            # Setup event handlers
+            self._setup_event_handlers()
+
+            # Setup high-performance event emitter
+            await self._setup_event_emitter()
+
+            self.logger.info(
+                "Using high-performance async event architecture with direct calls"
+            )
+
+            # Setup HTTP routes
+            self._setup_http_routes()
+
+            # 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)
+            await self.site.start()
+
+            self.running = True
+            self.logger.info(f"Server running on http://{self.host}:{self.port}")
+
+            # Keep the server running
+            while self.running:
+                await asyncio.sleep(1)
+
+        except Exception as e:
+            self.logger.error(f"Error starting async server: {e}")
+            raise
+        finally:
+            await self._cleanup_async()
+
+    def _setup_event_handlers(self):
+        """Setup Socket.IO event handlers."""
+        try:
+            # Create event handlers
+            self.code_analysis_handler = CodeAnalysisHandler(self.sio)
+            self.dashboard_handler = DashboardHandler(self.sio)
+            self.hook_handler = HookHandler(self.sio)
+
+            # Register handlers
+            self.code_analysis_handler.register()
+            self.dashboard_handler.register()
+            self.hook_handler.register()
+
+            self.logger.info("Event handlers registered successfully")
+
+        except Exception as e:
+            self.logger.error(f"Error setting up event handlers: {e}")
+            raise
+
+    async def _setup_event_emitter(self):
+        """Setup high-performance event emitter."""
+        try:
+            # Get the global event emitter instance
+            self.event_emitter = await get_event_emitter()
+
+            # Register this Socket.IO server for direct event emission
+            self.event_emitter.register_socketio_server(self.sio)
+
+            self.logger.info("Event emitter setup complete - direct calls enabled")
+
+        except Exception as e:
+            self.logger.error(f"Error setting up event emitter: {e}")
+            raise
+
+    def _setup_http_routes(self):
+        """Setup HTTP routes for the dashboard."""
+        try:
+            # Dashboard static files
+            dashboard_dir = Path(__file__).parent.parent.parent / "dashboard"
+
+            # Main dashboard route
+            async def dashboard_index(request):
+                template_path = dashboard_dir / "templates" / "index.html"
+                if template_path.exists():
+                    with open(template_path) as f:
+                        content = f.read()
+                    return web.Response(text=content, content_type="text/html")
+                return web.Response(text="Dashboard not found", status=404)
+
+            # Health check
+            async def health_check(request):
+                return web.json_response(
+                    {
+                        "status": "healthy",
+                        "service": "unified-monitor",
+                        "version": "1.0.0",
+                        "port": self.port,
+                    }
+                )
+
+            # Event ingestion endpoint for hook handlers
+            async def api_events_handler(request):
+                """Handle HTTP POST events from hook handlers."""
+                try:
+                    data = await request.json()
+
+                    # Extract event data
+                    namespace = data.get("namespace", "hook")
+                    event = data.get("event", "claude_event")
+                    event_data = data.get("data", {})
+
+                    # Emit to Socket.IO clients via the appropriate event
+                    if self.sio:
+                        await self.sio.emit(event, event_data)
+                        self.logger.debug(f"HTTP event forwarded to Socket.IO: {event}")
+
+                    return web.Response(status=204)  # No content response
+
+                except Exception as e:
+                    self.logger.error(f"Error handling HTTP event: {e}")
+                    return web.Response(text=f"Error: {e!s}", status=500)
+
+            # File content endpoint for file viewer
+            async def api_file_handler(request):
+                """Handle file content requests."""
+                import json
+                import os
+
+                try:
+                    data = await request.json()
+                    file_path = data.get("path", "")
+
+                    # Security check: ensure path is absolute and exists
+                    if not file_path or not os.path.isabs(file_path):
+                        return web.json_response(
+                            {"success": False, "error": "Invalid file path"}, status=400
+                        )
+
+                    # Check if file exists and is readable
+                    if not os.path.exists(file_path):
+                        return web.json_response(
+                            {"success": False, "error": "File not found"}, status=404
+                        )
+
+                    if not os.path.isfile(file_path):
+                        return web.json_response(
+                            {"success": False, "error": "Path is not a file"},
+                            status=400,
+                        )
+
+                    # Read file content (with size limit for safety)
+                    max_size = 10 * 1024 * 1024  # 10MB limit
+                    file_size = os.path.getsize(file_path)
+
+                    if file_size > max_size:
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": f"File too large (>{max_size} bytes)",
+                            },
+                            status=413,
+                        )
+
+                    try:
+                        with open(file_path, encoding="utf-8") as f:
+                            content = f.read()
+                            lines = content.count("\n") + 1
+                    except UnicodeDecodeError:
+                        # Try reading as binary if UTF-8 fails
+                        return web.json_response(
+                            {"success": False, "error": "File is not a text file"},
+                            status=415,
+                        )
+
+                    # Get file extension for type detection
+                    file_ext = os.path.splitext(file_path)[1].lstrip(".")
+
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "content": content,
+                            "lines": lines,
+                            "size": file_size,
+                            "type": file_ext or "text",
+                        }
+                    )
+
+                except json.JSONDecodeError:
+                    return web.json_response(
+                        {"success": False, "error": "Invalid JSON in request"},
+                        status=400,
+                    )
+                except Exception as e:
+                    self.logger.error(f"Error reading file: {e}")
+                    return web.json_response(
+                        {"success": False, "error": str(e)}, status=500
+                    )
+
+            # Version endpoint for dashboard build tracker
+            async def version_handler(request):
+                """Serve version information for dashboard build tracker."""
+                try:
+                    # Try to get version from version service
+                    from claude_mpm.services.version_service import VersionService
+
+                    version_service = VersionService()
+                    version_info = version_service.get_version_info()
+
+                    return web.json_response(
+                        {
+                            "version": version_info.get("base_version", "1.0.0"),
+                            "build": version_info.get("build_number", 1),
+                            "formatted_build": f"{version_info.get('build_number', 1):04d}",
+                            "full_version": version_info.get("version", "v1.0.0-0001"),
+                            "service": "unified-monitor",
+                        }
+                    )
+                except Exception as e:
+                    self.logger.warning(f"Error getting version info: {e}")
+                    # Return default version info if service fails
+                    return web.json_response(
+                        {
+                            "version": "1.0.0",
+                            "build": 1,
+                            "formatted_build": "0001",
+                            "full_version": "v1.0.0-0001",
+                            "service": "unified-monitor",
+                        }
+                    )
+
+            # Register routes
+            self.app.router.add_get("/", dashboard_index)
+            self.app.router.add_get("/health", health_check)
+            self.app.router.add_get("/version.json", version_handler)
+            self.app.router.add_get("/api/directory", list_directory)
+            self.app.router.add_post("/api/events", api_events_handler)
+            self.app.router.add_post("/api/file", api_file_handler)
+
+            # Static files
+            static_dir = dashboard_dir / "static"
+            if static_dir.exists():
+                self.app.router.add_static("/static/", static_dir)
+
+            # Templates
+            templates_dir = dashboard_dir / "templates"
+            if templates_dir.exists():
+                self.app.router.add_static("/templates/", templates_dir)
+
+            self.logger.info("HTTP routes registered successfully")
+
+        except Exception as e:
+            self.logger.error(f"Error setting up HTTP routes: {e}")
+            raise
+
+    def stop(self):
+        """Stop the unified monitor server."""
+        try:
+            self.logger.info("Stopping unified monitor server")
+
+            # Signal shutdown first
+            self.running = False
+
+            # If we have a loop, schedule the cleanup
+            if self.loop and not self.loop.is_closed():
+                try:
+                    # Use call_soon_threadsafe to schedule cleanup from another thread
+                    future = asyncio.run_coroutine_threadsafe(
+                        self._graceful_shutdown(), self.loop
+                    )
+                    # Wait for cleanup to complete (with timeout)
+                    future.result(timeout=3)
+                except Exception as e:
+                    self.logger.debug(f"Error during graceful shutdown: {e}")
+
+            # Wait for server thread to finish with a reasonable timeout
+            if self.server_thread and self.server_thread.is_alive():
+                self.server_thread.join(timeout=5)
+
+                # If thread is still alive after timeout, log a warning
+                if self.server_thread.is_alive():
+                    self.logger.warning("Server thread did not stop within timeout")
+
+            # Clear all references to help with cleanup
+            self.server_thread = None
+            self.app = None
+            self.sio = None
+            self.runner = None
+            self.site = None
+            self.event_emitter = None
+
+            # Give the system a moment to cleanup resources
+            import time
+
+            time.sleep(0.2)
+
+            self.logger.info("Unified monitor server stopped")
+
+        except Exception as e:
+            self.logger.error(f"Error stopping unified monitor server: {e}")
+
+    async def _cleanup_async(self):
+        """Cleanup async resources."""
+        try:
+            # Close the Socket.IO server first to stop accepting new connections
+            if self.sio:
+                try:
+                    await self.sio.shutdown()
+                    self.logger.debug("Socket.IO shutdown complete")
+                except Exception as e:
+                    self.logger.debug(f"Error shutting down Socket.IO: {e}")
+                finally:
+                    self.sio = None
+
+            # Cleanup event emitter
+            if self.event_emitter:
+                try:
+                    if self.sio:
+                        self.event_emitter.unregister_socketio_server(self.sio)
+
+                    # Use the global cleanup function to ensure proper cleanup
+                    from .event_emitter import cleanup_event_emitter
+
+                    await cleanup_event_emitter()
+
+                    self.logger.info("Event emitter cleaned up")
+                except Exception as e:
+                    self.logger.warning(f"Error cleaning up event emitter: {e}")
+                finally:
+                    self.event_emitter = None
+
+            # Stop the site (must be done before runner cleanup)
+            if self.site:
+                try:
+                    await self.site.stop()
+                    self.logger.debug("Site stopped")
+                except Exception as e:
+                    self.logger.debug(f"Error stopping site: {e}")
+                finally:
+                    self.site = None
+
+            # Cleanup the runner (after site is stopped)
+            if self.runner:
+                try:
+                    await self.runner.cleanup()
+                    self.logger.debug("Runner cleaned up")
+                except Exception as e:
+                    self.logger.debug(f"Error cleaning up runner: {e}")
+                finally:
+                    self.runner = None
+
+            # Clear app reference
+            self.app = None
+
+        except Exception as e:
+            self.logger.error(f"Error during async cleanup: {e}")
+
+    def get_status(self) -> Dict:
+        """Get server status information.
+
+        Returns:
+            Dictionary with server status
+        """
+        return {
+            "server_running": self.running,
+            "host": self.host,
+            "port": self.port,
+            "handlers": {
+                "code_analysis": self.code_analysis_handler is not None,
+                "dashboard": self.dashboard_handler is not None,
+                "hooks": self.hook_handler is not None,
+            },
+        }
+
+    def _cancel_all_tasks(self, loop=None):
+        """Cancel all pending tasks in the event loop."""
+        if loop is None:
+            loop = self.loop
+
+        if not loop or loop.is_closed():
+            return
+
+        try:
+            # Get all tasks in the loop
+            pending = asyncio.all_tasks(loop)
+
+            # Count tasks to cancel
+            tasks_to_cancel = [task for task in pending if not task.done()]
+
+            if tasks_to_cancel:
+                # Cancel each task
+                for task in tasks_to_cancel:
+                    task.cancel()
+
+                # Wait for all tasks to complete cancellation
+                gather = asyncio.gather(*tasks_to_cancel, return_exceptions=True)
+                try:
+                    loop.run_until_complete(gather)
+                except Exception:
+                    # Some tasks might fail to cancel, that's ok
+                    pass
+
+                self.logger.debug(f"Cancelled {len(tasks_to_cancel)} pending tasks")
+        except Exception as e:
+            self.logger.debug(f"Error cancelling tasks: {e}")
+
+    async def _graceful_shutdown(self):
+        """Perform graceful shutdown of async resources."""
+        try:
+            # Stop accepting new connections
+            self.running = False
+
+            # Give ongoing operations a moment to complete
+            await asyncio.sleep(0.5)
+
+            # Then cleanup resources
+            await self._cleanup_async()
+
+        except Exception as e:
+            self.logger.debug(f"Error in graceful shutdown: {e}")

claude_mpm/tools/code_tree_analyzer.py

@@ -1727,27 +1727,43 @@ class CodeTreeAnalyzer:
 
     def _is_internal_node(self, node: CodeNode) -> bool:
         """Check if node is an internal function that should be filtered."""
-        # Filter patterns for internal functions
-        internal_patterns = [
-            "handle",  # Event handlers
-            "on_",  # Event callbacks
-            "_",  # Private methods
-            "get_",  # Simple getters
-            "set_",  # Simple setters
-            "__",  # Python magic methods
-        ]
+        # Don't filter classes - always show them
+        if node.node_type == "class":
+            return False
+
+        # Don't filter variables or imports - they're useful for tree view
+        if node.node_type in ["variable", "import"]:
+            return False
 
         name_lower = node.name.lower()
 
-        # Don't filter classes or important public methods
-        if node.node_type == "class":
-            return False
+        # Filter only very specific internal patterns
+        # Be more conservative - only filter obvious internal handlers
+        if name_lower.startswith("handle_") or name_lower.startswith("on_"):
+            return True
+
+        # Filter Python magic methods except important ones
+        if name_lower.startswith("__") and name_lower.endswith("__"):
+            # Keep important magic methods
+            important_magic = [
+                "__init__",
+                "__call__",
+                "__enter__",
+                "__exit__",
+                "__str__",
+                "__repr__",
+            ]
+            return node.name not in important_magic
 
-        # Check patterns
-        for pattern in internal_patterns:
-            if name_lower.startswith(pattern):
-                # Exception: include __init__ methods
-                return node.name != "__init__"
+        # Filter very generic getters/setters only if they're trivial
+        if (name_lower.startswith("get_") or name_lower.startswith("set_")) and len(
+            node.name
+        ) <= 8:
+            return True
+
+        # Don't filter single underscore functions - they're often important
+        # (like _setup_logging, _validate_input, etc.)
+        return False
 
         return False
 

{claude_mpm-4.2.9.dist-info → claude_mpm-4.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.9
+Version: 4.2.12
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team