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

claude_mpm/services/mcp_config_manager.py

@@ -11,6 +11,7 @@ MCP service installations.
 
 import json
 import subprocess
+import sys
 from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
@@ -76,6 +77,7 @@ class MCPConfigManager:
 
             # Check system PATH (including homebrew)
             import shutil
+
             system_path = shutil.which(service_name)
             if system_path and system_path not in candidates:
                 candidates.append(system_path)
@@ -84,14 +86,13 @@ class MCPConfigManager:
             for path in candidates:
                 try:
                     result = subprocess.run(
-                        [path, "--help"],
-                        capture_output=True,
-                        text=True,
-                        timeout=5
+                        [path, "--help"], capture_output=True, text=True, timeout=5, check=False
                     )
                     # Check if this version has MCP support
                     if "claude" in result.stdout or "mcp" in result.stdout:
-                        self.logger.debug(f"Found kuzu-memory with MCP support at {path}")
+                        self.logger.debug(
+                            f"Found kuzu-memory with MCP support at {path}"
+                        )
                         return path
                 except:
                     pass
@@ -125,7 +126,9 @@ class MCPConfigManager:
             )
             return local_path
 
-        self.logger.debug(f"Service {service_name} not found - will auto-install when needed")
+        self.logger.debug(
+            f"Service {service_name} not found - will auto-install when needed"
+        )
         return None
 
     def _check_pipx_installation(self, service_name: str) -> Optional[str]:
@@ -192,58 +195,161 @@ class MCPConfigManager:
         """
         Generate configuration for a specific MCP service.
 
+        Prefers 'pipx run' or 'uvx' commands over direct execution for better isolation.
+
         Args:
             service_name: Name of the MCP service
 
         Returns:
             Service configuration dict or None if service not found
         """
-        service_path = self.detect_service_path(service_name)
-        if not service_path:
-            return None
+        import shutil
+
+        # Check for pipx run first (preferred for isolation)
+        use_pipx_run = False
+        use_uvx = False
+
+        # Try pipx run test
+        if shutil.which("pipx"):
+            try:
+                result = subprocess.run(
+                    ["pipx", "run", service_name, "--version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                    check=False,
+                )
+                if result.returncode == 0 or "version" in result.stdout.lower():
+                    use_pipx_run = True
+                    self.logger.debug(f"Will use 'pipx run' for {service_name}")
+            except:
+                pass
+
+        # Try uvx if pipx run not available
+        if not use_pipx_run and shutil.which("uvx"):
+            try:
+                result = subprocess.run(
+                    ["uvx", service_name, "--version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                    check=False,
+                )
+                if result.returncode == 0 or "version" in result.stdout.lower():
+                    use_uvx = True
+                    self.logger.debug(f"Will use 'uvx' for {service_name}")
+            except:
+                pass
 
-        config = {
-            "type": "stdio",
-            "command": service_path,
-        }
+        # If neither work, try to find direct path
+        service_path = None
+        if not use_pipx_run and not use_uvx:
+            service_path = self.detect_service_path(service_name)
+            if not service_path:
+                return None
+
+        # Build configuration
+        config = {"type": "stdio"}
 
         # Service-specific configurations
         if service_name == "mcp-vector-search":
-            config["args"] = [
-                "-m",
-                "mcp_vector_search.mcp.server",
-                str(self.project_root),
-            ]
+            if use_pipx_run:
+                config["command"] = "pipx"
+                config["args"] = [
+                    "run",
+                    "mcp-vector-search",
+                    "-m",
+                    "mcp_vector_search.mcp.server",
+                    str(self.project_root),
+                ]
+            elif use_uvx:
+                config["command"] = "uvx"
+                config["args"] = [
+                    "mcp-vector-search",
+                    "-m",
+                    "mcp_vector_search.mcp.server",
+                    str(self.project_root),
+                ]
+            else:
+                config["command"] = service_path
+                config["args"] = [
+                    "-m",
+                    "mcp_vector_search.mcp.server",
+                    str(self.project_root),
+                ]
             config["env"] = {}
+
         elif service_name == "mcp-browser":
-            config["args"] = ["mcp"]
+            if use_pipx_run:
+                config["command"] = "pipx"
+                config["args"] = ["run", "mcp-browser", "mcp"]
+            elif use_uvx:
+                config["command"] = "uvx"
+                config["args"] = ["mcp-browser", "mcp"]
+            else:
+                config["command"] = service_path
+                config["args"] = ["mcp"]
             config["env"] = {"MCP_BROWSER_HOME": str(Path.home() / ".mcp-browser")}
+
         elif service_name == "mcp-ticketer":
-            config["args"] = ["mcp"]
+            if use_pipx_run:
+                config["command"] = "pipx"
+                config["args"] = ["run", "mcp-ticketer", "mcp"]
+            elif use_uvx:
+                config["command"] = "uvx"
+                config["args"] = ["mcp-ticketer", "mcp"]
+            else:
+                config["command"] = service_path
+                config["args"] = ["mcp"]
+
         elif service_name == "kuzu-memory":
-            # Check kuzu-memory version to determine correct command
-            # v1.1.0+ has "claude mcp-server", v1.0.0 has "serve"
-            import subprocess
-            try:
-                result = subprocess.run(
-                    [service_path, "--help"],
-                    capture_output=True,
-                    text=True,
-                    timeout=10
-                )
-                if "claude" in result.stdout:
-                    # v1.1.0+ with claude command
-                    config["args"] = ["claude", "mcp-server"]
-                else:
-                    # v1.0.0 with serve command
-                    config["args"] = ["serve"]
-            except:
-                # Default to older version command
-                config["args"] = ["serve"]
-            # kuzu-memory works with project-specific databases, no custom path needed
+            # Determine kuzu-memory command version
+            kuzu_args = []
+            test_cmd = None
+
+            if use_pipx_run:
+                test_cmd = ["pipx", "run", "kuzu-memory", "--help"]
+            elif use_uvx:
+                test_cmd = ["uvx", "kuzu-memory", "--help"]
+            elif service_path:
+                test_cmd = [service_path, "--help"]
+
+            if test_cmd:
+                try:
+                    result = subprocess.run(
+                        test_cmd, capture_output=True, text=True, timeout=10, check=False
+                    )
+                    if "claude" in result.stdout:
+                        # v1.1.0+ with claude command
+                        kuzu_args = ["claude", "mcp-server"]
+                    else:
+                        # v1.0.0 with serve command
+                        kuzu_args = ["serve"]
+                except:
+                    # Default to newer version command
+                    kuzu_args = ["claude", "mcp-server"]
+
+            if use_pipx_run:
+                config["command"] = "pipx"
+                config["args"] = ["run", "kuzu-memory"] + kuzu_args
+            elif use_uvx:
+                config["command"] = "uvx"
+                config["args"] = ["kuzu-memory"] + kuzu_args
+            else:
+                config["command"] = service_path
+                config["args"] = kuzu_args
+
         else:
             # Generic config for unknown services
-            config["args"] = []
+            if use_pipx_run:
+                config["command"] = "pipx"
+                config["args"] = ["run", service_name]
+            elif use_uvx:
+                config["command"] = "uvx"
+                config["args"] = [service_name]
+            else:
+                config["command"] = service_path
+                config["args"] = []
 
         return config
 
@@ -464,7 +570,7 @@ class MCPConfigManager:
 
     def install_missing_services(self) -> Tuple[bool, str]:
         """
-        Install missing MCP services via pipx.
+        Install missing MCP services via pipx with verification and fallbacks.
 
         Returns:
             Tuple of (success, message)
@@ -481,22 +587,163 @@ class MCPConfigManager:
         failed = []
 
         for service_name in missing:
-            try:
-                self.logger.info(f"Installing {service_name} via pipx...")
-                subprocess.run(
-                    ["pipx", "install", service_name],
-                    capture_output=True,
-                    text=True,
-                    check=True,
-                )
-                installed.append(service_name)
-                self.logger.info(f"Successfully installed {service_name}")
-            except subprocess.CalledProcessError as e:
+            # Try pipx install first
+            success, method = self._install_service_with_fallback(service_name)
+            if success:
+                installed.append(f"{service_name} ({method})")
+                self.logger.info(f"Successfully installed {service_name} via {method}")
+            else:
                 failed.append(service_name)
-                self.logger.error(f"Failed to install {service_name}: {e.stderr}")
+                self.logger.error(f"Failed to install {service_name}")
 
         if failed:
             return False, f"Failed to install: {', '.join(failed)}"
         if installed:
             return True, f"Successfully installed: {', '.join(installed)}"
         return True, "No services needed installation"
+
+    def _install_service_with_fallback(self, service_name: str) -> Tuple[bool, str]:
+        """
+        Install a service with multiple fallback methods.
+
+        Returns:
+            Tuple of (success, installation_method)
+        """
+        import shutil
+
+        # Method 1: Try pipx install
+        if shutil.which("pipx"):
+            try:
+                self.logger.debug(f"Attempting to install {service_name} via pipx...")
+                result = subprocess.run(
+                    ["pipx", "install", service_name],
+                    capture_output=True,
+                    text=True,
+                    timeout=120,  # 2 minute timeout
+                    check=False,
+                )
+
+                if result.returncode == 0:
+                    # Verify installation worked
+                    if self._verify_service_installed(service_name, "pipx"):
+                        return True, "pipx"
+
+                    self.logger.warning(
+                        f"pipx install succeeded but verification failed for {service_name}"
+                    )
+                else:
+                    self.logger.debug(
+                        f"pipx install failed: {result.stderr}"
+                    )
+            except subprocess.TimeoutExpired:
+                self.logger.warning(f"pipx install timed out for {service_name}")
+            except Exception as e:
+                self.logger.debug(f"pipx install error: {e}")
+
+        # Method 2: Try uvx (if available)
+        if shutil.which("uvx"):
+            try:
+                self.logger.debug(f"Attempting to install {service_name} via uvx...")
+                result = subprocess.run(
+                    ["uvx", "install", service_name],
+                    capture_output=True,
+                    text=True,
+                    timeout=120,
+                    check=False,
+                )
+
+                if result.returncode == 0:
+                    if self._verify_service_installed(service_name, "uvx"):
+                        return True, "uvx"
+            except Exception as e:
+                self.logger.debug(f"uvx install error: {e}")
+
+        # Method 3: Try pip install --user
+        try:
+            self.logger.debug(f"Attempting to install {service_name} via pip --user...")
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--user", service_name],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                if self._verify_service_installed(service_name, "pip"):
+                    return True, "pip --user"
+
+                self.logger.warning(
+                    f"pip install succeeded but verification failed for {service_name}"
+                )
+        except Exception as e:
+            self.logger.debug(f"pip install error: {e}")
+
+        return False, "none"
+
+    def _verify_service_installed(self, service_name: str, method: str) -> bool:
+        """
+        Verify that a service was successfully installed and is functional.
+
+        Args:
+            service_name: Name of the service
+            method: Installation method used
+
+        Returns:
+            True if service is installed and functional
+        """
+        import time
+
+        # Give the installation a moment to settle
+        time.sleep(1)
+
+        # Check if we can find the service
+        service_path = self.detect_service_path(service_name)
+        if not service_path:
+            # Try pipx run as fallback for pipx installations
+            if method == "pipx":
+                try:
+                    result = subprocess.run(
+                        ["pipx", "run", service_name, "--version"],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
+                        check=False,
+                    )
+                    if result.returncode == 0 or "version" in result.stdout.lower():
+                        self.logger.debug(f"{service_name} accessible via 'pipx run'")
+                        return True
+                except:
+                    pass
+            return False
+
+        # Try to verify it works
+        try:
+            # Different services may need different verification
+            test_commands = [
+                [service_path, "--version"],
+                [service_path, "--help"],
+            ]
+
+            for cmd in test_commands:
+                result = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                    check=False,
+                )
+
+                output = (result.stdout + result.stderr).lower()
+                # Check for signs of success
+                if result.returncode == 0:
+                    return True
+                # Some tools return non-zero but still work
+                elif any(indicator in output for indicator in ["version", "usage", "help", service_name.lower()]):
+                    # Make sure it's not an error message
+                    if not any(error in output for error in ["error", "not found", "traceback", "no such"]):
+                        return True
+        except Exception as e:
+            self.logger.debug(f"Verification error for {service_name}: {e}")
+
+        return False

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -395,6 +395,7 @@ async def auto_initialize_vector_search():
     try:
         # Import MCPConfigManager to handle installation
         from claude_mpm.services.mcp_config_manager import MCPConfigManager
+
         config_manager = MCPConfigManager()
 
         # Check if mcp-vector-search is already installed
@@ -411,7 +412,9 @@ async def auto_initialize_vector_search():
             import subprocess
 
             if not shutil.which("pipx"):
-                logger.warning("⚠️ pipx not found. Please install pipx to enable automatic mcp-vector-search installation")
+                logger.warning(
+                    "⚠️ pipx not found. Please install pipx to enable automatic mcp-vector-search installation"
+                )
                 logger.info("   Install pipx with: python -m pip install --user pipx")
                 return
 
@@ -420,26 +423,34 @@ async def auto_initialize_vector_search():
                     ["pipx", "install", "mcp-vector-search"],
                     capture_output=True,
                     text=True,
-                    timeout=60  # 1 minute timeout for installation
+                    timeout=60, check=False,  # 1 minute timeout for installation
                 )
 
                 if result.returncode == 0:
                     logger.info("✅ mcp-vector-search installed successfully")
                     # Detect the newly installed path
-                    vector_search_path = config_manager.detect_service_path("mcp-vector-search")
+                    vector_search_path = config_manager.detect_service_path(
+                        "mcp-vector-search"
+                    )
                     if not vector_search_path:
-                        logger.warning("mcp-vector-search installed but command not found in PATH")
+                        logger.warning(
+                            "mcp-vector-search installed but command not found in PATH"
+                        )
                         return
 
                     # Update the Claude configuration to include the newly installed service
                     logger.info("📝 Updating Claude configuration...")
-                    config_success, config_msg = config_manager.ensure_mcp_services_configured()
+                    config_success, config_msg = (
+                        config_manager.ensure_mcp_services_configured()
+                    )
                     if config_success:
                         logger.info(f"✅ {config_msg}")
                     else:
                         logger.warning(f"⚠️ Configuration update issue: {config_msg}")
                 else:
-                    logger.warning(f"Failed to install mcp-vector-search: {result.stderr}")
+                    logger.warning(
+                        f"Failed to install mcp-vector-search: {result.stderr}"
+                    )
                     return
 
             except subprocess.TimeoutExpired:
@@ -452,10 +463,14 @@ async def auto_initialize_vector_search():
         # At this point, mcp-vector-search should be available
         # Get the actual command to use
         import shutil
+
         vector_search_cmd = shutil.which("mcp-vector-search")
         if not vector_search_cmd:
             # Try pipx installation path as fallback
-            pipx_path = Path.home() / ".local/pipx/venvs/mcp-vector-search/bin/mcp-vector-search"
+            pipx_path = (
+                Path.home()
+                / ".local/pipx/venvs/mcp-vector-search/bin/mcp-vector-search"
+            )
             if pipx_path.exists():
                 vector_search_cmd = str(pipx_path)
             else:
@@ -477,10 +492,13 @@ async def auto_initialize_vector_search():
                     if chroma_db.exists() and chroma_db.stat().st_size > 0:
                         logger.info("✓ Vector search index is healthy and ready")
                         return
-                    else:
-                        logger.info("⚠️ Vector search index may be corrupted, rebuilding...")
+                    logger.info(
+                        "⚠️ Vector search index may be corrupted, rebuilding..."
+                    )
                 except Exception as e:
-                    logger.debug(f"Vector search health check failed: {e}, will attempt to rebuild")
+                    logger.debug(
+                        f"Vector search health check failed: {e}, will attempt to rebuild"
+                    )
 
         # Initialize or reinitialize the project
         logger.info(f"🎯 Initializing vector search for project: {current_dir}")
@@ -488,12 +506,13 @@ async def auto_initialize_vector_search():
         # Initialize the project (this creates the config)
         # Note: mcp-vector-search operates on the current directory
         import subprocess
+
         proc = subprocess.run(
             [vector_search_cmd, "init"],
             capture_output=True,
             text=True,
             timeout=30,
-            cwd=str(current_dir)  # Run in the project directory
+            cwd=str(current_dir), check=False,  # Run in the project directory
         )
 
         if proc.returncode == 0:
@@ -508,29 +527,36 @@ async def auto_initialize_vector_search():
                         capture_output=True,
                         text=True,
                         timeout=300,  # 5 minute timeout for indexing
-                        cwd=str(current_dir)  # Run in the project directory
+                        cwd=str(current_dir), check=False,  # Run in the project directory
                     )
                     if index_proc.returncode == 0:
                         logger.info("✅ Project indexing completed successfully")
                         # Parse output to show statistics if available
                         if "indexed" in index_proc.stdout.lower():
                             # Extract and log indexing statistics
-                            lines = index_proc.stdout.strip().split('\n')
+                            lines = index_proc.stdout.strip().split("\n")
                             for line in lines:
                                 if "indexed" in line.lower() or "files" in line.lower():
                                     logger.info(f"   {line.strip()}")
                     else:
-                        logger.warning(f"⚠️ Project indexing failed: {index_proc.stderr}")
+                        logger.warning(
+                            f"⚠️ Project indexing failed: {index_proc.stderr}"
+                        )
                 except subprocess.TimeoutExpired:
-                    logger.warning("⚠️ Project indexing timed out (will continue in background)")
+                    logger.warning(
+                        "⚠️ Project indexing timed out (will continue in background)"
+                    )
                 except Exception as e:
                     logger.debug(f"Background indexing error (non-critical): {e}")
 
             # Run indexing in background thread
             import threading
+
             index_thread = threading.Thread(target=background_index, daemon=True)
             index_thread.start()
-            logger.info("📚 Background indexing started - vector search will be available shortly")
+            logger.info(
+                "📚 Background indexing started - vector search will be available shortly"
+            )
 
         else:
             logger.warning(f"⚠️ Vector search initialization failed: {proc.stderr}")
@@ -556,6 +582,7 @@ async def auto_initialize_kuzu_memory():
     try:
         # Import MCPConfigManager to handle installation
         from claude_mpm.services.mcp_config_manager import MCPConfigManager
+
         config_manager = MCPConfigManager()
 
         # Check if kuzu-memory is already installed
@@ -572,7 +599,9 @@ async def auto_initialize_kuzu_memory():
             import subprocess
 
             if not shutil.which("pipx"):
-                logger.warning("⚠️ pipx not found. Please install pipx to enable automatic kuzu-memory installation")
+                logger.warning(
+                    "⚠️ pipx not found. Please install pipx to enable automatic kuzu-memory installation"
+                )
                 logger.info("   Install pipx with: python -m pip install --user pipx")
                 return
 
@@ -581,7 +610,7 @@ async def auto_initialize_kuzu_memory():
                     ["pipx", "install", "kuzu-memory"],
                     capture_output=True,
                     text=True,
-                    timeout=60  # 1 minute timeout for installation
+                    timeout=60, check=False,  # 1 minute timeout for installation
                 )
 
                 if result.returncode == 0:
@@ -589,12 +618,16 @@ async def auto_initialize_kuzu_memory():
                     # Detect the newly installed path
                     kuzu_memory_path = config_manager.detect_service_path("kuzu-memory")
                     if not kuzu_memory_path:
-                        logger.warning("kuzu-memory installed but command not found in PATH")
+                        logger.warning(
+                            "kuzu-memory installed but command not found in PATH"
+                        )
                         return
 
                     # Update the Claude configuration to include the newly installed service
                     logger.info("📝 Updating Claude configuration...")
-                    config_success, config_msg = config_manager.ensure_mcp_services_configured()
+                    config_success, config_msg = (
+                        config_manager.ensure_mcp_services_configured()
+                    )
                     if config_success:
                         logger.info(f"✅ {config_msg}")
                     else:
@@ -613,6 +646,7 @@ async def auto_initialize_kuzu_memory():
         # At this point, kuzu-memory should be available
         # Get the actual command to use
         import shutil
+
         kuzu_memory_cmd = shutil.which("kuzu-memory")
         if not kuzu_memory_cmd:
             # Try pipx installation path as fallback
@@ -629,18 +663,23 @@ async def auto_initialize_kuzu_memory():
 
         # Check if database is already initialized
         if kuzu_memories_dir.exists():
-            logger.debug(f"Kuzu-memory database already initialized at {kuzu_memories_dir}")
+            logger.debug(
+                f"Kuzu-memory database already initialized at {kuzu_memories_dir}"
+            )
         else:
-            logger.info(f"🎯 Initializing kuzu-memory database for project: {current_dir}")
+            logger.info(
+                f"🎯 Initializing kuzu-memory database for project: {current_dir}"
+            )
 
             # Initialize the database in current project directory
             import subprocess
+
             proc = subprocess.run(
                 [kuzu_memory_cmd, "init"],
                 capture_output=True,
                 text=True,
                 timeout=30,
-                cwd=str(current_dir),
+                cwd=str(current_dir), check=False,
             )
 
             if proc.returncode == 0:

claude_mpm/services/mcp_gateway/tools/__init__.py

@@ -14,11 +14,12 @@ from .base_adapter import (
 from .document_summarizer import DocumentSummarizerTool
 from .kuzu_memory_service import (
     KuzuMemoryService,
-    store_memory,
+    get_context,
     recall_memories,
     search_memories,
-    get_context,
+    store_memory,
 )
+
 # Ticket tools removed - using mcp-ticketer instead
 
 __all__ = [
@@ -26,10 +27,10 @@ __all__ = [
     "CalculatorToolAdapter",
     "DocumentSummarizerTool",
     "EchoToolAdapter",
-    "SystemInfoToolAdapter",
     "KuzuMemoryService",
-    "store_memory",
+    "SystemInfoToolAdapter",
+    "get_context",
     "recall_memories",
     "search_memories",
-    "get_context",
+    "store_memory",
 ]