claude-mpm 4.1.11__py3-none-any.whl → 4.1.13__py3-none-any.whl

claude_mpm/services/cli/socketio_manager.py

@@ -172,10 +172,18 @@ class SocketIOManager(ISocketIOManager):
 
             # Check if server already running on this port
             if self.is_server_running(target_port):
-                self.logger.info(
-                    f"Socket.IO server already running on port {target_port}"
+                # Verify the server is healthy and responding
+                if self.wait_for_server(target_port, timeout=2):
+                    self.logger.info(
+                        f"Healthy Socket.IO server already running on port {target_port}"
+                    )
+                    return True, self.get_server_info(target_port)
+                # Server exists but not responding, try to clean it up
+                self.logger.warning(
+                    f"Socket.IO server on port {target_port} not responding, attempting cleanup"
                 )
-                return True, self.get_server_info(target_port)
+                self.stop_server(port=target_port, timeout=5)
+                # Continue with starting a new server
 
             # Ensure dependencies are available
             deps_ok, error_msg = self.ensure_dependencies()
@@ -459,14 +467,37 @@ class SocketIOManager(ISocketIOManager):
         Returns:
             Available port number
         """
-        # Try preferred port first
+        # First check if our Socket.IO server is already running on the preferred port
+        if self.is_server_running(preferred_port):
+            # Check if it's healthy
+            if self.wait_for_server(preferred_port, timeout=2):
+                self.logger.info(
+                    f"Healthy Socket.IO server already running on port {preferred_port}"
+                )
+                return preferred_port
+            self.logger.warning(
+                f"Socket.IO server on port {preferred_port} not responding, will try to restart"
+            )
+
+        # Try preferred port first if available
         if self.port_manager.is_port_available(preferred_port):
             return preferred_port
 
-        # Find alternative port
-        available_port = self.port_manager.get_available_port(preferred_port)
-        self.logger.info(f"Port {preferred_port} unavailable, using {available_port}")
-        return available_port
+        # Find alternative port using the correct method name
+        available_port = self.port_manager.find_available_port(
+            preferred_port=preferred_port, reclaim=True
+        )
+
+        if available_port:
+            self.logger.info(
+                f"Port {preferred_port} unavailable, using {available_port}"
+            )
+            return available_port
+        # If no port found, raise an error
+        raise RuntimeError(
+            f"No available ports in range {self.port_manager.PORT_RANGE.start}-"
+            f"{self.port_manager.PORT_RANGE.stop-1}"
+        )
 
     def ensure_dependencies(self) -> Tuple[bool, Optional[str]]:
         """

claude_mpm/services/infrastructure/monitoring.py

@@ -30,7 +30,7 @@ For backward compatibility, legacy classes are still available:
 """
 
 # Re-export all components from the modular implementation
-from .monitoring import (  # noqa: F401; New service-based API; Base components; Legacy compatibility
+from .monitoring import (
     AdvancedHealthMonitor,
     HealthChecker,
     HealthCheckResult,

claude_mpm/services/socketio/handlers/code_analysis.py

@@ -216,56 +216,22 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             )
             return
 
-        # ADDITIONAL SECURITY: Ensure path is within working directory bounds
-        # This prevents access to system directories like /Users, /System, etc.
-        working_dir = Path.cwd().absolute()
-        try:
-            requested_path = Path(path).absolute()
-            # This will raise ValueError if path is not within working_dir
-            requested_path.relative_to(working_dir)
-        except ValueError:
-            self.logger.warning(
-                f"Access denied - path outside working directory: {path}"
-            )
-            await self.server.core.sio.emit(
-                "code:analysis:error",
-                {
-                    "error": f"Access denied: Path outside working directory: {path}",
-                    "request_id": data.get("request_id"),
-                    "path": path,
-                },
-                room=sid,
-            )
-            return
+        # SECURITY: Validate the requested path
+        # Allow access to the explicitly chosen working directory and its subdirectories
+        requested_path = Path(path).absolute()
+
+        # For now, we trust the frontend to send valid paths
+        # In production, you might want to maintain a server-side list of allowed directories
+        # or implement a more sophisticated permission system
+
+        # Basic sanity checks are done below after creating the Path object
 
         ignore_patterns = data.get("ignore_patterns", [])
         request_id = data.get("request_id")
-        show_hidden_files = data.get("show_hidden_files", False)
-        
-        # Extensive debug logging
-        self.logger.info(f"[DEBUG] handle_discover_top_level START")
-        self.logger.info(f"[DEBUG] Received show_hidden_files={show_hidden_files} (type: {type(show_hidden_files)})")
-        self.logger.info(f"[DEBUG] Current analyzer exists: {self.code_analyzer is not None}")
-        if self.code_analyzer:
-            current_value = getattr(self.code_analyzer, 'show_hidden_files', 'NOT_FOUND')
-            self.logger.info(f"[DEBUG] Current analyzer show_hidden_files={current_value}")
-        self.logger.info(f"[DEBUG] Full request data: {data}")
 
         try:
-            # Create analyzer if needed or recreate if show_hidden_files changed
-            current_show_hidden = getattr(self.code_analyzer, 'show_hidden_files', None) if self.code_analyzer else None
-            need_recreate = (
-                not self.code_analyzer or 
-                current_show_hidden != show_hidden_files
-            )
-            
-            self.logger.info(f"[DEBUG] Analyzer recreation check:")
-            self.logger.info(f"[DEBUG]   - Analyzer exists: {self.code_analyzer is not None}")
-            self.logger.info(f"[DEBUG]   - Current show_hidden: {current_show_hidden}")
-            self.logger.info(f"[DEBUG]   - Requested show_hidden: {show_hidden_files}")
-            self.logger.info(f"[DEBUG]   - Need recreate: {need_recreate}")
-            
-            if need_recreate:
+            # Create analyzer if needed
+            if not self.code_analyzer:
                 # Create a custom emitter that sends to Socket.IO
                 emitter = CodeTreeEventEmitter(use_stdout=False)
                 # Override emit method to send to Socket.IO
@@ -276,14 +242,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 ):
                     # Keep the original event format with colons - frontend expects this!
                     # The frontend listens for 'code:directory:discovered' not 'code.directory.discovered'
-                    
+
                     # Special handling for 'info' events - they should be passed through directly
-                    if event_type == 'info':
+                    if event_type == "info":
                         # INFO events for granular tracking
                         loop = asyncio.get_event_loop()
                         loop.create_task(
                             self.server.core.sio.emit(
-                                'info', {"request_id": request_id, **event_data}
+                                "info", {"request_id": request_id, **event_data}
                             )
                         )
                     else:
@@ -298,14 +264,9 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                     original_emit(event_type, event_data, batch)
 
                 emitter.emit = socket_emit
-                # Initialize CodeTreeAnalyzer with emitter keyword argument and show_hidden_files
-                self.logger.info(f"[DEBUG] Creating new CodeTreeAnalyzer with show_hidden_files={show_hidden_files}")
-                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter, show_hidden_files=show_hidden_files)
-                self.logger.info(f"[DEBUG] CodeTreeAnalyzer created:")
-                self.logger.info(f"[DEBUG]   - analyzer.show_hidden_files={self.code_analyzer.show_hidden_files}")
-                self.logger.info(f"[DEBUG]   - gitignore_manager.show_hidden_files={self.code_analyzer.gitignore_manager.show_hidden_files}")
-            else:
-                self.logger.info(f"[DEBUG] Reusing existing analyzer with show_hidden_files={self.code_analyzer.show_hidden_files}")
+                # Initialize CodeTreeAnalyzer with emitter keyword argument
+                self.logger.info("Creating CodeTreeAnalyzer")
+                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
 
             # Use the provided path as-is - the frontend sends the absolute path
             # Make sure we're using an absolute path
@@ -341,17 +302,7 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 f"Discovering top-level contents of: {directory.absolute()}"
             )
 
-            # Log before discovery
-            self.logger.info(f"[DEBUG] About to discover with analyzer.show_hidden_files={self.code_analyzer.show_hidden_files}")
-            
             result = self.code_analyzer.discover_top_level(directory, ignore_patterns)
-            
-            # Log what we got back
-            num_items = len(result.get("children", []))
-            dotfiles = [c for c in result.get("children", []) if c.get("name", "").startswith(".")]
-            self.logger.info(f"[DEBUG] Discovery result: {num_items} items, {len(dotfiles)} dotfiles")
-            if dotfiles:
-                self.logger.info(f"[DEBUG] Dotfiles found: {[d.get('name') for d in dotfiles]}")
 
             # Send result to client with correct event name for top level discovery
             await self.server.core.sio.emit(
@@ -404,7 +355,6 @@ class CodeAnalysisEventHandler(BaseEventHandler):
         path = data.get("path")
         ignore_patterns = data.get("ignore_patterns", [])
         request_id = data.get("request_id")
-        show_hidden_files = data.get("show_hidden_files", False)
 
         if not path:
             await self.server.core.sio.emit(
@@ -432,21 +382,34 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             )
             return
 
-        # ADDITIONAL SECURITY: Ensure path is within working directory bounds
-        # This prevents access to system directories like /Users, /System, etc.
-        working_dir = Path.cwd().absolute()
-        try:
-            requested_path = Path(path).absolute()
-            # This will raise ValueError if path is not within working_dir
-            requested_path.relative_to(working_dir)
-        except ValueError:
-            self.logger.warning(
-                f"Access denied - path outside working directory: {path}"
+        # SECURITY: Validate the requested path
+        # Allow access to the explicitly chosen working directory and its subdirectories
+        requested_path = Path(path).absolute()
+
+        # For now, we trust the frontend to send valid paths
+        # In production, you might want to maintain a server-side list of allowed directories
+        # or implement a more sophisticated permission system
+
+        # Basic sanity checks
+        if not requested_path.exists():
+            self.logger.warning(f"Path does not exist: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"Path does not exist: {path}",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
             )
+            return
+
+        if not requested_path.is_dir():
+            self.logger.warning(f"Path is not a directory: {path}")
             await self.server.core.sio.emit(
                 "code:analysis:error",
                 {
-                    "error": f"Access denied: Path outside working directory: {path}",
+                    "error": f"Path is not a directory: {path}",
                     "request_id": request_id,
                     "path": path,
                 },
@@ -455,20 +418,8 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             return
 
         try:
-            # Ensure analyzer exists or recreate if show_hidden_files changed
-            current_show_hidden = getattr(self.code_analyzer, 'show_hidden_files', None) if self.code_analyzer else None
-            need_recreate = (
-                not self.code_analyzer or 
-                current_show_hidden != show_hidden_files
-            )
-            
-            self.logger.info(f"[DEBUG] Analyzer recreation check:")
-            self.logger.info(f"[DEBUG]   - Analyzer exists: {self.code_analyzer is not None}")
-            self.logger.info(f"[DEBUG]   - Current show_hidden: {current_show_hidden}")
-            self.logger.info(f"[DEBUG]   - Requested show_hidden: {show_hidden_files}")
-            self.logger.info(f"[DEBUG]   - Need recreate: {need_recreate}")
-            
-            if need_recreate:
+            # Ensure analyzer exists
+            if not self.code_analyzer:
                 emitter = CodeTreeEventEmitter(use_stdout=False)
                 # Override emit method to send to Socket.IO
                 original_emit = emitter.emit
@@ -478,14 +429,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 ):
                     # Keep the original event format with colons - frontend expects this!
                     # The frontend listens for 'code:directory:discovered' not 'code.directory.discovered'
-                    
+
                     # Special handling for 'info' events - they should be passed through directly
-                    if event_type == 'info':
+                    if event_type == "info":
                         # INFO events for granular tracking
                         loop = asyncio.get_event_loop()
                         loop.create_task(
                             self.server.core.sio.emit(
-                                'info', {"request_id": request_id, **event_data}
+                                "info", {"request_id": request_id, **event_data}
                             )
                         )
                     else:
@@ -499,17 +450,19 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                     original_emit(event_type, event_data, batch)
 
                 emitter.emit = socket_emit
-                # Initialize CodeTreeAnalyzer with emitter keyword argument and show_hidden_files
-                self.logger.info(f"[DEBUG] Creating new CodeTreeAnalyzer with show_hidden_files={show_hidden_files}")
-                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter, show_hidden_files=show_hidden_files)
-                self.logger.info(f"[DEBUG] CodeTreeAnalyzer created, analyzer.show_hidden_files={self.code_analyzer.show_hidden_files}")
-                self.logger.info(f"[DEBUG] GitignoreManager.show_hidden_files={self.code_analyzer.gitignore_manager.show_hidden_files}")
-            else:
-                self.logger.info(f"[DEBUG] Reusing analyzer with show_hidden_files={self.code_analyzer.show_hidden_files}")
+                # Initialize CodeTreeAnalyzer with emitter keyword argument
+                self.logger.info("Creating CodeTreeAnalyzer")
+                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
 
             # Discover directory
             result = self.code_analyzer.discover_directory(path, ignore_patterns)
 
+            # Log what we're sending
+            self.logger.info(
+                f"Discovery result for {path}: {len(result.get('children', []))} children found"
+            )
+            self.logger.debug(f"Full result: {result}")
+
             # Send result with correct event name (using colons, not dots!)
             await self.server.core.sio.emit(
                 "code:directory:discovered",
@@ -571,20 +524,30 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             )
             return
 
-        # ADDITIONAL SECURITY: Ensure file is within working directory bounds
-        working_dir = Path.cwd().absolute()
-        try:
-            requested_path = Path(path).absolute()
-            # This will raise ValueError if path is not within working_dir
-            requested_path.relative_to(working_dir)
-        except ValueError:
-            self.logger.warning(
-                f"Access denied - file outside working directory: {path}"
+        # SECURITY: Validate the requested file path
+        # Allow access to files within the explicitly chosen working directory
+        requested_path = Path(path).absolute()
+
+        # Basic sanity checks
+        if not requested_path.exists():
+            self.logger.warning(f"File does not exist: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"File does not exist: {path}",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
             )
+            return
+
+        if not requested_path.is_file():
+            self.logger.warning(f"Path is not a file: {path}")
             await self.server.core.sio.emit(
                 "code:analysis:error",
                 {
-                    "error": f"Access denied: File outside working directory: {path}",
+                    "error": f"Path is not a file: {path}",
                     "request_id": request_id,
                     "path": path,
                 },
@@ -593,20 +556,8 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             return
 
         try:
-            # Ensure analyzer exists or recreate if show_hidden_files changed
-            current_show_hidden = getattr(self.code_analyzer, 'show_hidden_files', None) if self.code_analyzer else None
-            need_recreate = (
-                not self.code_analyzer or 
-                current_show_hidden != show_hidden_files
-            )
-            
-            self.logger.info(f"[DEBUG] Analyzer recreation check:")
-            self.logger.info(f"[DEBUG]   - Analyzer exists: {self.code_analyzer is not None}")
-            self.logger.info(f"[DEBUG]   - Current show_hidden: {current_show_hidden}")
-            self.logger.info(f"[DEBUG]   - Requested show_hidden: {show_hidden_files}")
-            self.logger.info(f"[DEBUG]   - Need recreate: {need_recreate}")
-            
-            if need_recreate:
+            # Ensure analyzer exists
+            if not self.code_analyzer:
                 emitter = CodeTreeEventEmitter(use_stdout=False)
                 # Override emit method to send to Socket.IO
                 original_emit = emitter.emit
@@ -616,14 +567,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 ):
                     # Keep the original event format with colons - frontend expects this!
                     # The frontend listens for 'code:file:analyzed' not 'code.file.analyzed'
-                    
+
                     # Special handling for 'info' events - they should be passed through directly
-                    if event_type == 'info':
+                    if event_type == "info":
                         # INFO events for granular tracking
                         loop = asyncio.get_event_loop()
                         loop.create_task(
                             self.server.core.sio.emit(
-                                'info', {"request_id": request_id, **event_data}
+                                "info", {"request_id": request_id, **event_data}
                             )
                         )
                     else:
@@ -637,13 +588,9 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                     original_emit(event_type, event_data, batch)
 
                 emitter.emit = socket_emit
-                # Initialize CodeTreeAnalyzer with emitter keyword argument and show_hidden_files
-                self.logger.info(f"[DEBUG] Creating new CodeTreeAnalyzer with show_hidden_files={show_hidden_files}")
-                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter, show_hidden_files=show_hidden_files)
-                self.logger.info(f"[DEBUG] CodeTreeAnalyzer created, analyzer.show_hidden_files={self.code_analyzer.show_hidden_files}")
-                self.logger.info(f"[DEBUG] GitignoreManager.show_hidden_files={self.code_analyzer.gitignore_manager.show_hidden_files}")
-            else:
-                self.logger.info(f"[DEBUG] Reusing analyzer with show_hidden_files={self.code_analyzer.show_hidden_files}")
+                # Initialize CodeTreeAnalyzer with emitter keyword argument
+                self.logger.info("Creating CodeTreeAnalyzer")
+                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
 
             # Analyze file
             result = self.code_analyzer.analyze_file(path)