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

mcp_proxy_adapter/commands/unload_command.py

@@ -0,0 +1,158 @@
+"""
+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
+
+
+class UnloadResult(SuccessResult):
+    """
+    Result of the unload command execution.
+    """
+    
+    def __init__(self, success: bool, command_name: str, message: str, error: Optional[str] = None):
+        """
+        Initialize unload command result.
+        
+        Args:
+            success: Whether unloading was successful
+            command_name: Name of the command that was unloaded
+            message: Result message
+            error: Error message if unloading failed
+        """
+        data = {
+            "success": success,
+            "command_name": command_name
+        }
+        if error:
+            data["error"] = error
+            
+        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):
+    """
+    Command that unloads loaded commands from registry.
+    
+    This command allows removal of dynamically loaded commands from the command registry.
+    Only commands that were loaded via the 'load' command or from the commands directory
+    can be unloaded. Built-in commands and custom commands registered with higher priority
+    cannot be unloaded using this command.
+    
+    When a command is unloaded:
+    - The command class is removed from the loaded commands registry
+    - Any command instances are also removed
+    - The command becomes unavailable for execution
+    - Built-in and custom commands with the same name remain unaffected
+    
+    This is useful for:
+    - Removing outdated or problematic commands
+    - Managing memory usage by unloading unused commands
+    - Testing different versions of commands
+    - Cleaning up temporary commands loaded for testing
+    
+    Note: Unloading a command does not affect other commands and does not require
+    a system restart. The command can be reloaded later if needed.
+    """
+    
+    name = "unload"
+    result_class = UnloadResult
+    
+    async def execute(self, command_name: str, **kwargs) -> UnloadResult:
+        """
+        Execute unload command.
+        
+        Args:
+            command_name: Name of the command to unload
+            **kwargs: Additional parameters
+            
+        Returns:
+            UnloadResult: Unload command result
+        """
+        # Unload command from registry
+        result = registry.unload_command(command_name)
+        
+        return UnloadResult(
+            success=result.get("success", False),
+            command_name=result.get("command_name", command_name),
+            message=result.get("message", "Unknown result"),
+            error=result.get("error")
+        )
+    
+    @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 

mcp_proxy_adapter/config.py

@@ -1,17 +1,20 @@
 """
 Module for microservice configuration management.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
 """
 
 import json
 import os
-from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, List
 
 
 class Config:
     """
     Configuration management class for the microservice.
     Allows loading settings from configuration file and environment variables.
+    Supports optional features that can be enabled/disabled.
     """
 
     def __init__(self, config_path: Optional[str] = None):
@@ -19,7 +22,8 @@ class Config:
         Initialize configuration.
 
         Args:
-            config_path: Path to configuration file. If not specified, "./config.json" is used.
+            config_path: Path to configuration file. If not specified,
+                        "./config.json" is used.
         """
         self.config_path = config_path or "./config.json"
         self.config_data: Dict[str, Any] = {}
@@ -53,11 +57,177 @@ class Config:
             },
             "commands": {
                 "auto_discovery": True,
-                "discovery_path": "mcp_proxy_adapter.commands",  # Path to package with commands (e.g., "myproject.commands")
-                "custom_commands_path": None
+                "commands_directory": "./commands",
+                "catalog_directory": "./catalog",
+                "plugin_servers": [],
+                "auto_install_dependencies": True,
+                "enabled_commands": ["health", "echo", "list", "help"],
+                "disabled_commands": [],
+                "custom_commands_path": "./commands"
+            },
+            "ssl": {
+                "enabled": False,
+                "mode": "https_only",
+                "cert_file": None,
+                "key_file": None,
+                "ca_cert": None,
+                "verify_client": False,
+                "client_cert_required": False,
+                "cipher_suites": [
+                    "TLS_AES_256_GCM_SHA384",
+                    "TLS_CHACHA20_POLY1305_SHA256"
+                ],
+                "min_tls_version": "TLSv1.2",
+                "max_tls_version": "1.3",
+                "token_auth": {
+                    "enabled": False,
+                    "header_name": "Authorization",
+                    "token_prefix": "Bearer",
+                    "tokens_file": "tokens.json",
+                    "token_expiry": 3600,
+                    "jwt_secret": "",
+                    "jwt_algorithm": "HS256"
+                }
+            },
+            "roles": {
+                "enabled": False,
+                "config_file": None,
+                "default_policy": {
+                    "deny_by_default": False,
+                    "require_role_match": False,
+                    "case_sensitive": False,
+                    "allow_wildcard": False
+                },
+                "auto_load": False,
+                "validation_enabled": False
+            },
+            "transport": {
+                "type": "http",
+                "port": None,
+                "ssl": {
+                    "enabled": False,
+                    "cert_file": None,
+                    "key_file": None,
+                    "ca_cert": None,
+                    "verify_client": False,
+                    "client_cert_required": False
+                }
+            },
+            "proxy_registration": {
+                "enabled": False,
+                "proxy_url": "http://localhost:3004",
+                "server_id": "mcp_proxy_adapter",
+                "server_name": "MCP Proxy Adapter",
+                "description": "JSON-RPC API for interacting with MCP Proxy",
+                "registration_timeout": 30,
+                "retry_attempts": 3,
+                "retry_delay": 5,
+                "auto_register_on_startup": True,
+                "auto_unregister_on_shutdown": True
+            },
+            "debug": {
+                "enabled": False,
+                "level": "WARNING"
+            },
+            "security": {
+                "framework": "mcp_security_framework",
+                "enabled": False,
+                "debug": False,
+                "environment": "dev",
+                "version": "1.0.0",
+                "auth": {
+                    "enabled": False,
+                    "methods": ["api_key"],
+                    "api_keys": {},
+                    "user_roles": {},
+                    "jwt_secret": "",
+                    "jwt_algorithm": "HS256",
+                    "jwt_expiry_hours": 24,
+                    "certificate_auth": False,
+                    "certificate_roles_oid": "1.3.6.1.4.1.99999.1.1",
+                    "certificate_permissions_oid": "1.3.6.1.4.1.99999.1.2",
+                    "basic_auth": False,
+                    "oauth2_config": None,
+                    "public_paths": ["/health", "/docs", "/openapi.json"],
+                    "security_headers": None
+                },
+                "ssl": {
+                    "enabled": False,
+                    "cert_file": None,
+                    "key_file": None,
+                    "ca_cert_file": None,
+                    "client_cert_file": None,
+                    "client_key_file": None,
+                    "verify_mode": "CERT_NONE",
+                    "min_tls_version": "TLSv1.2",
+                    "max_tls_version": None,
+                    "cipher_suite": None,
+                    "check_hostname": True,
+                    "check_expiry": True,
+                    "expiry_warning_days": 30
+                },
+                "certificates": {
+                    "enabled": False,
+                    "ca_cert_path": None,
+                    "ca_key_path": None,
+                    "cert_storage_path": "./certs",
+                    "key_storage_path": "./keys",
+                    "default_validity_days": 365,
+                    "key_size": 2048,
+                    "hash_algorithm": "sha256",
+                    "crl_enabled": False,
+                    "crl_path": None,
+                    "crl_validity_days": 30,
+                    "auto_renewal": False,
+                    "renewal_threshold_days": 30
+                },
+                "permissions": {
+                    "enabled": False,
+                    "roles_file": None,
+                    "default_role": "guest",
+                    "admin_role": "admin",
+                    "role_hierarchy": {},
+                    "permission_cache_enabled": False,
+                    "permission_cache_ttl": 300,
+                    "wildcard_permissions": False,
+                    "strict_mode": False,
+                    "roles": None
+                },
+                "rate_limit": {
+                    "enabled": False,
+                    "default_requests_per_minute": 60,
+                    "default_requests_per_hour": 1000,
+                    "burst_limit": 2,
+                    "window_size_seconds": 60,
+                    "storage_backend": "memory",
+                    "redis_config": None,
+                    "cleanup_interval": 300,
+                    "exempt_paths": ["/health", "/docs", "/openapi.json"],
+                    "exempt_roles": ["admin"]
+                },
+                "logging": {
+                    "enabled": True,
+                    "level": "INFO",
+                    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+                    "date_format": "%Y-%m-%d %H:%M:%S",
+                    "file_path": None,
+                    "max_file_size": 10,
+                    "backup_count": 5,
+                    "console_output": True,
+                    "json_format": False,
+                    "include_timestamp": True,
+                    "include_level": True,
+                    "include_module": True
+                }
+            },
+            "protocols": {
+                "enabled": True,
+                "allowed_protocols": ["http", "jsonrpc"],
+                "default_protocol": "http",
+                "auto_discovery": True
             }
         }
-        
+
         # Try to load configuration from file
         if os.path.exists(self.config_path):
             try:
@@ -66,7 +236,7 @@ class Config:
                     self._update_nested_dict(self.config_data, file_config)
             except Exception as e:
                 print(f"Error loading config from {self.config_path}: {e}")
-        
+
         # Load configuration from environment variables
         self._load_env_variables()
 
@@ -131,14 +301,14 @@ class Config:
             Configuration value
         """
         parts = key.split(".")
-        
+
         # Get value from config
         value = self.config_data
         for part in parts:
             if not isinstance(value, dict) or part not in value:
                 return default
             value = value[part]
-            
+
         return value
 
     def get_all(self) -> Dict[str, Any]:
@@ -163,17 +333,17 @@ class Config:
             self.config_data[key] = value
         else:
             section = parts[0]
-            param = ".".join(parts[1:])
-            
+            param_key = ".".join(parts[1:])
+
             if section not in self.config_data:
                 self.config_data[section] = {}
-                
+
             current = self.config_data[section]
             for part in parts[1:-1]:
                 if part not in current:
                     current[part] = {}
                 current = current[part]
-                
+
             current[parts[-1]] = value
 
     def save(self, path: Optional[str] = None) -> None:
@@ -181,7 +351,8 @@ class Config:
         Save configuration to file.
 
         Args:
-            path: Path to configuration file. If not specified, self.config_path is used.
+            path: Path to configuration file. If not specified,
+                  self.config_path is used.
         """
         save_path = path or self.config_path
         with open(save_path, 'w', encoding='utf-8') as f:
@@ -205,6 +376,215 @@ class Config:
                 d[k] = v
         return d
 
+    def enable_feature(self, feature: str) -> None:
+        """
+        Enable a specific feature in the configuration.
+
+        Args:
+            feature: Feature to enable (ssl, auth, roles, proxy_registration,
+                     security)
+        """
+        if feature == "ssl":
+            self.set("ssl.enabled", True)
+            self.set("security.ssl.enabled", True)
+        elif feature == "auth":
+            self.set("security.auth.enabled", True)
+        elif feature == "roles":
+            self.set("security.permissions.enabled", True)
+            self.set("roles.enabled", True)
+        elif feature == "proxy_registration":
+            self.set("proxy_registration.enabled", True)
+        elif feature == "security":
+            self.set("security.enabled", True)
+        elif feature == "rate_limit":
+            self.set("security.rate_limit.enabled", True)
+        elif feature == "certificates":
+            self.set("security.certificates.enabled", True)
+        else:
+            raise ValueError(f"Unknown feature: {feature}")
+
+    def disable_feature(self, feature: str) -> None:
+        """
+        Disable a specific feature in the configuration.
+
+        Args:
+            feature: Feature to disable (ssl, auth, roles, proxy_registration,
+                     security)
+        """
+        if feature == "ssl":
+            self.set("ssl.enabled", False)
+            self.set("security.ssl.enabled", False)
+        elif feature == "auth":
+            self.set("security.auth.enabled", False)
+        elif feature == "roles":
+            self.set("security.permissions.enabled", False)
+            self.set("roles.enabled", False)
+        elif feature == "proxy_registration":
+            self.set("proxy_registration.enabled", False)
+        elif feature == "security":
+            self.set("security.enabled", False)
+        elif feature == "rate_limit":
+            self.set("security.rate_limit.enabled", False)
+        elif feature == "certificates":
+            self.set("security.certificates.enabled", False)
+        else:
+            raise ValueError(f"Unknown feature: {feature}")
+
+    def is_feature_enabled(self, feature: str) -> bool:
+        """
+        Check if a specific feature is enabled.
+
+        Args:
+            feature: Feature to check (ssl, auth, roles, proxy_registration,
+                     security)
+
+        Returns:
+            True if feature is enabled, False otherwise
+        """
+        if feature == "ssl":
+            return (self.get("ssl.enabled", False) or
+                    self.get("security.ssl.enabled", False))
+        elif feature == "auth":
+            return self.get("security.auth.enabled", False)
+        elif feature == "roles":
+            return (self.get("security.permissions.enabled", False) or
+                    self.get("roles.enabled", False))
+        elif feature == "proxy_registration":
+            return self.get("proxy_registration.enabled", False)
+        elif feature == "security":
+            return self.get("security.enabled", False)
+        elif feature == "rate_limit":
+            return self.get("security.rate_limit.enabled", False)
+        elif feature == "certificates":
+            return self.get("security.certificates.enabled", False)
+        else:
+            raise ValueError(f"Unknown feature: {feature}")
+
+    def get_enabled_features(self) -> List[str]:
+        """
+        Get list of all enabled features.
+
+        Returns:
+            List of enabled feature names
+        """
+        features = []
+        if self.is_feature_enabled("ssl"):
+            features.append("ssl")
+        if self.is_feature_enabled("auth"):
+            features.append("auth")
+        if self.is_feature_enabled("roles"):
+            features.append("roles")
+        if self.is_feature_enabled("proxy_registration"):
+            features.append("proxy_registration")
+        if self.is_feature_enabled("security"):
+            features.append("security")
+        if self.is_feature_enabled("rate_limit"):
+            features.append("rate_limit")
+        if self.is_feature_enabled("certificates"):
+            features.append("certificates")
+        return features
+
+    def configure_auth_mode(self, mode: str, **kwargs) -> None:
+        """
+        Configure authentication mode.
+
+        Args:
+            mode: Authentication mode (api_key, jwt, certificate, basic, oauth2)
+            **kwargs: Additional configuration parameters
+        """
+        if mode == "api_key":
+            self.set("security.auth.methods", ["api_key"])
+            if "api_keys" in kwargs:
+                self.set("security.auth.api_keys", kwargs["api_keys"])
+        elif mode == "jwt":
+            self.set("security.auth.methods", ["jwt"])
+            if "jwt_secret" in kwargs:
+                self.set("security.auth.jwt_secret", kwargs["jwt_secret"])
+        elif mode == "certificate":
+            self.set("security.auth.methods", ["certificate"])
+            self.set("security.auth.certificate_auth", True)
+        elif mode == "basic":
+            self.set("security.auth.methods", ["basic"])
+            self.set("security.auth.basic_auth", True)
+        elif mode == "oauth2":
+            self.set("security.auth.methods", ["oauth2"])
+            if "oauth2_config" in kwargs:
+                self.set("security.auth.oauth2_config", kwargs["oauth2_config"])
+        else:
+            raise ValueError(f"Unknown authentication mode: {mode}")
+
+    def configure_proxy_registration_mode(self, mode: str, **kwargs) -> None:
+        """
+        Configure proxy registration mode.
+
+        Args:
+            mode: Registration mode (token, certificate, api_key, none)
+            **kwargs: Additional configuration parameters
+        """
+        if mode == "none":
+            self.set("proxy_registration.enabled", False)
+        else:
+            self.set("proxy_registration.enabled", True)
+
+            if mode == "token":
+                self.set("proxy_registration.auth_method", "token")
+                if "token" in kwargs:
+                    self.set("proxy_registration.token.token", kwargs["token"])
+            elif mode == "certificate":
+                self.set("proxy_registration.auth_method", "certificate")
+                if "cert_file" in kwargs:
+                    self.set("proxy_registration.certificate.cert_file",
+                             kwargs["cert_file"])
+                if "key_file" in kwargs:
+                    self.set("proxy_registration.certificate.key_file",
+                             kwargs["key_file"])
+            elif mode == "api_key":
+                self.set("proxy_registration.auth_method", "api_key")
+                if "key" in kwargs:
+                    self.set("proxy_registration.api_key.key", kwargs["key"])
+
+    def create_minimal_config(self) -> Dict[str, Any]:
+        """
+        Create minimal configuration with only essential features.
+
+        Returns:
+            Minimal configuration dictionary
+        """
+        minimal_config = self.config_data.copy()
+
+        # Disable all optional features
+        minimal_config["ssl"]["enabled"] = False
+        minimal_config["security"]["enabled"] = False
+        minimal_config["security"]["auth"]["enabled"] = False
+        minimal_config["security"]["permissions"]["enabled"] = False
+        minimal_config["security"]["rate_limit"]["enabled"] = False
+        minimal_config["security"]["certificates"]["enabled"] = False
+        minimal_config["proxy_registration"]["enabled"] = False
+        minimal_config["roles"]["enabled"] = False
+
+        return minimal_config
+
+    def create_secure_config(self) -> Dict[str, Any]:
+        """
+        Create secure configuration with all security features enabled.
+
+        Returns:
+            Secure configuration dictionary
+        """
+        secure_config = self.config_data.copy()
+
+        # Enable all security features
+        secure_config["ssl"]["enabled"] = True
+        secure_config["security"]["enabled"] = True
+        secure_config["security"]["auth"]["enabled"] = True
+        secure_config["security"]["permissions"]["enabled"] = True
+        secure_config["security"]["rate_limit"]["enabled"] = True
+        secure_config["security"]["certificates"]["enabled"] = True
+        secure_config["proxy_registration"]["enabled"] = True
+        secure_config["roles"]["enabled"] = True
+
+        return secure_config
+
 
 # Singleton instance
 config = Config()