claude-mpm 4.0.34__py3-none-any.whl → 4.1.1__py3-none-any.whl

claude_mpm/services/event_bus/config.py

@@ -0,0 +1,165 @@
+"""Configuration for EventBus service.
+
+WHY configuration module:
+- Centralized configuration management
+- Environment variable support
+- Easy testing with different configurations
+- Runtime configuration changes
+"""
+
+import os
+from typing import List, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class EventBusConfig:
+    """Configuration for EventBus service.
+    
+    All settings can be overridden via environment variables.
+    """
+    
+    # Enable/disable the EventBus
+    enabled: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_ENABLED", "true").lower() == "true"
+    )
+    
+    # Debug logging
+    debug: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_DEBUG", "false").lower() == "true"
+    )
+    
+    # Event history settings
+    max_history_size: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_EVENTBUS_HISTORY_SIZE", "100"))
+    )
+    
+    # Event filters (comma-separated list)
+    event_filters: List[str] = field(
+        default_factory=lambda: [
+            f.strip() for f in os.environ.get("CLAUDE_MPM_EVENTBUS_FILTERS", "").split(",") 
+            if f.strip()
+        ]
+    )
+    
+    # Relay configuration
+    relay_enabled: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_ENABLED", "true").lower() == "true"
+    )
+    
+    relay_port: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_SOCKETIO_PORT", "8765"))
+    )
+    
+    relay_debug: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_DEBUG", "false").lower() == "true"
+    )
+    
+    # Connection settings
+    relay_max_retries: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_RELAY_MAX_RETRIES", "3"))
+    )
+    
+    relay_retry_delay: float = field(
+        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_RETRY_DELAY", "0.5"))
+    )
+    
+    relay_connection_cooldown: float = field(
+        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_CONNECTION_COOLDOWN", "5.0"))
+    )
+    
+    @classmethod
+    def from_env(cls) -> "EventBusConfig":
+        """Create configuration from environment variables.
+        
+        Returns:
+            EventBusConfig: Configuration instance
+        """
+        return cls()
+    
+    def to_dict(self) -> dict:
+        """Convert configuration to dictionary.
+        
+        Returns:
+            dict: Configuration as dictionary
+        """
+        return {
+            "enabled": self.enabled,
+            "debug": self.debug,
+            "max_history_size": self.max_history_size,
+            "event_filters": self.event_filters,
+            "relay_enabled": self.relay_enabled,
+            "relay_port": self.relay_port,
+            "relay_debug": self.relay_debug,
+            "relay_max_retries": self.relay_max_retries,
+            "relay_retry_delay": self.relay_retry_delay,
+            "relay_connection_cooldown": self.relay_connection_cooldown
+        }
+    
+    def apply_to_eventbus(self, event_bus) -> None:
+        """Apply configuration to an EventBus instance.
+        
+        Args:
+            event_bus: EventBus instance to configure
+        """
+        if not self.enabled:
+            event_bus.disable()
+        else:
+            event_bus.enable()
+        
+        event_bus.set_debug(self.debug)
+        event_bus._max_history_size = self.max_history_size
+        
+        # Apply filters
+        event_bus.clear_filters()
+        for filter_pattern in self.event_filters:
+            event_bus.add_filter(filter_pattern)
+    
+    def apply_to_relay(self, relay) -> None:
+        """Apply configuration to a SocketIORelay instance.
+        
+        Args:
+            relay: SocketIORelay instance to configure
+        """
+        if not self.relay_enabled:
+            relay.disable()
+        else:
+            relay.enable()
+        
+        relay.port = self.relay_port
+        relay.debug = self.relay_debug
+        relay.max_retries = self.relay_max_retries
+        relay.retry_delay = self.relay_retry_delay
+        relay.connection_cooldown = self.relay_connection_cooldown
+
+
+# Global configuration instance
+_config: Optional[EventBusConfig] = None
+
+
+def get_config() -> EventBusConfig:
+    """Get the global EventBus configuration.
+    
+    Returns:
+        EventBusConfig: Configuration instance
+    """
+    global _config
+    if _config is None:
+        _config = EventBusConfig.from_env()
+    return _config
+
+
+def set_config(config: EventBusConfig) -> None:
+    """Set the global EventBus configuration.
+    
+    Args:
+        config: Configuration to set
+    """
+    global _config
+    _config = config
+
+
+def reset_config() -> None:
+    """Reset configuration to defaults from environment."""
+    global _config
+    _config = EventBusConfig.from_env()

claude_mpm/services/event_bus/event_bus.py

@@ -13,7 +13,7 @@ import logging
 import threading
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Set
-from pyee import AsyncIOEventEmitter
+from pyee.asyncio import AsyncIOEventEmitter
 
 # Configure logger
 logger = logging.getLogger(__name__)
@@ -176,9 +176,33 @@ class EventBus:
             # Record event in history
             self._record_event(event_type, data)
             
-            # Emit event (pyee handles thread safety)
+            # Emit event to regular handlers (pyee handles thread safety)
             self._emitter.emit(event_type, data)
             
+            # Also emit to wildcard handlers
+            if hasattr(self, '_wildcard_handlers'):
+                for prefix, handlers in self._wildcard_handlers.items():
+                    if event_type.startswith(prefix):
+                        for handler in handlers:
+                            try:
+                                # Call with event_type and data for wildcard handlers
+                                if asyncio.iscoroutinefunction(handler):
+                                    # Schedule async handlers
+                                    try:
+                                        loop = asyncio.get_event_loop()
+                                        if loop.is_running():
+                                            asyncio.create_task(handler(event_type, data))
+                                        else:
+                                            loop.run_until_complete(handler(event_type, data))
+                                    except RuntimeError:
+                                        # No event loop, skip async handler
+                                        pass
+                                else:
+                                    handler(event_type, data)
+                            except Exception as e:
+                                if self._debug:
+                                    logger.debug(f"Wildcard handler error: {e}")
+            
             # Update stats
             self._stats["events_published"] += 1
             self._stats["last_event_time"] = datetime.now().isoformat()
@@ -217,29 +241,20 @@ class EventBus:
             handler: The handler function
         """
         if event_type.endswith("*"):
-            # Register for wildcard pattern
-            prefix = event_type[:-1]
+            # Store wildcard handlers separately
+            if not hasattr(self, '_wildcard_handlers'):
+                self._wildcard_handlers = {}
             
-            # Create a wrapper that checks event names
-            def wildcard_wrapper(actual_event_type: str):
-                def wrapper(data):
-                    if actual_event_type.startswith(prefix):
-                        if asyncio.iscoroutinefunction(handler):
-                            return handler(actual_event_type, data)
-                        else:
-                            handler(actual_event_type, data)
-                return wrapper
+            prefix = event_type[:-1]
+            if prefix not in self._wildcard_handlers:
+                self._wildcard_handlers[prefix] = []
+            self._wildcard_handlers[prefix].append(handler)
             
-            # Register for all possible events (we'll filter in the wrapper)
-            # For now, register common prefixes
-            for common_event in ["hook", "socketio", "system", "agent"]:
-                if common_event.startswith(prefix) or prefix.startswith(common_event):
-                    self._emitter.on(f"{common_event}.*", wildcard_wrapper(f"{common_event}.*"))
+            logger.debug(f"Registered wildcard handler for: {event_type}")
         else:
             # Regular event registration
             self._emitter.on(event_type, handler)
-        
-        logger.debug(f"Registered handler for: {event_type}")
+            logger.debug(f"Registered handler for: {event_type}")
     
     def once(self, event_type: str, handler: Callable) -> None:
         """Register a one-time event handler.

claude_mpm/services/event_bus/relay.py

@@ -106,20 +106,21 @@ class SocketIORelay:
         self.last_connection_attempt = current_time
         
         try:
-            # Create new client
+            # Create new client with better connection settings
             self.client = socketio.Client(
                 reconnection=True,
-                reconnection_attempts=3,
-                reconnection_delay=1,
+                reconnection_attempts=5,
+                reconnection_delay=2,
+                reconnection_delay_max=10,
                 logger=False,
                 engineio_logger=False
             )
             
-            # Connect to server
+            # Connect to server with longer timeout
             self.client.connect(
                 f"http://localhost:{self.port}",
                 wait=True,
-                wait_timeout=2.0,
+                wait_timeout=10.0,  # Increase timeout for stability
                 transports=['websocket', 'polling']
             )
             
@@ -219,15 +220,10 @@ class SocketIORelay:
             if event_type.startswith("hook."):
                 await self.relay_event(event_type, data)
         
-        # Subscribe to all hook events
+        # Subscribe to all hook events via wildcard
+        # This will catch ALL hook.* events
         self.event_bus.on("hook.*", handle_hook_event)
         
-        # Also subscribe to specific high-priority events
-        for event in ["hook.pre_tool", "hook.post_tool", "hook.subagent_stop", 
-                      "hook.user_prompt", "hook.assistant_response"]:
-            self.event_bus.on(event, lambda data, evt=event: 
-                             asyncio.create_task(self.relay_event(evt, data)))
-        
         logger.info("SocketIO relay started and subscribed to events")
     
     def stop(self) -> None:

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -0,0 +1,372 @@
+"""
+MCP Gateway Auto-Configuration Service
+======================================
+
+Provides automatic MCP configuration for pipx installations with user consent.
+Detects unconfigured MCP setups and offers one-time configuration prompts.
+
+WHY: Users installing via pipx should have MCP work out-of-the-box with minimal
+friction. This service detects unconfigured installations and offers automatic
+setup with user consent.
+
+DESIGN DECISIONS:
+- Only prompts once (saves preference to avoid repeated prompts)
+- Quick timeout with safe default (no configuration)
+- Non-intrusive with environment variable override
+- Creates backups before modifying any configuration
+- Validates JSON before and after modifications
+"""
+
+import json
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any, Tuple
+
+from claude_mpm.core.logger import get_logger
+from claude_mpm.config.paths import paths
+
+
+class MCPAutoConfigurator:
+    """
+    Handles automatic MCP configuration for pipx installations.
+    
+    Provides a one-time prompt to configure MCP Gateway with user consent,
+    making the experience seamless for pipx users while respecting choice.
+    """
+    
+    def __init__(self):
+        """Initialize the auto-configurator."""
+        self.logger = get_logger("MCPAutoConfig")
+        self.config_dir = paths.claude_mpm_dir_hidden
+        self.preference_file = self.config_dir / "mcp_auto_config_preference.json"
+        self.claude_config_path = Path.home() / ".claude.json"
+        
+    def should_auto_configure(self) -> bool:
+        """
+        Check if auto-configuration should be attempted.
+        
+        Returns:
+            True if auto-configuration should be offered, False otherwise
+        """
+        # Check environment variable override
+        if os.environ.get("CLAUDE_MPM_NO_AUTO_CONFIG"):
+            self.logger.debug("Auto-configuration disabled via environment variable")
+            return False
+        
+        # Check if already configured
+        if self._is_mcp_configured():
+            self.logger.debug("MCP already configured")
+            return False
+        
+        # Check if this is a pipx installation
+        if not self._is_pipx_installation():
+            self.logger.debug("Not a pipx installation")
+            return False
+        
+        # Check if we've already asked
+        if self._has_user_preference():
+            self.logger.debug("User preference already saved")
+            return False
+        
+        return True
+    
+    def _is_mcp_configured(self) -> bool:
+        """Check if MCP is already configured in Claude Code."""
+        if not self.claude_config_path.exists():
+            return False
+        
+        try:
+            with open(self.claude_config_path, 'r') as f:
+                config = json.load(f)
+            
+            # Check if claude-mpm-gateway is configured
+            mcp_servers = config.get("mcpServers", {})
+            return "claude-mpm-gateway" in mcp_servers
+            
+        except (json.JSONDecodeError, IOError):
+            return False
+    
+    def _is_pipx_installation(self) -> bool:
+        """Check if claude-mpm is installed via pipx."""
+        # Check if running from pipx virtual environment
+        if "pipx" in sys.executable.lower():
+            return True
+        
+        # Check module path
+        try:
+            import claude_mpm
+            module_path = Path(claude_mpm.__file__).parent
+            if "pipx" in str(module_path):
+                return True
+        except Exception:
+            pass
+        
+        # Check for pipx in PATH for claude-mpm command
+        try:
+            import subprocess
+            import platform
+            
+            # Use appropriate command for OS
+            if platform.system() == "Windows":
+                cmd = ["where", "claude-mpm"]
+            else:
+                cmd = ["which", "claude-mpm"]
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+            if result.returncode == 0 and "pipx" in result.stdout:
+                return True
+        except Exception:
+            pass
+        
+        return False
+    
+    def _has_user_preference(self) -> bool:
+        """Check if user has already been asked about auto-configuration."""
+        if not self.preference_file.exists():
+            return False
+        
+        try:
+            with open(self.preference_file, 'r') as f:
+                prefs = json.load(f)
+            return prefs.get("asked", False)
+        except (json.JSONDecodeError, IOError):
+            return False
+    
+    def _save_user_preference(self, choice: str):
+        """Save user's preference to avoid asking again."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        
+        prefs = {
+            "asked": True,
+            "choice": choice,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        try:
+            with open(self.preference_file, 'w') as f:
+                json.dump(prefs, f, indent=2)
+        except Exception as e:
+            self.logger.debug(f"Could not save preference: {e}")
+    
+    def prompt_user(self, timeout: int = 10) -> Optional[bool]:
+        """
+        Prompt user for auto-configuration with timeout.
+        
+        Args:
+            timeout: Seconds to wait for response (default 10)
+            
+        Returns:
+            True if user agrees, False if declines, None if timeout
+        """
+        print("\n" + "="*60)
+        print("🔧 MCP Gateway Configuration")
+        print("="*60)
+        print("\nClaude MPM can automatically configure MCP Gateway for")
+        print("Claude Code integration. This enables advanced features:")
+        print("  • File analysis and summarization")
+        print("  • System diagnostics")
+        print("  • Ticket management")
+        print("  • And more...")
+        print("\nWould you like to configure it now? (y/n)")
+        print(f"(Auto-declining in {timeout} seconds)")
+        
+        # Use threading for cross-platform timeout support
+        import threading
+        try:
+            # Python 3.7+ has queue built-in
+            import queue
+        except ImportError:
+            # Python 2.x fallback
+            import Queue as queue
+        
+        user_input = None
+        
+        def get_input():
+            nonlocal user_input
+            try:
+                user_input = input("> ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                user_input = 'n'
+        
+        # Start input thread
+        input_thread = threading.Thread(target=get_input)
+        input_thread.daemon = True
+        input_thread.start()
+        
+        # Wait for input or timeout
+        input_thread.join(timeout)
+        
+        if input_thread.is_alive():
+            # Timed out
+            print("\n(Timed out - declining)")
+            return None
+        else:
+            # Got input
+            if user_input in ['y', 'yes']:
+                return True
+            else:
+                return False
+    
+    def auto_configure(self) -> bool:
+        """
+        Perform automatic MCP configuration.
+        
+        Returns:
+            True if configuration successful, False otherwise
+        """
+        try:
+            # Create backup if config exists
+            if self.claude_config_path.exists():
+                backup_path = self._create_backup()
+                if backup_path:
+                    print(f"✅ Backup created: {backup_path}")
+            
+            # Load or create configuration
+            config = self._load_or_create_config()
+            
+            # Add MCP Gateway configuration
+            if "mcpServers" not in config:
+                config["mcpServers"] = {}
+            
+            # Find claude-mpm executable
+            executable = self._find_claude_mpm_executable()
+            if not executable:
+                print("❌ Could not find claude-mpm executable")
+                return False
+            
+            # Configure MCP server
+            config["mcpServers"]["claude-mpm-gateway"] = {
+                "command": str(executable),
+                "args": ["mcp", "server"],
+                "env": {
+                    "MCP_MODE": "production"
+                }
+            }
+            
+            # Save configuration
+            with open(self.claude_config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+            
+            print(f"✅ Configuration saved to: {self.claude_config_path}")
+            print("\n🎉 MCP Gateway configured successfully!")
+            print("\nNext steps:")
+            print("1. Restart Claude Code (if running)")
+            print("2. Look for the MCP icon in the interface")
+            print("3. Try @claude-mpm-gateway in a conversation")
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Auto-configuration failed: {e}")
+            print(f"❌ Configuration failed: {e}")
+            print("\nYou can configure manually with:")
+            print("  claude-mpm mcp install")
+            return False
+    
+    def _create_backup(self) -> Optional[Path]:
+        """Create backup of existing configuration."""
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_path = self.claude_config_path.with_suffix(f'.backup.{timestamp}.json')
+            
+            import shutil
+            shutil.copy2(self.claude_config_path, backup_path)
+            return backup_path
+            
+        except Exception as e:
+            self.logger.debug(f"Could not create backup: {e}")
+            return None
+    
+    def _load_or_create_config(self) -> Dict[str, Any]:
+        """Load existing config or create new one."""
+        if self.claude_config_path.exists():
+            try:
+                with open(self.claude_config_path, 'r') as f:
+                    return json.load(f)
+            except json.JSONDecodeError:
+                self.logger.warning("Existing config is invalid JSON, creating new")
+        
+        return {}
+    
+    def _find_claude_mpm_executable(self) -> Optional[str]:
+        """Find the claude-mpm executable path."""
+        # Try direct command first
+        import subprocess
+        import platform
+        
+        try:
+            # Use appropriate command for OS
+            if platform.system() == "Windows":
+                cmd = ["where", "claude-mpm"]
+            else:
+                cmd = ["which", "claude-mpm"]
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+            if result.returncode == 0:
+                executable_path = result.stdout.strip()
+                # On Windows, 'where' might return multiple paths
+                if platform.system() == "Windows" and '\n' in executable_path:
+                    executable_path = executable_path.split('\n')[0]
+                return executable_path
+        except Exception:
+            pass
+        
+        # Try to find via shutil.which (more portable)
+        import shutil
+        claude_mpm_path = shutil.which("claude-mpm")
+        if claude_mpm_path:
+            return claude_mpm_path
+        
+        # Fallback to Python module invocation
+        return sys.executable
+    
+    def run(self) -> bool:
+        """
+        Main entry point for auto-configuration.
+        
+        Returns:
+            True if configured (or already configured), False otherwise
+        """
+        if not self.should_auto_configure():
+            return True  # Already configured or not applicable
+        
+        # Prompt user
+        user_choice = self.prompt_user()
+        
+        # Save preference to not ask again
+        self._save_user_preference("yes" if user_choice else "no")
+        
+        if user_choice:
+            return self.auto_configure()
+        else:
+            if user_choice is False:  # User explicitly said no
+                print("\n📝 You can configure MCP later with:")
+                print("  claude-mpm mcp install")
+            # If timeout (None), don't show additional message
+            return False
+
+
+def check_and_configure_mcp() -> bool:
+    """
+    Check and potentially configure MCP for pipx installations.
+    
+    This is the main entry point called during CLI initialization.
+    
+    Returns:
+        True if MCP is configured (or configuration was successful), False otherwise
+    """
+    configurator = MCPAutoConfigurator()
+    return configurator.run()

claude_mpm/services/socketio/handlers/connection.py

@@ -99,9 +99,9 @@ class ConnectionEventHandler(BaseEventHandler):
         # Connection health tracking
         self.connection_metrics = {}
         self.last_ping_times = {}
-        self.ping_interval = 30  # seconds
-        self.ping_timeout = 10  # seconds
-        self.stale_check_interval = 60  # seconds
+        self.ping_interval = 45  # seconds - avoid conflict with Engine.IO pings
+        self.ping_timeout = 20  # seconds - more lenient timeout
+        self.stale_check_interval = 90  # seconds - less frequent checks
         
         # Health monitoring tasks (will be started after event registration)
         self.ping_task = None