mcp-proxy-adapter 6.8.2__py3-none-any.whl → 6.9.1__py3-none-any.whl

mcp_proxy_adapter/examples/full_application/main.py

@@ -28,12 +28,20 @@ class FullApplication:
 
     def __init__(self, config_path: str):
         self.config_path = config_path
-        self.config = Config(config_path)
+        try:
+            self.config = Config(config_path, validate_on_load=True)
+            self.logger = logging.getLogger(__name__)
+            self.logger.info("✅ Configuration loaded and validated successfully")
+        except Exception as e:
+            logging.basicConfig(level=logging.ERROR)
+            self.logger = logging.getLogger(__name__)
+            self.logger.error(f"❌ Configuration error: {e}")
+            raise
+        
         self.app = None
         self.command_registry = None
         # Setup logging
         logging.basicConfig(level=logging.INFO)
-        self.logger = logging.getLogger(__name__)
 
     def setup_hooks(self):
         """Setup application hooks."""

mcp_proxy_adapter/examples/full_application/run_mtls.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""
+mTLS Full Application Runner
+Runs the full application example with mTLS configuration.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import sys
+import argparse
+import logging
+import json
+import ssl
+import socket
+from pathlib import Path
+
+# Add the framework to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
+
+def validate_mtls_config(config_path: str) -> bool:
+    """Validate mTLS configuration file."""
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        # Check required sections
+        required_sections = [
+            'uuid', 'server', 'logging', 'commands', 'transport',
+            'proxy_registration', 'debug', 'security', 'roles', 'ssl'
+        ]
+        
+        missing_sections = []
+        for section in required_sections:
+            if section not in config:
+                missing_sections.append(section)
+        
+        if missing_sections:
+            print(f"❌ Missing required sections: {missing_sections}")
+            return False
+        
+        # Check SSL configuration
+        ssl_config = config.get('ssl', {})
+        if not ssl_config.get('enabled', False):
+            print("❌ SSL must be enabled for mTLS")
+            return False
+        
+        # Check certificate files
+        cert_file = ssl_config.get('cert_file')
+        key_file = ssl_config.get('key_file')
+        ca_cert_file = ssl_config.get('ca_cert_file')
+        
+        if not cert_file or not key_file or not ca_cert_file:
+            print("❌ SSL configuration missing certificate files")
+            return False
+        
+        # Check if certificate files exist
+        cert_path = Path(cert_file)
+        key_path = Path(key_file)
+        ca_path = Path(ca_cert_file)
+        
+        if not cert_path.exists():
+            print(f"❌ Certificate file not found: {cert_file}")
+            return False
+        
+        if not key_path.exists():
+            print(f"❌ Key file not found: {key_file}")
+            return False
+        
+        if not ca_path.exists():
+            print(f"❌ CA certificate file not found: {ca_cert_file}")
+            return False
+        
+        print("✅ mTLS Configuration validation passed")
+        return True
+        
+    except FileNotFoundError:
+        print(f"❌ Configuration file not found: {config_path}")
+        return False
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON in configuration: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Configuration validation error: {e}")
+        return False
+
+def test_mtls_connection(config_path: str):
+    """Test mTLS connection to the server."""
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        server_config = config.get('server', {})
+        host = server_config.get('host', '0.0.0.0')
+        port = server_config.get('port', 8443)
+        
+        ssl_config = config.get('ssl', {})
+        cert_file = ssl_config.get('cert_file')
+        key_file = ssl_config.get('key_file')
+        ca_cert_file = ssl_config.get('ca_cert_file')
+        
+        print(f"🔐 Testing mTLS connection to {host}:{port}")
+        
+        # Create SSL context
+        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        context.load_cert_chain(cert_file, key_file)
+        context.load_verify_locations(ca_cert_file)
+        context.verify_mode = ssl.CERT_REQUIRED
+        
+        # Test connection
+        with socket.create_connection((host, port), timeout=5) as sock:
+            with context.wrap_socket(sock, server_hostname=host) as ssock:
+                print(f"✅ mTLS connection successful")
+                print(f"🔒 Cipher: {ssock.cipher()}")
+                print(f"📜 Protocol: {ssock.version()}")
+                return True
+                
+    except Exception as e:
+        print(f"❌ mTLS connection failed: {e}")
+        return False
+
+def run_mtls_application(config_path: str):
+    """Run the mTLS application example."""
+    print("🚀 Starting mTLS Full Application Example")
+    print(f"📁 Configuration: {config_path}")
+    
+    # Validate configuration
+    if not validate_mtls_config(config_path):
+        print("❌ mTLS Configuration validation failed")
+        return False
+    
+    # Load configuration
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        server_config = config.get('server', {})
+        host = server_config.get('host', '0.0.0.0')
+        port = server_config.get('port', 8443)
+        protocol = server_config.get('protocol', 'https')
+        
+        ssl_config = config.get('ssl', {})
+        proxy_config = config.get('proxy_registration', {})
+        
+        print(f"🌐 Server: {host}:{port}")
+        print(f"🔗 Protocol: {protocol}")
+        print(f"🔒 SSL: {'Enabled' if ssl_config.get('enabled', False) else 'Disabled'}")
+        print(f"🔐 mTLS: {'Enabled' if ssl_config.get('verify_client', False) else 'Disabled'}")
+        print(f"🔒 Security: {'Enabled' if config.get('security', {}).get('enabled', False) else 'Disabled'}")
+        print(f"👥 Roles: {'Enabled' if config.get('roles', {}).get('enabled', False) else 'Disabled'}")
+        print(f"🌐 Proxy Registration: {'Enabled' if proxy_config.get('enabled', False) else 'Disabled'}")
+        
+        if proxy_config.get('enabled', False):
+            proxy_url = proxy_config.get('proxy_url', 'https://localhost:3004')
+            server_id = proxy_config.get('server_id', 'unknown')
+            print(f"📡 Proxy URL: {proxy_url}")
+            print(f"🆔 Server ID: {server_id}")
+        
+        # Simulate application startup
+        print("\n🔧 Setting up mTLS application components...")
+        print("✅ Configuration loaded and validated")
+        print("✅ SSL/TLS certificates loaded")
+        print("✅ mTLS context created")
+        print("✅ Logging configured")
+        print("✅ Command registry initialized")
+        print("✅ Transport layer configured with mTLS")
+        print("✅ Security layer configured")
+        print("✅ Proxy registration configured")
+        
+        if proxy_config.get('enabled', False):
+            print("✅ Proxy registration enabled")
+            print(f"📡 Will register with proxy at: {proxy_config.get('proxy_url')}")
+            print(f"🆔 Server ID: {proxy_config.get('server_id')}")
+        
+        print(f"\n🎉 mTLS Full Application Example started successfully!")
+        print(f"📡 Server listening on {host}:{port}")
+        print(f"🌐 Access via: {protocol}://{host}:{port}")
+        print("\n📋 Available features:")
+        print("  - Built-in commands (health, echo, list, help)")
+        print("  - Custom commands (custom_echo, dynamic_calculator)")
+        print("  - Application hooks")
+        print("  - Command hooks")
+        print("  - Proxy endpoints")
+        print("  - mTLS authentication")
+        print("  - Security (if enabled)")
+        print("  - Role management (if enabled)")
+        
+        print("\n🔐 mTLS Configuration:")
+        print(f"  - Certificate: {ssl_config.get('cert_file')}")
+        print(f"  - Private Key: {ssl_config.get('key_file')}")
+        print(f"  - CA Certificate: {ssl_config.get('ca_cert_file')}")
+        print(f"  - Client Verification: {'Required' if ssl_config.get('verify_client', False) else 'Optional'}")
+        print(f"  - Ciphers: {ssl_config.get('ciphers', 'Default')}")
+        print(f"  - Protocols: {ssl_config.get('protocols', 'Default')}")
+        
+        print("\n✅ mTLS Application simulation completed successfully")
+        print("💡 In a real application, the mTLS server would be running here")
+        return True
+            
+    except Exception as e:
+        print(f"❌ Application startup error: {e}")
+        return False
+
+def main():
+    """Main function."""
+    parser = argparse.ArgumentParser(
+        description="Run mTLS Full Application Example",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python run_mtls.py --config configs/mtls_no_roles_correct.json
+  python run_mtls.py --config configs/mtls_with_roles_correct.json
+  python run_mtls.py --config configs/mtls_no_roles_correct.json --test-connection
+        """
+    )
+    
+    parser.add_argument(
+        "--config",
+        default="configs/mtls_no_roles_correct.json",
+        help="Configuration file path"
+    )
+    
+    parser.add_argument(
+        "--test-connection",
+        action="store_true",
+        help="Test mTLS connection"
+    )
+    
+    args = parser.parse_args()
+    
+    # Check if config file exists
+    config_path = Path(args.config)
+    if not config_path.exists():
+        print(f"❌ Configuration file not found: {config_path}")
+        print("💡 Available mTLS configurations:")
+        configs_dir = Path("configs")
+        if configs_dir.exists():
+            for config_file in configs_dir.glob("*mtls*.json"):
+                print(f"  - {config_file}")
+        return 1
+    
+    # Test connection if requested
+    if args.test_connection:
+        success = test_mtls_connection(str(config_path))
+        return 0 if success else 1
+    
+    # Run application
+    success = run_mtls_application(str(config_path))
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/examples/full_application/run_simple.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+Simple Full Application Runner
+Runs the full application example without complex imports.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import sys
+import argparse
+import logging
+import json
+from pathlib import Path
+
+# Add the framework to the path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
+
+def validate_config(config_path: str) -> bool:
+    """Validate configuration file."""
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        # Check required sections
+        required_sections = [
+            'uuid', 'server', 'logging', 'commands', 'transport',
+            'proxy_registration', 'debug', 'security', 'roles'
+        ]
+        
+        missing_sections = []
+        for section in required_sections:
+            if section not in config:
+                missing_sections.append(section)
+        
+        if missing_sections:
+            print(f"❌ Missing required sections: {missing_sections}")
+            return False
+        
+        # Check server section
+        server = config.get('server', {})
+        if 'host' not in server or 'port' not in server:
+            print("❌ Server section missing host or port")
+            return False
+        
+        print("✅ Configuration validation passed")
+        return True
+        
+    except FileNotFoundError:
+        print(f"❌ Configuration file not found: {config_path}")
+        return False
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON in configuration: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Configuration validation error: {e}")
+        return False
+
+def run_application(config_path: str):
+    """Run the full application example."""
+    print("🚀 Starting Full Application Example")
+    print(f"📁 Configuration: {config_path}")
+    
+    # Validate configuration
+    if not validate_config(config_path):
+        print("❌ Configuration validation failed")
+        return False
+    
+    # Load configuration
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        
+        server_config = config.get('server', {})
+        host = server_config.get('host', '0.0.0.0')
+        port = server_config.get('port', 8000)
+        protocol = server_config.get('protocol', 'http')
+        
+        print(f"🌐 Server: {host}:{port}")
+        print(f"🔗 Protocol: {protocol}")
+        print(f"🔒 Security: {'Enabled' if config.get('security', {}).get('enabled', False) else 'Disabled'}")
+        print(f"👥 Roles: {'Enabled' if config.get('roles', {}).get('enabled', False) else 'Disabled'}")
+        
+        # Simulate application startup
+        print("\n🔧 Setting up application components...")
+        print("✅ Configuration loaded")
+        print("✅ Logging configured")
+        print("✅ Command registry initialized")
+        print("✅ Transport layer configured")
+        print("✅ Security layer configured")
+        print("✅ Proxy registration configured")
+        
+        print(f"\n🎉 Full Application Example started successfully!")
+        print(f"📡 Server listening on {host}:{port}")
+        print(f"🌐 Access via: {protocol}://{host}:{port}")
+        print("\n📋 Available features:")
+        print("  - Built-in commands (health, echo, list, help)")
+        print("  - Custom commands (custom_echo, dynamic_calculator)")
+        print("  - Application hooks")
+        print("  - Command hooks")
+        print("  - Proxy endpoints")
+        print("  - Security (if enabled)")
+        print("  - Role management (if enabled)")
+        
+        print("\n🛑 Press Ctrl+C to stop the server")
+        
+        # Simulate running server (non-blocking)
+        print("✅ Server simulation completed successfully")
+        print("💡 In a real application, the server would be running here")
+        return True
+            
+    except Exception as e:
+        print(f"❌ Application startup error: {e}")
+        return False
+
+def main():
+    """Main function."""
+    parser = argparse.ArgumentParser(
+        description="Run Full Application Example",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python run_simple.py --config configs/http_simple_correct.json
+  python run_simple.py --config configs/http_auth_correct.json
+        """
+    )
+    
+    parser.add_argument(
+        "--config",
+        default="configs/http_simple_correct.json",
+        help="Configuration file path"
+    )
+    
+    args = parser.parse_args()
+    
+    # Check if config file exists
+    config_path = Path(args.config)
+    if not config_path.exists():
+        print(f"❌ Configuration file not found: {config_path}")
+        print("💡 Available configurations:")
+        configs_dir = Path("configs")
+        if configs_dir.exists():
+            for config_file in configs_dir.glob("*.json"):
+                print(f"  - {config_file}")
+        return 1
+    
+    # Run application
+    success = run_application(str(config_path))
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_proxy_adapter/examples/full_application/test_server.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Test mTLS Server for Full Application Example
+Simple HTTPS server with mTLS for testing curl commands.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import sys
+import json
+import ssl
+import socket
+import threading
+import time
+from pathlib import Path
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+class TestMTLSHandler(BaseHTTPRequestHandler):
+    """Test handler for mTLS requests."""
+    
+    def do_GET(self):
+        """Handle GET requests."""
+        if self.path == '/health':
+            self.send_response(200)
+            self.send_header('Content-type', 'application/json')
+            self.end_headers()
+            response = {
+                "status": "healthy",
+                "service": "mcp_proxy_adapter",
+                "version": "6.2.33",
+                "protocol": "mTLS",
+                "timestamp": time.time()
+            }
+            self.wfile.write(json.dumps(response).encode())
+        elif self.path == '/echo':
+            self.send_response(200)
+            self.send_header('Content-type', 'application/json')
+            self.end_headers()
+            response = {
+                "message": "Echo from mTLS server",
+                "timestamp": time.time(),
+                "client_cert": self.get_client_cert_info()
+            }
+            self.wfile.write(json.dumps(response).encode())
+        else:
+            self.send_response(404)
+            self.send_header('Content-type', 'application/json')
+            self.end_headers()
+            response = {"error": "Not found", "path": self.path}
+            self.wfile.write(json.dumps(response).encode())
+    
+    def do_POST(self):
+        """Handle POST requests."""
+        content_length = int(self.headers.get('Content-Length', 0))
+        post_data = self.rfile.read(content_length)
+        
+        try:
+            data = json.loads(post_data.decode())
+        except json.JSONDecodeError:
+            data = {"raw": post_data.decode()}
+        
+        self.send_response(200)
+        self.send_header('Content-type', 'application/json')
+        self.end_headers()
+        
+        response = {
+            "received": data,
+            "timestamp": time.time(),
+            "client_cert": self.get_client_cert_info(),
+            "method": "POST"
+        }
+        self.wfile.write(json.dumps(response).encode())
+    
+    def get_client_cert_info(self):
+        """Get client certificate information."""
+        try:
+            cert = self.connection.getpeercert()
+            if cert:
+                return {
+                    "subject": dict(x[0] for x in cert.get('subject', [])),
+                    "issuer": dict(x[0] for x in cert.get('issuer', [])),
+                    "serial": cert.get('serialNumber'),
+                    "not_before": cert.get('notBefore'),
+                    "not_after": cert.get('notAfter')
+                }
+        except Exception:
+            pass
+        return None
+    
+    def log_message(self, format, *args):
+        """Override log message to include client cert info."""
+        client_cert = self.get_client_cert_info()
+        if client_cert:
+            print(f"[{self.address_string()}] {format % args} [Client: {client_cert.get('subject', {}).get('CN', 'Unknown')}]")
+        else:
+            print(f"[{self.address_string()}] {format % args} [No client cert]")
+
+class TestMTLSServer:
+    """Test mTLS server for the full application example."""
+    
+    def __init__(self, config_path: str):
+        self.config_path = config_path
+        self.config = self.load_config()
+        self.server = None
+        self.thread = None
+        
+    def load_config(self):
+        """Load configuration from file."""
+        with open(self.config_path, 'r') as f:
+            return json.load(f)
+    
+    def create_ssl_context(self):
+        """Create SSL context for mTLS."""
+        ssl_config = self.config.get('ssl', {})
+        
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        context.load_cert_chain(
+            ssl_config.get('cert_file'),
+            ssl_config.get('key_file')
+        )
+        
+        # Load CA certificate for client verification
+        if ssl_config.get('verify_client', False):
+            context.load_verify_locations(ssl_config.get('ca_cert_file'))
+            context.verify_mode = ssl.CERT_REQUIRED
+        
+        # Set ciphers and protocols
+        if ssl_config.get('ciphers'):
+            context.set_ciphers(ssl_config['ciphers'])
+        
+        return context
+    
+    def start_server(self):
+        """Start the mTLS server."""
+        server_config = self.config.get('server', {})
+        host = server_config.get('host', '0.0.0.0')
+        port = server_config.get('port', 8443)
+        
+        print(f"🚀 Starting mTLS Test Server")
+        print(f"📁 Configuration: {self.config_path}")
+        print(f"🌐 Server: {host}:{port}")
+        print(f"🔐 mTLS: {'Enabled' if self.config.get('ssl', {}).get('verify_client', False) else 'Disabled'}")
+        
+        # Create server
+        self.server = HTTPServer((host, port), TestMTLSHandler)
+        
+        # Configure SSL
+        ssl_context = self.create_ssl_context()
+        self.server.socket = ssl_context.wrap_socket(
+            self.server.socket,
+            server_side=True
+        )
+        
+        print(f"✅ mTLS Test Server started on {host}:{port}")
+        print(f"🔐 SSL Context configured")
+        print(f"📜 Available endpoints:")
+        print(f"  - GET  /health - Health check")
+        print(f"  - GET  /echo   - Echo test")
+        print(f"  - POST /echo   - Echo with data")
+        print(f"\n🛑 Press Ctrl+C to stop the server")
+        
+        try:
+            self.server.serve_forever()
+        except KeyboardInterrupt:
+            print(f"\n🛑 Server stopped by user")
+            self.server.shutdown()
+    
+    def start_background(self):
+        """Start server in background thread."""
+        self.thread = threading.Thread(target=self.start_server, daemon=True)
+        self.thread.start()
+        time.sleep(1)  # Give server time to start
+        return self.thread.is_alive()
+    
+    def stop_server(self):
+        """Stop the server."""
+        if self.server:
+            self.server.shutdown()
+        if self.thread:
+            self.thread.join(timeout=5)
+
+def main():
+    """Main function."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Test mTLS Server")
+    parser.add_argument("--config", required=True, help="Configuration file path")
+    parser.add_argument("--background", action="store_true", help="Run in background")
+    args = parser.parse_args()
+    
+    # Check if config file exists
+    config_path = Path(args.config)
+    if not config_path.exists():
+        print(f"❌ Configuration file not found: {config_path}")
+        return 1
+    
+    # Create and start server
+    server = TestMTLSServer(str(config_path))
+    
+    if args.background:
+        print("🔄 Starting server in background...")
+        if server.start_background():
+            print("✅ Server started in background")
+            print("💡 Use Ctrl+C to stop")
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print("\n🛑 Stopping background server...")
+                server.stop_server()
+        else:
+            print("❌ Failed to start server in background")
+            return 1
+    else:
+        server.start_server()
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())