mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.29__py3-none-any.whl

mcp_proxy_adapter/commands/auth_validation_command.py

@@ -13,11 +13,10 @@ Version: 1.0.0
 """
 
 import logging
-from typing import Dict, List, Any, Optional, Union
+from typing import Union, Dict, Any
 
 from ..commands.base import Command
 from ..commands.result import SuccessResult, ErrorResult
-from ..core.auth_validator import AuthValidator, AuthValidationResult
 
 
 from mcp_proxy_adapter.core.logging import get_global_logger
@@ -35,208 +34,10 @@ class AuthValidationCommand(Command):
         self.validator = AuthValidator()
         self.logger = logging.getLogger(__name__)
 
-    async def auth_validate(
-        self, auth_data: Dict[str, Any]
-    ) -> Union[SuccessResult, ErrorResult]:
-        """
-        Universal authentication validation.
-
-        Validates authentication data based on the provided type.
-        Supports certificate, token, mTLS, and SSL validation.
-
-        Args:
-            auth_data: Authentication data dictionary containing:
-                - auth_type: Type of authentication (auto/certificate/token/mtls/ssl)
-                - cert_path: Path to certificate file (for certificate/mtls/ssl)
-                - cert_type: Type of certificate (server/client/ca)
-                - token: Token string (for token validation)
-                - token_type: Type of token (jwt/api)
-                - client_cert: Path to client certificate (for mTLS)
-                - ca_cert: Path to CA certificate (for mTLS)
-                - server_cert: Path to server certificate (for SSL)
-
-        Returns:
-            CommandResult with validation status and extracted roles
-        """
-        try:
-            auth_type = auth_data.get("auth_type", "auto")
-
-            # Perform validation
-            result = self.validator.validate_auth(auth_data, auth_type)
-
-            if result.is_valid:
-                return SuccessResult(
-                    data={"valid": True, "roles": result.roles, "auth_type": auth_type}
-                )
-            else:
-                error_data = result.to_json_rpc_error()
-                return ErrorResult(
-                    message=error_data["message"], code=error_data["code"]
-                )
-
-        except Exception as e:
-            self.get_global_logger().error(f"Authentication validation error: {e}")
-            return ErrorResult(
-                message=f"Internal authentication validation error: {str(e)}",
-                code=-32603,
-            )
-
-    async def auth_validate_cert(
-        self, cert_path: str, cert_type: str = "server"
-    ) -> Union[SuccessResult, ErrorResult]:
-        """
-        Validate certificate.
-
-        Validates a certificate file and extracts roles if present.
-
-        Args:
-            cert_path: Path to certificate file
-            cert_type: Type of certificate (server/client/ca)
-
-        Returns:
-            CommandResult with certificate validation status and roles
-        """
-        try:
-            # Perform certificate validation
-            result = self.validator.validate_certificate(cert_path, cert_type)
-
-            if result.is_valid:
-                return SuccessResult(
-                    data={
-                        "valid": True,
-                        "cert_path": cert_path,
-                        "cert_type": cert_type,
-                        "roles": result.roles,
-                    }
-                )
-            else:
-                error_data = result.to_json_rpc_error()
-                return ErrorResult(
-                    message=error_data["message"], code=error_data["code"]
-                )
-
-        except Exception as e:
-            self.get_global_logger().error(f"Certificate validation error: {e}")
-            return ErrorResult(
-                message=f"Internal certificate validation error: {str(e)}", code=-32603
-            )
-
-    async def auth_validate_token(
-        self, token: str, token_type: str = "jwt"
-    ) -> Union[SuccessResult, ErrorResult]:
-        """
-        Validate token.
-
-        Validates a token and extracts roles if present.
-
-        Args:
-            token: Token string to validate
-            token_type: Type of token (jwt/api)
 
-        Returns:
-            CommandResult with token validation status and roles
-        """
-        try:
-            # Perform token validation
-            result = self.validator.validate_token(token, token_type)
 
-            if result.is_valid:
-                return SuccessResult(
-                    data={
-                        "valid": True,
-                        "token_type": token_type,
-                        "roles": result.roles,
-                    }
-                )
-            else:
-                error_data = result.to_json_rpc_error()
-                return ErrorResult(
-                    message=error_data["message"], code=error_data["code"]
-                )
 
-        except Exception as e:
-            self.get_global_logger().error(f"Token validation error: {e}")
-            return ErrorResult(
-                message=f"Internal token validation error: {str(e)}", code=-32603
-            )
-
-    async def auth_validate_mtls(
-        self, client_cert: str, ca_cert: str
-    ) -> Union[SuccessResult, ErrorResult]:
-        """
-        Validate mTLS connection.
-
-        Validates client certificate against CA certificate and extracts roles.
-
-        Args:
-            client_cert: Path to client certificate
-            ca_cert: Path to CA certificate
 
-        Returns:
-            CommandResult with mTLS validation status and roles
-        """
-        try:
-            # Perform mTLS validation
-            result = self.validator.validate_mtls(client_cert, ca_cert)
-
-            if result.is_valid:
-                return SuccessResult(
-                    data={
-                        "valid": True,
-                        "client_cert": client_cert,
-                        "ca_cert": ca_cert,
-                        "roles": result.roles,
-                    }
-                )
-            else:
-                error_data = result.to_json_rpc_error()
-                return ErrorResult(
-                    message=error_data["message"], code=error_data["code"]
-                )
-
-        except Exception as e:
-            self.get_global_logger().error(f"mTLS validation error: {e}")
-            return ErrorResult(
-                message=f"Internal mTLS validation error: {str(e)}", code=-32603
-            )
-
-    async def auth_validate_ssl(
-        self, server_cert: str
-    ) -> Union[SuccessResult, ErrorResult]:
-        """
-        Validate SSL connection.
-
-        Validates server certificate and extracts roles if present.
-
-        Args:
-            server_cert: Path to server certificate
-
-        Returns:
-            CommandResult with SSL validation status and roles
-        """
-        try:
-            # Perform SSL validation
-            result = self.validator.validate_ssl(server_cert)
-
-            if result.is_valid:
-                return SuccessResult(
-                    data={
-                        "valid": True,
-                        "server_cert": server_cert,
-                        "roles": result.roles,
-                    }
-                )
-            else:
-                error_data = result.to_json_rpc_error()
-                return ErrorResult(
-                    message=error_data["message"], code=error_data["code"]
-                )
-
-        except Exception as e:
-            self.get_global_logger().error(f"SSL validation error: {e}")
-            return ErrorResult(
-                message=f"Internal SSL validation error: {str(e)}", code=-32603
-            )
 
     async def execute(self, **kwargs) -> Union[SuccessResult, ErrorResult]:
         """
@@ -258,149 +59,11 @@ class AuthValidationCommand(Command):
 
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get command schema for documentation.
-
-        Returns:
-            Dictionary containing command schema
-        """
+        """Get JSON schema for auth validation command."""
         return {
-            "auth_validate": {
-                "description": "Universal authentication validation",
-                "parameters": {
-                    "auth_data": {
-                        "type": "object",
-                        "description": "Authentication data dictionary",
-                        "properties": {
-                            "auth_type": {
-                                "type": "string",
-                                "enum": ["auto", "certificate", "token", "mtls", "ssl"],
-                                "description": "Type of authentication to validate",
-                            },
-                            "cert_path": {
-                                "type": "string",
-                                "description": "Path to certificate file",
-                            },
-                            "cert_type": {
-                                "type": "string",
-                                "enum": ["server", "client", "ca"],
-                                "description": "Type of certificate",
-                            },
-                            "token": {
-                                "type": "string",
-                                "description": "Token string to validate",
-                            },
-                            "token_type": {
-                                "type": "string",
-                                "enum": ["jwt", "api"],
-                                "description": "Type of token",
-                            },
-                            "client_cert": {
-                                "type": "string",
-                                "description": "Path to client certificate (for mTLS)",
-                            },
-                            "ca_cert": {
-                                "type": "string",
-                                "description": "Path to CA certificate (for mTLS)",
-                            },
-                            "server_cert": {
-                                "type": "string",
-                                "description": "Path to server certificate (for SSL)",
-                            },
-                        },
-                    }
-                },
-                "returns": {
-                    "type": "object",
-                    "properties": {
-                        "valid": {"type": "boolean"},
-                        "roles": {"type": "array", "items": {"type": "string"}},
-                        "auth_type": {"type": "string"},
-                    },
-                },
-            },
-            "auth_validate_cert": {
-                "description": "Validate certificate",
-                "parameters": {
-                    "cert_path": {
-                        "type": "string",
-                        "description": "Path to certificate file",
-                    },
-                    "cert_type": {
-                        "type": "string",
-                        "enum": ["server", "client", "ca"],
-                        "description": "Type of certificate",
-                    },
-                },
-                "returns": {
-                    "type": "object",
-                    "properties": {
-                        "valid": {"type": "boolean"},
-                        "cert_path": {"type": "string"},
-                        "cert_type": {"type": "string"},
-                        "roles": {"type": "array", "items": {"type": "string"}},
-                    },
-                },
-            },
-            "auth_validate_token": {
-                "description": "Validate token",
-                "parameters": {
-                    "token": {
-                        "type": "string",
-                        "description": "Token string to validate",
-                    },
-                    "token_type": {
-                        "type": "string",
-                        "enum": ["jwt", "api"],
-                        "description": "Type of token",
-                    },
-                },
-                "returns": {
-                    "type": "object",
-                    "properties": {
-                        "valid": {"type": "boolean"},
-                        "token_type": {"type": "string"},
-                        "roles": {"type": "array", "items": {"type": "string"}},
-                    },
-                },
-            },
-            "auth_validate_mtls": {
-                "description": "Validate mTLS connection",
-                "parameters": {
-                    "client_cert": {
-                        "type": "string",
-                        "description": "Path to client certificate",
-                    },
-                    "ca_cert": {
-                        "type": "string",
-                        "description": "Path to CA certificate",
-                    },
-                },
-                "returns": {
-                    "type": "object",
-                    "properties": {
-                        "valid": {"type": "boolean"},
-                        "client_cert": {"type": "string"},
-                        "ca_cert": {"type": "string"},
-                        "roles": {"type": "array", "items": {"type": "string"}},
-                    },
-                },
-            },
-            "auth_validate_ssl": {
-                "description": "Validate SSL connection",
-                "parameters": {
-                    "server_cert": {
-                        "type": "string",
-                        "description": "Path to server certificate",
-                    }
-                },
-                "returns": {
-                    "type": "object",
-                    "properties": {
-                        "valid": {"type": "boolean"},
-                        "server_cert": {"type": "string"},
-                        "roles": {"type": "array", "items": {"type": "string"}},
-                    },
-                },
-            },
+            "type": "object",
+            "properties": {
+                "method": {"type": "string", "enum": ["validate_token", "validate_certificate", "validate_mtls"]},
+                "params": {"type": "object"}
+            }
         }

mcp_proxy_adapter/commands/base.py

@@ -4,11 +4,10 @@ Base command classes for MCP Microservice.
 
 import inspect
 from abc import ABC, abstractmethod
-from typing import Any, ClassVar, Dict, List, Optional, Type, TypeVar
+from typing import TypeVar, Type, ClassVar, Dict, Any, List
 
 from docstring_parser import parse
 
-from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
 from mcp_proxy_adapter.core.errors import (
     CommandError,
     InternalError,
@@ -19,6 +18,24 @@ from mcp_proxy_adapter.core.errors import (
 from mcp_proxy_adapter.core.logging import get_global_logger
 
 
+class CommandResult:
+    """Base class for command results."""
+    
+    def __init__(self, success: bool = True, data: dict = None, error: str = None):
+        self.success = success
+        self.data = data or {}
+        self.error = error
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        result = {"success": self.success}
+        if self.data:
+            result["data"] = self.data
+        if self.error:
+            result["error"] = self.error
+        return result
+
+
 T = TypeVar("T", bound=CommandResult)
 
 
@@ -260,47 +277,6 @@ class Command(ABC):
         return params
 
     @classmethod
-    def get_metadata(cls) -> Dict[str, Any]:
-        """
-        Returns complete metadata about the command.
-
-        Provides a single access point to all command metadata.
-
-        Returns:
-            Dict with command metadata
-        """
-        # Get and format docstring
-        doc = cls.__doc__ or ""
-        description = inspect.cleandoc(doc) if doc else ""
-
-        # Extract first line for summary
-        summary = description.split("\n")[0] if description else ""
-
-        # Get parameters information
-        param_info = cls.get_param_info()
-
-        # Generate examples based on parameters
-        examples = cls._generate_examples(param_info)
-
-        return {
-            "name": cls.name,
-            "version": cls.version,
-            "plugin": cls.plugin,
-            "descr": cls.descr,
-            "category": cls.category,
-            "author": cls.author,
-            "email": cls.email,
-            "source_url": cls.source_url,
-            "summary": summary,
-            "description": description,
-            "params": param_info,
-            "examples": examples,
-            "schema": cls.get_schema(),
-            "result_schema": cls.get_result_schema(),
-            "result_class": (
-                cls.result_class.__name__ if hasattr(cls, "result_class") else None
-            ),
-        }
 
     @classmethod
     def _generate_examples(

mcp_proxy_adapter/commands/builtin_commands.py

@@ -26,80 +26,5 @@ from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
 from mcp_proxy_adapter.core.logging import get_global_logger
 
 
-def register_builtin_commands() -> int:
-    """
-    Register all built-in framework commands.
 
-    Returns:
-        Number of built-in commands registered.
-    """
-    get_global_logger().debug("Registering built-in framework commands...")
 
-    builtin_commands = [
-        HelpCommand,
-        HealthCommand,
-        ConfigCommand,
-        ReloadCommand,
-        SettingsCommand,
-        LoadCommand,
-        UnloadCommand,
-        PluginsCommand,
-        TransportManagementCommand,
-        ProxyRegistrationCommand,
-        EchoCommand,
-        RoleTestCommand,
-    ]
-
-    registered_count = 0
-
-    for command_class in builtin_commands:
-        try:
-            # Get command name for logging
-            command_name = getattr(
-                command_class, "name", command_class.__name__.lower()
-            )
-            if command_name.endswith("command"):
-                command_name = command_name[:-7]
-
-            # Check if command already exists (should not happen for built-in)
-            if registry.command_exists(command_name):
-                get_global_logger().warning(
-                    f"Built-in command '{command_name}' already exists, skipping"
-                )
-                continue
-
-            # Register the command
-            registry.register_builtin(command_class)
-            registered_count += 1
-            get_global_logger().debug(f"Registered built-in command: {command_name}")
-
-        except Exception as e:
-            get_global_logger().error(
-                f"Failed to register built-in command {command_class.__name__}: {e}"
-            )
-
-    get_global_logger().info(f"Registered {registered_count} built-in framework commands")
-    return registered_count
-
-
-def get_builtin_commands_list() -> list:
-    """
-    Get list of all built-in command classes.
-
-    Returns:
-        List of built-in command classes.
-    """
-    return [
-        HelpCommand,
-        HealthCommand,
-        ConfigCommand,
-        ReloadCommand,
-        SettingsCommand,
-        LoadCommand,
-        UnloadCommand,
-        PluginsCommand,
-        TransportManagementCommand,
-        ProxyRegistrationCommand,
-        EchoCommand,
-        RoleTestCommand,
-    ]

mcp_proxy_adapter/commands/catalog/__init__.py

@@ -0,0 +1,20 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command catalog management package for MCP Proxy Adapter.
+"""
+
+from .command_catalog import CommandCatalog
+from .catalog_manager import CatalogManager
+from .catalog_loader import CatalogLoader
+from .catalog_syncer import CatalogSyncer
+from .dependency_manager import DependencyManager
+
+__all__ = [
+    "CommandCatalog",
+    "CatalogManager",
+    "CatalogLoader",
+    "CatalogSyncer",
+    "DependencyManager",
+]

mcp_proxy_adapter/commands/catalog/catalog_loader.py

@@ -0,0 +1,34 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Catalog loading utilities for MCP Proxy Adapter.
+"""
+
+import json
+from pathlib import Path
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .command_catalog import CommandCatalog
+
+# Try to import requests, but don't fail if not available
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    get_global_logger().warning(
+        "requests library not available, HTTP/HTTPS functionality will be limited"
+    )
+
+
+class CatalogLoader:
+    """Loader for command catalogs from various sources."""
+
+    def __init__(self):
+        """Initialize catalog loader."""
+        self.logger = get_global_logger()
+
+
+
+