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

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

claude_mpm/services/socketio/server/core.py

@@ -31,6 +31,9 @@ except ImportError:
     aiohttp = None
     web = None
 
+# Import VersionService for dynamic version retrieval
+from claude_mpm.services.version_service import VersionService
+
 from ....core.constants import (
     NetworkConfig,
     PerformanceConfig,
@@ -158,11 +161,14 @@ class SocketIOServerCore:
     async def _start_server(self):
         """Start the Socket.IO server with aiohttp."""
         try:
-            # Create Socket.IO server
+            # Create Socket.IO server with proper ping/pong configuration
             self.sio = socketio.AsyncServer(
                 cors_allowed_origins="*",
                 logger=False,  # Disable Socket.IO's own logging
                 engineio_logger=False,
+                ping_interval=25,  # Send ping every 25 seconds
+                ping_timeout=60,   # Wait 60 seconds for pong response
+                max_http_buffer_size=1e8,  # 100MB max buffer
             )
 
             # Create aiohttp application
@@ -255,6 +261,23 @@ class SocketIOServerCore:
                         return web.Response(text="Dashboard not available", status=404)
 
                 self.app.router.add_get("/", index_handler)
+                
+                # Serve version.json from dashboard directory
+                async def version_handler(request):
+                    version_file = self.dashboard_path / "version.json"
+                    if version_file.exists():
+                        self.logger.debug(f"Serving version.json from: {version_file}")
+                        return web.FileResponse(version_file)
+                    else:
+                        # Return default version info if file doesn't exist
+                        return web.json_response({
+                            "version": "1.0.0",
+                            "build": 1,
+                            "formatted_build": "0001",
+                            "full_version": "v1.0.0-0001"
+                        })
+                
+                self.app.router.add_get("/version.json", version_handler)
 
                 # Serve static assets (CSS, JS) from the dashboard static directory
                 dashboard_static_path = (
@@ -426,7 +449,7 @@ class SocketIOServerCore:
                         "total_events": self.stats.get("events_sent", 0),
                         "active_sessions": active_sessions,
                         "server_info": {
-                            "version": "4.0.2",
+                            "version": VersionService().get_version(),
                             "port": self.port,
                         },
                     },

claude_mpm/services/socketio/server/eventbus_integration.py

@@ -0,0 +1,189 @@
+"""EventBus integration for Socket.IO server.
+
+WHY this integration module:
+- Adds EventBus relay to Socket.IO server without modifying core
+- Maintains backward compatibility with existing server
+- Easy to enable/disable via configuration
+- Provides clean separation of concerns
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+from claude_mpm.services.event_bus import EventBus, SocketIORelay
+from claude_mpm.services.event_bus.config import get_config
+
+logger = logging.getLogger(__name__)
+
+
+class EventBusIntegration:
+    """Integrates EventBus relay with Socket.IO server.
+    
+    WHY integration class:
+    - Encapsulates EventBus setup and teardown
+    - Provides lifecycle management for relay
+    - Handles configuration and error cases
+    - Can be easily added to existing server
+    """
+    
+    def __init__(self, server_instance=None):
+        """Initialize EventBus integration.
+        
+        Args:
+            server_instance: Optional Socket.IO server instance
+        """
+        self.server = server_instance
+        self.relay: Optional[SocketIORelay] = None
+        self.event_bus: Optional[EventBus] = None
+        self.config = get_config()
+        self.enabled = self.config.enabled and self.config.relay_enabled
+        
+    def setup(self, port: Optional[int] = None) -> bool:
+        """Set up EventBus and relay.
+        
+        Args:
+            port: Optional Socket.IO server port
+            
+        Returns:
+            bool: True if setup successful
+        """
+        if not self.enabled:
+            logger.info("EventBus integration disabled by configuration")
+            return False
+        
+        try:
+            # Get EventBus instance
+            self.event_bus = EventBus.get_instance()
+            
+            # Apply configuration
+            self.config.apply_to_eventbus(self.event_bus)
+            
+            # Create and configure relay
+            relay_port = port or self.config.relay_port
+            self.relay = SocketIORelay(relay_port)
+            self.config.apply_to_relay(self.relay)
+            
+            # Start the relay
+            self.relay.start()
+            
+            logger.info(f"EventBus integration setup complete (port: {relay_port})")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to setup EventBus integration: {e}")
+            self.enabled = False
+            return False
+    
+    def teardown(self) -> None:
+        """Tear down EventBus integration."""
+        if self.relay:
+            try:
+                self.relay.stop()
+                logger.info("EventBus relay stopped")
+            except Exception as e:
+                logger.error(f"Error stopping relay: {e}")
+            finally:
+                self.relay = None
+    
+    def is_active(self) -> bool:
+        """Check if integration is active.
+        
+        Returns:
+            bool: True if relay is active and connected
+        """
+        return (
+            self.enabled and 
+            self.relay is not None and 
+            self.relay.enabled
+        )
+    
+    def get_stats(self) -> dict:
+        """Get integration statistics.
+        
+        Returns:
+            dict: Combined stats from EventBus and relay
+        """
+        stats = {
+            "enabled": self.enabled,
+            "active": self.is_active()
+        }
+        
+        if self.event_bus:
+            stats["eventbus"] = self.event_bus.get_stats()
+        
+        if self.relay:
+            stats["relay"] = self.relay.get_stats()
+        
+        return stats
+
+
+def integrate_with_server(server_instance, port: Optional[int] = None) -> EventBusIntegration:
+    """Helper function to integrate EventBus with a Socket.IO server.
+    
+    Args:
+        server_instance: Socket.IO server instance
+        port: Optional server port
+        
+    Returns:
+        EventBusIntegration: The integration instance
+    """
+    integration = EventBusIntegration(server_instance)
+    integration.setup(port or getattr(server_instance, 'port', 8765))
+    return integration
+
+
+# Monkey-patch helper for existing server
+def patch_socketio_server(server_class):
+    """Monkey-patch an existing Socket.IO server class to add EventBus.
+    
+    WHY monkey-patching:
+    - Allows integration without modifying existing code
+    - Can be applied selectively based on configuration
+    - Easy to remove or disable
+    
+    Args:
+        server_class: The server class to patch
+    """
+    original_init = server_class.__init__
+    original_start = getattr(server_class, 'start_sync', None) or getattr(server_class, 'start', None)
+    original_stop = getattr(server_class, 'stop_sync', None) or getattr(server_class, 'stop', None)
+    
+    def patched_init(self, *args, **kwargs):
+        """Patched __init__ that adds EventBus integration."""
+        original_init(self, *args, **kwargs)
+        self._eventbus_integration = EventBusIntegration(self)
+    
+    def patched_start(self, *args, **kwargs):
+        """Patched start method that sets up EventBus."""
+        # Call original start
+        if original_start:
+            result = original_start(self, *args, **kwargs)
+        else:
+            result = None
+        
+        # Setup EventBus integration
+        if hasattr(self, '_eventbus_integration'):
+            port = getattr(self, 'port', 8765)
+            self._eventbus_integration.setup(port)
+        
+        return result
+    
+    def patched_stop(self, *args, **kwargs):
+        """Patched stop method that tears down EventBus."""
+        # Teardown EventBus first
+        if hasattr(self, '_eventbus_integration'):
+            self._eventbus_integration.teardown()
+        
+        # Call original stop
+        if original_stop:
+            return original_stop(self, *args, **kwargs)
+    
+    # Apply patches
+    server_class.__init__ = patched_init
+    if original_start:
+        setattr(server_class, 'start_sync' if hasattr(server_class, 'start_sync') else 'start', patched_start)
+    if original_stop:
+        setattr(server_class, 'stop_sync' if hasattr(server_class, 'stop_sync') else 'stop', patched_stop)
+    
+    logger.info(f"Patched {server_class.__name__} with EventBus integration")

claude_mpm/services/socketio/server/main.py

@@ -43,6 +43,7 @@ from ...exceptions import SocketIOServerError as MPMConnectionError
 from ..handlers import EventHandlerRegistry, FileEventHandler, GitEventHandler
 from .broadcaster import SocketIOEventBroadcaster
 from .core import SocketIOServerCore
+from .eventbus_integration import EventBusIntegration
 
 
 class SocketIOServer(SocketIOServiceInterface):
@@ -93,6 +94,9 @@ class SocketIOServer(SocketIOServiceInterface):
         
         # Active session tracking for heartbeat
         self.active_sessions: Dict[str, Dict[str, Any]] = {}
+        
+        # EventBus integration
+        self.eventbus_integration = None
 
     def start_sync(self):
         """Start the Socket.IO server in a background thread (synchronous version)."""
@@ -144,6 +148,19 @@ class SocketIOServer(SocketIOServiceInterface):
 
         # Register events
         self._register_events()
+        
+        # Setup EventBus integration
+        # WHY: This connects the EventBus to the Socket.IO server, allowing
+        # events from other parts of the system to be broadcast to dashboard
+        try:
+            self.eventbus_integration = EventBusIntegration(self)
+            if self.eventbus_integration.setup(self.port):
+                self.logger.info("EventBus integration setup successful")
+            else:
+                self.logger.warning("EventBus integration setup failed or disabled")
+        except Exception as e:
+            self.logger.error(f"Failed to setup EventBus integration: {e}")
+            self.eventbus_integration = None
 
         # Update running state
         self.running = self.core.running
@@ -159,6 +176,14 @@ class SocketIOServer(SocketIOServiceInterface):
         if self.broadcaster:
             self.broadcaster.stop_retry_processor()
         
+        # Teardown EventBus integration
+        if self.eventbus_integration:
+            try:
+                self.eventbus_integration.teardown()
+                self.logger.info("EventBus integration teardown complete")
+            except Exception as e:
+                self.logger.error(f"Error during EventBus teardown: {e}")
+        
         # Stop health monitoring in connection handler
         if self.event_registry:
             from ..handlers import ConnectionEventHandler