claude-mpm 3.4.10__py3-none-any.whl → 5.4.55__py3-none-any.whl

claude_mpm/hooks/base_hook.py

@@ -1,18 +1,20 @@
 """Base hook class and types for claude-mpm hook system."""
 
+import asyncio
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
-import asyncio
-import logging
-from datetime import datetime
+from typing import Any, Dict, Optional
 
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
 
 
 class HookType(Enum):
     """Types of hooks available in the system."""
+
     SUBMIT = "submit"  # Process user prompts
     PRE_DELEGATION = "pre_delegation"  # Filter context before delegation
     POST_DELEGATION = "post_delegation"  # Process results after delegation
@@ -23,22 +25,24 @@ class HookType(Enum):
 @dataclass
 class HookContext:
     """Context passed to hooks for processing."""
+
     hook_type: HookType
     data: Dict[str, Any]
     metadata: Dict[str, Any]
     timestamp: datetime
     session_id: Optional[str] = None
     user_id: Optional[str] = None
-    
+
     def __post_init__(self):
         """Ensure timestamp is set."""
-        if not hasattr(self, 'timestamp') or self.timestamp is None:
-            self.timestamp = datetime.now()
+        if not hasattr(self, "timestamp") or self.timestamp is None:
+            self.timestamp = datetime.now(timezone.utc)
 
 
 @dataclass
 class HookResult:
     """Result returned from hook execution."""
+
     success: bool
     data: Optional[Dict[str, Any]] = None
     error: Optional[str] = None
@@ -49,10 +53,10 @@ class HookResult:
 
 class BaseHook(ABC):
     """Base class for all hooks."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         """Initialize hook with name and priority.
-        
+
         Args:
             name: Unique name for the hook
             priority: Execution priority (0-100, lower executes first)
@@ -61,40 +65,39 @@ class BaseHook(ABC):
         self.priority = max(0, min(100, priority))  # Clamp to 0-100
         self.enabled = True
         self._async = False
-        
+
     @abstractmethod
     def execute(self, context: HookContext) -> HookResult:
         """Execute the hook with given context.
-        
+
         Args:
             context: Hook context containing data and metadata
-            
+
         Returns:
             HookResult with execution results
         """
-        pass
-    
+
     async def async_execute(self, context: HookContext) -> HookResult:
         """Async version of execute. Override for async hooks."""
         # Default implementation calls sync execute in executor
         loop = asyncio.get_event_loop()
         return await loop.run_in_executor(None, self.execute, context)
-    
+
     def validate(self, context: HookContext) -> bool:
         """Validate if hook should run for given context.
-        
+
         Args:
             context: Hook context to validate
-            
+
         Returns:
             True if hook should execute, False otherwise
         """
         return self.enabled
-    
+
     def __repr__(self):
         """String representation of hook."""
         return f"{self.__class__.__name__}(name='{self.name}', priority={self.priority}, enabled={self.enabled})"
-    
+
     def __lt__(self, other):
         """Compare hooks by priority for sorting."""
         if not isinstance(other, BaseHook):
@@ -104,51 +107,53 @@ class BaseHook(ABC):
 
 class SubmitHook(BaseHook):
     """Base class for hooks that process user prompts."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate submit hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.SUBMIT and 'prompt' in context.data
+        return context.hook_type == HookType.SUBMIT and "prompt" in context.data
 
 
 class PreDelegationHook(BaseHook):
     """Base class for hooks that filter context before delegation."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate pre-delegation hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.PRE_DELEGATION and 'agent' in context.data
+        return context.hook_type == HookType.PRE_DELEGATION and "agent" in context.data
 
 
 class PostDelegationHook(BaseHook):
     """Base class for hooks that process results after delegation."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate post-delegation hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.POST_DELEGATION and 'result' in context.data
+        return (
+            context.hook_type == HookType.POST_DELEGATION and "result" in context.data
+        )
 
 
 class TicketExtractionHook(BaseHook):
     """Base class for hooks that extract and create tickets."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate ticket extraction hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.TICKET_EXTRACTION
+        return context.hook_type == HookType.TICKET_EXTRACTION

claude_mpm/hooks/claude_hooks/__init__.py

@@ -2,4 +2,4 @@
 
 from .hook_handler import ClaudeHookHandler
 
-__all__ = ['ClaudeHookHandler']
+__all__ = ["ClaudeHookHandler"]

claude_mpm/hooks/claude_hooks/connection_pool.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""[DEPRECATED] Socket.IO connection pool for Claude Code hook handler.
+
+DEPRECATION NOTICE: As of v4.0.35, this module is deprecated.
+All event emission now goes through the EventBus, which handles
+Socket.IO connections via its relay component. This provides:
+- Single event path (no duplicates)
+- Better separation of concerns
+- Centralized connection management
+- More resilient architecture
+
+This module is kept for backward compatibility but will be removed in v5.0.0.
+Please use EventBus.publish() instead of direct Socket.IO emission.
+
+Original purpose: Provided connection pooling for Socket.IO clients to reduce
+connection overhead and implement circuit breaker patterns.
+"""
+
+import time
+from typing import Any, Dict, List, Optional
+
+# Import constants for configuration
+try:
+    from claude_mpm.core.constants import NetworkConfig
+except ImportError:
+    # Fallback values if constants module not available
+    class NetworkConfig:
+        SOCKETIO_PORT_RANGE = (8765, 8785)
+        RECONNECTION_DELAY = 0.5
+        SOCKET_WAIT_TIMEOUT = 1.0
+
+
+# Socket.IO import
+try:
+    import socketio
+
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+
+
+class SocketIOConnectionPool:
+    """Connection pool for Socket.IO clients to prevent connection leaks."""
+
+    def __init__(self, max_connections: int = 3):
+        self.max_connections = max_connections
+        self.connections: List[Dict[str, Any]] = []
+        self.last_cleanup = time.time()
+
+    def get_connection(self, port: int) -> Optional[Any]:
+        """Get or create a connection to the specified port."""
+        if time.time() - self.last_cleanup > 60:
+            self._cleanup_dead_connections()
+            self.last_cleanup = time.time()
+
+        for conn in self.connections:
+            if conn.get("port") == port and conn.get("client"):
+                client = conn["client"]
+                if self._is_connection_alive(client):
+                    return client
+                self.connections.remove(conn)
+
+        if len(self.connections) < self.max_connections:
+            client = self._create_connection(port)
+            if client:
+                self.connections.append(
+                    {"port": port, "client": client, "created": time.time()}
+                )
+                return client
+
+        if self.connections:
+            oldest = min(self.connections, key=lambda x: x["created"])
+            self._close_connection(oldest["client"])
+            oldest["client"] = self._create_connection(port)
+            oldest["port"] = port
+            oldest["created"] = time.time()
+            return oldest["client"]
+
+        return None
+
+    def _create_connection(self, port: int) -> Optional[Any]:
+        """Create a new Socket.IO connection with persistent keep-alive.
+
+        WHY persistent connections:
+        - Maintains connection throughout handler lifecycle
+        - Automatic reconnection on disconnect
+        - Reduced connection overhead for multiple events
+        - Better reliability for event delivery
+        """
+        if not SOCKETIO_AVAILABLE:
+            return None
+        try:
+            client = socketio.Client(
+                reconnection=True,  # Enable automatic reconnection
+                reconnection_attempts=5,  # Try to reconnect up to 5 times
+                reconnection_delay=0.5,  # Wait 0.5s between reconnection attempts
+                reconnection_delay_max=2.0,  # Max delay between attempts
+                logger=False,
+                engineio_logger=False,
+            )
+
+            # Set up event handlers for connection lifecycle
+            @client.on("connect")
+            def on_connect():
+                pass  # Connection established
+
+            @client.on("disconnect")
+            def on_disconnect():
+                pass  # Will automatically try to reconnect
+
+            client.connect(
+                f"http://localhost:{port}",
+                wait=True,  # Wait for connection to establish
+                wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT,
+                transports=[
+                    "websocket",
+                    "polling",
+                ],  # Try WebSocket first, fall back to polling
+            )
+
+            if client.connected:
+                # Send a keep-alive ping to establish the connection
+                try:
+                    client.emit(
+                        "ping",
+                        {
+                            "type": "system",
+                            "subtype": "ping",
+                            "timestamp": time.time(),
+                            "source": "connection_pool",
+                        },
+                    )
+                except Exception:
+                    pass  # Ignore ping errors
+                return client
+        except Exception:
+            pass
+        return None
+
+    def _is_connection_alive(self, client: Any) -> bool:
+        """Check if a connection is still alive.
+
+        WHY enhanced check:
+        - Verifies actual connection state
+        - Attempts to ping server for liveness check
+        - More reliable than just checking connected flag
+        """
+        try:
+            if not client:
+                return False
+
+            # Check basic connection state
+            if not client.connected:
+                return False
+
+            # Try a quick ping to verify connection is truly alive
+            # This helps detect zombie connections
+            try:
+                # Just emit a ping, don't wait for response (faster)
+                client.emit(
+                    "ping",
+                    {
+                        "type": "system",
+                        "subtype": "ping",
+                        "timestamp": time.time(),
+                        "source": "connection_pool",
+                    },
+                )
+                return True
+            except Exception:
+                # If ping fails, connection might be dead
+                return client.connected  # Fall back to basic check
+        except Exception:
+            return False
+
+    def _close_connection(self, client: Any) -> None:
+        """Safely close a connection."""
+        try:
+            if client:
+                client.disconnect()
+        except Exception:
+            pass
+
+    def _cleanup_dead_connections(self) -> None:
+        """Remove dead connections from the pool and attempt reconnection.
+
+        WHY proactive reconnection:
+        - Maintains pool health
+        - Ensures connections are ready when needed
+        - Reduces latency for event emission
+        """
+        alive_connections = []
+        for conn in self.connections:
+            client = conn.get("client")
+            if self._is_connection_alive(client):
+                alive_connections.append(conn)
+            else:
+                # Try to reconnect dead connections
+                self._close_connection(client)
+                new_client = self._create_connection(conn.get("port", 8765))
+                if new_client:
+                    conn["client"] = new_client
+                    conn["created"] = time.time()
+                    alive_connections.append(conn)
+        self.connections = alive_connections
+
+    def close_all(self) -> None:
+        """Close all connections in the pool."""
+        for conn in self.connections:
+            self._close_connection(conn.get("client"))
+        self.connections.clear()
+
+    def emit(self, event: str, data: Dict[str, Any]) -> bool:
+        """Emit an event through the connection pool.
+
+        This method provides backward compatibility for the deprecated
+        connection pool. It attempts to send events directly to the
+        Socket.IO server.
+
+        Args:
+            event: Event name (e.g., "claude_event")
+            data: Event data dictionary
+
+        Returns:
+            bool: True if event was sent successfully
+        """
+        if not SOCKETIO_AVAILABLE:
+            return False
+
+        # Try multiple ports in the range
+        for port in range(
+            NetworkConfig.SOCKETIO_PORT_RANGE[0],
+            NetworkConfig.SOCKETIO_PORT_RANGE[1] + 1,
+        ):
+            client = self.get_connection(port)
+            if client:
+                try:
+                    # Emit the event
+                    client.emit(event, data)
+                    return True
+                except Exception:
+                    # Try next port
+                    continue
+
+        return False
+
+    def cleanup(self) -> None:
+        """Cleanup all connections (alias for close_all)."""
+        self.close_all()

claude_mpm/hooks/claude_hooks/correlation_manager.py

@@ -0,0 +1,60 @@
+"""Cross-process correlation storage using .claude-mpm directory."""
+
+import json
+import time
+from pathlib import Path
+
+
+def get_correlation_dir() -> Path:
+    """Get correlation directory in project's .claude-mpm folder."""
+    # Use CWD's .claude-mpm directory (where hooks run from)
+    cwd = Path.cwd()
+    return cwd / ".claude-mpm" / "correlations"
+
+
+TTL_SECONDS = 3600  # 1 hour
+
+
+class CorrelationManager:
+    """Manages correlation IDs across separate hook processes."""
+
+    @staticmethod
+    def store(session_id: str, tool_call_id: str, tool_name: str) -> None:
+        """Store correlation data for later retrieval by post_tool."""
+        correlation_dir = get_correlation_dir()
+        correlation_dir.mkdir(parents=True, exist_ok=True)
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        data = {
+            "tool_call_id": tool_call_id,
+            "tool_name": tool_name,
+            "timestamp": time.time(),
+        }
+        filepath.write_text(json.dumps(data))
+
+    @staticmethod
+    def retrieve(session_id: str) -> str | None:
+        """Retrieve and delete correlation data from temp file."""
+        correlation_dir = get_correlation_dir()
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        if not filepath.exists():
+            return None
+        try:
+            data = json.loads(filepath.read_text())
+            filepath.unlink()  # Delete after reading
+            return data.get("tool_call_id")
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    @staticmethod
+    def cleanup_old() -> None:
+        """Remove correlation files older than TTL."""
+        correlation_dir = get_correlation_dir()
+        if not correlation_dir.exists():
+            return
+        now = time.time()
+        for filepath in correlation_dir.glob("correlation_*.json"):
+            try:
+                if now - filepath.stat().st_mtime > TTL_SECONDS:
+                    filepath.unlink()
+            except OSError:
+                pass