claude-mpm 4.4.3__py3-none-any.whl → 4.4.5__py3-none-any.whl

claude_mpm/services/diagnostics/checks/installation_check.py

@@ -5,9 +5,11 @@ WHY: Verify that claude-mpm is properly installed with correct Python version,
 dependencies, and installation method.
 """
 
+import os
 import subprocess
 import sys
 from pathlib import Path
+from typing import Optional
 
 from ..models import DiagnosticResult, DiagnosticStatus
 from .base_check import BaseDiagnosticCheck
@@ -145,31 +147,41 @@ class InstallationCheck(BaseDiagnosticCheck):
         exe_path = sys.executable
         details["python_executable"] = exe_path
 
-        # 2. Check if we're in a virtual environment
+        # 2. Check for container environment
+        container_type = self._detect_container_environment()
+        if container_type:
+            details["container_type"] = container_type
+            methods_found.append("container")
+
+        # 3. Check if we're in a virtual environment
         in_venv = hasattr(sys, "real_prefix") or (
             hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
         )
 
-        # 3. Check if running from pipx environment
+        # 4. Check if running from pipx environment
         # Pipx creates venvs in specific locations
         is_pipx_venv = False
         if in_venv and (".local/pipx/venvs" in exe_path or "pipx/venvs" in exe_path):
             is_pipx_venv = True
             methods_found.append("pipx")
             details["pipx_venv"] = sys.prefix
+            # Get pipx metadata if available
+            pipx_metadata = self._get_pipx_metadata()
+            if pipx_metadata:
+                details["pipx_metadata"] = pipx_metadata
         elif in_venv:
             # Regular virtual environment (not pipx)
             methods_found.append("venv")
             details["venv_path"] = sys.prefix
 
-        # 4. Check if running from source (development mode)
+        # 5. Check if running from source (development mode)
         claude_mpm_path = Path(__file__).parent.parent.parent.parent.parent
         if (claude_mpm_path / "pyproject.toml").exists():
             if (claude_mpm_path / ".git").exists():
                 methods_found.append("development")
                 details["source_path"] = str(claude_mpm_path)
 
-        # 5. Check Homebrew Python
+        # 6. Check Homebrew Python
         if not in_venv and "/opt/homebrew" in exe_path:
             methods_found.append("homebrew")
             details["homebrew_python"] = exe_path
@@ -178,33 +190,24 @@ class InstallationCheck(BaseDiagnosticCheck):
             methods_found.append("homebrew")
             details["homebrew_python"] = exe_path
 
-        # 6. Check for system Python
+        # 7. Check for system Python
         if not in_venv and not methods_found:
             if "/usr/bin/python" in exe_path or "/usr/local/bin/python" in exe_path:
                 methods_found.append("system")
                 details["system_python"] = exe_path
 
-        # 7. Additional check for pipx if not detected via venv
+        # 8. Additional check for pipx if not detected via venv
         if "pipx" not in methods_found:
-            try:
-                result = subprocess.run(
-                    ["pipx", "list"],
-                    capture_output=True,
-                    text=True,
-                    timeout=5,
-                    check=False,
-                )
-                if "claude-mpm" in result.stdout:
-                    if not is_pipx_venv:
-                        # Pipx is installed but we're not running from it
-                        details["pipx_installed"] = True
-                        details["pipx_not_active"] = (
-                            "claude-mpm is installed via pipx but not currently running from pipx environment"
-                        )
-            except (subprocess.SubprocessError, FileNotFoundError):
-                pass
-
-        # 8. Check pip installation status
+            pipx_check = self._check_pipx_installation_status()
+            if pipx_check:
+                if not is_pipx_venv:
+                    # Pipx is installed but we're not running from it
+                    details["pipx_installed"] = True
+                    details["pipx_not_active"] = (
+                        "claude-mpm is installed via pipx but not currently running from pipx environment"
+                    )
+
+        # 9. Check pip installation status
         try:
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "show", "claude-mpm"],
@@ -242,6 +245,22 @@ class InstallationCheck(BaseDiagnosticCheck):
                 details=details,
             )
 
+        # Container environments are special
+        if "container" in methods_found:
+            container_msg = (
+                f"Running in {details.get('container_type', 'container')} environment"
+            )
+            if "pipx" in methods_found:
+                container_msg += " with pipx"
+            elif "venv" in methods_found:
+                container_msg += " with virtual environment"
+            return DiagnosticResult(
+                category="Installation Method",
+                status=DiagnosticStatus.OK,
+                message=container_msg,
+                details=details,
+            )
+
         # Pipx is the recommended method
         if "pipx" in methods_found:
             return DiagnosticResult(
@@ -413,3 +432,85 @@ class InstallationCheck(BaseDiagnosticCheck):
                 "in_venv": in_venv,
             },
         )
+
+    def _detect_container_environment(self) -> Optional[str]:
+        """Detect if running in a container environment."""
+        # Check for Docker
+        if Path("/.dockerenv").exists():
+            return "Docker"
+
+        # Check for Kubernetes
+        if Path("/var/run/secrets/kubernetes.io").exists():
+            return "Kubernetes"
+
+        # Check cgroup for container indicators
+        try:
+            with open("/proc/1/cgroup") as f:
+                cgroup = f.read()
+                if "docker" in cgroup:
+                    return "Docker"
+                if "kubepods" in cgroup:
+                    return "Kubernetes"
+                if "containerd" in cgroup:
+                    return "containerd"
+                if "lxc" in cgroup:
+                    return "LXC"
+        except (FileNotFoundError, PermissionError):
+            pass
+
+        # Check environment variables
+        if os.environ.get("CONTAINER"):
+            return os.environ.get("CONTAINER_ENGINE", "Container")
+
+        # Check for Podman
+        if Path("/run/.containerenv").exists():
+            return "Podman"
+
+        # Check for WSL
+        if Path("/proc/sys/fs/binfmt_misc/WSLInterop").exists():
+            return "WSL"
+
+        return None
+
+    def _get_pipx_metadata(self) -> Optional[dict]:
+        """Get pipx metadata for the current installation."""
+        try:
+            import json
+
+            result = subprocess.run(
+                ["pipx", "list", "--json"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0:
+                data = json.loads(result.stdout)
+                venvs = data.get("venvs", {})
+                if "claude-mpm" in venvs:
+                    return {
+                        "version": venvs["claude-mpm"]
+                        .get("metadata", {})
+                        .get("main_package", {})
+                        .get("package_version"),
+                        "python": venvs["claude-mpm"]
+                        .get("metadata", {})
+                        .get("python_version"),
+                    }
+        except Exception:
+            pass
+        return None
+
+    def _check_pipx_installation_status(self) -> bool:
+        """Check if claude-mpm is installed via pipx."""
+        try:
+            result = subprocess.run(
+                ["pipx", "list"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            return "claude-mpm" in result.stdout
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False

claude_mpm/services/diagnostics/checks/mcp_services_check.py

@@ -0,0 +1,451 @@
+"""
+Check MCP external services installation and health.
+
+WHY: Verify that MCP services (mcp-vector-search, mcp-browser, mcp-ticketer, kuzu-memory)
+are properly installed and accessible for enhanced Claude Desktop capabilities.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from ..models import DiagnosticResult, DiagnosticStatus
+from .base_check import BaseDiagnosticCheck
+
+
+class MCPServicesCheck(BaseDiagnosticCheck):
+    """Check MCP external services installation and health."""
+
+    # Define MCP services to check
+    MCP_SERVICES = {
+        "mcp-vector-search": {
+            "package": "mcp-vector-search",
+            "command": ["mcp-vector-search", "--version"],  # Use --version for proper check
+            "description": "Vector search for semantic code navigation",
+            "check_health": True,
+            "health_command": ["mcp-vector-search", "--version"],
+            "pipx_run_command": ["pipx", "run", "mcp-vector-search", "--version"],
+        },
+        "mcp-browser": {
+            "package": "mcp-browser",
+            "command": ["mcp-browser", "--version"],  # Use --version for proper check
+            "description": "Browser automation and web interaction",
+            "check_health": True,
+            "health_command": ["mcp-browser", "--version"],
+            "pipx_run_command": ["pipx", "run", "mcp-browser", "--version"],
+        },
+        "mcp-ticketer": {
+            "package": "mcp-ticketer",
+            "command": ["mcp-ticketer", "--version"],  # Use --version for proper check
+            "description": "Ticket and task management",
+            "check_health": True,
+            "health_command": ["mcp-ticketer", "--version"],
+            "pipx_run_command": ["pipx", "run", "mcp-ticketer", "--version"],
+        },
+        "kuzu-memory": {
+            "package": "kuzu-memory",
+            "command": ["kuzu-memory", "--version"],  # Use --version for proper check
+            "description": "Graph-based memory system",
+            "check_health": True,  # v1.1.0+ has version command
+            "health_command": ["kuzu-memory", "--version"],
+            "pipx_run_command": ["pipx", "run", "kuzu-memory", "--version"],
+        },
+    }
+
+    @property
+    def name(self) -> str:
+        return "mcp_services_check"
+
+    @property
+    def category(self) -> str:
+        return "MCP Services"
+
+    def run(self) -> DiagnosticResult:
+        """Run MCP services diagnostics."""
+        try:
+            details = {}
+            sub_results = []
+            services_status = {}
+
+            # Check each MCP service
+            for service_name, service_config in self.MCP_SERVICES.items():
+                service_result = self._check_service(service_name, service_config)
+                sub_results.append(service_result)
+                services_status[service_name] = {
+                    "status": service_result.status.value,
+                    "installed": service_result.details.get("installed", False),
+                    "accessible": service_result.details.get("accessible", False),
+                    "version": service_result.details.get("version"),
+                }
+
+            # Check MCP gateway configuration for services
+            gateway_result = self._check_gateway_configuration()
+            sub_results.append(gateway_result)
+
+            # Count service statuses
+            installed_count = sum(1 for s in services_status.values() if s["installed"])
+            accessible_count = sum(
+                1 for s in services_status.values() if s["accessible"]
+            )
+            total_services = len(self.MCP_SERVICES)
+
+            details["services"] = services_status
+            details["installed_count"] = installed_count
+            details["accessible_count"] = accessible_count
+            details["total_services"] = total_services
+            details["gateway_configured"] = gateway_result.status == DiagnosticStatus.OK
+
+            # Determine overall status
+            errors = [r for r in sub_results if r.status == DiagnosticStatus.ERROR]
+            warnings = [r for r in sub_results if r.status == DiagnosticStatus.WARNING]
+
+            if errors:
+                status = DiagnosticStatus.ERROR
+                message = f"Critical issues with {len(errors)} MCP service(s)"
+            elif installed_count == 0:
+                status = DiagnosticStatus.WARNING
+                message = "No MCP services installed"
+            elif accessible_count < installed_count:
+                status = DiagnosticStatus.WARNING
+                message = f"{installed_count}/{total_services} services installed, {accessible_count} accessible"
+            elif installed_count < total_services:
+                status = DiagnosticStatus.WARNING
+                message = f"{installed_count}/{total_services} MCP services installed"
+            else:
+                status = DiagnosticStatus.OK
+                message = f"All {total_services} MCP services installed and accessible"
+
+            return DiagnosticResult(
+                category=self.category,
+                status=status,
+                message=message,
+                details=details,
+                sub_results=sub_results if self.verbose else [],
+            )
+
+        except Exception as e:
+            return DiagnosticResult(
+                category=self.category,
+                status=DiagnosticStatus.ERROR,
+                message=f"MCP services check failed: {e!s}",
+                details={"error": str(e)},
+            )
+
+    def _check_service(self, service_name: str, config: Dict) -> DiagnosticResult:
+        """Check a specific MCP service."""
+        details = {"service": service_name}
+
+        # Check if installed via pipx
+        pipx_installed, pipx_path = self._check_pipx_installation(config["package"])
+        details["pipx_installed"] = pipx_installed
+        if pipx_path:
+            details["pipx_path"] = pipx_path
+
+        # Check if accessible in PATH
+        accessible, command_path = self._check_command_accessible(config["command"])
+        details["accessible"] = accessible
+        if command_path:
+            details["command_path"] = command_path
+
+        # If not directly accessible, try pipx run command
+        if not accessible and "pipx_run_command" in config:
+            if self._verify_command_works(config["pipx_run_command"]):
+                accessible = True
+                details["accessible_via_pipx_run"] = True
+                details["pipx_run_available"] = True
+
+        # Check for installation in various locations
+        if not pipx_installed and not accessible:
+            # Try common installation locations
+            alt_installed, alt_path = self._check_alternative_installations(
+                service_name
+            )
+            if alt_installed:
+                details["alternative_installation"] = alt_path
+                accessible = alt_installed
+
+        details["installed"] = pipx_installed or accessible
+
+        # Check service health/version if accessible
+        if accessible and config.get("check_health"):
+            # Try different version commands in order of preference
+            version_commands = []
+            if details.get("accessible_via_pipx_run") and "pipx_run_command" in config:
+                version_commands.append(config["pipx_run_command"])
+            if "health_command" in config:
+                version_commands.append(config["health_command"])
+            version_commands.append(config["command"])
+
+            for cmd in version_commands:
+                version = self._get_service_version(cmd)
+                if version:
+                    details["version"] = version
+                    break
+
+        # Determine status
+        if not (pipx_installed or accessible):
+            return DiagnosticResult(
+                category=f"MCP Service: {service_name}",
+                status=DiagnosticStatus.WARNING,
+                message=f"Not installed: {config['description']}",
+                details=details,
+                fix_command=f"pipx install {config['package']}",
+                fix_description=f"Install {service_name} for {config['description']}",
+            )
+
+        if pipx_installed and not accessible:
+            # Check if pipx run works
+            if details.get("pipx_run_available"):
+                return DiagnosticResult(
+                    category=f"MCP Service: {service_name}",
+                    status=DiagnosticStatus.OK,
+                    message="Installed via pipx (use 'pipx run' to execute)",
+                    details=details,
+                )
+            return DiagnosticResult(
+                category=f"MCP Service: {service_name}",
+                status=DiagnosticStatus.WARNING,
+                message="Installed via pipx but not in PATH",
+                details=details,
+                fix_command="pipx ensurepath",
+                fix_description="Ensure pipx bin directory is in PATH",
+            )
+
+        return DiagnosticResult(
+            category=f"MCP Service: {service_name}",
+            status=DiagnosticStatus.OK,
+            message="Installed and accessible",
+            details=details,
+        )
+
+    def _check_pipx_installation(self, package_name: str) -> Tuple[bool, Optional[str]]:
+        """Check if a package is installed via pipx."""
+        try:
+            result = subprocess.run(
+                ["pipx", "list", "--json"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                try:
+                    data = json.loads(result.stdout)
+                    venvs = data.get("venvs", {})
+
+                    if package_name in venvs:
+                        venv_info = venvs[package_name]
+                        # Get the main app path
+                        apps = (
+                            venv_info.get("metadata", {})
+                            .get("main_package", {})
+                            .get("apps", [])
+                        )
+                        if apps:
+                            app_path = (
+                                venv_info.get("metadata", {})
+                                .get("main_package", {})
+                                .get("app_paths", [])
+                            )
+                            if app_path:
+                                return True, app_path[0]
+                        return True, None
+                except json.JSONDecodeError:
+                    pass
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+
+        return False, None
+
+    def _check_command_accessible(
+        self, command: List[str]
+    ) -> Tuple[bool, Optional[str]]:
+        """Check if a command is accessible in PATH."""
+        try:
+            # Use 'which' on Unix-like systems
+            result = subprocess.run(
+                ["which", command[0]],
+                capture_output=True,
+                text=True,
+                timeout=2,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                path = result.stdout.strip()
+                # Verify the command actually works with --version
+                if self._verify_command_works(command):
+                    return True, path
+                return False, path
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+
+        # Try direct execution with --version
+        if self._verify_command_works(command):
+            return True, None
+
+        return False, None
+
+    def _verify_command_works(self, command: List[str]) -> bool:
+        """Verify a command actually works by checking its --version output."""
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            # Check for successful execution or version output
+            # Don't accept error messages containing "help" or "usage" as success
+            if result.returncode == 0:
+                # Look for actual version information
+                output = (result.stdout + result.stderr).lower()
+                # Check for version indicators
+                if any(keyword in output for keyword in ["version", "v1.", "v0.", "1.", "0."]):
+                    # But reject if it's an error message
+                    if not any(error in output for error in ["error", "not found", "no such", "command not found"]):
+                        return True
+
+            # For some tools, non-zero return code is OK if version is shown
+            elif "--version" in command or "--help" in command:
+                output = (result.stdout + result.stderr).lower()
+                # Must have version info and no error indicators
+                if ("version" in output or "v1." in output or "v0." in output):
+                    if not any(error in output for error in ["error", "not found", "no such", "command not found", "traceback"]):
+                        return True
+
+        except (subprocess.SubprocessError, FileNotFoundError, OSError):
+            pass
+
+        return False
+
+    def _check_alternative_installations(
+        self, service_name: str
+    ) -> Tuple[bool, Optional[str]]:
+        """Check for alternative installation locations."""
+        # Common installation paths
+        paths_to_check = [
+            Path.home() / ".local" / "bin" / service_name,
+            Path("/usr/local/bin") / service_name,
+            Path("/opt") / service_name / "bin" / service_name,
+            Path.home() / ".npm" / "bin" / service_name,  # For npm-based services
+            Path.home() / ".cargo" / "bin" / service_name,  # For Rust-based services
+        ]
+
+        for path in paths_to_check:
+            if path.exists():
+                return True, str(path)
+
+        return False, None
+
+    def _get_service_version(self, command: List[str]) -> Optional[str]:
+        """Get version information for a service."""
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                timeout=2,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                output = result.stdout.strip()
+                # Try to extract version from output
+                lines = output.split("\n")
+                for line in lines:
+                    if "version" in line.lower() or "v" in line.lower():
+                        return line.strip()
+                # Return first line if no version line found
+                if lines:
+                    return lines[0].strip()
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+
+        return None
+
+    def _check_gateway_configuration(self) -> DiagnosticResult:
+        """Check if MCP services are configured in the gateway."""
+        try:
+            # Check MCP config file
+            config_dir = Path.home() / ".claude" / "mcp"
+            config_file = config_dir / "config.json"
+
+            if not config_file.exists():
+                return DiagnosticResult(
+                    category="MCP Gateway Configuration",
+                    status=DiagnosticStatus.WARNING,
+                    message="MCP configuration file not found",
+                    details={"config_path": str(config_file), "exists": False},
+                    fix_command="claude-mpm configure --mcp",
+                    fix_description="Initialize MCP configuration",
+                )
+
+            with open(config_file) as f:
+                config = json.load(f)
+
+            # Check for external services configuration
+            external_services = config.get("external_services", {})
+            configured_services = []
+            missing_services = []
+
+            for service_name in self.MCP_SERVICES:
+                if service_name in external_services:
+                    configured_services.append(service_name)
+                else:
+                    # Also check if it's in the services list directly
+                    services = config.get("services", [])
+                    if any(s.get("name") == service_name for s in services):
+                        configured_services.append(service_name)
+                    else:
+                        missing_services.append(service_name)
+
+            details = {
+                "config_path": str(config_file),
+                "configured_services": configured_services,
+                "missing_services": missing_services,
+            }
+
+            if not configured_services:
+                return DiagnosticResult(
+                    category="MCP Gateway Configuration",
+                    status=DiagnosticStatus.WARNING,
+                    message="No MCP services configured in gateway",
+                    details=details,
+                    fix_command="claude-mpm configure --mcp --add-services",
+                    fix_description="Add MCP services to gateway configuration",
+                )
+
+            if missing_services:
+                return DiagnosticResult(
+                    category="MCP Gateway Configuration",
+                    status=DiagnosticStatus.WARNING,
+                    message=f"{len(configured_services)} services configured, {len(missing_services)} missing",
+                    details=details,
+                )
+
+            return DiagnosticResult(
+                category="MCP Gateway Configuration",
+                status=DiagnosticStatus.OK,
+                message=f"All {len(configured_services)} services configured",
+                details=details,
+            )
+
+        except json.JSONDecodeError as e:
+            return DiagnosticResult(
+                category="MCP Gateway Configuration",
+                status=DiagnosticStatus.ERROR,
+                message="Invalid JSON in MCP configuration",
+                details={"error": str(e)},
+            )
+        except Exception as e:
+            return DiagnosticResult(
+                category="MCP Gateway Configuration",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check configuration: {e!s}",
+                details={"error": str(e)},
+            )

claude_mpm/services/diagnostics/diagnostic_runner.py

@@ -21,6 +21,7 @@ from .checks import (
     InstallationCheck,
     InstructionsCheck,
     MCPCheck,
+    MCPServicesCheck,
     MonitorCheck,
     StartupLogCheck,
 )
@@ -55,6 +56,7 @@ class DiagnosticRunner:
             ClaudeDesktopCheck,
             AgentCheck,
             MCPCheck,
+            MCPServicesCheck,  # Check external MCP services
             MonitorCheck,
             StartupLogCheck,  # Check startup logs for recent issues
             CommonIssuesCheck,
@@ -122,6 +124,7 @@ class DiagnosticRunner:
             ClaudeDesktopCheck,
             AgentCheck,
             MCPCheck,
+            MCPServicesCheck,
             MonitorCheck,
             StartupLogCheck,
         ]