mcp-proxy-adapter 6.2.24__py3-none-any.whl → 6.2.26__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -350,9 +350,6 @@ def create_app(title: Optional[str] = None, description: Optional[str] = None, v
     )
     
     # Setup middleware using the new middleware package
-    print(f"DEBUG create_app: calling setup_middleware with config type: {type(current_config)}")
-    if hasattr(current_config, 'keys'):
-        print(f"DEBUG create_app: current_config keys: {list(current_config.keys())}")
     setup_middleware(app, current_config)
     
     # Use custom OpenAPI schema

mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -87,7 +87,7 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Response object
         """
-        logger.info(f"ProtocolMiddleware.dispatch called for {request.method} {request.url.path}")
+        logger.debug(f"ProtocolMiddleware.dispatch called for {request.method} {request.url.path}")
         try:
             # Get protocol from request
             protocol = self._get_request_protocol(request)
@@ -169,32 +169,32 @@ def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
         app: FastAPI application
         app_config: Application configuration dictionary (optional)
     """
-    logger.info(f"setup_protocol_middleware - app_config type: {type(app_config)}")
+    logger.debug(f"setup_protocol_middleware - app_config type: {type(app_config)}")
 
     # Check if protocol management is enabled
     if app_config is None:
         from mcp_proxy_adapter.config import config
         app_config = config.get_all()
-        logger.info(f"setup_protocol_middleware - loaded from global config, type: {type(app_config)}")
+        logger.debug(f"setup_protocol_middleware - loaded from global config, type: {type(app_config)}")
 
-    logger.info(f"setup_protocol_middleware - final app_config type: {type(app_config)}")
+    logger.debug(f"setup_protocol_middleware - final app_config type: {type(app_config)}")
 
     if hasattr(app_config, 'get'):
-        logger.info(f"setup_protocol_middleware - app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}")
+        logger.debug(f"setup_protocol_middleware - app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}")
         protocols_config = app_config.get("protocols", {})
-        logger.info(f"setup_protocol_middleware - protocols_config type: {type(protocols_config)}")
+        logger.debug(f"setup_protocol_middleware - protocols_config type: {type(protocols_config)}")
         enabled = protocols_config.get("enabled", True) if hasattr(protocols_config, 'get') else True
     else:
-        logger.info(f"setup_protocol_middleware - app_config is not dict-like: {repr(app_config)}")
+        logger.debug(f"setup_protocol_middleware - app_config is not dict-like: {repr(app_config)}")
         enabled = True
 
-    logger.info(f"setup_protocol_middleware - protocol management enabled: {enabled}")
+    logger.debug(f"setup_protocol_middleware - protocol management enabled: {enabled}")
 
     if enabled:
         # Create protocol middleware with current configuration
-        logger.info(f"setup_protocol_middleware - creating ProtocolMiddleware with config type: {type(app_config)}")
+        logger.debug(f"setup_protocol_middleware - creating ProtocolMiddleware with config type: {type(app_config)}")
         middleware = ProtocolMiddleware(app, app_config)
-        logger.info(f"setup_protocol_middleware - adding middleware to app")
+        logger.debug(f"setup_protocol_middleware - adding middleware to app")
         app.add_middleware(ProtocolMiddleware, app_config=app_config)
         logger.info("Protocol middleware added to application")
     else:

mcp_proxy_adapter/commands/health_command.py

@@ -80,7 +80,7 @@ class HealthCommand(Command):
     name = "health"
     result_class = HealthResult
     
-    async def execute(self) -> HealthResult:
+    async def execute(self, **kwargs) -> HealthResult:
         """
         Execute health command.
         

mcp_proxy_adapter/config.py

@@ -7,14 +7,14 @@ 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):
@@ -22,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] = {}
@@ -56,10 +57,13 @@ class Config:
             },
             "commands": {
                 "auto_discovery": True,
-                "commands_directory": "./commands",  # Path to directory with command files
-                "catalog_directory": "./catalog",  # Path to command catalog directory
-                "plugin_servers": [],  # List of plugin server URLs
-                "auto_install_dependencies": True  # Automatically install plugin dependencies
+                "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,
@@ -69,7 +73,10 @@ class Config:
                 "ca_cert": None,
                 "verify_client": False,
                 "client_cert_required": False,
-                "cipher_suites": ["TLS_AES_256_GCM_SHA384", "TLS_CHACHA20_POLY1305_SHA256"],
+                "cipher_suites": [
+                    "TLS_AES_256_GCM_SHA384",
+                    "TLS_CHACHA20_POLY1305_SHA256"
+                ],
                 "min_tls_version": "TLSv1.2",
                 "max_tls_version": "1.3",
                 "token_auth": {
@@ -118,12 +125,6 @@ class Config:
                 "auto_register_on_startup": True,
                 "auto_unregister_on_shutdown": True
             },
-            "commands": {
-                "auto_discovery": True,
-                "enabled_commands": ["health", "echo", "list", "help"],
-                "disabled_commands": [],
-                "custom_commands_path": "./commands"
-            },
             "debug": {
                 "enabled": False,
                 "level": "WARNING"
@@ -226,7 +227,7 @@ class Config:
                 "auto_discovery": True
             }
         }
-        
+
         # Try to load configuration from file
         if os.path.exists(self.config_path):
             try:
@@ -235,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()
 
@@ -300,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]:
@@ -332,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:
@@ -350,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:
@@ -374,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()

mcp_proxy_adapter/core/protocol_manager.py

@@ -35,28 +35,28 @@ class ProtocolManager:
         """Load protocol configuration from config."""
         # Use provided config or fallback to global config; normalize types
         current_config = self.app_config if self.app_config is not None else config.get_all()
-        logger.info(f"ProtocolManager._load_config - current_config type: {type(current_config)}")
+        logger.debug(f"ProtocolManager._load_config - current_config type: {type(current_config)}")
 
         if not hasattr(current_config, 'get'):
             # Not a dict-like config, fallback to global
-            logger.info(f"ProtocolManager._load_config - current_config is not dict-like, falling back to global config")
+            logger.debug(f"ProtocolManager._load_config - current_config is not dict-like, falling back to global config")
             current_config = config.get_all()
 
-        logger.info(f"ProtocolManager._load_config - final current_config type: {type(current_config)}")
+        logger.debug(f"ProtocolManager._load_config - final current_config type: {type(current_config)}")
         if hasattr(current_config, 'get'):
-            logger.info(f"ProtocolManager._load_config - current_config keys: {list(current_config.keys()) if hasattr(current_config, 'keys') else 'no keys'}")
+            logger.debug(f"ProtocolManager._load_config - current_config keys: {list(current_config.keys()) if hasattr(current_config, 'keys') else 'no keys'}")
 
         # Get protocols configuration
-        logger.info(f"ProtocolManager._load_config - before getting protocols")
+        logger.debug(f"ProtocolManager._load_config - before getting protocols")
         try:
             self.protocols_config = current_config.get("protocols", {})
-            logger.info(f"ProtocolManager._load_config - protocols_config type: {type(self.protocols_config)}")
+            logger.debug(f"ProtocolManager._load_config - protocols_config type: {type(self.protocols_config)}")
             if hasattr(self.protocols_config, 'get'):
-                logger.info(f"ProtocolManager._load_config - protocols_config is dict-like")
+                logger.debug(f"ProtocolManager._load_config - protocols_config is dict-like")
             else:
-                logger.info(f"ProtocolManager._load_config - protocols_config is NOT dict-like: {repr(self.protocols_config)}")
+                logger.debug(f"ProtocolManager._load_config - protocols_config is NOT dict-like: {repr(self.protocols_config)}")
         except Exception as e:
-            logger.info(f"ProtocolManager._load_config - ERROR getting protocols: {e}")
+            logger.debug(f"ProtocolManager._load_config - ERROR getting protocols: {e}")
             self.protocols_config = {}
 
         self.enabled = self.protocols_config.get("enabled", True) if hasattr(self.protocols_config, 'get') else True

mcp_proxy_adapter/examples/create_certificates_simple.py

@@ -466,18 +466,13 @@ class SimpleCertificateCreator:
                     shutil.copy2(ca_cert, expected_ca_cert)
                     print(f"✅ Created CA certificate copy: {expected_ca_cert}")
 
-            # Server certificate symlink
+            # Server certificate copy
             server_cert = self.certs_dir / "server_cert.pem"
             expected_server_cert = self.certs_dir / "localhost_server.crt"
             if server_cert.exists() and not expected_server_cert.exists():
-                try:
-                    expected_server_cert.symlink_to(server_cert)
-                    print(f"✅ Created server certificate symlink: {expected_server_cert}")
-                except OSError:
-                    # On Windows, symlink might require admin privileges, copy instead
-                    import shutil
-                    shutil.copy2(server_cert, expected_server_cert)
-                    print(f"✅ Created server certificate copy: {expected_server_cert}")
+                import shutil
+                shutil.copy2(server_cert, expected_server_cert)
+                print(f"✅ Created server certificate copy: {expected_server_cert}")
 
             # Server key symlink - check if it's in certs or keys directory
             server_key_certs = self.certs_dir / "server_key.pem"
@@ -492,14 +487,9 @@ class SimpleCertificateCreator:
             if server_key_keys.exists():
                 expected_server_key = self.keys_dir / "localhost_server.key"
                 if not expected_server_key.exists():
-                    try:
-                        expected_server_key.symlink_to(server_key_keys)
-                        print(f"✅ Created server key symlink: {expected_server_key}")
-                    except OSError:
-                        # On Windows, symlink might require admin privileges, copy instead
-                        import shutil
-                        shutil.copy2(server_key_keys, expected_server_key)
-                        print(f"✅ Created server key copy: {expected_server_key}")
+                    import shutil
+                    shutil.copy2(server_key_keys, expected_server_key)
+                    print(f"✅ Created server key copy: {expected_server_key}")
 
         # Print summary
         print("\n" + "=" * 60)

mcp_proxy_adapter/examples/examples/basic_framework/__init__.py

@@ -0,0 +1,9 @@
+"""Basic Framework Example.
+
+This example demonstrates the fundamental usage of MCP Proxy Adapter
+with minimal configuration and basic command registration.
+
+Note: This package provides a basic example of MCP Proxy Adapter usage.
+The main application is created dynamically in main.py and not exported
+as a global variable for this example.
+"""

mcp_proxy_adapter/examples/examples/basic_framework/commands/__init__.py

@@ -0,0 +1,4 @@
+"""Basic Framework Commands.
+
+Commands for the basic framework example.
+"""

mcp_proxy_adapter/examples/examples/basic_framework/hooks/__init__.py

@@ -0,0 +1,4 @@
+"""Basic Framework Hooks.
+
+Hooks for the basic framework example.
+"""

mcp_proxy_adapter/examples/examples/basic_framework/main.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+Basic Framework Example
+This example demonstrates the basic usage of the MCP Proxy Adapter framework
+with minimal configuration and built-in commands.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import sys
+import argparse
+from pathlib import Path
+# Add the framework to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+from mcp_proxy_adapter.core.app_factory import create_and_run_server
+def main():
+    """Main entry point for the basic framework example."""
+    parser = argparse.ArgumentParser(description="Basic Framework Example")
+    parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
+    parser.add_argument("--host", help="Server host")
+    parser.add_argument("--port", type=int, help="Server port")
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+    args = parser.parse_args()
+    # Override configuration if specified
+    config_overrides = {}
+    if args.host:
+        config_overrides["host"] = args.host
+    if args.port:
+        config_overrides["port"] = args.port
+    if args.debug:
+        config_overrides["debug"] = True
+    print(f"🚀 Starting Basic Framework Example")
+    print(f"📋 Configuration: {args.config}")
+    print("=" * 50)
+    # Use the factory method to create and run the server
+    create_and_run_server(
+        config_path=args.config,
+        title="Basic Framework Example",
+        description="Basic MCP Proxy Adapter with minimal configuration",
+        version="1.0.0",
+        host=config_overrides.get("host", "0.0.0.0"),
+        log_level="debug" if config_overrides.get("debug", False) else "info"
+    )
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/examples/full_application/__init__.py

@@ -0,0 +1,12 @@
+"""Full Application Example.
+
+This example demonstrates advanced usage of MCP Proxy Adapter including:
+- Proxy registration endpoints
+- Custom command hooks
+- Advanced security configurations
+- Role-based access control
+"""
+
+from .main import get_app
+app = get_app()
+from .proxy_endpoints import router as proxy_router

mcp_proxy_adapter/examples/examples/full_application/commands/__init__.py

@@ -0,0 +1,7 @@
+"""Full Application Commands.
+
+Custom command implementations for the full application example.
+"""
+
+from .custom_echo_command import CustomEchoCommand
+from .dynamic_calculator_command import DynamicCalculatorCommand