mcp-proxy-adapter 6.1.1__py3-none-any.whl → 6.2.0__py3-none-any.whl

mcp_proxy_adapter/examples/basic_framework/main.py

@@ -1,63 +1,44 @@
 #!/usr/bin/env python3
 """
-Basic Framework Example Application
-
-This is a simple application that demonstrates the basic usage of MCP Proxy Adapter framework.
-
+Basic Framework Example
+This example demonstrates the basic usage of the MCP Proxy Adapter framework
+with minimal configuration and built-in commands.
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import sys
 import argparse
 from pathlib import Path
-
 # Add the framework to the path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from mcp_proxy_adapter.api.app import create_app
-from mcp_proxy_adapter.config import Config
-
-
+from mcp_proxy_adapter.core.app_factory import create_and_run_server
 def main():
     """Main entry point for the basic framework example."""
     parser = argparse.ArgumentParser(description="Basic Framework Example")
     parser.add_argument("--config", "-c", required=True, help="Path to configuration file")
-    parser.add_argument("--host", default="0.0.0.0", help="Server host")
-    parser.add_argument("--port", type=int, help="Server port (overrides config)")
+    parser.add_argument("--host", help="Server host")
+    parser.add_argument("--port", type=int, help="Server port")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-    
     args = parser.parse_args()
-    
-    # Load configuration
-    config = Config(args.config)
-    
-    # Override port if specified
+    # Override configuration if specified
+    config_overrides = {}
+    if args.host:
+        config_overrides["host"] = args.host
     if args.port:
-        config.set("server.port", args.port)
-    
-    # Override debug if specified
+        config_overrides["port"] = args.port
     if args.debug:
-        config.set("server.debug", True)
-    
-    # Create application
-    app = create_app(app_config=config)
-    
-    # Get server configuration
-    host = config.get("server.host", "0.0.0.0")
-    port = config.get("server.port", 8000)
-    debug = config.get("server.debug", False)
-    
+        config_overrides["debug"] = True
     print(f"🚀 Starting Basic Framework Example")
     print(f"📋 Configuration: {args.config}")
-    print(f"🌐 Server: {host}:{port}")
-    print(f"🔧 Debug: {debug}")
     print("=" * 50)
-    
-    # Import uvicorn here to avoid dependency issues
-    import uvicorn
-    uvicorn.run(app, host=host, port=port, log_level="info")
-
-
+    # Use the factory method to create and run the server
+    create_and_run_server(
+        config_path=args.config,
+        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"
+    )
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/commands/__init__.py

@@ -1 +1,5 @@
-# Commands package
+"""Example Commands Package.
+
+This package contains example command implementations demonstrating
+various patterns for creating custom commands in MCP Proxy Adapter.
+"""

mcp_proxy_adapter/examples/create_certificates_simple.py

@@ -1,38 +1,50 @@
 #!/usr/bin/env python3
 """
 Simple Certificate Creation Script
-
-This script creates basic certificates for testing using OpenSSL directly.
-
+This script creates basic certificates for testing using mcp_security_framework.
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import os
 import subprocess
 import sys
+import argparse
 from pathlib import Path
-
-
+# Import mcp_security_framework
+try:
+    from mcp_security_framework.core.cert_manager import CertificateManager
+    from mcp_security_framework.schemas.config import CertificateConfig, CAConfig, ServerCertConfig, ClientCertConfig
+    from mcp_security_framework.schemas.models import CertificateType
+    SECURITY_FRAMEWORK_AVAILABLE = True
+except ImportError:
+    SECURITY_FRAMEWORK_AVAILABLE = False
+    print("Warning: mcp_security_framework not available, falling back to OpenSSL")
 class SimpleCertificateCreator:
     """Create certificates using OpenSSL directly."""
-    
-    def __init__(self):
-        self.project_root = Path(__file__).parent.parent.parent
-        self.certs_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "certs"
-        self.keys_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "keys"
-        
+    def __init__(self, certs_dir: str = None, keys_dir: str = None):
+        if certs_dir:
+            self.certs_dir = Path(certs_dir).resolve()
+        else:
+            self.project_root = Path(__file__).parent.parent.parent
+            self.certs_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "certs"
+        if keys_dir:
+            self.keys_dir = Path(keys_dir).resolve()
+        else:
+            if not certs_dir:
+                self.project_root = Path(__file__).parent.parent.parent
+            self.keys_dir = self.project_root / "mcp_proxy_adapter" / "examples" / "keys"
         # Create directories
         self.certs_dir.mkdir(parents=True, exist_ok=True)
         self.keys_dir.mkdir(parents=True, exist_ok=True)
-    
+        print(f"🔧 Using certificates directory: {self.certs_dir}")
+        print(f"🔧 Using keys directory: {self.keys_dir}")
     def run_command(self, cmd: list, description: str) -> bool:
         """Run a command and handle errors."""
         try:
             print(f"🔧 {description}...")
+            # Use current working directory instead of project_root
             result = subprocess.run(
                 cmd,
-                cwd=self.project_root,
                 capture_output=True,
                 text=True,
                 check=True
@@ -47,23 +59,73 @@ class SimpleCertificateCreator:
         except Exception as e:
             print(f"❌ {description} failed: {e}")
             return False
-    
     def create_ca_certificate(self) -> bool:
-        """Create CA certificate using OpenSSL."""
+        """Create CA certificate using mcp_security_framework or OpenSSL fallback."""
         ca_cert_path = self.certs_dir / "ca_cert.pem"
         ca_key_path = self.keys_dir / "ca_key.pem"
-        
         if ca_cert_path.exists() and ca_key_path.exists():
             print(f"ℹ️ CA certificate already exists: {ca_cert_path}")
             return True
-        
+        if SECURITY_FRAMEWORK_AVAILABLE:
+            return self._create_ca_certificate_with_framework()
+        else:
+            return self._create_ca_certificate_with_openssl()
+    def _create_ca_certificate_with_framework(self) -> bool:
+        """Create CA certificate using mcp_security_framework."""
+        try:
+            print("🔧 Creating CA certificate using mcp_security_framework...")
+            # Create CA certificate configuration
+            ca_config = CAConfig(
+                common_name="mcp_proxy_adapter_test_ca",
+                organization="Test Organization",
+                organizational_unit="Test Unit",
+                country="US",
+                state="Test State",
+                locality="Test City",
+                validity_years=10
+            )
+            # Create certificate manager
+            cert_config = CertificateConfig(
+                cert_storage_path=str(self.certs_dir),
+                key_storage_path=str(self.keys_dir),
+                default_validity_days=365,
+                key_size=2048,
+                hash_algorithm="sha256"
+            )
+            cert_manager = CertificateManager(cert_config)
+            # Create CA certificate
+            cert_pair = cert_manager.create_root_ca(ca_config)
+            if cert_pair and cert_pair.certificate_path and cert_pair.private_key_path:
+                # Rename the generated files to the expected names
+                generated_cert = Path(cert_pair.certificate_path)
+                generated_key = Path(cert_pair.private_key_path)
+                if generated_cert.exists() and generated_key.exists():
+                    # Move to expected names
+                    expected_cert = self.certs_dir / "ca_cert.pem"
+                    expected_key = self.keys_dir / "ca_key.pem"
+                    generated_cert.rename(expected_cert)
+                    generated_key.rename(expected_key)
+                    print("✅ CA certificate created successfully using mcp_security_framework")
+                    return True
+                else:
+                    print("❌ Generated CA certificate files not found")
+                    return False
+            else:
+                print("❌ Failed to create CA certificate: Invalid certificate pair")
+                return False
+        except Exception as e:
+            print(f"❌ Error creating CA certificate with framework: {e}")
+            return False
+    def _create_ca_certificate_with_openssl(self) -> bool:
+        """Create CA certificate using OpenSSL fallback."""
+        ca_cert_path = self.certs_dir / "ca_cert.pem"
+        ca_key_path = self.keys_dir / "ca_key.pem"
         # Create CA private key
         key_cmd = [
             "openssl", "genrsa", "-out", str(ca_key_path), "2048"
         ]
         if not self.run_command(key_cmd, "Creating CA private key"):
             return False
-        
         # Create CA certificate
         cert_cmd = [
             "openssl", "req", "-new", "-x509", "-days", "3650",
@@ -72,23 +134,97 @@ class SimpleCertificateCreator:
             "-subj", "/C=US/ST=Test State/L=Test City/O=Test Organization/CN=MCP Proxy Adapter Test CA"
         ]
         return self.run_command(cert_cmd, "Creating CA certificate")
-    
     def create_server_certificate(self) -> bool:
-        """Create server certificate using OpenSSL."""
+        """Create server certificate using mcp_security_framework or OpenSSL fallback."""
         server_cert_path = self.certs_dir / "server_cert.pem"
         server_key_path = self.certs_dir / "server_key.pem"
-        
         if server_cert_path.exists() and server_key_path.exists():
-            print(f"ℹ️ Server certificate already exists: {server_cert_path}")
+            print("ℹ️ Server certificate already exists")
             return True
-        
+        if SECURITY_FRAMEWORK_AVAILABLE:
+            return self._create_server_certificate_with_framework()
+        else:
+            return self._create_server_certificate_with_openssl()
+    def _create_server_certificate_with_framework(self) -> bool:
+        """Create server certificate using mcp_security_framework."""
+        try:
+            print("🔧 Creating server certificate using mcp_security_framework...")
+            # Find CA certificate and key files
+            ca_cert_path = None
+            ca_key_path = None
+            # Look for CA certificate files with expected names
+            expected_ca_cert = self.certs_dir / "ca_cert.pem"
+            expected_ca_key = self.keys_dir / "ca_key.pem"
+            if expected_ca_cert.exists():
+                ca_cert_path = str(expected_ca_cert)
+            else:
+                # Fallback: look for CA certificate files with pattern
+                for cert_file in self.certs_dir.glob("*_ca.crt"):
+                    ca_cert_path = str(cert_file)
+                    break
+            if expected_ca_key.exists():
+                ca_key_path = str(expected_ca_key)
+            else:
+                # Fallback: look for CA key files with pattern
+                for key_file in self.keys_dir.glob("*_ca.key"):
+                    ca_key_path = str(key_file)
+                    break
+            if not ca_cert_path or not ca_key_path:
+                print("❌ CA certificate or key not found")
+                return False
+            # Create server certificate configuration
+            server_config = ServerCertConfig(
+                common_name="localhost",
+                organization="Test Organization",
+                organizational_unit="Test Unit",
+                country="US",
+                state="Test State",
+                locality="Test City",
+                subject_alt_names=["localhost", "127.0.0.1"],
+                validity_years=1,
+                ca_cert_path=ca_cert_path,
+                ca_key_path=ca_key_path
+            )
+            # Create certificate manager
+            cert_config = CertificateConfig(
+                cert_storage_path=str(self.certs_dir),
+                key_storage_path=str(self.certs_dir),  # Server keys in certs dir
+                default_validity_days=365,
+                key_size=2048,
+                hash_algorithm="sha256"
+            )
+            cert_manager = CertificateManager(cert_config)
+            # Create server certificate
+            cert_pair = cert_manager.create_server_certificate(server_config)
+            if cert_pair and cert_pair.certificate_path and cert_pair.private_key_path:
+                # Rename the generated files to the expected names
+                generated_cert = Path(cert_pair.certificate_path)
+                generated_key = Path(cert_pair.private_key_path)
+                if generated_cert.exists() and generated_key.exists():
+                    # Move to expected names
+                    generated_cert.rename(self.certs_dir / "server_cert.pem")
+                    generated_key.rename(self.certs_dir / "server_key.pem")
+                    print("✅ Server certificate created successfully using mcp_security_framework")
+                    return True
+                else:
+                    print("❌ Generated certificate files not found")
+                    return False
+            else:
+                print("❌ Failed to create server certificate: Invalid certificate pair")
+                return False
+        except Exception as e:
+            print(f"❌ Error creating server certificate with framework: {e}")
+            return False
+    def _create_server_certificate_with_openssl(self) -> bool:
+        """Create server certificate using OpenSSL fallback."""
+        server_cert_path = self.certs_dir / "server_cert.pem"
+        server_key_path = self.certs_dir / "server_key.pem"
         # Create server private key
         key_cmd = [
             "openssl", "genrsa", "-out", str(server_key_path), "2048"
         ]
         if not self.run_command(key_cmd, "Creating server private key"):
             return False
-        
         # Create server certificate signing request
         csr_path = self.certs_dir / "server.csr"
         csr_cmd = [
@@ -99,7 +235,6 @@ class SimpleCertificateCreator:
         ]
         if not self.run_command(csr_cmd, "Creating server CSR"):
             return False
-        
         # Create server certificate
         cert_cmd = [
             "openssl", "x509", "-req", "-days", "730",
@@ -110,29 +245,102 @@ class SimpleCertificateCreator:
             "-out", str(server_cert_path)
         ]
         success = self.run_command(cert_cmd, "Creating server certificate")
-        
         # Clean up CSR
         if csr_path.exists():
             csr_path.unlink()
-        
         return success
-    
-    def create_client_certificate(self, name: str, common_name: str) -> bool:
-        """Create client certificate using OpenSSL."""
+    def create_client_certificate(self, name: str, common_name: str, roles: list = None, permissions: list = None) -> bool:
+        """Create client certificate using mcp_security_framework or OpenSSL fallback."""
         cert_path = self.certs_dir / f"{name}_cert.pem"
         key_path = self.certs_dir / f"{name}_key.pem"
-        
         if cert_path.exists() and key_path.exists():
             print(f"ℹ️ Client certificate {name} already exists: {cert_path}")
             return True
-        
+        if SECURITY_FRAMEWORK_AVAILABLE:
+            return self._create_client_certificate_with_framework(name, common_name, roles, permissions)
+        else:
+            return self._create_client_certificate_with_openssl(name, common_name)
+    def _create_client_certificate_with_framework(self, name: str, common_name: str, roles: list = None, permissions: list = None) -> bool:
+        """Create client certificate using mcp_security_framework."""
+        try:
+            print(f"🔧 Creating client certificate {name} using mcp_security_framework...")
+            # Find CA certificate and key files
+            ca_cert_path = None
+            ca_key_path = None
+            # Look for CA certificate files with expected names
+            expected_ca_cert = self.certs_dir / "ca_cert.pem"
+            expected_ca_key = self.keys_dir / "ca_key.pem"
+            if expected_ca_cert.exists():
+                ca_cert_path = str(expected_ca_cert)
+            else:
+                # Fallback: look for CA certificate files with pattern
+                for cert_file in self.certs_dir.glob("*_ca.crt"):
+                    ca_cert_path = str(cert_file)
+                    break
+            if expected_ca_key.exists():
+                ca_key_path = str(expected_ca_key)
+            else:
+                # Fallback: look for CA key files with pattern
+                for key_file in self.keys_dir.glob("*_ca.key"):
+                    ca_key_path = str(key_file)
+                    break
+            if not ca_cert_path or not ca_key_path:
+                print("❌ CA certificate or key not found")
+                return False
+            # Create client certificate configuration
+            client_config = ClientCertConfig(
+                common_name=common_name,
+                organization="Test Organization",
+                organizational_unit="Test Unit",
+                country="US",
+                state="Test State",
+                locality="Test City",
+                validity_years=1,
+                ca_cert_path=ca_cert_path,
+                ca_key_path=ca_key_path
+            )
+            # Create certificate manager
+            cert_config = CertificateConfig(
+                cert_storage_path=str(self.certs_dir),
+                key_storage_path=str(self.certs_dir),  # Client keys in certs dir
+                default_validity_days=365,
+                key_size=2048,
+                hash_algorithm="sha256"
+            )
+            cert_manager = CertificateManager(cert_config)
+            # Create client certificate
+            cert_pair = cert_manager.create_client_certificate(client_config)
+            if cert_pair and cert_pair.certificate_path and cert_pair.private_key_path:
+                # Rename the generated files to the expected names
+                generated_cert = Path(cert_pair.certificate_path)
+                generated_key = Path(cert_pair.private_key_path)
+                if generated_cert.exists() and generated_key.exists():
+                    # Move to expected names
+                    expected_cert = self.certs_dir / f"{name}_cert.pem"
+                    expected_key = self.certs_dir / f"{name}_key.pem"
+                    generated_cert.rename(expected_cert)
+                    generated_key.rename(expected_key)
+                    print(f"✅ Client certificate {name} created successfully using mcp_security_framework")
+                    return True
+                else:
+                    print(f"❌ Generated certificate files not found for {name}")
+                    return False
+            else:
+                print(f"❌ Failed to create client certificate {name}: Invalid certificate pair")
+                return False
+        except Exception as e:
+            print(f"❌ Error creating client certificate {name} with framework: {e}")
+            return False
+    def _create_client_certificate_with_openssl(self, name: str, common_name: str) -> bool:
+        """Create client certificate using OpenSSL fallback."""
+        cert_path = self.certs_dir / f"{name}_cert.pem"
+        key_path = self.certs_dir / f"{name}_key.pem"
         # Create client private key
         key_cmd = [
             "openssl", "genrsa", "-out", str(key_path), "2048"
         ]
         if not self.run_command(key_cmd, f"Creating {name} private key"):
             return False
-        
         # Create client certificate signing request
         csr_path = self.certs_dir / f"{name}.csr"
         csr_cmd = [
@@ -143,7 +351,6 @@ class SimpleCertificateCreator:
         ]
         if not self.run_command(csr_cmd, f"Creating {name} CSR"):
             return False
-        
         # Create client certificate
         cert_cmd = [
             "openssl", "x509", "-req", "-days", "730",
@@ -154,45 +361,36 @@ class SimpleCertificateCreator:
             "-out", str(cert_path)
         ]
         success = self.run_command(cert_cmd, f"Creating {name} certificate")
-        
         # Clean up CSR
         if csr_path.exists():
             csr_path.unlink()
-        
         return success
-    
     def create_legacy_certificates(self) -> bool:
         """Create legacy certificate files for compatibility."""
         legacy_files = [
-            ("client.crt", "client.key", "client"),
             ("client_admin.crt", "client_admin.key", "admin"),
             ("admin.crt", "admin.key", "admin"),
             ("user.crt", "user.key", "user"),
             ("readonly.crt", "readonly.key", "readonly")
         ]
-        
         success = True
         for cert_file, key_file, source_name in legacy_files:
             cert_path = self.certs_dir / cert_file
             key_path = self.certs_dir / key_file
-            
             if not cert_path.exists() or not key_path.exists():
                 source_cert = self.certs_dir / f"{source_name}_cert.pem"
                 source_key = self.certs_dir / f"{source_name}_key.pem"
-                
                 if source_cert.exists() and source_key.exists():
                     self.run_command(["cp", str(source_cert), str(cert_path)], f"Creating {cert_file}")
                     self.run_command(["cp", str(source_key), str(key_path)], f"Creating {key_file}")
                 else:
                     print(f"⚠️ Source certificate {source_name} not found for {cert_file}")
-                    success = False
-        
-        return success
-    
+                    # Don't fail the entire process for missing legacy certificates
+                    continue
+        return True  # Always return True for legacy certificates
     def validate_certificates(self) -> bool:
         """Validate all created certificates."""
         print("\n🔍 Validating certificates...")
-        
         cert_files = [
             "ca_cert.pem",
             "server_cert.pem",
@@ -202,7 +400,6 @@ class SimpleCertificateCreator:
             "guest_cert.pem",
             "proxy_cert.pem"
         ]
-        
         success = True
         for cert_file in cert_files:
             cert_path = self.certs_dir / cert_file
@@ -220,78 +417,68 @@ class SimpleCertificateCreator:
                     success = False
             else:
                 print(f"⚠️ {cert_file}: Not found")
-        
         return success
-    
     def create_all(self) -> bool:
         """Create all certificates."""
         print("🔐 Creating All Certificates for Security Testing")
         print("=" * 60)
-        
         success = True
-        
         # 1. Create CA certificate
         if not self.create_ca_certificate():
             success = False
             print("❌ Cannot continue without CA certificate")
             return False
-        
         # 2. Create server certificate
         if not self.create_server_certificate():
             success = False
-        
         # 3. Create client certificates
         print("\n👥 Creating client certificates...")
         client_certs = [
-            ("admin", "admin-client"),
-            ("user", "user-client"),
-            ("readonly", "readonly-client"),
-            ("guest", "guest-client"),
-            ("proxy", "proxy-client")
+            ("admin", "admin-client", ["admin"], ["read", "write", "execute", "delete", "admin", "register", "unregister", "heartbeat", "discover"]),
+            ("user", "user-client", ["user"], ["read", "execute", "register", "unregister", "heartbeat", "discover"]),
+            ("readonly", "readonly-client", ["readonly"], ["read", "discover"]),
+            ("guest", "guest-client", ["guest"], ["read", "discover"]),
+            ("proxy", "proxy-client", ["proxy"], ["register", "unregister", "heartbeat", "discover"])
         ]
-        
-        for name, common_name in client_certs:
-            if not self.create_client_certificate(name, common_name):
+        for name, common_name, roles, permissions in client_certs:
+            if not self.create_client_certificate(name, common_name, roles, permissions):
                 success = False
-        
         # 4. Create legacy certificates
         print("\n🔄 Creating legacy certificates...")
         if not self.create_legacy_certificates():
             success = False
-        
         # 5. Validate certificates
         if not self.validate_certificates():
             success = False
-        
         # Print summary
         print("\n" + "=" * 60)
         print("📊 CERTIFICATE CREATION SUMMARY")
         print("=" * 60)
-        
         if success:
             print("✅ All certificates created successfully!")
             print(f"📁 Certificates directory: {self.certs_dir}")
             print(f"🔑 Keys directory: {self.keys_dir}")
             print("\n📋 Created certificates:")
-            
             cert_files = list(self.certs_dir.glob("*.pem")) + list(self.certs_dir.glob("*.crt"))
             for cert_file in sorted(cert_files):
                 print(f"   - {cert_file.name}")
-            
             key_files = list(self.keys_dir.glob("*.pem")) + list(self.keys_dir.glob("*.key"))
             for key_file in sorted(key_files):
                 print(f"   - {key_file.name}")
         else:
             print("❌ Some certificates failed to create")
             print("Check the error messages above")
-        
         return success
-
-
 def main():
     """Main function."""
-    creator = SimpleCertificateCreator()
-    
+    parser = argparse.ArgumentParser(description="Create certificates for testing")
+    parser.add_argument("--certs-dir", help="Directory for certificates")
+    parser.add_argument("--keys-dir", help="Directory for keys")
+    args = parser.parse_args()
+    creator = SimpleCertificateCreator(
+        certs_dir=args.certs_dir,
+        keys_dir=args.keys_dir
+    )
     try:
         success = creator.create_all()
         sys.exit(0 if success else 1)
@@ -301,7 +488,5 @@ def main():
     except Exception as e:
         print(f"\n❌ Certificate creation failed: {e}")
         sys.exit(1)
-
-
 if __name__ == "__main__":
     main()