claude-mpm 4.1.6__py3-none-any.whl → 4.1.8__py3-none-any.whl

claude_mpm/cli/commands/configure.py

@@ -222,6 +222,16 @@ class ConfigureCommand(BaseCommand):
         if getattr(args, "version_info", False):
             return self._show_version_info()
 
+        # Handle hook installation
+        if getattr(args, "install_hooks", False):
+            return self._install_hooks(force=getattr(args, "force", False))
+
+        if getattr(args, "verify_hooks", False):
+            return self._verify_hooks()
+
+        if getattr(args, "uninstall_hooks", False):
+            return self._uninstall_hooks()
+
         # Handle direct navigation options
         if getattr(args, "agents", False):
             return self._run_agent_management()
@@ -1018,7 +1028,11 @@ class ConfigureCommand(BaseCommand):
             import subprocess
 
             result = subprocess.run(
-                ["claude", "--version"], capture_output=True, text=True, timeout=5, check=False
+                ["claude", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
             )
             if result.returncode == 0:
                 claude_version = result.stdout.strip()
@@ -1157,7 +1171,11 @@ Directory: {self.project_dir}
             import subprocess
 
             result = subprocess.run(
-                ["claude", "--version"], capture_output=True, text=True, timeout=5, check=False
+                ["claude", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
             )
             if result.returncode == 0:
                 data["claude_version"] = result.stdout.strip()
@@ -1175,6 +1193,137 @@ Directory: {self.project_dir}
 
         return CommandResult.success_result("Version information displayed", data=data)
 
+    def _install_hooks(self, force: bool = False) -> CommandResult:
+        """Install Claude MPM hooks for Claude Code integration."""
+        try:
+            from ...hooks.claude_hooks.installer import HookInstaller
+
+            installer = HookInstaller()
+
+            # Check current status first
+            status = installer.get_status()
+            if status["installed"] and not force:
+                self.console.print("[yellow]Hooks are already installed.[/yellow]")
+                self.console.print("Use --force to reinstall.")
+
+                if not status["valid"]:
+                    self.console.print("\n[red]However, there are issues:[/red]")
+                    for issue in status["issues"]:
+                        self.console.print(f"  - {issue}")
+
+                return CommandResult.success_result(
+                    "Hooks already installed", data=status
+                )
+
+            # Install hooks
+            self.console.print("[cyan]Installing Claude MPM hooks...[/cyan]")
+            success = installer.install_hooks(force=force)
+
+            if success:
+                self.console.print("[green]✓ Hooks installed successfully![/green]")
+                self.console.print("\nYou can now use /mpm commands in Claude Code:")
+                self.console.print("  /mpm         - Show help")
+                self.console.print("  /mpm status  - Show claude-mpm status")
+
+                # Verify installation
+                is_valid, issues = installer.verify_hooks()
+                if not is_valid:
+                    self.console.print(
+                        "\n[yellow]Warning: Installation completed but verification found issues:[/yellow]"
+                    )
+                    for issue in issues:
+                        self.console.print(f"  - {issue}")
+
+                return CommandResult.success_result("Hooks installed successfully")
+            self.console.print("[red]✗ Hook installation failed[/red]")
+            return CommandResult.error_result("Hook installation failed")
+
+        except ImportError:
+            self.console.print("[red]Error: HookInstaller module not found[/red]")
+            self.console.print("Please ensure claude-mpm is properly installed.")
+            return CommandResult.error_result("HookInstaller module not found")
+        except Exception as e:
+            self.logger.error(f"Hook installation error: {e}", exc_info=True)
+            return CommandResult.error_result(f"Hook installation failed: {e}")
+
+    def _verify_hooks(self) -> CommandResult:
+        """Verify that Claude MPM hooks are properly installed."""
+        try:
+            from ...hooks.claude_hooks.installer import HookInstaller
+
+            installer = HookInstaller()
+            status = installer.get_status()
+
+            self.console.print("[bold]Hook Installation Status[/bold]\n")
+
+            if status["installed"]:
+                self.console.print(
+                    f"[green]✓[/green] Hooks installed at: {status['hook_script']}"
+                )
+            else:
+                self.console.print("[red]✗[/red] Hooks not installed")
+
+            if status["settings_file"]:
+                self.console.print(
+                    f"[green]✓[/green] Settings file: {status['settings_file']}"
+                )
+            else:
+                self.console.print("[red]✗[/red] Settings file not found")
+
+            if status.get("configured_events"):
+                self.console.print(
+                    f"[green]✓[/green] Configured events: {', '.join(status['configured_events'])}"
+                )
+            else:
+                self.console.print("[red]✗[/red] No events configured")
+
+            if status["valid"]:
+                self.console.print("\n[green]All checks passed![/green]")
+            else:
+                self.console.print("\n[red]Issues found:[/red]")
+                for issue in status["issues"]:
+                    self.console.print(f"  - {issue}")
+
+            return CommandResult.success_result(
+                "Hook verification complete", data=status
+            )
+
+        except ImportError:
+            self.console.print("[red]Error: HookInstaller module not found[/red]")
+            return CommandResult.error_result("HookInstaller module not found")
+        except Exception as e:
+            self.logger.error(f"Hook verification error: {e}", exc_info=True)
+            return CommandResult.error_result(f"Hook verification failed: {e}")
+
+    def _uninstall_hooks(self) -> CommandResult:
+        """Uninstall Claude MPM hooks."""
+        try:
+            from ...hooks.claude_hooks.installer import HookInstaller
+
+            installer = HookInstaller()
+
+            # Confirm uninstallation
+            if not Confirm.ask(
+                "[yellow]Are you sure you want to uninstall Claude MPM hooks?[/yellow]"
+            ):
+                return CommandResult.success_result("Uninstallation cancelled")
+
+            self.console.print("[cyan]Uninstalling Claude MPM hooks...[/cyan]")
+            success = installer.uninstall_hooks()
+
+            if success:
+                self.console.print("[green]✓ Hooks uninstalled successfully![/green]")
+                return CommandResult.success_result("Hooks uninstalled successfully")
+            self.console.print("[red]✗ Hook uninstallation failed[/red]")
+            return CommandResult.error_result("Hook uninstallation failed")
+
+        except ImportError:
+            self.console.print("[red]Error: HookInstaller module not found[/red]")
+            return CommandResult.error_result("HookInstaller module not found")
+        except Exception as e:
+            self.logger.error(f"Hook uninstallation error: {e}", exc_info=True)
+            return CommandResult.error_result(f"Hook uninstallation failed: {e}")
+
     def _run_agent_management(self) -> CommandResult:
         """Jump directly to agent management."""
         try:

claude_mpm/cli/commands/configure_tui.py

@@ -1200,7 +1200,11 @@ class SettingsScreen(Container):
             import subprocess
 
             result = subprocess.run(
-                ["claude", "--version"], capture_output=True, text=True, timeout=5, check=False
+                ["claude", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
             )
             if result.returncode == 0:
                 claude_version = result.stdout.strip()

claude_mpm/cli/parsers/configure_parser.py

@@ -96,6 +96,29 @@ def add_configure_subparser(subparsers) -> argparse.ArgumentParser:
         help="Import configuration from a file",
     )
 
+    # Hook management options
+    hooks_group = configure_parser.add_argument_group("hook management")
+    hooks_group.add_argument(
+        "--install-hooks",
+        action="store_true",
+        help="Install Claude MPM hooks for Claude Code integration",
+    )
+    hooks_group.add_argument(
+        "--verify-hooks",
+        action="store_true",
+        help="Verify that Claude MPM hooks are properly installed",
+    )
+    hooks_group.add_argument(
+        "--uninstall-hooks",
+        action="store_true",
+        help="Uninstall Claude MPM hooks",
+    )
+    hooks_group.add_argument(
+        "--force",
+        action="store_true",
+        help="Force reinstallation of hooks even if they already exist",
+    )
+
     # Display options
     display_group = configure_parser.add_argument_group("display options")
     display_group.add_argument(

claude_mpm/config/socketio_config.py

@@ -10,6 +10,8 @@ WHY configuration management:
 - Supports multiple deployment scenarios (local, PyPI, Docker, etc.)
 - Provides environment-specific defaults
 - Allows runtime configuration overrides
+
+CRITICAL: Ping/pong settings MUST match between client and server to prevent disconnections!
 """
 
 import os
@@ -19,6 +21,30 @@ from typing import Any, Dict, List, Optional
 # Import constants for default values
 from claude_mpm.core.constants import NetworkConfig, RetryConfig, SystemLimits
 
+# Connection stability settings - MUST be consistent between client and server
+CONNECTION_CONFIG = {
+    # Ping/pong intervals (milliseconds for client, seconds for server)
+    "ping_interval_ms": 25000,  # 25 seconds (for client JavaScript)
+    "ping_interval": 25,  # 25 seconds (for server Python) - reduced for stability
+    "ping_timeout_ms": 20000,  # 20 seconds (for client JavaScript)
+    "ping_timeout": 20,  # 20 seconds (for server Python)
+    # Connection management
+    "stale_timeout": 90,  # 90 seconds before considering connection stale (was 180)
+    "health_check_interval": 30,  # Health check every 30 seconds
+    "event_ttl": 300,  # Keep events for 5 minutes for replay
+    "connection_timeout": 10,  # 10 seconds for initial connection timeout
+    # Client reconnection settings
+    "reconnection_attempts": 5,  # Number of reconnection attempts
+    "reconnection_delay": 1000,  # Initial delay in ms
+    "reconnection_delay_max": 5000,  # Maximum delay in ms
+    # Feature flags
+    "enable_extra_heartbeat": False,  # Disable redundant heartbeats
+    "enable_health_monitoring": True,  # Enable connection health monitoring
+    # Buffer settings
+    "max_events_buffer": 1000,  # Maximum events to buffer per client
+    "max_http_buffer_size": 1e8,  # 100MB max buffer for large payloads
+}
+
 
 @dataclass
 class SocketIOConfig:
@@ -29,11 +55,14 @@ class SocketIOConfig:
     port: int = NetworkConfig.DEFAULT_DASHBOARD_PORT
     server_id: Optional[str] = None
 
-    # Connection settings
+    # Connection settings - Use centralized config for consistency
     cors_allowed_origins: str = "*"  # Configure properly for production
-    ping_timeout: int = NetworkConfig.PING_TIMEOUT_STANDARD
-    ping_interval: int = NetworkConfig.PING_INTERVAL_STANDARD
-    max_http_buffer_size: int = 1000000
+    ping_timeout: int = CONNECTION_CONFIG["ping_timeout"]  # 20 seconds
+    ping_interval: int = CONNECTION_CONFIG["ping_interval"]  # 25 seconds (was 45)
+    max_http_buffer_size: int = int(CONNECTION_CONFIG["max_http_buffer_size"])
+    connection_timeout: int = CONNECTION_CONFIG.get(
+        "connection_timeout", 10
+    )  # 10 seconds
 
     # Compatibility settings
     min_client_version: str = "0.7.0"

claude_mpm/dashboard/static/js/socket-client.js

@@ -38,10 +38,10 @@ class SocketClient {
         this.eventQueue = [];
         this.maxQueueSize = 100;
         
-        // Retry configuration
+        // Retry configuration - Match server settings
         this.retryAttempts = 0;
-        this.maxRetryAttempts = 3;
-        this.retryDelays = [1000, 2000, 4000]; // Exponential backoff
+        this.maxRetryAttempts = 5;  // Increased from 3 to 5 for better stability
+        this.retryDelays = [1000, 2000, 3000, 4000, 5000]; // Exponential backoff with 5 attempts
         this.pendingEmissions = new Map(); // Track pending emissions for retry
         
         // Health monitoring
@@ -98,12 +98,12 @@ class SocketClient {
             reconnection: true,
             reconnectionDelay: 1000,
             reconnectionDelayMax: 5000,
-            reconnectionAttempts: Infinity,  // Keep trying indefinitely
-            timeout: 20000,  // Increase connection timeout
+            reconnectionAttempts: 5,  // Try 5 times then stop (was Infinity which can cause issues)
+            timeout: 20000,  // Connection timeout
             forceNew: true,
             transports: ['websocket', 'polling'],
-            pingInterval: 25000,  // Match server setting
-            pingTimeout: 60000    // Match server setting
+            pingInterval: 45000,  // CRITICAL: Must match server's 45 seconds
+            pingTimeout: 20000    // CRITICAL: Must match server's 20 seconds
         });
 
         this.setupSocketHandlers();
@@ -143,17 +143,22 @@ class SocketClient {
         });
 
         this.socket.on('disconnect', (reason) => {
-            console.log('Disconnected from server:', reason);
+            // Enhanced logging for debugging disconnection issues
+            const disconnectInfo = {
+                reason: reason,
+                timestamp: new Date().toISOString(),
+                wasConnected: this.isConnected,
+                uptimeSeconds: this.lastConnectTime ? ((Date.now() - this.lastConnectTime) / 1000).toFixed(1) : 0,
+                lastPing: this.lastPingTime ? ((Date.now() - this.lastPingTime) / 1000).toFixed(1) + 's ago' : 'never',
+                lastPong: this.lastPongTime ? ((Date.now() - this.lastPongTime) / 1000).toFixed(1) + 's ago' : 'never'
+            };
+            
+            console.log('Disconnected from server:', disconnectInfo);
+            
             this.isConnected = false;
             this.isConnecting = false;
             this.disconnectTime = Date.now();
             
-            // Calculate uptime
-            if (this.lastConnectTime) {
-                const uptime = (Date.now() - this.lastConnectTime) / 1000;
-                console.log(`Connection uptime was ${uptime.toFixed(1)}s`);
-            }
-            
             this.notifyConnectionStatus(`Disconnected: ${reason}`, 'disconnected');
 
             // Emit disconnect callback
@@ -161,8 +166,21 @@ class SocketClient {
                 callback(reason)
             );
             
-            // Start auto-reconnect if it was an unexpected disconnect
-            if (reason === 'transport close' || reason === 'ping timeout') {
+            // Detailed reason analysis for auto-reconnect decision
+            const reconnectReasons = [
+                'transport close',      // Network issue
+                'ping timeout',         // Server not responding
+                'transport error',      // Connection error
+                'io server disconnect', // Server initiated disconnect (might be restart)
+            ];
+            
+            if (reconnectReasons.includes(reason)) {
+                console.log(`Auto-reconnect triggered for reason: ${reason}`);
+                this.scheduleReconnect();
+            } else if (reason === 'io client disconnect') {
+                console.log('Client-initiated disconnect, not auto-reconnecting');
+            } else {
+                console.log(`Unknown disconnect reason: ${reason}, attempting reconnect anyway`);
                 this.scheduleReconnect();
             }
         });
@@ -222,6 +240,12 @@ class SocketClient {
             });
         });
         
+        // Track pong responses from server
+        this.socket.on('pong', (data) => {
+            this.lastPongTime = Date.now();
+            // console.log('Received pong from server');
+        });
+        
         // Session and event handlers (legacy/fallback)
         this.socket.on('session.started', (data) => {
             this.addEvent({ type: 'session', subtype: 'started', timestamp: new Date().toISOString(), data });