claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/services/runner_configuration_service.py

@@ -10,10 +10,14 @@ This service handles:
 5. Hook service registration
 
 Extracted from ClaudeRunner to follow Single Responsibility Principle.
+
+DEPENDENCY INJECTION:
+This service uses protocol-based dependency injection to avoid circular imports
+when registering the SessionManagementService.
 """
 
 import os
-from typing import Any, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
 from claude_mpm.core.base_service import BaseService
 from claude_mpm.core.config import Config
@@ -22,6 +26,13 @@ from claude_mpm.core.logger import get_project_logger
 from claude_mpm.core.shared.config_loader import ConfigLoader
 from claude_mpm.services.core.interfaces import RunnerConfigurationInterface
 
+# Protocol imports for type checking without circular dependencies
+if TYPE_CHECKING:
+    from claude_mpm.core.protocols import ClaudeRunnerProtocol
+else:
+    # At runtime, accept any object with matching interface
+    ClaudeRunnerProtocol = Any
+
 
 class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
     """Service for configuring and initializing ClaudeRunner components."""
@@ -168,6 +179,7 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
             "launch_method": kwargs.get("launch_method", "exec"),
             "enable_websocket": kwargs.get("enable_websocket", False),
             "websocket_port": kwargs.get("websocket_port", 8765),
+            "use_native_agents": kwargs.get("use_native_agents", False),
         }
 
         # Initialize main configuration using ConfigLoader
@@ -494,12 +506,14 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
             )
             return None
 
-    def register_session_management_service(self, container, runner):
+    def register_session_management_service(
+        self, container, runner: "ClaudeRunnerProtocol"
+    ):
         """Register session management service in the DI container.
 
         Args:
             container: DI container instance
-            runner: ClaudeRunner instance dependency
+            runner: ClaudeRunner instance (or any object matching ClaudeRunnerProtocol)
 
         Returns:
             Initialized session management service or None if failed

claude_mpm/services/self_upgrade_service.py

@@ -0,0 +1,500 @@
+"""
+Self-Upgrade Service
+====================
+
+Handles version checking and self-upgrade functionality for claude-mpm.
+Supports pip, pipx, and npm installations with automatic detection.
+Also checks Claude Code version compatibility.
+
+WHY: Users should be notified of updates and have an easy way to upgrade
+without manually running installation commands. Claude Code version checking
+ensures compatibility with required features.
+
+DESIGN DECISIONS:
+- Detects installation method (pip/pipx/npm/editable)
+- Non-blocking version checks with caching
+- Interactive upgrade prompts with confirmation
+- Automatic restart after upgrade
+- Graceful failure handling (never breaks existing installation)
+- Claude Code version detection and compatibility checking
+"""
+
+import os
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+from packaging import version
+
+from ..core.logger import get_logger
+from ..core.unified_paths import PathContext
+from .mcp_gateway.utils.package_version_checker import PackageVersionChecker
+
+
+class InstallationMethod:
+    """Installation method enumeration."""
+
+    PIP = "pip"
+    PIPX = "pipx"
+    NPM = "npm"
+    EDITABLE = "editable"
+    UNKNOWN = "unknown"
+
+
+class SelfUpgradeService:
+    """
+    Service for checking and performing self-upgrades.
+
+    Capabilities:
+    - Detect current installation method
+    - Check PyPI/npm for latest version
+    - Check Claude Code version and compatibility
+    - Prompt user for upgrade confirmation
+    - Execute upgrade command
+    - Restart after upgrade
+    """
+
+    # Claude Code version requirements
+    CLAUDE_CODE_MIN_VERSION = "1.0.92"
+    CLAUDE_CODE_RECOMMENDED_VERSION = "2.0.30"
+
+    def __init__(self):
+        """Initialize the self-upgrade service."""
+        self.logger = get_logger("SelfUpgradeService")
+        self.version_checker = PackageVersionChecker()
+        self.current_version = self._get_current_version()
+        self.installation_method = self._detect_installation_method()
+        self.claude_code_version = self._get_claude_code_version()
+
+    def _get_current_version(self) -> str:
+        """
+        Get the current installed version.
+
+        Returns:
+            Version string (e.g., "4.7.10")
+        """
+        try:
+            from .. import __version__
+
+            return __version__
+        except ImportError:
+            # Fallback to VERSION file
+            try:
+                version_file = Path(__file__).parent.parent / "VERSION"
+                if version_file.exists():
+                    return version_file.read_text().strip()
+            except Exception:
+                pass
+
+        return "unknown"
+
+    def _detect_installation_method(self) -> str:
+        """
+        Detect how claude-mpm was installed.
+
+        Returns:
+            Installation method constant
+        """
+        # Check for editable install
+        if PathContext.detect_deployment_context().name in [
+            "DEVELOPMENT",
+            "EDITABLE_INSTALL",
+        ]:
+            return InstallationMethod.EDITABLE
+
+        # Check for pipx by looking at executable path
+        executable = sys.executable
+        if "pipx" in executable:
+            return InstallationMethod.PIPX
+
+        # Check if npm wrapper is present
+        try:
+            result = subprocess.run(
+                ["npm", "list", "-g", "claude-mpm"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and "claude-mpm" in result.stdout:
+                return InstallationMethod.NPM
+        except Exception:
+            pass
+
+        # Default to pip
+        return InstallationMethod.PIP
+
+    def _get_claude_code_version(self) -> Optional[str]:
+        """
+        Get the installed Claude Code version.
+
+        Returns:
+            Version string (e.g., "2.0.30") or None if not installed
+        """
+        try:
+            # Try to get Claude Code version via CLI
+            result = subprocess.run(
+                ["claude", "--version"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                # Parse version from output
+                # Expected format: "Claude Code 2.0.30" or similar
+                match = re.search(r"(\d+\.\d+\.\d+)", result.stdout)
+                if match:
+                    return match.group(1)
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            # Claude Code not installed or command not found
+            pass
+        except Exception as e:
+            self.logger.debug(f"Failed to detect Claude Code version: {e}")
+
+        return None
+
+    def check_claude_code_compatibility(self) -> Dict[str, any]:
+        """
+        Check Claude Code version compatibility.
+
+        Returns:
+            Dict with compatibility information:
+            {
+                "installed": bool,
+                "version": str or None,
+                "meets_minimum": bool,
+                "is_recommended": bool,
+                "status": str,
+                "message": str
+            }
+        """
+        if not self.claude_code_version:
+            return {
+                "installed": False,
+                "version": None,
+                "meets_minimum": False,
+                "is_recommended": False,
+                "status": "not_installed",
+                "message": (
+                    "Claude Code is not installed or not in PATH.\n"
+                    "   Install from: https://docs.anthropic.com/en/docs/claude-code"
+                ),
+            }
+
+        try:
+            current = version.parse(self.claude_code_version)
+            minimum = version.parse(self.CLAUDE_CODE_MIN_VERSION)
+            recommended = version.parse(self.CLAUDE_CODE_RECOMMENDED_VERSION)
+
+            meets_minimum = current >= minimum
+            is_recommended = current >= recommended
+
+            if is_recommended:
+                status = "optimal"
+                message = f"Claude Code v{self.claude_code_version} (optimal version)"
+            elif meets_minimum:
+                status = "compatible"
+                message = (
+                    f"Claude Code v{self.claude_code_version} is compatible\n"
+                    f"   Recommended: Upgrade to v{self.CLAUDE_CODE_RECOMMENDED_VERSION}+ for best experience"
+                )
+            else:
+                status = "outdated"
+                message = (
+                    f"Claude Code v{self.claude_code_version} is outdated\n"
+                    f"   Minimum required: v{self.CLAUDE_CODE_MIN_VERSION}\n"
+                    f"   Recommended: v{self.CLAUDE_CODE_RECOMMENDED_VERSION}+"
+                )
+
+            return {
+                "installed": True,
+                "version": self.claude_code_version,
+                "meets_minimum": meets_minimum,
+                "is_recommended": is_recommended,
+                "status": status,
+                "message": message,
+            }
+
+        except Exception as e:
+            self.logger.debug(f"Version comparison failed: {e}")
+            return {
+                "installed": True,
+                "version": self.claude_code_version,
+                "meets_minimum": False,
+                "is_recommended": False,
+                "status": "unknown",
+                "message": f"Unable to verify Claude Code version: {e}",
+            }
+
+    async def check_for_update(
+        self, cache_ttl: Optional[int] = None
+    ) -> Optional[Dict[str, any]]:
+        """
+        Check if an update is available.
+
+        Args:
+            cache_ttl: Cache time-to-live in seconds (default: 24 hours)
+
+        Returns:
+            Dict with update info or None:
+            {
+                "current": "4.7.10",
+                "latest": "4.7.11",
+                "update_available": True,
+                "installation_method": "pipx",
+                "upgrade_command": "pipx upgrade claude-mpm"
+            }
+        """
+        if self.current_version == "unknown":
+            self.logger.warning("Cannot check for updates: version unknown")
+            return None
+
+        # Check PyPI for Python installations
+        if self.installation_method in [
+            InstallationMethod.PIP,
+            InstallationMethod.PIPX,
+        ]:
+            result = await self.version_checker.check_for_update(
+                "claude-mpm", self.current_version, cache_ttl
+            )
+            if result and result.get("update_available"):
+                result["installation_method"] = self.installation_method
+                result["upgrade_command"] = self._get_upgrade_command()
+                return result
+
+        # Check npm for npm installations
+        elif self.installation_method == InstallationMethod.NPM:
+            npm_version = await self._check_npm_version()
+            if npm_version:
+                current_ver = version.parse(self.current_version)
+                latest_ver = version.parse(npm_version)
+                if latest_ver > current_ver:
+                    return {
+                        "current": self.current_version,
+                        "latest": npm_version,
+                        "update_available": True,
+                        "installation_method": InstallationMethod.NPM,
+                        "upgrade_command": self._get_upgrade_command(),
+                        "checked_at": datetime.now(timezone.utc).isoformat(),
+                    }
+
+        return None
+
+    async def _check_npm_version(self) -> Optional[str]:
+        """
+        Check npm registry for latest version.
+
+        Returns:
+            Latest version string or None
+        """
+        try:
+            result = subprocess.run(
+                ["npm", "view", "claude-mpm", "version"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except Exception as e:
+            self.logger.debug(f"npm version check failed: {e}")
+
+        return None
+
+    def _get_upgrade_command(self) -> str:
+        """
+        Get the appropriate upgrade command for current installation method.
+
+        Returns:
+            Shell command string to upgrade claude-mpm
+        """
+        if self.installation_method == InstallationMethod.PIPX:
+            return "pipx upgrade claude-mpm"
+        if self.installation_method == InstallationMethod.NPM:
+            return "npm update -g claude-mpm"
+        if self.installation_method == InstallationMethod.PIP:
+            return f"{sys.executable} -m pip install --upgrade claude-mpm"
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return "git pull && pip install -e ."
+        return "pip install --upgrade claude-mpm"
+
+    def prompt_for_upgrade(self, update_info: Dict[str, any]) -> bool:
+        """
+        Prompt user to upgrade with enhanced formatting.
+
+        Args:
+            update_info: Update information dict
+
+        Returns:
+            True if user confirms upgrade, False otherwise
+        """
+        current = update_info["current"]
+        latest = update_info["latest"]
+        method = update_info.get("installation_method", "unknown")
+
+        # Enhanced notification with release notes link
+        print("\n" + "=" * 70)
+        print("📢 Update Available for claude-mpm")
+        print("=" * 70)
+        print(f"   Current: v{current}")
+        print(f"   Latest:  v{latest}")
+        print(f"   Method:  {method}")
+        print()
+        print(f"   Upgrade: {update_info['upgrade_command']}")
+        print(
+            f"   Release: https://github.com/bobmatnyc/claude-mpm/releases/tag/v{latest}"
+        )
+        print("=" * 70)
+
+        try:
+            response = input("\nWould you like to upgrade now? [y/N]: ").strip().lower()
+            return response in ["y", "yes"]
+        except (KeyboardInterrupt, EOFError):
+            print("\n")
+            return False
+
+    def display_update_notification(self, update_info: Dict[str, any]) -> None:
+        """
+        Display a non-interactive update notification.
+
+        Args:
+            update_info: Update information dict
+        """
+        current = update_info["current"]
+        latest = update_info["latest"]
+        command = update_info.get("upgrade_command", "pip install --upgrade claude-mpm")
+
+        print(f"\nℹ️  Update available: v{current} → v{latest}")
+        print(f"   Run: {command}")
+        print(
+            f"   Release notes: https://github.com/bobmatnyc/claude-mpm/releases/tag/v{latest}"
+        )
+        print()
+
+    def perform_upgrade(self, update_info: Dict[str, any]) -> Tuple[bool, str]:
+        """
+        Perform the upgrade.
+
+        Args:
+            update_info: Update information dict
+
+        Returns:
+            Tuple of (success: bool, message: str)
+        """
+        command = update_info["upgrade_command"]
+
+        # Don't upgrade editable installs automatically
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return (
+                False,
+                "Editable installation detected. Please update manually with: git pull && pip install -e .",
+            )
+
+        print("\n⏳ Upgrading claude-mpm...")
+        print(f"   Running: {command}")
+
+        try:
+            # Execute upgrade command
+            result = subprocess.run(
+                command,
+                check=False,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minutes
+            )
+
+            if result.returncode == 0:
+                return (True, f"✅ Successfully upgraded to v{update_info['latest']}")
+            error_msg = result.stderr or result.stdout or "Unknown error"
+            return (False, f"❌ Upgrade failed: {error_msg}")
+
+        except subprocess.TimeoutExpired:
+            return (False, "❌ Upgrade timed out")
+        except Exception as e:
+            return (False, f"❌ Upgrade failed: {e!s}")
+
+    def restart_after_upgrade(self) -> None:
+        """
+        Restart claude-mpm after a successful upgrade.
+
+        Preserves original command line arguments.
+        """
+        print("\n🔄 Restarting claude-mpm...")
+
+        try:
+            # Get current command line arguments
+            args = sys.argv[:]
+
+            # Replace current process with new one
+            if self.installation_method == InstallationMethod.PIPX:
+                # Use pipx run
+                os.execvp("pipx", ["pipx", "run", "claude-mpm", *args[1:]])
+            elif self.installation_method == InstallationMethod.NPM:
+                # Use npm executable
+                os.execvp("claude-mpm", args)
+            else:
+                # Use Python executable
+                os.execvp(sys.executable, [sys.executable, *args])
+
+        except Exception as e:
+            self.logger.error(f"Failed to restart: {e}")
+            print(f"\n⚠️  Restart failed: {e}")
+            print("Please restart claude-mpm manually.")
+
+    async def check_and_prompt_on_startup(
+        self, auto_upgrade: bool = False, check_claude_code: bool = True
+    ) -> Optional[Dict[str, any]]:
+        """
+        Check for updates on startup and optionally prompt user.
+        Also checks Claude Code version compatibility.
+
+        Args:
+            auto_upgrade: If True, upgrade without prompting (use with caution)
+            check_claude_code: If True, also check Claude Code compatibility
+
+        Returns:
+            Update info if available, None otherwise
+        """
+        # Skip for editable installs
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return None
+
+        try:
+            # Check Claude Code compatibility first
+            if check_claude_code:
+                claude_compat = self.check_claude_code_compatibility()
+                if not claude_compat["installed"]:
+                    print("\n⚠️  Claude Code Not Detected")
+                    print("   " + claude_compat["message"])
+                elif claude_compat["status"] == "outdated":
+                    print("\n⚠️  Claude Code Outdated")
+                    print("   " + claude_compat["message"].replace("\n", "\n   "))
+                elif claude_compat["status"] == "compatible":
+                    # Only show if verbose or debug
+                    self.logger.debug(claude_compat["message"])
+
+            # Check for claude-mpm updates
+            update_info = await self.check_for_update()
+
+            if update_info and update_info.get("update_available"):
+                if auto_upgrade:
+                    success, message = self.perform_upgrade(update_info)
+                    print(message)
+                    if success:
+                        self.restart_after_upgrade()
+                else:
+                    # Just display notification, don't prompt during startup
+                    self.display_update_notification(update_info)
+
+                return update_info
+
+        except Exception as e:
+            self.logger.debug(f"Startup version check failed: {e}")
+
+        return None

claude_mpm/services/session_management_service.py

@@ -9,27 +9,41 @@ This service handles:
 4. Session logging and cleanup
 
 Extracted from ClaudeRunner to follow Single Responsibility Principle.
+
+DEPENDENCY INJECTION:
+This service uses protocol-based dependency injection to avoid circular imports.
+It accepts a ClaudeRunnerProtocol instead of importing ClaudeRunner directly.
 """
 
 import time
 import uuid
-from typing import Any, Dict, List, Optional
+from datetime import timezone
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from claude_mpm.core.base_service import BaseService
+from claude_mpm.core.enums import OperationResult, ServiceState
 from claude_mpm.services.core.interfaces import SessionManagementInterface
 
+# Protocol imports for type checking without circular dependencies
+if TYPE_CHECKING:
+    from claude_mpm.core.protocols import ClaudeRunnerProtocol
+else:
+    # At runtime, accept any object with matching interface
+    ClaudeRunnerProtocol = Any
+
 
 class SessionManagementService(BaseService, SessionManagementInterface):
     """Service for managing Claude session orchestration."""
 
-    def __init__(self, runner=None):
+    def __init__(self, runner: Optional["ClaudeRunnerProtocol"] = None):
         """Initialize the session management service.
 
         Args:
-            runner: ClaudeRunner instance for delegation
+            runner: ClaudeRunner instance (or any object matching ClaudeRunnerProtocol)
+                    for delegation
         """
         super().__init__(name="session_management_service")
-        self.runner = runner
+        self.runner: Optional[ClaudeRunnerProtocol] = runner
         self.active_sessions = {}  # Track active sessions
 
     async def _initialize(self) -> None:
@@ -153,7 +167,7 @@ class SessionManagementService(BaseService, SessionManagementInterface):
             session_logs_dir.mkdir(parents=True, exist_ok=True)
 
             # Generate unique session log filename
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
             session_id = str(uuid.uuid4())[:8]
             log_filename = f"session_{timestamp}_{session_id}.jsonl"
             log_file = session_logs_dir / log_filename
@@ -183,10 +197,10 @@ class SessionManagementService(BaseService, SessionManagementInterface):
             from datetime import datetime
 
             # Add timestamp to event data
-            event_data["timestamp"] = datetime.now().isoformat()
+            event_data["timestamp"] = datetime.now(timezone.utc).isoformat()
 
             # Append to log file as JSONL
-            with open(log_file, "a") as f:
+            with log_file.open("a") as f:
                 f.write(json.dumps(event_data) + "\n")
 
         except Exception as e:
@@ -222,7 +236,7 @@ class SessionManagementService(BaseService, SessionManagementInterface):
             "id": session_id,
             "config": session_config,
             "start_time": time.time(),
-            "status": "active",
+            "status": ServiceState.RUNNING,
             "type": session_config.get("type", "interactive"),
         }
 
@@ -266,7 +280,7 @@ class SessionManagementService(BaseService, SessionManagementInterface):
             return self.active_sessions[session_id].copy()
         return {
             "id": session_id,
-            "status": "not_found",
+            "status": OperationResult.ERROR,
             "error": "Session not found",
         }