claude-mpm 3.4.6__tar.gz → 3.4.9__tar.gz

{claude_mpm-3.4.6 → claude_mpm-3.4.9}/MANIFEST.in

@@ -28,6 +28,9 @@ recursive-include src/claude_mpm/config *.py
 # Include hook files (including shell scripts)
 recursive-include src/claude_mpm/hooks *.py *.sh
 
+# Include package scripts
+recursive-include src/claude_mpm/scripts *.py
+
 # Exclude test and cache files
 global-exclude __pycache__
 global-exclude *.py[co]

{claude_mpm-3.4.6/src/claude_mpm.egg-info → claude_mpm-3.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.4.6
+Version: 3.4.9
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

claude_mpm-3.4.9/VERSION

@@ -0,0 +1 @@
+3.4.9

{claude_mpm-3.4.6 → claude_mpm-3.4.9}/src/claude_mpm/cli/commands/run.py

@@ -467,6 +467,7 @@ def _check_socketio_server_running(port, logger):
     
     DESIGN DECISION: We try multiple endpoints and connection methods to ensure
     robust detection. Some servers may be starting up and only partially ready.
+    Added retry logic to handle race conditions during server initialization.
     
     Args:
         port: Port number to check
@@ -483,34 +484,50 @@ def _check_socketio_server_running(port, logger):
         # First, do a basic TCP connection check
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.settimeout(1.0)
+                s.settimeout(2.0)  # Increased from 1.0s for slower connections
                 result = s.connect_ex(('127.0.0.1', port))
                 if result != 0:
-                    logger.debug(f"TCP connection to port {port} failed (not listening)")
+                    logger.debug(f"TCP connection to port {port} failed (server not started yet)")
                     return False
         except Exception as e:
             logger.debug(f"TCP socket check failed for port {port}: {e}")
             return False
         
-        # If TCP connection succeeds, try HTTP health check
-        try:
-            response = urllib.request.urlopen(f'http://localhost:{port}/status', timeout=5)
-            
-            if response.getcode() == 200:
-                content = response.read().decode()
-                logger.debug(f"✅ Socket.IO server health check passed on port {port}")
-                logger.debug(f"📄 Server response: {content[:100]}...")
-                return True
-            else:
-                logger.debug(f"⚠️ HTTP response code {response.getcode()} from port {port}")
-                return False
+        # If TCP connection succeeds, try HTTP health check with retries
+        # WHY: Even when TCP is accepting connections, the HTTP handler may not be ready
+        max_retries = 3
+        for retry in range(max_retries):
+            try:
+                response = urllib.request.urlopen(f'http://localhost:{port}/status', timeout=10)  # Increased from 5s to 10s
                 
-        except urllib.error.HTTPError as e:
-            logger.debug(f"⚠️ HTTP error {e.code} from server on port {port}")
-            return False
-        except urllib.error.URLError as e:
-            logger.debug(f"⚠️ URL error connecting to port {port}: {e.reason}")
-            return False
+                if response.getcode() == 200:
+                    content = response.read().decode()
+                    logger.debug(f"✅ Socket.IO server health check passed on port {port} (attempt {retry + 1})")
+                    logger.debug(f"📄 Server response: {content[:100]}...")
+                    return True
+                else:
+                    logger.debug(f"⚠️ HTTP response code {response.getcode()} from port {port} (attempt {retry + 1})")
+                    if retry < max_retries - 1:
+                        time.sleep(0.5)  # Brief pause before retry
+                    
+            except urllib.error.HTTPError as e:
+                logger.debug(f"⚠️ HTTP error {e.code} from server on port {port} (attempt {retry + 1})")
+                if retry < max_retries - 1 and e.code in [404, 503]:  # Server starting but not ready
+                    logger.debug("Server appears to be starting, retrying...")
+                    time.sleep(0.5)
+                    continue
+                return False
+            except urllib.error.URLError as e:
+                logger.debug(f"⚠️ URL error connecting to port {port} (attempt {retry + 1}): {e.reason}")
+                if retry < max_retries - 1:
+                    logger.debug("Connection refused - server may still be initializing, retrying...")
+                    time.sleep(0.5)
+                    continue
+                return False
+        
+        # All retries exhausted
+        logger.debug(f"Health check failed after {max_retries} attempts - server not fully ready")
+        return False
             
     except (ConnectionError, OSError) as e:
         logger.debug(f"🔌 Connection error checking port {port}: {e}")
@@ -569,13 +586,17 @@ def _start_standalone_socketio_server(port, logger):
         # 2. Event loop setup (~1s) 
         # 3. aiohttp server binding (~2-5s)
         # 4. Socket.IO service initialization (~1-3s)
-        # Total: up to 10 seconds for full readiness
-        max_attempts = 20  # Increased from 10
-        initial_delay = 0.5  # seconds
-        max_delay = 2.0  # seconds
+        # Total: up to 15+ seconds for full readiness (especially on Python 3.13)
+        max_attempts = 30  # Increased from 20 to handle Python 3.13 slower initialization
+        initial_delay = 1.0  # Increased from 0.5s to give daemon more time to fork
+        max_delay = 3.0  # Increased from 2.0s for slower systems
         
         logger.info(f"Waiting up to {max_attempts * max_delay} seconds for server to be fully ready...")
         
+        # Give the daemon initial time to fork and start before checking
+        logger.debug("Allowing initial daemon startup time...")
+        time.sleep(0.5)
+        
         for attempt in range(max_attempts):
             # Progressive delay - start fast, then slow down for socket binding
             if attempt < 5:
@@ -596,9 +617,14 @@ def _start_standalone_socketio_server(port, logger):
             else:
                 logger.debug(f"Server not yet accepting connections on attempt {attempt + 1}")
         
-        logger.error(f"❌ Socket.IO server failed to start properly on port {port} after {max_attempts} attempts")
-        logger.error(f"💡 This may indicate a port conflict or dependency issue")
-        logger.error(f"🔧 Try a different port with --websocket-port or check for conflicts")
+        logger.error(f"❌ Socket.IO server health check failed after {max_attempts} attempts ({max_attempts * max_delay:.1f}s)")
+        logger.warning(f"⏱️  Server may still be starting - initialization can take 15+ seconds on some systems")
+        logger.warning(f"💡 The daemon process might be running but not yet accepting HTTP connections")
+        logger.error(f"🔧 Troubleshooting steps:")
+        logger.error(f"   - Wait a few more seconds and try again")
+        logger.error(f"   - Check for port conflicts: lsof -i :{port}")
+        logger.error(f"   - Try a different port with --websocket-port")
+        logger.error(f"   - Verify dependencies: pip install python-socketio aiohttp")
         return False
             
     except Exception as e:

{claude_mpm-3.4.6 → claude_mpm-3.4.9}/src/claude_mpm/core/claude_runner.py

@@ -184,12 +184,8 @@ class ClaudeRunner:
                 self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
-        # Get version
-        try:
-            from claude_mpm import __version__
-            version_str = f"v{__version__}"
-        except:
-            version_str = "v0.0.0"
+        # Get version with robust fallback mechanisms
+        version_str = self._get_version()
         
         # Print styled welcome box
         print("\033[32m╭───────────────────────────────────────────────────╮\033[0m")
@@ -750,6 +746,74 @@ class ClaudeRunner:
             except Exception as e:
                 self.logger.debug(f"Failed to log session event: {e}")
     
+    def _get_version(self) -> str:
+        """
+        Robust version determination with multiple fallback mechanisms.
+        
+        WHY: The version display is critical for debugging and user experience.
+        This implementation ensures we always show the correct version rather than 
+        defaulting to v0.0.0, even in edge cases where imports might fail.
+        
+        DESIGN DECISION: We try multiple methods in order of preference:
+        1. Package import (__version__) - fastest for normal installations
+        2. importlib.metadata - standard for installed packages  
+        3. VERSION file reading - fallback for development environments
+        4. Only then default to v0.0.0 with detailed error logging
+        
+        Returns version string formatted as "vX.Y.Z"
+        """
+        version = "0.0.0"
+        method_used = "default"
+        
+        # Method 1: Try package import (fastest, most common)
+        try:
+            from claude_mpm import __version__
+            version = __version__
+            method_used = "package_import"
+            self.logger.debug(f"Version obtained via package import: {version}")
+        except ImportError as e:
+            self.logger.debug(f"Package import failed: {e}")
+        except Exception as e:
+            self.logger.warning(f"Unexpected error in package import: {e}")
+        
+        # Method 2: Try importlib.metadata (standard for installed packages)
+        if version == "0.0.0":
+            try:
+                import importlib.metadata
+                version = importlib.metadata.version('claude-mpm')
+                method_used = "importlib_metadata"
+                self.logger.debug(f"Version obtained via importlib.metadata: {version}")
+            except importlib.metadata.PackageNotFoundError:
+                self.logger.debug("Package not found in importlib.metadata (likely development install)")
+            except ImportError:
+                self.logger.debug("importlib.metadata not available (Python < 3.8)")
+            except Exception as e:
+                self.logger.warning(f"Unexpected error in importlib.metadata: {e}")
+        
+        # Method 3: Try reading VERSION file directly (development fallback)
+        if version == "0.0.0":
+            try:
+                # Calculate path relative to this file
+                version_file = Path(__file__).parent.parent.parent.parent / "VERSION"
+                if version_file.exists():
+                    version = version_file.read_text().strip()
+                    method_used = "version_file"
+                    self.logger.debug(f"Version obtained via VERSION file: {version}")
+                else:
+                    self.logger.debug(f"VERSION file not found at: {version_file}")
+            except Exception as e:
+                self.logger.warning(f"Failed to read VERSION file: {e}")
+        
+        # Log final result
+        if version == "0.0.0":
+            self.logger.error(
+                "All version detection methods failed. This indicates a packaging or installation issue."
+            )
+        else:
+            self.logger.debug(f"Final version: {version} (method: {method_used})")
+        
+        return f"v{version}"
+    
     def _register_memory_hooks(self):
         """Register memory integration hooks with the hook service.
         

{claude_mpm-3.4.6 → claude_mpm-3.4.9}/src/claude_mpm/core/simple_runner.py

@@ -184,12 +184,8 @@ class ClaudeRunner:
                 self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
-        # Get version
-        try:
-            from claude_mpm import __version__
-            version_str = f"v{__version__}"
-        except:
-            version_str = "v0.0.0"
+        # Get version with robust fallback mechanisms
+        version_str = self._get_version()
         
         # Print styled welcome box
         print("\033[32m╭───────────────────────────────────────────────────╮\033[0m")
@@ -750,6 +746,74 @@ class ClaudeRunner:
             except Exception as e:
                 self.logger.debug(f"Failed to log session event: {e}")
     
+    def _get_version(self) -> str:
+        """
+        Robust version determination with multiple fallback mechanisms.
+        
+        WHY: The version display is critical for debugging and user experience.
+        This implementation ensures we always show the correct version rather than 
+        defaulting to v0.0.0, even in edge cases where imports might fail.
+        
+        DESIGN DECISION: We try multiple methods in order of preference:
+        1. Package import (__version__) - fastest for normal installations
+        2. importlib.metadata - standard for installed packages  
+        3. VERSION file reading - fallback for development environments
+        4. Only then default to v0.0.0 with detailed error logging
+        
+        Returns version string formatted as "vX.Y.Z"
+        """
+        version = "0.0.0"
+        method_used = "default"
+        
+        # Method 1: Try package import (fastest, most common)
+        try:
+            from claude_mpm import __version__
+            version = __version__
+            method_used = "package_import"
+            self.logger.debug(f"Version obtained via package import: {version}")
+        except ImportError as e:
+            self.logger.debug(f"Package import failed: {e}")
+        except Exception as e:
+            self.logger.warning(f"Unexpected error in package import: {e}")
+        
+        # Method 2: Try importlib.metadata (standard for installed packages)
+        if version == "0.0.0":
+            try:
+                import importlib.metadata
+                version = importlib.metadata.version('claude-mpm')
+                method_used = "importlib_metadata"
+                self.logger.debug(f"Version obtained via importlib.metadata: {version}")
+            except importlib.metadata.PackageNotFoundError:
+                self.logger.debug("Package not found in importlib.metadata (likely development install)")
+            except ImportError:
+                self.logger.debug("importlib.metadata not available (Python < 3.8)")
+            except Exception as e:
+                self.logger.warning(f"Unexpected error in importlib.metadata: {e}")
+        
+        # Method 3: Try reading VERSION file directly (development fallback)
+        if version == "0.0.0":
+            try:
+                # Calculate path relative to this file
+                version_file = Path(__file__).parent.parent.parent.parent / "VERSION"
+                if version_file.exists():
+                    version = version_file.read_text().strip()
+                    method_used = "version_file"
+                    self.logger.debug(f"Version obtained via VERSION file: {version}")
+                else:
+                    self.logger.debug(f"VERSION file not found at: {version_file}")
+            except Exception as e:
+                self.logger.warning(f"Failed to read VERSION file: {e}")
+        
+        # Log final result
+        if version == "0.0.0":
+            self.logger.error(
+                "All version detection methods failed. This indicates a packaging or installation issue."
+            )
+        else:
+            self.logger.debug(f"Final version: {version} (method: {method_used})")
+        
+        return f"v{version}"
+    
     def _register_memory_hooks(self):
         """Register memory integration hooks with the hook service.
         

claude_mpm-3.4.9/src/claude_mpm/scripts/socketio_daemon.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Pure Python daemon management for Socket.IO server.
+No external dependencies required.
+"""
+
+import os
+import sys
+import time
+import signal
+import subprocess
+import psutil
+import json
+from pathlib import Path
+
+# Handle imports for both development and installed scenarios
+script_dir = Path(__file__).parent
+try:
+    # When installed as package, this should work directly
+    from claude_mpm.services.socketio_server import SocketIOServer
+except ImportError:
+    # When in development, add src to path
+    project_root = script_dir.parent.parent.parent  # from scripts -> claude_mpm -> src -> project_root
+    src_path = project_root / "src"
+    if src_path.exists():
+        sys.path.insert(0, str(src_path))
+    from claude_mpm.services.socketio_server import SocketIOServer
+
+PID_FILE = Path.home() / ".claude-mpm" / "socketio-server.pid"
+LOG_FILE = Path.home() / ".claude-mpm" / "socketio-server.log"
+
+def ensure_dirs():
+    """Ensure required directories exist."""
+    PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+def is_running():
+    """Check if server is already running."""
+    if not PID_FILE.exists():
+        return False
+    
+    try:
+        with open(PID_FILE) as f:
+            pid = int(f.read().strip())
+        
+        # Check if process exists
+        process = psutil.Process(pid)
+        return process.is_running()
+    except (ValueError, psutil.NoSuchProcess, psutil.AccessDenied):
+        # Clean up stale PID file
+        PID_FILE.unlink(missing_ok=True)
+        return False
+
+def start_server():
+    """Start the Socket.IO server as a daemon with conflict detection."""
+    if is_running():
+        print("Socket.IO daemon server is already running.")
+        print(f"Use '{__file__} status' for details")
+        return
+    
+    # Check for HTTP-managed server conflict
+    try:
+        import requests
+        response = requests.get("http://localhost:8765/health", timeout=1.0)
+        if response.status_code == 200:
+            data = response.json()
+            if 'server_id' in data:
+                print(f"⚠️  HTTP-managed server already running: {data.get('server_id')}")
+                print(f"   Stop it first: socketio_server_manager.py stop --port 8765")
+                print(f"   Or diagnose: socketio_server_manager.py diagnose")
+                return
+    except:
+        pass  # No HTTP server, continue
+    
+    ensure_dirs()
+    
+    # Fork to create daemon
+    pid = os.fork()
+    if pid > 0:
+        # Parent process
+        print(f"Starting Socket.IO server (PID: {pid})...")
+        with open(PID_FILE, 'w') as f:
+            f.write(str(pid))
+        print("Socket.IO server started successfully.")
+        print(f"PID file: {PID_FILE}")
+        print(f"Log file: {LOG_FILE}")
+        sys.exit(0)
+    
+    # Child process - become daemon
+    os.setsid()
+    os.umask(0)
+    
+    # Redirect stdout/stderr to log file
+    with open(LOG_FILE, 'a') as log:
+        os.dup2(log.fileno(), sys.stdout.fileno())
+        os.dup2(log.fileno(), sys.stderr.fileno())
+    
+    # Start server
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Starting Socket.IO server...")
+    server = SocketIOServer(host="localhost", port=8765)
+    
+    # Handle signals
+    def signal_handler(signum, frame):
+        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Received signal {signum}, shutting down...")
+        server.stop()
+        PID_FILE.unlink(missing_ok=True)
+        sys.exit(0)
+    
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+    
+    # Start server
+    server.start()
+    
+    # Keep running
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        signal_handler(signal.SIGINT, None)
+
+def stop_server():
+    """Stop the Socket.IO daemon server."""
+    if not is_running():
+        print("Socket.IO daemon server is not running.")
+        print(f"Check for other servers: socketio_server_manager.py status")
+        return
+    
+    try:
+        with open(PID_FILE) as f:
+            pid = int(f.read().strip())
+        
+        print(f"Stopping Socket.IO server (PID: {pid})...")
+        os.kill(pid, signal.SIGTERM)
+        
+        # Wait for process to stop
+        for _ in range(10):
+            if not is_running():
+                print("Socket.IO server stopped successfully.")
+                PID_FILE.unlink(missing_ok=True)
+                return
+            time.sleep(0.5)
+        
+        # Force kill if still running
+        print("Server didn't stop gracefully, forcing...")
+        os.kill(pid, signal.SIGKILL)
+        PID_FILE.unlink(missing_ok=True)
+        
+    except Exception as e:
+        print(f"Error stopping server: {e}")
+
+def status_server():
+    """Check server status with manager integration info."""
+    if is_running():
+        with open(PID_FILE) as f:
+            pid = int(f.read().strip())
+        print(f"Socket.IO daemon server is running (PID: {pid})")
+        print(f"PID file: {PID_FILE}")
+        
+        # Check if port is listening
+        try:
+            import socket
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            result = sock.connect_ex(('localhost', 8765))
+            sock.close()
+            if result == 0:
+                print("✅ Server is listening on port 8765")
+                print("🔧 Management style: daemon")
+            else:
+                print("⚠️ WARNING: Server process exists but port 8765 is not accessible")
+        except:
+            pass
+            
+        # Show management commands
+        print("\n🔧 Management Commands:")
+        print(f"   • Stop: {__file__} stop")
+        print(f"   • Restart: {__file__} restart")
+        
+        # Check for manager conflicts
+        try:
+            import requests
+            response = requests.get("http://localhost:8765/health", timeout=1.0)
+            if response.status_code == 200:
+                data = response.json()
+                if 'server_id' in data and data.get('server_id') != 'daemon-socketio':
+                    print(f"\n⚠️  POTENTIAL CONFLICT: HTTP-managed server also detected")
+                    print(f"   Server ID: {data.get('server_id')}")
+                    print(f"   Use 'socketio_server_manager.py diagnose' to resolve")
+        except:
+            pass
+            
+    else:
+        print("Socket.IO daemon server is not running")
+        print(f"\n🔧 Start Commands:")
+        print(f"   • Daemon: {__file__} start")
+        print(f"   • HTTP-managed: socketio_server_manager.py start")
+
+def main():
+    """Main entry point."""
+    if len(sys.argv) < 2:
+        print("Usage: socketio-daemon.py {start|stop|restart|status}")
+        sys.exit(1)
+    
+    command = sys.argv[1]
+    
+    if command == "start":
+        start_server()
+    elif command == "stop":
+        stop_server()
+    elif command == "restart":
+        stop_server()
+        time.sleep(1)
+        start_server()
+    elif command == "status":
+        status_server()
+    else:
+        print(f"Unknown command: {command}")
+        print("Usage: socketio-daemon.py {start|stop|restart|status}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    # Install psutil if not available
+    try:
+        import psutil
+    except ImportError:
+        print("Installing psutil...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "psutil"])
+        import psutil
+    
+    main()

{claude_mpm-3.4.6 → claude_mpm-3.4.9/src/claude_mpm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.4.6
+Version: 3.4.9
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

{claude_mpm-3.4.6 → claude_mpm-3.4.9}/src/claude_mpm.egg-info/SOURCES.txt

@@ -130,6 +130,7 @@ src/claude_mpm/orchestration/archive/subprocess_orchestrator.py
 src/claude_mpm/orchestration/archive/system_prompt_orchestrator.py
 src/claude_mpm/orchestration/archive/wrapper_orchestrator.py
 src/claude_mpm/schemas/workflow_validator.py
+src/claude_mpm/scripts/socketio_daemon.py
 src/claude_mpm/services/__init__.py
 src/claude_mpm/services/agent_capabilities_generator.py
 src/claude_mpm/services/agent_deployment.py

claude_mpm-3.4.6/VERSION

@@ -1 +0,0 @@
-3.4.6