mcp-proxy-adapter 6.4.10__py3-none-any.whl → 6.4.12__py3-none-any.whl

mcp_proxy_adapter/examples/basic_framework/main.py

@@ -43,8 +43,9 @@ def main():
         title="Basic Framework Example",
         description="Basic MCP Proxy Adapter with minimal configuration",
         version="1.0.0",
-        host=config_overrides.get("host", "0.0.0.0"),
-        log_level="debug" if config_overrides.get("debug", False) else "info",
+        host=config_overrides.get("host"),
+        port=config_overrides.get("port"),
+        debug=config_overrides.get("debug", False),
     ))
 
 

mcp_proxy_adapter/examples/create_test_configs.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""
+Test Configuration Generator
+Creates test configurations by copying the comprehensive config and enabling/disabling specific options.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+import json
+import shutil
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+
+class TestConfigGenerator:
+    """Generator for test configurations based on comprehensive config."""
+
+    def __init__(self, comprehensive_config_path: str, output_dir: str = "configs"):
+        """
+        Initialize the generator.
+        
+        Args:
+            comprehensive_config_path: Path to the comprehensive configuration file
+            output_dir: Directory to output test configurations
+        """
+        self.comprehensive_config_path = Path(comprehensive_config_path)
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        
+        # Load the comprehensive config
+        with open(self.comprehensive_config_path, 'r', encoding='utf-8') as f:
+            self.base_config = json.load(f)
+
+    def create_config(self, name: str, modifications: Dict[str, Any]) -> Path:
+        """
+        Create a test configuration with specific modifications.
+        
+        Args:
+            name: Name of the configuration (without .json extension)
+            modifications: Dictionary of modifications to apply
+            
+        Returns:
+            Path to the created configuration file
+        """
+        # Deep copy the base config
+        config = json.loads(json.dumps(self.base_config))
+        
+        # Apply modifications
+        for key, value in modifications.items():
+            self._set_nested_value(config, key, value)
+        
+        # Save the configuration
+        output_path = self.output_dir / f"{name}.json"
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+        
+        print(f"✅ Created test config: {output_path}")
+        return output_path
+
+    def _set_nested_value(self, config: Dict, key: str, value: Any):
+        """Set a nested value in the configuration using dot notation."""
+        keys = key.split('.')
+        current = config
+        
+        for k in keys[:-1]:
+            if k not in current:
+                current[k] = {}
+            current = current[k]
+        
+        current[keys[-1]] = value
+
+    def create_all_test_configs(self):
+        """Create all standard test configurations."""
+        print("🔧 Creating test configurations from comprehensive config...")
+        
+        # 1. HTTP Simple
+        self.create_config("http_simple", {
+            "server.port": 8001,
+            "ssl.enabled": False,
+            "security.enabled": False,
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["http"]
+        })
+        
+        # 2. HTTP with Auth
+        self.create_config("http_auth", {
+            "server.port": 8002,
+            "ssl.enabled": False,
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["api_key"],
+            "security.auth.api_keys": {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key"
+            },
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["http"]
+        })
+        
+        # 3. HTTPS Simple
+        self.create_config("https_simple", {
+            "server.port": 8003,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "security.enabled": False,
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["https"]
+        })
+        
+        # 4. HTTPS with Auth
+        self.create_config("https_auth", {
+            "server.port": 8004,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["api_key"],
+            "security.auth.api_keys": {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key"
+            },
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["https"]
+        })
+        
+        # 5. mTLS Simple
+        self.create_config("mtls_simple", {
+            "server.port": 8005,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "ssl.ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
+            "ssl.verify_client": True,
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["certificate"],
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["https", "mtls"]
+        })
+        
+        # 6. mTLS with Roles
+        self.create_config("mtls_with_roles", {
+            "server.port": 8006,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "ssl.ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
+            "ssl.verify_client": True,
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["certificate"],
+            "security.permissions.enabled": True,
+            "security.permissions.roles_file": "configs/roles.json",
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["https", "mtls"]
+        })
+        
+        # 6a. mTLS without Roles (for security tests)
+        self.create_config("mtls_no_roles", {
+            "server.port": 8009,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "ssl.ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
+            "ssl.verify_client": True,
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["certificate"],
+            "security.permissions.enabled": False,
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["https", "mtls"]
+        })
+        
+        # 7. mTLS with Proxy Registration
+        self.create_config("mtls_with_proxy", {
+            "server.port": 8007,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "ssl.ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
+            "ssl.verify_client": True,
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["certificate"],
+            "proxy_registration.enabled": True,
+            "proxy_registration.proxy_url": "http://127.0.0.1:3006",
+            "proxy_registration.server_id": "mcp_test_server",
+            "proxy_registration.server_name": "MCP Test Server",
+            "protocols.allowed_protocols": ["https", "mtls"]
+        })
+        
+        # 8. HTTP with Token Auth (for security tests)
+        self.create_config("http_token", {
+            "server.port": 8010,
+            "ssl.enabled": False,
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["api_key"],
+            "security.auth.api_keys": {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key"
+            },
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["http"]
+        })
+        
+        # 9. HTTPS with Token Auth (for security tests)
+        self.create_config("https_token", {
+            "server.port": 8011,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["api_key"],
+            "security.auth.api_keys": {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key"
+            },
+            "proxy_registration.enabled": False,
+            "protocols.allowed_protocols": ["https"]
+        })
+        
+        # 10. Full Featured (everything enabled)
+        self.create_config("full_featured", {
+            "server.port": 8008,
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/localhost_server.crt",
+            "ssl.key_file": "keys/localhost_server.key",
+            "ssl.ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
+            "ssl.verify_client": True,
+            "security.enabled": True,
+            "security.auth.enabled": True,
+            "security.auth.methods": ["certificate", "api_key"],
+            "security.auth.api_keys": {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key"
+            },
+            "security.permissions.enabled": True,
+            "security.permissions.roles_file": "configs/roles.json",
+            "security.rate_limit.enabled": True,
+            "proxy_registration.enabled": True,
+            "proxy_registration.proxy_url": "http://127.0.0.1:3006",
+            "proxy_registration.server_id": "mcp_full_server",
+            "proxy_registration.server_name": "MCP Full Featured Server",
+            "protocols.allowed_protocols": ["http", "https", "mtls", "jsonrpc"]
+        })
+        
+        print(f"✅ Created {10} test configurations in {self.output_dir}")
+
+
+def main():
+    """Main entry point."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Generate test configurations")
+    parser.add_argument(
+        "--comprehensive-config", 
+        default="comprehensive_config.json",
+        help="Path to comprehensive configuration file"
+    )
+    parser.add_argument(
+        "--output-dir",
+        default="configs",
+        help="Output directory for test configurations"
+    )
+    parser.add_argument(
+        "--config-name",
+        help="Create a specific configuration (http_simple, https_auth, mtls_with_roles, etc.)"
+    )
+    parser.add_argument(
+        "--modifications",
+        help="JSON string of modifications to apply (for custom configs)"
+    )
+    
+    args = parser.parse_args()
+    
+    generator = TestConfigGenerator(args.comprehensive_config, args.output_dir)
+    
+    if args.config_name:
+        # Create a specific configuration
+        if args.modifications:
+            modifications = json.loads(args.modifications)
+        else:
+            # Use predefined modifications
+            predefined = {
+                "http_simple": {"server.port": 8001, "ssl.enabled": False, "security.enabled": False},
+                "https_simple": {"server.port": 8003, "ssl.enabled": True},
+                "mtls_simple": {"server.port": 8005, "ssl.enabled": True, "ssl.verify_client": True},
+            }
+            modifications = predefined.get(args.config_name, {})
+        
+        generator.create_config(args.config_name, modifications)
+    else:
+        # Create all test configurations
+        generator.create_all_test_configs()
+
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -115,11 +115,7 @@ class FullTestSuiteRunner:
 
         try:
             # Run certificate generation script
-            cmd = [
-                sys.executable,
-                "-m",
-                "mcp_proxy_adapter.examples.create_certificates_simple",
-            ]
+            cmd = [sys.executable, "create_certificates_simple.py"]
             self.print_info("Running certificate generation script...")
 
             result = subprocess.run(
@@ -143,29 +139,76 @@ class FullTestSuiteRunner:
             return False
 
     def generate_configurations(self) -> bool:
-        """Generate test configurations."""
+        """Generate test configurations from comprehensive config."""
         self.print_step("4", "Configuration Generation")
 
         try:
-            # Run configuration generation script
-            cmd = [
-                sys.executable,
-                "-m",
-                "mcp_proxy_adapter.examples.generate_test_configs",
-            ]
-            self.print_info("Running configuration generation script...")
+            # Check if create_test_configs.py exists
+            config_script = self.working_dir / "create_test_configs.py"
+            if not config_script.exists():
+                self.print_error(f"Configuration generator not found: {config_script}")
+                return False
+
+            # Check if comprehensive_config.json exists
+            comprehensive_config = self.working_dir / "comprehensive_config.json"
+            if not comprehensive_config.exists():
+                self.print_error(f"Comprehensive config not found: {comprehensive_config}")
+                return False
 
+            self.print_info("Generating test configurations from comprehensive config...")
+            self.print_info("This will create:")
+            self.print_info("  - HTTP configurations (simple and with auth)")
+            self.print_info("  - HTTPS configurations (simple and with auth)")
+            self.print_info("  - mTLS configurations (simple, with roles, with proxy registration)")
+            self.print_info("  - Full featured configuration (everything enabled)")
+
+            # Run the configuration generator
+            cmd = [sys.executable, "create_test_configs.py", "--comprehensive-config", "comprehensive_config.json"]
             result = subprocess.run(
                 cmd, capture_output=True, text=True, cwd=self.working_dir
             )
 
             if result.returncode == 0:
-                self.print_success("Configurations generated successfully")
+                self.print_success("Configuration generation completed successfully!")
                 if result.stdout:
+                    print("Generator output:")
                     print(result.stdout)
+                
+                # Create roles.json file
+                self.print_info("Creating roles.json file...")
+                roles_content = {
+                    "roles": {
+                        "admin": {
+                            "permissions": ["*"],
+                            "description": "Full administrative access"
+                        },
+                        "user": {
+                            "permissions": ["read", "write"],
+                            "description": "Standard user access"
+                        },
+                        "readonly": {
+                            "permissions": ["read"],
+                            "description": "Read-only access"
+                        },
+                        "guest": {
+                            "permissions": ["read"],
+                            "description": "Limited guest access"
+                        }
+                    }
+                }
+                
+                roles_file = self.configs_dir / "roles.json"
+                import json
+                with open(roles_file, 'w', encoding='utf-8') as f:
+                    json.dump(roles_content, f, indent=2, ensure_ascii=False)
+                self.print_success(f"Created roles.json: {roles_file}")
+                
                 return True
             else:
                 self.print_error("Configuration generation failed!")
+                if result.stdout:
+                    print("Generator output:")
+                    print(result.stdout)
                 if result.stderr:
                     print("Error output:")
                     print(result.stderr)
@@ -181,12 +224,7 @@ class FullTestSuiteRunner:
 
         try:
             # Run security tests
-            cmd = [
-                sys.executable,
-                "-m",
-                "mcp_proxy_adapter.examples.run_security_tests",
-                "--verbose",
-            ]
+            cmd = [sys.executable, "run_security_tests.py", "--verbose"]
             self.print_info("Running security tests...")
 
             # Debug: show current working directory and check files
@@ -235,6 +273,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 +460,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 +474,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}")

mcp_proxy_adapter/version.py

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