devsync 0.5.5__py3-none-any.whl

aiconfigkit/core/mcp/credentials.py

@@ -0,0 +1,279 @@
+"""MCP server credential management and .env file handling."""
+
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+from aiconfigkit.core.models import EnvironmentConfig, InstallationScope, MCPServer
+from aiconfigkit.utils.dotenv import ensure_env_gitignored, load_env_config, save_env_config, set_env_variable
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+class CredentialManager:
+    """Manages MCP server credentials and .env file operations."""
+
+    def __init__(self, project_root: Optional[Path] = None):
+        """
+        Initialize credential manager.
+
+        Args:
+            project_root: Project root directory (for project-scoped credentials)
+                         If None, uses current directory
+        """
+        self.project_root = project_root or Path.cwd()
+        self.project_env_path = self.project_root / ".instructionkit" / ".env"
+        self.global_env_path = Path.home() / ".instructionkit" / "global" / ".env"
+
+    def configure_server(
+        self,
+        server: MCPServer,
+        scope: InstallationScope = InstallationScope.PROJECT,
+        non_interactive: bool = False,
+    ) -> EnvironmentConfig:
+        """
+        Configure credentials for an MCP server.
+
+        Args:
+            server: MCPServer to configure
+            scope: Installation scope (PROJECT or GLOBAL)
+            non_interactive: If True, read from environment instead of prompting
+
+        Returns:
+            EnvironmentConfig with configured credentials
+
+        Raises:
+            ValueError: If non-interactive mode and required vars are missing
+        """
+        # Get env path for scope
+        env_path = self._get_env_path(scope)
+
+        # Load existing config
+        env_config = load_env_config(env_path, scope)
+
+        # Get required env vars
+        required_vars = server.get_required_env_vars()
+
+        if not required_vars:
+            logger.info(f"Server '{server.name}' requires no additional credentials")
+            return env_config
+
+        # Configure each required variable
+        if non_interactive:
+            self._configure_non_interactive(server, required_vars, env_config)
+        else:
+            self._configure_interactive(server, required_vars, env_config)
+
+        # Save updated config
+        save_env_config(env_config)
+
+        logger.info(f"Configured {len(required_vars)} credential(s) for server '{server.name}'")
+
+        return env_config
+
+    def _configure_interactive(
+        self,
+        server: MCPServer,
+        required_vars: list[str],
+        env_config: EnvironmentConfig,
+    ) -> None:
+        """
+        Configure credentials interactively with user prompts.
+
+        Args:
+            server: MCPServer being configured
+            required_vars: List of required environment variable names
+            env_config: EnvironmentConfig to update
+        """
+        console.print(f"\n[bold]Configuring MCP server:[/bold] {server.get_fully_qualified_name()}")
+        console.print(f"[dim]Required environment variables: {len(required_vars)}[/dim]\n")
+
+        for var_name in required_vars:
+            # Check if already configured
+            existing_value = env_config.get(var_name)
+
+            if existing_value:
+                # Show masked existing value
+                masked_value = self._mask_value(existing_value)
+                console.print(f"[dim]{var_name} is already configured: {masked_value}[/dim]")
+
+                # Ask if they want to update
+                update = Prompt.ask(
+                    "Do you want to update this value?",
+                    choices=["y", "n"],
+                    default="n",
+                )
+
+                if update.lower() == "n":
+                    continue
+
+            # Prompt for value (masked input)
+            console.print(f"[cyan]Enter value for {var_name}:[/cyan]")
+            value = Prompt.ask(f"  {var_name}", password=True)
+
+            if not value:
+                console.print("[yellow]Warning: Empty value provided, skipping[/yellow]")
+                continue
+
+            # Set the value
+            env_config.set(var_name, value)
+            console.print(f"[green]✓[/green] Set {var_name}")
+
+    def _configure_non_interactive(
+        self,
+        server: MCPServer,
+        required_vars: list[str],
+        env_config: EnvironmentConfig,
+    ) -> None:
+        """
+        Configure credentials non-interactively from environment.
+
+        Args:
+            server: MCPServer being configured
+            required_vars: List of required environment variable names
+            env_config: EnvironmentConfig to update
+
+        Raises:
+            ValueError: If required variables are missing from environment
+        """
+        missing_vars = []
+
+        for var_name in required_vars:
+            # Check if already in env_config
+            if env_config.has(var_name):
+                continue
+
+            # Try to read from current environment
+            value = os.getenv(var_name)
+
+            if not value:
+                missing_vars.append(var_name)
+                continue
+
+            # Set the value
+            env_config.set(var_name, value)
+
+        if missing_vars:
+            raise ValueError(
+                f"Non-interactive mode: Missing required environment variables: {', '.join(missing_vars)}"
+            )
+
+    def show_current_credentials(
+        self,
+        server: MCPServer,
+        scope: InstallationScope = InstallationScope.PROJECT,
+    ) -> dict[str, str]:
+        """
+        Show current credential values (masked) for a server.
+
+        Args:
+            server: MCPServer to show credentials for
+            scope: Installation scope
+
+        Returns:
+            Dictionary of variable names to masked values
+        """
+        env_path = self._get_env_path(scope)
+        env_config = load_env_config(env_path, scope)
+
+        required_vars = server.get_required_env_vars()
+        credentials = {}
+
+        for var_name in required_vars:
+            value = env_config.get(var_name)
+            if value:
+                credentials[var_name] = self._mask_value(value)
+            else:
+                credentials[var_name] = "[NOT SET]"
+
+        return credentials
+
+    def validate_credentials(
+        self,
+        server: MCPServer,
+        scope: InstallationScope = InstallationScope.PROJECT,
+    ) -> tuple[bool, list[str]]:
+        """
+        Validate that all required credentials are configured.
+
+        Args:
+            server: MCPServer to validate
+            scope: Installation scope
+
+        Returns:
+            Tuple of (is_valid, missing_vars)
+        """
+        env_path = self._get_env_path(scope)
+        env_config = load_env_config(env_path, scope)
+
+        missing_vars = env_config.validate_for_server(server)
+
+        return (len(missing_vars) == 0, missing_vars)
+
+    def _get_env_path(self, scope: InstallationScope) -> Path:
+        """
+        Get .env file path for scope.
+
+        Args:
+            scope: Installation scope
+
+        Returns:
+            Path to .env file
+        """
+        if scope == InstallationScope.GLOBAL:
+            return self.global_env_path
+        else:
+            return self.project_env_path
+
+    def _mask_value(self, value: str, visible_chars: int = 4) -> str:
+        """
+        Mask a credential value for display.
+
+        Args:
+            value: Value to mask
+            visible_chars: Number of characters to show at end
+
+        Returns:
+            Masked value (e.g., "****abc123")
+        """
+        if len(value) <= visible_chars:
+            return "*" * len(value)
+
+        masked_part = "*" * (len(value) - visible_chars)
+        visible_part = value[-visible_chars:]
+
+        return f"{masked_part}{visible_part}"
+
+    def get_env_config(self, scope: InstallationScope = InstallationScope.PROJECT) -> EnvironmentConfig:
+        """
+        Get environment configuration for scope.
+
+        Args:
+            scope: Installation scope
+
+        Returns:
+            EnvironmentConfig
+        """
+        env_path = self._get_env_path(scope)
+        return load_env_config(env_path, scope)
+
+    def merge_scopes(self) -> EnvironmentConfig:
+        """
+        Merge global and project environment configs.
+
+        Project variables take precedence over global.
+
+        Returns:
+            Merged EnvironmentConfig
+        """
+        from aiconfigkit.utils.dotenv import merge_env_configs
+
+        global_config = self.get_env_config(InstallationScope.GLOBAL)
+        project_config = self.get_env_config(InstallationScope.PROJECT)
+
+        return merge_env_configs(project_config, global_config)

aiconfigkit/core/mcp/manager.py

@@ -0,0 +1,308 @@
+"""MCP template installation and library management."""
+
+import logging
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from aiconfigkit.core.git_operations import GitOperations
+from aiconfigkit.core.models import InstallationScope, MCPTemplate
+from aiconfigkit.core.repository import RepositoryParser
+
+logger = logging.getLogger(__name__)
+
+
+class MCPManager:
+    """Manages MCP template installation and library operations."""
+
+    def __init__(self, library_root: Path):
+        """
+        Initialize MCP manager.
+
+        Args:
+            library_root: Root directory for MCP library (e.g., ~/.instructionkit/library/)
+        """
+        self.library_root = library_root
+        self.library_root.mkdir(parents=True, exist_ok=True)
+
+    def install_template(
+        self,
+        source: str,
+        namespace: str,
+        scope: InstallationScope = InstallationScope.PROJECT,
+        force: bool = False,
+    ) -> MCPTemplate:
+        """
+        Install MCP template from source URL or local path.
+
+        Args:
+            source: Git URL or local directory path
+            namespace: Unique identifier for this template
+            scope: Installation scope (PROJECT or GLOBAL)
+            force: Overwrite existing template if it exists
+
+        Returns:
+            MCPTemplate object representing the installed template
+
+        Raises:
+            ValueError: If namespace is invalid or already exists (without force)
+            FileNotFoundError: If source path doesn't exist
+            RuntimeError: If Git clone/copy fails
+        """
+        # Validate namespace
+        self._validate_namespace(namespace)
+
+        # Get installation path
+        install_path = self._get_install_path(namespace, scope)
+
+        # Check if already exists
+        if install_path.exists() and not force:
+            raise ValueError(
+                f"Template namespace '{namespace}' already exists at {install_path}. " f"Use --force to overwrite."
+            )
+
+        # Remove existing if force
+        if install_path.exists() and force:
+            logger.info(f"Removing existing template at {install_path}")
+            shutil.rmtree(install_path)
+
+        # Install from source
+        source_url: Optional[str] = None
+        source_path: Optional[str] = None
+
+        if source.startswith(("http://", "https://", "git@")):
+            # Git URL
+            source_url = source
+            self._install_from_git(source, install_path)
+        else:
+            # Local path
+            source_path_obj = Path(source).resolve()
+            if not source_path_obj.exists():
+                raise FileNotFoundError(f"Source path does not exist: {source}")
+            source_path = str(source_path_obj)
+            self._install_from_local(source_path_obj, install_path)
+
+        # Parse template
+        parser = RepositoryParser(install_path)
+        metadata = self._parse_metadata(install_path)
+
+        # Parse MCP servers and sets
+        servers = parser.parse_mcp_servers(namespace)
+        sets = parser.parse_mcp_sets(namespace)
+
+        # Create MCPTemplate
+        template = MCPTemplate(
+            namespace=namespace,
+            source_url=source_url,
+            source_path=source_path,
+            version=metadata.get("version", "unknown"),
+            description=metadata.get("description", ""),
+            installed_at=datetime.now(),
+            servers=servers,
+            sets=sets,
+        )
+
+        # Save template metadata
+        self._save_template_metadata(template, install_path)
+
+        logger.info(f"Installed MCP template '{namespace}' with {len(servers)} servers and {len(sets)} sets")
+
+        return template
+
+    def _validate_namespace(self, namespace: str) -> None:
+        """
+        Validate namespace format.
+
+        Args:
+            namespace: Namespace to validate
+
+        Raises:
+            ValueError: If namespace is invalid
+        """
+        import re
+
+        if not namespace:
+            raise ValueError("Namespace cannot be empty")
+
+        # Check for path separators first (security)
+        if "/" in namespace or "\\" in namespace:
+            raise ValueError(f"Namespace cannot contain path separators: {namespace}")
+
+        if not re.match(r"^[a-zA-Z0-9_-]+$", namespace):
+            raise ValueError(
+                f"Invalid namespace: {namespace}. "
+                f"Must contain only alphanumeric characters, hyphens, and underscores."
+            )
+
+    def _get_install_path(self, namespace: str, scope: InstallationScope) -> Path:
+        """
+        Get installation path for template.
+
+        Args:
+            namespace: Template namespace
+            scope: Installation scope
+
+        Returns:
+            Path to install location
+        """
+        if scope == InstallationScope.GLOBAL:
+            return self.library_root / "global" / namespace
+        else:
+            return self.library_root / namespace
+
+    def _install_from_git(self, git_url: str, dest_path: Path) -> None:
+        """
+        Install template from Git repository.
+
+        Args:
+            git_url: Git repository URL
+            dest_path: Destination path
+
+        Raises:
+            RuntimeError: If Git clone fails
+        """
+        logger.info(f"Cloning Git repository: {git_url}")
+
+        try:
+            git_ops = GitOperations()
+            git_ops.clone_repository(git_url, dest_path)
+        except Exception as e:
+            raise RuntimeError(f"Failed to clone Git repository: {e}") from e
+
+    def _install_from_local(self, source_path: Path, dest_path: Path) -> None:
+        """
+        Install template from local directory.
+
+        Args:
+            source_path: Source directory path
+            dest_path: Destination path
+        """
+        logger.info(f"Copying from local path: {source_path}")
+
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Copy directory contents
+        shutil.copytree(source_path, dest_path, dirs_exist_ok=False)
+
+    def _parse_metadata(self, template_path: Path) -> dict:
+        """
+        Parse template metadata from aiconfigkit.yaml.
+
+        Args:
+            template_path: Path to template directory
+
+        Returns:
+            Dictionary with metadata
+        """
+        import yaml
+
+        metadata_file = template_path / "templatekit.yaml"
+        if not metadata_file.exists():
+            # Try templatekit.yaml as alternative
+            metadata_file = template_path / "templatekit.yaml"
+
+        if not metadata_file.exists():
+            logger.warning(f"No metadata file found in {template_path}")
+            return {}
+
+        with open(metadata_file, "r", encoding="utf-8") as f:
+            metadata = yaml.safe_load(f)
+
+        return metadata or {}
+
+    def _save_template_metadata(self, template: MCPTemplate, install_path: Path) -> None:
+        """
+        Save template metadata to .mcp_template.json.
+
+        Args:
+            template: MCPTemplate to save
+            install_path: Installation path
+        """
+        import json
+
+        metadata_file = install_path / ".mcp_template.json"
+
+        with open(metadata_file, "w", encoding="utf-8") as f:
+            json.dump(template.to_dict(), f, indent=2)
+
+    def load_template(
+        self, namespace: str, scope: InstallationScope = InstallationScope.PROJECT
+    ) -> Optional[MCPTemplate]:
+        """
+        Load installed template by namespace.
+
+        Args:
+            namespace: Template namespace
+            scope: Installation scope
+
+        Returns:
+            MCPTemplate if found, None otherwise
+        """
+        import json
+
+        install_path = self._get_install_path(namespace, scope)
+        metadata_file = install_path / ".mcp_template.json"
+
+        if not metadata_file.exists():
+            return None
+
+        with open(metadata_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        return MCPTemplate.from_dict(data)
+
+    def list_templates(self, scope: InstallationScope = InstallationScope.PROJECT) -> list[MCPTemplate]:
+        """
+        List all installed MCP templates.
+
+        Args:
+            scope: Installation scope to list
+
+        Returns:
+            List of MCPTemplate objects
+        """
+        templates = []
+
+        if scope == InstallationScope.GLOBAL:
+            search_path = self.library_root / "global"
+        else:
+            search_path = self.library_root
+
+        if not search_path.exists():
+            return []
+
+        # Find all .mcp_template.json files
+        for metadata_file in search_path.glob("**/.mcp_template.json"):
+            try:
+                import json
+
+                with open(metadata_file, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                template = MCPTemplate.from_dict(data)
+                templates.append(template)
+            except Exception as e:
+                logger.warning(f"Failed to load template from {metadata_file}: {e}")
+
+        return templates
+
+    def uninstall_template(self, namespace: str, scope: InstallationScope = InstallationScope.PROJECT) -> bool:
+        """
+        Uninstall MCP template.
+
+        Args:
+            namespace: Template namespace
+            scope: Installation scope
+
+        Returns:
+            True if uninstalled, False if not found
+        """
+        install_path = self._get_install_path(namespace, scope)
+
+        if not install_path.exists():
+            return False
+
+        shutil.rmtree(install_path)
+        logger.info(f"Uninstalled MCP template '{namespace}'")
+
+        return True

aiconfigkit/core/mcp/set_manager.py

@@ -0,0 +1 @@
+"""MCP set activation and management."""

aiconfigkit/core/mcp/validator.py

@@ -0,0 +1 @@
+"""MCP server configuration validation."""