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

mcp_proxy_adapter/examples/universal_client.py

@@ -6,6 +6,7 @@ and connection types supported by the security framework.
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
+
 import asyncio
 import json
 import os
@@ -17,16 +18,35 @@ from pathlib import Path
 import aiohttp
 import requests
 from requests.exceptions import RequestException
+
 # Import security framework components
 try:
-    from mcp_security_framework import SecurityManager, AuthManager, CertificateManager, PermissionManager
-    from mcp_security_framework.utils import generate_api_key, create_jwt_token, validate_jwt_token
-    from mcp_security_framework.utils import extract_roles_from_cert, validate_certificate_chain
-    from mcp_security_framework.utils import create_ssl_context, validate_server_certificate
+    from mcp_security_framework import (
+        SecurityManager,
+        AuthManager,
+        CertificateManager,
+        PermissionManager,
+    )
+    from mcp_security_framework.utils import (
+        generate_api_key,
+        create_jwt_token,
+        validate_jwt_token,
+    )
+    from mcp_security_framework.utils import (
+        extract_roles_from_cert,
+        validate_certificate_chain,
+    )
+    from mcp_security_framework.utils import (
+        create_ssl_context,
+        validate_server_certificate,
+    )
+
     SECURITY_FRAMEWORK_AVAILABLE = True
 except ImportError:
     SECURITY_FRAMEWORK_AVAILABLE = False
     print("Warning: mcp_security_framework not available. Using basic HTTP client.")
+
+
 class UniversalClient:
     """
     Universal client that demonstrates all possible secure connection methods.
@@ -39,6 +59,7 @@ class UniversalClient:
     - Role-based access control
     - Rate limiting awareness
     """
+
     def __init__(self, config: Dict[str, Any]):
         """
         Initialize universal client with configuration.
@@ -64,6 +85,7 @@ class UniversalClient:
         self.current_token: Optional[str] = None
         self.token_expiry: Optional[float] = None
         print(f"Universal client initialized with auth method: {self.auth_method}")
+
     def _initialize_security_managers(self) -> None:
         """Initialize security framework managers."""
         try:
@@ -81,16 +103,21 @@ class UniversalClient:
             print("Security framework managers initialized successfully")
         except Exception as e:
             print(f"Warning: Failed to initialize security managers: {e}")
+
     async def __aenter__(self):
         """Async context manager entry."""
         await self.connect()
         return self
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
         await self.disconnect()
+
     async def connect(self) -> None:
         """Establish connection with authentication."""
-        print(f"Connecting to {self.base_url} with {self.auth_method} authentication...")
+        print(
+            f"Connecting to {self.base_url} with {self.auth_method} authentication..."
+        )
         # Create SSL context
         ssl_context = self._create_ssl_context()
         # Create connector with SSL context
@@ -111,12 +138,14 @@ class UniversalClient:
         else:
             print("No authentication required")
         print("Connection established successfully")
+
     async def disconnect(self) -> None:
         """Close connection and cleanup."""
         if self.session:
             await self.session.close()
             self.session = None
         print("Connection closed")
+
     async def _authenticate_api_key(self) -> None:
         """Authenticate using API key."""
         api_key_config = self.security_config.get("api_key", {})
@@ -126,6 +155,7 @@ class UniversalClient:
         # Store API key for requests
         self.current_token = api_key
         print(f"Authenticated with API key: {api_key[:8]}...")
+
     async def _authenticate_jwt(self) -> None:
         """Authenticate using JWT token."""
         jwt_config = self.security_config.get("jwt", {})
@@ -142,20 +172,20 @@ class UniversalClient:
         # Create JWT token
         if SECURITY_FRAMEWORK_AVAILABLE:
             self.current_token = create_jwt_token(
-                username,
-                secret,
-                expiry_hours=jwt_config.get("expiry_hours", 24)
+                username, secret, expiry_hours=jwt_config.get("expiry_hours", 24)
             )
         else:
             # Simple JWT creation (for demonstration)
             import jwt
+
             payload = {
                 "username": username,
-                "exp": time.time() + (jwt_config.get("expiry_hours", 24) * 3600)
+                "exp": time.time() + (jwt_config.get("expiry_hours", 24) * 3600),
             }
             self.current_token = jwt.encode(payload, secret, algorithm="HS256")
         self.token_expiry = time.time() + (jwt_config.get("expiry_hours", 24) * 3600)
         print(f"Authenticated with JWT token: {self.current_token[:20]}...")
+
     async def _authenticate_certificate(self) -> None:
         """Authenticate using client certificate."""
         cert_config = self.security_config.get("certificate", {})
@@ -175,6 +205,7 @@ class UniversalClient:
             except Exception as e:
                 print(f"Warning: Certificate validation failed: {e}")
         print("Certificate authentication prepared")
+
     async def _authenticate_basic(self) -> None:
         """Authenticate using basic authentication."""
         basic_config = self.security_config.get("basic", {})
@@ -183,9 +214,11 @@ class UniversalClient:
         if not username or not password:
             raise ValueError("Basic auth credentials not provided in configuration")
         import base64
+
         credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
         self.current_token = f"Basic {credentials}"
         print(f"Authenticated with basic auth: {username}")
+
     def _get_auth_headers(self) -> Dict[str, str]:
         """Get authentication headers for requests."""
         headers = {"Content-Type": "application/json"}
@@ -200,6 +233,7 @@ class UniversalClient:
         elif self.auth_method == "basic":
             headers["Authorization"] = self.current_token
         return headers
+
     def _create_ssl_context(self) -> Optional[ssl.SSLContext]:
         """Create SSL context for secure connections."""
         ssl_config = self.security_config.get("ssl", {})
@@ -236,12 +270,13 @@ class UniversalClient:
         except Exception as e:
             print(f"Warning: Failed to create SSL context: {e}")
             return None
+
     async def request(
         self,
         method: str,
         endpoint: str,
         data: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None
+        headers: Optional[Dict[str, str]] = None,
     ) -> Dict[str, Any]:
         """
         Make authenticated request to server.
@@ -266,14 +301,18 @@ class UniversalClient:
                         url,
                         json=data,
                         headers=request_headers,
-                        timeout=aiohttp.ClientTimeout(total=self.timeout)
+                        timeout=aiohttp.ClientTimeout(total=self.timeout),
                     ) as response:
                         result = await response.json()
                         # Validate response if security framework available
                         if SECURITY_FRAMEWORK_AVAILABLE and self.security_manager:
-                            self.security_manager.validate_server_response(dict(response.headers))
+                            self.security_manager.validate_server_response(
+                                dict(response.headers)
+                            )
                         if response.status >= 400:
-                            print(f"Request failed with status {response.status}: {result}")
+                            print(
+                                f"Request failed with status {response.status}: {result}"
+                            )
                             return {"error": result, "status": response.status}
                         return result
                 except Exception as e:
@@ -285,18 +324,27 @@ class UniversalClient:
         except Exception as e:
             print(f"Request failed: {e}")
             raise
+
     async def get(self, endpoint: str, **kwargs) -> Dict[str, Any]:
         """Make GET request."""
         return await self.request("GET", endpoint, **kwargs)
-    async def post(self, endpoint: str, data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+
+    async def post(
+        self, endpoint: str, data: Dict[str, Any], **kwargs
+    ) -> Dict[str, Any]:
         """Make POST request."""
         return await self.request("POST", endpoint, data=data, **kwargs)
-    async def put(self, endpoint: str, data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+
+    async def put(
+        self, endpoint: str, data: Dict[str, Any], **kwargs
+    ) -> Dict[str, Any]:
         """Make PUT request."""
         return await self.request("PUT", endpoint, data=data, **kwargs)
+
     async def delete(self, endpoint: str, **kwargs) -> Dict[str, Any]:
         """Make DELETE request."""
         return await self.request("DELETE", endpoint, **kwargs)
+
     async def test_connection(self) -> bool:
         """Test connection to server."""
         try:
@@ -310,6 +358,7 @@ class UniversalClient:
         except Exception as e:
             print(f"❌ Connection test failed: {e}")
             return False
+
     async def test_security_features(self) -> Dict[str, bool]:
         """Test various security features."""
         results = {}
@@ -333,10 +382,10 @@ class UniversalClient:
         else:
             results["certificate_validation"] = False
         return results
+
+
 def create_client_config(
-    server_url: str,
-    auth_method: str = "none",
-    **kwargs
+    server_url: str, auth_method: str = "none", **kwargs
 ) -> Dict[str, Any]:
     """
     Create client configuration for different authentication methods.
@@ -352,40 +401,40 @@ def create_client_config(
         "timeout": 30,
         "retry_attempts": 3,
         "retry_delay": 1,
-        "security": {
-            "auth_method": auth_method
-        }
+        "security": {"auth_method": auth_method},
     }
     if auth_method == "api_key":
         config["security"]["api_key"] = {
             "key": kwargs.get("api_key", "your_api_key_here"),
-            "header": kwargs.get("header", "X-API-Key")
+            "header": kwargs.get("header", "X-API-Key"),
         }
     elif auth_method == "jwt":
         config["security"]["jwt"] = {
             "username": kwargs.get("username", "user"),
             "password": kwargs.get("password", "password"),
             "secret": kwargs.get("secret", "your_jwt_secret"),
-            "expiry_hours": kwargs.get("expiry_hours", 24)
+            "expiry_hours": kwargs.get("expiry_hours", 24),
         }
     elif auth_method == "certificate":
         config["security"]["certificate"] = {
             "enabled": True,
             "cert_file": kwargs.get("cert_file", "./certs/client.crt"),
             "key_file": kwargs.get("key_file", "./keys/client.key"),
-            "ca_cert_file": kwargs.get("ca_cert_file", "./certs/ca.crt")
+            "ca_cert_file": kwargs.get("ca_cert_file", "./certs/ca.crt"),
         }
         config["security"]["ssl"] = {
             "enabled": True,
             "check_hostname": kwargs.get("check_hostname", True),
-            "ca_cert_file": kwargs.get("ca_cert_file", "./certs/ca.crt")
+            "ca_cert_file": kwargs.get("ca_cert_file", "./certs/ca.crt"),
         }
     elif auth_method == "basic":
         config["security"]["basic"] = {
             "username": kwargs.get("username", "user"),
-            "password": kwargs.get("password", "password")
+            "password": kwargs.get("password", "password"),
         }
     return config
+
+
 async def demo_all_connection_methods():
     """Demonstrate all possible connection methods."""
     print("🚀 Universal Client Demo - All Connection Methods")
@@ -394,15 +443,13 @@ async def demo_all_connection_methods():
     test_configs = [
         {
             "name": "No Authentication",
-            "config": create_client_config("http://localhost:8000", "none")
+            "config": create_client_config("http://localhost:8000", "none"),
         },
         {
             "name": "API Key Authentication",
             "config": create_client_config(
-                "http://localhost:8000",
-                "api_key",
-                api_key="demo_api_key_123"
-            )
+                "http://localhost:8000", "api_key", api_key="demo_api_key_123"
+            ),
         },
         {
             "name": "JWT Authentication",
@@ -411,8 +458,8 @@ async def demo_all_connection_methods():
                 "jwt",
                 username="demo_user",
                 password="demo_password",
-                secret="demo_jwt_secret"
-            )
+                secret="demo_jwt_secret",
+            ),
         },
         {
             "name": "Basic Authentication",
@@ -420,8 +467,8 @@ async def demo_all_connection_methods():
                 "http://localhost:8000",
                 "basic",
                 username="demo_user",
-                password="demo_password"
-            )
+                password="demo_password",
+            ),
         },
         {
             "name": "Certificate Authentication (HTTPS)",
@@ -430,9 +477,9 @@ async def demo_all_connection_methods():
                 "certificate",
                 cert_file="./certs/client.crt",
                 key_file="./keys/client.key",
-                ca_cert_file="./certs/ca.crt"
-            )
-        }
+                ca_cert_file="./certs/ca.crt",
+            ),
+        },
     ]
     for test_config in test_configs:
         print(f"\n📋 Testing: {test_config['name']}")
@@ -459,6 +506,8 @@ async def demo_all_connection_methods():
         except Exception as e:
             print(f"❌ Test failed: {e}")
     print("\n🎉 Demo completed!")
+
+
 async def demo_specific_connection(auth_method: str, **kwargs):
     """
     Demo specific connection method.
@@ -484,7 +533,7 @@ async def demo_specific_connection(auth_method: str, **kwargs):
                     "jsonrpc": "2.0",
                     "method": "test_command",
                     "params": {"message": "Hello from universal client!"},
-                    "id": 1
+                    "id": 1,
                 }
                 result = await client.post("/api/jsonrpc", command_data)
                 print(f"Command Result: {result}")
@@ -492,11 +541,16 @@ async def demo_specific_connection(auth_method: str, **kwargs):
                 print(f"API calls failed: {e}")
         else:
             print("❌ Connection failed")
+
+
 if __name__ == "__main__":
     import sys
     import argparse
     import json
-    parser = argparse.ArgumentParser(description="Universal Client for MCP Proxy Adapter")
+
+    parser = argparse.ArgumentParser(
+        description="Universal Client for MCP Proxy Adapter"
+    )
     parser.add_argument("--config", help="Path to configuration file")
     parser.add_argument("--method", help="JSON-RPC method to call")
     parser.add_argument("--params", help="JSON-RPC parameters (JSON string)")
@@ -506,7 +560,7 @@ if __name__ == "__main__":
     if args.config:
         # Load configuration from file
         try:
-            with open(args.config, 'r') as f:
+            with open(args.config, "r") as f:
                 config_data = json.load(f)
             # Extract server configuration
             server_config = config_data.get("server", {})
@@ -527,21 +581,20 @@ if __name__ == "__main__":
                 "timeout": 30,
                 "retry_attempts": 3,
                 "retry_delay": 1,
-                "security": {
-                    "auth_method": "none"
-                }
+                "security": {"auth_method": "none"},
             }
             # Add SSL configuration if needed
             if ssl_enabled:
                 client_config["security"]["ssl"] = {
                     "enabled": True,
                     "check_hostname": False,
-                    "verify": False
+                    "verify": False,
                 }
                 # Add CA certificate if available
                 ca_cert = ssl_config.get("ca_cert")
                 if ca_cert and os.path.exists(ca_cert):
                     client_config["security"]["ssl"]["ca_cert_file"] = ca_cert
+
             async def test_config_connection():
                 async with UniversalClient(client_config) as client:
                     # Test connection
@@ -562,11 +615,13 @@ if __name__ == "__main__":
                                 "jsonrpc": "2.0",
                                 "method": args.method,
                                 "params": params,
-                                "id": 1
+                                "id": 1,
                             }
                             try:
                                 result = await client.post("/api/jsonrpc", command_data)
-                                print(f"✅ Method '{args.method}' executed successfully:")
+                                print(
+                                    f"✅ Method '{args.method}' executed successfully:"
+                                )
                                 print(json.dumps(result, indent=2))
                             except Exception as e:
                                 print(f"❌ Method execution failed: {e}")
@@ -576,7 +631,7 @@ if __name__ == "__main__":
                                 "jsonrpc": "2.0",
                                 "method": "help",
                                 "params": {},
-                                "id": 1
+                                "id": 1,
                             }
                             try:
                                 result = await client.post("/api/jsonrpc", command_data)
@@ -587,6 +642,7 @@ if __name__ == "__main__":
                     else:
                         print("❌ Connection failed")
                     print("Connection closed")
+
             asyncio.run(test_config_connection())
         except FileNotFoundError:
             print(f"❌ Configuration file not found: {args.config}")
@@ -601,22 +657,23 @@ if __name__ == "__main__":
         if auth_method == "api_key":
             kwargs["api_key"] = "demo_key_123"
         elif auth_method == "jwt":
-            kwargs.update({
-                "username": "demo_user",
-                "password": "demo_password",
-                "secret": "demo_secret"
-            })
+            kwargs.update(
+                {
+                    "username": "demo_user",
+                    "password": "demo_password",
+                    "secret": "demo_secret",
+                }
+            )
         elif auth_method == "certificate":
-            kwargs.update({
-                "cert_file": "./certs/client.crt",
-                "key_file": "./keys/client.key",
-                "ca_cert_file": "./certs/ca.crt"
-            })
+            kwargs.update(
+                {
+                    "cert_file": "./certs/client.crt",
+                    "key_file": "./keys/client.key",
+                    "ca_cert_file": "./certs/ca.crt",
+                }
+            )
         elif auth_method == "basic":
-            kwargs.update({
-                "username": "demo_user",
-                "password": "demo_password"
-            })
+            kwargs.update({"username": "demo_user", "password": "demo_password"})
         asyncio.run(demo_specific_connection(auth_method, **kwargs))
     else:
         # Demo all connection methods