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

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -1,369 +0,0 @@
-"""
-MCP Gateway Auto-Configuration Service
-======================================
-
-Provides automatic MCP configuration for pipx installations with user consent.
-Detects unconfigured MCP setups and offers one-time configuration prompts.
-
-WHY: Users installing via pipx should have MCP work out-of-the-box with minimal
-friction. This service detects unconfigured installations and offers automatic
-setup with user consent.
-
-DESIGN DECISIONS:
-- Only prompts once (saves preference to avoid repeated prompts)
-- Quick timeout with safe default (no configuration)
-- Non-intrusive with environment variable override
-- Creates backups before modifying any configuration
-- Validates JSON before and after modifications
-"""
-
-import json
-import os
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from claude_mpm.config.paths import paths
-from claude_mpm.core.logger import get_logger
-
-
-class MCPAutoConfigurator:
-    """
-    Handles automatic MCP configuration for pipx installations.
-
-    Provides a one-time prompt to configure MCP Gateway with user consent,
-    making the experience seamless for pipx users while respecting choice.
-    """
-
-    def __init__(self):
-        """Initialize the auto-configurator."""
-        self.logger = get_logger("MCPAutoConfig")
-        self.config_dir = paths.claude_mpm_dir_hidden
-        self.preference_file = self.config_dir / "mcp_auto_config_preference.json"
-        self.claude_config_path = Path.home() / ".claude.json"
-
-    def should_auto_configure(self) -> bool:
-        """
-        Check if auto-configuration should be attempted.
-
-        Returns:
-            True if auto-configuration should be offered, False otherwise
-        """
-        # Check environment variable override
-        if os.environ.get("CLAUDE_MPM_NO_AUTO_CONFIG"):
-            self.logger.debug("Auto-configuration disabled via environment variable")
-            return False
-
-        # Check if already configured
-        if self._is_mcp_configured():
-            self.logger.debug("MCP already configured")
-            return False
-
-        # Check if this is a pipx installation
-        if not self._is_pipx_installation():
-            self.logger.debug("Not a pipx installation")
-            return False
-
-        # Check if we've already asked
-        if self._has_user_preference():
-            self.logger.debug("User preference already saved")
-            return False
-
-        return True
-
-    def _is_mcp_configured(self) -> bool:
-        """Check if MCP is already configured in Claude Code."""
-        if not self.claude_config_path.exists():
-            return False
-
-        try:
-            with self.claude_config_path.open() as f:
-                config = json.load(f)
-
-            # Check if claude-mpm-gateway is configured
-            mcp_servers = config.get("mcpServers", {})
-            return "claude-mpm-gateway" in mcp_servers
-
-        except (OSError, json.JSONDecodeError):
-            return False
-
-    def _is_pipx_installation(self) -> bool:
-        """Check if claude-mpm is installed via pipx."""
-        # Check if running from pipx virtual environment
-        if "pipx" in sys.executable.lower():
-            return True
-
-        # Check module path
-        try:
-            import claude_mpm
-
-            module_path = Path(claude_mpm.__file__).parent
-            if "pipx" in str(module_path):
-                return True
-        except Exception:
-            pass
-
-        # Check for pipx in PATH for claude-mpm command
-        try:
-            import platform
-            import subprocess
-
-            # Use appropriate command for OS
-            if platform.system() == "Windows":
-                cmd = ["where", "claude-mpm"]
-            else:
-                cmd = ["which", "claude-mpm"]
-
-            result = subprocess.run(
-                cmd, capture_output=True, text=True, timeout=2, check=False
-            )
-            if result.returncode == 0 and "pipx" in result.stdout:
-                return True
-        except Exception:
-            pass
-
-        return False
-
-    def _has_user_preference(self) -> bool:
-        """Check if user has already been asked about auto-configuration."""
-        if not self.preference_file.exists():
-            return False
-
-        try:
-            with self.preference_file.open() as f:
-                prefs = json.load(f)
-            return prefs.get("asked", False)
-        except (OSError, json.JSONDecodeError):
-            return False
-
-    def _save_user_preference(self, choice: str):
-        """Save user's preference to avoid asking again."""
-        self.config_dir.mkdir(parents=True, exist_ok=True)
-
-        prefs = {
-            "asked": True,
-            "choice": choice,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
-
-        try:
-            with self.preference_file.open("w") as f:
-                json.dump(prefs, f, indent=2)
-        except Exception as e:
-            self.logger.debug(f"Could not save preference: {e}")
-
-    def prompt_user(self, timeout: int = 10) -> Optional[bool]:
-        """
-        Prompt user for auto-configuration with timeout.
-
-        Args:
-            timeout: Seconds to wait for response (default 10)
-
-        Returns:
-            True if user agrees, False if declines, None if timeout
-        """
-        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+
-        import importlib.util
-        import threading
-
-        if importlib.util.find_spec("queue") is None:
-            # Extremely unlikely in Python 3.10+, but for completeness
-            pass
-
-        user_input = None
-
-        def get_input():
-            nonlocal user_input
-            try:
-                user_input = input("> ").strip().lower()
-            except (EOFError, KeyboardInterrupt):
-                user_input = "n"
-
-        # Start input thread
-        input_thread = threading.Thread(target=get_input)
-        input_thread.daemon = True
-        input_thread.start()
-
-        # Wait for input or timeout
-        input_thread.join(timeout)
-
-        if input_thread.is_alive():
-            # Timed out
-            print("\n(Timed out - declining)", file=sys.stderr)
-            return None
-        # Got input
-        return user_input in ["y", "yes"]
-
-    def auto_configure(self) -> bool:
-        """
-        Perform automatic MCP configuration.
-
-        Returns:
-            True if configuration successful, False otherwise
-        """
-        try:
-            # Create backup if config exists
-            if self.claude_config_path.exists():
-                backup_path = self._create_backup()
-                if backup_path:
-                    print(f"✅ Backup created: {backup_path}", file=sys.stderr)
-
-            # Load or create configuration
-            config = self._load_or_create_config()
-
-            # Add MCP Gateway configuration
-            if "mcpServers" not in config:
-                config["mcpServers"] = {}
-
-            # Find claude-mpm executable
-            executable = self._find_claude_mpm_executable()
-            if not executable:
-                print("❌ Could not find claude-mpm executable", file=sys.stderr)
-                return False
-
-            # Configure MCP server
-            config["mcpServers"]["claude-mpm-gateway"] = {
-                "command": str(executable),
-                "args": ["mcp", "server"],
-                "env": {"MCP_MODE": "production"},
-            }
-
-            # Save configuration
-            with self.claude_config_path.open("w") as f:
-                json.dump(config, f, indent=2)
-
-            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}", 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]:
-        """Create backup of existing configuration."""
-        try:
-            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-            backup_path = self.claude_config_path.with_suffix(
-                f".backup.{timestamp}.json"
-            )
-
-            import shutil
-
-            shutil.copy2(self.claude_config_path, backup_path)
-            return backup_path
-
-        except Exception as e:
-            self.logger.debug(f"Could not create backup: {e}")
-            return None
-
-    def _load_or_create_config(self) -> Dict[str, Any]:
-        """Load existing config or create new one."""
-        if self.claude_config_path.exists():
-            try:
-                with self.claude_config_path.open() as f:
-                    return json.load(f)
-            except json.JSONDecodeError:
-                self.logger.warning("Existing config is invalid JSON, creating new")
-
-        return {}
-
-    def _find_claude_mpm_executable(self) -> Optional[str]:
-        """Find the claude-mpm executable path."""
-        # Try direct command first
-        import platform
-        import subprocess
-
-        try:
-            # Use appropriate command for OS
-            if platform.system() == "Windows":
-                cmd = ["where", "claude-mpm"]
-            else:
-                cmd = ["which", "claude-mpm"]
-
-            result = subprocess.run(
-                cmd, capture_output=True, text=True, timeout=2, check=False
-            )
-            if result.returncode == 0:
-                executable_path = result.stdout.strip()
-                # On Windows, 'where' might return multiple paths
-                if platform.system() == "Windows" and "\n" in executable_path:
-                    executable_path = executable_path.split("\n")[0]
-                return executable_path
-        except Exception:
-            pass
-
-        # Try to find via shutil.which (more portable)
-        import shutil
-
-        claude_mpm_path = shutil.which("claude-mpm")
-        if claude_mpm_path:
-            return claude_mpm_path
-
-        # Fallback to Python module invocation
-        return sys.executable
-
-    def run(self) -> bool:
-        """
-        Main entry point for auto-configuration.
-
-        Returns:
-            True if configured (or already configured), False otherwise
-        """
-        if not self.should_auto_configure():
-            return True  # Already configured or not applicable
-
-        # Prompt user
-        user_choice = self.prompt_user()
-
-        # Save preference to not ask again
-        self._save_user_preference("yes" if user_choice else "no")
-
-        if user_choice:
-            return self.auto_configure()
-        if user_choice is False:  # User explicitly said no
-            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
-
-
-def check_and_configure_mcp() -> bool:
-    """
-    Check and potentially configure MCP for pipx installations.
-
-    This is the main entry point called during CLI initialization.
-
-    Returns:
-        True if MCP is configured (or configuration was successful), False otherwise
-    """
-    configurator = MCPAutoConfigurator()
-    return configurator.run()

claude_mpm/services/mcp_gateway/config/__init__.py

@@ -1,17 +0,0 @@
-"""
-MCP Gateway Configuration Module
-=================================
-
-Configuration management for the MCP Gateway service.
-"""
-
-from .config_loader import MCPConfigLoader
-from .config_schema import MCPConfigSchema, validate_config
-from .configuration import MCPConfiguration
-
-__all__ = [
-    "MCPConfigLoader",
-    "MCPConfigSchema",
-    "MCPConfiguration",
-    "validate_config",
-]

claude_mpm/services/mcp_gateway/config/config_loader.py

@@ -1,296 +0,0 @@
-from pathlib import Path
-
-"""
-MCP Gateway Configuration Loader
-================================
-
-Handles loading and discovery of MCP configuration files.
-
-Part of ISS-0034: Infrastructure Setup - MCP Gateway Project Foundation
-
-UPDATED: Migrated to use shared ConfigLoader pattern (TSK-0141)
-"""
-
-import os
-from typing import List, Optional
-
-import yaml
-
-from claude_mpm.core.logger import get_logger
-from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern
-
-
-class MCPConfigLoader:
-    """
-    Configuration loader for MCP Gateway.
-
-    This class handles discovering and loading configuration files from
-    standard locations, supporting both user and system configurations.
-
-    WHY: We separate configuration loading from the main configuration
-    service to support multiple configuration sources and provide a clean
-    abstraction for configuration discovery.
-
-    UPDATED: Now uses shared ConfigLoader pattern for consistency (TSK-0141)
-    """
-
-    # MCP Gateway configuration pattern
-    MCP_CONFIG_PATTERN = ConfigPattern(
-        filenames=[
-            "mcp_gateway.yaml",
-            "mcp_gateway.yml",
-            ".mcp_gateway.yaml",
-            ".mcp_gateway.yml",
-            "config.yaml",
-            "config.yml",
-        ],
-        search_paths=[
-            "~/.claude/mcp",
-            "~/.config/claude-mpm",
-            ".",
-            "./config",
-            "./.claude",
-            "/etc/claude-mpm",
-        ],
-        env_prefix="CLAUDE_MPM_MCP_",
-        defaults={"host": "localhost", "port": 3000, "debug": False, "timeout": 30},
-    )
-
-    def __init__(self):
-        """Initialize configuration loader."""
-        self.logger = get_logger("MCPConfigLoader")
-        self._shared_loader = ConfigLoader()
-
-    def find_config_file(self) -> Optional[Path]:
-        """
-        Find the first available configuration file.
-
-        Searches through standard locations and returns the first
-        existing configuration file.
-
-        Returns:
-            Path to configuration file if found, None otherwise
-        """
-        for config_path in self.CONFIG_SEARCH_PATHS:
-            expanded_path = config_path.expanduser()
-            if expanded_path.exists() and expanded_path.is_file():
-                self.logger.info(f"Found configuration file: {expanded_path}")
-                return expanded_path
-
-        self.logger.debug("No configuration file found in standard locations")
-        return None
-
-    def load_from_file(self, config_path: Path) -> Optional[dict]:
-        """
-        Load configuration from a specific file.
-
-        Args:
-            config_path: Path to configuration file
-
-        Returns:
-            Configuration dictionary if successful, None otherwise
-        """
-        try:
-            expanded_path = config_path.expanduser()
-
-            if not expanded_path.exists():
-                self.logger.error(f"Configuration file not found: {expanded_path}")
-                return None
-
-            with expanded_path.open() as f:
-                config = yaml.safe_load(f)
-
-            self.logger.info(f"Configuration loaded from {expanded_path}")
-            return config or {}
-
-        except yaml.YAMLError as e:
-            self.logger.error(f"Failed to parse YAML configuration: {e}")
-            return None
-        except Exception as e:
-            self.logger.error(f"Failed to load configuration: {e}")
-            return None
-
-    def load_from_env(self) -> dict:
-        """
-        Load configuration from environment variables.
-
-        Environment variables follow the pattern: MCP_GATEWAY_<SECTION>_<KEY>
-
-        Returns:
-            Configuration dictionary built from environment variables
-        """
-        config = {}
-        prefix = "MCP_GATEWAY_"
-
-        for env_key, env_value in os.environ.items():
-            if not env_key.startswith(prefix):
-                continue
-
-            # Parse environment variable into configuration path
-            config_path = env_key[len(prefix) :].lower().split("_")
-
-            # Build nested configuration structure
-            current = config
-            for part in config_path[:-1]:
-                if part not in current:
-                    current[part] = {}
-                current = current[part]
-
-            # Set the value
-            key = config_path[-1]
-            try:
-                # Try to parse as JSON for complex types
-                import json
-
-                current[key] = json.loads(env_value)
-            except Exception:
-                # Fall back to string value
-                current[key] = env_value
-
-            self.logger.debug(f"Loaded from environment: {env_key}")
-
-        return config
-
-    def load(self, config_path: Optional[Path] = None) -> dict:
-        """
-        Load configuration from all sources.
-
-        Loads configuration in the following priority order:
-        1. Default configuration
-        2. File configuration (if found or specified)
-        3. Environment variable overrides
-
-        Args:
-            config_path: Optional specific configuration file path
-
-        Returns:
-            Merged configuration dictionary
-        """
-        from .configuration import MCPConfiguration
-
-        if config_path:
-            # Use specific config file with shared loader
-            pattern = ConfigPattern(
-                filenames=[config_path.name],
-                search_paths=[str(config_path.parent)],
-                env_prefix=self.MCP_CONFIG_PATTERN.env_prefix,
-                defaults=MCPConfiguration.DEFAULT_CONFIG.copy(),
-            )
-            config_obj = self._shared_loader.load_config(
-                pattern, cache_key=f"mcp_{config_path}"
-            )
-            return config_obj.to_dict()
-        # Use standard MCP pattern with defaults
-        pattern = ConfigPattern(
-            filenames=self.MCP_CONFIG_PATTERN.filenames,
-            search_paths=self.MCP_CONFIG_PATTERN.search_paths,
-            env_prefix=self.MCP_CONFIG_PATTERN.env_prefix,
-            defaults=MCPConfiguration.DEFAULT_CONFIG.copy(),
-        )
-        config_obj = self._shared_loader.load_config(pattern, cache_key="mcp_gateway")
-        return config_obj.to_dict()
-
-    # Backward compatibility methods (deprecated)
-    def find_config_file(self) -> Optional[Path]:
-        """Find configuration file using legacy method (deprecated)."""
-        import warnings
-
-        warnings.warn(
-            "find_config_file is deprecated. Use load() method instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Use shared loader to find config file
-        return self._shared_loader._find_config_file(self.MCP_CONFIG_PATTERN)
-
-    def load_from_file(self, config_path: Path) -> Optional[dict]:
-        """Load from file using legacy method (deprecated)."""
-        import warnings
-
-        warnings.warn(
-            "load_from_file is deprecated. Use load() method instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Use shared loader
-        return self._shared_loader._load_config_file(config_path)
-
-    def load_from_env(self, prefix: str = "CLAUDE_MPM_MCP_") -> dict:
-        """Load from environment using legacy method (deprecated)."""
-        import warnings
-
-        warnings.warn(
-            "load_from_env is deprecated. Use load() method instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        # Use shared loader
-        return self._shared_loader._load_env_config(prefix)
-
-    def _merge_configs(self, base: dict, overlay: dict) -> dict:
-        """
-        Recursively merge two configuration dictionaries.
-
-        Args:
-            base: Base configuration
-            overlay: Configuration to merge in
-
-        Returns:
-            Merged configuration
-        """
-        result = base.copy()
-
-        for key, value in overlay.items():
-            if (
-                key in result
-                and isinstance(result[key], dict)
-                and isinstance(value, dict)
-            ):
-                result[key] = self._merge_configs(result[key], value)
-            else:
-                result[key] = value
-
-        return result
-
-    def create_default_config(self, path: Path) -> bool:
-        """
-        Create a default configuration file.
-
-        Args:
-            path: Path where to create the configuration file
-
-        Returns:
-            True if file created successfully
-        """
-        from .configuration import MCPConfiguration
-
-        try:
-            expanded_path = path.expanduser()
-            expanded_path.parent.mkdir(parents=True, exist_ok=True)
-
-            with expanded_path.open("w") as f:
-                yaml.dump(
-                    MCPConfiguration.DEFAULT_CONFIG,
-                    f,
-                    default_flow_style=False,
-                    sort_keys=True,
-                )
-
-            self.logger.info(f"Created default configuration at {expanded_path}")
-            return True
-
-        except Exception as e:
-            self.logger.error(f"Failed to create default configuration: {e}")
-            return False
-
-    def list_config_locations(self) -> List[str]:
-        """
-        List all configuration file search locations.
-
-        Returns:
-            List of configuration file paths (as strings)
-        """
-        return [str(path.expanduser()) for path in self.CONFIG_SEARCH_PATHS]