claude-mpm 4.2.29__tar.gz → 4.2.32__tar.gz

claude_mpm-4.2.32/BUILD_NUMBER

@@ -0,0 +1 @@
+354

{claude_mpm-4.2.29 → claude_mpm-4.2.32}/PKG-INFO

@@ -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.32/VERSION

@@ -0,0 +1 @@
+4.2.32

{claude_mpm-4.2.29 → claude_mpm-4.2.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.2.29"
+version = "4.2.32"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -78,7 +78,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.2.29"
+version = "4.2.32"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-4.2.32/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.2.32

{claude_mpm-4.2.29 → claude_mpm-4.2.32}/src/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-4.2.29 → claude_mpm-4.2.32}/src/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"