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

mcp_proxy_adapter/core/crl_utils.py

@@ -118,7 +118,9 @@ class CRLManager:
 
         # If CRL is enabled but no source is configured, this is an error
         if self.crl_enabled:
-            raise ValueError("CRL is enabled but neither crl_path nor crl_url is configured")
+            raise ValueError(
+                "CRL is enabled but neither crl_path nor crl_url is configured"
+            )
 
         return None
 
@@ -149,7 +151,9 @@ class CRLManager:
                 logger.warning(f"Unexpected content type for CRL: {content_type}")
 
             # Save to temporary file
-            with tempfile.NamedTemporaryFile(mode="wb", suffix=".crl", delete=False) as temp_file:
+            with tempfile.NamedTemporaryFile(
+                mode="wb", suffix=".crl", delete=False
+            ) as temp_file:
                 temp_file.write(response.content)
                 temp_file_path = temp_file.name
 
@@ -157,12 +161,16 @@ class CRLManager:
             if SECURITY_FRAMEWORK_AVAILABLE:
                 try:
                     is_crl_valid(temp_file_path)
-                    logger.info(f"CRL downloaded and validated successfully from {self.crl_url}")
+                    logger.info(
+                        f"CRL downloaded and validated successfully from {self.crl_url}"
+                    )
                 except Exception as e:
                     os.unlink(temp_file_path)
                     raise ValueError(f"Downloaded CRL is not valid: {e}")
             else:
-                logger.warning("mcp_security_framework not available, skipping CRL validation")
+                logger.warning(
+                    "mcp_security_framework not available, skipping CRL validation"
+                )
 
             # Cache the file path
             self._crl_cache[self.crl_url] = temp_file_path
@@ -198,7 +206,9 @@ class CRLManager:
             except Exception as e:
                 raise ValueError(f"CRL file is not valid: {e}")
         else:
-            logger.warning("mcp_security_framework not available, skipping CRL validation")
+            logger.warning(
+                "mcp_security_framework not available, skipping CRL validation"
+            )
 
         return self.crl_path
 
@@ -234,7 +244,9 @@ class CRLManager:
             if is_revoked:
                 logger.warning(f"Certificate is revoked according to CRL: {cert_path}")
             else:
-                logger.debug(f"Certificate is not revoked according to CRL: {cert_path}")
+                logger.debug(
+                    f"Certificate is not revoked according to CRL: {cert_path}"
+                )
 
             return is_revoked
 
@@ -266,7 +278,9 @@ class CRLManager:
             }
 
         if not SECURITY_FRAMEWORK_AVAILABLE:
-            logger.warning("mcp_security_framework not available, skipping CRL validation")
+            logger.warning(
+                "mcp_security_framework not available, skipping CRL validation"
+            )
             return {
                 "is_revoked": False,
                 "crl_checked": False,

mcp_proxy_adapter/core/errors.py

@@ -8,13 +8,16 @@ from typing import Any, Dict, List, Optional, Union
 class MicroserviceError(Exception):
     """
     Base class for all microservice exceptions.
-    
+
     Attributes:
         message: Error message.
         code: Error code.
         data: Additional error data.
     """
-    def __init__(self, message: str, code: int = -32000, data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str, code: int = -32000, data: Optional[Dict[str, Any]] = None
+    ):
         """
         Initialize the error.
 
@@ -35,14 +38,11 @@ class MicroserviceError(Exception):
         Returns:
             Dictionary with error information.
         """
-        result = {
-            "code": self.code,
-            "message": self.message
-        }
-        
+        result = {"code": self.code, "message": self.message}
+
         if self.data:
             result["data"] = self.data
-            
+
         return result
 
 
@@ -51,7 +51,10 @@ class ParseError(MicroserviceError):
     Error while parsing JSON request.
     JSON-RPC Error code: -32700
     """
-    def __init__(self, message: str = "Parse error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Parse error", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32700, data=data)
 
 
@@ -60,7 +63,10 @@ class InvalidRequestError(MicroserviceError):
     Invalid JSON-RPC request format.
     JSON-RPC Error code: -32600
     """
-    def __init__(self, message: str = "Invalid Request", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Invalid Request", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32600, data=data)
 
 
@@ -69,7 +75,10 @@ class MethodNotFoundError(MicroserviceError):
     Method not found error.
     JSON-RPC Error code: -32601
     """
-    def __init__(self, message: str = "Method not found", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Method not found", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32601, data=data)
 
 
@@ -78,7 +87,10 @@ class InvalidParamsError(MicroserviceError):
     Invalid method parameters.
     JSON-RPC Error code: -32602
     """
-    def __init__(self, message: str = "Invalid params", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Invalid params", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32602, data=data)
 
 
@@ -87,7 +99,10 @@ class InternalError(MicroserviceError):
     Internal server error.
     JSON-RPC Error code: -32603
     """
-    def __init__(self, message: str = "Internal error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Internal error", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32603, data=data)
 
 
@@ -96,7 +111,10 @@ class ValidationError(MicroserviceError):
     Input data validation error.
     JSON-RPC Error code: -32602 (using Invalid params code)
     """
-    def __init__(self, message: str = "Validation error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Validation error", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32602, data=data)
 
 
@@ -105,7 +123,12 @@ class CommandError(MicroserviceError):
     Command execution error.
     JSON-RPC Error code: -32000 (server error)
     """
-    def __init__(self, message: str = "Command execution error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        message: str = "Command execution error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
         super().__init__(message, code=-32000, data=data)
 
 
@@ -114,7 +137,10 @@ class NotFoundError(MicroserviceError):
     "Not found" error.
     JSON-RPC Error code: -32601 (using Method not found code)
     """
-    def __init__(self, message: str = "Resource not found", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Resource not found", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32601, data=data)
 
 
@@ -123,7 +149,12 @@ class ConfigurationError(MicroserviceError):
     Configuration error.
     JSON-RPC Error code: -32603 (using Internal error code)
     """
-    def __init__(self, message: str = "Configuration error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        message: str = "Configuration error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
         super().__init__(message, code=-32603, data=data)
 
 
@@ -132,7 +163,12 @@ class AuthenticationError(MicroserviceError):
     Authentication error.
     JSON-RPC Error code: -32001 (server error)
     """
-    def __init__(self, message: str = "Authentication error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        message: str = "Authentication error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
         super().__init__(message, code=-32001, data=data)
 
 
@@ -141,7 +177,12 @@ class AuthorizationError(MicroserviceError):
     Authorization error.
     JSON-RPC Error code: -32002 (server error)
     """
-    def __init__(self, message: str = "Authorization error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        message: str = "Authorization error",
+        data: Optional[Dict[str, Any]] = None,
+    ):
         super().__init__(message, code=-32002, data=data)
 
 
@@ -150,7 +191,10 @@ class TimeoutError(MicroserviceError):
     Timeout error.
     JSON-RPC Error code: -32003 (server error)
     """
-    def __init__(self, message: str = "Timeout error", data: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self, message: str = "Timeout error", data: Optional[Dict[str, Any]] = None
+    ):
         super().__init__(message, code=-32003, data=data)
 
 

mcp_proxy_adapter/core/logging.py

@@ -16,6 +16,7 @@ class CustomFormatter(logging.Formatter):
     """
     Custom formatter for logs with colored output in console.
     """
+
     grey = "\x1b[38;20m"
     yellow = "\x1b[33;20m"
     red = "\x1b[31;20m"
@@ -28,7 +29,7 @@ class CustomFormatter(logging.Formatter):
         logging.INFO: grey + format_str + reset,
         logging.WARNING: yellow + format_str + reset,
         logging.ERROR: red + format_str + reset,
-        logging.CRITICAL: bold_red + format_str + reset
+        logging.CRITICAL: bold_red + format_str + reset,
     }
 
     def format(self, record):
@@ -41,11 +42,11 @@ class RequestContextFilter(logging.Filter):
     """
     Filter for adding request context to logs.
     """
-    
+
     def __init__(self, request_id: Optional[str] = None):
         super().__init__()
         self.request_id = request_id
-    
+
     def filter(self, record):
         # Add request_id attribute to the record
         record.request_id = self.request_id or "no-request-id"
@@ -56,11 +57,11 @@ class RequestLogger:
     """
     Logger class for logging requests with context.
     """
-    
+
     def __init__(self, logger_name: str, request_id: Optional[str] = None):
         """
         Initialize request logger.
-        
+
         Args:
             logger_name: Logger name.
             request_id: Request identifier.
@@ -69,27 +70,27 @@ class RequestLogger:
         self.request_id = request_id or str(uuid.uuid4())
         self.filter = RequestContextFilter(self.request_id)
         self.logger.addFilter(self.filter)
-    
+
     def debug(self, msg: str, *args, **kwargs):
         """Log message with DEBUG level."""
         self.logger.debug(f"[{self.request_id}] {msg}", *args, **kwargs)
-    
+
     def info(self, msg: str, *args, **kwargs):
         """Log message with INFO level."""
         self.logger.info(f"[{self.request_id}] {msg}", *args, **kwargs)
-    
+
     def warning(self, msg: str, *args, **kwargs):
         """Log message with WARNING level."""
         self.logger.warning(f"[{self.request_id}] {msg}", *args, **kwargs)
-    
+
     def error(self, msg: str, *args, **kwargs):
         """Log message with ERROR level."""
         self.logger.error(f"[{self.request_id}] {msg}", *args, **kwargs)
-    
+
     def exception(self, msg: str, *args, **kwargs):
         """Log exception with traceback."""
         self.logger.exception(f"[{self.request_id}] {msg}", *args, **kwargs)
-    
+
     def critical(self, msg: str, *args, **kwargs):
         """Log message with CRITICAL level."""
         self.logger.critical(f"[{self.request_id}] {msg}", *args, **kwargs)
@@ -102,7 +103,7 @@ def setup_logging(
     backup_count: Optional[int] = None,
     rotation_type: Optional[str] = None,
     rotation_when: Optional[str] = None,
-    rotation_interval: Optional[int] = None
+    rotation_interval: Optional[int] = None,
 ) -> logging.Logger:
     """
     Configure logging for the microservice.
@@ -121,7 +122,7 @@ def setup_logging(
     """
     # Get parameters from configuration if not explicitly specified
     level = level or config.get("logging.level", "INFO")
-    
+
     # Check debug level from config if debug is enabled
     if config.get("debug.enabled", False):
         debug_level = config.get("debug.level", "INFO")
@@ -131,27 +132,31 @@ def setup_logging(
         if debug_level_num < level_num:
             level = debug_level
             logger.debug(f"Using debug level from config: {debug_level}")
-    
+
     log_file = log_file or config.get("logging.file")
     rotation_type = rotation_type or "size"  # Default to size-based rotation
-    
+
     # Get log directory and file settings from config
     log_dir = config.get("logging.log_dir", "./logs")
     log_file_name = config.get("logging.log_file", "mcp_proxy_adapter.log")
     error_log_file = config.get("logging.error_log_file", "mcp_proxy_adapter_error.log")
-    access_log_file = config.get("logging.access_log_file", "mcp_proxy_adapter_access.log")
-    
+    access_log_file = config.get(
+        "logging.access_log_file", "mcp_proxy_adapter_access.log"
+    )
+
     # Get rotation settings from config
     max_file_size_str = config.get("logging.max_file_size", "10MB")
     backup_count = backup_count or config.get("logging.backup_count", 5)
-    
+
     # Parse max file size (e.g., "10MB" -> 10 * 1024 * 1024)
     max_bytes = max_bytes or _parse_file_size(max_file_size_str)
-    
+
     # Get format settings
-    log_format = config.get("logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    log_format = config.get(
+        "logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
     date_format = config.get("logging.date_format", "%Y-%m-%d %H:%M:%S")
-    
+
     # Get output settings
     console_output = config.get("logging.console_output", True)
     file_output = config.get("logging.file_output", True)
@@ -189,7 +194,7 @@ def setup_logging(
                 main_log_path,
                 maxBytes=max_bytes,
                 backupCount=backup_count,
-                encoding="utf-8"
+                encoding="utf-8",
             )
             main_handler.setLevel(numeric_level)
             main_handler.setFormatter(formatter)
@@ -202,7 +207,7 @@ def setup_logging(
                 error_log_path,
                 maxBytes=max_bytes,
                 backupCount=backup_count,
-                encoding="utf-8"
+                encoding="utf-8",
             )
             error_handler.setLevel(logging.ERROR)
             error_handler.setFormatter(formatter)
@@ -215,7 +220,7 @@ def setup_logging(
                 access_log_path,
                 maxBytes=max_bytes,
                 backupCount=backup_count,
-                encoding="utf-8"
+                encoding="utf-8",
             )
             access_handler.setLevel(logging.INFO)
             access_handler.setFormatter(formatter)
@@ -233,17 +238,17 @@ def setup_logging(
 def _parse_file_size(size_str) -> int:
     """
     Parse file size string to bytes.
-    
+
     Args:
         size_str: Size string (e.g., "10MB", "1GB", "100KB") or int
-        
+
     Returns:
         Size in bytes
     """
     # If it's already an int, return it
     if isinstance(size_str, int):
         return size_str
-    
+
     # Convert to string and parse
     size_str = str(size_str).upper()
     if size_str.endswith("KB"):
@@ -260,10 +265,10 @@ def _parse_file_size(size_str) -> int:
 def get_logger(name: str) -> logging.Logger:
     """
     Get a logger with the specified name.
-    
+
     Args:
         name: Logger name.
-        
+
     Returns:
         Configured logger instance.
     """

mcp_proxy_adapter/core/mtls_asgi.py

@@ -19,15 +19,15 @@ logger = logging.getLogger(__name__)
 class MTLSASGIApp:
     """
     Custom ASGI application that properly handles mTLS client certificates.
-    
+
     This wrapper ensures that client certificates are properly extracted
     and made available to the FastAPI application.
     """
-    
+
     def __init__(self, app: ASGIApp, ssl_config: Dict[str, Any]):
         """
         Initialize MTLS ASGI application.
-        
+
         Args:
             app: The underlying ASGI application (FastAPI)
             ssl_config: SSL configuration for mTLS
@@ -36,14 +36,16 @@ class MTLSASGIApp:
         self.ssl_config = ssl_config
         self.verify_client = ssl_config.get("verify_client", False)
         self.client_cert_required = ssl_config.get("client_cert_required", False)
-        
-        logger.info(f"MTLS ASGI app initialized: verify_client={self.verify_client}, "
-                   f"client_cert_required={self.client_cert_required}")
-    
+
+        logger.info(
+            f"MTLS ASGI app initialized: verify_client={self.verify_client}, "
+            f"client_cert_required={self.client_cert_required}"
+        )
+
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         """
         Handle ASGI request with mTLS support.
-        
+
         Args:
             scope: ASGI scope
             receive: ASGI receive callable
@@ -56,27 +58,29 @@ class MTLSASGIApp:
                 if client_cert:
                     # Store certificate in scope for middleware access
                     scope["client_certificate"] = client_cert
-                    logger.debug(f"Client certificate extracted: {client_cert.get('subject', {})}")
+                    logger.debug(
+                        f"Client certificate extracted: {client_cert.get('subject', {})}"
+                    )
                 elif self.client_cert_required:
                     logger.warning("Client certificate required but not provided")
                     # Return 401 Unauthorized
                     await self._send_unauthorized_response(send)
                     return
-            
+
             # Call the underlying application
             await self.app(scope, receive, send)
-            
+
         except Exception as e:
             logger.error(f"Error in MTLS ASGI app: {e}")
             await self._send_error_response(send, str(e))
-    
+
     def _extract_client_certificate(self, scope: Scope) -> Optional[Dict[str, Any]]:
         """
         Extract client certificate from SSL context.
-        
+
         Args:
             scope: ASGI scope
-            
+
         Returns:
             Client certificate data or None
         """
@@ -84,22 +88,22 @@ class MTLSASGIApp:
             ssl_context = scope.get("ssl")
             if not ssl_context:
                 return None
-            
+
             # Get peer certificate
             cert = ssl_context.getpeercert()
             if cert:
                 return cert
-            
+
             return None
-            
+
         except Exception as e:
             logger.error(f"Failed to extract client certificate: {e}")
             return None
-    
+
     async def _send_unauthorized_response(self, send: Send) -> None:
         """
         Send 401 Unauthorized response.
-        
+
         Args:
             send: ASGI send callable
         """
@@ -112,14 +116,14 @@ class MTLSASGIApp:
             ],
         }
         await send(response)
-        
+
         body = b'{"jsonrpc": "2.0", "error": {"code": -32001, "message": "Unauthorized: Client certificate required"}, "id": null}'
         await send({"type": "http.response.body", "body": body})
-    
+
     async def _send_error_response(self, send: Send, error_message: str) -> None:
         """
         Send error response.
-        
+
         Args:
             send: ASGI send callable
             error_message: Error message
@@ -132,7 +136,7 @@ class MTLSASGIApp:
             ],
         }
         await send(response)
-        
+
         body = f'{{"jsonrpc": "2.0", "error": {{"code": -32603, "message": "Internal error: {error_message}"}}, "id": null}}'.encode()
         await send({"type": "http.response.body", "body": body})
 
@@ -140,11 +144,11 @@ class MTLSASGIApp:
 def create_mtls_asgi_app(app: ASGIApp, ssl_config: Dict[str, Any]) -> ASGIApp:
     """
     Create MTLS-enabled ASGI application.
-    
+
     Args:
         app: The underlying ASGI application (FastAPI)
         ssl_config: SSL configuration for mTLS
-        
+
     Returns:
         MTLS-enabled ASGI application
     """