mcp-proxy-adapter 4.1.1__py3-none-any.whl → 6.0.1__py3-none-any.whl

mcp_proxy_adapter/commands/auth_validation_command.py

@@ -0,0 +1,408 @@
+"""
+Authentication Validation Commands
+
+This module provides commands for validating different types of authentication:
+- Universal authentication validation
+- Certificate validation
+- Token validation
+- mTLS validation
+- SSL validation
+
+Author: MCP Proxy Adapter Team
+Version: 1.0.0
+"""
+
+import logging
+from typing import Dict, List, Any, Optional, Union
+
+from ..commands.base import Command
+from ..commands.result import SuccessResult, ErrorResult
+from ..core.auth_validator import AuthValidator, AuthValidationResult
+
+
+class AuthValidationCommand(Command):
+    """
+    Authentication validation commands.
+    
+    Provides commands for validating different types of authentication
+    using the universal AuthValidator.
+    """
+    
+    def __init__(self):
+        """Initialize authentication validation command."""
+        super().__init__()
+        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.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.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.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.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.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]:
+        """
+        Execute authentication validation command.
+        
+        This is a placeholder method to satisfy the abstract base class.
+        Individual validation methods should be called directly.
+        
+        Args:
+            **kwargs: Command parameters
+            
+        Returns:
+            Command result
+        """
+        return ErrorResult(
+            message="Method not found. Use specific validation methods instead.",
+            code=-32601
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get command schema for documentation.
+        
+        Returns:
+            Dictionary containing command schema
+        """
+        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"}}
+                    }
+                }
+            }
+        } 

mcp_proxy_adapter/commands/base.py

@@ -13,7 +13,6 @@ from mcp_proxy_adapter.core.errors import (
     CommandError, InternalError, InvalidParamsError, NotFoundError, ValidationError
 )
 from mcp_proxy_adapter.core.logging import logger
-from .hooks import hooks, HookContext
 
 
 T = TypeVar("T", bound=CommandResult)
@@ -26,6 +25,20 @@ class Command(ABC):
     
     # Command name for registration
     name: ClassVar[str]
+    # Command version (default: 0.1)
+    version: ClassVar[str] = "0.1"
+    # Plugin filename
+    plugin: ClassVar[str] = ""
+    # Command description
+    descr: ClassVar[str] = ""
+    # Command category
+    category: ClassVar[str] = ""
+    # Command author
+    author: ClassVar[str] = ""
+    # Author email
+    email: ClassVar[str] = ""
+    # Source URL
+    source_url: ClassVar[str] = ""
     # Result class
     result_class: ClassVar[Type[CommandResult]]
     
@@ -35,7 +48,7 @@ class Command(ABC):
         Execute command with the specified parameters.
         
         Args:
-            **kwargs: Command parameters.
+            **kwargs: Command parameters including optional 'context' parameter.
             
         Returns:
             Command result.
@@ -68,8 +81,7 @@ class Command(ABC):
             return cls.result_class.get_schema()
         return {}
     
-    @classmethod
-    def validate_params(cls, params: Dict[str, Any]) -> Dict[str, Any]:
+    def validate_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
         """
         Validate command parameters.
         
@@ -100,9 +112,39 @@ class Command(ABC):
                 else:
                     # For most parameters, remove None values to avoid issues
                     del validated_params[key]
+        
+        # Get command schema to validate parameters
+        schema = self.get_schema()
+        if schema and "properties" in schema:
+            allowed_properties = schema["properties"].keys()
+            
+            # Filter out parameters that are not in the schema
+            invalid_params = []
+            for param_name in list(validated_params.keys()):
+                if param_name not in allowed_properties:
+                    invalid_params.append(param_name)
+                    del validated_params[param_name]
+            
+            # Log warning about invalid parameters
+            if invalid_params:
+                logger.warning(f"Command {self.__class__.__name__} received invalid parameters: {invalid_params}. "
+                             f"Allowed parameters: {list(allowed_properties)}")
+        
+        # Validate required parameters based on command schema
+        if schema and "required" in schema:
+            required_params = schema["required"]
+            missing_params = []
+            
+            for param in required_params:
+                if param not in validated_params:
+                    missing_params.append(param)
+            
+            if missing_params:
+                raise ValidationError(
+                    f"Missing required parameters: {', '.join(missing_params)}",
+                    data={"missing_parameters": missing_params}
+                )
                 
-        # This is a simple implementation that can be overridden by subclasses
-        # In real implementation this method would validate parameters against the schema
         return validated_params
     
     @classmethod
@@ -111,11 +153,14 @@ class Command(ABC):
         Runs the command with the specified arguments.
 
         Args:
-            **kwargs: Command arguments.
+            **kwargs: Command arguments including optional 'context' parameter.
 
         Returns:
             Command result.
         """
+        # Extract context from kwargs
+        context = kwargs.pop('context', {}) if 'context' in kwargs else {}
+        
         try:
             logger.debug(f"Running command {cls.__name__} with params: {kwargs}")
             
@@ -134,35 +179,17 @@ class Command(ABC):
             if kwargs is None:
                 kwargs = {}
                 
-            # Parameters validation
-            validated_params = cls.validate_params(kwargs)
-            
-            # Execute before hooks
-            hook_context = hooks.execute_before_hooks(command_name, validated_params)
-            
-            # Check if standard processing should be skipped
-            if not hook_context.standard_processing:
-                logger.debug(f"Standard processing skipped for command {command_name} due to hook")
-                # Return the params as result if standard processing is disabled
-                return SuccessResult(data=validated_params)
-            
             # Get command with priority (custom commands first, then built-in)
-            priority_command_class = registry.get_priority_command(command_name)
-            if priority_command_class is None:
+            command_class = registry.get_command(command_name)
+            if command_class is None:
                 raise NotFoundError(f"Command '{command_name}' not found")
             
-            # Check if we have a registered instance for this command
-            if registry.has_instance(command_name):
-                # Use existing instance with dependencies
-                command = registry.get_command_instance(command_name)
-                result = await command.execute(**validated_params)
-            else:
-                # Create new instance for commands without dependencies
-                command = priority_command_class()
-                result = await command.execute(**validated_params)
+            # Create new instance and validate parameters
+            command = command_class()
+            validated_params = command.validate_params(kwargs)
             
-            # Execute after hooks
-            hooks.execute_after_hooks(command_name, validated_params, result)
+            # Execute command with validated parameters and context
+            result = await command.execute(**validated_params, context=context)
             
             logger.debug(f"Command {cls.__name__} executed successfully")
             return result
@@ -271,6 +298,13 @@ class Command(ABC):
         
         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,

mcp_proxy_adapter/commands/builtin_commands.py

@@ -0,0 +1,95 @@
+"""
+Module for registering built-in framework commands.
+
+This module contains the procedure for adding predefined commands
+that are part of the framework.
+"""
+
+from typing import List
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.help_command import HelpCommand
+from mcp_proxy_adapter.commands.health_command import HealthCommand
+from mcp_proxy_adapter.commands.config_command import ConfigCommand
+from mcp_proxy_adapter.commands.reload_command import ReloadCommand
+from mcp_proxy_adapter.commands.settings_command import SettingsCommand
+from mcp_proxy_adapter.commands.load_command import LoadCommand
+from mcp_proxy_adapter.commands.unload_command import UnloadCommand
+from mcp_proxy_adapter.commands.plugins_command import PluginsCommand
+from mcp_proxy_adapter.commands.transport_management_command import TransportManagementCommand
+from mcp_proxy_adapter.commands.proxy_registration_command import ProxyRegistrationCommand
+from mcp_proxy_adapter.commands.echo_command import EchoCommand
+from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
+from mcp_proxy_adapter.core.logging import logger
+
+
+def register_builtin_commands() -> int:
+    """
+    Register all built-in framework commands.
+    
+    Returns:
+        Number of built-in commands registered.
+    """
+    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):
+                logger.warning(f"Built-in command '{command_name}' already exists, skipping")
+                continue
+            
+            # Register the command
+            registry.register_builtin(command_class)
+            registered_count += 1
+            logger.debug(f"Registered built-in command: {command_name}")
+            
+        except Exception as e:
+            logger.error(f"Failed to register built-in command {command_class.__name__}: {e}")
+    
+    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
+    ]