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

claude_mpm/services/mcp_config_manager.py

@@ -12,7 +12,6 @@ MCP service installations.
 import json
 import subprocess
 import sys
-from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Dict, Optional, Tuple
@@ -698,175 +697,106 @@ class MCPConfigManager:
 
         return config
 
-    def ensure_mcp_services_configured(self) -> Tuple[bool, str]:
+    def check_mcp_services_available(self) -> Tuple[bool, str]:
         """
-        Ensure MCP services are configured correctly in ~/.claude.json on startup.
+        Check if required MCP services are available in ~/.claude.json (READ-ONLY).
 
-        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
+        This method performs a READ-ONLY check of MCP service availability.
+        It does NOT modify ~/.claude.json. Users should install and configure
+        MCP services themselves via pip, npx, or Claude Desktop.
 
         Returns:
-            Tuple of (success, message)
+            Tuple of (all_available: bool, message: str)
         """
-        updated = False
-        fixed_services = []
-        added_services = []
-
-        # Load existing Claude config or create minimal structure
-        claude_config = {}
-        if self.claude_config_path.exists():
-            try:
-                with self.claude_config_path.open() as f:
-                    claude_config = json.load(f)
-            except Exception as e:
-                self.logger.error(f"Error reading {self.claude_config_path}: {e}")
-                return False, f"Failed to read Claude config: {e}"
+        # Get services Claude MPM expects to use (from ~/.claude-mpm/config/)
+        expected_services = self.get_filtered_services()
 
-        # Ensure projects structure exists
-        if "projects" not in claude_config:
-            claude_config["projects"] = {}
-            updated = True
+        if not expected_services:
+            return True, "No MCP services configured in Claude MPM"
 
-        # Note: fix_mcp_service_issues() is already called during CLI initialization
-        # Calling it here would duplicate the service health checks
+        # Load Claude config (read-only)
+        if not self.claude_config_path.exists():
+            return False, f"Claude config not found at {self.claude_config_path}"
 
-        # Process ALL projects in the config, not just current one
-        projects_to_update = list(claude_config.get("projects", {}).keys())
+        try:
+            with self.claude_config_path.open() as f:
+                claude_config = json.load(f)
+        except Exception as e:
+            return False, f"Failed to read Claude config: {e}"
 
-        # Also add the current project if not in list
+        # Check current project
         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": [],
-                "mcpServers": {},
-                "enabledMcpjsonServers": [],
-                "disabledMcpjsonServers": [],
-                "hasTrustDialogAccepted": False,
-                "projectOnboardingSeenCount": 0,
-                "hasClaudeMdExternalIncludesApproved": False,
-                "hasClaudeMdExternalIncludesWarningShown": False,
-            }
-            updated = True
-
-        # 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 - now filtered by startup config
-            services_to_configure = self.get_filtered_services()
-
-            for service_name, correct_config in services_to_configure.items():
-                # 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}")
-                # Service exists, check if configuration is correct
-                # Compare command and args (the most critical parts)
-                elif 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"Updated MCP service config for {service_name} in project {Path(project_key).name}"
-                    )
+        project_config = claude_config.get("projects", {}).get(current_project_key)
 
-            # Remove disabled services from configuration
-            if self.config is not None:
-                # Import Config here to avoid circular import
-                from ..core.config import Config
+        if not project_config:
+            missing = list(expected_services.keys())
+            return (
+                False,
+                f"Current project not configured in Claude. Missing services: {', '.join(missing)}",
+            )
 
-                if isinstance(self.config, Config):
-                    enabled_services = self.config.get(
-                        "startup.enabled_mcp_services", None
-                    )
-                    if enabled_services is not None:
-                        # Remove services that are not in the enabled list
-                        services_to_remove = []
-                        for service_name in project_config["mcpServers"]:
-                            if service_name not in enabled_services:
-                                services_to_remove.append(service_name)
-
-                        for service_name in services_to_remove:
-                            del project_config["mcpServers"][service_name]
-                            updated = True
-                            self.logger.debug(
-                                f"Removed disabled service {service_name} from project {Path(project_key).name}"
-                            )
-
-        # Write updated config if changes were made
-        if updated:
-            try:
-                # Create backup if file exists and is large (> 100KB)
-                if self.claude_config_path.exists():
-                    file_size = self.claude_config_path.stat().st_size
-                    if file_size > 100000:  # 100KB
-                        backup_path = self.claude_config_path.with_suffix(
-                            f".backup.{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
-                        )
-                        import shutil
+        # Check which services are missing
+        mcp_servers = project_config.get("mcpServers", {})
+        missing_services = [
+            name for name in expected_services if name not in mcp_servers
+        ]
 
-                        shutil.copy2(self.claude_config_path, backup_path)
-                        self.logger.debug(f"Created backup: {backup_path}")
+        if missing_services:
+            msg = (
+                f"Missing MCP services: {', '.join(missing_services)}. "
+                f"Install via: pip install {' '.join(missing_services)} "
+                f"or configure in Claude Desktop"
+            )
+            return False, msg
 
-                # Write updated config
-                with self.claude_config_path.open("w") as f:
-                    json.dump(claude_config, f, indent=2)
+        return (
+            True,
+            f"All required MCP services available ({len(expected_services)} services)",
+        )
 
-                messages = []
-                if added_services:
-                    messages.append(
-                        f"Added MCP services: {', '.join(added_services[:3])}"
-                    )
-                if fixed_services:
-                    messages.append(
-                        f"Fixed MCP services: {', '.join(fixed_services[:3])}"
-                    )
+    def ensure_mcp_services_configured(self) -> Tuple[bool, str]:
+        """
+        DEPRECATED: Auto-configuring ~/.claude.json is no longer supported.
 
-                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}"
+        As of v4.15.0+, MCP services are user-controlled. Users should install
+        and configure MCP services themselves via:
+        - pip install <service-name>
+        - npx @modelcontextprotocol/...
+        - Claude Desktop UI
 
-        return True, "All MCP services already configured correctly"
+        This method now only performs a read-only check and logs a deprecation warning.
+        Use check_mcp_services_available() for read-only checks.
+
+        Returns:
+            Tuple of (success, message)
+        """
+        import warnings
+
+        warnings.warn(
+            "ensure_mcp_services_configured() is deprecated and will be removed in v6.0.0. "
+            "MCP services are now user-controlled. Use check_mcp_services_available() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        # Delegate to read-only check
+        return self.check_mcp_services_available()
 
     def update_mcp_config(self, force_pipx: bool = True) -> Tuple[bool, str]:
         """
-        Update the MCP configuration in ~/.claude.json.
+        DEPRECATED: Check MCP configuration in ~/.claude.json (READ-ONLY).
+
+        This method no longer modifies ~/.claude.json. Users should install
+        and configure MCP services themselves.
 
         Args:
-            force_pipx: If True, only use pipx installations
+            force_pipx: Ignored (kept for backward compatibility)
 
         Returns:
-            Tuple of (success, message)
+            Tuple of (success, message) from read-only check
         """
-        # This method now delegates to ensure_mcp_services_configured
-        # since we're updating the Claude config directly
-        return self.ensure_mcp_services_configured()
+        # Delegate to read-only check
+        return self.check_mcp_services_available()
 
     def update_project_mcp_config(self, force_pipx: bool = True) -> Tuple[bool, str]:
         """

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -215,7 +215,7 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                     current[part] = {}
                 elif not isinstance(current[part], dict):
                     self.log_warning(
-                        f"Cannot override non-dict config at {'.'.join(config_path[:i+1])}"
+                        f"Cannot override non-dict config at {'.'.join(config_path[: i + 1])}"
                     )
                     break
                 current = current[part]

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -440,15 +440,18 @@ async def auto_initialize_vector_search():
                         )
                         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()
-                    )
-                    if config_success:
-                        logger.info(f"✅ {config_msg}")
+                    # Verify the newly installed service is available
+                    logger.info("📝 Verifying installation...")
+                    available, msg = config_manager.check_mcp_services_available()
+                    if available:
+                        logger.info(f"✅ {msg}")
                     else:
-                        logger.warning(f"⚠️ Configuration update issue: {config_msg}")
+                        logger.warning(
+                            f"⚠️ Service installed but not configured in Claude: {msg}"
+                        )
+                        logger.info(
+                            "💡 Configure via: Claude Desktop > Settings > Developer > Model Context Protocol"
+                        )
                 else:
                     logger.warning(
                         f"Failed to install mcp-vector-search: {result.stderr}"
@@ -658,15 +661,18 @@ async def auto_initialize_kuzu_memory():
                         )
                         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()
-                    )
-                    if config_success:
-                        logger.info(f"✅ {config_msg}")
+                    # Verify the newly installed service is available
+                    logger.info("📝 Verifying installation...")
+                    available, msg = config_manager.check_mcp_services_available()
+                    if available:
+                        logger.info(f"✅ {msg}")
                     else:
-                        logger.warning(f"⚠️ Configuration update issue: {config_msg}")
+                        logger.warning(
+                            f"⚠️ Service installed but not configured in Claude: {msg}"
+                        )
+                        logger.info(
+                            "💡 Configure via: Claude Desktop > Settings > Developer > Model Context Protocol"
+                        )
                 else:
                     logger.warning(f"Failed to install kuzu-memory: {result.stderr}")
                     return

claude_mpm/services/mcp_gateway/server/mcp_gateway.py

@@ -21,12 +21,7 @@ from typing import Any, Callable, Dict, List, Optional, Union
 
 # Import from the official MCP package
 from mcp.server import Server
-from mcp.types import (
-    EmbeddedResource,
-    ImageContent,
-    TextContent,
-    Tool,
-)
+from mcp.types import EmbeddedResource, ImageContent, TextContent, Tool
 
 from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
 from claude_mpm.services.mcp_gateway.core.interfaces import (

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -65,7 +65,6 @@ def apply_backward_compatibility_patches():
                         and hasattr(request, "params")
                         and request.params is not None
                     ):
-
                         # Convert params to dict to check for clientInfo
                         params_dict = request.params
                         if hasattr(params_dict, "model_dump"):
@@ -542,7 +541,6 @@ class SimpleMCPServer:
 
                         result = f"Python: {sys.version}"
                     elif info_type == "cwd":
-
                         result = f"Working Directory: {Path.cwd()}"
                     elif info_type == "all":
                         import datetime

claude_mpm/services/mcp_gateway/tools/kuzu_memory_service.py

@@ -199,7 +199,9 @@ class KuzuMemoryService(BaseToolAdapter):
         try:
             if action == "store":
                 result = await self.store_memory(
-                    params.get("content"), params.get("tags"), {}  # metadata
+                    params.get("content"),
+                    params.get("tags"),
+                    {},  # metadata
                 )
             elif action == "recall":
                 result = await self.recall_memories(
@@ -213,7 +215,9 @@ class KuzuMemoryService(BaseToolAdapter):
                 )
             elif action == "context":
                 result = await self.get_context(
-                    params.get("query", ""), 2, True  # depth  # include_related
+                    params.get("query", ""),
+                    2,
+                    True,  # depth  # include_related
                 )
             else:
                 return MCPToolResult(success=False, error=f"Unknown action: {action}")

claude_mpm/services/mcp_service_verifier.py

@@ -620,12 +620,15 @@ class MCPServiceVerifier:
                 return True
 
             if "claude-mpm configure" in diagnostic.fix_command:
-                # Trigger configuration update
+                # Check if services are available (read-only)
                 from .mcp_config_manager import MCPConfigManager
 
                 manager = MCPConfigManager()
-                success, _ = manager.ensure_mcp_services_configured()
-                return success
+                available, message = manager.check_mcp_services_available()
+                if not available:
+                    # Cannot auto-fix - user must install services manually
+                    self.logger.warning(f"Cannot auto-fix: {message}")
+                return available
 
         except Exception as e:
             self.logger.error(f"Auto-fix failed for {service_name}: {e}")

claude_mpm/services/model/model_router.py

@@ -356,8 +356,7 @@ class ModelRouter(BaseService, IModelRouter):
         if require_success and not await self.ollama_provider.is_available():
             if self.strategy == RoutingStrategy.PRIVACY_FIRST:
                 error_msg = (
-                    "Ollama not available. Privacy mode enabled - "
-                    "not sending to cloud."
+                    "Ollama not available. Privacy mode enabled - not sending to cloud."
                 )
             else:
                 error_msg = "Ollama not available and required by configuration"

claude_mpm/services/monitor/daemon.py

@@ -88,11 +88,12 @@ class UnifiedMonitorDaemon:
         self.shutdown_event = threading.Event()
 
     def _get_default_pid_file(self) -> str:
-        """Get default PID file path."""
+        """Get default PID file path with port number to support multiple daemons."""
         project_root = Path.cwd()
         claude_mpm_dir = project_root / ".claude-mpm"
         claude_mpm_dir.mkdir(exist_ok=True)
-        return str(claude_mpm_dir / "monitor-daemon.pid")
+        # Include port in filename to support multiple daemon instances
+        return str(claude_mpm_dir / f"monitor-daemon-{self.port}.pid")
 
     def start(self, force_restart: bool = False) -> bool:
         """Start the unified monitor daemon.
@@ -145,16 +146,26 @@ class UnifiedMonitorDaemon:
         if self.daemon_manager.is_running():
             existing_pid = self.daemon_manager.get_pid()
             if not force_restart:
-                self.logger.warning(f"Daemon already running with PID {existing_pid}")
+                msg = f"Daemon already running on port {self.port} with PID {existing_pid}"
+                self.logger.warning(msg)
+                # If we're in subprocess mode, this is an error - we should have cleaned up
+                if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
+                    self.logger.error(
+                        f"SUBPROCESS ERROR: {msg} - This should not happen in subprocess mode!"
+                    )
                 return False
             # Force restart was already handled above
 
         # Check for our service on the port
         is_ours, pid = self.daemon_manager.is_our_service()
         if is_ours and pid and not force_restart:
-            self.logger.warning(
-                f"Our service already running on port {self.port} (PID: {pid})"
-            )
+            msg = f"Our service already running on port {self.port} (PID: {pid})"
+            self.logger.warning(msg)
+            # If we're in subprocess mode, this is an error - we should have cleaned up
+            if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
+                self.logger.error(
+                    f"SUBPROCESS ERROR: {msg} - This should not happen in subprocess mode!"
+                )
             return False
 
         # Use subprocess approach for clean daemon startup (v4.2.40)
@@ -169,20 +180,29 @@ class UnifiedMonitorDaemon:
         if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":
             # We're in a subprocess started by start_daemon_subprocess
             # We need to write the PID file ourselves since parent didn't
-            self.logger.info("Running in subprocess daemon mode, writing PID file")
+            self.logger.info(f"Running in subprocess daemon mode on port {self.port}")
+            self.logger.info(f"Subprocess PID: {os.getpid()}")
+            self.logger.info(f"PID file path: {self.daemon_manager.pid_file}")
             self.daemon_manager.write_pid_file()
+            self.logger.info("PID file written successfully")
 
             # Setup signal handlers for graceful shutdown
             self._setup_signal_handlers()
+            self.logger.info("Signal handlers configured")
 
             # Start the server (this will run until shutdown)
+            self.logger.info("Starting server in subprocess mode...")
             try:
                 result = self._run_server()
                 if not result:
                     self.logger.error("Failed to start server in subprocess mode")
+                    return result
+                self.logger.info("Server started successfully in subprocess mode")
                 return result
             except Exception as e:
-                self.logger.error(f"Server startup exception in subprocess: {e}")
+                self.logger.error(
+                    f"Server startup exception in subprocess: {e}", exc_info=True
+                )
                 raise
         else:
             # Legacy fork approach (kept for compatibility but not used by default)
@@ -479,7 +499,7 @@ class UnifiedMonitorDaemon:
             except OSError:
                 if i < 9:
                     self.logger.debug(
-                        f"Port {self.port} still in use, waiting... ({i+1}/10)"
+                        f"Port {self.port} still in use, waiting... ({i + 1}/10)"
                     )
                     time.sleep(1)
                 else:

claude_mpm/services/monitor/daemon_manager.py

@@ -80,18 +80,20 @@ class DaemonManager:
         self.startup_status_file = None
 
     def _get_default_pid_file(self) -> Path:
-        """Get default PID file path."""
+        """Get default PID file path with port number to support multiple daemons."""
         project_root = Path.cwd()
         claude_mpm_dir = project_root / ".claude-mpm"
         claude_mpm_dir.mkdir(exist_ok=True)
-        return claude_mpm_dir / "monitor-daemon.pid"
+        # Include port in filename to support multiple daemon instances
+        return claude_mpm_dir / f"monitor-daemon-{self.port}.pid"
 
     def _get_default_log_file(self) -> Path:
-        """Get default log file path."""
+        """Get default log file path with port number to support multiple daemons."""
         project_root = Path.cwd()
         claude_mpm_dir = project_root / ".claude-mpm"
         claude_mpm_dir.mkdir(exist_ok=True)
-        return claude_mpm_dir / "monitor-daemon.log"
+        # Include port in filename to support multiple daemon instances
+        return claude_mpm_dir / f"monitor-daemon-{self.port}.log"
 
     def cleanup_port_conflicts(self, max_retries: int = 3) -> bool:
         """Clean up any processes using the daemon port.
@@ -471,6 +473,55 @@ class DaemonManager:
 
         return None
 
+    def _verify_daemon_health(self, max_attempts: int = 3) -> bool:
+        """Verify daemon is healthy by checking HTTP health endpoint.
+
+        Args:
+            max_attempts: Maximum number of connection attempts
+
+        Returns:
+            True if health check passes, False otherwise
+        """
+        try:
+            import requests
+
+            for attempt in range(max_attempts):
+                try:
+                    # Try to connect to health endpoint
+                    response = requests.get(
+                        f"http://{self.host}:{self.port}/health", timeout=2
+                    )
+
+                    if response.status_code == 200:
+                        self.logger.debug(
+                            f"Health check passed on attempt {attempt + 1}/{max_attempts}"
+                        )
+                        return True
+
+                    self.logger.debug(
+                        f"Health check returned status {response.status_code} on attempt {attempt + 1}/{max_attempts}"
+                    )
+
+                except requests.exceptions.RequestException as e:
+                    self.logger.debug(
+                        f"Health check attempt {attempt + 1}/{max_attempts} failed: {e}"
+                    )
+
+                # Wait before retry (except on last attempt)
+                if attempt < max_attempts - 1:
+                    time.sleep(1)
+
+            self.logger.debug(f"Health check failed after {max_attempts} attempts")
+            return False
+
+        except ImportError:
+            # requests not available, skip health check
+            self.logger.debug("requests library not available, skipping health check")
+            return True
+        except Exception as e:
+            self.logger.debug(f"Health check error: {e}")
+            return False
+
     def start_daemon(self, force_restart: bool = False) -> bool:
         """Start the daemon with automatic cleanup and retry.
 
@@ -588,36 +639,62 @@ class DaemonManager:
                 pid = process.pid
                 self.logger.info(f"Monitor subprocess started with PID {pid}")
 
-                # Wait for the subprocess to write its PID file
+                # Wait for the subprocess to write its PID file and bind to port
                 # The subprocess will write the PID file after it starts successfully
                 max_wait = 10  # seconds
                 start_time = time.time()
+                pid_file_found = False
+                port_bound = False
+
+                self.logger.debug(f"Waiting up to {max_wait}s for daemon to start...")
 
                 while time.time() - start_time < max_wait:
                     # Check if process is still running
-                    if process.poll() is not None:
-                        # Process exited
+                    returncode = process.poll()
+                    if returncode is not None:
+                        # Process exited - this is the bug we're fixing!
+                        self.logger.error(
+                            f"Monitor daemon subprocess exited prematurely with code {returncode}"
+                        )
                         self.logger.error(
-                            f"Monitor daemon exited with code {process.returncode}"
+                            f"Port {self.port} daemon failed to start. Check {self.log_file} for details."
                         )
                         return False
 
                     # Check if PID file was written
-                    if self.pid_file.exists():
+                    if not pid_file_found and self.pid_file.exists():
                         try:
                             with self.pid_file.open() as f:
                                 written_pid = int(f.read().strip())
                             if written_pid == pid:
-                                # PID file written correctly, check port
-                                if (
-                                    not self._is_port_available()
-                                ):  # Port NOT available means it's in use (good!)
-                                    self.logger.info(
-                                        f"Monitor daemon successfully started on port {self.port}"
-                                    )
-                                    return True
-                        except Exception:
-                            pass  # PID file not ready yet
+                                pid_file_found = True
+                                self.logger.debug(
+                                    f"PID file found with correct PID {pid}"
+                                )
+                        except Exception as e:
+                            self.logger.debug(f"Error reading PID file: {e}")
+
+                    # Check if port is bound (health check)
+                    if not port_bound and not self._is_port_available():
+                        # Port NOT available means it's in use (good!)
+                        port_bound = True
+                        self.logger.debug(f"Port {self.port} is now bound")
+
+                    # Success criteria: both PID file exists and port is bound
+                    if pid_file_found and port_bound:
+                        self.logger.info(
+                            f"Monitor daemon successfully started on port {self.port} (PID: {pid})"
+                        )
+                        # Additional health check: verify we can connect
+                        if self._verify_daemon_health(max_attempts=3):
+                            self.logger.info("Daemon health check passed")
+                            return True
+                        self.logger.warning(
+                            "Daemon started but health check failed - may still be initializing"
+                        )
+                        return (
+                            True  # Return success anyway if PID file and port are good
+                        )
 
                     time.sleep(0.5)