mcp-proxy-adapter 6.6.1__tar.gz → 6.6.3__tar.gz

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.6.1
+Version: 6.6.3
 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.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/api/app.py

@@ -88,11 +88,11 @@ def create_lifespan(config_path: Optional[str] = None):
         public_host = reg_cfg.get("public_host")
         public_port = reg_cfg.get("public_port")
 
-        security_config = config.get("security", {})
-        ssl_config = security_config.get("ssl", {})
-        if not ssl_config.get("enabled", False):
-            ssl_config = config.get("ssl", {})
-        protocol = "https" if ssl_config.get("enabled", False) else "http"
+        # Check SSL configuration from new structure
+        protocol = config.get("server.protocol", "http")
+        verify_client = config.get("transport.verify_client", False)
+        ssl_enabled = protocol in ["https", "mtls"] or verify_client
+        protocol = "https" if ssl_enabled else "http"
 
         import os
         docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
@@ -227,20 +227,26 @@ def create_ssl_context(
     """
     current_config = app_config if app_config is not None else config.get_all()
 
-    # Try security framework SSL config first
-    security_config = current_config.get("security", {})
-    ssl_config = security_config.get("ssl", {})
-
-    # Fallback to legacy SSL config
-    if not ssl_config.get("enabled", False):
-        ssl_config = current_config.get("ssl", {})
+    # Check SSL configuration from new structure
+    protocol = current_config.get("server", {}).get("protocol", "http")
+    verify_client = current_config.get("transport", {}).get("verify_client", False)
+    ssl_enabled = protocol in ["https", "mtls"] or verify_client
 
-    if not ssl_config.get("enabled", False):
+    if not ssl_enabled:
         logger.info("SSL is disabled in configuration")
         return None
 
-    cert_file = ssl_config.get("cert_file")
-    key_file = ssl_config.get("key_file")
+    # Get certificate paths from configuration
+    cert_file = current_config.get("ssl", {}).get("cert_file")
+    key_file = current_config.get("ssl", {}).get("key_file")
+    
+    # If not found in ssl section, use default paths
+    if not cert_file:
+        project_root = Path(__file__).parent.parent.parent
+        cert_file = str(project_root / "certs" / "server.crt")
+    if not key_file:
+        project_root = Path(__file__).parent.parent.parent
+        key_file = str(project_root / "certs" / "server.key")
 
     if not cert_file or not key_file:
         logger.warning("SSL enabled but certificate or key file not specified")
@@ -308,17 +314,13 @@ def create_app(
             print(
                 f"🔍 Debug: create_app received app_config keys: {list(app_config.keys())}"
             )
-            if "security" in app_config:
-                ssl_config = app_config["security"].get("ssl", {})
-                print(
-                    f"🔍 Debug: create_app SSL config: enabled={ssl_config.get('enabled', False)}"
-                )
-                print(
-                    f"🔍 Debug: create_app SSL config: cert_file={ssl_config.get('cert_file')}"
-                )
-                print(
-                    f"🔍 Debug: create_app SSL config: key_file={ssl_config.get('key_file')}"
-                )
+            # Debug SSL configuration
+            protocol = app_config.get("server", {}).get("protocol", "http")
+            verify_client = app_config.get("transport", {}).get("verify_client", False)
+            ssl_enabled = protocol in ["https", "mtls"] or verify_client
+            print(f"🔍 Debug: create_app SSL config: enabled={ssl_enabled}")
+            print(f"🔍 Debug: create_app protocol: {protocol}")
+            print(f"🔍 Debug: create_app verify_client: {verify_client}")
         else:
             print(f"🔍 Debug: create_app received app_config type: {type(app_config)}")
     else:

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/config.py

@@ -84,15 +84,8 @@ class Config:
             "transport": {
                 "type": "http",
                 "port": None,
-                "ssl": {
-                    "enabled": False,
-                    "cert_file": None,
-                    "key_file": None,
-                    "ca_cert": None,
-                    "verify_client": False,
-                    "client_cert_required": False,
-                    "chk_hostname": False,  # Default to False when SSL is disabled
-                },
+                "verify_client": False,
+                "chk_hostname": False,  # Default to False for HTTP
             },
             "proxy_registration": {
                 "enabled": False,

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/core/server_adapter.py

@@ -65,7 +65,7 @@ class ServerConfigAdapter:
 
         # Map verification mode
         if ssl_config.get("verify_client", False):
-            hypercorn_ssl["verify_mode"] = "CERT_REQUIRED"
+            hypercorn_ssl["verify_mode"] = 2  # ssl.CERT_REQUIRED
 
         # Map hostname checking
         if "chk_hostname" in ssl_config:

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/examples/check_config.py

@@ -15,7 +15,7 @@ from pathlib import Path
 from typing import Dict, Any, List, Optional
 
 # Add the project root to the path
-sys.path.insert(0, str(Path(__file__).parent))
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
 from mcp_proxy_adapter.config import Config
 from mcp_proxy_adapter.examples.config_builder import ConfigBuilder, Protocol, AuthMethod

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/examples/config_builder.py

@@ -77,15 +77,8 @@ class ConfigBuilder:
             "transport": {
                 "type": "http",
                 "port": None,
-                "ssl": {
-                    "enabled": False,
-                    "cert_file": None,
-                    "key_file": None,
-                    "ca_cert": None,
-                    "verify_client": False,
-                    "client_cert_required": False,
-                    "chk_hostname": False,
-                },
+                "verify_client": False,
+                "chk_hostname": False
             }
         }
     
@@ -94,18 +87,19 @@ class ConfigBuilder:
         self.config["server"]["protocol"] = protocol.value
         
         if protocol == Protocol.HTTP:
-            # HTTP - no SSL
-            pass
+            # HTTP - no SSL, no client verification
+            self.config["transport"]["verify_client"] = False
+            self.config["transport"]["chk_hostname"] = False
             
         elif protocol == Protocol.HTTPS:
-            # HTTPS - server SSL only
-            # SSL configuration will be handled by the server based on protocol
-            pass
+            # HTTPS - SSL enabled, no client verification
+            self.config["transport"]["verify_client"] = False
+            self.config["transport"]["chk_hostname"] = True
             
         elif protocol == Protocol.MTLS:
-            # mTLS - server SSL + client certificates
-            # SSL configuration will be handled by the server based on protocol
-            pass
+            # mTLS - SSL enabled, client verification required
+            self.config["transport"]["verify_client"] = True
+            self.config["transport"]["chk_hostname"] = True
         
         return self
     

mcp_proxy_adapter-6.6.1/mcp_proxy_adapter/examples/generate_certificates_bugfix.py → mcp_proxy_adapter-6.6.3/mcp_proxy_adapter/examples/generate_certificates.py

@@ -229,7 +229,18 @@ class BugfixCertificateGenerator:
                 with open(client_info["output_key"], 'w') as f:
                     f.write(result.private_key_pem)
                 
+                # Also create a copy in certs/ directory for easier access
+                cert_name_base = client_info["common_name"].replace("-", "_")
+                certs_cert = self.certs_dir / f"{cert_name_base}_client.crt"
+                certs_key = self.certs_dir / f"{cert_name_base}_client.key"
+                
+                with open(certs_cert, 'w') as f:
+                    f.write(result.certificate_pem)
+                with open(certs_key, 'w') as f:
+                    f.write(result.private_key_pem)
+                
                 self.print_success(f"{cert_name} certificate generated: {client_info['output_cert']}")
+                self.print_success(f"Also created: {certs_cert} and {certs_key}")
                 return True
             else:
                 self.print_error(f"Failed to generate {cert_name} certificate")

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/examples/generate_config.py

@@ -12,10 +12,10 @@ import sys
 from pathlib import Path
 from typing import Dict, Any, Optional
 
-# Add the examples directory to the path to import config_builder
-sys.path.insert(0, str(Path(__file__).parent / "mcp_proxy_adapter" / "examples"))
+# Add the project root to the path to import config_builder
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
-from config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
+from mcp_proxy_adapter.examples.config_builder import ConfigBuilder, ConfigFactory, Protocol, AuthMethod
 
 
 def create_config_from_flags(

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -113,7 +113,7 @@ class FullTestSuiteRunner:
 
         try:
             # Check if certificate generation script exists
-            cert_script = self.working_dir / "generate_certificates_bugfix.py"
+            cert_script = self.working_dir / "mcp_proxy_adapter" / "examples" / "generate_certificates.py"
             if not cert_script.exists():
                 self.print_error(
                     f"Certificate generation script not found: {cert_script}"
@@ -167,7 +167,7 @@ class FullTestSuiteRunner:
 
         try:
             # Check if create_test_configs.py exists
-            config_script = self.working_dir / "create_test_configs.py"
+            config_script = self.working_dir / "mcp_proxy_adapter" / "examples" / "create_test_configs.py"
             if not config_script.exists():
                 self.print_error(f"Configuration generator not found: {config_script}")
                 return False
@@ -194,7 +194,7 @@ class FullTestSuiteRunner:
             # Run the configuration generator
             cmd = [
                 sys.executable,
-                "create_test_configs.py",
+                "mcp_proxy_adapter/examples/create_test_configs.py",
                 "--comprehensive-config",
                 "comprehensive_config.json",
             ]

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/examples/security_test_client.py

@@ -124,11 +124,12 @@ class SecurityTestClient:
     def create_ssl_context_for_mtls(self) -> ssl.SSLContext:
         """Create SSL context for mTLS connections."""
         # For mTLS, we need client certificates - check if they exist
-        # Paths are relative to project root (../../ from examples directory)
-        # Use admin certificates to match server configuration
-        cert_file = "../../certs/admin.crt"
-        key_file = "../../certs/client_admin.key"
-        ca_cert_file = "../../certs/localhost_server.crt"
+        # Use absolute paths to avoid issues with working directory
+        # Use newly generated admin_client_client.crt which is signed by the same CA as server
+        project_root = Path(__file__).parent.parent.parent
+        cert_file = str(project_root / "certs" / "admin_client_client.crt")
+        key_file = str(project_root / "keys" / "admin-client_client.key")
+        ca_cert_file = str(project_root / "certs" / "localhost_server.crt")
         
         # CRITICAL: For mTLS, certificates are REQUIRED
         if not os.path.exists(cert_file):

{mcp_proxy_adapter-6.6.1 → mcp_proxy_adapter-6.6.3}/mcp_proxy_adapter/examples/test_chk_hostname_automated.py

@@ -13,7 +13,7 @@ from pathlib import Path
 import sys
 
 # Add the project root to the path
-sys.path.insert(0, str(Path(__file__).parent))
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
 from mcp_proxy_adapter.config import Config
 from mcp_proxy_adapter.examples.config_builder import ConfigBuilder, Protocol, AuthMethod
@@ -27,7 +27,7 @@ def test_chk_hostname_default_config():
     
     # Default should be HTTP with chk_hostname=False
     assert config.get("server.protocol") == "http"
-    assert config.get("transport.ssl.chk_hostname") is False
+    assert config.get("transport.chk_hostname") is False
     
     print("✅ Default config: chk_hostname=False for HTTP")
 
@@ -49,7 +49,7 @@ def test_chk_hostname_http_config():
         
         # HTTP should have chk_hostname=False
         assert config.get("server.protocol") == "http"
-        assert config.get("transport.ssl.chk_hostname") is False
+        assert config.get("transport.chk_hostname") is False
         
         print("✅ HTTP config: chk_hostname=False")
     finally:
@@ -74,7 +74,7 @@ def test_chk_hostname_https_config():
         
         # HTTPS should have chk_hostname=True
         assert config.get("server.protocol") == "https"
-        assert config.get("transport.ssl.chk_hostname") is True
+        assert config.get("transport.chk_hostname") is True
         
         print("✅ HTTPS config: chk_hostname=True")
     finally:
@@ -98,7 +98,7 @@ def test_chk_hostname_mtls_config():
         
         # mTLS should have chk_hostname=True
         assert config.get("server.protocol") == "mtls"
-        assert config.get("transport.ssl.chk_hostname") is True
+        assert config.get("transport.chk_hostname") is True
         
         print("✅ mTLS config: chk_hostname=True")
     finally:
@@ -114,10 +114,7 @@ def test_chk_hostname_override():
     # Add transport section if it doesn't exist
     if "transport" not in https_config:
         https_config["transport"] = {}
-    if "ssl" not in https_config["transport"]:
-        https_config["transport"]["ssl"] = {}
-    https_config["transport"]["ssl"]["chk_hostname"] = False
-    https_config["transport"]["ssl"]["_chk_hostname_user_set"] = True
+    https_config["transport"]["chk_hostname"] = False
     
     # Save to temporary file and load with Config
     with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
@@ -130,7 +127,7 @@ def test_chk_hostname_override():
         
         # Should respect the override
         assert config.get("server.protocol") == "https"
-        assert config.get("transport.ssl.chk_hostname") is False
+        assert config.get("transport.chk_hostname") is False
         
         print("✅ HTTPS config with chk_hostname=False override works")
     finally:

mcp_proxy_adapter-6.6.3/mcp_proxy_adapter/examples/test_framework_complete.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Complete framework testing with real MCP servers.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import json
+import subprocess
+import time
+import requests
+import ssl
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class FrameworkTester:
+    """Complete framework testing with real MCP servers."""
+    
+    def __init__(self):
+        self.project_root = Path(__file__).parent.parent.parent
+        self.configs_dir = self.project_root / "configs"
+        self.examples_dir = Path(__file__).parent
+        self.test_results = []
+        self.server_processes = []
+        
+    async def test_all_protocols(self):
+        """Test all protocols with real MCP server registration."""
+        logger.info("🧪 Starting Complete Framework Testing")
+        logger.info("=" * 60)
+        
+        # Test configurations
+        test_configs = [
+            ("http.json", "HTTP", 20000),
+            ("https.json", "HTTPS", 20003), 
+            ("mtls.json", "mTLS", 20006)
+        ]
+        
+        for config_file, protocol, port in test_configs:
+            logger.info(f"\n🔧 Testing {protocol} (port {port})")
+            logger.info("-" * 40)
+            
+            try:
+                # Start proxy adapter server
+                proxy_process = await self._start_proxy_server(config_file, port)
+                if not proxy_process:
+                    continue
+                
+                # Wait for server to start
+                await asyncio.sleep(2)
+                
+                # Test server registration
+                await self._test_server_registration(protocol, port)
+                
+                # Test MCP communication
+                await self._test_mcp_communication(protocol, port)
+                
+                # Test security features
+                await self._test_security_features(protocol, port)
+                
+                # Stop server
+                proxy_process.terminate()
+                await asyncio.sleep(1)
+                
+                logger.info(f"✅ {protocol} testing completed successfully")
+                
+            except Exception as e:
+                logger.error(f"❌ {protocol} testing failed: {e}")
+                self.test_results.append({
+                    "protocol": protocol,
+                    "status": "failed",
+                    "error": str(e)
+                })
+        
+        # Print summary
+        self._print_summary()
+    
+    async def _start_proxy_server(self, config_file: str, port: int) -> Optional[subprocess.Popen]:
+        """Start proxy adapter server."""
+        config_path = self.configs_dir / config_file
+        
+        if not config_path.exists():
+            logger.error(f"❌ Config file not found: {config_path}")
+            return None
+        
+        logger.info(f"🚀 Starting proxy server with {config_file}")
+        
+        try:
+            # Start server in background
+            process = subprocess.Popen([
+                "python", str(self.examples_dir / "main.py"),
+                "--config", str(config_path)
+            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            self.server_processes.append(process)
+            return process
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to start server: {e}")
+            return None
+    
+    async def _test_server_registration(self, protocol: str, port: int):
+        """Test MCP server registration."""
+        logger.info(f"📝 Testing server registration for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test registration endpoint
+        registration_data = {
+            "server_id": "test-mcp-server",
+            "server_url": "stdio://test-server",
+            "server_name": "Test MCP Server",
+            "description": "Test server for framework validation"
+        }
+        
+        try:
+            # Create SSL context for HTTPS/mTLS
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.post(
+                f"{base_url}/register",
+                json=registration_data,
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                logger.info("✅ Server registration successful")
+            else:
+                logger.warning(f"⚠️ Registration returned status {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"❌ Registration failed: {e}")
+            raise
+    
+    async def _test_mcp_communication(self, protocol: str, port: int):
+        """Test MCP communication through proxy."""
+        logger.info(f"🔗 Testing MCP communication for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test MCP JSON-RPC call
+        mcp_request = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "tools/list",
+            "params": {}
+        }
+        
+        try:
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.post(
+                f"{base_url}/mcp",
+                json=mcp_request,
+                headers={"Content-Type": "application/json"},
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if "result" in result:
+                    logger.info("✅ MCP communication successful")
+                else:
+                    logger.warning(f"⚠️ MCP response: {result}")
+            else:
+                logger.warning(f"⚠️ MCP call returned status {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"❌ MCP communication failed: {e}")
+            raise
+    
+    async def _test_security_features(self, protocol: str, port: int):
+        """Test security features."""
+        logger.info(f"🔒 Testing security features for {protocol}")
+        
+        base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
+        
+        # Test without authentication
+        try:
+            ssl_context = None
+            if protocol in ["HTTPS", "mTLS"]:
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+            
+            response = requests.get(
+                f"{base_url}/health",
+                verify=False,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                logger.info("✅ Health check successful")
+            else:
+                logger.warning(f"⚠️ Health check returned status {response.status_code}")
+                
+        except Exception as e:
+            logger.error(f"❌ Security test failed: {e}")
+            raise
+    
+    def _print_summary(self):
+        """Print test summary."""
+        logger.info("\n" + "=" * 60)
+        logger.info("📊 FRAMEWORK TESTING SUMMARY")
+        logger.info("=" * 60)
+        
+        total_tests = len(self.test_results)
+        successful_tests = len([r for r in self.test_results if r["status"] == "success"])
+        
+        logger.info(f"Total tests: {total_tests}")
+        logger.info(f"Successful: {successful_tests}")
+        logger.info(f"Failed: {total_tests - successful_tests}")
+        
+        if total_tests > 0:
+            success_rate = (successful_tests / total_tests) * 100
+            logger.info(f"Success rate: {success_rate:.1f}%")
+            
+            if success_rate == 100:
+                logger.info("🎉 All tests passed! Framework is working correctly.")
+            elif success_rate >= 80:
+                logger.info("✅ Most tests passed. Framework is mostly functional.")
+            else:
+                logger.info("⚠️ Many tests failed. Framework needs attention.")
+        
+        logger.info("=" * 60)
+    
+    async def cleanup(self):
+        """Cleanup server processes."""
+        logger.info("🧹 Cleaning up server processes...")
+        
+        for process in self.server_processes:
+            try:
+                if process.poll() is None:  # Process is still running
+                    process.terminate()
+                    process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+            except Exception as e:
+                logger.warning(f"Warning: Failed to cleanup process: {e}")
+        
+        self.server_processes.clear()
+
+async def main():
+    """Main testing function."""
+    tester = FrameworkTester()
+    
+    try:
+        await tester.test_all_protocols()
+    finally:
+        await tester.cleanup()
+
+if __name__ == "__main__":
+    asyncio.run(main())