mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.6__py3-none-any.whl

mcp_proxy_adapter/commands/settings_command.py

@@ -4,12 +4,17 @@ Settings command for demonstrating configuration management.
 
 from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.core.settings import Settings, get_setting, set_setting, reload_settings
+from mcp_proxy_adapter.core.settings import (
+    Settings,
+    get_setting,
+    set_setting,
+    reload_settings,
+)
 
 
 class SettingsResult:
     """Result class for settings command."""
-    
+
     def __init__(
         self,
         success: bool,
@@ -17,7 +22,7 @@ class SettingsResult:
         key: Optional[str] = None,
         value: Any = None,
         all_settings: Optional[Dict[str, Any]] = None,
-        error_message: Optional[str] = None
+        error_message: Optional[str] = None,
     ):
         self.success = success
         self.operation = operation
@@ -25,14 +30,11 @@ class SettingsResult:
         self.value = value
         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
-        }
-        
+        result = {"success": self.success, "operation": self.operation}
+
         if self.key is not None:
             result["key"] = self.key
         if self.value is not None:
@@ -41,9 +43,9 @@ class SettingsResult:
             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."""
@@ -52,119 +54,108 @@ class SettingsResult:
             "properties": {
                 "success": {
                     "type": "boolean",
-                    "description": "Whether the operation was successful"
+                    "description": "Whether the operation was successful",
                 },
                 "operation": {
                     "type": "string",
                     "description": "Type of operation performed",
-                    "enum": ["get", "set", "get_all", "reload"]
+                    "enum": ["get", "set", "get_all", "reload"],
                 },
                 "key": {
                     "type": "string",
-                    "description": "Configuration key (for get/set operations)"
+                    "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)"
+                    "description": "All configuration settings (for get_all operation)",
                 },
                 "error_message": {
                     "type": "string",
-                    "description": "Error message if operation failed"
-                }
+                    "description": "Error message if operation failed",
+                },
             },
-            "required": ["success", "operation"]
+            "required": ["success", "operation"],
         }
 
 
 class SettingsCommand(Command):
     """Command for managing framework settings."""
-    
+
     name = "settings"
     description = "Manage framework settings and configuration"
-    
+
     async def execute(self, **params) -> SettingsResult:
         """
         Execute settings command.
-        
+
         Args:
             operation: Operation to perform (get, set, get_all, reload)
             key: Configuration key (for get/set operations)
             value: Configuration value (for set operation)
-            
+
         Returns:
             SettingsResult with operation result
         """
         try:
             operation = params.get("operation", "get_all")
-            
+
             if operation == "get":
                 key = params.get("key")
                 if not key:
                     return SettingsResult(
                         success=False,
                         operation=operation,
-                        error_message="Key is required for 'get' operation"
+                        error_message="Key is required for 'get' operation",
                     )
-                
+
                 value = get_setting(key)
                 return SettingsResult(
-                    success=True,
-                    operation=operation,
-                    key=key,
-                    value=value
+                    success=True, operation=operation, key=key, value=value
                 )
-            
+
             elif operation == "set":
                 key = params.get("key")
                 value = params.get("value")
-                
+
                 if not key:
                     return SettingsResult(
                         success=False,
                         operation=operation,
-                        error_message="Key is required for 'set' operation"
+                        error_message="Key is required for 'set' operation",
                     )
-                
+
                 set_setting(key, value)
                 return SettingsResult(
-                    success=True,
-                    operation=operation,
-                    key=key,
-                    value=value
+                    success=True, operation=operation, key=key, value=value
                 )
-            
+
             elif operation == "get_all":
                 all_settings = Settings.get_all_settings()
                 return SettingsResult(
-                    success=True,
-                    operation=operation,
-                    all_settings=all_settings
+                    success=True, operation=operation, all_settings=all_settings
                 )
-            
+
             elif operation == "reload":
                 reload_settings()
-                return SettingsResult(
-                    success=True,
-                    operation=operation
-                )
-            
+                return SettingsResult(success=True, operation=operation)
+
             else:
                 return SettingsResult(
                     success=False,
                     operation=operation,
-                    error_message=f"Unknown operation: {operation}. Supported operations: get, set, get_all, reload"
+                    error_message=f"Unknown operation: {operation}. Supported operations: get, set, get_all, reload",
                 )
-                
+
         except Exception as e:
             return SettingsResult(
                 success=False,
                 operation=params.get("operation", "unknown"),
-                error_message=str(e)
+                error_message=str(e),
             )
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get schema for the command."""
@@ -175,16 +166,16 @@ class SettingsCommand(Command):
                     "type": "string",
                     "description": "Operation to perform",
                     "enum": ["get", "set", "get_all", "reload"],
-                    "default": "get_all"
+                    "default": "get_all",
                 },
                 "key": {
                     "type": "string",
-                    "description": "Configuration key in dot notation (e.g., 'server.host', 'custom.feature_enabled')"
+                    "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
-        } 
+            "additionalProperties": False,
+        }

mcp_proxy_adapter/commands/ssl_setup_command.py

@@ -16,6 +16,7 @@ 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:
     SECURITY_FRAMEWORK_AVAILABLE = False
@@ -30,10 +31,10 @@ logger = logging.getLogger(__name__)
 class SSLSetupCommand(Command):
     """
     SSL Setup Command
-    
+
     Handles SSL/TLS configuration and certificate management.
     """
-    
+
     # Command metadata
     name = "ssl_setup"
     version = "1.0.0"
@@ -43,28 +44,28 @@ class SSLSetupCommand(Command):
     email = "team@mcp-proxy-adapter.com"
     source_url = "https://github.com/mcp-proxy-adapter"
     result_class = SuccessResult
-    
+
     def __init__(self):
         """Initialize SSL Setup Command."""
         super().__init__()
-    
+
     async def execute(self, **kwargs) -> SuccessResult | ErrorResult:
         """
         Execute SSL setup command.
-        
+
         Args:
             params: Command parameters including:
                 - action: Operation to perform (get, set, update, reset, test)
                 - config_data: Configuration data for set/update actions
                 - cert_file: Certificate file path for testing
                 - key_file: Private key file path for testing
-                
+
         Returns:
             SuccessResult or ErrorResult
         """
         try:
             action = kwargs.get("action", "get")
-            
+
             if action == "get":
                 return await self._get_ssl_config()
             elif action == "set":
@@ -75,108 +76,96 @@ class SSLSetupCommand(Command):
                 return await self._reset_ssl_config()
             elif action == "test":
                 return await self._test_ssl_config(
-                    kwargs.get("cert_file"),
-                    kwargs.get("key_file")
+                    kwargs.get("cert_file"), kwargs.get("key_file")
                 )
             else:
                 return ErrorResult(
                     message=f"Unknown action: {action}. Supported actions: get, set, update, reset, test"
                 )
-                
+
         except Exception as e:
             logger.error(f"SSL setup command failed: {e}")
-            return ErrorResult(
-                message=f"SSL setup command failed: {str(e)}"
-            )
-    
+            return ErrorResult(message=f"SSL setup command failed: {str(e)}")
+
     async def _get_ssl_config(self) -> SuccessResult | ErrorResult:
         """Get current SSL configuration."""
         try:
             config = Config()
             ssl_config = config.get("ssl", {})
-            
+
             # Add framework information
             ssl_config["framework_available"] = SECURITY_FRAMEWORK_AVAILABLE
-            
-            return SuccessResult(
-                data={"ssl_config": ssl_config}
-            )
-            
+
+            return SuccessResult(data={"ssl_config": ssl_config})
+
         except Exception as e:
             logger.error(f"Failed to get SSL config: {e}")
-            return ErrorResult(
-                message=f"Failed to get SSL config: {str(e)}"
-            )
-            
-    async def _set_ssl_config(self, config_data: Dict[str, Any]) -> SuccessResult | ErrorResult:
+            return ErrorResult(message=f"Failed to get SSL config: {str(e)}")
+
+    async def _set_ssl_config(
+        self, config_data: Dict[str, Any]
+    ) -> SuccessResult | ErrorResult:
         """Set SSL configuration."""
         try:
             if not isinstance(config_data, dict):
-                return ErrorResult(
-                    message="Configuration data must be a dictionary"
-                )
-            
+                return ErrorResult(message="Configuration data must be a dictionary")
+
             # Validate configuration if mcp_security_framework is available
             if SECURITY_FRAMEWORK_AVAILABLE:
                 try:
                     ssl_config = SSLConfig(**config_data)
                     config_data = ssl_config.dict()
                 except Exception as e:
-                    return ErrorResult(
-                        message=f"Invalid SSL configuration: {str(e)}"
-                    )
-            
+                    return ErrorResult(message=f"Invalid SSL configuration: {str(e)}")
+
             # Update configuration
             config = Config()
             config.update_config({"ssl": config_data})
-            
+
             return SuccessResult(
                 data={"message": "SSL configuration updated", "ssl_config": config_data}
             )
-            
+
         except Exception as e:
             logger.error(f"Failed to set SSL config: {e}")
-            return ErrorResult(
-                message=f"Failed to set SSL config: {str(e)}"
-            )
-    
-    async def _update_ssl_config(self, config_data: Dict[str, Any]) -> SuccessResult | ErrorResult:
+            return ErrorResult(message=f"Failed to set SSL config: {str(e)}")
+
+    async def _update_ssl_config(
+        self, config_data: Dict[str, Any]
+    ) -> SuccessResult | ErrorResult:
         """Update SSL configuration."""
         try:
             if not isinstance(config_data, dict):
-                return ErrorResult(
-                    message="Configuration data must be a dictionary"
-                )
-            
+                return ErrorResult(message="Configuration data must be a dictionary")
+
             config = Config()
             current_config = config.get("ssl", {})
-            
+
             # Update with new data
             current_config.update(config_data)
-            
+
             # Validate configuration if mcp_security_framework is available
             if SECURITY_FRAMEWORK_AVAILABLE:
                 try:
                     ssl_config = SSLConfig(**current_config)
                     current_config = ssl_config.dict()
                 except Exception as e:
-                    return ErrorResult(
-                        message=f"Invalid SSL configuration: {str(e)}"
-                    )
-            
+                    return ErrorResult(message=f"Invalid SSL configuration: {str(e)}")
+
             # Update configuration
             config.update_config({"ssl": current_config})
-            
+
             return SuccessResult(
-                data={"message": "SSL configuration updated", "ssl_config": current_config}
+                data={
+                    "message": "SSL configuration updated",
+                    "ssl_config": current_config,
+                }
             )
-            
+
         except Exception as e:
             logger.error(f"Failed to update SSL config: {e}")
-            return ErrorResult(
-                message=f"Failed to update SSL config: {str(e)}"
-            )
-    
+            return ErrorResult(message=f"Failed to update SSL config: {str(e)}")
+
     async def _reset_ssl_config(self) -> SuccessResult | ErrorResult:
         """Reset SSL configuration to defaults."""
         try:
@@ -187,30 +176,33 @@ class SSLSetupCommand(Command):
                 "ca_file": None,
                 "verify_mode": "CERT_REQUIRED",
                 "cipher_suites": [],
-                "framework_available": SECURITY_FRAMEWORK_AVAILABLE
+                "framework_available": SECURITY_FRAMEWORK_AVAILABLE,
             }
-            
+
             config = Config()
             config.update_config({"ssl": default_config})
-            
+
             return SuccessResult(
-                data={"message": "SSL configuration reset to defaults", "ssl_config": default_config}
+                data={
+                    "message": "SSL configuration reset to defaults",
+                    "ssl_config": default_config,
+                }
             )
-            
+
         except Exception as e:
             logger.error(f"Failed to reset SSL config: {e}")
-            return ErrorResult(
-                message=f"Failed to reset SSL config: {str(e)}"
-            )
-    
-    async def _test_ssl_config(self, cert_file: Optional[str], key_file: Optional[str]) -> SuccessResult | ErrorResult:
+            return ErrorResult(message=f"Failed to reset SSL config: {str(e)}")
+
+    async def _test_ssl_config(
+        self, cert_file: Optional[str], key_file: Optional[str]
+    ) -> SuccessResult | ErrorResult:
         """
         Test SSL configuration.
-        
+
         Args:
             cert_file: Path to certificate file
             key_file: Path to private key file
-            
+
         Returns:
             SuccessResult or ErrorResult with test results
         """
@@ -219,49 +211,40 @@ class SSLSetupCommand(Command):
                 return ErrorResult(
                     message="Both cert_file and key_file are required for testing"
                 )
-            
+
             if SECURITY_FRAMEWORK_AVAILABLE:
                 return await self._test_ssl_config_with_framework(cert_file, key_file)
             else:
                 return await self._test_ssl_config_fallback(cert_file, key_file)
-                
+
         except Exception as e:
             logger.error(f"Failed to test SSL config: {e}")
-            return ErrorResult(
-                message=f"Failed to test SSL config: {str(e)}"
-            )
-    
-    async def _test_ssl_config_with_framework(self, cert_file: str, key_file: str) -> SuccessResult | ErrorResult:
+            return ErrorResult(message=f"Failed to test SSL config: {str(e)}")
+
+    async def _test_ssl_config_with_framework(
+        self, cert_file: str, key_file: str
+    ) -> SuccessResult | ErrorResult:
         """Test SSL configuration using mcp_security_framework."""
         try:
             # Create SSL manager
-            ssl_config = SSLConfig(
-                cert_file=cert_file,
-                key_file=key_file,
-                enabled=True
-            )
-            
+            ssl_config = SSLConfig(cert_file=cert_file, key_file=key_file, enabled=True)
+
             ssl_manager = SSLManager(ssl_config)
-            
+
             # Test SSL context creation
             context = ssl_manager.create_server_ssl_context()
-            
+
             details = {
                 "framework": "mcp_security_framework",
                 "certificate_loaded": True,
                 "private_key_loaded": True,
                 "context_created": True,
                 "cert_file": cert_file,
-                "key_file": key_file
+                "key_file": key_file,
             }
-            
-            return SuccessResult(
-                data={
-                    "success": True,
-                    "details": details
-                }
-            )
-                
+
+            return SuccessResult(data={"success": True, "details": details})
+
         except Exception as e:
             return ErrorResult(
                 message=f"SSL test failed: {str(e)}",
@@ -272,22 +255,24 @@ class SSLSetupCommand(Command):
                         "framework": "mcp_security_framework",
                         "certificate_loaded": False,
                         "private_key_loaded": False,
-                        "context_created": False
-                    }
-                }
+                        "context_created": False,
+                    },
+                },
             )
-    
-    async def _test_ssl_config_fallback(self, cert_file: str, key_file: str) -> SuccessResult | ErrorResult:
+
+    async def _test_ssl_config_fallback(
+        self, cert_file: str, key_file: str
+    ) -> SuccessResult | ErrorResult:
         """Test SSL configuration using fallback method."""
         try:
             # Create SSL context
             context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
             context.check_hostname = False
             context.verify_mode = ssl.CERT_NONE
-            
+
             # Load certificate and key
             context.load_cert_chain(cert_file, key_file)
-            
+
             # Test basic SSL functionality
             details = {
                 "framework": "fallback (ssl module)",
@@ -296,41 +281,36 @@ class SSLSetupCommand(Command):
                 "private_key_loaded": True,
                 "context_created": True,
                 "cert_file": cert_file,
-                "key_file": key_file
-            }
-            
-            return SuccessResult(
-                data={
-                "success": True,
-                "details": details
+                "key_file": key_file,
             }
-            )
-            
+
+            return SuccessResult(data={"success": True, "details": details})
+
         except Exception as e:
             return ErrorResult(
                 message=f"SSL test failed: {str(e)}",
                 data={
-                "success": False,
-                "error": str(e),
-                "details": {
+                    "success": False,
+                    "error": str(e),
+                    "details": {
                         "framework": "fallback (ssl module)",
-                    "ssl_version": ssl.OPENSSL_VERSION,
-                    "certificate_loaded": False,
-                    "private_key_loaded": False,
-                    "context_created": False
-                }
-                }
+                        "ssl_version": ssl.OPENSSL_VERSION,
+                        "certificate_loaded": False,
+                        "private_key_loaded": False,
+                        "context_created": False,
+                    },
+                },
             )
-    
+
     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
+            "framework_available": SECURITY_FRAMEWORK_AVAILABLE,
         }
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get command schema."""
@@ -340,7 +320,7 @@ class SSLSetupCommand(Command):
                 "action": {
                     "type": "string",
                     "enum": ["get", "set", "update", "reset", "test"],
-                    "description": "Action to perform"
+                    "description": "Action to perform",
                 },
                 "config_data": {
                     "type": "object",
@@ -351,17 +331,17 @@ class SSLSetupCommand(Command):
                         "key_file": {"type": "string"},
                         "ca_file": {"type": "string"},
                         "verify_mode": {"type": "string"},
-                        "cipher_suites": {"type": "array", "items": {"type": "string"}}
-                    }
+                        "cipher_suites": {"type": "array", "items": {"type": "string"}},
+                    },
                 },
                 "cert_file": {
                     "type": "string",
-                    "description": "Certificate file path for testing"
+                    "description": "Certificate file path for testing",
                 },
                 "key_file": {
                     "type": "string",
-                    "description": "Private key file path for testing"
-                }
+                    "description": "Private key file path for testing",
+                },
             },
-            "required": ["action"]
-            } 
+            "required": ["action"],
+        }