claude-mpm 4.4.8__py3-none-any.whl → 4.4.10__py3-none-any.whl

claude_mpm/services/mcp_config_manager.py

@@ -41,6 +41,34 @@ class MCPConfigManager:
         "kuzu-memory",
     }
 
+    # Static known-good MCP service configurations
+    # These are the correct, tested configurations that work reliably
+    STATIC_MCP_CONFIGS = {
+        "kuzu-memory": {
+            "type": "stdio",
+            "command": "kuzu-memory",  # Use direct binary, will be resolved to full path
+            "args": ["mcp", "serve"]  # v1.1.0+ uses 'mcp serve' command
+        },
+        "mcp-ticketer": {
+            "type": "stdio",
+            "command": "mcp-ticketer",  # Use direct binary to preserve injected dependencies
+            "args": ["mcp"]
+        },
+        "mcp-browser": {
+            "type": "stdio",
+            "command": "mcp-browser",  # Use direct binary
+            "args": ["mcp"],
+            "env": {"MCP_BROWSER_HOME": str(Path.home() / ".mcp-browser")}
+        },
+        "mcp-vector-search": {
+            "type": "stdio",
+            # Use pipx venv's Python directly for module execution
+            "command": str(Path.home() / ".local" / "pipx" / "venvs" / "mcp-vector-search" / "bin" / "python"),
+            "args": ["-m", "mcp_vector_search.mcp.server", "{project_root}"],
+            "env": {}
+        }
+    }
+
     def __init__(self):
         """Initialize the MCP configuration manager."""
         self.logger = get_logger(__name__)
@@ -195,11 +223,187 @@ class MCPConfigManager:
 
         return None
 
+    def test_service_command(self, service_name: str, config: Dict) -> bool:
+        """
+        Test if a service configuration actually works.
+
+        Args:
+            service_name: Name of the MCP service
+            config: Service configuration to test
+
+        Returns:
+            True if service responds correctly, False otherwise
+        """
+        try:
+            import shutil
+
+            # Build command - handle pipx PATH issues
+            command = config["command"]
+
+            # If command is pipx and not found, try common paths
+            if command == "pipx":
+                pipx_path = shutil.which("pipx")
+                if not pipx_path:
+                    # Try common pipx locations
+                    for possible_path in [
+                        "/opt/homebrew/bin/pipx",
+                        "/usr/local/bin/pipx",
+                        str(Path.home() / ".local" / "bin" / "pipx"),
+                    ]:
+                        if Path(possible_path).exists():
+                            command = possible_path
+                            break
+                else:
+                    command = pipx_path
+
+            cmd = [command]
+
+            # Add test args (--help or --version)
+            if "args" in config:
+                # For MCP services, test with --help after the subcommand
+                test_args = config["args"].copy()
+                # Replace project root placeholder for testing
+                test_args = [
+                    arg.replace("{project_root}", str(self.project_root)) if "{project_root}" in arg else arg
+                    for arg in test_args
+                ]
+
+                # Add --help at the end
+                if service_name == "mcp-vector-search":
+                    # For Python module invocation, just test if Python can import the module
+                    cmd.extend(test_args[:2])  # Just python -m module_name
+                    cmd.extend(["--help"])
+                else:
+                    cmd.extend(test_args)
+                    cmd.append("--help")
+            else:
+                cmd.append("--help")
+
+            # Run test command with timeout
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+                env=config.get("env", {})
+            )
+
+            # Check if command executed (exit code 0 or 1 for help)
+            if result.returncode in [0, 1]:
+                # Additional check for import errors in stderr
+                if "ModuleNotFoundError" in result.stderr or "ImportError" in result.stderr:
+                    self.logger.debug(f"Service {service_name} has import errors")
+                    return False
+                return True
+
+        except subprocess.TimeoutExpired:
+            # Timeout might mean the service started successfully and is waiting for input
+            return True
+        except Exception as e:
+            self.logger.debug(f"Error testing {service_name}: {e}")
+
+        return False
+
+    def get_static_service_config(self, service_name: str, project_path: Optional[str] = None) -> Optional[Dict]:
+        """
+        Get the static, known-good configuration for an MCP service.
+
+        Args:
+            service_name: Name of the MCP service
+            project_path: Optional project path to use (defaults to current project)
+
+        Returns:
+            Static service configuration dict or None if service not known
+        """
+        if service_name not in self.STATIC_MCP_CONFIGS:
+            return None
+
+        config = self.STATIC_MCP_CONFIGS[service_name].copy()
+        import shutil
+
+        # Resolve service binary commands to full paths
+        if service_name in ["kuzu-memory", "mcp-ticketer", "mcp-browser"]:
+            # Try to find the full path of the binary
+            binary_name = config["command"]
+            binary_path = shutil.which(binary_name)
+
+            if not binary_path:
+                # Try common installation locations
+                possible_paths = [
+                    f"/opt/homebrew/bin/{binary_name}",
+                    f"/usr/local/bin/{binary_name}",
+                    str(Path.home() / ".local" / "bin" / binary_name),
+                ]
+                for path in possible_paths:
+                    if Path(path).exists():
+                        binary_path = path
+                        break
+
+            if binary_path:
+                config["command"] = binary_path
+            # If still not found, keep the binary name and hope it's in PATH
+
+        # Resolve pipx command to full path if needed
+        elif config.get("command") == "pipx":
+            pipx_path = shutil.which("pipx")
+            if not pipx_path:
+                # Try common pipx locations
+                for possible_path in [
+                    "/opt/homebrew/bin/pipx",
+                    "/usr/local/bin/pipx",
+                    str(Path.home() / ".local" / "bin" / "pipx"),
+                ]:
+                    if Path(possible_path).exists():
+                        pipx_path = possible_path
+                        break
+            if pipx_path:
+                config["command"] = pipx_path
+            else:
+                # Keep as "pipx" and hope it's in PATH when executed
+                config["command"] = "pipx"
+
+        # Handle user-specific paths for mcp-vector-search
+        if service_name == "mcp-vector-search":
+            # Get the correct pipx venv path for the current user
+            home = Path.home()
+            python_path = home / ".local" / "pipx" / "venvs" / "mcp-vector-search" / "bin" / "python"
+
+            # Check if the Python interpreter exists, if not fallback to pipx run
+            if python_path.exists():
+                config["command"] = str(python_path)
+            else:
+                # Fallback to pipx run method
+                import shutil
+                pipx_path = shutil.which("pipx")
+                if not pipx_path:
+                    # Try common pipx locations
+                    for possible_path in [
+                        "/opt/homebrew/bin/pipx",
+                        "/usr/local/bin/pipx",
+                        str(Path.home() / ".local" / "bin" / "pipx"),
+                    ]:
+                        if Path(possible_path).exists():
+                            pipx_path = possible_path
+                            break
+                config["command"] = pipx_path if pipx_path else "pipx"
+                config["args"] = ["run", "--spec", "mcp-vector-search", "python"] + config["args"]
+
+            # Use provided project path or current project
+            project_root = project_path if project_path else str(self.project_root)
+            config["args"] = [
+                arg.replace("{project_root}", project_root) if "{project_root}" in arg else arg
+                for arg in config["args"]
+            ]
+
+        return config
+
     def generate_service_config(self, service_name: str) -> Optional[Dict]:
         """
         Generate configuration for a specific MCP service.
 
-        Prefers 'pipx run' or 'uvx' commands over direct execution for better isolation.
+        Prefers static configurations over detection. Falls back to detection
+        only for unknown services.
 
         Args:
             service_name: Name of the MCP service
@@ -207,6 +411,17 @@ class MCPConfigManager:
         Returns:
             Service configuration dict or None if service not found
         """
+        # First try to get static configuration
+        static_config = self.get_static_service_config(service_name)
+        if static_config:
+            # Validate that the static config actually works
+            if self.test_service_command(service_name, static_config):
+                self.logger.debug(f"Static config for {service_name} validated successfully")
+                return static_config
+            else:
+                self.logger.warning(f"Static config for {service_name} failed validation, trying fallback")
+
+        # Fall back to detection-based configuration for unknown services
         import shutil
 
         # Check for pipx run first (preferred for isolation)
@@ -308,7 +523,7 @@ class MCPConfigManager:
 
         elif service_name == "kuzu-memory":
             # Determine kuzu-memory command version
-            kuzu_args = ["mcp", "serve"]  # Default to the correct modern format
+            kuzu_args = ["mcp", "serve"]  # Default to the standard v1.1.0+ format
             test_cmd = None
 
             if use_pipx_run:
@@ -330,20 +545,21 @@ class MCPConfigManager:
                     # Check for MCP support in help output
                     help_output = result.stdout.lower() + result.stderr.lower()
 
-                    # Modern version detection - look for "mcp serve" command
+                    # Standard version detection - look for "mcp serve" command (v1.1.0+)
+                    # This is the correct format for kuzu-memory v1.1.0 and later
                     if "mcp serve" in help_output or ("mcp" in help_output and "serve" in help_output):
-                        # Modern version with mcp serve command
+                        # Standard v1.1.0+ version with mcp serve command
                         kuzu_args = ["mcp", "serve"]
                     # Legacy version detection - only "serve" without "mcp"
                     elif "serve" in help_output and "mcp" not in help_output:
                         # Very old version that only has serve command
                         kuzu_args = ["serve"]
-                    # Note: "claude mcp-server" format is deprecated and not used
                     else:
-                        # Default to the correct modern format
+                        # Default to the standard mcp serve format (v1.1.0+)
+                        # Note: "claude mcp-server" format is deprecated and does not work
                         kuzu_args = ["mcp", "serve"]
                 except Exception:
-                    # Default to the correct mcp serve command on any error
+                    # Default to the standard mcp serve command on any error
                     kuzu_args = ["mcp", "serve"]
 
             if use_pipx_run:
@@ -371,17 +587,20 @@ class MCPConfigManager:
 
     def ensure_mcp_services_configured(self) -> Tuple[bool, str]:
         """
-        Ensure MCP services are configured in ~/.claude.json on startup.
+        Ensure MCP services are configured correctly in ~/.claude.json on startup.
 
-        This method checks if the core MCP services are configured in the
-        current project's mcpServers section and automatically adds them if missing.
+        This method checks ALL projects in ~/.claude.json and ensures each has
+        the correct, static MCP service configurations. It will:
+        1. Add missing services
+        2. Fix incorrect configurations
+        3. Update all projects, not just the current one
 
         Returns:
             Tuple of (success, message)
         """
         updated = False
+        fixed_services = []
         added_services = []
-        project_key = str(self.project_root)
 
         # Load existing Claude config or create minimal structure
         claude_config = {}
@@ -396,9 +615,22 @@ class MCPConfigManager:
         # Ensure projects structure exists
         if "projects" not in claude_config:
             claude_config["projects"] = {}
+            updated = True
+
+        # Fix any corrupted MCP service installations first
+        fix_success, fix_message = self.fix_mcp_service_issues()
+        if not fix_success:
+            self.logger.warning(f"Some MCP services could not be fixed: {fix_message}")
+
+        # Process ALL projects in the config, not just current one
+        projects_to_update = list(claude_config.get("projects", {}).keys())
 
-        if project_key not in claude_config["projects"]:
-            claude_config["projects"][project_key] = {
+        # Also add the current project if not in list
+        current_project_key = str(self.project_root)
+        if current_project_key not in projects_to_update:
+            projects_to_update.append(current_project_key)
+            # Initialize new project structure
+            claude_config["projects"][current_project_key] = {
                 "allowedTools": [],
                 "history": [],
                 "mcpContextUris": [],
@@ -412,29 +644,47 @@ class MCPConfigManager:
             }
             updated = True
 
-        # Get the project's mcpServers section
-        project_config = claude_config["projects"][project_key]
-        if "mcpServers" not in project_config:
-            project_config["mcpServers"] = {}
-            updated = True
-
-        # Check each service and add if missing
-        for service_name in self.PIPX_SERVICES:
-            if service_name not in project_config["mcpServers"]:
-                # Try to detect and configure the service
-                service_path = self.detect_service_path(service_name)
-                if service_path:
-                    config = self.generate_service_config(service_name)
-                    if config:
-                        project_config["mcpServers"][service_name] = config
-                        added_services.append(service_name)
-                        updated = True
-                        self.logger.debug(
-                            f"Added MCP service to config: {service_name}"
-                        )
+        # Update each project's MCP configurations
+        for project_key in projects_to_update:
+            project_config = claude_config["projects"][project_key]
+
+            # Ensure mcpServers section exists
+            if "mcpServers" not in project_config:
+                project_config["mcpServers"] = {}
+                updated = True
+
+            # Check and fix each service configuration
+            for service_name in self.PIPX_SERVICES:
+                # Get the correct static configuration with project-specific paths
+                correct_config = self.get_static_service_config(service_name, project_key)
+
+                if not correct_config:
+                    self.logger.warning(f"No static config available for {service_name}")
+                    continue
+
+                # Check if service exists and has correct configuration
+                existing_config = project_config["mcpServers"].get(service_name)
+
+                # Determine if we need to update
+                needs_update = False
+                if not existing_config:
+                    # Service is missing
+                    needs_update = True
+                    added_services.append(f"{service_name} in {Path(project_key).name}")
                 else:
+                    # Service exists, check if configuration is correct
+                    # Compare command and args (the most critical parts)
+                    if (existing_config.get("command") != correct_config.get("command") or
+                        existing_config.get("args") != correct_config.get("args")):
+                        needs_update = True
+                        fixed_services.append(f"{service_name} in {Path(project_key).name}")
+
+                # Update configuration if needed
+                if needs_update:
+                    project_config["mcpServers"][service_name] = correct_config
+                    updated = True
                     self.logger.debug(
-                        f"MCP service {service_name} not found for auto-configuration"
+                        f"Updated MCP service config for {service_name} in project {Path(project_key).name}"
                     )
 
         # Write updated config if changes were made
@@ -448,7 +698,6 @@ class MCPConfigManager:
                             f".backup.{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
                         )
                         import shutil
-
                         shutil.copy2(self.claude_config_path, backup_path)
                         self.logger.debug(f"Created backup: {backup_path}")
 
@@ -456,18 +705,20 @@ class MCPConfigManager:
                 with open(self.claude_config_path, "w") as f:
                     json.dump(claude_config, f, indent=2)
 
+                messages = []
                 if added_services:
-                    message = (
-                        f"Auto-configured MCP services: {', '.join(added_services)}"
-                    )
-                    # Don't log here - let the caller handle logging to avoid duplicates
-                    return True, message
-                return True, "All MCP services already configured"
+                    messages.append(f"Added MCP services: {', '.join(added_services[:3])}")
+                if fixed_services:
+                    messages.append(f"Fixed MCP services: {', '.join(fixed_services[:3])}")
+
+                if messages:
+                    return True, "; ".join(messages)
+                return True, "All MCP services already configured correctly"
             except Exception as e:
                 self.logger.error(f"Failed to write Claude config: {e}")
                 return False, f"Failed to write configuration: {e}"
 
-        return True, "All MCP services already configured"
+        return True, "All MCP services already configured correctly"
 
     def update_mcp_config(self, force_pipx: bool = True) -> Tuple[bool, str]:
         """
@@ -695,6 +946,250 @@ class MCPConfigManager:
 
         return False, "none"
 
+    def _check_and_fix_mcp_ticketer_dependencies(self) -> bool:
+        """Check and fix mcp-ticketer missing gql dependency.
+
+        Note: This is a workaround for mcp-ticketer <= 0.1.8 which is missing
+        the gql dependency in its package metadata. Future versions (> 0.1.8)
+        should include 'gql[httpx]>=3.0.0' as a dependency, making this fix
+        unnecessary. We keep this for backward compatibility with older versions.
+        """
+        try:
+            # Test if gql is available in mcp-ticketer's environment
+            test_result = subprocess.run(
+                ["pipx", "run", "--spec", "mcp-ticketer", "python", "-c", "import gql"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            # If import fails, inject the dependency
+            if test_result.returncode != 0:
+                self.logger.info("🔧 mcp-ticketer missing gql dependency, fixing...")
+
+                inject_result = subprocess.run(
+                    ["pipx", "inject", "mcp-ticketer", "gql"],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                    check=False,
+                )
+
+                if inject_result.returncode == 0:
+                    self.logger.info("✅ Successfully injected gql dependency into mcp-ticketer")
+                    return True
+                else:
+                    self.logger.warning(f"Failed to inject gql: {inject_result.stderr}")
+                    return False
+
+            return False
+
+        except Exception as e:
+            self.logger.debug(f"Could not check/fix mcp-ticketer dependencies: {e}")
+            return False
+
+    def fix_mcp_service_issues(self) -> Tuple[bool, str]:
+        """
+        Detect and fix corrupted MCP service installations.
+
+        This method:
+        1. Tests each MCP service for import/execution errors
+        2. Automatically reinstalls corrupted services
+        3. Fixes missing dependencies (like mcp-ticketer's gql)
+        4. Validates fixes worked
+
+        Returns:
+            Tuple of (success, message)
+        """
+        self.logger.info("🔍 Checking MCP services for issues...")
+
+        services_to_fix = []
+        fixed_services = []
+        failed_services = []
+
+        # Check each service for issues
+        for service_name in self.PIPX_SERVICES:
+            issue_type = self._detect_service_issue(service_name)
+            if issue_type:
+                services_to_fix.append((service_name, issue_type))
+                self.logger.debug(f"Found issue with {service_name}: {issue_type}")
+
+        if not services_to_fix:
+            return True, "All MCP services are functioning correctly"
+
+        # Fix each problematic service
+        for service_name, issue_type in services_to_fix:
+            self.logger.info(f"🔧 Fixing {service_name}: {issue_type}")
+
+            if issue_type == "not_installed":
+                # Install the service
+                success, method = self._install_service_with_fallback(service_name)
+                if success:
+                    fixed_services.append(f"{service_name} (installed via {method})")
+                else:
+                    failed_services.append(f"{service_name} (installation failed)")
+
+            elif issue_type == "import_error":
+                # Reinstall to fix corrupted installation
+                self.logger.info(f"  Reinstalling {service_name} to fix import errors...")
+                success = self._reinstall_service(service_name)
+                if success:
+                    # Special handling for mcp-ticketer - inject missing gql dependency
+                    if service_name == "mcp-ticketer":
+                        self._check_and_fix_mcp_ticketer_dependencies()
+                    fixed_services.append(f"{service_name} (reinstalled)")
+                else:
+                    failed_services.append(f"{service_name} (reinstall failed)")
+
+            elif issue_type == "missing_dependency":
+                # Fix missing dependencies
+                if service_name == "mcp-ticketer":
+                    if self._check_and_fix_mcp_ticketer_dependencies():
+                        fixed_services.append(f"{service_name} (dependency fixed)")
+                    else:
+                        failed_services.append(f"{service_name} (dependency fix failed)")
+                else:
+                    failed_services.append(f"{service_name} (unknown dependency issue)")
+
+            elif issue_type == "path_issue":
+                # Path issues are handled by config updates
+                self.logger.info(f"  Path issue for {service_name} will be fixed by config update")
+                fixed_services.append(f"{service_name} (config updated)")
+
+        # Build result message
+        messages = []
+        if fixed_services:
+            messages.append(f"✅ Fixed: {', '.join(fixed_services)}")
+        if failed_services:
+            messages.append(f"❌ Failed: {', '.join(failed_services)}")
+
+        # Return success if at least some services were fixed
+        success = len(fixed_services) > 0 or len(failed_services) == 0
+        message = " | ".join(messages) if messages else "No services needed fixing"
+
+        # Provide manual fix instructions if auto-fix failed
+        if failed_services:
+            message += "\n\n💡 Manual fix instructions:"
+            for failed in failed_services:
+                service = failed.split(" ")[0]
+                message += f"\n  • {service}: pipx uninstall {service} && pipx install {service}"
+
+        return success, message
+
+    def _detect_service_issue(self, service_name: str) -> Optional[str]:
+        """
+        Detect what type of issue a service has.
+
+        Returns:
+            Issue type: 'not_installed', 'import_error', 'missing_dependency', 'path_issue', or None
+        """
+        import shutil
+
+        # First check if pipx is available
+        if not shutil.which("pipx"):
+            return "not_installed"  # Can't use pipx services without pipx
+
+        # Try to run the service with --help to detect issues
+        try:
+            # Test with pipx run
+            result = subprocess.run(
+                ["pipx", "run", service_name, "--help"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False
+            )
+
+            # Check for specific error patterns
+            stderr_lower = result.stderr.lower()
+            stdout_lower = result.stdout.lower()
+            combined_output = stderr_lower + stdout_lower
+
+            # Not installed
+            if "no apps associated" in combined_output or "not found" in combined_output:
+                return "not_installed"
+
+            # Import errors (like mcp-ticketer's corrupted state)
+            if "modulenotfounderror" in combined_output or "importerror" in combined_output:
+                # Check if it's specifically the gql dependency for mcp-ticketer
+                if service_name == "mcp-ticketer" and "gql" in combined_output:
+                    return "missing_dependency"
+                return "import_error"
+
+            # Path issues
+            if "no such file or directory" in combined_output:
+                return "path_issue"
+
+            # If help text appears, service is working
+            if "usage:" in combined_output or "help" in combined_output or result.returncode in [0, 1]:
+                return None  # Service is working
+
+            # Unknown issue
+            if result.returncode not in [0, 1]:
+                return "unknown_error"
+
+        except subprocess.TimeoutExpired:
+            # Timeout might mean service is actually working but waiting for input
+            return None
+        except Exception as e:
+            self.logger.debug(f"Error detecting issue for {service_name}: {e}")
+            return "unknown_error"
+
+        return None
+
+    def _reinstall_service(self, service_name: str) -> bool:
+        """
+        Reinstall a corrupted MCP service.
+
+        Args:
+            service_name: Name of the service to reinstall
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            self.logger.debug(f"Uninstalling {service_name}...")
+
+            # First uninstall the corrupted version
+            uninstall_result = subprocess.run(
+                ["pipx", "uninstall", service_name],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                check=False
+            )
+
+            # Don't check return code - uninstall might fail if partially corrupted
+            self.logger.debug(f"Uninstall result: {uninstall_result.returncode}")
+
+            # Now reinstall
+            self.logger.debug(f"Installing fresh {service_name}...")
+            install_result = subprocess.run(
+                ["pipx", "install", service_name],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False
+            )
+
+            if install_result.returncode == 0:
+                # Verify the reinstall worked
+                issue = self._detect_service_issue(service_name)
+                if issue is None:
+                    self.logger.info(f"✅ Successfully reinstalled {service_name}")
+                    return True
+                else:
+                    self.logger.warning(f"Reinstalled {service_name} but still has issue: {issue}")
+                    return False
+            else:
+                self.logger.error(f"Failed to reinstall {service_name}: {install_result.stderr}")
+                return False
+
+        except Exception as e:
+            self.logger.error(f"Error reinstalling {service_name}: {e}")
+            return False
+
     def _verify_service_installed(self, service_name: str, method: str) -> bool:
         """
         Verify that a service was successfully installed and is functional.
@@ -711,6 +1206,9 @@ class MCPConfigManager:
         # Give the installation a moment to settle
         time.sleep(1)
 
+        # Note: mcp-ticketer dependency fix is now handled once in ensure_mcp_services_configured()
+        # to avoid running the same pipx inject command multiple times
+
         # Check if we can find the service
         service_path = self.detect_service_path(service_name)
         if not service_path:
@@ -767,3 +1265,26 @@ class MCPConfigManager:
             self.logger.debug(f"Verification error for {service_name}: {e}")
 
         return False
+
+    def _get_fallback_config(self, service_name: str, project_path: str) -> Optional[Dict]:
+        """
+        Get a fallback configuration for a service if the primary config fails.
+
+        Args:
+            service_name: Name of the MCP service
+            project_path: Project path to use
+
+        Returns:
+            Fallback configuration or None
+        """
+        # Special fallback for mcp-vector-search using pipx run
+        if service_name == "mcp-vector-search":
+            return {
+                "type": "stdio",
+                "command": "pipx",
+                "args": ["run", "--spec", "mcp-vector-search", "python", "-m", "mcp_vector_search.mcp.server", project_path],
+                "env": {}
+            }
+
+        # For other services, try pipx run
+        return None