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

mcp_proxy_adapter/commands/roles_management_command.py

@@ -10,7 +10,6 @@ Version: 1.0.0
 
 import json
 import logging
-from typing import Dict, List, Optional, Any
 from pathlib import Path
 
 from .base import Command
@@ -40,57 +39,8 @@ class RolesListResult(SuccessResult):
         self.roles = roles
         self.total_count = total_count
 
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert to dictionary format.
-
-        Returns:
-            Dictionary representation
-        """
-        return {
-            "success": self.success,
-            "roles": self.roles,
-            "total_count": self.total_count,
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result.
-
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "roles": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "name": {"type": "string"},
-                            "description": {"type": "string"},
-                            "allowed_servers": {
-                                "type": "array",
-                                "items": {"type": "string"},
-                            },
-                            "allowed_clients": {
-                                "type": "array",
-                                "items": {"type": "string"},
-                            },
-                            "permissions": {
-                                "type": "array",
-                                "items": {"type": "string"},
-                            },
-                            "priority": {"type": "integer"},
-                        },
-                    },
-                },
-                "total_count": {"type": "integer"},
-            },
-        }
 
 
 class RolesCreateResult(SuccessResult):
@@ -111,35 +61,8 @@ class RolesCreateResult(SuccessResult):
         self.role_name = role_name
         self.role_config = role_config
 
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert to dictionary format.
-
-        Returns:
-            Dictionary representation
-        """
-        return {
-            "success": self.success,
-            "role_name": self.role_name,
-            "role_config": self.role_config,
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result.
-
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "role_name": {"type": "string"},
-                "role_config": {"type": "object"},
-            },
-        }
 
 
 class RolesUpdateResult(SuccessResult):
@@ -160,35 +83,8 @@ class RolesUpdateResult(SuccessResult):
         self.role_name = role_name
         self.role_config = role_config
 
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert to dictionary format.
-
-        Returns:
-            Dictionary representation
-        """
-        return {
-            "success": self.success,
-            "role_name": self.role_name,
-            "role_config": self.role_config,
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result.
-
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "role_name": {"type": "string"},
-                "role_config": {"type": "object"},
-            },
-        }
 
 
 class RolesDeleteResult(SuccessResult):
@@ -207,30 +103,8 @@ class RolesDeleteResult(SuccessResult):
         self.success = True
         self.role_name = role_name
 
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert to dictionary format.
-
-        Returns:
-            Dictionary representation
-        """
-        return {"success": self.success, "role_name": self.role_name}
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result.
-
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "role_name": {"type": "string"},
-            },
-        }
 
 
 class RolesValidateResult(SuccessResult):
@@ -253,37 +127,8 @@ class RolesValidateResult(SuccessResult):
         self.is_valid = is_valid
         self.validation_errors = validation_errors
 
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert to dictionary format.
-
-        Returns:
-            Dictionary representation
-        """
-        return {
-            "success": self.success,
-            "role_name": self.role_name,
-            "is_valid": self.is_valid,
-            "validation_errors": self.validation_errors,
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result.
-
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "success": {"type": "boolean"},
-                "role_name": {"type": "string"},
-                "is_valid": {"type": "boolean"},
-                "validation_errors": {"type": "array", "items": {"type": "string"}},
-            },
-        }
 
 
 class RolesManagementCommand(Command):
@@ -655,47 +500,3 @@ class RolesManagementCommand(Command):
         return errors
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters.
-
-        Returns:
-            JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": ["list", "create", "update", "delete", "validate"],
-                    "description": "Action to perform",
-                },
-                "role_name": {"type": "string", "description": "Name of the role"},
-                "description": {"type": "string", "description": "Role description"},
-                "allowed_servers": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "List of allowed servers",
-                },
-                "allowed_clients": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "List of allowed clients",
-                },
-                "permissions": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "List of permissions",
-                },
-                "priority": {"type": "integer", "description": "Role priority"},
-                "role_config": {
-                    "type": "object",
-                    "description": "Complete role configuration",
-                },
-                "filter": {"type": "string", "description": "Filter for list action"},
-                "limit": {"type": "integer", "description": "Limit for list action"},
-                "offset": {"type": "integer", "description": "Offset for list action"},
-            },
-            "required": ["action"],
-            "additionalProperties": False,
-        }

mcp_proxy_adapter/commands/security_command.py

@@ -9,12 +9,8 @@ email: vasilyvz@gmail.com
 """
 
 import logging
-from typing import Dict, Any, List, Optional
-from pathlib import Path
 
 from .base import Command
-from .result import CommandResult, SuccessResult, ErrorResult
-from mcp_proxy_adapter.core.security_integration import create_security_integration
 
 from mcp_proxy_adapter.core.logging import get_global_logger
 logger = logging.getLogger(__name__)
@@ -44,34 +40,8 @@ class SecurityResult(CommandResult):
         self.data = data or {}
         self.error = error
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            "operation": self.operation,
-            "success": self.success,
-            "data": self.data,
-            "error": self.error,
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get result schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "operation": {
-                    "type": "string",
-                    "description": "Security operation performed",
-                },
-                "success": {
-                    "type": "boolean",
-                    "description": "Whether operation was successful",
-                },
-                "data": {"type": "object", "description": "Operation data"},
-                "error": {"type": "string", "description": "Error message if any"},
-            },
-            "required": ["operation", "success"],
-        }
 
 
 class SecurityCommand(Command):

mcp_proxy_adapter/commands/settings_command.py

@@ -31,54 +31,8 @@ class SettingsResult:
         self.all_settings = all_settings
         self.error_message = error_message
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert result to dictionary."""
-        result = {"success": self.success, "operation": self.operation}
-
-        if self.key is not None:
-            result["key"] = self.key
-        if self.value is not None:
-            result["value"] = self.value
-        if self.all_settings is not None:
-            result["all_settings"] = self.all_settings
-        if self.error_message is not None:
-            result["error_message"] = self.error_message
-
-        return result
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get schema for the result."""
-        return {
-            "type": "object",
-            "properties": {
-                "success": {
-                    "type": "boolean",
-                    "description": "Whether the operation was successful",
-                },
-                "operation": {
-                    "type": "string",
-                    "description": "Type of operation performed",
-                    "enum": ["get", "set", "get_all", "reload"],
-                },
-                "key": {
-                    "type": "string",
-                    "description": "Configuration key (for get/set operations)",
-                },
-                "value": {
-                    "description": "Configuration value (for get/set operations)"
-                },
-                "all_settings": {
-                    "type": "object",
-                    "description": "All configuration settings (for get_all operation)",
-                },
-                "error_message": {
-                    "type": "string",
-                    "description": "Error message if operation failed",
-                },
-            },
-            "required": ["success", "operation"],
-        }
 
 
 class SettingsCommand(Command):
@@ -157,25 +111,3 @@ class SettingsCommand(Command):
             )
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get schema for the command."""
-        return {
-            "type": "object",
-            "properties": {
-                "operation": {
-                    "type": "string",
-                    "description": "Operation to perform",
-                    "enum": ["get", "set", "get_all", "reload"],
-                    "default": "get_all",
-                },
-                "key": {
-                    "type": "string",
-                    "description": "Configuration key in dot notation (e.g., 'server.host', 'custom.feature_enabled')",
-                },
-                "value": {
-                    "description": "Configuration value to set (for 'set' operation)"
-                },
-            },
-            "required": ["operation"],
-            "additionalProperties": False,
-        }

mcp_proxy_adapter/commands/ssl_setup_command.py

@@ -16,7 +16,6 @@ from mcp_proxy_adapter.core.logging import get_global_logger
 try:
     from mcp_security_framework.core.ssl_manager import SSLManager
     from mcp_security_framework.schemas.config import SSLConfig
-    from mcp_security_framework.utils.cert_utils import validate_certificate_chain
 
     SECURITY_FRAMEWORK_AVAILABLE = True
 except ImportError:
@@ -303,46 +302,5 @@ class SSLSetupCommand(Command):
                 },
             )
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert command to dictionary."""
-        return {
-            "name": self.name,
-            "description": self.description,
-            "version": self.version,
-            "framework_available": SECURITY_FRAMEWORK_AVAILABLE,
-        }
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """Get command schema."""
-        return {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": ["get", "set", "update", "reset", "test"],
-                    "description": "Action to perform",
-                },
-                "config_data": {
-                    "type": "object",
-                    "description": "SSL configuration data",
-                    "properties": {
-                        "enabled": {"type": "boolean"},
-                        "cert_file": {"type": "string"},
-                        "key_file": {"type": "string"},
-                        "ca_file": {"type": "string"},
-                        "verify_mode": {"type": "string"},
-                        "cipher_suites": {"type": "array", "items": {"type": "string"}},
-                    },
-                },
-                "cert_file": {
-                    "type": "string",
-                    "description": "Certificate file path for testing",
-                },
-                "key_file": {
-                    "type": "string",
-                    "description": "Private key file path for testing",
-                },
-            },
-            "required": ["action"],
-        }

mcp_proxy_adapter/commands/token_management_command.py

@@ -16,7 +16,6 @@ import json
 import logging
 import time
 import uuid
-from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Dict, List, Any, Optional, Union
 

mcp_proxy_adapter/commands/transport_management_command.py

@@ -4,9 +4,7 @@ Transport Management Command
 This command provides transport management functionality for the MCP Proxy Adapter.
 """
 
-from typing import Dict, Any, ClassVar
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import SuccessResult, ErrorResult
 from mcp_proxy_adapter.core.transport_manager import transport_manager
 from mcp_proxy_adapter.core.logging import get_global_logger
 
@@ -40,24 +38,6 @@ class TransportManagementCommand(Command):
     descr = "Manage and query transport configurations (HTTP, HTTPS, MTLS)"
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get command schema.
-
-        Returns:
-            Command schema dictionary
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": ["get_info", "validate", "reload"],
-                    "description": "Action to perform",
-                }
-            },
-            "required": ["action"],
-        }
 
     async def execute(self, **params) -> TransportManagementResult:
         """

mcp_proxy_adapter/commands/unload_command.py

@@ -5,7 +5,6 @@ Module with unload command implementation.
 from typing import Dict, Any, Optional, List
 
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
 from mcp_proxy_adapter.commands.command_registry import registry
 
 
@@ -37,28 +36,6 @@ class UnloadResult(SuccessResult):
         super().__init__(data=data, message=message)
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for result validation.
-
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "data": {
-                    "type": "object",
-                    "properties": {
-                        "success": {"type": "boolean"},
-                        "command_name": {"type": "string"},
-                        "error": {"type": "string"},
-                    },
-                    "required": ["success", "command_name"],
-                }
-            },
-            "required": ["data"],
-        }
 
 
 class UnloadCommand(Command):
@@ -111,53 +88,5 @@ class UnloadCommand(Command):
         )
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Get JSON schema for command parameters.
-
-        Returns:
-            Dict[str, Any]: JSON schema
-        """
-        return {
-            "type": "object",
-            "properties": {
-                "command_name": {
-                    "type": "string",
-                    "description": "Name of the command to unload (must be a loaded command)",
-                }
-            },
-            "required": ["command_name"],
-        }
 
     @classmethod
-    def _generate_examples(
-        cls, params: Dict[str, Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
-        """
-        Generate custom examples for unload command.
-
-        Args:
-            params: Information about command parameters
-
-        Returns:
-            List of examples
-        """
-        examples = [
-            {
-                "command": cls.name,
-                "params": {"command_name": "test_command"},
-                "description": "Unload a previously loaded test command",
-            },
-            {
-                "command": cls.name,
-                "params": {"command_name": "remote_command"},
-                "description": "Unload a command that was loaded from URL",
-            },
-            {
-                "command": cls.name,
-                "params": {"command_name": "custom_command"},
-                "description": "Unload a custom command loaded from local file",
-            },
-        ]
-
-        return examples