claude-mpm 4.2.26__tar.gz → 4.2.27__tar.gz

claude_mpm-4.2.27/BUILD_NUMBER

@@ -0,0 +1 @@
+351

{claude_mpm-4.2.26 → claude_mpm-4.2.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.26
+Version: 4.2.27
 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.27/VERSION

@@ -0,0 +1 @@
+4.2.27

{claude_mpm-4.2.26 → claude_mpm-4.2.27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.2.26"
+version = "4.2.27"
 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.26"
+version = "4.2.27"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-4.2.27/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.2.27

{claude_mpm-4.2.26 → claude_mpm-4.2.27}/src/claude_mpm/services/cli/unified_dashboard_manager.py

@@ -115,18 +115,46 @@ 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)
             elif self.is_dashboard_running(port) and not force_restart:
-                # Different service is using the port
-                self.logger.warning(f"Port {port} is in use by a different service")
-                return False, False
+                # 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)
+                # Brief pause to ensure cleanup is complete
+                import time
+                time.sleep(1)
 
             self.logger.info(
                 f"Starting unified dashboard on port {port} (background: {background}, force_restart: {force_restart})"
             )
 
             if background:
-                # Start daemon in background mode with force restart if needed
-                success = daemon.start(force_restart=force_restart)
+                # 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}")
+                        self._cleanup_port_conflicts(port)
+                        time.sleep(2)  # Wait for cleanup to complete
+                    
+                    # Start daemon in background mode with force restart if needed
+                    success = daemon.start(force_restart=force_restart or retry_count > 0)
+                    
+                    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")
+                            retry_count += 1
+                        else:
+                            # Different kind of failure, don't retry
+                            break
+                    else:
+                        break
+                
                 if success:
                     with self._lock:
                         self._background_daemons[port] = daemon
@@ -311,6 +339,84 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         """
         return self.port_manager.find_available_port(preferred_port)
 
+    def _cleanup_port_conflicts(self, port: int) -> bool:
+        """
+        Try to clean up any processes using our port.
+        
+        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
+                    
+                    # Brief pause after force kill to ensure port is released
+                    time.sleep(2)
+                
+                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
+
     def start_server(
         self, port: Optional[int] = None, timeout: int = 30, force_restart: bool = True
     ) -> Tuple[bool, DashboardInfo]:

{claude_mpm-4.2.26 → claude_mpm-4.2.27}/src/claude_mpm/services/monitor/daemon.py

@@ -263,8 +263,8 @@ class UnifiedMonitorDaemon:
             cleaned = self._cleanup_port_conflicts()
             
             if cleaned:
-                # Wait a moment for port to be released
-                time.sleep(2)
+                # 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)
                 
@@ -302,6 +302,13 @@ 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
+        # 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()
+            time.sleep(1)  # Brief pause to ensure port is released
 
         # Check if already running (check PID file even in foreground mode)
         if self.lifecycle.is_running():

{claude_mpm-4.2.26 → claude_mpm-4.2.27}/src/claude_mpm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.26
+Version: 4.2.27
 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.26/BUILD_NUMBER

@@ -1 +0,0 @@
-350

claude_mpm-4.2.26/VERSION

@@ -1 +0,0 @@
-4.2.26

claude_mpm-4.2.26/src/claude_mpm/VERSION

@@ -1 +0,0 @@
-4.2.26