claude-mpm 4.2.21__tar.gz → 4.2.23__tar.gz

claude_mpm-4.2.23/BUILD_NUMBER

@@ -0,0 +1 @@
+349

{claude_mpm-4.2.21 → claude_mpm-4.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.2.21
+Version: 4.2.23
 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
@@ -149,11 +149,18 @@ pip install claude-mpm
 
 Or with pipx (recommended for isolated installation):
 ```bash
+# Install with monitor support (recommended)
+pipx install "claude-mpm[monitor]"
+
+# Basic installation without monitor
 pipx install claude-mpm
+
 # Configure MCP for pipx users:
 claude-mpm mcp-pipx-config
 ```
 
+**💡 Pipx Tip**: Use `"claude-mpm[monitor]"` to get full monitoring dashboard functionality! The `[monitor]` optional dependency includes Socket.IO and async web server components needed for real-time agent monitoring.
+
 **🎉 Pipx Support Now Fully Functional!** Recent improvements ensure complete compatibility:
 - ✅ Socket.IO daemon script path resolution (fixed)
 - ✅ Commands directory access (fixed) 

{claude_mpm-4.2.21 → claude_mpm-4.2.23}/README.md

@@ -25,11 +25,18 @@ pip install claude-mpm
 
 Or with pipx (recommended for isolated installation):
 ```bash
+# Install with monitor support (recommended)
+pipx install "claude-mpm[monitor]"
+
+# Basic installation without monitor
 pipx install claude-mpm
+
 # Configure MCP for pipx users:
 claude-mpm mcp-pipx-config
 ```
 
+**💡 Pipx Tip**: Use `"claude-mpm[monitor]"` to get full monitoring dashboard functionality! The `[monitor]` optional dependency includes Socket.IO and async web server components needed for real-time agent monitoring.
+
 **🎉 Pipx Support Now Fully Functional!** Recent improvements ensure complete compatibility:
 - ✅ Socket.IO daemon script path resolution (fixed)
 - ✅ Commands directory access (fixed) 

claude_mpm-4.2.23/VERSION

@@ -0,0 +1 @@
+4.2.23

{claude_mpm-4.2.21 → claude_mpm-4.2.23}/pyproject.toml

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

claude_mpm-4.2.23/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.2.23

{claude_mpm-4.2.21 → claude_mpm-4.2.23}/src/claude_mpm/cli/commands/monitor.py

@@ -91,8 +91,11 @@ class MonitorCommand(BaseCommand):
             host=host, port=port, daemon_mode=daemon_mode
         )
 
+        # Get force restart flag
+        force_restart = getattr(args, "force", False)
+        
         # Check if already running
-        if self.daemon.lifecycle.is_running():
+        if self.daemon.lifecycle.is_running() and not force_restart:
             existing_pid = self.daemon.lifecycle.get_pid()
             return CommandResult.success_result(
                 f"Unified monitor daemon already running with PID {existing_pid}",
@@ -103,14 +106,46 @@ class MonitorCommand(BaseCommand):
                 },
             )
 
-        # Start the daemon
-        if self.daemon.start():
-            mode_info = " in background" if daemon_mode else " in foreground"
+        # Start the daemon (with force restart if specified)
+        if self.daemon.start(force_restart=force_restart):
+            # For daemon mode, verify it actually started
+            if daemon_mode:
+                # Give it a moment to fully initialize
+                import time
+                time.sleep(0.5)
+                
+                # Check if it's actually running
+                if not self.daemon.lifecycle.is_running():
+                    return CommandResult.error_result(
+                        "Monitor daemon failed to start. Check ~/.claude-mpm/monitor-daemon.log for details."
+                    )
+                
+                # Get the actual PID
+                actual_pid = self.daemon.lifecycle.get_pid()
+                mode_info = f" in background (PID: {actual_pid})"
+            else:
+                mode_info = " in foreground"
+            
             return CommandResult.success_result(
                 f"Unified monitor daemon started on {host}:{port}{mode_info}",
                 data={"url": f"http://{host}:{port}", "port": port, "mode": mode_str},
             )
-        return CommandResult.error_result("Failed to start unified monitor daemon")
+        
+        # Check if error was due to port already in use
+        import socket
+        try:
+            test_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            test_sock.connect((host, port))
+            test_sock.close()
+            return CommandResult.error_result(
+                f"Port {port} is already in use. Try 'claude-mpm monitor stop' first or use a different port."
+            )
+        except:
+            pass
+        
+        return CommandResult.error_result(
+            "Failed to start unified monitor daemon. Check ~/.claude-mpm/monitor-daemon.log for details."
+        )
 
     def _stop_monitor(self, args) -> CommandResult:
         """Stop the unified monitor daemon."""

{claude_mpm-4.2.21 → claude_mpm-4.2.23}/src/claude_mpm/services/cli/unified_dashboard_manager.py

@@ -75,7 +75,8 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         self._lock = threading.Lock()
 
     def start_dashboard(
-        self, port: int = 8765, background: bool = False, open_browser: bool = True
+        self, port: int = 8765, background: bool = False, open_browser: bool = True,
+        force_restart: bool = False
     ) -> Tuple[bool, bool]:
         """
         Start the dashboard using unified daemon.
@@ -84,30 +85,41 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
             port: Port to run dashboard on
             background: Whether to run in background mode
             open_browser: Whether to open browser automatically
+            force_restart: If True, restart existing service if it's ours
 
         Returns:
             Tuple of (success, browser_opened)
         """
         try:
-            # Check if already running
-            if self.is_dashboard_running(port):
-                self.logger.info(f"Dashboard already running on port {port}")
+            # Create daemon instance to check service status
+            daemon = UnifiedMonitorDaemon(
+                host="localhost", port=port, daemon_mode=background
+            )
+            
+            # Check if it's our service running
+            is_ours, pid = daemon.lifecycle.is_our_service("localhost")
+            
+            if is_ours and not force_restart:
+                # Our service is already running, just open browser if needed
+                self.logger.info(f"Our dashboard already running on port {port} (PID: {pid})")
                 browser_opened = False
                 if open_browser:
                     browser_opened = self.open_browser(self.get_dashboard_url(port))
                 return True, browser_opened
+            elif is_ours and force_restart:
+                self.logger.info(f"Force restarting our dashboard on port {port} (PID: {pid})")
+            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
 
             self.logger.info(
-                f"Starting unified dashboard on port {port} (background: {background})"
+                f"Starting unified dashboard on port {port} (background: {background}, force_restart: {force_restart})"
             )
 
             if background:
-                # Start daemon in background mode
-                daemon = UnifiedMonitorDaemon(
-                    host="localhost", port=port, daemon_mode=True
-                )
-
-                success = daemon.start()
+                # Start daemon in background mode with force restart if needed
+                success = daemon.start(force_restart=force_restart)
                 if success:
                     with self._lock:
                         self._background_daemons[port] = daemon
@@ -293,7 +305,7 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         return self.port_manager.find_available_port(preferred_port)
 
     def start_server(
-        self, port: Optional[int] = None, timeout: int = 30
+        self, port: Optional[int] = None, timeout: int = 30, force_restart: bool = True
     ) -> Tuple[bool, DashboardInfo]:
         """
         Start the server (compatibility method for SocketIOManager interface).
@@ -301,6 +313,7 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         Args:
             port: Port to use (finds available if None)
             timeout: Timeout for startup
+            force_restart: If True, restart existing service if it's ours
 
         Returns:
             Tuple of (success, DashboardInfo)
@@ -308,8 +321,9 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         if port is None:
             port = self.find_available_port()
 
+        # Use force_restart to ensure we're using the latest code
         success, browser_opened = self.start_dashboard(
-            port=port, background=True, open_browser=False
+            port=port, background=True, open_browser=False, force_restart=force_restart
         )
 
         if success:

{claude_mpm-4.2.21 → claude_mpm-4.2.23}/src/claude_mpm/services/monitor/daemon.py

@@ -57,9 +57,11 @@ class UnifiedMonitorDaemon:
         self.daemon_mode = daemon_mode
         self.logger = get_logger(__name__)
 
-        # Daemon management
+        # Daemon management with port for verification
         self.lifecycle = DaemonLifecycle(
-            pid_file=pid_file or self._get_default_pid_file(), log_file=log_file
+            pid_file=pid_file or self._get_default_pid_file(), 
+            log_file=log_file,
+            port=port
         )
 
         # Core server
@@ -79,28 +81,82 @@ class UnifiedMonitorDaemon:
         claude_mpm_dir.mkdir(exist_ok=True)
         return str(claude_mpm_dir / "monitor-daemon.pid")
 
-    def start(self) -> bool:
+    def start(self, force_restart: bool = False) -> bool:
         """Start the unified monitor daemon.
 
+        Args:
+            force_restart: If True, restart existing service if it's ours
+
         Returns:
             True if started successfully, False otherwise
         """
         try:
             if self.daemon_mode:
-                return self._start_daemon()
-            return self._start_foreground()
+                return self._start_daemon(force_restart=force_restart)
+            return self._start_foreground(force_restart=force_restart)
         except Exception as e:
             self.logger.error(f"Failed to start unified monitor daemon: {e}")
             return False
 
-    def _start_daemon(self) -> bool:
-        """Start as background daemon process."""
+    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
+        """
         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()
-            self.logger.warning(f"Daemon already running with PID {existing_pid}")
+            
+            if force_restart:
+                # Check if it's our service
+                is_ours, pid = self.lifecycle.is_our_service(self.host)
+                if is_ours:
+                    self.logger.info(f"Force restarting our existing daemon (PID: {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"Daemon already running with PID {existing_pid}, but it's not our service")
+                    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:
+            is_ours, pid = self.lifecycle.is_our_service(self.host)
+            if is_ours and pid:
+                self.logger.info(f"Found orphaned claude-mpm 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
+        
+        # Verify port is available before forking
+        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
 
         # Wait for any pre-warming threads to complete before forking
@@ -112,19 +168,73 @@ class UnifiedMonitorDaemon:
             return False
 
         # Start the server in daemon mode
-        return self._run_server()
+        # 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")
+            return result
+        except Exception as e:
+            # Report any exceptions during startup
+            self.lifecycle._report_startup_error(f"Server startup exception: {e}")
+            raise
 
-    def _start_foreground(self) -> bool:
-        """Start in foreground mode."""
+    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
+        """
         self.logger.info(f"Starting unified monitor daemon on {self.host}:{self.port}")
 
         # Check if already running (check PID file even in foreground mode)
         if self.lifecycle.is_running():
             existing_pid = self.lifecycle.get_pid()
-            self.logger.warning(
-                f"Monitor daemon already running with PID {existing_pid}"
-            )
-            return False
+            
+            if force_restart:
+                # Check if it's our service
+                is_ours, pid = self.lifecycle.is_our_service(self.host)
+                if is_ours:
+                    self.logger.info(f"Force restarting our existing daemon (PID: {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"Monitor daemon already running with PID {existing_pid}, but it's not our service")
+                    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:
+            is_ours, pid = self.lifecycle.is_our_service(self.host)
+            if is_ours and pid:
+                self.logger.info(f"Found orphaned claude-mpm 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
 
         # Setup signal handlers for graceful shutdown
         self._setup_signal_handlers()
@@ -140,11 +250,17 @@ class UnifiedMonitorDaemon:
         try:
             # Ensure components exist before starting
             if not self.health_monitor:
-                self.logger.error("Health monitor not initialized")
+                error_msg = "Health monitor not initialized"
+                self.logger.error(error_msg)
+                if self.daemon_mode:
+                    self.lifecycle._report_startup_error(error_msg)
                 return False
 
             if not self.server:
-                self.logger.error("Server not initialized")
+                error_msg = "Server not initialized"
+                self.logger.error(error_msg)
+                if self.daemon_mode:
+                    self.lifecycle._report_startup_error(error_msg)
                 return False
 
             # Start health monitoring
@@ -153,11 +269,18 @@ class UnifiedMonitorDaemon:
             # Start the unified server
             success = self.server.start()
             if not success:
-                self.logger.error("Failed to start unified monitor server")
+                error_msg = "Failed to start unified monitor server"
+                self.logger.error(error_msg)
+                if self.daemon_mode:
+                    self.lifecycle._report_startup_error(error_msg)
                 return False
 
             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()
 
             # Keep running until shutdown
             if self.daemon_mode: