claude-mpm 4.14.6__py3-none-any.whl → 4.21.0__py3-none-any.whl

claude_mpm/services/local_ops/state_manager.py

@@ -30,9 +30,10 @@ from typing import Dict, List, Optional
 import psutil
 from filelock import FileLock
 
+from claude_mpm.core.enums import ServiceState
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.interfaces.process import IDeploymentStateManager
-from claude_mpm.services.core.models.process import DeploymentState, ProcessStatus
+from claude_mpm.services.core.models.process import DeploymentState
 
 
 class StateCorruptionError(Exception):
@@ -206,12 +207,12 @@ class DeploymentStateManager(SyncBaseService, IDeploymentStateManager):
         states = self.load_state()
         return list(states.values())
 
-    def get_deployments_by_status(self, status: ProcessStatus) -> List[DeploymentState]:
+    def get_deployments_by_status(self, status: ServiceState) -> List[DeploymentState]:
         """
         Get all deployments with a specific status.
 
         Args:
-            status: ProcessStatus to filter by
+            status: ServiceState to filter by
 
         Returns:
             List of matching DeploymentState objects
@@ -295,14 +296,14 @@ class DeploymentStateManager(SyncBaseService, IDeploymentStateManager):
             return False
 
     def update_deployment_status(
-        self, deployment_id: str, status: ProcessStatus
+        self, deployment_id: str, status: ServiceState
     ) -> bool:
         """
         Update the status of a deployment.
 
         Args:
             deployment_id: Unique deployment identifier
-            status: New ProcessStatus
+            status: New ServiceState
 
         Returns:
             True if updated, False if deployment not found

claude_mpm/services/local_ops/unified_manager.py

@@ -45,12 +45,12 @@ from typing import Any, Dict, List, Optional
 
 import yaml
 
+from claude_mpm.core.enums import ServiceState
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.models.health import DeploymentHealth
 from claude_mpm.services.core.models.process import (
     DeploymentState,
     ProcessInfo,
-    ProcessStatus,
     StartConfig,
 )
 from claude_mpm.services.core.models.restart import RestartConfig, RestartHistory
@@ -384,7 +384,7 @@ class UnifiedLocalOpsManager(SyncBaseService):
 
     def list_deployments(
         self,
-        status_filter: Optional[ProcessStatus] = None,
+        status_filter: Optional[ServiceState] = None,
     ) -> List[DeploymentState]:
         """
         List all deployments.

claude_mpm/services/mcp_config_manager.py

@@ -1130,134 +1130,15 @@ class MCPConfigManager:
         """
         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
+        NOTE: Proactive health checking has been disabled.
+        Each MCP service should stand on its own and handle its own issues.
+        This function now only returns success without checking services.
 
         Returns:
             Tuple of (success, message)
         """
-        services_to_fix = []
-        fixed_services = []
-        failed_services = []
-
-        # Check each service for issues
-        for service_name in self.PIPX_SERVICES:
-            self.logger.info(f"🔍 Checking {service_name} for issues...")
-            issue_type = self._detect_service_issue(service_name)
-            if issue_type:
-                services_to_fix.append((service_name, issue_type))
-                self.logger.info(f"  ⚠️  Found issue with {service_name}: {issue_type}")
-            else:
-                self.logger.debug(f"  ✅ {service_name} is functioning correctly")
-
-        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:
-                    # NOTE: Removed automatic dependency injection workaround
-                    # Package maintainers should fix dependency declarations
-                    fixed_services.append(f"{service_name} (reinstalled)")
-                else:
-                    failed_services.append(f"{service_name} (reinstall failed)")
-
-            elif issue_type == "missing_dependency":
-                # Fix missing dependencies - try injection first, then reinstall if needed
-                self.logger.info(
-                    f"  {service_name} has missing dependencies - attempting fix..."
-                )
-
-                # First try to inject dependencies without reinstalling
-                injection_success = self._inject_missing_dependencies(service_name)
-
-                if injection_success:
-                    # Verify the fix worked
-                    issue_after_injection = self._detect_service_issue(service_name)
-                    if issue_after_injection is None:
-                        fixed_services.append(f"{service_name} (dependencies injected)")
-                        self.logger.info(
-                            f"  ✅ Fixed {service_name} with dependency injection"
-                        )
-                        continue  # Move to next service
-
-                # If injection alone didn't work, try full reinstall
-                self.logger.info(
-                    "  Dependency injection insufficient, trying full reinstall..."
-                )
-                success = self._auto_reinstall_mcp_service(service_name)
-                if success:
-                    fixed_services.append(
-                        f"{service_name} (auto-reinstalled with dependencies)"
-                    )
-                else:
-                    # Provide specific manual fix for known services
-                    if service_name == "mcp-ticketer":
-                        self.logger.warning(
-                            f"  Auto-fix failed for {service_name}. Manual fix: "
-                            f"pipx uninstall {service_name} && pipx install {service_name} && pipx inject {service_name} gql"
-                        )
-                    else:
-                        self.logger.warning(
-                            f"  Auto-reinstall failed for {service_name}. Manual fix: "
-                            f"pipx uninstall {service_name} && pipx install {service_name}"
-                        )
-                    failed_services.append(f"{service_name} (auto-reinstall failed)")
-
-            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]
-                if service in self.SERVICE_MISSING_DEPENDENCIES:
-                    deps = " ".join(
-                        [
-                            f"&& pipx inject {service} {dep}"
-                            for dep in self.SERVICE_MISSING_DEPENDENCIES[service]
-                        ]
-                    )
-                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service} {deps}"
-                else:
-                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service}"
-
-        return success, message
+        # Services should stand on their own - no proactive health checking
+        return True, "MCP services managing their own health"
 
     def _detect_service_issue(self, service_name: str) -> Optional[str]:
         """
@@ -1492,7 +1373,7 @@ class MCPConfigManager:
                 )
 
                 if result.returncode == 0:
-                    self.logger.info(f"    ✅ Successfully injected {dep}")
+                    self.logger.debug(f"    ✅ Successfully injected {dep}")
                 # Check if already injected (pipx will complain if package already exists)
                 elif (
                     "already satisfied" in result.stderr.lower()
@@ -1577,7 +1458,7 @@ class MCPConfigManager:
                     )
 
             # Verify the reinstall worked
-            self.logger.info(f"  → Verifying {service_name} installation...")
+            self.logger.debug(f"  → Verifying {service_name} installation...")
             issue = self._detect_service_issue(service_name)
 
             if issue is None:

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -163,17 +163,21 @@ class MCPAutoConfigurator:
         Returns:
             True if user agrees, False if declines, None if timeout
         """
-        print("\n" + "=" * 60)
-        print("🔧 MCP Gateway Configuration")
-        print("=" * 60)
-        print("\nClaude MPM can automatically configure MCP Gateway for")
-        print("Claude Code integration. This enables advanced features:")
-        print("  • File analysis and summarization")
-        print("  • System diagnostics")
-        print("  • Ticket management")
-        print("  • And more...")
-        print("\nWould you like to configure it now? (y/n)")
-        print(f"(Auto-declining in {timeout} seconds)")
+        print("\n" + "=" * 60, file=sys.stderr)
+        print("🔧 MCP Gateway Configuration", file=sys.stderr)
+        print("=" * 60, file=sys.stderr)
+        print(
+            "\nClaude MPM can automatically configure MCP Gateway for", file=sys.stderr
+        )
+        print(
+            "Claude Code integration. This enables advanced features:", file=sys.stderr
+        )
+        print("  • File analysis and summarization", file=sys.stderr)
+        print("  • System diagnostics", file=sys.stderr)
+        print("  • Ticket management", file=sys.stderr)
+        print("  • And more...", file=sys.stderr)
+        print("\nWould you like to configure it now? (y/n)", file=sys.stderr)
+        print(f"(Auto-declining in {timeout} seconds)", file=sys.stderr)
 
         # Use threading for cross-platform timeout support
         # Python 3.7+ has queue built-in - no need to check, we require 3.10+
@@ -203,7 +207,7 @@ class MCPAutoConfigurator:
 
         if input_thread.is_alive():
             # Timed out
-            print("\n(Timed out - declining)")
+            print("\n(Timed out - declining)", file=sys.stderr)
             return None
         # Got input
         return user_input in ["y", "yes"]
@@ -220,7 +224,7 @@ class MCPAutoConfigurator:
             if self.claude_config_path.exists():
                 backup_path = self._create_backup()
                 if backup_path:
-                    print(f"✅ Backup created: {backup_path}")
+                    print(f"✅ Backup created: {backup_path}", file=sys.stderr)
 
             # Load or create configuration
             config = self._load_or_create_config()
@@ -232,7 +236,7 @@ class MCPAutoConfigurator:
             # Find claude-mpm executable
             executable = self._find_claude_mpm_executable()
             if not executable:
-                print("❌ Could not find claude-mpm executable")
+                print("❌ Could not find claude-mpm executable", file=sys.stderr)
                 return False
 
             # Configure MCP server
@@ -246,20 +250,22 @@ class MCPAutoConfigurator:
             with self.claude_config_path.open("w") as f:
                 json.dump(config, f, indent=2)
 
-            print(f"✅ Configuration saved to: {self.claude_config_path}")
-            print("\n🎉 MCP Gateway configured successfully!")
-            print("\nNext steps:")
-            print("1. Restart Claude Code (if running)")
-            print("2. Look for the MCP icon in the interface")
-            print("3. Try @claude-mpm-gateway in a conversation")
+            print(
+                f"✅ Configuration saved to: {self.claude_config_path}", file=sys.stderr
+            )
+            print("\n🎉 MCP Gateway configured successfully!", file=sys.stderr)
+            print("\nNext steps:", file=sys.stderr)
+            print("1. Restart Claude Code (if running)", file=sys.stderr)
+            print("2. Look for the MCP icon in the interface", file=sys.stderr)
+            print("3. Try @claude-mpm-gateway in a conversation", file=sys.stderr)
 
             return True
 
         except Exception as e:
             self.logger.error(f"Auto-configuration failed: {e}")
-            print(f"❌ Configuration failed: {e}")
-            print("\nYou can configure manually with:")
-            print("  claude-mpm mcp install")
+            print(f"❌ Configuration failed: {e}", file=sys.stderr)
+            print("\nYou can configure manually with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
             return False
 
     def _create_backup(self) -> Optional[Path]:
@@ -344,8 +350,8 @@ class MCPAutoConfigurator:
         if user_choice:
             return self.auto_configure()
         if user_choice is False:  # User explicitly said no
-            print("\n📝 You can configure MCP later with:")
-            print("  claude-mpm mcp install")
+            print("\n📝 You can configure MCP later with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
         # If timeout (None), don't show additional message
         return False
 

claude_mpm/services/mcp_gateway/core/__init__.py

@@ -5,7 +5,7 @@ MCP Gateway Core Module
 Core interfaces and base classes for the MCP Gateway service.
 """
 
-from .base import BaseMCPService, MCPServiceState
+from .base import BaseMCPService
 from .exceptions import (
     MCPCommunicationError,
     MCPConfigurationError,
@@ -38,7 +38,6 @@ __all__ = [
     # Exceptions
     "MCPException",
     "MCPServerError",
-    "MCPServiceState",
     "MCPToolNotFoundError",
     "MCPValidationError",
 ]

claude_mpm/services/mcp_gateway/core/base.py

@@ -8,25 +8,12 @@ Part of ISS-0034: Infrastructure Setup - MCP Gateway Project Foundation
 """
 
 import asyncio
-from enum import Enum
 from typing import Any, Dict, Optional
 
+from claude_mpm.core.enums import ServiceState
 from claude_mpm.services.core.base import BaseService
 
 
-class MCPServiceState(Enum):
-    """MCP service lifecycle states."""
-
-    UNINITIALIZED = "uninitialized"
-    INITIALIZING = "initializing"
-    INITIALIZED = "initialized"
-    STARTING = "starting"
-    RUNNING = "running"
-    STOPPING = "stopping"
-    STOPPED = "stopped"
-    ERROR = "error"
-
-
 class BaseMCPService(BaseService):
     """
     Base class for all MCP Gateway services.
@@ -53,7 +40,7 @@ class BaseMCPService(BaseService):
             config: Service-specific configuration
         """
         super().__init__(service_name or "MCPService", config)
-        self._state = MCPServiceState.UNINITIALIZED
+        self._state = ServiceState.UNINITIALIZED
         self._health_status = {
             "healthy": False,
             "state": self._state.value,
@@ -76,13 +63,13 @@ class BaseMCPService(BaseService):
         """
         async with self._state_lock:
             if self._state not in [
-                MCPServiceState.UNINITIALIZED,
-                MCPServiceState.STOPPED,
+                ServiceState.UNINITIALIZED,
+                ServiceState.STOPPED,
             ]:
                 self.log_warning(f"Cannot initialize from state {self._state.value}")
                 return False
 
-            self._state = MCPServiceState.INITIALIZING
+            self._state = ServiceState.INITIALIZING
             self.log_info("Initializing MCP service")
 
         try:
@@ -91,13 +78,13 @@ class BaseMCPService(BaseService):
 
             async with self._state_lock:
                 if success:
-                    self._state = MCPServiceState.INITIALIZED
+                    self._state = ServiceState.INITIALIZED
                     self._initialized = True
                     self._health_status["healthy"] = True
                     self._health_status["state"] = self._state.value
                     self.log_info("MCP service initialized successfully")
                 else:
-                    self._state = MCPServiceState.ERROR
+                    self._state = ServiceState.ERROR
                     self._health_status["healthy"] = False
                     self._health_status["state"] = self._state.value
                     self.log_error("MCP service initialization failed")
@@ -106,7 +93,7 @@ class BaseMCPService(BaseService):
 
         except Exception as e:
             async with self._state_lock:
-                self._state = MCPServiceState.ERROR
+                self._state = ServiceState.ERROR
                 self._health_status["healthy"] = False
                 self._health_status["state"] = self._state.value
                 self._health_status["details"]["error"] = str(e)
@@ -134,11 +121,11 @@ class BaseMCPService(BaseService):
             True if startup successful
         """
         async with self._state_lock:
-            if self._state != MCPServiceState.INITIALIZED:
+            if self._state != ServiceState.INITIALIZED:
                 self.log_warning(f"Cannot start from state {self._state.value}")
                 return False
 
-            self._state = MCPServiceState.STARTING
+            self._state = ServiceState.STARTING
             self.log_info("Starting MCP service")
 
         try:
@@ -146,12 +133,12 @@ class BaseMCPService(BaseService):
 
             async with self._state_lock:
                 if success:
-                    self._state = MCPServiceState.RUNNING
+                    self._state = ServiceState.RUNNING
                     self._health_status["healthy"] = True
                     self._health_status["state"] = self._state.value
                     self.log_info("MCP service started successfully")
                 else:
-                    self._state = MCPServiceState.ERROR
+                    self._state = ServiceState.ERROR
                     self._health_status["healthy"] = False
                     self._health_status["state"] = self._state.value
                     self.log_error("MCP service startup failed")
@@ -160,7 +147,7 @@ class BaseMCPService(BaseService):
 
         except Exception as e:
             async with self._state_lock:
-                self._state = MCPServiceState.ERROR
+                self._state = ServiceState.ERROR
                 self._health_status["healthy"] = False
                 self._health_status["state"] = self._state.value
                 self._health_status["details"]["error"] = str(e)
@@ -188,18 +175,18 @@ class BaseMCPService(BaseService):
         Subclasses should override _do_shutdown() for custom shutdown logic.
         """
         async with self._state_lock:
-            if self._state in [MCPServiceState.STOPPED, MCPServiceState.STOPPING]:
+            if self._state in [ServiceState.STOPPED, ServiceState.STOPPING]:
                 self.log_warning(f"Already in state {self._state.value}")
                 return
 
-            self._state = MCPServiceState.STOPPING
+            self._state = ServiceState.STOPPING
             self.log_info("Shutting down MCP service")
 
         try:
             await self._do_shutdown()
 
             async with self._state_lock:
-                self._state = MCPServiceState.STOPPED
+                self._state = ServiceState.STOPPED
                 self._shutdown = True
                 self._health_status["healthy"] = False
                 self._health_status["state"] = self._state.value
@@ -207,7 +194,7 @@ class BaseMCPService(BaseService):
 
         except Exception as e:
             async with self._state_lock:
-                self._state = MCPServiceState.ERROR
+                self._state = ServiceState.ERROR
                 self._health_status["healthy"] = False
                 self._health_status["state"] = self._state.value
                 self._health_status["details"]["error"] = str(e)
@@ -232,7 +219,7 @@ class BaseMCPService(BaseService):
         self.log_info("Restarting MCP service")
 
         # Shutdown if running
-        if self._state == MCPServiceState.RUNNING:
+        if self._state == ServiceState.RUNNING:
             await self.shutdown()
 
         # Re-initialize

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -864,7 +864,7 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
     # Check if running in a non-interactive context
     try:
         if confirm_operation(message):
-            print("🚀 Updating kuzu-memory...")
+            print("🚀 Updating kuzu-memory...", file=sys.stderr)
             try:
                 result = subprocess.run(
                     ["pipx", "upgrade", "kuzu-memory"],
@@ -874,28 +874,37 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
                     check=False,
                 )
                 if result.returncode == 0:
-                    print("✅ Successfully updated kuzu-memory!")
+                    print("✅ Successfully updated kuzu-memory!", file=sys.stderr)
                     logger.info(f"Updated kuzu-memory from {current} to {latest}")
                 else:
-                    print(f"⚠️ Update failed: {result.stderr}")
+                    print(f"⚠️ Update failed: {result.stderr}", file=sys.stderr)
                     logger.warning(f"kuzu-memory update failed: {result.stderr}")
             except subprocess.TimeoutExpired:
-                print("⚠️ Update timed out. Please try again later.")
+                print("⚠️ Update timed out. Please try again later.", file=sys.stderr)
                 logger.warning("kuzu-memory update timed out")
             except Exception as e:
-                print(f"⚠️ Update failed: {e}")
+                print(f"⚠️ Update failed: {e}", file=sys.stderr)
                 logger.warning(f"kuzu-memory update error: {e}")
         else:
             # User declined update
-            print("\n  To skip this version permanently, run:")
-            print(f"    claude-mpm config set-skip-version kuzu-memory {latest}")
-            print("  To disable update checks for kuzu-memory:")
-            print("    claude-mpm config disable-update-checks kuzu-memory")
+            print("\n  To skip this version permanently, run:", file=sys.stderr)
+            print(
+                f"    claude-mpm config set-skip-version kuzu-memory {latest}",
+                file=sys.stderr,
+            )
+            print("  To disable update checks for kuzu-memory:", file=sys.stderr)
+            print(
+                "    claude-mpm config disable-update-checks kuzu-memory",
+                file=sys.stderr,
+            )
 
             # Ask if user wants to skip this version
             if confirm_operation("\n  Skip this version in future checks?"):
                 UpdatePreferences.set_skip_version("kuzu-memory", latest)
-                print(f"  Version {latest} will be skipped in future checks.")
+                print(
+                    f"  Version {latest} will be skipped in future checks.",
+                    file=sys.stderr,
+                )
     except (KeyboardInterrupt, EOFError):
         # User interrupted or input not available
         pass