claude-mpm 5.4.22__py3-none-any.whl → 5.6.34__py3-none-any.whl

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -7,16 +7,29 @@ This service manages:
 DESIGN DECISION: Use stateless HTTP POST instead of persistent SocketIO
 connections because hook handlers are ephemeral processes (< 1 second lifetime).
 This eliminates disconnection issues and matches the process lifecycle.
+
+DESIGN DECISION: Synchronous HTTP POST only (no async)
+Hook handlers are too short-lived (~25ms lifecycle) to benefit from async.
+Using asyncio.run() creates event loops that close before HTTP operations complete,
+causing "Event loop is closed" errors. Synchronous HTTP POST in a thread pool
+is simpler and more reliable for ephemeral processes.
 """
 
-import asyncio
 import os
-import sys
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 
-# Debug mode is enabled by default for better visibility into hook processing
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
+# Debug mode - disabled by default to prevent logging overhead in production
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Import requests for HTTP POST communication
 try:
@@ -27,9 +40,6 @@ except ImportError:
     REQUESTS_AVAILABLE = False
     requests = None
 
-# Import high-performance event emitter - lazy loaded in _async_emit()
-# to reduce hook handler initialization time by ~85% (792ms -> minimal)
-
 # Import EventNormalizer for consistent event formatting
 try:
     from claude_mpm.services.socketio.event_normalizer import EventNormalizer
@@ -55,10 +65,6 @@ except ImportError:
             )
 
 
-# EventBus removed - using direct HTTP POST only
-# This eliminates duplicate events and simplifies the architecture
-
-
 class ConnectionManagerService:
     """Manages connections for the Claude hook handler using HTTP POST."""
 
@@ -72,35 +78,26 @@ class ConnectionManagerService:
         self.server_port = int(os.environ.get("CLAUDE_MPM_SERVER_PORT", "8765"))
         self.http_endpoint = f"http://{self.server_host}:{self.server_port}/api/events"
 
-        # EventBus removed - using direct HTTP POST only
-
-        # For backward compatibility with tests
-        self.connection_pool = None  # No longer used
-
-        # Track async emit tasks to prevent garbage collection
-        self._emit_tasks: set = set()
-
         # Thread pool for non-blocking HTTP requests
         # WHY: Prevents HTTP POST from blocking hook processing (2s timeout → 0ms blocking)
-        # max_workers=2: Sufficient for low-frequency HTTP fallback events
+        # max_workers=2: Sufficient for low-frequency hook events
         self._http_executor = ThreadPoolExecutor(
             max_workers=2, thread_name_prefix="http-emit"
         )
 
         if DEBUG:
-            print(
-                f"✅ HTTP connection manager initialized - endpoint: {self.http_endpoint}",
-                file=sys.stderr,
+            _log(
+                f"✅ HTTP connection manager initialized - endpoint: {self.http_endpoint}"
             )
 
     def emit_event(self, namespace: str, event: str, data: dict):
-        """Emit event using high-performance async emitter with HTTP fallback.
+        """Emit event using HTTP POST.
 
-        WHY Hybrid approach:
-        - Direct async calls for ultra-low latency in-process events
-        - HTTP POST fallback for cross-process communication
-        - Connection pooling for memory protection
-        - Automatic routing based on availability
+        WHY HTTP POST only:
+        - Hook handlers are ephemeral (~25ms lifecycle)
+        - Async emission causes "Event loop is closed" errors
+        - HTTP POST in thread pool is simpler and more reliable
+        - Completes in 20-50ms, which is acceptable for hook handlers
         """
         # Create event data for normalization
         raw_event = {
@@ -120,74 +117,17 @@ class ConnectionManagerService:
         if DEBUG and event in ["subagent_stop", "pre_tool"]:
             if event == "subagent_stop":
                 agent_type = data.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing SubagentStop for agent '{agent_type}'",
-                    file=sys.stderr,
-                )
+                _log(f"Hook handler: Publishing SubagentStop for agent '{agent_type}'")
             elif event == "pre_tool" and data.get("tool_name") == "Task":
                 delegation = data.get("delegation_details", {})
                 agent_type = delegation.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'",
-                    file=sys.stderr,
+                _log(
+                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'"
                 )
 
-        # Try high-performance async emitter first (direct calls)
-        success = self._try_async_emit(namespace, event, claude_event_data)
-        if success:
-            return
-
-        # Fallback to HTTP POST for cross-process communication
+        # Emit via HTTP POST (non-blocking, runs in thread pool)
         self._try_http_emit(namespace, event, claude_event_data)
 
-    def _try_async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Try to emit event using high-performance async emitter."""
-        try:
-            # Run async emission in the current event loop or create one
-            loop = None
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                # No running loop, create a new one
-                pass
-
-            if loop:
-                # We're in an async context, create a task with tracking
-                task = loop.create_task(self._async_emit(namespace, event, data))
-                self._emit_tasks.add(task)
-                task.add_done_callback(self._emit_tasks.discard)
-                # Don't wait for completion to maintain low latency
-                if DEBUG:
-                    print(f"✅ Async emit scheduled: {event}", file=sys.stderr)
-                return True
-            # No event loop, run synchronously
-            success = asyncio.run(self._async_emit(namespace, event, data))
-            if DEBUG and success:
-                print(f"✅ Async emit successful: {event}", file=sys.stderr)
-            return success
-
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emit failed: {e}", file=sys.stderr)
-            return False
-
-    async def _async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Async helper for event emission."""
-        try:
-            # Lazy load event emitter to reduce initialization overhead
-            from claude_mpm.services.monitor.event_emitter import get_event_emitter
-
-            emitter = await get_event_emitter()
-            return await emitter.emit_event(namespace, "claude_event", data)
-        except ImportError:
-            if DEBUG:
-                print("⚠️ Event emitter not available", file=sys.stderr)
-            return False
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emitter error: {e}", file=sys.stderr)
-            return False
-
     def _try_http_emit(self, namespace: str, event: str, data: dict):
         """Try to emit event using HTTP POST fallback (non-blocking).
 
@@ -196,10 +136,7 @@ class ConnectionManagerService:
         """
         if not REQUESTS_AVAILABLE:
             if DEBUG:
-                print(
-                    "⚠️ requests module not available - cannot emit via HTTP",
-                    file=sys.stderr,
-                )
+                _log("⚠️ requests module not available - cannot emit via HTTP")
             return
 
         # Submit to thread pool - don't wait for result (fire-and-forget)
@@ -225,25 +162,21 @@ class ConnectionManagerService:
 
             if response.status_code in [200, 204]:
                 if DEBUG:
-                    print(f"✅ HTTP POST successful: {event}", file=sys.stderr)
+                    _log(f"✅ HTTP POST successful: {event}")
             elif DEBUG:
-                print(
-                    f"⚠️ HTTP POST failed with status {response.status_code}: {event}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ HTTP POST failed with status {response.status_code}: {event}")
 
         except requests.exceptions.Timeout:
             if DEBUG:
-                print(f"⚠️ HTTP POST timeout for: {event}", file=sys.stderr)
+                _log(f"⚠️ HTTP POST timeout for: {event}")
         except requests.exceptions.ConnectionError:
             if DEBUG:
-                print(
-                    f"⚠️ HTTP POST connection failed for: {event} (server not running?)",
-                    file=sys.stderr,
+                _log(
+                    f"⚠️ HTTP POST connection failed for: {event} (server not running?)"
                 )
         except Exception as e:
             if DEBUG:
-                print(f"⚠️ HTTP POST error for {event}: {e}", file=sys.stderr)
+                _log(f"⚠️ HTTP POST error for {event}: {e}")
 
     def cleanup(self):
         """Cleanup connections on service destruction."""
@@ -251,4 +184,4 @@ class ConnectionManagerService:
         if hasattr(self, "_http_executor"):
             self._http_executor.shutdown(wait=False)
             if DEBUG:
-                print("✅ HTTP executor shutdown", file=sys.stderr)
+                _log("✅ HTTP executor shutdown")

claude_mpm/hooks/claude_hooks/services/container.py

@@ -0,0 +1,310 @@
+"""Dependency Injection container for hook handler services.
+
+This module provides a DI container that manages service instantiation,
+lazy initialization, and service overriding for testing.
+
+WHY DI Container:
+- Centralized service management
+- Lazy initialization reduces startup overhead
+- Easy testing through service overriding
+- Clear dependency graph
+- Thread-safe singleton pattern
+"""
+
+import threading
+from typing import Any, Optional, TypeVar
+
+# Import service protocols for type hints
+from .protocols import (
+    IAutoPauseHandler,
+    IConnectionManager,
+    IDuplicateDetector,
+    IEventHandlers,
+    IMemoryHookManager,
+    IResponseTrackingManager,
+    IStateManager,
+    ISubagentProcessor,
+)
+
+T = TypeVar("T")
+
+
+class HookServiceContainer:
+    """Dependency injection container for hook handler services.
+
+    Features:
+    - Lazy initialization of services
+    - Thread-safe singleton pattern
+    - Service overriding for testing
+    - Automatic dependency resolution
+
+    Usage:
+        # Normal usage (services created lazily)
+        container = HookServiceContainer()
+        state_manager = container.get_state_manager()
+
+        # Testing usage (override services)
+        container = HookServiceContainer()
+        container.override_state_manager(mock_state_manager)
+        state_manager = container.get_state_manager()  # Returns mock
+
+        # Reset overrides
+        container.reset_overrides()
+    """
+
+    # Thread-safe singleton
+    _instance: Optional["HookServiceContainer"] = None
+    _lock = threading.Lock()
+
+    def __new__(cls) -> "HookServiceContainer":
+        """Thread-safe singleton pattern."""
+        if cls._instance is None:
+            with cls._lock:
+                # Double-check locking pattern
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self) -> None:
+        """Initialize container if not already initialized."""
+        if getattr(self, "_initialized", False):
+            return
+
+        # Service instances (lazily initialized)
+        self._state_manager: Optional[IStateManager] = None
+        self._connection_manager: Optional[IConnectionManager] = None
+        self._duplicate_detector: Optional[IDuplicateDetector] = None
+        self._response_tracking_manager: Optional[IResponseTrackingManager] = None
+        self._memory_hook_manager: Optional[IMemoryHookManager] = None
+        self._subagent_processor: Optional[ISubagentProcessor] = None
+        self._auto_pause_handler: Optional[IAutoPauseHandler] = None
+        self._event_handlers: Optional[IEventHandlers] = None
+
+        # Override factories for testing
+        self._overrides: dict[str, Any] = {}
+
+        # Lock for lazy initialization
+        self._init_lock = threading.Lock()
+
+        self._initialized = True
+
+    # =========================================================================
+    # Lazy Service Getters
+    # =========================================================================
+
+    def get_state_manager(self) -> IStateManager:
+        """Get or create StateManagerService instance."""
+        if "state_manager" in self._overrides:
+            return self._overrides["state_manager"]
+
+        if self._state_manager is None:
+            with self._init_lock:
+                if self._state_manager is None:
+                    from .state_manager import StateManagerService
+
+                    self._state_manager = StateManagerService()
+        return self._state_manager
+
+    def get_connection_manager(self) -> IConnectionManager:
+        """Get or create ConnectionManagerService instance."""
+        if "connection_manager" in self._overrides:
+            return self._overrides["connection_manager"]
+
+        if self._connection_manager is None:
+            with self._init_lock:
+                if self._connection_manager is None:
+                    from .connection_manager_http import ConnectionManagerService
+
+                    self._connection_manager = ConnectionManagerService()
+        return self._connection_manager
+
+    def get_duplicate_detector(self) -> IDuplicateDetector:
+        """Get or create DuplicateEventDetector instance."""
+        if "duplicate_detector" in self._overrides:
+            return self._overrides["duplicate_detector"]
+
+        if self._duplicate_detector is None:
+            with self._init_lock:
+                if self._duplicate_detector is None:
+                    from .duplicate_detector import DuplicateEventDetector
+
+                    self._duplicate_detector = DuplicateEventDetector()
+        return self._duplicate_detector
+
+    def get_response_tracking_manager(self) -> IResponseTrackingManager:
+        """Get or create ResponseTrackingManager instance."""
+        if "response_tracking_manager" in self._overrides:
+            return self._overrides["response_tracking_manager"]
+
+        if self._response_tracking_manager is None:
+            with self._init_lock:
+                if self._response_tracking_manager is None:
+                    from ..response_tracking import ResponseTrackingManager
+
+                    self._response_tracking_manager = ResponseTrackingManager()
+        return self._response_tracking_manager
+
+    def get_memory_hook_manager(self) -> IMemoryHookManager:
+        """Get or create MemoryHookManager instance."""
+        if "memory_hook_manager" in self._overrides:
+            return self._overrides["memory_hook_manager"]
+
+        if self._memory_hook_manager is None:
+            with self._init_lock:
+                if self._memory_hook_manager is None:
+                    from ..memory_integration import MemoryHookManager
+
+                    self._memory_hook_manager = MemoryHookManager()
+        return self._memory_hook_manager
+
+    def get_auto_pause_handler(self) -> Optional[IAutoPauseHandler]:
+        """Get or create AutoPauseHandler instance.
+
+        Returns None if initialization fails (auto-pause is optional).
+        """
+        if "auto_pause_handler" in self._overrides:
+            return self._overrides["auto_pause_handler"]
+
+        if self._auto_pause_handler is None:
+            with self._init_lock:
+                if self._auto_pause_handler is None:
+                    try:
+                        from ..auto_pause_handler import AutoPauseHandler
+
+                        self._auto_pause_handler = AutoPauseHandler()
+                    except Exception:
+                        # Auto-pause is optional
+                        self._auto_pause_handler = None
+        return self._auto_pause_handler
+
+    def get_subagent_processor(
+        self,
+        state_manager: Optional[IStateManager] = None,
+        response_tracking_manager: Optional[IResponseTrackingManager] = None,
+        connection_manager: Optional[IConnectionManager] = None,
+    ) -> ISubagentProcessor:
+        """Get or create SubagentResponseProcessor instance.
+
+        Args:
+            state_manager: Optional override for state manager
+            response_tracking_manager: Optional override for response tracking
+            connection_manager: Optional override for connection manager
+        """
+        if "subagent_processor" in self._overrides:
+            return self._overrides["subagent_processor"]
+
+        if self._subagent_processor is None:
+            with self._init_lock:
+                if self._subagent_processor is None:
+                    from .subagent_processor import SubagentResponseProcessor
+
+                    # Use provided dependencies or get from container
+                    sm = state_manager or self.get_state_manager()
+                    rtm = (
+                        response_tracking_manager
+                        or self.get_response_tracking_manager()
+                    )
+                    cm = connection_manager or self.get_connection_manager()
+
+                    self._subagent_processor = SubagentResponseProcessor(sm, rtm, cm)
+        return self._subagent_processor
+
+    def get_event_handlers(self, hook_handler: Any = None) -> IEventHandlers:
+        """Get or create EventHandlers instance.
+
+        Args:
+            hook_handler: The ClaudeHookHandler instance for backward compatibility.
+                         In the future, this will be replaced with proper DI.
+        """
+        if "event_handlers" in self._overrides:
+            return self._overrides["event_handlers"]
+
+        if self._event_handlers is None:
+            with self._init_lock:
+                if self._event_handlers is None:
+                    from ..event_handlers import EventHandlers
+
+                    if hook_handler is None:
+                        raise ValueError(
+                            "hook_handler is required to create EventHandlers"
+                        )
+                    self._event_handlers = EventHandlers(hook_handler)
+        return self._event_handlers
+
+    # =========================================================================
+    # Service Override Methods (for testing)
+    # =========================================================================
+
+    def override_state_manager(self, service: IStateManager) -> None:
+        """Override state manager with a mock or custom implementation."""
+        self._overrides["state_manager"] = service
+
+    def override_connection_manager(self, service: IConnectionManager) -> None:
+        """Override connection manager with a mock or custom implementation."""
+        self._overrides["connection_manager"] = service
+
+    def override_duplicate_detector(self, service: IDuplicateDetector) -> None:
+        """Override duplicate detector with a mock or custom implementation."""
+        self._overrides["duplicate_detector"] = service
+
+    def override_response_tracking_manager(
+        self, service: IResponseTrackingManager
+    ) -> None:
+        """Override response tracking manager with a mock or custom implementation."""
+        self._overrides["response_tracking_manager"] = service
+
+    def override_memory_hook_manager(self, service: IMemoryHookManager) -> None:
+        """Override memory hook manager with a mock or custom implementation."""
+        self._overrides["memory_hook_manager"] = service
+
+    def override_subagent_processor(self, service: ISubagentProcessor) -> None:
+        """Override subagent processor with a mock or custom implementation."""
+        self._overrides["subagent_processor"] = service
+
+    def override_auto_pause_handler(self, service: Optional[IAutoPauseHandler]) -> None:
+        """Override auto-pause handler with a mock or custom implementation."""
+        self._overrides["auto_pause_handler"] = service
+
+    def override_event_handlers(self, service: IEventHandlers) -> None:
+        """Override event handlers with a mock or custom implementation."""
+        self._overrides["event_handlers"] = service
+
+    def reset_overrides(self) -> None:
+        """Reset all service overrides."""
+        self._overrides.clear()
+
+    def reset_all(self) -> None:
+        """Reset all services and overrides.
+
+        Useful for testing to ensure clean state between tests.
+        """
+        self._state_manager = None
+        self._connection_manager = None
+        self._duplicate_detector = None
+        self._response_tracking_manager = None
+        self._memory_hook_manager = None
+        self._subagent_processor = None
+        self._auto_pause_handler = None
+        self._event_handlers = None
+        self._overrides.clear()
+
+    @classmethod
+    def reset_singleton(cls) -> None:
+        """Reset the singleton instance.
+
+        USE WITH CAUTION: This is primarily for testing.
+        """
+        with cls._lock:
+            if cls._instance is not None:
+                cls._instance.reset_all()
+            cls._instance = None
+
+
+def get_container() -> HookServiceContainer:
+    """Get the global HookServiceContainer singleton.
+
+    Returns:
+        The singleton HookServiceContainer instance.
+    """
+    return HookServiceContainer()