mcp-proxy-adapter 6.2.25__py3-none-any.whl → 6.2.27__py3-none-any.whl

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/examples/generate_test_configs.py

@@ -9,7 +9,11 @@ import json
 import os
 import argparse
 from typing import Dict, Any
-def generate_http_simple_config(port: int = 20000, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
+
+
+def generate_http_simple_config(
+    port: int = 20000, certs_dir: str = "certs", keys_dir: str = "keys"
+) -> Dict[str, Any]:
     """Generate HTTP configuration without authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -23,13 +27,27 @@ def generate_http_simple_config(port: int = 20000, certs_dir: str = "certs", key
             "proxy_info": {
                 "name": "mcp_example_server",
                 "capabilities": ["jsonrpc", "rest", "proxy_registration"],
-                "endpoints": {"jsonrpc": "/api/jsonrpc", "rest": "/cmd", "health": "/health"}
+                "endpoints": {
+                    "jsonrpc": "/api/jsonrpc",
+                    "rest": "/cmd",
+                    "health": "/health"
+                }
             },
             "heartbeat": {"enabled": True, "interval": 30}
         },
-        "protocols": {"enabled": True, "allowed_protocols": ["http"]}
+        "protocols": {
+            "enabled": True,
+            "allowed_protocols": ["http"]
+        }
     }
-def generate_http_token_config(port: int = 20001, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> Dict[str, Any]:
+
+
+def generate_http_token_config(
+    port: int = 20001,
+    certs_dir: str = "certs",
+    keys_dir: str = "keys",
+    roles_file: str = "configs/roles.json"
+) -> Dict[str, Any]:
     """Generate HTTP configuration with token authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -59,9 +77,16 @@ def generate_http_token_config(port: int = 20001, certs_dir: str = "certs", keys
             "retry_delay": 5,
             "heartbeat": {"enabled": True, "interval": 30}
         },
-        "protocols": {"enabled": True, "allowed_protocols": ["http"]}
+        "protocols": {
+            "enabled": True,
+            "allowed_protocols": ["http"]
+        }
     }
-def generate_https_simple_config(port: int = 20002, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
+
+
+def generate_https_simple_config(
+    port: int = 20002, certs_dir: str = "certs", keys_dir: str = "keys"
+) -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification and authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -80,9 +105,16 @@ def generate_https_simple_config(port: int = 20002, certs_dir: str = "certs", ke
             "retry_delay": 5,
             "heartbeat": {"enabled": True, "interval": 30}
         },
-        "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
+        "protocols": {
+            "enabled": True,
+            "allowed_protocols": ["http", "https"]
+        }
     }
-def generate_https_token_config(port: int = 20003, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
+
+
+def generate_https_token_config(
+    port: int = 20003, certs_dir: str = "certs", keys_dir: str = "keys"
+) -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification with token authorization."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -115,9 +147,16 @@ def generate_https_token_config(port: int = 20003, certs_dir: str = "certs", key
             "retry_delay": 5,
             "heartbeat": {"enabled": True, "interval": 30}
         },
-        "protocols": {"enabled": True, "allowed_protocols": ["http", "https"]}
+        "protocols": {
+            "enabled": True,
+            "allowed_protocols": ["http", "https"]
+        }
     }
-def generate_mtls_no_roles_config(port: int = 20004, certs_dir: str = "certs", keys_dir: str = "keys") -> Dict[str, Any]:
+
+
+def generate_mtls_no_roles_config(
+    port: int = 20004, certs_dir: str = "certs", keys_dir: str = "keys"
+) -> Dict[str, Any]:
     """Generate mTLS configuration without roles."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -126,16 +165,30 @@ def generate_mtls_no_roles_config(port: int = 20004, certs_dir: str = "certs", k
             "cert_file": f"{certs_dir}/localhost_server.crt",
             "key_file": f"{keys_dir}/localhost_server.key",
             "ca_cert": f"{certs_dir}/mcp_proxy_adapter_ca_ca.crt",
-            "verify_client": True
+            "verify_client": True,
+            "client_cert_required": True
         },
         "security": {
             "enabled": True,
             "auth": {"enabled": True, "methods": ["certificate"]},
             "permissions": {"enabled": False}
         },
-        "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]}
+        "registration": {
+            "enabled": False
+        },
+        "protocols": {
+            "enabled": True,
+            "allowed_protocols": ["https", "mtls"]
+        }
     }
-def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> Dict[str, Any]:
+
+
+def generate_mtls_with_roles_config(
+    port: int = 20005,
+    certs_dir: str = "certs",
+    keys_dir: str = "keys",
+    roles_file: str = "configs/roles.json"
+) -> Dict[str, Any]:
     """Generate mTLS configuration with roles."""
     return {
         "server": {"host": "127.0.0.1", "port": port},
@@ -154,7 +207,11 @@ def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "certs",
             "proxy_info": {
                 "name": "mcp_example_server",
                 "capabilities": ["jsonrpc", "rest", "security", "proxy_registration"],
-                "endpoints": {"jsonrpc": "/api/jsonrpc", "rest": "/cmd", "health": "/health"}
+                "endpoints": {
+                    "jsonrpc": "/api/jsonrpc",
+                    "rest": "/cmd",
+                    "health": "/health"
+                }
             },
             "heartbeat": {"enabled": True, "interval": 30}
         },
@@ -163,8 +220,13 @@ def generate_mtls_with_roles_config(port: int = 20005, certs_dir: str = "certs",
             "auth": {"enabled": True, "methods": ["certificate"]},
             "permissions": {"enabled": True, "roles_file": roles_file}
         },
-        "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]}
+        "protocols": {
+            "enabled": True,
+            "allowed_protocols": ["https", "mtls"]
+        }
     }
+
+
 def generate_roles_config() -> Dict[str, Any]:
     """Generate roles configuration for testing."""
     return {
@@ -222,7 +284,14 @@ def generate_roles_config() -> Dict[str, Any]:
             "tokens": ["proxy-token-123"]
         }
     }
-def generate_all_configs(output_dir: str, certs_dir: str = "certs", keys_dir: str = "keys", roles_file: str = "configs/roles.json") -> None:
+
+
+def generate_all_configs(
+    output_dir: str,
+    certs_dir: str = "certs",
+    keys_dir: str = "keys",
+    roles_file: str = "configs/roles.json"
+) -> None:
     """Generate all 6 configuration types and save them to files."""
     # Ensure output directory exists first
     os.makedirs(output_dir, exist_ok=True)
@@ -235,17 +304,17 @@ def generate_all_configs(output_dir: str, certs_dir: str = "certs", keys_dir: st
         "mtls_no_roles": generate_mtls_no_roles_config(20004, certs_dir, keys_dir),
         "mtls_with_roles": generate_mtls_with_roles_config(20005, certs_dir, keys_dir, roles_file)
     }
-    # Ensure output directory exists
-    os.makedirs(output_dir, exist_ok=True)
+
     # Generate each configuration
     for name, config in configs.items():
         filename = os.path.join(output_dir, f"{name}.json")
         with open(filename, 'w', encoding='utf-8') as f:
             json.dump(config, f, indent=2, ensure_ascii=False)
         print(f"Generated: {filename}")
+
     # Generate roles configuration
     roles_config = generate_roles_config()
-    
+
     # Create roles.json in the root directory (test environment root) for compatibility
     # When running as module, we need to create roles.json in the current working directory
     # This is the directory where the user is running the command from
@@ -253,30 +322,30 @@ def generate_all_configs(output_dir: str, certs_dir: str = "certs", keys_dir: st
         # Get the current working directory where the user is running the command
         current_dir = os.getcwd()
         root_roles_filename = os.path.join(current_dir, "roles.json")
-        
+
         # Create roles.json in the current working directory
         with open(root_roles_filename, 'w', encoding='utf-8') as f:
             json.dump(roles_config, f, indent=2, ensure_ascii=False)
         print(f"Generated: {root_roles_filename}")
-        
+
         # Also create a copy in the output directory for reference
         backup_roles_filename = os.path.join(output_dir, "roles_backup.json")
         with open(backup_roles_filename, 'w', encoding='utf-8') as f:
             json.dump(roles_config, f, indent=2, ensure_ascii=False)
         print(f"Generated backup: {backup_roles_filename}")
-        
+
     except Exception as e:
         print(f"Warning: Could not create roles.json in current directory: {e}")
         print(f"Current working directory: {os.getcwd()}")
         print(f"Script directory: {os.path.dirname(os.path.abspath(__file__))}")
-    
+
     # Also create roles.json in configs directory for reference
     roles_filename = os.path.join(output_dir, "roles.json")
     with open(roles_filename, 'w', encoding='utf-8') as f:
         json.dump(roles_config, f, indent=2, ensure_ascii=False)
     print(f"Generated: {roles_filename}")
     print(f"\nGenerated {len(configs)} configuration files and roles.json in {output_dir}")
-    
+
     print("\n" + "=" * 60)
     print("✅ CONFIGURATION GENERATION COMPLETED SUCCESSFULLY")
     print("=" * 60)
@@ -288,7 +357,9 @@ def generate_all_configs(output_dir: str, certs_dir: str = "certs", keys_dir: st
     print("\n3. Start full application example:")
     print("   python -m mcp_proxy_adapter.examples.full_application.main --config configs/mtls_with_roles.json")
     print("=" * 60)
-def main():
+
+
+def main() -> int:
     """Main function for command line execution."""
     parser = argparse.ArgumentParser(
         description="Generate test configurations for MCP Proxy Adapter"
@@ -314,6 +385,7 @@ def main():
         help="Roles file path (default: configs/roles.json)"
     )
     args = parser.parse_args()
+
     try:
         generate_all_configs(args.output_dir, args.certs_dir, args.keys_dir, args.roles_file)
         print("Configuration generation completed successfully!")
@@ -327,5 +399,7 @@ def main():
         print("=" * 60)
         return 1
     return 0
+
+
 if __name__ == "__main__":
     exit(main())

mcp_proxy_adapter/utils/config_generator.py

@@ -262,7 +262,11 @@ class ConfigGenerator:
                 - "https": HTTPS configuration
                 - "https_token": HTTPS with token authentication
                 - "mtls": mTLS configuration
-                
+                - "optional_ssl": Configuration with optional SSL
+                - "optional_auth": Configuration with optional authentication
+                - "optional_proxy_reg": Configuration with optional proxy registration
+                - "custom": Custom configuration with specified features
+
         Returns:
             JSON configuration string with comments
         """
@@ -300,6 +304,14 @@ class ConfigGenerator:
             return self._get_mtls_config(base_config)
         elif config_type == "mtls_no_protocol_middleware":
             return self._get_mtls_no_protocol_middleware_config(base_config)
+        elif config_type == "optional_ssl":
+            return self._get_optional_ssl_config(base_config)
+        elif config_type == "optional_auth":
+            return self._get_optional_auth_config(base_config)
+        elif config_type == "optional_proxy_reg":
+            return self._get_optional_proxy_reg_config(base_config)
+        elif config_type == "custom":
+            return self._get_custom_config(base_config)
         else:  # full
             return base_config
     
@@ -543,6 +555,245 @@ class ConfigGenerator:
         
         return config
     
+    def _get_optional_ssl_config(self, base_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Get configuration with optional SSL support."""
+        config = base_config.copy()
+        
+        # Server configuration
+        config["server"]["port"] = 8000
+        
+        # SSL configuration - can be enabled/disabled via environment or config
+        config["ssl"]["enabled"] = False  # Default disabled, can be enabled
+        config["ssl"]["cert_file"] = "mcp_proxy_adapter/examples/certs/server_cert.pem"
+        config["ssl"]["key_file"] = "mcp_proxy_adapter/examples/certs/server_key.pem"
+        config["ssl"]["ca_cert"] = "mcp_proxy_adapter/examples/certs/ca_cert.pem"
+        config["ssl"]["verify_client"] = False  # Can be enabled for mTLS
+        
+        # Security framework SSL - mirrors main SSL config
+        config["security"]["ssl"]["enabled"] = False  # Default disabled
+        config["security"]["ssl"]["cert_file"] = "mcp_proxy_adapter/examples/certs/server_cert.pem"
+        config["security"]["ssl"]["key_file"] = "mcp_proxy_adapter/examples/certs/server_key.pem"
+        config["security"]["ssl"]["ca_cert_file"] = "mcp_proxy_adapter/examples/certs/ca_cert.pem"
+        config["security"]["ssl"]["client_cert_file"] = "mcp_proxy_adapter/examples/certs/client_cert.pem"
+        config["security"]["ssl"]["client_key_file"] = "mcp_proxy_adapter/examples/certs/client_key.key"
+        
+        # Protocols support both HTTP and HTTPS
+        config["protocols"]["enabled"] = True
+        config["protocols"]["allowed_protocols"] = ["http", "https"]
+        config["protocols"]["default_protocol"] = "http"
+        
+        # Enable proxy registration with token auth
+        config["registration"]["enabled"] = True
+        config["registration"]["auth_method"] = "token"
+        config["registration"]["token"]["enabled"] = True
+        config["registration"]["token"]["token"] = "proxy_registration_token_123"
+        config["registration"]["server_url"] = "http://127.0.0.1:3004/proxy"
+        
+        return config
+    
+    def _get_optional_auth_config(self, base_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Get configuration with optional authentication support."""
+        config = base_config.copy()
+        
+        # Server configuration
+        config["server"]["port"] = 8001
+        
+        # SSL disabled by default
+        config["ssl"]["enabled"] = False
+        config["security"]["ssl"]["enabled"] = False
+        
+        # Authentication configuration - can be enabled/disabled
+        config["security"]["auth"]["enabled"] = False  # Default disabled
+        config["security"]["auth"]["methods"] = ["api_key", "jwt"]  # Available methods
+        
+        # API keys configuration
+        config["security"]["auth"]["api_keys"] = {
+            "admin-token": {
+                "roles": ["admin"],
+                "permissions": ["*"],
+                "expires": None
+            },
+            "user-token": {
+                "roles": ["user"],
+                "permissions": ["read", "execute"],
+                "expires": None
+            },
+            "guest-token": {
+                "roles": ["guest"],
+                "permissions": ["read"],
+                "expires": None
+            }
+        }
+        
+        # JWT configuration
+        config["security"]["auth"]["jwt_secret"] = "your_jwt_secret_here"
+        config["security"]["auth"]["jwt_algorithm"] = "HS256"
+        config["security"]["auth"]["jwt_expiry_hours"] = 24
+        
+        # User roles mapping
+        config["security"]["auth"]["user_roles"] = {
+            "admin": ["admin"],
+            "user": ["user"],
+            "guest": ["guest"]
+        }
+        
+        # Permissions configuration - can be enabled/disabled
+        config["security"]["permissions"]["enabled"] = False  # Default disabled
+        config["security"]["permissions"]["roles_file"] = "mcp_proxy_adapter/examples/server_configs/roles.json"
+        config["security"]["permissions"]["default_role"] = "guest"
+        config["security"]["permissions"]["admin_role"] = "admin"
+        
+        # Protocols
+        config["protocols"]["enabled"] = True
+        config["protocols"]["allowed_protocols"] = ["http"]
+        config["protocols"]["default_protocol"] = "http"
+        
+        # Enable proxy registration
+        config["registration"]["enabled"] = True
+        config["registration"]["auth_method"] = "token"
+        config["registration"]["token"]["enabled"] = True
+        config["registration"]["token"]["token"] = "proxy_registration_token_123"
+        
+        return config
+    
+    def _get_optional_proxy_reg_config(self, base_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Get configuration with optional proxy registration support."""
+        config = base_config.copy()
+        
+        # Server configuration
+        config["server"]["port"] = 8002
+        
+        # SSL disabled by default
+        config["ssl"]["enabled"] = False
+        config["security"]["ssl"]["enabled"] = False
+        
+        # Authentication disabled by default
+        config["security"]["auth"]["enabled"] = False
+        config["security"]["permissions"]["enabled"] = False
+        
+        # Proxy registration configuration - can be enabled/disabled
+        config["registration"]["enabled"] = False  # Default disabled
+        config["registration"]["server_url"] = "http://127.0.0.1:3004/proxy"
+        config["registration"]["server_id"] = "mcp_proxy_adapter"
+        config["registration"]["server_name"] = "MCP Proxy Adapter"
+        config["registration"]["description"] = "JSON-RPC API for interacting with MCP Proxy"
+        
+        # Multiple authentication methods for proxy registration
+        config["registration"]["auth_method"] = "token"  # Default method
+        
+        # Token authentication
+        config["registration"]["token"]["enabled"] = True
+        config["registration"]["token"]["token"] = "proxy_registration_token_123"
+        config["registration"]["token"]["token_type"] = "bearer"
+        config["registration"]["token"]["refresh_interval"] = 3600
+        
+        # Certificate authentication
+        config["registration"]["certificate"]["enabled"] = False
+        config["registration"]["certificate"]["cert_file"] = "mcp_proxy_adapter/examples/certs/proxy_client.crt"
+        config["registration"]["certificate"]["key_file"] = "mcp_proxy_adapter/examples/keys/proxy_client.key"
+        config["registration"]["certificate"]["ca_cert_file"] = "mcp_proxy_adapter/examples/certs/ca.crt"
+        config["registration"]["certificate"]["verify_server"] = True
+        
+        # API key authentication
+        config["registration"]["api_key"]["enabled"] = False
+        config["registration"]["api_key"]["key"] = "proxy_api_key_456"
+        config["registration"]["api_key"]["key_header"] = "X-Proxy-API-Key"
+        
+        # Proxy information
+        config["registration"]["proxy_info"]["name"] = "mcp_proxy_adapter"
+        config["registration"]["proxy_info"]["version"] = "1.0.0"
+        config["registration"]["proxy_info"]["description"] = "MCP Proxy Adapter with optional features"
+        config["registration"]["proxy_info"]["capabilities"] = ["jsonrpc", "rest", "optional_features"]
+        config["registration"]["proxy_info"]["endpoints"] = {
+            "jsonrpc": "/api/jsonrpc",
+            "rest": "/cmd",
+            "health": "/health"
+        }
+        
+        # Heartbeat configuration
+        config["registration"]["heartbeat"]["enabled"] = True
+        config["registration"]["heartbeat"]["interval"] = 300
+        config["registration"]["heartbeat"]["timeout"] = 30
+        config["registration"]["heartbeat"]["retry_attempts"] = 3
+        config["registration"]["heartbeat"]["retry_delay"] = 60
+        
+        # Auto-discovery
+        config["registration"]["auto_discovery"]["enabled"] = False
+        config["registration"]["auto_discovery"]["discovery_urls"] = []
+        config["registration"]["auto_discovery"]["discovery_interval"] = 3600
+        config["registration"]["auto_discovery"]["register_on_discovery"] = True
+        
+        # Protocols
+        config["protocols"]["enabled"] = True
+        config["protocols"]["allowed_protocols"] = ["http"]
+        config["protocols"]["default_protocol"] = "http"
+        
+        return config
+    
+    def _get_custom_config(self, base_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Get custom configuration with configurable features."""
+        config = base_config.copy()
+        
+        # Server configuration
+        config["server"]["port"] = 8003
+        
+        # SSL configuration - configurable
+        config["ssl"]["enabled"] = False  # Can be enabled via config
+        config["ssl"]["cert_file"] = "mcp_proxy_adapter/examples/certs/server_cert.pem"
+        config["ssl"]["key_file"] = "mcp_proxy_adapter/examples/certs/server_key.pem"
+        config["ssl"]["ca_cert"] = "mcp_proxy_adapter/examples/certs/ca_cert.pem"
+        config["ssl"]["verify_client"] = False  # Can be enabled for mTLS
+        
+        # Security framework - configurable
+        config["security"]["enabled"] = False  # Can be enabled via config
+        config["security"]["ssl"]["enabled"] = False  # Mirrors main SSL
+        config["security"]["ssl"]["cert_file"] = "mcp_proxy_adapter/examples/certs/server_cert.pem"
+        config["security"]["ssl"]["key_file"] = "mcp_proxy_adapter/examples/certs/server_key.pem"
+        config["security"]["ssl"]["ca_cert_file"] = "mcp_proxy_adapter/examples/certs/ca_cert.pem"
+        
+        # Authentication - configurable
+        config["security"]["auth"]["enabled"] = False  # Can be enabled via config
+        config["security"]["auth"]["methods"] = ["api_key", "jwt", "certificate"]
+        config["security"]["auth"]["api_keys"] = {
+            "custom-admin": {
+                "roles": ["admin"],
+                "permissions": ["*"],
+                "expires": None
+            },
+            "custom-user": {
+                "roles": ["user"],
+                "permissions": ["read", "execute"],
+                "expires": None
+            }
+        }
+        
+        # Permissions - configurable
+        config["security"]["permissions"]["enabled"] = False  # Can be enabled via config
+        config["security"]["permissions"]["roles_file"] = "mcp_proxy_adapter/examples/server_configs/roles.json"
+        
+        # Rate limiting - configurable
+        config["security"]["rate_limit"]["enabled"] = False  # Can be enabled via config
+        config["security"]["rate_limit"]["default_requests_per_minute"] = 60
+        config["security"]["rate_limit"]["default_requests_per_hour"] = 1000
+        
+        # Certificates - configurable
+        config["security"]["certificates"]["enabled"] = False  # Can be enabled via config
+        config["security"]["certificates"]["cert_storage_path"] = "./certs"
+        config["security"]["certificates"]["key_storage_path"] = "./keys"
+        
+        # Proxy registration - configurable
+        config["registration"]["enabled"] = False  # Can be enabled via config
+        config["registration"]["auth_method"] = "token"
+        config["registration"]["token"]["enabled"] = True
+        config["registration"]["token"]["token"] = "custom_proxy_token"
+        
+        # Protocols
+        config["protocols"]["enabled"] = True
+        config["protocols"]["allowed_protocols"] = ["http", "https"]
+        config["protocols"]["default_protocol"] = "http"
+        
+        return config
+    
     def _get_secure_config(self, base_config: Dict[str, Any]) -> Dict[str, Any]:
         """Get secure configuration with all security features enabled."""
         config = base_config.copy()
@@ -660,27 +911,42 @@ class ConfigGenerator:
         elif config_type == "mtls_no_protocol_middleware":
             base_comments["ssl"] = "SSL/TLS configuration (enabled for mTLS without ProtocolMiddleware)"
             base_comments["security"] = "Security framework configuration (mTLS mode without ProtocolMiddleware)"
+        elif config_type == "optional_ssl":
+            base_comments["ssl"] = "SSL/TLS configuration (optional, can be enabled/disabled)"
+            base_comments["security"] = "Security framework SSL configuration (mirrors main SSL)"
+        elif config_type == "optional_auth":
+            base_comments["ssl"] = "SSL/TLS configuration (disabled for optional auth)"
+            base_comments["security"] = "Security framework authentication configuration (optional, can be enabled/disabled)"
+        elif config_type == "optional_proxy_reg":
+            base_comments["ssl"] = "SSL/TLS configuration (disabled for optional proxy reg)"
+            base_comments["security"] = "Security framework proxy registration configuration (optional, can be enabled/disabled)"
+        elif config_type == "custom":
+            base_comments["ssl"] = "SSL/TLS configuration (configurable)"
+            base_comments["security"] = "Security framework configuration (configurable)"
+            base_comments["registration"] = "Proxy registration configuration (configurable)"
+            base_comments["protocols"] = "Protocol endpoints and settings (configurable)"
         
         return base_comments
     
     def generate_config_file(self, output_path: str, config_type: str = "full") -> None:
         """
         Generate configuration file and save to disk.
-        
+
         Args:
             output_path: Path to save the configuration file
             config_type: Type of configuration to generate
         """
         try:
-            config_content = self.generate_config_with_comments(config_type)
+            # Get configuration without comments for file generation
+            config = self._get_config_by_type(config_type)
             
             # Create directory if it doesn't exist
             output_file = Path(output_path)
             output_file.parent.mkdir(parents=True, exist_ok=True)
             
-            # Write configuration file
+            # Write configuration file as clean JSON
             with open(output_file, 'w', encoding='utf-8') as f:
-                f.write(config_content)
+                json.dump(config, f, indent=2, ensure_ascii=False)
             
             logger.info(f"Configuration file generated: {output_path}")
             logger.info(f"Configuration type: {config_type}")
@@ -699,7 +965,8 @@ class ConfigGenerator:
         config_types = [
             "minimal", "development", "secure", "full",
             "basic_http", "http_token", "https", "https_token", "mtls",
-            "https_no_protocol_middleware", "mtls_no_protocol_middleware"
+            "https_no_protocol_middleware", "mtls_no_protocol_middleware",
+            "optional_ssl", "optional_auth", "optional_proxy_reg", "custom"
         ]
         
         for config_type in config_types:
@@ -717,7 +984,8 @@ def main():
     parser.add_argument("--type", 
                        choices=["minimal", "development", "secure", "full", 
                                "basic_http", "http_token", "https", "https_token", "mtls",
-                               "https_no_protocol_middleware", "mtls_no_protocol_middleware"], 
+                               "https_no_protocol_middleware", "mtls_no_protocol_middleware",
+                               "optional_ssl", "optional_auth", "optional_proxy_reg", "custom"], 
                        default="full", help="Configuration type to generate")
     parser.add_argument("--output", default="./config.json", 
                        help="Output file path")

{mcp_proxy_adapter-6.2.25.dist-info → mcp_proxy_adapter-6.2.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.2.25
+Version: 6.2.27
 Summary: Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration
 Home-page: https://github.com/maverikod/mcp-proxy-adapter
 Author: Vasiliy Zdanovskiy

{mcp_proxy_adapter-6.2.25.dist-info → mcp_proxy_adapter-6.2.27.dist-info}/RECORD

@@ -1,6 +1,6 @@
 mcp_proxy_adapter/__init__.py,sha256=B7m1YWyv_Wb87-Q-JqVpHQgwajnfIgDyZ_iIxzdTbBY,1021
 mcp_proxy_adapter/__main__.py,sha256=-Wp1myP9DzJNB9j97mj62C8kFk5YUbCmd0e7Rnwte0A,769
-mcp_proxy_adapter/config.py,sha256=MgomeGL3XBO0tYOA6VIIP1hizUuTYpF9Bs2tp3cesMY,13333
+mcp_proxy_adapter/config.py,sha256=ss6A-7Ef1I7iyZ-h-bzGWGwddB47642wEhN7uwnt5bk,21563
 mcp_proxy_adapter/custom_openapi.py,sha256=jYUrCy8C1mShh3sjKj-JkzSMLAvxDLTvtzSJFj5HUNg,15023
 mcp_proxy_adapter/main.py,sha256=9qt_pEQdq8roUc73CumfDn6jDWP_NyfdE1lCGEynv5I,2841
 mcp_proxy_adapter/openapi.py,sha256=36vOEbJjGnVZR6hUhl6mHCD29HYOEFKo2bL0JdGSm-4,13952
@@ -88,7 +88,7 @@ mcp_proxy_adapter/examples/demo_client.py,sha256=inic-FP5qG8oQXUaCrtEhmhac_PDZ1p
 mcp_proxy_adapter/examples/generate_all_certificates.py,sha256=rgcwqIkQ1eDfEIRFRXGIOz-jOSS1w0GPBRhYvMl6Vjc,16948
 mcp_proxy_adapter/examples/generate_certificates.py,sha256=A34OHUEiFvINOHrm3_JiDSbp-WG-eQXIvKCsE8JAeXQ,6616
 mcp_proxy_adapter/examples/generate_certificates_and_tokens.py,sha256=J0qHm_BMY8RYqfuwf7V7xKsHcsRJx8E7x-8JxmW5sPw,15988
-mcp_proxy_adapter/examples/generate_test_configs.py,sha256=NLhPrA9AfPlQ0WCbOJ1B_V9OC445tanKTmq7aAWKULU,13672
+mcp_proxy_adapter/examples/generate_test_configs.py,sha256=OQjLJ0x1YrvYAFR1agu_Tl314KI_Mhjmo4o64H00wVw,14132
 mcp_proxy_adapter/examples/proxy_registration_example.py,sha256=g59_QG2D1CCqhIXEvgy2XmgXI3toLmLyH7hL3uHZwC8,12647
 mcp_proxy_adapter/examples/run_example.py,sha256=o8rcy9Xo0UuZG4MpKdex3pFWYdtAi6uW8dEBQE6Yzbw,2539
 mcp_proxy_adapter/examples/run_full_test_suite.py,sha256=7Z6qDOvbndGPue1P9v-GcYZxy_XPqoC9voJ7tR8eKQ8,12428
@@ -131,10 +131,10 @@ mcp_proxy_adapter/examples/full_application/hooks/builtin_command_hooks.py,sha25
 mcp_proxy_adapter/examples/scripts/config_generator.py,sha256=4qruYxQ2kGLVOukLX2JOW5kslJ06RhkNqTobAgh4rfw,32801
 mcp_proxy_adapter/examples/scripts/create_certificates_simple.py,sha256=xkIvUYl6hbKlWImQmenG0k_CvIsOsc9ZHICiKY3rtI8,26380
 mcp_proxy_adapter/examples/scripts/generate_certificates_and_tokens.py,sha256=J0qHm_BMY8RYqfuwf7V7xKsHcsRJx8E7x-8JxmW5sPw,15988
-mcp_proxy_adapter/utils/config_generator.py,sha256=4qruYxQ2kGLVOukLX2JOW5kslJ06RhkNqTobAgh4rfw,32801
-mcp_proxy_adapter-6.2.25.dist-info/licenses/LICENSE,sha256=6KdtUcTwmTRbJrAmYjVn7e6S-V42ubeDJ-AiVEzZ510,1075
-mcp_proxy_adapter-6.2.25.dist-info/METADATA,sha256=cteiRynMPhEN2ErSDc0FtqAAZ_n0XgMwdLcvanfwnyQ,22348
-mcp_proxy_adapter-6.2.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.2.25.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
-mcp_proxy_adapter-6.2.25.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
-mcp_proxy_adapter-6.2.25.dist-info/RECORD,,
+mcp_proxy_adapter/utils/config_generator.py,sha256=2dxwBh9k_nUw9kgytZso5TNOQpBqd3c-RpKSTLoHlLE,46465
+mcp_proxy_adapter-6.2.27.dist-info/licenses/LICENSE,sha256=6KdtUcTwmTRbJrAmYjVn7e6S-V42ubeDJ-AiVEzZ510,1075
+mcp_proxy_adapter-6.2.27.dist-info/METADATA,sha256=IrXoUBV-RR8hYdbUxWaeLPgacoo_c_8xoi0z_XJMzog,22348
+mcp_proxy_adapter-6.2.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.2.27.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
+mcp_proxy_adapter-6.2.27.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-6.2.27.dist-info/RECORD,,