mcp-proxy-adapter 6.3.30__py3-none-any.whl → 6.4.1__py3-none-any.whl

mcp_proxy_adapter/api/middleware/unified_security.py

@@ -64,15 +64,25 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
         # Create security integration
         try:
             security_config = config.get("security", {})
-            self.security_integration = create_security_integration(security_config)
-            # Use framework's FastAPI middleware
-            self.framework_middleware = (
-                self.security_integration.security_manager.create_fastapi_middleware()
-            )
-            logger.info("Using mcp_security_framework FastAPI middleware")
-            # IMPORTANT: Don't replace self.app! This breaks the middleware chain.
-            # Instead, store the framework middleware for use in dispatch method.
-            logger.info("Framework middleware will be used in dispatch method")
+            
+            # Check if permissions are enabled - only use mcp_security_framework if needed
+            permissions_config = security_config.get("permissions", {})
+            permissions_enabled = permissions_config.get("enabled", False)
+            
+            if permissions_enabled:
+                self.security_integration = create_security_integration(security_config)
+                # Use framework's FastAPI middleware
+                self.framework_middleware = (
+                    self.security_integration.security_manager.create_fastapi_middleware()
+                )
+                logger.info("Using mcp_security_framework FastAPI middleware")
+                # IMPORTANT: Don't replace self.app! This breaks the middleware chain.
+                # Instead, store the framework middleware for use in dispatch method.
+                logger.info("Framework middleware will be used in dispatch method")
+            else:
+                logger.info("Permissions disabled, skipping mcp_security_framework integration")
+                self.security_integration = None
+                self.framework_middleware = None
         except Exception as e:
             logger.error(f"Security framework integration failed: {e}")
             # Instead of raising error, log warning and continue without security

mcp_proxy_adapter/api/middleware/user_info_middleware.py

@@ -53,69 +53,68 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
             try:
                 # Get API keys configuration
                 security_config = config.get("security", {})
-                auth_config = security_config.get("auth", {})
-                permissions_config = security_config.get("permissions", {})
-
-                # Check if permissions are enabled
-                permissions_enabled = permissions_config.get("enabled", False)
-
-                # Create AuthConfig for mcp_security_framework
-                mcp_auth_config = AuthConfig(
-                    enabled=True,
-                    methods=["api_key"],
-                    api_keys=auth_config.get("api_keys", {}),
-                )
-
-                # Initialize PermissionManager only if permissions are enabled
-                if permissions_enabled:
-                    # Create PermissionConfig for mcp_security_framework
-                    roles_file = permissions_config.get("roles_file")
-                    if roles_file is None:
-                        logger.warning("⚠️ Permissions enabled but no roles_file specified, using default configuration")
-                        roles_file = None
-                    
-                    mcp_permission_config = PermissionConfig(
-                        roles_file=roles_file,
-                        default_role=permissions_config.get("default_role", "guest"),
-                        admin_role=permissions_config.get("admin_role", "admin"),
-                        role_hierarchy=permissions_config.get("role_hierarchy", {}),
-                        permission_cache_enabled=permissions_config.get(
-                            "permission_cache_enabled", True
-                        ),
-                        permission_cache_ttl=permissions_config.get(
-                            "permission_cache_ttl", 300
-                        ),
-                        wildcard_permissions=permissions_config.get(
-                            "wildcard_permissions", False
-                        ),
-                        strict_mode=permissions_config.get("strict_mode", True),
-                        roles=permissions_config.get("roles", {}),
-                    )
-
-                    # Initialize PermissionManager first
-                    self.permission_manager = PermissionManager(mcp_permission_config)
+                
+                # Check if security is enabled
+                security_enabled = security_config.get("enabled", False)
+                if not security_enabled:
+                    logger.info("ℹ️ Security disabled in configuration, using basic auth")
+                    self._security_available = False
                 else:
-                    # Create a minimal PermissionManager when permissions are disabled
-                    mcp_permission_config = PermissionConfig(
-                        roles_file=None,
-                        default_role="guest",
-                        admin_role="admin",
-                        role_hierarchy={},
-                        permission_cache_enabled=False,
-                        permission_cache_ttl=300,
-                        wildcard_permissions=False,
-                        strict_mode=False,
-                        roles={},
-                    )
-                    self.permission_manager = PermissionManager(mcp_permission_config)
-
-                # Initialize AuthManager with permission_manager
-                self.auth_manager = AuthManager(
-                    mcp_auth_config, self.permission_manager
-                )
-                logger.info(
-                    "✅ User info middleware initialized with " "mcp_security_framework"
-                )
+                    auth_config = security_config.get("auth", {})
+                    permissions_config = security_config.get("permissions", {})
+
+                    # Check if permissions are enabled
+                    permissions_enabled = permissions_config.get("enabled", False)
+
+                    # Only use mcp_security_framework if permissions are enabled
+                    if permissions_enabled:
+                        # Create AuthConfig for mcp_security_framework
+                        mcp_auth_config = AuthConfig(
+                            enabled=True,
+                            methods=["api_key"],
+                            api_keys=auth_config.get("api_keys", {}),
+                        )
+
+                        # Create PermissionConfig for mcp_security_framework
+                        roles_file = permissions_config.get("roles_file")
+                        if roles_file is None:
+                            logger.warning("⚠️ Permissions enabled but no roles_file specified, using default configuration")
+                            roles_file = None
+                        
+                        mcp_permission_config = PermissionConfig(
+                            roles_file=roles_file,
+                            default_role=permissions_config.get("default_role", "guest"),
+                            admin_role=permissions_config.get("admin_role", "admin"),
+                            role_hierarchy=permissions_config.get("role_hierarchy", {}),
+                            permission_cache_enabled=permissions_config.get(
+                                "permission_cache_enabled", True
+                            ),
+                            permission_cache_ttl=permissions_config.get(
+                                "permission_cache_ttl", 300
+                            ),
+                            wildcard_permissions=permissions_config.get(
+                                "wildcard_permissions", False
+                            ),
+                            strict_mode=permissions_config.get("strict_mode", True),
+                            roles=permissions_config.get("roles", {}),
+                        )
+
+                        # Initialize PermissionManager first
+                        self.permission_manager = PermissionManager(mcp_permission_config)
+
+                        # Initialize AuthManager with permission_manager
+                        self.auth_manager = AuthManager(
+                            mcp_auth_config, self.permission_manager
+                        )
+                        logger.info(
+                            "✅ User info middleware initialized with " "mcp_security_framework"
+                        )
+                    else:
+                        # When permissions are disabled, use basic auth without mcp_security_framework
+                        logger.info("ℹ️ Permissions disabled, using basic token auth without mcp_security_framework")
+                        self._security_available = False
+                        # Initialize api_keys for basic auth
+                        self.api_keys = auth_config.get("api_keys", {})
             except Exception as e:
                 logger.warning(f"⚠️ Failed to initialize AuthManager: {e}")
                 self._security_available = False

mcp_proxy_adapter/commands/dependency_manager.py

@@ -3,15 +3,26 @@ Dependency management system for remote plugins.
 
 This module handles automatic installation and verification of plugin dependencies
 using pip and other package management tools.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
 """
 
 import subprocess
 import sys
 import importlib
-import pkg_resources
-from typing import List, Dict, Any, Optional, Tuple
+from typing import List, Dict, Any, Tuple
 from pathlib import Path
 
+try:  # Python 3.8+
+    from importlib import metadata as importlib_metadata  # type: ignore
+except Exception:  # pragma: no cover - very old Python fallback
+    import importlib_metadata  # type: ignore
+
+from packaging.requirements import Requirement
+from packaging.specifiers import SpecifierSet
+from packaging.version import Version, InvalidVersion
+
 from mcp_proxy_adapter.core.logging import logger
 
 
@@ -28,9 +39,15 @@ class DependencyManager:
     def _load_installed_packages(self) -> None:
         """Load list of currently installed packages."""
         try:
-            installed = pkg_resources.working_set
-            for dist in installed:
-                self._installed_packages[dist.project_name.lower()] = dist.version
+            self._installed_packages.clear()
+            for dist in importlib_metadata.distributions():
+                try:
+                    name = dist.metadata.get("Name") or dist.metadata.get("name")
+                    version = dist.version
+                    if name and version:
+                        self._installed_packages[name.lower()] = version
+                except Exception:
+                    continue
         except Exception as e:
             logger.warning(f"Failed to load installed packages: {e}")
 
@@ -71,32 +88,32 @@ class DependencyManager:
         Returns:
             True if dependency is satisfied, False otherwise
         """
-        # Try to import the module
+        # Parse requirement (handles version specifiers)
         try:
-            importlib.import_module(dependency)
-            return True
-        except ImportError:
-            pass
+            req = Requirement(dependency)
+        except Exception:
+            # Fallback: treat as importable module name
+            try:
+                importlib.import_module(dependency)
+                return True
+            except ImportError:
+                return False
 
-        # Check if it's installed as a package
+        # Check installation by distribution name
         try:
-            pkg_resources.require(dependency)
-            return True
-        except (pkg_resources.DistributionNotFound, pkg_resources.VersionConflict):
-            pass
+            installed_version = importlib_metadata.version(req.name)
+        except importlib_metadata.PackageNotFoundError:
+            return False
 
-        # Check installed packages cache
-        dep_name = (
-            dependency.split("==")[0]
-            .split(">=")[0]
-            .split("<=")[0]
-            .split("!=")[0]
-            .split("~=")[0]
-        )
-        if dep_name.lower() in self._installed_packages:
+        # If no specifier, any installed version satisfies
+        if not req.specifier:
             return True
 
-        return False
+        try:
+            return Version(installed_version) in req.specifier
+        except InvalidVersion:
+            # If version parsing fails, fallback to string comparison via specifier
+            return req.specifier.contains(installed_version, prereleases=True)
 
     def install_dependencies(
         self, dependencies: List[str], user_install: bool = False
@@ -216,7 +233,7 @@ class DependencyManager:
         Returns:
             Dictionary with dependency information
         """
-        info = {
+        info: Dict[str, Any] = {
             "name": dependency,
             "installed": False,
             "version": None,
@@ -225,10 +242,10 @@ class DependencyManager:
 
         # Check if it's installed
         try:
-            dist = pkg_resources.get_distribution(dependency)
+            version = importlib_metadata.version(dependency)
             info["installed"] = True
-            info["version"] = dist.version
-        except pkg_resources.DistributionNotFound:
+            info["version"] = version
+        except importlib_metadata.PackageNotFoundError:
             pass
 
         # Check if it's importable

mcp_proxy_adapter/examples/basic_framework/roles.json

@@ -0,0 +1,21 @@
+{
+    "roles": {
+        "admin": {
+            "permissions": ["*"],
+            "description": "Administrator with full access"
+        },
+        "user": {
+            "permissions": ["read", "write"],
+            "description": "Regular user with read/write access"
+        },
+        "readonly": {
+            "permissions": ["read"],
+            "description": "Read-only user"
+        }
+    },
+    "user_roles": {
+        "admin": "admin",
+        "user": "user",
+        "readonly": "readonly"
+    }
+}

mcp_proxy_adapter/examples/full_application/roles.json

@@ -0,0 +1,21 @@
+{
+    "roles": {
+        "admin": {
+            "permissions": ["*"],
+            "description": "Administrator with full access"
+        },
+        "user": {
+            "permissions": ["read", "write"],
+            "description": "Regular user with read/write access"
+        },
+        "readonly": {
+            "permissions": ["read"],
+            "description": "Read-only user"
+        }
+    },
+    "user_roles": {
+        "admin": "admin",
+        "user": "user",
+        "readonly": "readonly"
+    }
+}

mcp_proxy_adapter/examples/generate_comprehensive_config.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+Script for generating comprehensive HTTP configuration for MCP Proxy Adapter.
+Generates single comprehensive configuration with all features enabled.
+"""
+import json
+import os
+import argparse
+import uuid
+from typing import Dict, Any
+
+
+def generate_comprehensive_http_config(
+    port: int = 20001,
+    roles_file: str = "configs/roles.json",
+) -> Dict[str, Any]:
+    """Generate comprehensive HTTP configuration with all features."""
+    return {
+        "uuid": str(uuid.uuid4()),
+        "server": {
+            "host": "127.0.0.1",
+            "port": port,
+            "debug": False,
+            "log_level": "INFO",
+            "workers": 1,
+            "reload": False
+        },
+        "ssl": {
+            "enabled": False
+        },
+        "security": {
+            "enabled": True,
+            "auth": {
+                "enabled": True,
+                "methods": [
+                    "api_key"
+                ],
+                "api_keys": {
+                    "admin-token-123": "admin",
+                    "user-token-456": "user",
+                    "readonly-token-789": "readonly",
+                    "guest-token-abc": "guest",
+                    "proxy-token-def": "proxy"
+                }
+            },
+            "permissions": {
+                "enabled": True,
+                "roles_file": roles_file
+            }
+        },
+        "registration": {
+            "enabled": True,
+            "url": "http://127.0.0.1:3004/proxy",
+            "name": "comprehensive_http_adapter",
+            "capabilities": [
+                "http",
+                "token_auth",
+                "roles",
+                "registration",
+                "heartbeat"
+            ],
+            "retry_count": 3,
+            "retry_delay": 5,
+            "heartbeat": {
+                "enabled": True,
+                "interval": 30
+            }
+        },
+        "protocols": {
+            "enabled": True,
+            "allowed_protocols": [
+                "http"
+            ]
+        }
+    }
+
+
+def generate_roles_config() -> Dict[str, Any]:
+    """Generate comprehensive roles configuration."""
+    return {
+        "admin": {
+            "description": "Full administrative access",
+            "permissions": [
+                "read",
+                "write",
+                "execute",
+                "delete",
+                "admin"
+            ],
+            "inherits": []
+        },
+        "user": {
+            "description": "Standard user access",
+            "permissions": [
+                "read",
+                "write",
+                "execute"
+            ],
+            "inherits": []
+        },
+        "readonly": {
+            "description": "Read-only access",
+            "permissions": [
+                "read"
+            ],
+            "inherits": []
+        },
+        "guest": {
+            "description": "Limited guest access",
+            "permissions": [
+                "read"
+            ],
+            "inherits": []
+        },
+        "proxy": {
+            "description": "Proxy registration access",
+            "permissions": [
+                "read",
+                "register",
+                "heartbeat"
+            ],
+            "inherits": []
+        }
+    }
+
+
+def main():
+    """Generate comprehensive configuration."""
+    parser = argparse.ArgumentParser(description="Generate comprehensive HTTP configuration")
+    parser.add_argument(
+        "--output-dir",
+        default="configs",
+        help="Output directory for configuration files"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=20001,
+        help="Server port"
+    )
+    
+    args = parser.parse_args()
+    
+    # Create output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+    
+    # Generate comprehensive HTTP configuration
+    config = generate_comprehensive_http_config(port=args.port)
+    config_file = os.path.join(args.output_dir, "comprehensive_http.json")
+    
+    with open(config_file, 'w') as f:
+        json.dump(config, f, indent=2)
+    
+    print(f"Generated: {config_file}")
+    
+    # Generate roles configuration
+    roles = generate_roles_config()
+    roles_file = os.path.join(args.output_dir, "roles.json")
+    
+    with open(roles_file, 'w') as f:
+        json.dump(roles, f, indent=2)
+    
+    print(f"Generated: {roles_file}")
+    
+    print(f"\nGenerated comprehensive configuration in {args.output_dir}/")
+    print("Configuration includes:")
+    print("- HTTP server with token authentication")
+    print("- Role-based permissions")
+    print("- Proxy registration")
+    print("- Heartbeat monitoring")
+    print("- 5 predefined tokens with roles")
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/generate_test_configs.py

@@ -8,6 +8,7 @@ Generates 6 different configuration types for testing various security scenarios
 import json
 import os
 import argparse
+import uuid
 from typing import Dict, Any
 
 
@@ -16,6 +17,7 @@ def generate_http_simple_config(
 ) -> Dict[str, Any]:
     """Generate HTTP configuration without authorization."""
     return {
+        "uuid": str(uuid.uuid4()),
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {"enabled": False},
         "security": {"enabled": False},
@@ -47,6 +49,7 @@ def generate_http_token_config(
 ) -> Dict[str, Any]:
     """Generate HTTP configuration with token authorization."""
     return {
+        "uuid": str(uuid.uuid4()),
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {"enabled": False},
         "security": {
@@ -83,6 +86,7 @@ def generate_https_simple_config(
 ) -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification and authorization."""
     return {
+        "uuid": str(uuid.uuid4()),
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
@@ -108,6 +112,7 @@ def generate_https_token_config(
 ) -> Dict[str, Any]:
     """Generate HTTPS configuration without client certificate verification with token authorization."""
     return {
+        "uuid": str(uuid.uuid4()),
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
@@ -147,12 +152,15 @@ def generate_mtls_no_roles_config(
 ) -> Dict[str, Any]:
     """Generate mTLS configuration without roles."""
     return {
+        "uuid": str(uuid.uuid4()),
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
             "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",
+            "client_cert_file": f"{certs_dir}/admin_cert.pem",
+            "client_key_file": f"{certs_dir}/admin_key.pem",
             "verify_client": True,
             "client_cert_required": True,
         },
@@ -174,12 +182,15 @@ def generate_mtls_with_roles_config(
 ) -> Dict[str, Any]:
     """Generate mTLS configuration with roles."""
     return {
+        "uuid": str(uuid.uuid4()),
         "server": {"host": "127.0.0.1", "port": port},
         "ssl": {
             "enabled": True,
             "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",
+            "client_cert_file": f"{certs_dir}/admin_cert.pem",
+            "client_key_file": f"{certs_dir}/admin_key.pem",
             "verify_client": True,
         },
         "registration": {

mcp_proxy_adapter/examples/setup_test_environment.py

@@ -618,135 +618,66 @@ def generate_enhanced_configurations(output_dir: Path) -> None:
 
     validator = ConfigurationValidator()
 
-    # Configuration templates with proper protocol settings
+    # Single comprehensive HTTP configuration with all features
     configs = {
-        "development_http.json": {
-            "server": {"host": "0.0.0.0", "port": 8000},
-            "protocols": {"enabled": False},
-            "security": {"ssl": {"enabled": False}},
-            "logging": {"level": "DEBUG"},
-        },
-        "production_https.json": {
-            "uuid": "550e8400-e29b-41d4-a716-446655440001",
-            "server": {"host": "0.0.0.0", "port": 8443},
-            "protocols": {"enabled": True, "allowed_protocols": ["https"]},
-            "ssl": {
-                "enabled": True,
-                "cert_file": "mcp_proxy_adapter/examples/basic_framework/certs/server_cert.pem",
-                "key_file": "mcp_proxy_adapter/examples/basic_framework/certs/server_key.pem",
-                "ca_cert_file": "mcp_proxy_adapter/examples/basic_framework/certs/ca_cert.pem",
-                "verify_client": False,
-                "min_tls_version": "TLSv1.2",
-            },
-            "logging": {"level": "INFO"},
-        },
-        "mtls_with_roles.json": {
+        "comprehensive_http.json": {
             "uuid": "550e8400-e29b-41d4-a716-446655440000",
-            "server": {"host": "0.0.0.0", "port": 8443},
-            "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]},
+            "server": {
+                "host": "127.0.0.1",
+                "port": 20001,
+                "debug": False,
+                "log_level": "INFO",
+                "workers": 1,
+                "reload": False
+            },
             "ssl": {
-                "enabled": True,
-                "cert_file": "mcp_proxy_adapter/examples/basic_framework/certs/server_cert.pem",
-                "key_file": "mcp_proxy_adapter/examples/basic_framework/certs/server_key.pem",
-                "ca_cert_file": "mcp_proxy_adapter/examples/basic_framework/certs/ca_cert.pem",
-                "verify_client": True,
-                "min_tls_version": "TLSv1.2",
+                "enabled": False
             },
             "security": {
+                "enabled": True,
                 "auth": {
                     "enabled": True,
-                    "token_required": False,
-                    "token_secret": "your-secret-key",
+                    "methods": [
+                        "api_key"
+                    ],
+                    "api_keys": {
+                        "admin-token-123": "admin",
+                        "user-token-456": "user",
+                        "readonly-token-789": "readonly",
+                        "guest-token-abc": "guest",
+                        "proxy-token-def": "proxy"
+                    }
                 },
-            },
-            "logging": {"level": "INFO"},
-        },
-        "mtls_no_roles.json": {
-            "server": {"host": "0.0.0.0", "port": 8443},
-            "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]},
-            "security": {
-                "ssl": {
+                "permissions": {
                     "enabled": True,
-                    "server_cert_file": "certs/server_cert.pem",
-                    "server_key_file": "keys/server_key.pem",
-                    "ca_cert_file": "certs/ca_cert.pem",
-                    "client_cert_file": "certs/client_cert.pem",
-                    "client_key_file": "keys/client_key.pem",
-                    "verify_server": True,
-                    "verify_client": True,
-                    "min_tls_version": "TLSv1.2",
+                    "roles_file": "configs/roles.json"
                 }
             },
-            "logging": {"level": "INFO"},
-        },
-        "https_simple.json": {
-            "uuid": "550e8400-e29b-41d4-a716-446655440002",
-            "server": {"host": "0.0.0.0", "port": 8443},
-            "protocols": {"enabled": True, "allowed_protocols": ["https"]},
-            "ssl": {
+            "registration": {
                 "enabled": True,
-                "cert_file": "mcp_proxy_adapter/examples/basic_framework/certs/server_cert.pem",
-                "key_file": "mcp_proxy_adapter/examples/basic_framework/certs/server_key.pem",
-                "verify_client": False,
-                "min_tls_version": "TLSv1.2",
-            },
-            "logging": {"level": "INFO"},
-        },
-        "https_with_auth.json": {
-            "server": {"host": "0.0.0.0", "port": 8443},
-            "protocols": {"enabled": True, "allowed_protocols": ["https"]},
-            "security": {
-                "ssl": {
-                    "enabled": True,
-                    "server_cert_file": "certs/server_cert.pem",
-                    "server_key_file": "keys/server_key.pem",
-                    "verify_server": True,
-                    "ca_cert_file": "certs/ca_cert.pem",
-                    "verify_client": False,
-                    "min_tls_version": "TLSv1.2",
-                },
-                "auth": {
-                    "enabled": True,
-                    "token_required": True,
-                    "token_secret": "your-secret-key",
-                },
-            },
-            "logging": {"level": "INFO"},
-        },
-        "test_proxy_registration.json": {
-            "server": {"host": "127.0.0.1", "port": 8010},
-            "protocols": {"enabled": True, "allowed_protocols": ["https", "mtls"]},
-            "security": {
-                "ssl": {
+                "url": "http://127.0.0.1:3004/proxy",
+                "name": "comprehensive_http_adapter",
+                "capabilities": [
+                    "http",
+                    "token_auth",
+                    "roles",
+                    "registration",
+                    "heartbeat"
+                ],
+                "retry_count": 3,
+                "retry_delay": 5,
+                "heartbeat": {
                     "enabled": True,
-                    "server_cert_file": "certs/mtls/server/embedding-service.pem",
-                    "server_key_file": "certs/mtls/server/embedding-service.key",
-                    "ca_cert_file": "certs/mtls/truststore.pem",
-                    "client_cert_file": "certs/mtls/client/embedding-service.pem",
-                    "client_key_file": "certs/mtls/client/embedding-service.key",
-                    "verify_server": True,
-                    "verify_client": True,
-                    "min_tls_version": "TLSv1.2",
+                    "interval": 30
                 }
             },
-            "registration": {
+            "protocols": {
                 "enabled": True,
-                "proxy_url": "https://127.0.0.1:3004",
-                "server_id": "test-proxy-registration",
-                "server_name": "Test Proxy Registration Service",
-                "description": "Test service for proxy registration SSL fix",
-                "auth_method": "certificate",
-                "certificate": {
-                    "cert_file": "certs/mtls/client/embedding-service.pem",
-                    "key_file": "certs/mtls/client/embedding-service.key",
-                },
-                "ssl": {
-                    "verify_mode": "CERT_REQUIRED",
-                    "ca_cert": "mtls_certificates/truststore.pem",
-                },
-            },
-            "logging": {"level": "DEBUG"},
-        },
+                "allowed_protocols": [
+                    "http"
+                ]
+            }
+        }
     }
 
     # Generate and validate configurations
@@ -777,41 +708,81 @@ def generate_enhanced_configurations(output_dir: Path) -> None:
     index_path = configs_dir / "README.md"
     with open(index_path, "w", encoding="utf-8") as f:
         f.write(
-            """# Configuration Files
+            """# Comprehensive HTTP Configuration
+
+This directory contains a single comprehensive HTTP configuration with all features enabled.
+
+## Available Configuration
 
-This directory contains pre-configured examples for different deployment scenarios.
+### Comprehensive HTTP
+- `comprehensive_http.json` - Complete HTTP server with all features
 
-## Available Configurations
+## Features
 
-### Development
-- `development_http.json` - HTTP development server (no SSL)
+### Security
+- **Token Authentication**: API key-based access control with 5 predefined tokens
+- **Role-based Permissions**: Granular access control with 5 roles
+- **Roles**: admin, user, readonly, guest, proxy
 
-### Production HTTPS
-- `production_https.json` - HTTPS with server certificate verification
-- `https_simple.json` - HTTPS without certificate verification
-- `https_with_auth.json` - HTTPS with token authentication
+### Authentication Tokens
+- `admin-token-123` → admin role (full access)
+- `user-token-456` → user role (read, write, execute)
+- `readonly-token-789` → readonly role (read only)
+- `guest-token-abc` → guest role (limited access)
+- `proxy-token-def` → proxy role (registration, heartbeat)
 
-### mTLS (Mutual TLS)
-- `mtls_with_roles.json` - mTLS with role-based authentication
-- `mtls_no_roles.json` - mTLS without roles
+### Registration & Monitoring
+- **Proxy Registration**: Automatic service discovery
+- **Heartbeat**: 30-second health monitoring
+- **Retry Logic**: 3 attempts with 5-second delay
+
+### Protocols
+- **HTTP**: Standard web protocol (port 20001)
 
 ## Usage
 
-Start the server with a specific configuration:
+### Starting the Server
+```bash
+# Start comprehensive HTTP server
+python -m mcp_proxy_adapter --config configs/comprehensive_http.json
+```
 
+### Testing Authentication
 ```bash
-python -m mcp_proxy_adapter --config configs/production_https.json
+# Test with admin token
+curl -H "Authorization: Bearer admin-token-123" http://localhost:20001/health
+
+# Test with user token
+curl -H "Authorization: Bearer user-token-456" http://localhost:20001/health
+
+# Test with readonly token
+curl -H "Authorization: Bearer readonly-token-789" http://localhost:20001/health
 ```
 
-## Validation
+## Configuration Details
 
-All configurations are validated for:
-- Mutually exclusive settings
-- Required dependencies
-- Protocol compatibility
-- Security best practices
+- **Server**: 127.0.0.1:20001
+- **SSL**: Disabled (HTTP only)
+- **Authentication**: Token-based with roles
+- **Registration**: Enabled with proxy server
+- **Heartbeat**: 30-second interval
+- **Protocols**: HTTP only
+
+## Customization
+
+Edit `comprehensive_http.json` to:
+- Change server host/port
+- Add/modify authentication tokens
+- Update role permissions
+- Modify registration settings
+- Adjust heartbeat interval
+
+## Troubleshooting
 
-See `docs/CONFIGURATION_GUIDE.md` for detailed documentation.
+1. **Port Conflicts**: Ensure port 20001 is not in use
+2. **Token Issues**: Verify token format and role mapping
+3. **Registration Issues**: Check proxy server availability
+4. **Permission Errors**: Verify roles.json file exists
 """
         )
 

mcp_proxy_adapter/version.py

@@ -2,4 +2,4 @@
 Version information for MCP Proxy Adapter.
 """
 
-__version__ = "6.3.30"
+__version__ = "6.3.31"

{mcp_proxy_adapter-6.3.30.dist-info → mcp_proxy_adapter-6.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.3.30
+Version: 6.4.1
 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.3.30.dist-info → mcp_proxy_adapter-6.4.1.dist-info}/RECORD

@@ -4,7 +4,7 @@ mcp_proxy_adapter/config.py,sha256=-7iVS0mUWWKNeao7nqTAFlUD6FcMwRlDkchN7OwYsr0,2
 mcp_proxy_adapter/custom_openapi.py,sha256=yLle4CntYK9wpivgn9NflZyJhy-YNrmWjJzt0ai5nP0,14672
 mcp_proxy_adapter/main.py,sha256=idp3KUR7CT7kTXLVPvvclJlNnt8d_HYl8_jY98uknmo,4677
 mcp_proxy_adapter/openapi.py,sha256=2UZOI09ZDRJuBYBjKbMyb2U4uASszoCMD5o_4ktRpvg,13480
-mcp_proxy_adapter/version.py,sha256=P9yxGAMLjCfxwoZms2TyoWvVR_JhmPQJrS3y9M1gBlw,75
+mcp_proxy_adapter/version.py,sha256=P9qw3X3vfbgoqSgoCae8MiE-WtXOwkrl5G370CizL5E,75
 mcp_proxy_adapter/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_proxy_adapter/api/app.py,sha256=dIsAWbQFWMa8zxhPro9hxUnUuqnLWlqutWAKrqJIHGE,33386
 mcp_proxy_adapter/api/handlers.py,sha256=iyFGoEuUS1wxbV1ELA0zmaxIyQR7j4zw-4MrD-uIO6E,8294
@@ -20,8 +20,8 @@ mcp_proxy_adapter/api/middleware/logging.py,sha256=iME87hrbvyTjI-RJro5Cwao7VlHUI
 mcp_proxy_adapter/api/middleware/performance.py,sha256=-EvA7YIcTlxn8RuxlWlScJvX2EIoeEp3P5dKVWZHYRY,2357
 mcp_proxy_adapter/api/middleware/protocol_middleware.py,sha256=YiwgeWXaFjj-TvTpAyqOMu1Rql4UENmX6pAJ8vEb9T8,15449
 mcp_proxy_adapter/api/middleware/transport_middleware.py,sha256=VG1rWyuh-O2pdc0kQ3SADFvyh286o5Wrnkt8OFQ0WQw,4274
-mcp_proxy_adapter/api/middleware/unified_security.py,sha256=PMbJxVzGNlb-IPAqvIeEo1st-jykYX9Mns6lXIfdtAE,7764
-mcp_proxy_adapter/api/middleware/user_info_middleware.py,sha256=94oItW3uyNhLvp6p1Sl7EhY_gC4MqrbR9KyAJWreTwk,10326
+mcp_proxy_adapter/api/middleware/unified_security.py,sha256=qjNPOCusMimXjEtjwyG6CgFieLm2T7O2e2QghqE_s3M,8313
+mcp_proxy_adapter/api/middleware/user_info_middleware.py,sha256=sUHHyy33xvZKRDtOWfzbndrIxDYLUFeVYfUbPIKawR8,10652
 mcp_proxy_adapter/commands/__init__.py,sha256=eStfu2UrLfMvMTY6x20GD8sMPmPB1so-0QZQYV53nqo,1565
 mcp_proxy_adapter/commands/auth_validation_command.py,sha256=p4UrAaHyoCxMy98G1BUUlFJWjoelEJzX3OAWIiQaGls,14593
 mcp_proxy_adapter/commands/base.py,sha256=0_hu8t89-2vWBPFpEMokr27A-IifKI32rkQwZfc2Grk,15162
@@ -32,7 +32,7 @@ mcp_proxy_adapter/commands/certificate_management_command.py,sha256=TDoGV2mnEz1H
 mcp_proxy_adapter/commands/command_registry.py,sha256=RFGZw-0A29P6ZQMZ2qi5wQe3K89hCNOqRTdhtYYDGDg,36498
 mcp_proxy_adapter/commands/config_command.py,sha256=PWX1OhKAmjlc8CSy4-sImdvGeSNgDNyv30Y-P5iZp9g,3767
 mcp_proxy_adapter/commands/dependency_container.py,sha256=mvPob62lQ-mKRbAA9aL3L5gOT9_4V2Vy2cGoup2S840,3239
-mcp_proxy_adapter/commands/dependency_manager.py,sha256=JWdmQ0de6rQAv8GYDToFIlpomBBXqT61XMygWcggYSQ,7366
+mcp_proxy_adapter/commands/dependency_manager.py,sha256=lXgtrhCiQhy9Y-QpU_RWRg2d0VYy5msoNQPUjPOcOc8,8245
 mcp_proxy_adapter/commands/echo_command.py,sha256=7E4DGGYULt6XN7NOTHwpmM9rMJgJ-ykMTqImOXY8160,2378
 mcp_proxy_adapter/commands/health_command.py,sha256=Li0snwkFHdeYdYy4Nrrt_OpLU9cZedfoNatndT_yLUo,4543
 mcp_proxy_adapter/commands/help_command.py,sha256=y6-li7XLAS_W4forLO-8r4QsnKVqzB2OmQzNKcMZ1f8,14224
@@ -89,7 +89,8 @@ mcp_proxy_adapter/examples/demo_client.py,sha256=en2Rtb70B1sQmhL-vdQ4PDpKNNl_mfl
 mcp_proxy_adapter/examples/generate_all_certificates.py,sha256=lLP5RKmJwpSyprvrxQXFt_xcN4aiUzlIxk5WVdXx2Fk,19024
 mcp_proxy_adapter/examples/generate_certificates.py,sha256=VRJnT9Za2Wk_oKRT5g2SA7qcGeBSxZm9wPMOM5i50T0,6707
 mcp_proxy_adapter/examples/generate_certificates_and_tokens.py,sha256=hUCoJH3fy5WeR_YMHj-_W0mR0ZKUWqewH4FVN3yWyrM,17972
-mcp_proxy_adapter/examples/generate_test_configs.py,sha256=hzb9NBCl21Og9Tsox8nRT_uG0AhgT-t7uRyghinucc8,13853
+mcp_proxy_adapter/examples/generate_comprehensive_config.py,sha256=2UyTGIUKxw3EdCFaOMwO1vB-OZjOQV0senU44JPuyH0,4787
+mcp_proxy_adapter/examples/generate_test_configs.py,sha256=RorZOrhjtoFwtC0Y0kQK7wBA1OnvHDod9nK-C2PMgPo,14323
 mcp_proxy_adapter/examples/proxy_registration_example.py,sha256=vemRhftnjbiOBCJkmtDGqlWQ8syTG0a8755GCOnaQsg,12503
 mcp_proxy_adapter/examples/run_example.py,sha256=yp-a6HIrSk3ddQmbn0KkuKwErId0aNfj028TE6U-zmY,2626
 mcp_proxy_adapter/examples/run_full_test_suite.py,sha256=bR25OOrmWnLQccZno9cZhi_Ltk_6k8DFR2vXPCj1XQ4,12468
@@ -97,14 +98,14 @@ mcp_proxy_adapter/examples/run_proxy_server.py,sha256=SBLSSY2F_VEBQD3MsCE_Pa9xFE
 mcp_proxy_adapter/examples/run_security_tests.py,sha256=0vjaUdWC-rLyviQuNxM3PtfiU9TzSRuxGxWMehrFA_w,23311
 mcp_proxy_adapter/examples/run_security_tests_fixed.py,sha256=2BKMT0_-FhmcZA73hdQOt2XR7Cgb9Sq8qBI88BkwAAA,10934
 mcp_proxy_adapter/examples/security_test_client.py,sha256=K5gEVat1SJS2pBVxqLl5c9-uiiG12k8UT3ULQDXZ2Uc,35713
-mcp_proxy_adapter/examples/setup_test_environment.py,sha256=FiBC52GfNFzv_U2RK3GnhNLLZeo5UdUNWDaIaG5sZ68,37198
-mcp_proxy_adapter/examples/setup_test_environment_old.py,sha256=qV7IT8lMObcaPeNrFXI7CkuvJnbJsLIVaRn7fTFXjJ0,11631
+mcp_proxy_adapter/examples/setup_test_environment.py,sha256=LR4kGneHELgk4lHMfA9k1yFZ1o3KEQelqOXua5oT88Q,34540
 mcp_proxy_adapter/examples/test_config.py,sha256=ekEoUZe9q484vU_0IxOVhQdNMVJXG3IpmQpP--VmuDI,6491
 mcp_proxy_adapter/examples/test_config_generator.py,sha256=PBXk1V_awJ-iBlbE66Pme5sQwu6CJDxkmqgm8uPtM58,4091
 mcp_proxy_adapter/examples/test_examples.py,sha256=CYlVatdHUVC_rwv4NsvxFG3GXiKIyxPDUH43BOJHjrU,12330
 mcp_proxy_adapter/examples/universal_client.py,sha256=n1-cBPOiCipA86Zcc_mI_jMywDMZS1p3u5JT3AqTsrQ,27577
 mcp_proxy_adapter/examples/basic_framework/__init__.py,sha256=4aYD--R6hy9n9CUxj7Osb9HcdVUMJ6_cfpu4ujkbCwI,345
 mcp_proxy_adapter/examples/basic_framework/main.py,sha256=AkGUXW05_AK8SEKwlS_0isJKKqjulKBDPp7t36t9QJk,1787
+mcp_proxy_adapter/examples/basic_framework/roles.json,sha256=I0lSP3hfq1DESv3xsZ7-xOEdzaQGCb8b9YMK_AOPDsE,510
 mcp_proxy_adapter/examples/basic_framework/commands/__init__.py,sha256=_VQNLUEdsxUG-4yt9BZI_vtOxHAdGG0OUSsP6Wj-Vz4,76
 mcp_proxy_adapter/examples/basic_framework/hooks/__init__.py,sha256=IE_EIXMnkdXuakZn7wLD9kBFyfDF5lYi56ejgiBeb-A,70
 mcp_proxy_adapter/examples/commands/__init__.py,sha256=zvY_OpH_B1bVc_khrNIl6O8vqCw1FH6gGMAsJAkGWGY,170
@@ -124,6 +125,7 @@ mcp_proxy_adapter/examples/examples/full_application/hooks/builtin_command_hooks
 mcp_proxy_adapter/examples/full_application/__init__.py,sha256=xGiPYhRAzs1Fh9wA8HoowV-Gg9QMLaMZn-OamExq1TI,320
 mcp_proxy_adapter/examples/full_application/main.py,sha256=ogL3Bil_5puGnwvMh3YNOjrW76FIzzoggKEp-04HSfo,7855
 mcp_proxy_adapter/examples/full_application/proxy_endpoints.py,sha256=Kt_WAsG61HLTMkKQ1mQqjvlX9I4TcfwYq0NaRR9HKvM,6179
+mcp_proxy_adapter/examples/full_application/roles.json,sha256=I0lSP3hfq1DESv3xsZ7-xOEdzaQGCb8b9YMK_AOPDsE,510
 mcp_proxy_adapter/examples/full_application/commands/__init__.py,sha256=yQHxVSFkAyFLUOdk42QOebUODPlQV9IbydPgF3UKsGM,217
 mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py,sha256=H7FPJmVJNWT61rPWxep06-7hsYRt8XYBUSBiwqpBurU,3096
 mcp_proxy_adapter/examples/full_application/commands/dynamic_calculator_command.py,sha256=DFTqVnIDt6nBdZ27-vD_f1X2cFcDInVQiCEq9ltw4lA,3428
@@ -137,8 +139,8 @@ mcp_proxy_adapter/schemas/base_schema.json,sha256=v9G9cGMd4dRhCZsOQ_FMqOi5VFyVbI
 mcp_proxy_adapter/schemas/openapi_schema.json,sha256=C3yLkwmDsvnLW9B5gnKKdBGl4zxkeU-rEmjTrNVsQU0,8405
 mcp_proxy_adapter/utils/config_generator.py,sha256=UXxuxxAyKTesAS3DOofQ26e20v771inA7EfBV8PZD1c,47543
 mcp_proxy_adapter_issue_package/demonstrate_issue.py,sha256=O54fwWQvUAjEGiHhQGm1JLnARkhVCwAqjBk_89HyRbY,7894
-mcp_proxy_adapter-6.3.30.dist-info/METADATA,sha256=BxBZhz8TcLcDZt3bdhdYHTcpddyQ8dnmizdSnv53fzQ,22404
-mcp_proxy_adapter-6.3.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_proxy_adapter-6.3.30.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
-mcp_proxy_adapter-6.3.30.dist-info/top_level.txt,sha256=CHk-Mc-AxjO-tRheegA2qLiQnU4vZRnxuTF81So6SAc,50
-mcp_proxy_adapter-6.3.30.dist-info/RECORD,,
+mcp_proxy_adapter-6.4.1.dist-info/METADATA,sha256=z0V7ZTjQlTXg1cGCGu5NaRbvqQk4Z7moSp3lvLeNgKE,22403
+mcp_proxy_adapter-6.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_proxy_adapter-6.4.1.dist-info/entry_points.txt,sha256=J3eV6ID0lt_VSp4lIdIgBFTqLCThgObNNxRCbyfiMHw,70
+mcp_proxy_adapter-6.4.1.dist-info/top_level.txt,sha256=CHk-Mc-AxjO-tRheegA2qLiQnU4vZRnxuTF81So6SAc,50
+mcp_proxy_adapter-6.4.1.dist-info/RECORD,,

mcp_proxy_adapter/examples/setup_test_environment_old.py

@@ -1,316 +0,0 @@
-#!/usr/bin/env python3
-"""
-Author: Vasiliy Zdanovskiy
-email: vasilyvz@gmail.com
-Script for setting up test environment for MCP Proxy Adapter.
-Prepares the test environment with all necessary files and directories.
-Uses mcp_security_framework for certificate generation.
-
-This script accepts an output directory and copies required example files
-and helper scripts into that directory, creating a ready-to-use workspace.
-By default, the current working directory is used, so end-users can run
-it in their project root after installing this framework in a virtual
-environment.
-"""
-import shutil
-import sys
-import argparse
-from pathlib import Path
-
-# Import mcp_security_framework
-try:
-    from mcp_security_framework.core.cert_manager import CertificateManager
-    from mcp_security_framework.schemas.config import (
-        CertificateConfig,
-        CAConfig,
-        ServerCertConfig,
-        ClientCertConfig,
-    )
-
-    SECURITY_FRAMEWORK_AVAILABLE = True
-except ImportError:
-    SECURITY_FRAMEWORK_AVAILABLE = False
-    print("Warning: mcp_security_framework not available")
-
-
-def _get_package_paths() -> tuple[Path, Path]:
-    """
-    Resolve source paths for examples and utils relative to this file
-    to avoid importing the package during setup.
-    """
-    pkg_root = Path(__file__).resolve().parents[1]
-    return pkg_root / "examples", pkg_root / "utils"
-
-
-def setup_test_environment(output_dir: Path) -> None:
-    """
-    Setup test environment under output_dir with required files
-    and directories.
-
-    All created directories and copied files are rooted at output_dir
-    so users can run scripts relative to that directory.
-    """
-    print("🔧 Setting up test environment...")
-    output_dir = output_dir.resolve()
-    output_dir.mkdir(parents=True, exist_ok=True)
-    # Create test environment directory structure
-    directories = [
-        "examples/basic_framework",
-        "examples/full_application",
-        "scripts",
-        "configs",
-        "certs",
-        "keys",
-        "tokens",
-        "logs",
-    ]
-    for directory in directories:
-        target_dir = output_dir / directory
-        target_dir.mkdir(parents=True, exist_ok=True)
-        print(f"✅ Created directory: {target_dir}")
-    # Resolve package paths
-    examples_src_root, utils_src_root = _get_package_paths()
-    # Copy example files
-    basic_framework_src = examples_src_root / "basic_framework"
-    if basic_framework_src.exists():
-        shutil.copytree(
-            basic_framework_src,
-            output_dir / "examples/basic_framework",
-            dirs_exist_ok=True,
-        )
-        print("✅ Copied basic_framework examples")
-    full_application_src = examples_src_root / "full_application"
-    if full_application_src.exists():
-        shutil.copytree(
-            full_application_src,
-            output_dir / "examples/full_application",
-            dirs_exist_ok=True,
-        )
-        print("✅ Copied full_application examples")
-    # Copy utility scripts
-    config_generator_src = utils_src_root / "config_generator.py"
-    if config_generator_src.exists():
-        shutil.copy2(config_generator_src, output_dir / "scripts/")
-        print("✅ Copied config_generator.py")
-    # Copy certificate generation scripts
-    create_certs_src = examples_src_root / "create_certificates_simple.py"
-    if create_certs_src.exists():
-        shutil.copy2(create_certs_src, output_dir / "scripts/")
-        print("✅ Copied create_certificates_simple.py")
-    cert_tokens_src = examples_src_root / "generate_certificates_and_tokens.py"
-    if cert_tokens_src.exists():
-        shutil.copy2(cert_tokens_src, output_dir / "scripts/")
-        print("✅ Copied generate_certificates_and_tokens.py")
-
-    # Copy roles.json to the root directory for compatibility
-    roles_src = examples_src_root / "roles.json"
-    if roles_src.exists():
-        shutil.copy2(roles_src, output_dir)
-        print("✅ Copied roles.json to root directory")
-
-    # Also copy from configs directory if it exists
-    roles_configs_src = output_dir / "configs" / "roles.json"
-    if roles_configs_src.exists():
-        shutil.copy2(roles_configs_src, output_dir / "roles.json")
-        print("✅ Updated roles.json from configs directory")
-    print("🎉 Test environment setup completed successfully at: {}".format(output_dir))
-
-
-def generate_certificates_with_framework(output_dir: Path) -> bool:
-    """
-    Generate certificates using mcp_security_framework.
-    """
-    if not SECURITY_FRAMEWORK_AVAILABLE:
-        print("❌ mcp_security_framework not available for certificate " "generation")
-        return False
-    try:
-        print("🔐 Generating certificates using mcp_security_framework...")
-        # Configure certificate manager
-        cert_config = CertificateConfig(
-            cert_storage_path=str((output_dir / "certs").resolve()),
-            key_storage_path=str((output_dir / "keys").resolve()),
-            default_validity_days=365,
-            key_size=2048,
-            hash_algorithm="sha256",
-        )
-        cert_manager = CertificateManager(cert_config)
-        # Generate CA certificate
-        ca_config = CAConfig(
-            common_name="MCP Proxy Adapter Test CA",
-            organization="Test Organization",
-            organizational_unit="Certificate Authority",
-            country="US",
-            state="Test State",
-            locality="Test City",
-            validity_years=10,  # Use validity_years instead of validity_days
-            key_size=2048,
-            hash_algorithm="sha256",
-        )
-        cert_pair = cert_manager.create_root_ca(ca_config)
-        if not cert_pair or not cert_pair.certificate_path:
-            print("❌ Failed to create CA certificate: Invalid certificate pair")
-            return False
-        print("✅ CA certificate created successfully")
-        # Find CA key file
-        ca_key_path = cert_pair.private_key_path
-        # Generate server certificate
-        server_config = ServerCertConfig(
-            common_name="localhost",
-            organization="Test Organization",
-            organizational_unit="Server",
-            country="US",
-            state="Test State",
-            locality="Test City",
-            validity_days=365,
-            key_size=2048,
-            hash_algorithm="sha256",
-            subject_alt_names=[
-                "localhost",
-                "127.0.0.1",
-            ],
-            ca_cert_path=cert_pair.certificate_path,
-            ca_key_path=ca_key_path,
-        )
-        cert_pair = cert_manager.create_server_certificate(server_config)
-        if not cert_pair or not cert_pair.certificate_path:
-            print("❌ Failed to create server certificate: Invalid certificate " "pair")
-            return False
-        print("✅ Server certificate created successfully")
-        # Generate client certificates
-        client_configs = [
-            (
-                "admin",
-                ["admin"],
-                [
-                    "read",
-                    "write",
-                    "execute",
-                    "delete",
-                    "admin",
-                    "register",
-                    "unregister",
-                    "heartbeat",
-                    "discover",
-                ],
-            ),
-            (
-                "user",
-                ["user"],
-                [
-                    "read",
-                    "execute",
-                    "register",
-                    "unregister",
-                    "heartbeat",
-                    "discover",
-                ],
-            ),
-            ("readonly", ["readonly"], ["read", "discover"]),
-            ("guest", ["guest"], ["read", "discover"]),
-            (
-                "proxy",
-                ["proxy"],
-                ["register", "unregister", "heartbeat", "discover"],
-            ),
-        ]
-        for client_name, roles, permissions in client_configs:
-            client_config = ClientCertConfig(
-                common_name=f"{client_name}-client",
-                organization="Test Organization",
-                organizational_unit="Client",
-                country="US",
-                state="Test State",
-                locality="Test City",
-                validity_days=730,
-                key_size=2048,
-                hash_algorithm="sha256",
-                roles=roles,
-                permissions=permissions,
-                ca_cert_path=cert_pair.certificate_path,
-                ca_key_path=ca_key_path,
-            )
-            cert_pair = cert_manager.create_client_certificate(client_config)
-            if not cert_pair or not cert_pair.certificate_path:
-                print(
-                    (
-                        "❌ Failed to create client certificate {}: "
-                        "Invalid certificate pair"
-                    ).format(client_name)
-                )
-                return False
-            print("✅ Client certificate {} created successfully".format(client_name))
-        print(
-            "🎉 All certificates generated successfully using "
-            "mcp_security_framework!"
-        )
-        return True
-    except Exception as e:
-        print("❌ Error generating certificates with framework: {}".format(e))
-        print("\n🔧 TROUBLESHOOTING:")
-        print("1. Check if mcp_security_framework is installed:")
-        print("   pip install mcp_security_framework")
-        print("\n2. Verify write permissions in output directory")
-        print("\n3. Check if certs/ and keys/ directories exist")
-        return False
-
-
-def main() -> int:
-    """Main function for command line execution."""
-    parser = argparse.ArgumentParser(
-        description="Setup test environment for MCP Proxy Adapter"
-    )
-    parser.add_argument(
-        "--output-dir",
-        "-o",
-        type=str,
-        default=".",
-        help=(
-            "Target directory to create the test environment "
-            "(default: current directory)"
-        ),
-    )
-    args = parser.parse_args()
-    try:
-        target_root = Path(args.output_dir)
-        setup_test_environment(target_root)
-        # Generate certificates if framework is available
-        if SECURITY_FRAMEWORK_AVAILABLE:
-            generate_certificates_with_framework(target_root)
-        else:
-            print(
-                "⚠️ Skipping certificate generation (mcp_security_framework "
-                "not available)"
-            )
-    except Exception as e:
-        print(
-            "❌ Error setting up test environment: {}".format(e),
-            file=sys.stderr,
-        )
-        print("\n🔧 TROUBLESHOOTING:")
-        print("1. Check if output directory is writable")
-        print("2. Verify mcp_security_framework installation")
-        print("3. Check available disk space")
-        return 1
-
-    print("\n" + "=" * 60)
-    print("✅ TEST ENVIRONMENT SETUP COMPLETED SUCCESSFULLY")
-    print("=" * 60)
-    print("\n📋 NEXT STEPS:")
-    print("1. Generate test configurations:")
-    print(
-        "   python -m mcp_proxy_adapter.examples.generate_test_configs --output-dir configs"
-    )
-    print("\n2. Generate additional certificates (if needed):")
-    print("   python -m mcp_proxy_adapter.examples.generate_certificates")
-    print("\n3. Run security tests:")
-    print("   python -m mcp_proxy_adapter.examples.run_security_tests")
-    print("\n4. Start basic framework example:")
-    print(
-        "   python -m mcp_proxy_adapter.examples.basic_framework.main --config configs/https_simple.json"
-    )
-    print("=" * 60)
-    return 0
-
-
-if __name__ == "__main__":
-    exit(main())