claude-mpm 4.2.29__py3-none-any.whl → 4.2.32__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.29
+4.2.32

claude_mpm/services/cli/unified_dashboard_manager.py

@@ -25,6 +25,7 @@ import requests
 
 from ...core.logging_config import get_logger
 from ...services.monitor.daemon import UnifiedMonitorDaemon
+from ...services.monitor.daemon_manager import DaemonManager
 from ...services.port_manager import PortManager
 
 
@@ -99,8 +100,9 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
                 host="localhost", port=port, daemon_mode=background
             )
 
-            # Check if it's our service running
-            is_ours, pid = daemon.lifecycle.is_our_service("localhost")
+            # Use daemon manager to check service ownership
+            daemon_mgr = DaemonManager(port=port, host="localhost")
+            is_ours, pid = daemon_mgr.is_our_service()
 
             if is_ours and not force_restart:
                 # Our service is already running, just open browser if needed
@@ -115,12 +117,16 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
                 self.logger.info(
                     f"Force restarting our dashboard on port {port} (PID: {pid})"
                 )
-                # Clean up the existing service before restart
-                self._cleanup_port_conflicts(port)
+                # Use daemon manager for cleanup
+                daemon_mgr = DaemonManager(port=port, host="localhost")
+                daemon_mgr.cleanup_port_conflicts()
             elif self.is_dashboard_running(port) and not force_restart:
                 # Different service is using the port - try to clean it up
-                self.logger.warning(f"Port {port} is in use by a different service, attempting cleanup")
-                self._cleanup_port_conflicts(port)
+                self.logger.warning(
+                    f"Port {port} is in use by a different service, attempting cleanup"
+                )
+                daemon_mgr = DaemonManager(port=port, host="localhost")
+                daemon_mgr.cleanup_port_conflicts()
                 # Brief pause to ensure cleanup is complete
                 time.sleep(1)
 
@@ -130,39 +136,49 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
 
             if background:
                 # Always try to clean up first before starting
-                self.logger.info(f"Pre-emptively cleaning up port {port} before starting daemon")
-                if not self._cleanup_port_conflicts(port):
+                self.logger.info(
+                    f"Pre-emptively cleaning up port {port} before starting daemon"
+                )
+                daemon_mgr = DaemonManager(port=port, host="localhost")
+                if not daemon_mgr.cleanup_port_conflicts():
                     self.logger.error(f"Failed to clean up port {port}, cannot proceed")
                     return False, False
-                    
+
                 # Try to start daemon with retry on port conflicts
                 max_retries = 3
                 retry_count = 0
                 success = False
-                
+
                 while retry_count < max_retries and not success:
                     if retry_count > 0:
-                        self.logger.info(f"Retry {retry_count}/{max_retries}: Cleaning up port {port}")
-                        if not self._cleanup_port_conflicts(port):
+                        self.logger.info(
+                            f"Retry {retry_count}/{max_retries}: Cleaning up port {port}"
+                        )
+                        daemon_mgr = DaemonManager(port=port, host="localhost")
+                        if not daemon_mgr.cleanup_port_conflicts():
                             self.logger.error(f"Cleanup failed on retry {retry_count}")
                             break
                         time.sleep(3)  # Longer wait for cleanup to complete
-                    
+
                     # Start daemon in background mode with force restart if needed
                     success = daemon.start(force_restart=True)  # Always force restart
-                    
+
                     if not success and retry_count < max_retries - 1:
                         # Check if it's a port conflict
                         if not self.port_manager.is_port_available(port):
-                            self.logger.warning(f"Port {port} still in use, will retry cleanup")
+                            self.logger.warning(
+                                f"Port {port} still in use, will retry cleanup"
+                            )
                             retry_count += 1
                         else:
                             # Different kind of failure, don't retry
-                            self.logger.error(f"Daemon start failed for reason other than port conflict")
+                            self.logger.error(
+                                "Daemon start failed for reason other than port conflict"
+                            )
                             break
                     else:
                         break
-                
+
                 if success:
                     with self._lock:
                         self._background_daemons[port] = daemon
@@ -350,91 +366,17 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
     def _cleanup_port_conflicts(self, port: int) -> bool:
         """
         Try to clean up any processes using our port.
-        
+
+        Delegates to the consolidated DaemonManager for consistent behavior.
+
         Args:
             port: Port to clean up
-            
+
         Returns:
             True if cleanup was successful or not needed
         """
-        try:
-            import subprocess
-            import signal
-            import time
-            
-            # Find processes using the port
-            result = subprocess.run(
-                ["lsof", "-ti", f":{port}"],
-                capture_output=True,
-                text=True
-            )
-            
-            if result.returncode == 0 and result.stdout.strip():
-                pids = result.stdout.strip().split('\n')
-                self.logger.info(f"Found processes using port {port}: {pids}")
-                
-                for pid_str in pids:
-                    try:
-                        pid = int(pid_str.strip())
-                        # Try graceful termination first
-                        import os
-                        os.kill(pid, signal.SIGTERM)
-                        self.logger.info(f"Sent SIGTERM to process {pid}")
-                    except (ValueError, ProcessLookupError) as e:
-                        self.logger.debug(f"Could not terminate process {pid_str}: {e}")
-                        continue
-                
-                # Give processes time to shut down gracefully
-                time.sleep(3)
-                
-                # Check if port is still in use and force kill if needed
-                result = subprocess.run(
-                    ["lsof", "-ti", f":{port}"],
-                    capture_output=True,
-                    text=True
-                )
-                
-                if result.returncode == 0 and result.stdout.strip():
-                    remaining_pids = result.stdout.strip().split('\n')
-                    self.logger.warning(f"Processes still using port {port}: {remaining_pids}, force killing")
-                    
-                    for pid_str in remaining_pids:
-                        try:
-                            pid = int(pid_str.strip())
-                            os.kill(pid, signal.SIGKILL)
-                            self.logger.info(f"Force killed process {pid}")
-                        except (ValueError, ProcessLookupError) as e:
-                            self.logger.debug(f"Could not force kill process {pid_str}: {e}")
-                            continue
-                    
-                    # Longer pause after force kill to ensure port is fully released
-                    time.sleep(5)
-                    
-                # Final verification that port is actually free
-                final_check = subprocess.run(
-                    ["lsof", "-ti", f":{port}"],
-                    capture_output=True,
-                    text=True
-                )
-                
-                if final_check.returncode == 0 and final_check.stdout.strip():
-                    self.logger.error(f"Failed to clean up port {port} - processes still running: {final_check.stdout.strip()}")
-                    return False
-                
-                self.logger.info(f"Successfully cleaned up processes on port {port}")
-                return True
-            else:
-                self.logger.debug(f"No processes found using port {port}")
-                return True
-                
-        except FileNotFoundError:
-            # lsof not available, try alternative approach
-            self.logger.debug("lsof not available, skipping port cleanup")
-            return True
-        except Exception as e:
-            self.logger.warning(f"Error during port cleanup: {e}")
-            # Continue anyway - the port check will catch actual conflicts
-            return True
+        daemon_mgr = DaemonManager(port=port, host="localhost")
+        return daemon_mgr.cleanup_port_conflicts()
 
     def start_server(
         self, port: Optional[int] = None, timeout: int = 30, force_restart: bool = True

claude_mpm/services/monitor/daemon.py

@@ -24,6 +24,7 @@ from typing import Optional
 
 from ...core.logging_config import get_logger
 from ..hook_installer_service import HookInstallerService
+from .daemon_manager import DaemonManager
 from .management.health import HealthMonitor
 from .management.lifecycle import DaemonLifecycle
 from .server import UnifiedMonitorServer
@@ -58,7 +59,15 @@ class UnifiedMonitorDaemon:
         self.daemon_mode = daemon_mode
         self.logger = get_logger(__name__)
 
-        # Daemon management with port for verification
+        # Use new consolidated DaemonManager for all daemon operations
+        self.daemon_manager = DaemonManager(
+            port=port,
+            host=host,
+            pid_file=pid_file or self._get_default_pid_file(),
+            log_file=log_file,
+        )
+
+        # Keep lifecycle for backward compatibility (delegates to daemon_manager)
         self.lifecycle = DaemonLifecycle(
             pid_file=pid_file or self._get_default_pid_file(),
             log_file=log_file,
@@ -104,84 +113,13 @@ class UnifiedMonitorDaemon:
 
     def _cleanup_port_conflicts(self) -> bool:
         """Try to clean up any processes using our port.
-        
+
+        Delegates to the consolidated DaemonManager for consistent behavior.
+
         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
+        return self.daemon_manager.cleanup_port_conflicts()
 
     def _start_daemon(self, force_restart: bool = False) -> bool:
         """Start as background daemon process.
@@ -191,108 +129,60 @@ class UnifiedMonitorDaemon:
         """
         self.logger.info("Starting unified monitor daemon in background mode")
 
-        # 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..."
-                )
-                is_ours, detected_pid = self.lifecycle.is_our_service(self.host)
+        # Always use daemon manager for cleanup first
+        # This ensures consistent behavior and prevents race conditions
+        if force_restart:
+            self.logger.info(
+                "Force restart requested, cleaning up any existing processes..."
+            )
+            if not self.daemon_manager.cleanup_port_conflicts(max_retries=3):
+                self.logger.error(f"Failed to clean up port {self.port}")
+                return False
+            # Wait for port to be fully released
+            time.sleep(2)
 
-                if is_ours:
-                    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
-                        time.sleep(2)
-                    else:
-                        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."
-                    )
-                    return False
-            else:
+        # Check if already running via daemon manager
+        if self.daemon_manager.is_running():
+            existing_pid = self.daemon_manager.get_pid()
+            if not force_restart:
                 self.logger.warning(f"Daemon already running with PID {existing_pid}")
                 return False
+            # Force restart was already handled above
 
-        # 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..."
+        # Check for our service on the port
+        is_ours, pid = self.daemon_manager.is_our_service()
+        if is_ours and pid and not force_restart:
+            self.logger.warning(
+                f"Our service already running on port {self.port} (PID: {pid})"
             )
-            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"
-                )
-                # Try to kill the orphaned process
-                try:
-                    os.kill(pid, signal.SIGTERM)
-                    # Wait for it to exit
-                    for _ in range(10):
-                        try:
-                            os.kill(pid, 0)  # Check if still exists
-                            time.sleep(0.5)
-                        except ProcessLookupError:
-                            break
-                    else:
-                        # Force kill if still running
-                        os.kill(pid, signal.SIGKILL)
-                        time.sleep(1)
-                except Exception as e:
-                    self.logger.error(f"Failed to kill orphaned process: {e}")
-                    return False
-
-        # 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.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 longer for port to be released to avoid race conditions
-                time.sleep(3)
-                # 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
+            return False
 
         # Wait for any pre-warming threads to complete before forking
         self._wait_for_prewarm_completion()
 
-        # Daemonize the process
-        success = self.lifecycle.daemonize()
+        # Use daemon manager's daemonize which includes cleanup
+        self.daemon_manager.startup_status_file = None  # Reset status file
+        success = self.daemon_manager.daemonize()
         if not success:
             return False
 
+        # We're now in the daemon process
+        # Update our PID references
+        self.lifecycle.pid_file = self.daemon_manager.pid_file
+
         # Start the server in daemon mode
-        # This will run in the child process
         try:
             result = self._run_server()
             if not result:
                 # Report failure before exiting
-                self.lifecycle._report_startup_error("Failed to start server")
+                self.daemon_manager._report_startup_error("Failed to start server")
+            else:
+                # Report success
+                self.daemon_manager._report_startup_success()
             return result
         except Exception as e:
             # Report any exceptions during startup
-            self.lifecycle._report_startup_error(f"Server startup exception: {e}")
+            self.daemon_manager._report_startup_error(f"Server startup exception: {e}")
             raise
 
     def _start_foreground(self, force_restart: bool = False) -> bool:
@@ -302,12 +192,12 @@ class UnifiedMonitorDaemon:
             force_restart: If True, restart existing service if it's ours
         """
         self.logger.info(f"Starting unified monitor daemon on {self.host}:{self.port}")
-        
-        # Clean up any processes on the port before checking service status
+
+        # Use daemon manager for consistent port cleanup
         # This helps with race conditions where old processes haven't fully released the port
         if force_restart:
             self.logger.info("Force restart requested, cleaning up port conflicts...")
-            self._cleanup_port_conflicts()
+            self.daemon_manager.cleanup_port_conflicts(max_retries=2)
             time.sleep(1)  # Brief pause to ensure port is released
 
         # Check if already running (check PID file even in foreground mode)
@@ -319,7 +209,7 @@ class UnifiedMonitorDaemon:
                 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)
+                is_ours, detected_pid = self.daemon_manager.is_our_service()
 
                 if is_ours:
                     self.logger.info(
@@ -351,7 +241,7 @@ class UnifiedMonitorDaemon:
             self.logger.debug(
                 "No PID file found, checking for orphaned claude-mpm service..."
             )
-            is_ours, pid = self.lifecycle.is_our_service(self.host)
+            is_ours, pid = self.daemon_manager.is_our_service()
             if is_ours and pid:
                 self.logger.info(
                     f"Found orphaned claude-mpm monitor service (PID: {pid}), force restarting"

claude_mpm/services/monitor/daemon_manager.py

@@ -0,0 +1,739 @@
+"""
+Unified Daemon Manager Service
+==============================
+
+WHY: This service consolidates ALL daemon lifecycle operations into a single place,
+eliminating duplicate code and race conditions from having daemon management logic
+scattered across multiple files.
+
+DESIGN DECISIONS:
+- Single source of truth for all daemon operations
+- Robust port cleanup with retry logic
+- Thread-safe operations with proper locking
+- Comprehensive error handling and recovery
+- Supports both foreground and background/daemon modes
+- Manages PID files, port conflicts, and process lifecycle
+
+This replaces duplicate logic that was in:
+- UnifiedMonitorDaemon._cleanup_port_conflicts()
+- UnifiedDashboardManager._cleanup_port_conflicts()
+- Various daemon startup/stop logic spread across files
+"""
+
+import os
+import signal
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+from typing import Optional, Tuple
+
+from ...core.logging_config import get_logger
+
+
+class DaemonManager:
+    """Centralized manager for all daemon lifecycle operations.
+
+    This is the SINGLE source of truth for:
+    - Port conflict resolution
+    - Process cleanup
+    - Daemon startup/stop
+    - PID file management
+    - Service detection
+    """
+
+    # Class-level lock for thread safety
+    _lock = threading.Lock()
+
+    def __init__(
+        self,
+        port: int = 8765,
+        host: str = "localhost",
+        pid_file: Optional[str] = None,
+        log_file: Optional[str] = None,
+    ):
+        """Initialize the daemon manager.
+
+        Args:
+            port: Port number for the daemon
+            host: Host to bind to
+            pid_file: Path to PID file (uses default if None)
+            log_file: Path to log file for daemon mode
+        """
+        self.port = port
+        self.host = host
+        self.logger = get_logger(__name__)
+
+        # Set up paths
+        if pid_file:
+            self.pid_file = Path(pid_file)
+        else:
+            self.pid_file = self._get_default_pid_file()
+
+        self.log_file = Path(log_file) if log_file else self._get_default_log_file()
+
+        # Startup status communication
+        self.startup_status_file = None
+
+    def _get_default_pid_file(self) -> Path:
+        """Get default PID file path."""
+        project_root = Path.cwd()
+        claude_mpm_dir = project_root / ".claude-mpm"
+        claude_mpm_dir.mkdir(exist_ok=True)
+        return claude_mpm_dir / "monitor-daemon.pid"
+
+    def _get_default_log_file(self) -> Path:
+        """Get default log file path."""
+        project_root = Path.cwd()
+        claude_mpm_dir = project_root / ".claude-mpm"
+        claude_mpm_dir.mkdir(exist_ok=True)
+        return claude_mpm_dir / "monitor-daemon.log"
+
+    def cleanup_port_conflicts(self, max_retries: int = 3) -> bool:
+        """Clean up any processes using the daemon port.
+
+        This is the SINGLE implementation for port cleanup, replacing
+        duplicate logic in multiple files.
+
+        Args:
+            max_retries: Maximum number of cleanup attempts
+
+        Returns:
+            True if port is available after cleanup, False otherwise
+        """
+        with self._lock:
+            for attempt in range(max_retries):
+                if attempt > 0:
+                    self.logger.info(
+                        f"Port cleanup attempt {attempt + 1}/{max_retries}"
+                    )
+
+                # First check if port is actually in use
+                if self._is_port_available():
+                    self.logger.debug(f"Port {self.port} is available")
+                    return True
+
+                self.logger.info(f"Port {self.port} is in use, attempting cleanup")
+
+                # Try to find and kill processes using the port
+                if self._kill_processes_on_port():
+                    # Wait for port to be released
+                    time.sleep(2 if attempt == 0 else 3)
+
+                    # Verify port is now free
+                    if self._is_port_available():
+                        self.logger.info(f"Port {self.port} successfully cleaned up")
+                        return True
+
+                if attempt < max_retries - 1:
+                    # Wait longer between attempts
+                    time.sleep(3)
+
+            self.logger.error(
+                f"Failed to clean up port {self.port} after {max_retries} attempts"
+            )
+            return False
+
+    def _is_port_available(self) -> bool:
+        """Check if the port is available for binding.
+
+        Returns:
+            True if port is available, False otherwise
+        """
+        try:
+            test_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            test_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            test_sock.bind((self.host, self.port))
+            test_sock.close()
+            return True
+        except OSError:
+            return False
+
+    def _kill_processes_on_port(self) -> bool:
+        """Kill processes using the daemon port.
+
+        Returns:
+            True if processes were killed or none found, False on error
+        """
+        try:
+            # Try using lsof first (most reliable)
+            if self._kill_using_lsof():
+                return True
+
+            # Fallback to checking our known PID file
+            if self._kill_using_pid_file():
+                return True
+
+            # Try to identify claude-mpm processes
+            if self._kill_claude_mpm_processes():
+                return True
+
+            return False
+
+        except Exception as e:
+            self.logger.error(f"Error killing processes on port: {e}")
+            return False
+
+    def _kill_using_lsof(self) -> bool:
+        """Kill processes using lsof to find them.
+
+        Returns:
+            True if successful or lsof not available, False on error
+        """
+        try:
+            # Find processes using the port
+            result = subprocess.run(
+                ["lsof", "-ti", f":{self.port}"], capture_output=True, text=True, check=False
+            )
+
+            if result.returncode != 0 or not result.stdout.strip():
+                self.logger.debug(f"No processes found using port {self.port}")
+                return True
+
+            pids = result.stdout.strip().split("\n")
+            self.logger.info(f"Found processes using port {self.port}: {pids}")
+
+            # Kill each process
+            for pid_str in pids:
+                try:
+                    pid = int(pid_str.strip())
+
+                    # Check if it's a Python/Claude process
+                    process_info = subprocess.run(
+                        ["ps", "-p", str(pid), "-o", "comm="],
+                        capture_output=True,
+                        text=True, check=False,
+                    )
+
+                    process_name = process_info.stdout.strip().lower()
+                    if "python" in process_name or "claude" in process_name:
+                        self.logger.info(f"Killing Python/Claude process {pid}")
+                        os.kill(pid, signal.SIGTERM)
+
+                        # Wait briefly for graceful shutdown
+                        time.sleep(1)
+
+                        # Check if still alive and force kill if needed
+                        try:
+                            os.kill(pid, 0)  # Check if process exists
+                            self.logger.warning(
+                                f"Process {pid} didn't terminate, force killing"
+                            )
+                            os.kill(pid, signal.SIGKILL)
+                            time.sleep(0.5)
+                        except ProcessLookupError:
+                            pass  # Process already dead
+                    else:
+                        self.logger.warning(
+                            f"Process {pid} ({process_name}) is not a Claude MPM process"
+                        )
+                        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
+            self.logger.debug("lsof not available, using alternative methods")
+            return True
+        except Exception as e:
+            self.logger.error(f"Error using lsof: {e}")
+            return False
+
+    def _kill_using_pid_file(self) -> bool:
+        """Kill process using PID file.
+
+        Returns:
+            True if successful or no PID file, False on error
+        """
+        try:
+            if not self.pid_file.exists():
+                return True
+
+            with open(self.pid_file) as f:
+                pid = int(f.read().strip())
+
+            self.logger.info(f"Found PID {pid} in PID file")
+
+            # Kill the process
+            try:
+                os.kill(pid, signal.SIGTERM)
+                time.sleep(1)
+
+                # Check if still alive
+                try:
+                    os.kill(pid, 0)
+                    os.kill(pid, signal.SIGKILL)
+                    time.sleep(0.5)
+                except ProcessLookupError:
+                    pass
+
+                # Remove PID file
+                self.pid_file.unlink(missing_ok=True)
+                return True
+
+            except ProcessLookupError:
+                # Process doesn't exist, just remove PID file
+                self.pid_file.unlink(missing_ok=True)
+                return True
+
+        except Exception as e:
+            self.logger.error(f"Error killing process from PID file: {e}")
+            return False
+
+    def _kill_claude_mpm_processes(self) -> bool:
+        """Kill any claude-mpm monitor processes.
+
+        Returns:
+            True if successful, False on error
+        """
+        try:
+            # Look for claude-mpm monitor processes
+            result = subprocess.run(["ps", "aux"], capture_output=True, text=True, check=False)
+
+            if result.returncode != 0:
+                return False
+
+            lines = result.stdout.strip().split("\n")
+            killed_any = False
+
+            for line in lines:
+                if "claude" in line.lower() and "monitor" in line.lower():
+                    parts = line.split()
+                    if len(parts) > 1:
+                        try:
+                            pid = int(parts[1])
+                            self.logger.info(
+                                f"Killing claude-mpm monitor process {pid}"
+                            )
+                            os.kill(pid, signal.SIGTERM)
+                            killed_any = True
+                            time.sleep(0.5)
+                        except (ValueError, ProcessLookupError):
+                            continue
+
+            if killed_any:
+                time.sleep(1)  # Give processes time to exit
+
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Error killing claude-mpm processes: {e}")
+            return False
+
+    def is_our_service(self) -> Tuple[bool, Optional[int]]:
+        """Check if the service on the port is our claude-mpm monitor.
+
+        Returns:
+            Tuple of (is_ours, pid) where is_ours is True if it's our service
+        """
+        try:
+            # First check PID file
+            if self.pid_file.exists():
+                try:
+                    with open(self.pid_file) as f:
+                        pid = int(f.read().strip())
+
+                    # Verify process exists
+                    os.kill(pid, 0)
+
+                    # Check if it's a Python process
+                    process_info = subprocess.run(
+                        ["ps", "-p", str(pid), "-o", "comm="],
+                        capture_output=True,
+                        text=True, check=False,
+                    )
+
+                    if "python" in process_info.stdout.lower():
+                        return True, pid
+
+                except (ValueError, ProcessLookupError, subprocess.CalledProcessError):
+                    # PID file exists but process doesn't or isn't Python
+                    self.pid_file.unlink(missing_ok=True)
+
+            # Check if service responds to our health endpoint
+            try:
+                import requests
+
+                response = requests.get(
+                    f"http://{self.host}:{self.port}/health", timeout=2
+                )
+
+                if response.status_code == 200:
+                    # Try to get service info
+                    try:
+                        data = response.json()
+                        if "claude" in str(data).lower() or "mpm" in str(data).lower():
+                            # It's likely our service, try to find PID
+                            pid = self._find_service_pid()
+                            return True, pid
+                    except:
+                        pass
+
+            except:
+                pass
+
+            return False, None
+
+        except Exception as e:
+            self.logger.error(f"Error checking service ownership: {e}")
+            return False, None
+
+    def _find_service_pid(self) -> Optional[int]:
+        """Find PID of service on our port using lsof.
+
+        Returns:
+            PID if found, None otherwise
+        """
+        try:
+            result = subprocess.run(
+                ["lsof", "-ti", f":{self.port}"], capture_output=True, text=True, check=False
+            )
+
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split("\n")
+                if pids:
+                    return int(pids[0].strip())
+
+        except:
+            pass
+
+        return None
+
+    def start_daemon(self, force_restart: bool = False) -> bool:
+        """Start the daemon with automatic cleanup and retry.
+
+        Args:
+            force_restart: Force restart even if already running
+
+        Returns:
+            True if daemon started successfully
+        """
+        with self._lock:
+            # Check if already running
+            if self.is_running():
+                if not force_restart:
+                    pid = self.get_pid()
+                    self.logger.info(f"Daemon already running with PID {pid}")
+                    return True
+
+                # Stop existing daemon
+                self.logger.info("Force restarting daemon")
+                if not self.stop_daemon():
+                    self.logger.error("Failed to stop existing daemon")
+                    return False
+
+                # Wait for cleanup
+                time.sleep(2)
+
+            # Clean up port conflicts
+            if not self.cleanup_port_conflicts():
+                self.logger.error(f"Cannot start daemon - port {self.port} is in use")
+                return False
+
+            # Daemonize the process
+            return self.daemonize()
+
+    def daemonize(self) -> bool:
+        """Daemonize the current process.
+
+        Returns:
+            True if successful (in parent), doesn't return in child
+        """
+        try:
+            # Clean up asyncio event loops before forking
+            self._cleanup_event_loops()
+
+            # Create status file for communication
+            with tempfile.NamedTemporaryFile(
+                mode="w", delete=False, suffix=".status"
+            ) as f:
+                self.startup_status_file = f.name
+                f.write("starting")
+
+            # First fork
+            pid = os.fork()
+            if pid > 0:
+                # Parent process - wait for child to confirm startup
+                return self._parent_wait_for_startup(pid)
+
+        except OSError as e:
+            self.logger.error(f"First fork failed: {e}")
+            return False
+
+        # Child process continues...
+
+        # Decouple from parent
+        os.chdir("/")
+        os.setsid()
+        os.umask(0)
+
+        try:
+            # Second fork
+            pid = os.fork()
+            if pid > 0:
+                # First child exits
+                sys.exit(0)
+        except OSError as e:
+            self.logger.error(f"Second fork failed: {e}")
+            self._report_startup_error(f"Second fork failed: {e}")
+            sys.exit(1)
+
+        # Grandchild process - the actual daemon
+
+        # Write PID file
+        self.write_pid_file()
+
+        # Redirect streams
+        self._redirect_streams()
+
+        # Setup signal handlers
+        self._setup_signal_handlers()
+
+        self.logger.info(f"Daemon process started with PID {os.getpid()}")
+
+        # Report successful startup
+        self._report_startup_success()
+
+        # Note: Daemon process continues running
+        # Caller is responsible for running the actual service
+        return True
+
+    def stop_daemon(self, timeout: int = 10) -> bool:
+        """Stop the daemon process.
+
+        Args:
+            timeout: Maximum time to wait for daemon to stop
+
+        Returns:
+            True if stopped successfully
+        """
+        with self._lock:
+            try:
+                pid = self.get_pid()
+                if not pid:
+                    self.logger.info("No daemon PID found")
+                    # Still try to clean up port
+                    self.cleanup_port_conflicts()
+                    return True
+
+                self.logger.info(f"Stopping daemon with PID {pid}")
+
+                # Send SIGTERM for graceful shutdown
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                except ProcessLookupError:
+                    # Process already dead
+                    self.cleanup_pid_file()
+                    return True
+
+                # Wait for process to exit
+                start_time = time.time()
+                while time.time() - start_time < timeout:
+                    try:
+                        os.kill(pid, 0)  # Check if still alive
+                        time.sleep(0.5)
+                    except ProcessLookupError:
+                        # Process exited
+                        self.cleanup_pid_file()
+                        return True
+
+                # Force kill if still running
+                self.logger.warning("Daemon didn't stop gracefully, force killing")
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                    time.sleep(1)
+                except ProcessLookupError:
+                    pass
+
+                self.cleanup_pid_file()
+                return True
+
+            except Exception as e:
+                self.logger.error(f"Error stopping daemon: {e}")
+                return False
+
+    def is_running(self) -> bool:
+        """Check if daemon is running.
+
+        Returns:
+            True if daemon is running
+        """
+        try:
+            pid = self.get_pid()
+            if not pid:
+                return False
+
+            # Check if process exists
+            os.kill(pid, 0)
+            return True
+
+        except ProcessLookupError:
+            # Process doesn't exist
+            self.cleanup_pid_file()
+            return False
+
+    def get_pid(self) -> Optional[int]:
+        """Get daemon PID from PID file.
+
+        Returns:
+            PID if found, None otherwise
+        """
+        try:
+            if not self.pid_file.exists():
+                return None
+
+            with open(self.pid_file) as f:
+                return int(f.read().strip())
+
+        except Exception as e:
+            self.logger.error(f"Error reading PID file: {e}")
+            return None
+
+    def write_pid_file(self):
+        """Write current PID to PID file."""
+        try:
+            self.pid_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.pid_file, "w") as f:
+                f.write(str(os.getpid()))
+            self.logger.debug(f"PID file written: {self.pid_file}")
+        except Exception as e:
+            self.logger.error(f"Error writing PID file: {e}")
+            raise
+
+    def cleanup_pid_file(self):
+        """Remove PID file."""
+        try:
+            self.pid_file.unlink(missing_ok=True)
+            self.logger.debug("PID file removed")
+        except Exception as e:
+            self.logger.error(f"Error removing PID file: {e}")
+
+    def _cleanup_event_loops(self):
+        """Clean up asyncio event loops before forking."""
+        try:
+            import asyncio
+
+            try:
+                loop = asyncio.get_event_loop()
+                if loop and not loop.is_closed():
+                    # Cancel pending tasks
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+
+                    # Stop and close loop
+                    if loop.is_running():
+                        loop.stop()
+
+                    asyncio.set_event_loop(None)
+                    loop.close()
+
+            except RuntimeError:
+                # No event loop
+                pass
+
+        except Exception as e:
+            self.logger.debug(f"Error cleaning up event loops: {e}")
+
+    def _redirect_streams(self):
+        """Redirect standard streams for daemon mode."""
+        try:
+            sys.stdout.flush()
+            sys.stderr.flush()
+
+            # Redirect stdin to /dev/null
+            with open("/dev/null") as null_in:
+                os.dup2(null_in.fileno(), sys.stdin.fileno())
+
+            # Redirect stdout and stderr to log file
+            self.log_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.log_file, "a") as log_out:
+                os.dup2(log_out.fileno(), sys.stdout.fileno())
+                os.dup2(log_out.fileno(), sys.stderr.fileno())
+
+        except Exception as e:
+            self.logger.error(f"Error redirecting streams: {e}")
+
+    def _setup_signal_handlers(self):
+        """Setup signal handlers for graceful shutdown."""
+
+        def signal_handler(signum, frame):
+            self.logger.info(f"Received signal {signum}, shutting down")
+            self.cleanup_pid_file()
+            sys.exit(0)
+
+        signal.signal(signal.SIGTERM, signal_handler)
+        signal.signal(signal.SIGINT, signal_handler)
+
+    def _parent_wait_for_startup(self, child_pid: int, timeout: float = 10.0) -> bool:
+        """Parent process waits for child to confirm startup.
+
+        Args:
+            child_pid: PID of child process
+            timeout: Maximum time to wait
+
+        Returns:
+            True if child started successfully
+        """
+        try:
+            start_time = time.time()
+
+            while time.time() - start_time < timeout:
+                if (
+                    not self.startup_status_file
+                    or not Path(self.startup_status_file).exists()
+                ):
+                    time.sleep(0.1)
+                    continue
+
+                try:
+                    with open(self.startup_status_file) as f:
+                        status = f.read().strip()
+
+                    if status == "success":
+                        # Cleanup status file
+                        Path(self.startup_status_file).unlink(missing_ok=True)
+                        return True
+
+                    if status.startswith("error:"):
+                        error_msg = status[6:]
+                        self.logger.error(f"Daemon startup failed: {error_msg}")
+                        Path(self.startup_status_file).unlink(missing_ok=True)
+                        return False
+
+                except Exception:
+                    pass
+
+                time.sleep(0.1)
+
+            self.logger.error("Daemon startup timed out")
+            return False
+
+        except Exception as e:
+            self.logger.error(f"Error waiting for daemon startup: {e}")
+            return False
+
+    def _report_startup_success(self):
+        """Report successful startup to parent process."""
+        if self.startup_status_file and Path(self.startup_status_file).exists():
+            try:
+                with open(self.startup_status_file, "w") as f:
+                    f.write("success")
+            except Exception as e:
+                self.logger.error(f"Error reporting startup success: {e}")
+
+    def _report_startup_error(self, error: str):
+        """Report startup error to parent process."""
+        if self.startup_status_file and Path(self.startup_status_file).exists():
+            try:
+                with open(self.startup_status_file, "w") as f:
+                    f.write(f"error:{error}")
+            except Exception as e:
+                self.logger.error(f"Error reporting startup error: {e}")

{claude_mpm-4.2.29.dist-info → claude_mpm-4.2.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.29
+Version: 4.2.32
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-4.2.29.dist-info → claude_mpm-4.2.32.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=hIwkdjdvDMNpzPJDraAmQG0xxBDRq80-ZJvqBX-i4nQ,7
+claude_mpm/VERSION,sha256=D4RiM4BijFcXkczgjBK5VLy8keaTJQARC_2jVMdSt8s,7
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=I946iCQzIIPRZVVJ8aO7lA4euiyDnNw2IX7EelAOkIE,5915
@@ -436,7 +436,7 @@ claude_mpm/services/cli/memory_crud_service.py,sha256=ciN9Pl_12iDAqF9zPBWOzu-iXi
 claude_mpm/services/cli/memory_output_formatter.py,sha256=nbf7VsjGvH4e9fLv9c7PzjuO9COZhbK5P2fNZ79055w,24783
 claude_mpm/services/cli/session_manager.py,sha256=rla_Stbcvt93wa9G9MCMu9UqB3FLGqlPt_eN5lQb3Gg,16599
 claude_mpm/services/cli/startup_checker.py,sha256=efhuvu8ns5G16jcQ0nQZKVddmD2AktUEdlvjNcXjAuk,12232
-claude_mpm/services/cli/unified_dashboard_manager.py,sha256=xYhMagOsrpYMctLTndB2-_CScju-1ovyS3bFxExVR7Y,18489
+claude_mpm/services/cli/unified_dashboard_manager.py,sha256=ZdiN-YlUjtycaE-TLUCRRP-WZZzwXz5XB896LgDx7G8,15712
 claude_mpm/services/communication/__init__.py,sha256=b4qc7_Rqy4DE9q7BAUlfUZjoYG4uimAyUnE0irPcXyU,560
 claude_mpm/services/core/__init__.py,sha256=evEayLlBqJvxMZhrhuK6aagXmNrKGSj8Jm9OOxKzqvU,2195
 claude_mpm/services/core/base.py,sha256=iA-F7DgGp-FJIMvQTiHQ68RkG_k-AtUWlArJPMw6ZPk,7297
@@ -552,7 +552,8 @@ claude_mpm/services/memory/cache/__init__.py,sha256=6M6-P8ParyxX8vOgp_IxHgLMvacr
 claude_mpm/services/memory/cache/shared_prompt_cache.py,sha256=crnYPUT8zcS7TvoE1vW7pyaf4T77N5rJ1wUf_YQ2vvo,28704
 claude_mpm/services/memory/cache/simple_cache.py,sha256=qsTjbcsPxj-kNfaod9VN_uE5NioIwpfkUin_mMVUJCg,10218
 claude_mpm/services/monitor/__init__.py,sha256=X7gxSLUm9Fg_zEsX6LtCHP2ipF0qj6Emkun20h2So7g,745
-claude_mpm/services/monitor/daemon.py,sha256=LGKn9LG2RKL4Of6c3DWZSxRFWqJJRUZFnxT4ochTPjc,28157
+claude_mpm/services/monitor/daemon.py,sha256=nkB_xslT4yxIiSVf2u6nGm56rYpkit0WDj4YPWr-osM,22961
+claude_mpm/services/monitor/daemon_manager.py,sha256=6ZYXgRhwurnPDXxFgk9msLoa7x7ccE64m93FwqWVJfs,24519
 claude_mpm/services/monitor/event_emitter.py,sha256=JzRLNg8PUJ5s3ulNnq_D4yqCPItvidJzu8DmFxriieQ,12224
 claude_mpm/services/monitor/server.py,sha256=m98Eyv9caxRywJ4JtAdOuv5EB__z7vd2hYRZPwcqFLg,28498
 claude_mpm/services/monitor/handlers/__init__.py,sha256=jgPIf4IJVERm_tAeD9834tfx9IcxtlHj5r9rhEWpkfM,701
@@ -643,9 +644,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=zgiwLqh_17WxHpySvUPH65pb4bzIeUGOAYUJ
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=3Lo6LK-Mw9IdnL_bd3zl_R6FkgSVDYKUUM7EeVVD3jc,20865
 claude_mpm/validation/frontmatter_validator.py,sha256=u8g4Eyd_9O6ugj7Un47oSGh3kqv4wMkuks2i_CtWRvM,7028
-claude_mpm-4.2.29.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.2.29.dist-info/METADATA,sha256=19CRh27IbVYKtvIk4_1KMM0BQXr6EMDGydXPp7H8rzs,14451
-claude_mpm-4.2.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.2.29.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.2.29.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.2.29.dist-info/RECORD,,
+claude_mpm-4.2.32.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.2.32.dist-info/METADATA,sha256=5rI-z0awk9FawxvQGIv5ehodB23tje9Z3550ObeFurk,14451
+claude_mpm-4.2.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.2.32.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.2.32.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.2.32.dist-info/RECORD,,