claude-mpm 4.2.24__py3-none-any.whl → 4.2.26__py3-none-any.whl

claude_mpm/services/monitor/daemon.py

@@ -23,6 +23,7 @@ from pathlib import Path
 from typing import Optional
 
 from ...core.logging_config import get_logger
+from ..hook_installer_service import HookInstallerService
 from .management.health import HealthMonitor
 from .management.lifecycle import DaemonLifecycle
 from .server import UnifiedMonitorServer
@@ -59,9 +60,9 @@ class UnifiedMonitorDaemon:
 
         # Daemon management with port for verification
         self.lifecycle = DaemonLifecycle(
-            pid_file=pid_file or self._get_default_pid_file(), 
+            pid_file=pid_file or self._get_default_pid_file(),
             log_file=log_file,
-            port=port
+            port=port,
         )
 
         # Core server
@@ -70,6 +71,9 @@ class UnifiedMonitorDaemon:
         # Health monitoring
         self.health_monitor = HealthMonitor(port=port)
 
+        # Hook installer service
+        self.hook_installer = HookInstallerService()
+
         # State
         self.running = False
         self.shutdown_event = threading.Event()
@@ -98,9 +102,90 @@ class UnifiedMonitorDaemon:
             self.logger.error(f"Failed to start unified monitor daemon: {e}")
             return False
 
+    def _cleanup_port_conflicts(self) -> bool:
+        """Try to clean up any processes using our port.
+        
+        Returns:
+            True if cleanup was successful, False otherwise
+        """
+        try:
+            # Find process using the port
+            import subprocess
+            result = subprocess.run(
+                ["lsof", "-ti", f":{self.port}"],
+                capture_output=True,
+                text=True
+            )
+            
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split('\n')
+                for pid_str in pids:
+                    try:
+                        pid = int(pid_str.strip())
+                        self.logger.info(f"Found process {pid} using port {self.port}")
+                        
+                        # Check if it's a claude-mpm process
+                        process_info = subprocess.run(
+                            ["ps", "-p", str(pid), "-o", "comm="],
+                            capture_output=True,
+                            text=True
+                        )
+                        
+                        if "python" in process_info.stdout.lower() or "claude" in process_info.stdout.lower():
+                            self.logger.info(f"Killing process {pid} (appears to be Python/Claude related)")
+                            os.kill(pid, signal.SIGTERM)
+                            time.sleep(1)
+                            
+                            # Check if still alive
+                            try:
+                                os.kill(pid, 0)
+                                # Still alive, force kill
+                                self.logger.warning(f"Process {pid} didn't terminate, force killing")
+                                os.kill(pid, signal.SIGKILL)
+                                time.sleep(1)
+                            except ProcessLookupError:
+                                pass
+                        else:
+                            self.logger.warning(f"Process {pid} is not a Claude MPM process: {process_info.stdout}")
+                            return False
+                    except (ValueError, ProcessLookupError) as e:
+                        self.logger.debug(f"Error handling PID {pid_str}: {e}")
+                        continue
+                
+                return True
+                
+        except FileNotFoundError:
+            # lsof not available, try alternative method
+            self.logger.debug("lsof not available, using alternative cleanup")
+            
+            # Check if there's an orphaned service we can identify
+            is_ours, pid = self.lifecycle.is_our_service(self.host)
+            if is_ours and pid:
+                try:
+                    self.logger.info(f"Killing orphaned Claude MPM service (PID: {pid})")
+                    os.kill(pid, signal.SIGTERM)
+                    time.sleep(1)
+                    
+                    # Check if still alive
+                    try:
+                        os.kill(pid, 0)
+                        os.kill(pid, signal.SIGKILL)
+                        time.sleep(1)
+                    except ProcessLookupError:
+                        pass
+                    
+                    return True
+                except Exception as e:
+                    self.logger.error(f"Failed to kill process: {e}")
+                    
+        except Exception as e:
+            self.logger.error(f"Error during port cleanup: {e}")
+            
+        return False
+
     def _start_daemon(self, force_restart: bool = False) -> bool:
         """Start as background daemon process.
-        
+
         Args:
             force_restart: If True, restart existing service if it's ours
         """
@@ -109,14 +194,18 @@ class UnifiedMonitorDaemon:
         # Check if already running
         if self.lifecycle.is_running():
             existing_pid = self.lifecycle.get_pid()
-            
+
             if force_restart:
                 # Check if it's our service
-                self.logger.debug(f"Checking if existing daemon (PID: {existing_pid}) is our service...")
+                self.logger.debug(
+                    f"Checking if existing daemon (PID: {existing_pid}) is our service..."
+                )
                 is_ours, detected_pid = self.lifecycle.is_our_service(self.host)
-                
+
                 if is_ours:
-                    self.logger.info(f"Force restarting our existing claude-mpm monitor daemon (PID: {detected_pid or existing_pid})")
+                    self.logger.info(
+                        f"Force restarting our existing claude-mpm monitor daemon (PID: {detected_pid or existing_pid})"
+                    )
                     # Stop the existing daemon
                     if self.lifecycle.stop_daemon():
                         # Wait a moment for port to be released
@@ -125,19 +214,27 @@ class UnifiedMonitorDaemon:
                         self.logger.error("Failed to stop existing daemon for restart")
                         return False
                 else:
-                    self.logger.warning(f"Port {self.port} is in use by another service (PID: {existing_pid}). Cannot force restart.")
-                    self.logger.info("To restart the claude-mpm monitor, first stop the other service or use a different port.")
+                    self.logger.warning(
+                        f"Port {self.port} is in use by another service (PID: {existing_pid}). Cannot force restart."
+                    )
+                    self.logger.info(
+                        "To restart the claude-mpm monitor, first stop the other service or use a different port."
+                    )
                     return False
             else:
                 self.logger.warning(f"Daemon already running with PID {existing_pid}")
                 return False
-        
+
         # Check for orphaned processes (service running but no PID file)
         elif force_restart:
-            self.logger.debug("No PID file found, checking for orphaned claude-mpm service...")
+            self.logger.debug(
+                "No PID file found, checking for orphaned claude-mpm service..."
+            )
             is_ours, pid = self.lifecycle.is_our_service(self.host)
             if is_ours and pid:
-                self.logger.info(f"Found orphaned claude-mpm monitor service (PID: {pid}), force restarting")
+                self.logger.info(
+                    f"Found orphaned claude-mpm monitor service (PID: {pid}), force restarting"
+                )
                 # Try to kill the orphaned process
                 try:
                     os.kill(pid, signal.SIGTERM)
@@ -155,13 +252,27 @@ class UnifiedMonitorDaemon:
                 except Exception as e:
                     self.logger.error(f"Failed to kill orphaned process: {e}")
                     return False
-        
-        # Verify port is available before forking
+
+        # Check port availability and clean up if needed
         port_available, error_msg = self.lifecycle.verify_port_available(self.host)
         if not port_available:
-            self.logger.error(error_msg)
-            print(f"Error: {error_msg}", file=sys.stderr)
-            return False
+            self.logger.warning(f"Port {self.port} is not available: {error_msg}")
+            
+            # Try to identify and kill any process using the port
+            self.logger.info("Attempting to clean up processes on port...")
+            cleaned = self._cleanup_port_conflicts()
+            
+            if cleaned:
+                # Wait a moment for port to be released
+                time.sleep(2)
+                # Check again
+                port_available, error_msg = self.lifecycle.verify_port_available(self.host)
+                
+            if not port_available:
+                self.logger.error(f"Port {self.port} is still not available after cleanup: {error_msg}")
+                print(f"Error: {error_msg}", file=sys.stderr)
+                print(f"Try 'claude-mpm monitor stop' or use --force flag", file=sys.stderr)
+                return False
 
         # Wait for any pre-warming threads to complete before forking
         self._wait_for_prewarm_completion()
@@ -186,7 +297,7 @@ class UnifiedMonitorDaemon:
 
     def _start_foreground(self, force_restart: bool = False) -> bool:
         """Start in foreground mode.
-        
+
         Args:
             force_restart: If True, restart existing service if it's ours
         """
@@ -195,14 +306,18 @@ class UnifiedMonitorDaemon:
         # Check if already running (check PID file even in foreground mode)
         if self.lifecycle.is_running():
             existing_pid = self.lifecycle.get_pid()
-            
+
             if force_restart:
                 # Check if it's our service
-                self.logger.debug(f"Checking if existing daemon (PID: {existing_pid}) is our service...")
+                self.logger.debug(
+                    f"Checking if existing daemon (PID: {existing_pid}) is our service..."
+                )
                 is_ours, detected_pid = self.lifecycle.is_our_service(self.host)
-                
+
                 if is_ours:
-                    self.logger.info(f"Force restarting our existing claude-mpm monitor daemon (PID: {detected_pid or existing_pid})")
+                    self.logger.info(
+                        f"Force restarting our existing claude-mpm monitor daemon (PID: {detected_pid or existing_pid})"
+                    )
                     # Stop the existing daemon
                     if self.lifecycle.stop_daemon():
                         # Wait a moment for port to be released
@@ -211,21 +326,29 @@ class UnifiedMonitorDaemon:
                         self.logger.error("Failed to stop existing daemon for restart")
                         return False
                 else:
-                    self.logger.warning(f"Port {self.port} is in use by another service (PID: {existing_pid}). Cannot force restart.")
-                    self.logger.info("To restart the claude-mpm monitor, first stop the other service or use a different port.")
+                    self.logger.warning(
+                        f"Port {self.port} is in use by another service (PID: {existing_pid}). Cannot force restart."
+                    )
+                    self.logger.info(
+                        "To restart the claude-mpm monitor, first stop the other service or use a different port."
+                    )
                     return False
             else:
                 self.logger.warning(
                     f"Monitor daemon already running with PID {existing_pid}"
                 )
                 return False
-        
+
         # Check for orphaned processes (service running but no PID file)
         elif force_restart:
-            self.logger.debug("No PID file found, checking for orphaned claude-mpm service...")
+            self.logger.debug(
+                "No PID file found, checking for orphaned claude-mpm service..."
+            )
             is_ours, pid = self.lifecycle.is_our_service(self.host)
             if is_ours and pid:
-                self.logger.info(f"Found orphaned claude-mpm monitor service (PID: {pid}), force restarting")
+                self.logger.info(
+                    f"Found orphaned claude-mpm monitor service (PID: {pid}), force restarting"
+                )
                 # Try to kill the orphaned process
                 try:
                     os.kill(pid, signal.SIGTERM)
@@ -271,6 +394,26 @@ class UnifiedMonitorDaemon:
                     self.lifecycle._report_startup_error(error_msg)
                 return False
 
+            # Check and install hooks if needed
+            try:
+                if not self.hook_installer.is_hooks_configured():
+                    self.logger.info("Claude Code hooks not configured, installing...")
+                    if self.hook_installer.install_hooks():
+                        self.logger.info("Claude Code hooks installed successfully")
+                    else:
+                        # Don't fail startup if hook installation fails
+                        # The monitor can still function without hooks
+                        self.logger.warning(
+                            "Failed to install Claude Code hooks. Monitor will run without hook integration."
+                        )
+                else:
+                    self.logger.info("Claude Code hooks are already configured")
+            except Exception as e:
+                # Don't fail startup if hook checking fails
+                self.logger.warning(
+                    f"Error checking/installing hooks: {e}. Monitor will run without hook integration."
+                )
+
             # Start health monitoring
             self.health_monitor.start()
 
@@ -285,7 +428,7 @@ class UnifiedMonitorDaemon:
 
             self.running = True
             self.logger.info("Unified monitor daemon started successfully")
-            
+
             # Report successful startup to parent (for daemon mode)
             if self.daemon_mode:
                 self.lifecycle._report_startup_success()
@@ -326,7 +469,7 @@ class UnifiedMonitorDaemon:
                 pid = self.lifecycle.get_pid()
                 if pid and pid != os.getpid():
                     # We're not the daemon process, so stop it via signal
-                    self.logger.info(f"Stopping daemon process with PID {pid}")
+                    # Don't log here - lifecycle.stop_daemon will log
                     success = self.lifecycle.stop_daemon()
                     if success:
                         # Clean up our local state