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

mcp_proxy_adapter/examples/full_application/proxy_endpoints.py

@@ -0,0 +1,154 @@
+"""
+Proxy Registration Endpoints
+This module provides proxy registration endpoints for testing.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Dict, List, Optional
+import time
+import uuid
+# In-memory registry for testing
+_registry: Dict[str, Dict] = {}
+router = APIRouter(prefix="/proxy", tags=["proxy"])
+class ServerRegistration(BaseModel):
+    """Server registration request model."""
+    server_id: str
+    server_url: str
+    server_name: str
+    description: Optional[str] = None
+    version: Optional[str] = "1.0.0"
+    capabilities: Optional[List[str]] = None
+    endpoints: Optional[Dict[str, str]] = None
+    auth_method: Optional[str] = "none"
+    security_enabled: Optional[bool] = False
+class ServerUnregistration(BaseModel):
+    """Server unregistration request model."""
+    server_key: str  # Use server_key directly
+class HeartbeatData(BaseModel):
+    """Heartbeat data model."""
+    server_id: str
+    server_key: str
+    timestamp: Optional[int] = None
+    status: Optional[str] = "healthy"
+class RegistrationResponse(BaseModel):
+    """Registration response model."""
+    success: bool
+    server_key: str
+    message: str
+    copy_number: int
+class DiscoveryResponse(BaseModel):
+    """Discovery response model."""
+    success: bool
+    servers: List[Dict]
+    total: int
+    active: int
+@router.post("/register", response_model=RegistrationResponse)
+async def register_server(registration: ServerRegistration):
+    """Register a server with the proxy."""
+    try:
+        # Generate unique server key
+        server_key = f"{registration.server_id}_{uuid.uuid4().hex[:8]}"
+        copy_number = 1
+        # Store server information
+        _registry[server_key] = {
+            "server_id": registration.server_id,
+            "server_url": registration.server_url,
+            "server_name": registration.server_name,
+            "description": registration.description,
+            "version": registration.version,
+            "capabilities": registration.capabilities or [],
+            "endpoints": registration.endpoints or {},
+            "auth_method": registration.auth_method,
+            "security_enabled": registration.security_enabled,
+            "registered_at": int(time.time()),
+            "last_heartbeat": int(time.time()),
+            "status": "active"
+        }
+        return RegistrationResponse(
+            success=True,
+            server_key=server_key,
+            message=f"Server {registration.server_name} registered successfully",
+            copy_number=copy_number
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Registration failed: {str(e)}")
+@router.post("/unregister")
+async def unregister_server(unregistration: ServerUnregistration):
+    """Unregister a server from the proxy."""
+    try:
+        # Check if server exists in registry
+        if unregistration.server_key not in _registry:
+            raise HTTPException(status_code=404, detail="Server not found")
+        # Remove from registry
+        del _registry[unregistration.server_key]
+        return {"success": True, "message": "Server unregistered successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unregistration failed: {str(e)}")
+@router.post("/heartbeat")
+async def send_heartbeat(heartbeat: HeartbeatData):
+    """Send heartbeat for a registered server."""
+    try:
+        if heartbeat.server_key not in _registry:
+            raise HTTPException(status_code=404, detail="Server not found")
+        # Update heartbeat information
+        _registry[heartbeat.server_key]["last_heartbeat"] = heartbeat.timestamp or int(time.time())
+        _registry[heartbeat.server_key]["status"] = heartbeat.status
+        return {"success": True, "message": "Heartbeat received"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Heartbeat failed: {str(e)}")
+@router.get("/discover", response_model=DiscoveryResponse)
+async def discover_servers():
+    """Discover active servers."""
+    try:
+        current_time = int(time.time())
+        active_servers = []
+        for server_key, server in _registry.items():
+            # Consider server active if heartbeat was within last 5 minutes
+            if current_time - server["last_heartbeat"] < 300:
+                active_servers.append({
+                    "server_key": server_key,
+                    "server_id": server["server_id"],
+                    "server_name": server["server_name"],
+                    "server_url": server["server_url"],
+                    "status": server["status"],
+                    "last_heartbeat": server["last_heartbeat"]
+                })
+        return DiscoveryResponse(
+            success=True,
+            servers=active_servers,
+            total=len(_registry),
+            active=len(active_servers)
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Discovery failed: {str(e)}")
+@router.get("/status")
+async def get_proxy_status():
+    """Get proxy status."""
+    try:
+        current_time = int(time.time())
+        active_count = sum(
+            1 for server in _registry.values()
+            if current_time - server["last_heartbeat"] < 300
+        )
+        return {
+            "success": True,
+            "total_registered": len(_registry),
+            "active_servers": active_count,
+            "inactive_servers": len(_registry) - active_count
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Status check failed: {str(e)}")
+@router.delete("/clear")
+async def clear_registry():
+    """Clear the registry (for testing)."""
+    try:
+        _registry.clear()
+        return {"success": True, "message": "Registry cleared"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Clear failed: {str(e)}")

mcp_proxy_adapter/examples/generate_all_certificates.py

@@ -1,37 +1,29 @@
 #!/usr/bin/env python3
 """
 Generate All Certificates for Security Testing
-
 This script generates all necessary certificates for comprehensive security testing:
 - Root CA certificate and key
 - Server certificates for HTTPS and mTLS
 - Client certificates for different roles (admin, user, readonly, etc.)
 - Test certificates for negative scenarios
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import json
 import os
 import subprocess
 import sys
 from pathlib import Path
 from typing import Dict, List, Optional
-
-
 class CertificateGenerator:
     """Generate all certificates for security testing."""
-    
     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"
-        
         # Create directories if they don't exist
         self.certs_dir.mkdir(parents=True, exist_ok=True)
         self.keys_dir.mkdir(parents=True, exist_ok=True)
-        
         # Certificate configuration
         self.ca_config = {
             "common_name": "MCP Proxy Adapter Test CA",
@@ -41,7 +33,6 @@ class CertificateGenerator:
             "city": "Test City",
             "validity_years": 10
         }
-        
         self.server_config = {
             "common_name": "mcp-proxy-adapter-test.local",
             "organization": "Test Organization",
@@ -51,7 +42,6 @@ class CertificateGenerator:
             "validity_years": 2,
             "san": ["localhost", "127.0.0.1", "mcp-proxy-adapter-test.local"]
         }
-        
         # Client certificates configuration
         self.client_certs = {
             "admin": {
@@ -85,7 +75,6 @@ class CertificateGenerator:
                 "permissions": ["register", "discover"]
             }
         }
-        
         # Negative test certificates
         self.negative_certs = {
             "expired": {
@@ -109,7 +98,6 @@ class CertificateGenerator:
                 "roles": ["invalid_role"]
             }
         }
-    
     def run_command(self, cmd: List[str], description: str) -> bool:
         """Run a command and handle errors."""
         try:
@@ -131,16 +119,13 @@ class CertificateGenerator:
         except Exception as e:
             print(f"❌ {description} failed: {e}")
             return False
-    
     def create_ca_certificate(self) -> bool:
         """Create Root CA certificate and key."""
         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
-        
         cmd = [
             sys.executable, "-m", "mcp_security_framework.cli.cert_cli", "create-ca",
             "-cn", self.ca_config["common_name"],
@@ -150,30 +135,23 @@ class CertificateGenerator:
             "-l", self.ca_config["city"],
             "-y", str(self.ca_config["validity_years"])
         ]
-        
         success = self.run_command(cmd, "Creating Root CA certificate")
-        
         if success:
             # Move files to correct locations
             default_ca_cert = Path("./certs") / f"{self.ca_config['common_name'].lower().replace(' ', '_')}_ca.crt"
             default_ca_key = Path("./keys") / f"{self.ca_config['common_name'].lower().replace(' ', '_')}_ca.key"
-            
             if default_ca_cert.exists():
                 self.run_command(["mv", str(default_ca_cert), str(ca_cert_path)], "Moving CA certificate")
             if default_ca_key.exists():
                 self.run_command(["mv", str(default_ca_key), str(ca_key_path)], "Moving CA key")
-        
         return success
-    
     def create_server_certificate(self) -> bool:
         """Create server certificate for HTTPS and mTLS."""
         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}")
             return True
-        
         # Create server certificate
         cmd = [
             sys.executable, "-m", "mcp_security_framework.cli.cert_cli", "create-server",
@@ -184,35 +162,27 @@ class CertificateGenerator:
             "-l", self.server_config["city"],
             "-d", str(self.server_config["validity_years"] * 365)  # Convert years to days
         ]
-        
         # Add SAN if supported
         if self.server_config["san"]:
             for san in self.server_config["san"]:
                 cmd.extend(["--san", san])
-        
         success = self.run_command(cmd, "Creating server certificate")
-        
         if success:
             # Move files to correct locations
             default_server_cert = Path("./certs") / f"{self.server_config['common_name'].lower().replace('.', '_')}_server.crt"
             default_server_key = Path("./keys") / f"{self.server_config['common_name'].lower().replace('.', '_')}_server.key"
-            
             if default_server_cert.exists():
                 self.run_command(["mv", str(default_server_cert), str(server_cert_path)], "Moving server certificate")
             if default_server_key.exists():
                 self.run_command(["mv", str(default_server_key), str(server_key_path)], "Moving server key")
-        
         return success
-    
     def create_client_certificate(self, name: str, config: Dict) -> bool:
         """Create client certificate with specific configuration."""
         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
-        
         cmd = [
             sys.executable, "-m", "mcp_security_framework.cli.cert_cli", "create-client",
             "-cn", config["common_name"],
@@ -222,35 +192,27 @@ class CertificateGenerator:
             "-l", self.ca_config["city"],
             "-d", "730"  # 2 years in days
         ]
-        
         # Add roles if specified
         if "roles" in config and config["roles"]:
             for role in config["roles"]:
                 cmd.extend(["--roles", role])
-        
         # Add permissions if specified
         if "permissions" in config and config["permissions"]:
             for permission in config["permissions"]:
                 cmd.extend(["--permissions", permission])
-        
         # Add custom validity for negative tests
         if "validity_days" in config:
             cmd[cmd.index("-d") + 1] = str(config["validity_days"])
-        
         success = self.run_command(cmd, f"Creating client certificate: {name}")
-        
         if success:
             # Move files to correct locations
             default_client_cert = Path("./certs") / f"{config['common_name'].lower().replace('-', '_')}_client.crt"
             default_client_key = Path("./keys") / f"{config['common_name'].lower().replace('-', '_')}_client.key"
-            
             if default_client_cert.exists():
                 self.run_command(["mv", str(default_client_cert), str(cert_path)], f"Moving {name} certificate")
             if default_client_key.exists():
                 self.run_command(["mv", str(default_client_key), str(key_path)], f"Moving {name} key")
-        
         return success
-    
     def create_legacy_certificates(self) -> bool:
         """Create legacy certificate files for compatibility."""
         legacy_files = [
@@ -260,12 +222,10 @@ class CertificateGenerator:
             ("user.crt", "user.key"),
             ("readonly.crt", "readonly.key")
         ]
-        
         success = True
         for cert_file, key_file 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():
                 # Copy from existing certificates
                 if cert_file == "client.crt" and (self.certs_dir / "user_cert.pem").exists():
@@ -283,13 +243,10 @@ class CertificateGenerator:
                 elif cert_file == "readonly.crt" and (self.certs_dir / "readonly_cert.pem").exists():
                     self.run_command(["cp", str(self.certs_dir / "readonly_cert.pem"), str(cert_path)], f"Creating {cert_file}")
                     self.run_command(["cp", str(self.certs_dir / "readonly_key.pem"), str(key_path)], f"Creating {key_file}")
-        
         return success
-    
     def create_certificate_config(self) -> bool:
         """Create certificate configuration file."""
         config_path = self.certs_dir / "cert_config.json"
-        
         config = {
             "ca_cert_path": str(self.certs_dir / "ca_cert.pem"),
             "ca_key_path": str(self.keys_dir / "ca_key.pem"),
@@ -299,7 +256,6 @@ class CertificateGenerator:
             "key_size": 2048,
             "hash_algorithm": "sha256"
         }
-        
         try:
             with open(config_path, 'w') as f:
                 json.dump(config, f, indent=2)
@@ -308,11 +264,9 @@ class CertificateGenerator:
         except Exception as e:
             print(f"❌ Failed to create certificate config: {e}")
             return False
-    
     def validate_certificates(self) -> bool:
         """Validate all created certificates."""
         print("\n🔍 Validating certificates...")
-        
         cert_files = [
             "ca_cert.pem",
             "server_cert.pem",
@@ -322,7 +276,6 @@ class CertificateGenerator:
             "guest_cert.pem",
             "proxy_cert.pem"
         ]
-        
         success = True
         for cert_file in cert_files:
             cert_path = self.certs_dir / cert_file
@@ -340,80 +293,62 @@ class CertificateGenerator:
                     success = False
             else:
                 print(f"⚠️ {cert_file}: Not found")
-        
         return success
-    
     def generate_all(self) -> bool:
         """Generate all certificates."""
         print("🔐 Generating 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 for different roles
         print("\n👥 Creating client certificates...")
         for name, config in self.client_certs.items():
             if not self.create_client_certificate(name, config):
                 success = False
-        
         # 4. Create negative test certificates
         print("\n🚫 Creating negative test certificates...")
         for name, config in self.negative_certs.items():
             if not self.create_client_certificate(name, config):
                 success = False
-        
         # 5. Create legacy certificates for compatibility
         print("\n🔄 Creating legacy certificates...")
         if not self.create_legacy_certificates():
             success = False
-        
         # 6. Create certificate configuration
         if not self.create_certificate_config():
             success = False
-        
         # 7. Validate certificates
         if not self.validate_certificates():
             success = False
-        
         # Print summary
         print("\n" + "=" * 60)
         print("📊 CERTIFICATE GENERATION SUMMARY")
         print("=" * 60)
-        
         if success:
             print("✅ All certificates generated successfully!")
             print(f"📁 Certificates directory: {self.certs_dir}")
             print(f"🔑 Keys directory: {self.keys_dir}")
             print("\n📋 Generated 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 generate")
             print("Check the error messages above")
-        
         return success
-
-
 def main():
     """Main function."""
     generator = CertificateGenerator()
-    
     try:
         success = generator.generate_all()
         sys.exit(0 if success else 1)
@@ -423,7 +358,5 @@ def main():
     except Exception as e:
         print(f"\n❌ Certificate generation failed: {e}")
         sys.exit(1)
-
-
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/generate_certificates.py

@@ -1,19 +1,15 @@
 #!/usr/bin/env python3
 """
 Certificate Generation Script
-
 This script generates all necessary certificates for the examples using
 mcp_security_framework certificate management tools.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import os
 import subprocess
 import sys
 from pathlib import Path
-
 def run_command(cmd, description):
     """Run a command and handle errors."""
     print(f"🔧 {description}...")
@@ -25,16 +21,13 @@ def run_command(cmd, description):
         print(f"❌ {description} failed: {e}")
         print(f"Error output: {e.stderr}")
         return False
-
 def main():
     """Generate all certificates for examples."""
     print("🔐 Certificate Generation Script")
     print("=" * 50)
-    
     # Create directories
     cert_dir = Path("certs")
     cert_dir.mkdir(exist_ok=True)
-    
     # Check if mcp_security_framework is available
     try:
         import mcp_security_framework
@@ -42,7 +35,6 @@ def main():
     except ImportError:
         print("❌ mcp_security_framework not found")
         return False
-    
     # Generate CA certificate
     if not run_command(
         "python -m mcp_security_framework.cli.cert_cli create-ca "
@@ -56,7 +48,6 @@ def main():
         "Creating root CA certificate"
     ):
         return False
-    
     # Generate server certificate
     if not run_command(
         "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-server "
@@ -68,7 +59,6 @@ def main():
         "Creating server certificate"
     ):
         return False
-    
     # Generate admin client certificate
     if not run_command(
         "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-client "
@@ -82,7 +72,6 @@ def main():
         "Creating admin client certificate"
     ):
         return False
-    
     # Generate user client certificate
     if not run_command(
         "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-client "
@@ -96,7 +85,6 @@ def main():
         "Creating user client certificate"
     ):
         return False
-    
     # Generate readonly client certificate
     if not run_command(
         "python -m mcp_security_framework.cli.cert_cli -c cert_config.json create-client "
@@ -110,12 +98,9 @@ def main():
         "Creating readonly client certificate"
     ):
         return False
-    
     print("\n🎉 All certificates generated successfully!")
     print("📁 Certificates are stored in the 'certs' directory")
-    
     return True
-
 if __name__ == "__main__":
     success = main()
     sys.exit(0 if success else 1)