mcp-proxy-adapter 6.9.17__py3-none-any.whl → 6.9.19__py3-none-any.whl

mcp_proxy_adapter/core/transport_manager.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class TransportType(Enum):
@@ -72,7 +72,7 @@ class TransportManager:
             try:
                 transport_type = TransportType(transport_type_str)
             except ValueError:
-                logger.error(f"Invalid transport type: {transport_type_str}")
+                get_global_logger().error(f"Invalid transport type: {transport_type_str}")
                 return False
 
             # Get port (use default if not specified)
@@ -89,13 +89,13 @@ class TransportManager:
                 transport_type in [TransportType.HTTPS, TransportType.MTLS]
                 and not ssl_enabled
             ):
-                logger.error(
+                get_global_logger().error(
                     f"SSL must be enabled for transport type: {transport_type.value}"
                 )
                 return False
 
             if transport_type == TransportType.HTTP and ssl_enabled:
-                logger.warning("SSL enabled for HTTP transport - this may cause issues")
+                get_global_logger().warning("SSL enabled for HTTP transport - this may cause issues")
 
             # Create transport config
             self._config = TransportConfig(
@@ -111,13 +111,13 @@ class TransportManager:
 
             self._current_transport = transport_type
 
-            logger.info(
+            get_global_logger().info(
                 f"Transport config loaded: {transport_type.value} on port {port}"
             )
             return True
 
         except Exception as e:
-            logger.error(f"Failed to load transport config: {e}")
+            get_global_logger().error(f"Failed to load transport config: {e}")
             return False
 
     def get_transport_type(self) -> Optional[TransportType]:
@@ -220,17 +220,17 @@ class TransportManager:
             True if configuration is valid, False otherwise
         """
         if not self._config:
-            logger.error("Transport not configured")
+            get_global_logger().error("Transport not configured")
             return False
 
         # Validate SSL requirements
         if self._config.type in [TransportType.HTTPS, TransportType.MTLS]:
             if not self._config.ssl_enabled:
-                logger.error(f"SSL must be enabled for {self._config.type.value}")
+                get_global_logger().error(f"SSL must be enabled for {self._config.type.value}")
                 return False
 
             if not self._config.cert_file or not self._config.key_file:
-                logger.error(
+                get_global_logger().error(
                     f"SSL certificate and key required for {self._config.type.value}"
                 )
                 return False
@@ -242,12 +242,12 @@ class TransportManager:
         # Validate MTLS requirements
         if self._config.type == TransportType.MTLS:
             if not self._config.verify_client:
-                logger.warning("MTLS transport should have client verification enabled")
+                get_global_logger().warning("MTLS transport should have client verification enabled")
 
             if not self._config.ca_cert:
-                logger.warning("CA certificate recommended for MTLS transport")
+                get_global_logger().warning("CA certificate recommended for MTLS transport")
 
-        logger.info(f"Transport configuration validated: {self._config.type.value}")
+        get_global_logger().info(f"Transport configuration validated: {self._config.type.value}")
         return True
 
     def validate_ssl_files(self) -> bool:
@@ -270,10 +270,10 @@ class TransportManager:
 
         for file_path in files_to_check:
             if not Path(file_path).exists():
-                logger.error(f"SSL file not found: {file_path}")
+                get_global_logger().error(f"SSL file not found: {file_path}")
                 return False
 
-        logger.info(f"All SSL files validated successfully: {files_to_check}")
+        get_global_logger().info(f"All SSL files validated successfully: {files_to_check}")
         return True
 
     def get_hypercorn_config(self) -> Dict[str, Any]:

mcp_proxy_adapter/core/unified_config_adapter.py

@@ -33,7 +33,7 @@ except ImportError:
     PermissionConfig = None
     RateLimitConfig = None
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 @dataclass
@@ -84,7 +84,7 @@ class UnifiedConfigAdapter:
             SecurityConfig instance or None if conversion failed
         """
         if not SECURITY_FRAMEWORK_AVAILABLE:
-            logger.error(
+            get_global_logger().error(
                 "mcp_security_framework not available, cannot convert configuration"
             )
             return None
@@ -93,7 +93,7 @@ class UnifiedConfigAdapter:
             # Validate configuration first
             validation_result = self.validate_configuration(config)
             if not validation_result.is_valid:
-                logger.error(
+                get_global_logger().error(
                     f"Configuration validation failed: {validation_result.errors}"
                 )
                 return None
@@ -112,11 +112,11 @@ class UnifiedConfigAdapter:
                 rate_limit=rate_limit_config,
             )
 
-            logger.info("Configuration successfully converted to SecurityConfig")
+            get_global_logger().info("Configuration successfully converted to SecurityConfig")
             return security_config
 
         except Exception as e:
-            logger.error(f"Failed to convert configuration: {e}")
+            get_global_logger().error(f"Failed to convert configuration: {e}")
             return None
 
     def validate_configuration(self, config: Dict[str, Any]) -> ValidationResult:
@@ -569,7 +569,7 @@ class UnifiedConfigAdapter:
                 "enabled": migrated_config["rate_limit_enabled"]
             }
 
-        logger.info("Legacy configuration migrated to new format")
+        get_global_logger().info("Legacy configuration migrated to new format")
         return migrated_config
 
     def get_default_config(self) -> Dict[str, Any]:

mcp_proxy_adapter/core/utils.py

@@ -12,7 +12,7 @@ import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 def generate_id() -> str:
@@ -80,7 +80,7 @@ def safe_json_loads(s: str, default: Any = None) -> Any:
     try:
         return json.loads(s)
     except Exception as e:
-        logger.error(f"Error parsing JSON: {e}")
+        get_global_logger().error(f"Error parsing JSON: {e}")
         return default
 
 
@@ -99,7 +99,7 @@ def safe_json_dumps(obj: Any, default: str = "{}", indent: Optional[int] = None)
     try:
         return json.dumps(obj, ensure_ascii=False, indent=indent)
     except Exception as e:
-        logger.error(f"Error serializing to JSON: {e}")
+        get_global_logger().error(f"Error serializing to JSON: {e}")
         return default
 
 
@@ -137,7 +137,7 @@ def ensure_directory(path: str) -> bool:
             os.makedirs(path, exist_ok=True)
         return True
     except Exception as e:
-        logger.error(f"Error creating directory {path}: {e}")
+        get_global_logger().error(f"Error creating directory {path}: {e}")
         return False
 
 
@@ -159,7 +159,7 @@ def check_port_availability(host: str, port: int, timeout: float = 1.0) -> bool:
             result = sock.connect_ex((host, port))
             return result != 0  # True if connection failed (port is free)
     except Exception as e:
-        logger.warning(f"Error checking port {port} on {host}: {e}")
+        get_global_logger().warning(f"Error checking port {port} on {host}: {e}")
         return True  # Assume port is available if check fails
 
 

mcp_proxy_adapter/custom_openapi.py

@@ -12,7 +12,7 @@ from fastapi.openapi.utils import get_openapi
 
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.commands.base import Command
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class CustomOpenAPIGenerator:
@@ -49,7 +49,7 @@ class CustomOpenAPIGenerator:
             with open(self.base_schema_path, "r", encoding="utf-8") as f:
                 return json.load(f)
         except FileNotFoundError:
-            logger.warning(f"Base schema file not found at {self.base_schema_path}, using fallback schema")
+            get_global_logger().warning(f"Base schema file not found at {self.base_schema_path}, using fallback schema")
             return self._get_fallback_schema()
 
     def _get_fallback_schema(self) -> Dict[str, Any]:
@@ -406,7 +406,7 @@ class CustomOpenAPIGenerator:
             return cmd_schema
         except Exception as e:
             # Return default schema if command schema generation fails
-            logger.warning(f"Failed to get schema for command {cmd_class.name}: {e}")
+            get_global_logger().warning(f"Failed to get schema for command {cmd_class.name}: {e}")
             return {
                 "type": "object",
                 "title": f"Parameters for {cmd_class.name}",
@@ -569,7 +569,7 @@ class CustomOpenAPIGenerator:
         # Add commands to schema
         self._add_commands_to_schema(schema)
 
-        logger.debug(
+        get_global_logger().debug(
             f"Generated OpenAPI schema with {len(registry.get_all_commands())} commands"
         )
 
@@ -620,7 +620,7 @@ def register_openapi_generator(
         generator_func: Function that generates OpenAPI schema.
     """
     _openapi_generators[name] = generator_func
-    logger.info(f"Registered custom OpenAPI generator: {name}")
+    get_global_logger().info(f"Registered custom OpenAPI generator: {name}")
 
 
 def get_openapi_generator(name: str) -> Optional[Callable[[FastAPI], Dict[str, Any]]]:
@@ -669,9 +669,9 @@ def custom_openapi_with_fallback(app: FastAPI) -> Dict[str, Any]:
         # Use the first registered generator
         generator_name = list(_openapi_generators.keys())[0]
         generator_func = _openapi_generators[generator_name]
-        logger.debug(f"Using custom OpenAPI generator: {generator_name}")
+        get_global_logger().debug(f"Using custom OpenAPI generator: {generator_name}")
         return generator_func(app)
 
     # Fall back to default generator
-    logger.debug("Using default OpenAPI generator")
+    get_global_logger().debug("Using default OpenAPI generator")
     return custom_openapi(app)

mcp_proxy_adapter/examples/cert_manager_bugfix.py

@@ -63,7 +63,7 @@ def create_cert_manager_patch():
 -            )
 +        # BUGFIX: Skip CA path validation if in CA creation mode
 +        if self.config.ca_creation_mode:
-+            self.logger.info("CA creation mode enabled, skipping CA path validation")
++            self.get_global_logger().info("CA creation mode enabled, skipping CA path validation")
 +            return
 +
 +        if not self.config.ca_cert_path:
@@ -110,7 +110,7 @@ def test_fixed_cert_manager():
             
             # BUGFIX: Skip CA path validation if in CA creation mode
             if self.config.ca_creation_mode:
-                self.logger.info("CA creation mode enabled, skipping CA path validation")
+                self.get_global_logger().info("CA creation mode enabled, skipping CA path validation")
                 return
             
             if not self.config.ca_cert_path:

mcp_proxy_adapter/examples/full_application/commands/__init__.py

@@ -1,7 +1,8 @@
-"""Full Application Commands.
-
-Custom command implementations for the full application example.
 """
+Commands package for full application example.
+"""
+from .echo_command import EchoCommand
+from .list_command import ListCommand
+from .help_command import HelpCommand
 
-from .custom_echo_command import CustomEchoCommand
-from .dynamic_calculator_command import DynamicCalculatorCommand
+__all__ = ["EchoCommand", "ListCommand", "HelpCommand"]

mcp_proxy_adapter/examples/full_application/commands/echo_command.py

@@ -0,0 +1,44 @@
+"""
+Echo command implementation.
+"""
+from mcp_proxy_adapter.commands.base import BaseCommand
+from mcp_proxy_adapter.core.errors import MicroserviceError
+
+
+class EchoCommand(BaseCommand):
+    """Echo command that returns the input message."""
+    
+    def __init__(self):
+        super().__init__()
+        self.name = "echo"
+        self.description = "Echo command that returns the input message"
+        self.version = "1.0.0"
+    
+    def get_schema(self):
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Message to echo back"
+                }
+            },
+            "required": ["message"]
+        }
+    
+    async def execute(self, params: dict) -> dict:
+        """Execute echo command."""
+        try:
+            message = params.get("message", "")
+            return {
+                "echo": message,
+                "timestamp": self._get_timestamp()
+            }
+        except Exception as e:
+            raise MicroserviceError(f"Echo command failed: {str(e)}")
+    
+    def _get_timestamp(self):
+        """Get current timestamp."""
+        import time
+        return time.time()

mcp_proxy_adapter/examples/full_application/commands/help_command.py

@@ -0,0 +1,66 @@
+"""
+Help command implementation.
+"""
+from mcp_proxy_adapter.commands.base import BaseCommand
+from mcp_proxy_adapter.core.errors import MicroserviceError
+
+
+class HelpCommand(BaseCommand):
+    """Help command that provides usage information."""
+    
+    def __init__(self):
+        super().__init__()
+        self.name = "help"
+        self.description = "Get help information"
+        self.version = "1.0.0"
+    
+    def get_schema(self):
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "Command name to get help for (optional)"
+                }
+            },
+            "required": []
+        }
+    
+    async def execute(self, params: dict) -> dict:
+        """Execute help command."""
+        try:
+            command = params.get("command")
+            
+            if command:
+                # Get help for specific command
+                help_info = self._get_command_help(command)
+                return {
+                    "command": command,
+                    "help": help_info,
+                    "timestamp": self._get_timestamp()
+                }
+            else:
+                # Get general help
+                return {
+                    "help": "MCP Proxy Adapter - Available commands: echo, list, health, help",
+                    "usage": "Use 'help' with a command name to get specific help",
+                    "timestamp": self._get_timestamp()
+                }
+        except Exception as e:
+            raise MicroserviceError(f"Help command failed: {str(e)}")
+    
+    def _get_command_help(self, command: str) -> str:
+        """Get help for specific command."""
+        help_map = {
+            "echo": "Echo command - returns the input message. Usage: {'message': 'your message'}",
+            "list": "List command - returns available commands. Usage: {}",
+            "health": "Health command - returns server health status. Usage: {}",
+            "help": "Help command - provides usage information. Usage: {'command': 'command_name'} (optional)"
+        }
+        return help_map.get(command, f"No help available for command '{command}'")
+    
+    def _get_timestamp(self):
+        """Get current timestamp."""
+        import time
+        return time.time()

mcp_proxy_adapter/examples/full_application/commands/list_command.py

@@ -0,0 +1,64 @@
+"""
+List command implementation.
+"""
+from mcp_proxy_adapter.commands.base import BaseCommand
+from mcp_proxy_adapter.core.errors import MicroserviceError
+
+
+class ListCommand(BaseCommand):
+    """List command that returns available commands."""
+    
+    def __init__(self):
+        super().__init__()
+        self.name = "list"
+        self.description = "List available commands"
+        self.version = "1.0.0"
+    
+    def get_schema(self):
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    
+    async def execute(self, params: dict) -> dict:
+        """Execute list command."""
+        try:
+            # This is a simplified list - in a real implementation,
+            # this would query the command registry
+            commands = [
+                {
+                    "name": "echo",
+                    "description": "Echo command that returns the input message",
+                    "version": "1.0.0"
+                },
+                {
+                    "name": "list",
+                    "description": "List available commands",
+                    "version": "1.0.0"
+                },
+                {
+                    "name": "health",
+                    "description": "Health check command",
+                    "version": "1.0.0"
+                },
+                {
+                    "name": "help",
+                    "description": "Help command",
+                    "version": "1.0.0"
+                }
+            ]
+            
+            return {
+                "commands": commands,
+                "count": len(commands),
+                "timestamp": self._get_timestamp()
+            }
+        except Exception as e:
+            raise MicroserviceError(f"List command failed: {str(e)}")
+    
+    def _get_timestamp(self):
+        """Get current timestamp."""
+        import time
+        return time.time()

mcp_proxy_adapter/examples/full_application/hooks/application_hooks.py

@@ -18,25 +18,25 @@ class ApplicationHooks:
     @staticmethod
     def on_startup():
         """Hook executed on application startup."""
-        logger.info("🚀 Application startup hook executed")
+        get_global_logger().info("🚀 Application startup hook executed")
         # Initialize application-specific resources
-        logger.info("📊 Initializing application metrics")
-        logger.info("🔐 Loading security configurations")
-        logger.info("📝 Setting up logging")
+        get_global_logger().info("📊 Initializing application metrics")
+        get_global_logger().info("🔐 Loading security configurations")
+        get_global_logger().info("📝 Setting up logging")
 
     @staticmethod
     def on_shutdown():
         """Hook executed on application shutdown."""
-        logger.info("🛑 Application shutdown hook executed")
+        get_global_logger().info("🛑 Application shutdown hook executed")
         # Cleanup application resources
-        logger.info("🧹 Cleaning up resources")
-        logger.info("💾 Saving application state")
-        logger.info("📊 Finalizing metrics")
+        get_global_logger().info("🧹 Cleaning up resources")
+        get_global_logger().info("💾 Saving application state")
+        get_global_logger().info("📊 Finalizing metrics")
 
     @staticmethod
     def before_request(request_data: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before processing any request."""
-        logger.info(f"🔧 Application hook: before_request with data: {request_data}")
+        get_global_logger().info(f"🔧 Application hook: before_request with data: {request_data}")
         # Add request metadata
         request_data["app_metadata"] = {
             "request_id": f"req_{datetime.now().timestamp()}",
@@ -48,7 +48,7 @@ class ApplicationHooks:
     @staticmethod
     def after_request(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after processing any request."""
-        logger.info(f"🔧 Application hook: after_request with result: {result}")
+        get_global_logger().info(f"🔧 Application hook: after_request with result: {result}")
         # Add response metadata
         result["app_response_metadata"] = {
             "processed_at": datetime.now().isoformat(),
@@ -60,29 +60,29 @@ class ApplicationHooks:
     @staticmethod
     def on_error(error: Exception, context: Dict[str, Any]):
         """Hook executed when an error occurs."""
-        logger.error(f"🔧 Application hook: on_error - {error} in context: {context}")
+        get_global_logger().error(f"🔧 Application hook: on_error - {error} in context: {context}")
         # Log error details
-        logger.error(f"Error type: {type(error).__name__}")
-        logger.error(f"Error message: {str(error)}")
-        logger.error(f"Context: {context}")
+        get_global_logger().error(f"Error type: {type(error).__name__}")
+        get_global_logger().error(f"Error message: {str(error)}")
+        get_global_logger().error(f"Context: {context}")
 
     @staticmethod
     def on_command_registered(command_name: str, command_info: Dict[str, Any]):
         """Hook executed when a command is registered."""
-        logger.info(f"🔧 Application hook: on_command_registered - {command_name}")
-        logger.info(f"Command info: {command_info}")
+        get_global_logger().info(f"🔧 Application hook: on_command_registered - {command_name}")
+        get_global_logger().info(f"Command info: {command_info}")
         # Track registered commands
-        logger.info(f"📝 Command '{command_name}' registered successfully")
+        get_global_logger().info(f"📝 Command '{command_name}' registered successfully")
 
     @staticmethod
     def on_command_executed(command_name: str, execution_time: float, success: bool):
         """Hook executed when a command is executed."""
-        logger.info(f"🔧 Application hook: on_command_executed - {command_name}")
-        logger.info(f"Execution time: {execution_time}s, Success: {success}")
+        get_global_logger().info(f"🔧 Application hook: on_command_executed - {command_name}")
+        get_global_logger().info(f"Execution time: {execution_time}s, Success: {success}")
         # Track command execution metrics
         if success:
-            logger.info(
+            get_global_logger().info(
                 f"✅ Command '{command_name}' executed successfully in {execution_time}s"
             )
         else:
-            logger.warning(f"⚠️ Command '{command_name}' failed after {execution_time}s")
+            get_global_logger().warning(f"⚠️ Command '{command_name}' failed after {execution_time}s")

mcp_proxy_adapter/examples/full_application/hooks/builtin_command_hooks.py

@@ -18,7 +18,7 @@ class BuiltinCommandHooks:
     @staticmethod
     def before_echo_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before echo command."""
-        logger.info(f"🔧 Built-in hook: before_echo_command with params: {params}")
+        get_global_logger().info(f"🔧 Built-in hook: before_echo_command with params: {params}")
         # Add timestamp to message
         if "message" in params:
             timestamp = datetime.now().isoformat()
@@ -28,7 +28,7 @@ class BuiltinCommandHooks:
     @staticmethod
     def after_echo_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after echo command."""
-        logger.info(f"🔧 Built-in hook: after_echo_command with result: {result}")
+        get_global_logger().info(f"🔧 Built-in hook: after_echo_command with result: {result}")
         # Add hook metadata
         result["hook_metadata"] = {
             "hook_type": "builtin_after_echo",
@@ -40,7 +40,7 @@ class BuiltinCommandHooks:
     @staticmethod
     def before_health_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before health command."""
-        logger.info(f"🔧 Built-in hook: before_health_command with params: {params}")
+        get_global_logger().info(f"🔧 Built-in hook: before_health_command with params: {params}")
         # Add custom health check parameters
         params["include_detailed_info"] = True
         params["check_dependencies"] = True
@@ -49,7 +49,7 @@ class BuiltinCommandHooks:
     @staticmethod
     def after_health_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after health command."""
-        logger.info(f"🔧 Built-in hook: after_health_command with result: {result}")
+        get_global_logger().info(f"🔧 Built-in hook: after_health_command with result: {result}")
         # Add custom health metrics
         if "status" in result and result["status"] == "healthy":
             result["custom_metrics"] = {
@@ -62,7 +62,7 @@ class BuiltinCommandHooks:
     @staticmethod
     def before_config_command(params: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed before config command."""
-        logger.info(f"🔧 Built-in hook: before_config_command with params: {params}")
+        get_global_logger().info(f"🔧 Built-in hook: before_config_command with params: {params}")
         # Add configuration validation
         params["validate_config"] = True
         params["include_secrets"] = False
@@ -71,7 +71,7 @@ class BuiltinCommandHooks:
     @staticmethod
     def after_config_command(result: Dict[str, Any]) -> Dict[str, Any]:
         """Hook executed after config command."""
-        logger.info(f"🔧 Built-in hook: after_config_command with result: {result}")
+        get_global_logger().info(f"🔧 Built-in hook: after_config_command with result: {result}")
         # Add configuration metadata
         result["config_metadata"] = {
             "last_modified": datetime.now().isoformat(),

mcp_proxy_adapter/examples/full_application/main.py

@@ -30,6 +30,7 @@ class FullApplication:
         self.config_path = config_path
         try:
             self.config = Config(config_path, validate_on_load=True)
+            self.config.load_config()  # Explicitly load the configuration
             self.logger = logging.getLogger(__name__)
             self.logger.info("✅ Configuration loaded and validated successfully")
         except Exception as e:
@@ -152,5 +153,32 @@ def get_app():
     return app
 
 
+def main():
+    """Main entry point."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="MCP Proxy Adapter Full Application")
+    parser.add_argument("--config", required=True, help="Path to configuration file")
+    parser.add_argument("--port", type=int, help="Port to run server on")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    
+    args = parser.parse_args()
+    
+    # Create application
+    app_instance = FullApplication(args.config)
+    
+    # Override port if specified
+    if args.port:
+        app_instance.config.config_data["server"]["port"] = args.port
+        print(f"🔧 Overriding port to {args.port}")
+    
+    # Override host if specified
+    if args.host:
+        app_instance.config.config_data["server"]["host"] = args.host
+        print(f"🔧 Overriding host to {args.host}")
+    
+    # Run server
+    app_instance.run()
+
 if __name__ == "__main__":
     main()