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

claude_mpm/services/socketio/handlers/code_analysis.py

@@ -41,6 +41,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
         self.logger = get_logger(__name__)
         self.analysis_runner = None
         self.code_analyzer = None  # For lazy loading operations
+        self._emit_tasks: set = set()  # Track emit tasks to prevent GC
+
+    def _create_emit_task(self, coro):
+        """Create a tracked emit task to prevent garbage collection."""
+        task = asyncio.get_event_loop().create_task(coro)
+        self._emit_tasks.add(task)
+        task.add_done_callback(self._emit_tasks.discard)
+        return task
 
     def initialize(self):
         """Initialize the analysis runner."""
@@ -218,7 +226,7 @@ class CodeAnalysisEventHandler(BaseEventHandler):
 
         # SECURITY: Validate the requested path
         # Allow access to the explicitly chosen working directory and its subdirectories
-        requested_path = Path(path).absolute()
+        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
@@ -246,16 +254,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                     # Special handling for 'info' events - they should be passed through directly
                     if event_type == "info":
                         # INFO events for granular tracking
-                        loop = asyncio.get_event_loop()
-                        loop.create_task(
+                        self._create_emit_task(
                             self.server.core.sio.emit(
                                 "info", {"request_id": request_id, **event_data}
                             )
                         )
                     else:
                         # Regular code analysis events
-                        loop = asyncio.get_event_loop()
-                        loop.create_task(
+                        self._create_emit_task(
                             self.server.core.sio.emit(
                                 event_type, {"request_id": request_id, **event_data}
                             )
@@ -266,7 +272,11 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 emitter.emit = socket_emit
                 # Initialize CodeTreeAnalyzer with emitter keyword argument
                 self.logger.info("Creating CodeTreeAnalyzer")
-                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
+                # Pass emit_events=False to prevent duplicate events from the analyzer
+                # The emitter will still work but the analyzer won't create its own stdout emitter
+                self.code_analyzer = CodeTreeAnalyzer(
+                    emit_events=False, emitter=emitter
+                )
 
             # Use the provided path as-is - the frontend sends the absolute path
             # Make sure we're using an absolute path
@@ -433,16 +443,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                     # Special handling for 'info' events - they should be passed through directly
                     if event_type == "info":
                         # INFO events for granular tracking
-                        loop = asyncio.get_event_loop()
-                        loop.create_task(
+                        self._create_emit_task(
                             self.server.core.sio.emit(
                                 "info", {"request_id": request_id, **event_data}
                             )
                         )
                     else:
                         # Regular code analysis events
-                        loop = asyncio.get_event_loop()
-                        loop.create_task(
+                        self._create_emit_task(
                             self.server.core.sio.emit(
                                 event_type, {"request_id": request_id, **event_data}
                             )
@@ -452,7 +460,11 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 emitter.emit = socket_emit
                 # Initialize CodeTreeAnalyzer with emitter keyword argument
                 self.logger.info("Creating CodeTreeAnalyzer")
-                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
+                # Pass emit_events=False to prevent duplicate events from the analyzer
+                # The emitter will still work but the analyzer won't create its own stdout emitter
+                self.code_analyzer = CodeTreeAnalyzer(
+                    emit_events=False, emitter=emitter
+                )
 
             # Discover directory
             result = self.code_analyzer.discover_directory(path, ignore_patterns)
@@ -463,14 +475,41 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             )
             self.logger.debug(f"Full result: {result}")
 
+            # DEBUG: Log exact children being sent
+            children = result.get("children", [])
+            if children:
+                self.logger.info(
+                    f"Children being sent: {[child.get('name') for child in children]}"
+                )
+                self.logger.info(f"Full children data: {children}")
+            else:
+                self.logger.warning(f"No children found for {path}")
+
+            # Prepare the response data
+            response_data = {
+                "request_id": request_id,
+                "path": path,  # Absolute path as requested
+                "name": Path(path).name,  # Just the directory name for display
+                "type": result.get("type", "directory"),
+                "children": children,  # Send children array directly
+            }
+
+            # CRITICAL DEBUG: Log exact JSON that will be sent
+            import json
+
+            self.logger.info(
+                f"Sending response data (JSON): {json.dumps(response_data, indent=2)}"
+            )
+            self.logger.info(
+                f"Children count in response: {len(response_data.get('children', []))}"
+            )
+
             # Send result with correct event name (using colons, not dots!)
+            # Include both absolute path and relative name for frontend compatibility
+            # IMPORTANT: Don't use **result as it overwrites path and name
             await self.server.core.sio.emit(
                 "code:directory:discovered",
-                {
-                    "request_id": request_id,
-                    "path": path,
-                    **result,
-                },
+                response_data,
                 room=sid,
             )
 
@@ -497,7 +536,7 @@ class CodeAnalysisEventHandler(BaseEventHandler):
 
         path = data.get("path")
         request_id = data.get("request_id")
-        show_hidden_files = data.get("show_hidden_files", False)
+        data.get("show_hidden_files", False)
 
         if not path:
             await self.server.core.sio.emit(
@@ -556,8 +595,11 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             return
 
         try:
+            self.logger.info(f"Starting file analysis for: {path}")
+
             # Ensure analyzer exists
             if not self.code_analyzer:
+                self.logger.info("Creating new CodeTreeAnalyzer instance")
                 emitter = CodeTreeEventEmitter(use_stdout=False)
                 # Override emit method to send to Socket.IO
                 original_emit = emitter.emit
@@ -571,16 +613,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                     # Special handling for 'info' events - they should be passed through directly
                     if event_type == "info":
                         # INFO events for granular tracking
-                        loop = asyncio.get_event_loop()
-                        loop.create_task(
+                        self._create_emit_task(
                             self.server.core.sio.emit(
                                 "info", {"request_id": request_id, **event_data}
                             )
                         )
                     else:
                         # Regular code analysis events
-                        loop = asyncio.get_event_loop()
-                        loop.create_task(
+                        self._create_emit_task(
                             self.server.core.sio.emit(
                                 event_type, {"request_id": request_id, **event_data}
                             )
@@ -590,24 +630,47 @@ class CodeAnalysisEventHandler(BaseEventHandler):
                 emitter.emit = socket_emit
                 # Initialize CodeTreeAnalyzer with emitter keyword argument
                 self.logger.info("Creating CodeTreeAnalyzer")
-                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
+                # Pass emit_events=False to prevent duplicate events from the analyzer
+                # The emitter will still work but the analyzer won't create its own stdout emitter
+                self.code_analyzer = CodeTreeAnalyzer(
+                    emit_events=False, emitter=emitter
+                )
+                self.logger.info("CodeTreeAnalyzer created successfully")
 
             # Analyze file
+            self.logger.info(f"Calling analyze_file for: {path}")
             result = self.code_analyzer.analyze_file(path)
+            self.logger.info(
+                f"Analysis complete. Result keys: {list(result.keys()) if result else 'None'}"
+            )
+
+            if result:
+                self.logger.info(
+                    f"Analysis result: elements={len(result.get('elements', []))}, nodes={len(result.get('nodes', []))}"
+                )
+            else:
+                self.logger.warning("Analysis returned None or empty result")
 
             # Send result with correct event name (using colons, not dots!)
+            response_data = {
+                "request_id": request_id,
+                "path": path,
+                **result,
+            }
+
+            self.logger.info(f"Emitting code:file:analyzed event to {sid}")
             await self.server.core.sio.emit(
                 "code:file:analyzed",
-                {
-                    "request_id": request_id,
-                    "path": path,
-                    **result,
-                },
+                response_data,
                 room=sid,
             )
+            self.logger.info("Event emitted successfully")
 
         except Exception as e:
             self.logger.error(f"Error analyzing file {path}: {e}")
+            import traceback
+
+            self.logger.error(f"Full traceback: {traceback.format_exc()}")
             await self.server.core.sio.emit(
                 "code:analysis:error",
                 {

claude_mpm/services/socketio/handlers/connection.py

@@ -8,11 +8,15 @@ from other handlers makes connection management more maintainable.
 import asyncio
 import functools
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional
 
+from claude_mpm.core.logging_utils import get_logger
+
 from .base import BaseEventHandler
 
+logger = get_logger(__name__)
+
 
 def timeout_handler(timeout_seconds: float = 5.0):
     """Decorator to add timeout protection to async handlers.
@@ -39,49 +43,26 @@ def timeout_handler(timeout_seconds: float = 5.0):
 
                 elapsed = time.time() - start_time
                 if elapsed > timeout_seconds * 0.8:  # Warn if close to timeout
-                    # Try to get logger from closure scope or fallback to print
-                    try:
-                        import logging
-
-                        logger = logging.getLogger(__name__)
-                        logger.warning(
-                            f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
-                            f"(close to {timeout_seconds}s timeout)"
-                        )
-                    except:
-                        print(
-                            f"⚠️ Handler {handler_name} took {elapsed:.2f}s (close to {timeout_seconds}s timeout)"
-                        )
+                    logger.warning(
+                        f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
+                        f"(close to {timeout_seconds}s timeout)"
+                    )
 
                 return result
 
             except asyncio.TimeoutError:
                 elapsed = time.time() - start_time
-                # Try to get logger from closure scope or fallback to print
-                try:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.error(
-                        f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
-                    )
-                except:
-                    print(f"❌ Handler {handler_name} timed out after {elapsed:.2f}s")
+                logger.error(
+                    f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
+                )
 
                 return None
 
             except Exception as e:
                 elapsed = time.time() - start_time
-                # Try to get logger from closure scope or fallback to print
-                try:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.error(
-                        f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
-                    )
-                except:
-                    print(f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}")
+                logger.error(
+                    f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
+                )
                 raise
 
         return wrapper
@@ -274,7 +255,7 @@ class ConnectionEventHandler(BaseEventHandler):
             # Force disconnect if still connected
             try:
                 await self.sio.disconnect(sid)
-            except:
+            except Exception:
                 pass  # Already disconnected
 
             self.logger.info(f"🔌 Cleaned up stale connection: {sid}")
@@ -326,7 +307,7 @@ class ConnectionEventHandler(BaseEventHandler):
             status_data = {
                 "type": "connection",
                 "subtype": "status",
-                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                 "source": "server",
                 "session_id": self.server.session_id,
                 "data": {
@@ -348,13 +329,13 @@ class ConnectionEventHandler(BaseEventHandler):
                     {
                         "type": "connection",
                         "subtype": "welcome",
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                         "source": "server",
                         "session_id": self.server.session_id,
                         "data": {
                             "message": "Connected to Claude MPM Socket.IO server",
                             "client_id": sid,
-                            "server_time": datetime.utcnow().isoformat() + "Z",
+                            "server_time": datetime.now(timezone.utc).isoformat() + "Z",
                             "build_info": monitor_build_info,
                         },
                     },
@@ -401,7 +382,7 @@ class ConnectionEventHandler(BaseEventHandler):
             status_data = {
                 "type": "connection",
                 "subtype": "status",
-                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                 "source": "server",
                 "session_id": self.server.session_id,
                 "data": {
@@ -456,7 +437,7 @@ class ConnectionEventHandler(BaseEventHandler):
                 {
                     "type": "connection",
                     "subtype": "subscribed",
-                    "timestamp": datetime.utcnow().isoformat() + "Z",
+                    "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                     "source": "server",
                     "data": {"channels": channels},
                 },

claude_mpm/services/socketio/handlers/connection_handler.py

@@ -8,7 +8,7 @@ DESIGN DECISION: Centralized connection event handling ensures consistent
 state management and provides resilient event delivery across reconnections.
 """
 
-from datetime import datetime
+from datetime import datetime, timezone
 
 from .base import BaseEventHandler
 
@@ -50,7 +50,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     # Store client info
                     self.server.client_info[sid] = {
                         "client_id": conn.client_id,
-                        "connected_at": datetime.now().isoformat(),
+                        "connected_at": datetime.now(timezone.utc).isoformat(),
                         "user_agent": environ.get("HTTP_USER_AGENT", "unknown"),
                         "remote_addr": environ.get("REMOTE_ADDR", "unknown"),
                     }
@@ -61,7 +61,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                         {
                             "client_id": conn.client_id,
                             "sid": sid,
-                            "timestamp": datetime.now().isoformat(),
+                            "timestamp": datetime.now(timezone.utc).isoformat(),
                             "server_version": self.get_server_version(),
                         },
                         room=sid,
@@ -120,7 +120,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     self.server.stats["connections_total"] += 1
 
                     self.server.client_info[sid] = {
-                        "connected_at": datetime.now().isoformat(),
+                        "connected_at": datetime.now(timezone.utc).isoformat(),
                         "user_agent": environ.get("HTTP_USER_AGENT", "unknown"),
                         "remote_addr": environ.get("REMOTE_ADDR", "unknown"),
                     }
@@ -185,8 +185,8 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                 await sio.emit(
                     "pong",
                     {
-                        "timestamp": datetime.now().isoformat(),
-                        "server_time": datetime.now().timestamp(),
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                        "server_time": datetime.now(timezone.utc).timestamp(),
                     },
                     room=sid,
                 )
@@ -210,7 +210,10 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     # Optional: Send confirmation
                     await sio.emit(
                         "ack_confirmed",
-                        {"sequence": sequence, "timestamp": datetime.now().isoformat()},
+                        {
+                            "sequence": sequence,
+                            "timestamp": datetime.now(timezone.utc).isoformat(),
+                        },
                         room=sid,
                     )
 
@@ -263,7 +266,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
             """Get connection statistics for debugging."""
             try:
                 stats = {
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "total_connections": len(self.server.connected_clients),
                     "server_stats": self.server.stats,
                 }
@@ -312,7 +315,7 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
                     if self.server.stats.get("start_time")
                     else None
                 ),
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             }
 
             await self.server.core.sio.emit("server_status", status_data, room=sid)
@@ -326,5 +329,5 @@ class EnhancedConnectionEventHandler(BaseEventHandler):
             from claude_mpm.services.version_service import VersionService
 
             return VersionService().get_version()
-        except:
+        except Exception:
             return "unknown"

claude_mpm/services/socketio/handlers/file.py

@@ -5,7 +5,6 @@ safely with security checks. Separating file operations improves security
 auditing and makes it easier to add file-related features.
 """
 
-import os
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -24,6 +23,12 @@ class FileEventHandler(BaseEventHandler):
 
     def register_events(self) -> None:
         """Register file operation event handlers."""
+        self.logger.info(
+            "[FileEventHandler] Starting registration of read_file event handler"
+        )
+
+        # Capture self reference to avoid closure issues
+        handler_self = self
 
         @self.sio.event
         async def read_file(sid, data):
@@ -33,13 +38,19 @@ class FileEventHandler(BaseEventHandler):
             click on files, but we must ensure secure file access with
             proper validation and size limits.
             """
+            handler_self.logger.info(
+                f"[FileEventHandler] Received read_file event from {sid} with data: {data}"
+            )
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
                 max_size = data.get("max_size", 1024 * 1024)  # 1MB default limit
 
                 if not file_path:
-                    await self.emit_to_client(
+                    handler_self.logger.warning(
+                        f"[FileEventHandler] Missing file_path in request from {sid}"
+                    )
+                    await handler_self.emit_to_client(
                         sid,
                         "file_content_response",
                         {
@@ -51,14 +62,29 @@ class FileEventHandler(BaseEventHandler):
                     return
 
                 # Use the shared file reading logic
-                result = await self._read_file_safely(file_path, working_dir, max_size)
+                handler_self.logger.info(
+                    f"[FileEventHandler] Reading file: {file_path} from working_dir: {working_dir}"
+                )
+                result = await handler_self._read_file_safely(
+                    file_path, working_dir, max_size
+                )
 
                 # Send the result back to the client
-                await self.emit_to_client(sid, "file_content_response", result)
+                handler_self.logger.info(
+                    f"[FileEventHandler] Sending file_content_response to {sid}, success: {result.get('success', False)}"
+                )
+                await handler_self.emit_to_client(sid, "file_content_response", result)
+                handler_self.logger.info(
+                    f"[FileEventHandler] Response sent successfully to {sid}"
+                )
 
             except Exception as e:
-                self.log_error("read_file", e, data)
-                await self.emit_to_client(
+                handler_self.logger.error(
+                    f"[FileEventHandler] Exception in read_file handler: {e}",
+                    exc_info=True,
+                )
+                handler_self.log_error("read_file", e, data)
+                await handler_self.emit_to_client(
                     sid,
                     "file_content_response",
                     {
@@ -67,6 +93,14 @@ class FileEventHandler(BaseEventHandler):
                         "file_path": data.get("file_path", "unknown"),
                     },
                 )
+                handler_self.logger.info(
+                    f"[FileEventHandler] Error response sent to {sid}"
+                )
+
+        # Log successful registration
+        self.logger.info(
+            "[FileEventHandler] read_file event handler registered successfully"
+        )
 
     async def _read_file_safely(
         self,
@@ -90,7 +124,7 @@ class FileEventHandler(BaseEventHandler):
         """
         try:
             if working_dir is None:
-                working_dir = os.getcwd()
+                working_dir = Path.cwd()
 
             # Resolve absolute path based on working directory
             file_path_obj = Path(file_path)
@@ -156,7 +190,9 @@ class FileEventHandler(BaseEventHandler):
 
             # Read file content
             try:
-                with open(real_path, encoding="utf-8") as f:
+                with Path(real_path).open(
+                    encoding="utf-8",
+                ) as f:
                     content = f.read()
 
                 # Get file extension for syntax highlighting hint
@@ -189,7 +225,7 @@ class FileEventHandler(BaseEventHandler):
         be displayed as text.
         """
         try:
-            with open(real_path, "rb") as f:
+            with real_path.open("rb") as f:
                 binary_content = f.read()
 
             # Check if it's a text file by looking for common text patterns

claude_mpm/services/socketio/handlers/git.py

@@ -106,7 +106,7 @@ class GitEventHandler(BaseEventHandler):
             """
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
 
                 if not file_path:
                     await self.emit_to_client(
@@ -162,7 +162,7 @@ class GitEventHandler(BaseEventHandler):
             """
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
 
                 # Debug: check_git_status called
 
@@ -287,7 +287,7 @@ class GitEventHandler(BaseEventHandler):
             """
             try:
                 file_path = data.get("file_path")
-                working_dir = data.get("working_dir", os.getcwd())
+                working_dir = data.get("working_dir", Path.cwd())
 
                 # Debug: git_add_file called
 
@@ -389,7 +389,7 @@ class GitEventHandler(BaseEventHandler):
         if working_dir in invalid_states or (
             isinstance(working_dir, str) and working_dir.strip() == ""
         ):
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
             self.logger.info(
                 f"[{operation}] working_dir was invalid ({original_working_dir!r}), using cwd: {working_dir}"
             )
@@ -404,7 +404,7 @@ class GitEventHandler(BaseEventHandler):
                 self.logger.warning(
                     f"[{operation}] working_dir contains null bytes, using cwd instead"
                 )
-                working_dir = os.getcwd()
+                working_dir = Path.cwd()
 
         return working_dir
 
@@ -640,7 +640,7 @@ class GitEventHandler(BaseEventHandler):
 
             # Handle case where working_dir is None, empty string, or 'Unknown'
             if not working_dir or working_dir == "Unknown" or working_dir.strip() == "":
-                working_dir = os.getcwd()
+                working_dir = Path.cwd()
                 # Debug: working_dir was invalid, using cwd
             else:
                 # Debug: Using provided working_dir
@@ -648,7 +648,7 @@ class GitEventHandler(BaseEventHandler):
 
             # For read-only git operations, we can work from any directory
             # by passing the -C flag to git commands instead of changing directories
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             try:
                 # We'll use git -C <working_dir> for all commands instead of chdir
 
@@ -792,7 +792,7 @@ class GitEventHandler(BaseEventHandler):
                         stdout=asyncio.subprocess.PIPE,
                         stderr=asyncio.subprocess.PIPE,
                     )
-                    diff_output, diff_error = await diff_proc.communicate()
+                    diff_output, _diff_error = await diff_proc.communicate()
 
                     if diff_proc.returncode == 0:
                         return {