claude-mpm 5.4.85__py3-none-any.whl → 5.6.76__py3-none-any.whl

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -8,13 +8,21 @@ with their original requests.
 import json
 import os
 import re
-import sys
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Optional
 
+# 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
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Response tracking integration
 # NOTE: ResponseTracker import moved to _initialize_response_tracking() for lazy loading
@@ -80,10 +88,7 @@ class ResponseTrackingManager:
 
             if not (response_tracking_enabled or response_logging_enabled):
                 if DEBUG:
-                    print(
-                        "Response tracking disabled - skipping initialization",
-                        file=sys.stderr,
-                    )
+                    _log("Response tracking disabled - skipping initialization")
                 return
 
             # Initialize response tracker with config
@@ -101,15 +106,11 @@ class ResponseTrackingManager:
                     if self.track_all_interactions
                     else "Task delegations only"
                 )
-                print(
-                    f"✅ Response tracking initialized (mode: {mode})", file=sys.stderr
-                )
+                _log(f"✅ Response tracking initialized (mode: {mode})")
 
         except Exception as e:
             if DEBUG:
-                print(
-                    f"❌ Failed to initialize response tracking: {e}", file=sys.stderr
-                )
+                _log(f"❌ Failed to initialize response tracking: {e}")
             # Don't fail the entire handler - response tracking is optional
 
     def track_agent_response(
@@ -130,12 +131,11 @@ class ResponseTrackingManager:
 
         try:
             # Get the original request data stored during pre-tool
-            request_info = delegation_requests.get(session_id)
+            request_info = delegation_requests.get(session_id)  # nosec B113 - False positive: dict.get(), not requests library
             if not request_info:
                 if DEBUG:
-                    print(
-                        f"No request data found for session {session_id}, skipping response tracking",
-                        file=sys.stderr,
+                    _log(
+                        f"No request data found for session {session_id}, skipping response tracking"
                     )
                 return
 
@@ -163,15 +163,11 @@ class ResponseTrackingManager:
                 if json_match:
                     structured_response = json.loads(json_match.group(1))
                     if DEBUG:
-                        print(
-                            f"Extracted structured response from {agent_type} agent",
-                            file=sys.stderr,
-                        )
+                        _log(f"Extracted structured response from {agent_type} agent")
             except (json.JSONDecodeError, AttributeError) as e:
                 if DEBUG:
-                    print(
-                        f"No structured JSON response found in {agent_type} agent output: {e}",
-                        file=sys.stderr,
+                    _log(
+                        f"No structured JSON response found in {agent_type} agent output: {e}"
                     )
 
             # Get the original request (prompt + description)
@@ -220,9 +216,8 @@ class ResponseTrackingManager:
                 if structured_response.get("MEMORIES"):
                     if DEBUG:
                         memories_count = len(structured_response["MEMORIES"])
-                        print(
-                            f"Agent {agent_type} returned MEMORIES field with {memories_count} items",
-                            file=sys.stderr,
+                        _log(
+                            f"Agent {agent_type} returned MEMORIES field with {memories_count} items"
                         )
 
                 # Check if task was completed for logging purposes
@@ -232,9 +227,7 @@ class ResponseTrackingManager:
                 # Log files modified for debugging
                 if DEBUG and structured_response.get("files_modified"):
                     files = [f["file"] for f in structured_response["files_modified"]]
-                    print(
-                        f"Agent {agent_type} modified files: {files}", file=sys.stderr
-                    )
+                    _log(f"Agent {agent_type} modified files: {files}")
 
             # Track the response
             file_path = self.response_tracker.track_response(
@@ -246,14 +239,12 @@ class ResponseTrackingManager:
             )
 
             if file_path and DEBUG:
-                print(
-                    f"✅ Tracked response for {agent_type} agent in session {session_id}: {file_path.name}",
-                    file=sys.stderr,
+                _log(
+                    f"✅ Tracked response for {agent_type} agent in session {session_id}: {file_path.name}"
                 )
             elif DEBUG and not file_path:
-                print(
-                    f"Response tracking returned None for {agent_type} agent (might be excluded or disabled)",
-                    file=sys.stderr,
+                _log(
+                    f"Response tracking returned None for {agent_type} agent (might be excluded or disabled)"
                 )
 
             # Clean up the request data after successful tracking
@@ -261,7 +252,7 @@ class ResponseTrackingManager:
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to track agent response: {e}", file=sys.stderr)
+                _log(f"❌ Failed to track agent response: {e}")
             # Don't fail the hook processing - response tracking is optional
 
     def track_stop_response(
@@ -286,11 +277,10 @@ class ResponseTrackingManager:
             prompt_data = pending_prompts.get(session_id)
 
             if DEBUG:
-                print(
-                    f"  - output present: {bool(output)} (length: {len(str(output)) if output else 0})",
-                    file=sys.stderr,
+                _log(
+                    f"  - output present: {bool(output)} (length: {len(str(output)) if output else 0})"
                 )
-                print(f"  - prompt_data present: {bool(prompt_data)}", file=sys.stderr)
+                _log(f"  - prompt_data present: {bool(prompt_data)}")
 
             if output and prompt_data:
                 # Add prompt timestamp to metadata
@@ -300,12 +290,11 @@ class ResponseTrackingManager:
                 if "stop_reason" in event:
                     metadata["stop_reason"] = event["stop_reason"]
                     if DEBUG:
-                        print(
-                            f"  - Captured stop_reason: {event['stop_reason']}",
-                            file=sys.stderr,
-                        )
+                        _log(f"  - Captured stop_reason: {event['stop_reason']}")
 
                 # Capture Claude API usage data if available
+                # NOTE: Usage data is already captured in metadata by handle_stop_fast()
+                # which also handles auto-pause triggering (even when response tracking disabled)
                 if "usage" in event:
                     usage_data = event["usage"]
                     metadata["usage"] = {
@@ -322,10 +311,7 @@ class ResponseTrackingManager:
                         total_tokens = usage_data.get(
                             "input_tokens", 0
                         ) + usage_data.get("output_tokens", 0)
-                        print(
-                            f"  - Captured usage: {total_tokens} total tokens",
-                            file=sys.stderr,
-                        )
+                        _log(f"  - Captured usage: {total_tokens} total tokens")
 
                 # Track the main Claude response
                 file_path = self.response_tracker.track_response(
@@ -337,14 +323,14 @@ class ResponseTrackingManager:
                 )
 
                 if file_path and DEBUG:
-                    print(f"  - Response tracked to: {file_path}", file=sys.stderr)
+                    _log(f"  - Response tracked to: {file_path}")
 
                 # Clean up pending prompt
                 del pending_prompts[session_id]
 
         except Exception as e:
             if DEBUG:
-                print(f"Error tracking stop response: {e}", file=sys.stderr)
+                _log(f"Error tracking stop response: {e}")
 
     def track_assistant_response(self, event: dict, pending_prompts: dict):
         """Handle assistant response events for comprehensive response tracking."""
@@ -359,9 +345,8 @@ class ResponseTrackingManager:
         prompt_data = pending_prompts.get(session_id)
         if not prompt_data:
             if DEBUG:
-                print(
-                    f"No stored prompt for session {session_id[:8]}..., skipping response tracking",
-                    file=sys.stderr,
+                _log(
+                    f"No stored prompt for session {session_id[:8]}..., skipping response tracking"
                 )
             return
 
@@ -375,9 +360,8 @@ class ResponseTrackingManager:
 
             if not response_content:
                 if DEBUG:
-                    print(
-                        f"No response content in event for session {session_id[:8]}...",
-                        file=sys.stderr,
+                    _log(
+                        f"No response content in event for session {session_id[:8]}..."
                     )
                 return
 
@@ -399,9 +383,8 @@ class ResponseTrackingManager:
             )
 
             if file_path and DEBUG:
-                print(
-                    f"✅ Tracked Claude response for session {session_id[:8]}...: {file_path.name}",
-                    file=sys.stderr,
+                _log(
+                    f"✅ Tracked Claude response for session {session_id[:8]}...: {file_path.name}"
                 )
 
             # Clean up the stored prompt
@@ -409,4 +392,4 @@ class ResponseTrackingManager:
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to track assistant response: {e}", file=sys.stderr)
+                _log(f"❌ Failed to track assistant response: {e}")

claude_mpm/hooks/claude_hooks/services/__init__.py

@@ -3,13 +3,34 @@
 # Use HTTP-based connection manager for stable dashboard communication
 # from .connection_manager import ConnectionManagerService  # Old SocketIO-based
 from .connection_manager_http import ConnectionManagerService  # New HTTP-based
+from .container import HookServiceContainer, get_container
 from .duplicate_detector import DuplicateEventDetector
+from .protocols import (
+    IAutoPauseHandler,
+    IConnectionManager,
+    IDuplicateDetector,
+    IEventHandlers,
+    IMemoryHookManager,
+    IResponseTrackingManager,
+    IStateManager,
+    ISubagentProcessor,
+)
 from .state_manager import StateManagerService
 from .subagent_processor import SubagentResponseProcessor
 
 __all__ = [
     "ConnectionManagerService",
     "DuplicateEventDetector",
+    "HookServiceContainer",
+    "IAutoPauseHandler",
+    "IConnectionManager",
+    "IDuplicateDetector",
+    "IEventHandlers",
+    "IMemoryHookManager",
+    "IResponseTrackingManager",
+    "IStateManager",
+    "ISubagentProcessor",
     "StateManagerService",
     "SubagentResponseProcessor",
+    "get_container",
 ]

claude_mpm/hooks/claude_hooks/services/connection_manager.py

@@ -20,8 +20,17 @@ import os
 import sys
 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 extracted modules with fallback for direct execution
 try:
@@ -94,13 +103,10 @@ class ConnectionManagerService:
         try:
             self.connection_pool = get_connection_pool()
             if DEBUG:
-                print("✅ Modern SocketIO connection pool initialized", file=sys.stderr)
+                _log("✅ Modern SocketIO connection pool initialized")
         except Exception as e:
             if DEBUG:
-                print(
-                    f"⚠️ Failed to initialize SocketIO connection pool: {e}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ Failed to initialize SocketIO connection pool: {e}")
             self.connection_pool = None
 
     def emit_event(self, namespace: str, event: str, data: dict):
@@ -134,6 +140,23 @@ class ConnectionManagerService:
         # Otherwise use "hook" as the type
         if event == "hook_execution":
             hook_type = data.get("hook_type", "unknown")
+
+            # BUGFIX: Validate hook_type is meaningful (not generic/invalid values)
+            # Problem: Dashboard shows "hook hook" instead of "PreToolUse", "UserPromptSubmit", etc.
+            # Root cause: hook_type defaults to "hook" or "unknown", providing no useful information
+            # Solution: Fallback to hook_name, then to descriptive "hook_execution_untyped"
+            if hook_type in ("hook", "unknown", "", None):
+                # Try fallback to hook_name field (set by _emit_hook_execution_event)
+                hook_type = data.get("hook_name", "unknown_hook")
+
+                # Final fallback if still generic - use descriptive name
+                if hook_type in ("hook", "unknown", "", None):
+                    hook_type = "hook_execution_untyped"
+
+                # Debug log when we detect invalid hook_type for troubleshooting
+                if DEBUG:
+                    _log(f"⚠️ Invalid hook_type detected, using fallback: {hook_type}")
+
             event_type = hook_type
         else:
             event_type = "hook"
@@ -157,16 +180,12 @@ 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}'"
                 )
 
         # Emit through direct Socket.IO connection pool (primary path)
@@ -176,11 +195,11 @@ class ConnectionManagerService:
                 # Emit to Socket.IO server directly
                 self.connection_pool.emit("mpm_event", claude_event_data)
                 if DEBUG:
-                    print(f"✅ Emitted via connection pool: {event}", file=sys.stderr)
+                    _log(f"✅ Emitted via connection pool: {event}")
                 return  # Success - no need for fallback
             except Exception as e:
                 if DEBUG:
-                    print(f"⚠️ Failed to emit via connection pool: {e}", file=sys.stderr)
+                    _log(f"⚠️ Failed to emit via connection pool: {e}")
 
         # HTTP fallback for cross-process communication (when direct calls fail)
         # This replaces EventBus for reliability without the complexity
@@ -201,22 +220,18 @@ class ConnectionManagerService:
 
             if response.status_code in [200, 204]:
                 if DEBUG:
-                    print("✅ HTTP fallback successful", file=sys.stderr)
+                    _log("✅ HTTP fallback successful")
             elif DEBUG:
-                print(
-                    f"⚠️ HTTP fallback failed: {response.status_code}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ HTTP fallback failed: {response.status_code}")
 
         except Exception as e:
             if DEBUG:
-                print(f"⚠️ HTTP fallback error: {e}", file=sys.stderr)
+                _log(f"⚠️ HTTP fallback error: {e}")
 
         # Warn if no emission method is available
         if not self.connection_pool and DEBUG:
-            print(
-                f"⚠️ No event emission method available for: {claude_event_data.get('event', 'unknown')}",
-                file=sys.stderr,
+            _log(
+                f"⚠️ No event emission method available for: {claude_event_data.get('event', 'unknown')}"
             )
 
     def cleanup(self):
@@ -225,5 +240,5 @@ class ConnectionManagerService:
         if self.connection_pool:
             try:
                 self.connection_pool.cleanup()
-            except Exception:
+            except Exception:  # nosec B110
                 pass  # Ignore cleanup errors during destruction

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")