mcp-proxy-adapter 6.4.9__tar.gz → 6.4.11__tar.gz

mcp_proxy_adapter-6.4.11/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: mcp-proxy-adapter
+Version: 6.4.11
+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
+Author-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+Maintainer: Vasiliy Zdanovskiy
+Maintainer-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/maverikod/mcp-proxy-adapter
+Project-URL: Documentation, https://github.com/maverikod/mcp-proxy-adapter#readme
+Project-URL: Source, https://github.com/maverikod/mcp-proxy-adapter
+Project-URL: Tracker, https://github.com/maverikod/mcp-proxy-adapter/issues
+Project-URL: PyPI, https://pypi.org/project/mcp-proxy-adapter/
+Keywords: json-rpc,microservices,fastapi,security,authentication,authorization,proxy,mcp,mtls,ssl,rest,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi<1.0.0,>=0.95.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: hypercorn<1.0.0,>=0.15.0
+Requires-Dist: docstring-parser<1.0.0,>=0.15
+Requires-Dist: typing-extensions<5.0.0,>=4.5.0
+Requires-Dist: jsonrpc>=1.2.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: mcp_security_framework>=1.1.2
+Requires-Dist: packaging>=20.0
+Requires-Dist: aiohttp<4.0.0,>=3.8.0
+Requires-Dist: requests<3.0.0,>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.20.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: httpx>=0.24.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10.0; extra == "test"
+Provides-Extra: examples
+Dynamic: author
+Dynamic: home-page
+Dynamic: maintainer
+Dynamic: requires-python
+
+# MCP Proxy Adapter
+
+**Author:** Vasiliy Zdanovskiy  
+**Email:** vasilyvz@gmail.com
+
+## Overview
+
+MCP Proxy Adapter is a comprehensive framework for building JSON-RPC API servers with built-in security, SSL/TLS support, and proxy registration capabilities. It provides a unified interface for command execution, protocol management, and security enforcement.
+
+## Features
+
+- **JSON-RPC API**: Full JSON-RPC 2.0 support with built-in commands
+- **Security Framework**: Integrated authentication, authorization, and SSL/TLS
+- **Protocol Management**: HTTP, HTTPS, and mTLS protocol support
+- **Proxy Registration**: Automatic registration with proxy servers
+- **Command System**: Extensible command registry with built-in commands
+- **Configuration Management**: Comprehensive configuration with environment variable overrides
+
+## Quick Start
+
+1. **Installation**:
+   ```bash
+   pip install mcp-proxy-adapter
+   ```
+
+2. **Basic Configuration**:
+   ```bash
+   # Use the comprehensive config with all options disabled by default
+   python -m mcp_proxy_adapter --config config.json
+   ```
+
+3. **Access the API**:
+   - Health check: `GET http://localhost:8000/health`
+   - JSON-RPC: `POST http://localhost:8000/api/jsonrpc`
+   - REST API: `POST http://localhost:8000/cmd`
+   - Documentation: `http://localhost:8000/docs`
+
+## Configuration
+
+The adapter uses a comprehensive JSON configuration file (`config.json`) that includes all available options with sensible defaults. All features are disabled by default and can be enabled as needed:
+
+- **Server settings**: Host, port, debug mode
+- **Security**: Authentication methods, SSL/TLS, permissions
+- **Protocols**: HTTP/HTTPS/mTLS configuration
+- **Proxy registration**: Automatic server registration
+- **Logging**: Comprehensive logging configuration
+- **Commands**: Built-in and custom command management
+
+See `docs/EN/configuration.md` for complete configuration documentation.
+
+## Built-in Commands
+
+- `health` - Server health check
+- `echo` - Echo test command
+- `config` - Configuration management
+- `help` - Command help and documentation
+- `reload` - Configuration reload
+- `settings` - Settings management
+- `load`/`unload` - Command loading/unloading
+- `plugins` - Plugin management
+- `proxy_registration` - Proxy registration control
+- `transport_management` - Transport protocol management
+- `role_test` - Role-based access testing
+
+## Security Features
+
+- **Authentication**: API keys, JWT tokens, certificate-based auth
+- **Authorization**: Role-based permissions with wildcard support
+- **SSL/TLS**: Full SSL/TLS and mTLS support
+- **Rate Limiting**: Configurable request rate limiting
+- **Security Headers**: Automatic security header injection
+
+## Examples
+
+The `mcp_proxy_adapter/examples/` directory contains comprehensive examples for different use cases:
+
+- **Basic Framework**: Simple HTTP server setup
+- **Full Application**: Complete application with custom commands and hooks
+- **Security Testing**: Comprehensive security test suite
+- **Certificate Generation**: SSL/TLS certificate management
+
+## Development
+
+The project follows a modular architecture:
+
+- `mcp_proxy_adapter/api/` - FastAPI application and handlers
+- `mcp_proxy_adapter/commands/` - Command system and built-in commands
+- `mcp_proxy_adapter/core/` - Core functionality and utilities
+- `mcp_proxy_adapter/config.py` - Configuration management
+
+## License
+
+This project is licensed under the MIT License.
+
+## Support
+
+For issues and questions, please contact vasilyvz@gmail.com.

mcp_proxy_adapter-6.4.11/README.md

@@ -0,0 +1,97 @@
+# MCP Proxy Adapter
+
+**Author:** Vasiliy Zdanovskiy  
+**Email:** vasilyvz@gmail.com
+
+## Overview
+
+MCP Proxy Adapter is a comprehensive framework for building JSON-RPC API servers with built-in security, SSL/TLS support, and proxy registration capabilities. It provides a unified interface for command execution, protocol management, and security enforcement.
+
+## Features
+
+- **JSON-RPC API**: Full JSON-RPC 2.0 support with built-in commands
+- **Security Framework**: Integrated authentication, authorization, and SSL/TLS
+- **Protocol Management**: HTTP, HTTPS, and mTLS protocol support
+- **Proxy Registration**: Automatic registration with proxy servers
+- **Command System**: Extensible command registry with built-in commands
+- **Configuration Management**: Comprehensive configuration with environment variable overrides
+
+## Quick Start
+
+1. **Installation**:
+   ```bash
+   pip install mcp-proxy-adapter
+   ```
+
+2. **Basic Configuration**:
+   ```bash
+   # Use the comprehensive config with all options disabled by default
+   python -m mcp_proxy_adapter --config config.json
+   ```
+
+3. **Access the API**:
+   - Health check: `GET http://localhost:8000/health`
+   - JSON-RPC: `POST http://localhost:8000/api/jsonrpc`
+   - REST API: `POST http://localhost:8000/cmd`
+   - Documentation: `http://localhost:8000/docs`
+
+## Configuration
+
+The adapter uses a comprehensive JSON configuration file (`config.json`) that includes all available options with sensible defaults. All features are disabled by default and can be enabled as needed:
+
+- **Server settings**: Host, port, debug mode
+- **Security**: Authentication methods, SSL/TLS, permissions
+- **Protocols**: HTTP/HTTPS/mTLS configuration
+- **Proxy registration**: Automatic server registration
+- **Logging**: Comprehensive logging configuration
+- **Commands**: Built-in and custom command management
+
+See `docs/EN/configuration.md` for complete configuration documentation.
+
+## Built-in Commands
+
+- `health` - Server health check
+- `echo` - Echo test command
+- `config` - Configuration management
+- `help` - Command help and documentation
+- `reload` - Configuration reload
+- `settings` - Settings management
+- `load`/`unload` - Command loading/unloading
+- `plugins` - Plugin management
+- `proxy_registration` - Proxy registration control
+- `transport_management` - Transport protocol management
+- `role_test` - Role-based access testing
+
+## Security Features
+
+- **Authentication**: API keys, JWT tokens, certificate-based auth
+- **Authorization**: Role-based permissions with wildcard support
+- **SSL/TLS**: Full SSL/TLS and mTLS support
+- **Rate Limiting**: Configurable request rate limiting
+- **Security Headers**: Automatic security header injection
+
+## Examples
+
+The `mcp_proxy_adapter/examples/` directory contains comprehensive examples for different use cases:
+
+- **Basic Framework**: Simple HTTP server setup
+- **Full Application**: Complete application with custom commands and hooks
+- **Security Testing**: Comprehensive security test suite
+- **Certificate Generation**: SSL/TLS certificate management
+
+## Development
+
+The project follows a modular architecture:
+
+- `mcp_proxy_adapter/api/` - FastAPI application and handlers
+- `mcp_proxy_adapter/commands/` - Command system and built-in commands
+- `mcp_proxy_adapter/core/` - Core functionality and utilities
+- `mcp_proxy_adapter/config.py` - Configuration management
+
+## License
+
+This project is licensed under the MIT License.
+
+## Support
+
+For issues and questions, please contact vasilyvz@gmail.com.

{mcp_proxy_adapter-6.4.9 → mcp_proxy_adapter-6.4.11}/mcp_proxy_adapter/api/app.py

@@ -169,7 +169,7 @@ def create_lifespan(config_path: Optional[str] = None):
             except Exception:
                 pass
 
-            logger.info("🔍 Registration server_url resolved to: %s", server_url)
+            logger.debug("Registration server_url resolved to: %s", server_url)
             try:
                 print("🔍 Registration server_url resolved to (print):", server_url)
             except Exception:
@@ -499,11 +499,11 @@ def create_app(
     # This ensures commands are available before the server starts accepting requests
     try:
         from mcp_proxy_adapter.commands.builtin_commands import register_builtin_commands
-        logger.info("🔧 Registering built-in commands during app creation...")
+        logger.info("Registering built-in commands during app creation...")
         registered_count = register_builtin_commands()
-        logger.info(f"✅ Registered {registered_count} built-in commands during app creation")
+        logger.info(f"Registered {registered_count} built-in commands during app creation")
     except Exception as e:
-        logger.error(f"❌ Failed to register built-in commands during app creation: {e}")
+        logger.error(f"Failed to register built-in commands during app creation: {e}")
         # Don't fail app creation, but log the error
 
     # Configure CORS
@@ -518,14 +518,13 @@ def create_app(
     # Add request logging middleware for debugging
     @app.middleware("http")
     async def debug_request_middleware(request: Request, call_next):
-        logger.info(f"🔍 FastAPI Request START: {request.method} {request.url.path}")
-        logger.info(f"🔍 FastAPI Request Headers: {dict(request.headers)}")
+        logger.debug(f"FastAPI Request START: {request.method} {request.url.path}")
         try:
             response = await call_next(request)
-            logger.info(f"🔍 FastAPI Request COMPLETED: {response.status_code}")
+            logger.debug(f"FastAPI Request COMPLETED: {response.status_code}")
             return response
         except Exception as e:
-            logger.error(f"🔍 FastAPI Request ERROR: {e}", exc_info=True)
+            logger.error(f"FastAPI Request ERROR: {e}", exc_info=True)
             raise
 
     # Setup middleware using the new middleware package

{mcp_proxy_adapter-6.4.9 → mcp_proxy_adapter-6.4.11}/mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -97,26 +97,19 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Response object
         """
-        logger.info(f"🔍 PROTOCOL STEP 1: ProtocolMiddleware.dispatch START - {request.method} {request.url.path}")
-        logger.info(f"🔍 PROTOCOL STEP 1.1: Request scheme: {request.url.scheme}")
-        logger.info(f"🔍 PROTOCOL STEP 1.2: Request headers: {dict(request.headers)}")
-        logger.info(f"🔍 PROTOCOL STEP 1.3: Request scope: {request.scope}")
-        logger.info(f"🔍 PROTOCOL STEP 1.4: Protocol manager enabled: {self.protocol_manager.enabled}")
-        logger.info(f"🔍 PROTOCOL STEP 1.5: Protocol manager allowed_protocols: {self.protocol_manager.allowed_protocols}")
+        logger.debug(f"ProtocolMiddleware processing {request.method} {request.url.path}")
         
         try:
             # Get protocol from request
-            logger.info(f"🔍 PROTOCOL STEP 2: Getting request protocol...")
             protocol = self._get_request_protocol(request)
-            logger.info(f"🔍 PROTOCOL STEP 3: Detected protocol: {protocol} for {request.method} {request.url.path}")
+            logger.debug(f"Detected protocol: {protocol} for {request.method} {request.url.path}")
 
             # Check if protocol is allowed
-            logger.info(f"🔍 PROTOCOL STEP 4: Checking if protocol '{protocol}' is allowed...")
             is_allowed = self.protocol_manager.is_protocol_allowed(protocol)
-            logger.info(f"🔍 PROTOCOL STEP 5: Protocol '{protocol}' allowed: {is_allowed}")
+            logger.debug(f"Protocol '{protocol}' allowed: {is_allowed}")
             
             if not is_allowed:
-                logger.warning(f"❌ PROTOCOL STEP ERROR: Protocol '{protocol}' not allowed for request to {request.url.path}")
+                logger.warning(f"Protocol '{protocol}' not allowed for request to {request.url.path}")
                 return JSONResponse(
                     status_code=403,
                     content={
@@ -127,17 +120,11 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
                 )
 
             # Continue processing
-            logger.info(f"✅ PROTOCOL STEP 6: Protocol '{protocol}' allowed, proceeding...")
-            logger.info(f"🔍 PROTOCOL STEP 7: Adding protocol '{protocol}' to request state...")
             request.state.protocol = protocol
-            logger.info(f"🔍 PROTOCOL STEP 8: Protocol '{protocol}' added to request state")
+            logger.debug(f"Protocol '{protocol}' added to request state")
             
-            logger.info(f"🔍 PROTOCOL STEP 9: Calling next middleware/endpoint...")
             response = await call_next(request)
-            logger.info(f"🔍 PROTOCOL STEP 10: Next middleware/endpoint completed with status: {response.status_code}")
-            logger.info(f"🔍 PROTOCOL STEP 10.1: Response headers: {dict(response.headers)}")
-            
-            logger.info(f"✅ PROTOCOL STEP 11: ProtocolMiddleware completed successfully")
+            logger.debug(f"ProtocolMiddleware completed with status: {response.status_code}")
             return response
 
         except Exception as e:
@@ -157,63 +144,33 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Protocol name (http, https, mtls)
         """
-        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol START")
-        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - request.url.scheme: {request.url.scheme}")
-        
         try:
             # Check if request is secure (HTTPS)
             if request.url.scheme:
                 scheme = request.url.scheme.lower()
-                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - scheme: {scheme}")
 
                 # If HTTPS, check if client certificate is provided (MTLS)
                 if scheme == "https":
-                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - HTTPS detected, checking for mTLS")
-                    
                     # Check for client certificate in ASGI scope
                     try:
                         # Method 1: Check transport info in ASGI scope
                         if hasattr(request, "scope") and request.scope:
-                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - ASGI scope available")
-                            # Check for client certificate in transport layer
                             transport = request.scope.get("transport")
                             if transport and hasattr(transport, "get_extra_info"):
-                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - transport available, checking SSL object")
                                 try:
                                     ssl_object = transport.get_extra_info("ssl_object")
                                     if ssl_object:
-                                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - SSL object available, checking peer cert")
                                         try:
                                             cert = ssl_object.getpeercert()
                                             if cert:
-                                                logger.debug(f"✅ ProtocolMiddleware._get_request_protocol - mTLS client certificate detected: {cert.get('subject', 'unknown')}")
+                                                logger.debug(f"mTLS client certificate detected: {cert.get('subject', 'unknown')}")
                                                 return "mtls"
-                                            else:
-                                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No peer certificate found")
-                                        except Exception as e:
-                                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking client certificate: {e}")
-                                    else:
-                                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No SSL object found")
-                                except Exception as e:
-                                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error getting SSL object from transport: {e}")
-                            else:
-                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No transport or get_extra_info method")
-                            
-                            # Method 2: Check client info in ASGI scope
-                            try:
-                                client_info = request.scope.get("client")
-                                if client_info and len(client_info) > 2:
-                                    # client_info format: (host, port, additional_info...)
-                                    # Additional info might contain certificate information
-                                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Client info detected, might be mTLS: {client_info}")
-                                else:
-                                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Client info: {client_info}")
-                            except Exception as e:
-                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking client info: {e}")
-                        else:
-                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No ASGI scope available")
-                    except Exception as e:
-                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking ASGI scope for mTLS: {e}")
+                                        except Exception:
+                                            pass
+                                except Exception:
+                                    pass
+                    except Exception:
+                        pass
 
                     # Check for client certificate in headers (proxy forwarded)
                     try:
@@ -224,31 +181,25 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
                             request.headers.get("x-forwarded-client-cert")
                         ]
                         if any(mtls_headers):
-                            logger.debug(f"✅ ProtocolMiddleware._get_request_protocol - mTLS client certificate detected in headers")
+                            logger.debug("mTLS client certificate detected in headers")
                             return "mtls"
-                        else:
-                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No mTLS headers found")
-                    except Exception as e:
-                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking headers for mTLS: {e}")
+                    except Exception:
+                        pass
 
-                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Returning 'https' (no mTLS detected)")
                     return "https"
 
-                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Returning scheme: {scheme}")
                 return scheme
 
             # Fallback to checking headers
             x_forwarded_proto = request.headers.get("x-forwarded-proto")
             if x_forwarded_proto:
-                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Using x-forwarded-proto: {x_forwarded_proto}")
                 return x_forwarded_proto.lower()
 
             # Default to HTTP
-            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Defaulting to 'http'")
             return "http"
             
         except Exception as e:
-            logger.error(f"❌ ProtocolMiddleware._get_request_protocol - Error: {e}", exc_info=True)
+            logger.error(f"Error extracting protocol from request: {e}", exc_info=True)
             # Fallback to HTTP if there's any error
             return "http"
 
@@ -261,43 +212,25 @@ def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
         app: FastAPI application
         app_config: Application configuration dictionary (optional)
     """
-    logger.info(f"🔍 SETUP STEP 1: setup_protocol_middleware - app_config type: {type(app_config)}")
-
     # Check if protocol management is enabled
     if app_config is None:
-        logger.info(f"🔍 SETUP STEP 2: app_config is None, loading from global config...")
         from mcp_proxy_adapter.config import config
-
         app_config = config.get_all()
-        logger.info(f"🔍 SETUP STEP 3: loaded from global config, type: {type(app_config)}")
-
-    logger.info(f"🔍 SETUP STEP 4: final app_config type: {type(app_config)}")
 
     if hasattr(app_config, "get"):
-        logger.info(f"🔍 SETUP STEP 5: app_config has 'get' method")
-        logger.info(f"🔍 SETUP STEP 5.1: app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}")
         protocols_config = app_config.get("protocols", {})
-        logger.info(f"🔍 SETUP STEP 6: protocols_config: {protocols_config}")
-        logger.info(f"🔍 SETUP STEP 6.1: protocols_config type: {type(protocols_config)}")
         enabled = (
             protocols_config.get("enabled", True)
             if hasattr(protocols_config, "get")
             else True
         )
-        logger.info(f"🔍 SETUP STEP 7: protocols_config.get('enabled', True) = {enabled}")
     else:
-        logger.info(f"🔍 SETUP STEP 5: app_config is not dict-like: {repr(app_config)}")
         enabled = True
 
-    logger.info(f"🔍 SETUP STEP 8: protocol management enabled: {enabled}")
-
     if enabled:
         # Create protocol middleware with current configuration
-        logger.info(f"🔍 SETUP STEP 9: Creating ProtocolMiddleware with config type: {type(app_config)}")
         middleware = ProtocolMiddleware(app, app_config)
-        logger.info(f"🔍 SETUP STEP 10: ProtocolMiddleware created successfully")
-        logger.info(f"🔍 SETUP STEP 11: Adding ProtocolMiddleware to app...")
         app.add_middleware(ProtocolMiddleware, app_config=app_config)
-        logger.info(f"✅ SETUP STEP 12: Protocol middleware added to application")
+        logger.info("Protocol middleware added to application")
     else:
-        logger.info(f"✅ SETUP STEP 9: Protocol management is disabled, skipping protocol middleware")
+        logger.info("Protocol management is disabled, skipping protocol middleware")

{mcp_proxy_adapter-6.4.9 → mcp_proxy_adapter-6.4.11}/mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -235,6 +235,123 @@ class FullTestSuiteRunner:
             self.print_error(f"Failed to run security tests: {e}")
             return False
 
+    def run_mtls_registration_test(self) -> bool:
+        """Run mTLS with proxy registration test."""
+        self.print_step("6", "mTLS Proxy Registration Testing")
+
+        try:
+            # Check if test_proxy_registration.py exists
+            test_script = self.working_dir / "test_proxy_registration.py"
+            if not test_script.exists():
+                self.print_error(f"Test script not found: {test_script}")
+                return False
+
+            # Create test_proxy_registration.json config if it doesn't exist
+            test_config = self.configs_dir / "test_proxy_registration.json"
+            if not test_config.exists():
+                self.print_info("Creating test_proxy_registration.json configuration...")
+                test_config_content = {
+                    "uuid": "550e8400-e29b-41d4-a716-446655440001",
+                    "server": {
+                        "host": "127.0.0.1",
+                        "port": 20005
+                    },
+                    "ssl": {
+                        "enabled": True,
+                        "cert_file": "certs/localhost_server.crt",
+                        "key_file": "keys/localhost_server.key",
+                        "ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
+                        "client_cert_file": "certs/admin_cert.pem",
+                        "client_key_file": "certs/admin_key.pem",
+                        "verify_client": True
+                    },
+                    "registration": {
+                        "enabled": True,
+                        "auth_method": "token",
+                        "server_url": "http://127.0.0.1:3006/proxy",
+                        "token": {
+                            "enabled": True,
+                            "token": "proxy_registration_token_123"
+                        },
+                        "proxy_info": {
+                            "name": "mcp_test_server",
+                            "capabilities": [
+                                "jsonrpc",
+                                "rest",
+                                "security",
+                                "proxy_registration"
+                            ],
+                            "endpoints": {
+                                "jsonrpc": "/api/jsonrpc",
+                                "rest": "/cmd",
+                                "health": "/health"
+                            }
+                        },
+                        "heartbeat": {
+                            "enabled": True,
+                            "interval": 30
+                        }
+                    },
+                    "security": {
+                        "enabled": True,
+                        "auth": {
+                            "enabled": True,
+                            "methods": [
+                                "certificate"
+                            ]
+                        },
+                        "permissions": {
+                            "enabled": True,
+                            "roles_file": "configs/roles.json"
+                        }
+                    },
+                    "protocols": {
+                        "enabled": True,
+                        "default_protocol": "mtls",
+                        "allowed_protocols": [
+                            "https",
+                            "mtls"
+                        ]
+                    }
+                }
+                
+                import json
+                with open(test_config, 'w', encoding='utf-8') as f:
+                    json.dump(test_config_content, f, indent=2)
+                self.print_success(f"Created test configuration: {test_config}")
+
+            self.print_info("Running mTLS proxy registration test...")
+            self.print_info("This test verifies:")
+            self.print_info("  - mTLS server startup with client certificate verification")
+            self.print_info("  - Proxy registration functionality")
+            self.print_info("  - SSL configuration validation")
+
+            # Run the test
+            cmd = [sys.executable, "test_proxy_registration.py"]
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, cwd=self.working_dir
+            )
+
+            if result.returncode == 0:
+                self.print_success("mTLS proxy registration test completed successfully!")
+                if result.stdout:
+                    print("Test output:")
+                    print(result.stdout)
+                return True
+            else:
+                self.print_error("mTLS proxy registration test failed!")
+                if result.stdout:
+                    print("Test output:")
+                    print(result.stdout)
+                if result.stderr:
+                    print("Error output:")
+                    print(result.stderr)
+                return False
+
+        except Exception as e:
+            self.print_error(f"Failed to run mTLS registration test: {e}")
+            return False
+
     def cleanup(self):
         """Clean up temporary files and processes."""
         self.print_info("Cleaning up...")
@@ -305,6 +422,10 @@ class FullTestSuiteRunner:
             if not self.run_security_tests():
                 return False
 
+            # Step 6: mTLS proxy registration testing
+            if not self.run_mtls_registration_test():
+                return False
+
             # All steps completed successfully
             print(f"\n{'='*60}")
             print("🎉 FULL TEST SUITE COMPLETED SUCCESSFULLY!")
@@ -315,6 +436,7 @@ class FullTestSuiteRunner:
             print("✅ Certificates generated")
             print("✅ Configurations generated")
             print("✅ Security tests passed")
+            print("✅ mTLS proxy registration test passed")
             print(f"\n📁 Test artifacts created in: {self.working_dir}")
             print(f"📁 Configurations: {self.configs_dir}")
             print(f"📁 Certificates: {self.certs_dir}")