mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/examples/setup_test_environment.py

@@ -16,6 +16,7 @@ import shutil
 import sys
 import argparse
 from pathlib import Path
+
 # Import mcp_security_framework
 try:
     from mcp_security_framework.core.cert_manager import CertificateManager
@@ -25,6 +26,7 @@ try:
         ServerCertConfig,
         ClientCertConfig,
     )
+
     SECURITY_FRAMEWORK_AVAILABLE = True
 except ImportError:
     SECURITY_FRAMEWORK_AVAILABLE = False
@@ -60,7 +62,7 @@ def setup_test_environment(output_dir: Path) -> None:
         "certs",
         "keys",
         "tokens",
-        "logs"
+        "logs",
     ]
     for directory in directories:
         target_dir = output_dir / directory
@@ -111,11 +113,7 @@ def setup_test_environment(output_dir: Path) -> None:
     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
-        )
-    )
+    print("🎉 Test environment setup completed successfully at: {}".format(output_dir))
 
 
 def generate_certificates_with_framework(output_dir: Path) -> bool:
@@ -123,15 +121,10 @@ 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"
-        )
+        print("❌ mcp_security_framework not available for certificate " "generation")
         return False
     try:
-        print(
-            "🔐 Generating certificates using mcp_security_framework..."
-        )
+        print("🔐 Generating certificates using mcp_security_framework...")
         # Configure certificate manager
         cert_config = CertificateConfig(
             cert_storage_path=str((output_dir / "certs").resolve()),
@@ -155,9 +148,7 @@ def generate_certificates_with_framework(output_dir: Path) -> bool:
         )
         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"
-            )
+            print("❌ Failed to create CA certificate: Invalid certificate pair")
             return False
         print("✅ CA certificate created successfully")
         # Find CA key file
@@ -182,10 +173,7 @@ def generate_certificates_with_framework(output_dir: Path) -> bool:
         )
         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"
-            )
+            print("❌ Failed to create server certificate: Invalid certificate " "pair")
             return False
         print("✅ Server certificate created successfully")
         # Generate client certificates
@@ -239,7 +227,7 @@ def generate_certificates_with_framework(output_dir: Path) -> bool:
                 roles=roles,
                 permissions=permissions,
                 ca_cert_path=cert_pair.certificate_path,
-                ca_key_path=ca_key_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:
@@ -250,11 +238,7 @@ def generate_certificates_with_framework(output_dir: Path) -> bool:
                     ).format(client_name)
                 )
                 return False
-            print(
-                "✅ Client certificate {} created successfully".format(
-                    client_name
-                )
-            )
+            print("✅ Client certificate {} created successfully".format(client_name))
         print(
             "🎉 All certificates generated successfully using "
             "mcp_security_framework!"
@@ -307,19 +291,23 @@ def main() -> int:
         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(
+        "   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(
+        "   python -m mcp_proxy_adapter.examples.basic_framework.main --config configs/https_simple.json"
+    )
     print("=" * 60)
     return 0
 

mcp_proxy_adapter/examples/test_config.py

@@ -14,16 +14,20 @@ import time
 import subprocess
 from pathlib import Path
 from typing import Dict, Any, Optional
+
 # Import mcp_security_framework
 try:
     from mcp_security_framework import SecurityManager
     from mcp_security_framework.schemas.config import SecurityConfig
+
     SECURITY_FRAMEWORK_AVAILABLE = True
 except ImportError:
     SECURITY_FRAMEWORK_AVAILABLE = False
     print("Warning: mcp_security_framework not available")
 # Add parent directory to path to import mcp_proxy_adapter
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
+
+
 def validate_security_config(config: Dict[str, Any]) -> bool:
     """
     Validate security configuration using mcp_security_framework.
@@ -46,7 +50,7 @@ def validate_security_config(config: Dict[str, Any]) -> bool:
             auth=security_section.get("auth", {}),
             ssl=security_section.get("ssl", {}),
             permissions=security_section.get("permissions", {}),
-            rate_limit=security_section.get("rate_limit", {})
+            rate_limit=security_section.get("rate_limit", {}),
         )
         # Create SecurityManager for validation
         security_manager = SecurityManager(security_config)
@@ -63,6 +67,8 @@ def validate_security_config(config: Dict[str, Any]) -> bool:
     except Exception as e:
         print(f"❌ Error validating security configuration: {e}")
         return False
+
+
 def test_configuration(config_path: str, timeout: int = 30) -> bool:
     """
     Test a configuration by creating an application and validating it.
@@ -76,11 +82,12 @@ def test_configuration(config_path: str, timeout: int = 30) -> bool:
     print("=" * 60)
     try:
         # Load configuration
-        with open(config_path, 'r') as f:
+        with open(config_path, "r") as f:
             config = json.load(f)
         # Import required modules
         from mcp_proxy_adapter.core.app_factory import create_application
         from mcp_proxy_adapter.core.app_runner import ApplicationRunner
+
         # Create application
         print("🔧 Creating application...")
         app = create_application(config)
@@ -133,16 +140,24 @@ def test_configuration(config_path: str, timeout: int = 30) -> bool:
     except Exception as e:
         print(f"❌ Configuration test failed: {e}")
         return False
+
+
 def main():
     """Main function for command line execution."""
     parser = argparse.ArgumentParser(description="Test MCP Proxy Adapter configuration")
-    parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
-    parser.add_argument("--timeout", "-t", type=int, default=30, help="Timeout in seconds")
+    parser.add_argument(
+        "--config", "-c", required=True, help="Path to configuration file"
+    )
+    parser.add_argument(
+        "--timeout", "-t", type=int, default=30, help="Timeout in seconds"
+    )
     args = parser.parse_args()
     if not os.path.exists(args.config):
         print(f"❌ Configuration file not found: {args.config}")
         return 1
     success = test_configuration(args.config, args.timeout)
     return 0 if success else 1
+
+
 if __name__ == "__main__":
     exit(main())

mcp_proxy_adapter/examples/test_config_generator.py

@@ -7,10 +7,13 @@ configurations with the new protocols section and fixes for ProtocolMiddleware i
 import sys
 import json
 from pathlib import Path
+
 # Add the project root to the path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
 from mcp_proxy_adapter.utils.config_generator import ConfigGenerator
+
+
 def test_config_generator():
     """Test the configuration generator with different types."""
     generator = ConfigGenerator()
@@ -22,7 +25,7 @@ def test_config_generator():
         "https_token",
         "https_no_protocol_middleware",
         "mtls",
-        "mtls_no_protocol_middleware"
+        "mtls_no_protocol_middleware",
     ]
     print("Testing Configuration Generator")
     print("=" * 50)
@@ -37,17 +40,26 @@ def test_config_generator():
                 protocols = config["protocols"]
                 print(f"✅ Protocols section found:")
                 print(f"   - enabled: {protocols.get('enabled', 'NOT SET')}")
-                print(f"   - allowed_protocols: {protocols.get('allowed_protocols', 'NOT SET')}")
-                print(f"   - default_protocol: {protocols.get('default_protocol', 'NOT SET')}")
+                print(
+                    f"   - allowed_protocols: {protocols.get('allowed_protocols', 'NOT SET')}"
+                )
+                print(
+                    f"   - default_protocol: {protocols.get('default_protocol', 'NOT SET')}"
+                )
             else:
                 print("❌ Protocols section missing!")
             # Check SSL configuration
             ssl_enabled = config.get("ssl", {}).get("enabled", False)
-            security_ssl_enabled = config.get("security", {}).get("ssl", {}).get("enabled", False)
+            security_ssl_enabled = (
+                config.get("security", {}).get("ssl", {}).get("enabled", False)
+            )
             print(f"   - legacy ssl.enabled: {ssl_enabled}")
             print(f"   - security.ssl.enabled: {security_ssl_enabled}")
             # Check if configuration is valid for its type
-            if config_type == "https_no_protocol_middleware" or config_type == "mtls_no_protocol_middleware":
+            if (
+                config_type == "https_no_protocol_middleware"
+                or config_type == "mtls_no_protocol_middleware"
+            ):
                 if protocols.get("enabled") == False:
                     print("✅ ProtocolMiddleware correctly disabled")
                 else:
@@ -59,13 +71,15 @@ def test_config_generator():
                     print("❌ ProtocolMiddleware should be enabled but is disabled")
             # Save configuration to file for inspection
             output_file = f"test_config_{config_type}.json"
-            with open(output_file, 'w') as f:
+            with open(output_file, "w") as f:
                 json.dump(config, f, indent=2)
             print(f"   - Configuration saved to {output_file}")
         except Exception as e:
             print(f"❌ Error generating {config_type} configuration: {e}")
     print("\n" + "=" * 50)
     print("Configuration generator test completed!")
+
+
 def test_config_with_comments():
     """Test configuration generation with comments."""
     generator = ConfigGenerator()
@@ -76,11 +90,13 @@ def test_config_with_comments():
         commented_config = generator.generate_config_with_comments("https")
         print("✅ HTTPS configuration with comments generated successfully")
         # Save to file
-        with open("test_https_with_comments.json", 'w') as f:
+        with open("test_https_with_comments.json", "w") as f:
             f.write(commented_config)
         print("   - Configuration saved to test_https_with_comments.json")
     except Exception as e:
         print(f"❌ Error generating configuration with comments: {e}")
+
+
 if __name__ == "__main__":
     test_config_generator()
     test_config_with_comments()

mcp_proxy_adapter/examples/test_examples.py

@@ -12,6 +12,7 @@ import time
 import requests
 from pathlib import Path
 from typing import Dict, Any, List
+
 # Configuration for testing
 CONFIGS = {
     "basic_framework": {
@@ -20,7 +21,7 @@ CONFIGS = {
         "http_auth": {"port": 8001, "ssl": False, "auth": True},
         "https_auth": {"port": 8444, "ssl": True, "auth": True},
         "mtls_no_roles": {"port": 9443, "ssl": True, "auth": True, "mtls": True},
-        "mtls_with_roles": {"port": 9444, "ssl": True, "auth": True, "mtls": True}
+        "mtls_with_roles": {"port": 9444, "ssl": True, "auth": True, "mtls": True},
     },
     "full_application": {
         "http_simple": {"port": 9000, "ssl": False, "auth": False},
@@ -28,26 +29,28 @@ CONFIGS = {
         "http_auth": {"port": 9001, "ssl": False, "auth": True},
         "https_auth": {"port": 9446, "ssl": True, "auth": True},
         "mtls_no_roles": {"port": 9447, "ssl": True, "auth": True, "mtls": True},
-        "mtls_with_roles": {"port": 9448, "ssl": True, "auth": True, "mtls": True}
-    }
-}
-API_KEYS = {
-    "admin": "admin-secret-key-123",
-    "user": "user-secret-key-456"
+        "mtls_with_roles": {"port": 9448, "ssl": True, "auth": True, "mtls": True},
+    },
 }
+API_KEYS = {"admin": "admin-secret-key-123", "user": "user-secret-key-456"}
+
+
 class ExampleTester:
     """Test examples with different configurations."""
+
     def __init__(self):
         self.examples_dir = Path(__file__).parent
         self.results = {}
         self.processes = []
+
     def generate_certificates(self):
         """Generate certificates for testing."""
         print("🔐 Generating certificates...")
         cert_script = self.examples_dir.parent / "generate_certificates.py"
         if cert_script.exists():
-            result = subprocess.run([sys.executable, str(cert_script)],
-                                  capture_output=True, text=True)
+            result = subprocess.run(
+                [sys.executable, str(cert_script)], capture_output=True, text=True
+            )
             if result.returncode == 0:
                 print("✅ Certificates generated successfully")
                 return True
@@ -55,27 +58,31 @@ class ExampleTester:
                 print(f"❌ Certificate generation failed: {result.stderr}")
                 return False
         else:
-            print("⚠️ Certificate generation script not found, using existing certificates")
+            print(
+                "⚠️ Certificate generation script not found, using existing certificates"
+            )
             return True
+
     def start_server(self, example_type: str, config_name: str) -> subprocess.Popen:
         """Start a server with specific configuration."""
-        config_path = self.examples_dir / example_type / "configs" / f"{config_name}.json"
+        config_path = (
+            self.examples_dir / example_type / "configs" / f"{config_name}.json"
+        )
         main_script = self.examples_dir / example_type / "main.py"
         if not config_path.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_path}")
         if not main_script.exists():
             raise FileNotFoundError(f"Main script not found: {main_script}")
-        cmd = [
-            sys.executable, str(main_script),
-            "--config", str(config_path)
-        ]
+        cmd = [sys.executable, str(main_script), "--config", str(config_path)]
         print(f"🚀 Starting {example_type} server with {config_name} config...")
         process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         # Wait for server to start
         time.sleep(5)
         return process
-    def test_health_endpoint(self, port: int, ssl: bool = False, auth: bool = False,
-                           api_key: str = None) -> Dict[str, Any]:
+
+    def test_health_endpoint(
+        self, port: int, ssl: bool = False, auth: bool = False, api_key: str = None
+    ) -> Dict[str, Any]:
         """Test health endpoint."""
         protocol = "https" if ssl else "http"
         url = f"{protocol}://localhost:{port}/health"
@@ -87,15 +94,20 @@ class ExampleTester:
             return {
                 "success": True,
                 "status_code": response.status_code,
-                "response": response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text
+                "response": (
+                    response.json()
+                    if response.headers.get("content-type", "").startswith(
+                        "application/json"
+                    )
+                    else response.text
+                ),
             }
         except Exception as e:
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    def test_echo_command(self, port: int, ssl: bool = False, auth: bool = False,
-                         api_key: str = None) -> Dict[str, Any]:
+            return {"success": False, "error": str(e)}
+
+    def test_echo_command(
+        self, port: int, ssl: bool = False, auth: bool = False, api_key: str = None
+    ) -> Dict[str, Any]:
         """Test echo command."""
         protocol = "https" if ssl else "http"
         url = f"{protocol}://localhost:{port}/cmd"
@@ -106,22 +118,23 @@ class ExampleTester:
             "jsonrpc": "2.0",
             "method": "echo",
             "params": {"message": "Hello from test!"},
-            "id": 1
+            "id": 1,
         }
         try:
-            response = requests.post(url, json=data, headers=headers, verify=False, timeout=10)
+            response = requests.post(
+                url, json=data, headers=headers, verify=False, timeout=10
+            )
             return {
                 "success": True,
                 "status_code": response.status_code,
-                "response": response.json()
+                "response": response.json(),
             }
         except Exception as e:
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    def test_full_application_commands(self, port: int, ssl: bool = False, auth: bool = False,
-                                     api_key: str = None) -> Dict[str, Any]:
+            return {"success": False, "error": str(e)}
+
+    def test_full_application_commands(
+        self, port: int, ssl: bool = False, auth: bool = False, api_key: str = None
+    ) -> Dict[str, Any]:
         """Test full application specific commands."""
         protocol = "https" if ssl else "http"
         url = f"{protocol}://localhost:{port}/cmd"
@@ -134,40 +147,39 @@ class ExampleTester:
             "jsonrpc": "2.0",
             "method": "custom_echo",
             "params": {"message": "Custom echo test", "repeat": 3},
-            "id": 1
+            "id": 1,
         }
         try:
-            response = requests.post(url, json=data, headers=headers, verify=False, timeout=10)
+            response = requests.post(
+                url, json=data, headers=headers, verify=False, timeout=10
+            )
             results["custom_echo"] = {
                 "success": True,
                 "status_code": response.status_code,
-                "response": response.json()
+                "response": response.json(),
             }
         except Exception as e:
-            results["custom_echo"] = {
-                "success": False,
-                "error": str(e)
-            }
+            results["custom_echo"] = {"success": False, "error": str(e)}
         # Test dynamic calculator command
         data = {
             "jsonrpc": "2.0",
             "method": "dynamic_calculator",
             "params": {"operation": "add", "a": 10, "b": 5},
-            "id": 2
+            "id": 2,
         }
         try:
-            response = requests.post(url, json=data, headers=headers, verify=False, timeout=10)
+            response = requests.post(
+                url, json=data, headers=headers, verify=False, timeout=10
+            )
             results["dynamic_calculator"] = {
                 "success": True,
                 "status_code": response.status_code,
-                "response": response.json()
+                "response": response.json(),
             }
         except Exception as e:
-            results["dynamic_calculator"] = {
-                "success": False,
-                "error": str(e)
-            }
+            results["dynamic_calculator"] = {"success": False, "error": str(e)}
         return results
+
     def run_tests(self):
         """Run all tests."""
         print("🧪 Starting Example Tests")
@@ -196,30 +208,37 @@ class ExampleTester:
                     print(f"  📝 Testing echo command...")
                     if auth:
                         # Test with admin key
-                        echo_result = self.test_echo_command(port, ssl, auth, API_KEYS["admin"])
+                        echo_result = self.test_echo_command(
+                            port, ssl, auth, API_KEYS["admin"]
+                        )
                     else:
                         echo_result = self.test_echo_command(port, ssl, auth)
                     print(f"    Echo: {'✅' if echo_result['success'] else '❌'}")
                     # Test full application specific commands
                     if example_type == "full_application":
                         print(f"  🔧 Testing full application commands...")
-                        app_results = self.test_full_application_commands(port, ssl, auth,
-                                                                        API_KEYS["admin"] if auth else None)
+                        app_results = self.test_full_application_commands(
+                            port, ssl, auth, API_KEYS["admin"] if auth else None
+                        )
                         for cmd_name, result in app_results.items():
-                            print(f"    {cmd_name}: {'✅' if result['success'] else '❌'}")
+                            print(
+                                f"    {cmd_name}: {'✅' if result['success'] else '❌'}"
+                            )
                     # Store results
                     self.results[f"{example_type}_{config_name}"] = {
                         "health": health_result,
                         "echo": echo_result,
-                        "config_info": config_info
+                        "config_info": config_info,
                     }
                     if example_type == "full_application":
-                        self.results[f"{example_type}_{config_name}"]["app_commands"] = app_results
+                        self.results[f"{example_type}_{config_name}"][
+                            "app_commands"
+                        ] = app_results
                 except Exception as e:
                     print(f"  ❌ Error testing {config_name}: {e}")
                     self.results[f"{example_type}_{config_name}"] = {
                         "error": str(e),
-                        "config_info": config_info
+                        "config_info": config_info,
                     }
                 finally:
                     # Stop server
@@ -228,6 +247,7 @@ class ExampleTester:
                         process.wait()
                         time.sleep(2)
         self.print_results()
+
     def print_results(self):
         """Print test results."""
         print("\n📊 Test Results Summary")
@@ -247,8 +267,10 @@ class ExampleTester:
             print(f"  Echo: {'✅' if echo_success else '❌'}")
             # Check app commands for full application
             if "app_commands" in result:
-                app_success = all(cmd_result.get("success", False)
-                                for cmd_result in result["app_commands"].values())
+                app_success = all(
+                    cmd_result.get("success", False)
+                    for cmd_result in result["app_commands"].values()
+                )
                 print(f"  App Commands: {'✅' if app_success else '❌'}")
             # Overall test success
             test_success = health_success and echo_success
@@ -259,15 +281,19 @@ class ExampleTester:
             print("🎉 All tests passed!")
         else:
             print("⚠️ Some tests failed. Check the details above.")
+
     def cleanup(self):
         """Cleanup processes."""
         for process in self.processes:
             if process.poll() is None:
                 process.terminate()
                 process.wait()
+
+
 def main():
     """Main function."""
     import sys
+
     tester = ExampleTester()
     try:
         tester.run_tests()
@@ -277,5 +303,7 @@ def main():
         print(f"\n❌ Test execution failed: {e}")
     finally:
         tester.cleanup()
+
+
 if __name__ == "__main__":
     main()