mcp-proxy-adapter 6.4.42__tar.gz → 6.4.44__tar.gz

{mcp_proxy_adapter-6.4.42 → mcp_proxy_adapter-6.4.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.4.42
+Version: 6.4.44
 Summary: Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration
 Home-page: https://github.com/maverikod/mcp-proxy-adapter
 Author: Vasiliy Zdanovskiy

{mcp_proxy_adapter-6.4.42 → mcp_proxy_adapter-6.4.44}/mcp_proxy_adapter/api/app.py

@@ -74,9 +74,15 @@ def create_lifespan(config_path: Optional[str] = None):
         # Compute server_url EARLY and inject into registration manager so
         # that reload_system (which may perform registration) uses the correct
         # externally reachable address.
-        server_config = config.get("server", {})
-        server_host = server_config.get("host", "0.0.0.0")
-        server_port = server_config.get("port", 8000)
+        server_config = config.get("server")
+        if not server_config:
+            raise ValueError("server configuration is required")
+        server_host = server_config.get("host")
+        server_port = server_config.get("port")
+        if not server_host:
+            raise ValueError("server.host is required")
+        if not server_port:
+            raise ValueError("server.port is required")
 
         reg_cfg = config.get("registration", {})
         public_host = reg_cfg.get("public_host")

{mcp_proxy_adapter-6.4.42 → mcp_proxy_adapter-6.4.44}/mcp_proxy_adapter/core/proxy_registration.py

@@ -69,41 +69,83 @@ class ProxyRegistrationManager:
             pass
 
         # Basic registration settings
-        self.proxy_url = self.registration_config.get(
-            "proxy_url", "https://proxy-registry.example.com"
-        )
-        self.server_id = self.registration_config.get(
-            "server_id",
-            self.registration_config.get("proxy_info", {}).get(
-                "name", "mcp_proxy_adapter"
-            ),
-        )
-        self.server_name = self.registration_config.get(
-            "server_name",
-            self.registration_config.get("proxy_info", {}).get(
-                "name", "MCP Proxy Adapter"
-            ),
-        )
-        self.description = self.registration_config.get(
-            "description",
-            self.registration_config.get("proxy_info", {}).get(
-                "description", "JSON-RPC API for interacting with MCP Proxy"
-            ),
-        )
-        self.version = self.registration_config.get(
-            "version",
-            self.registration_config.get("proxy_info", {}).get("version", "1.0.0"),
-        )
+        self.proxy_url = self.registration_config.get("proxy_url")
+        if not self.proxy_url:
+            raise ValueError(
+                "proxy_url is required in registration configuration. "
+                "Please specify a valid proxy URL in your configuration."
+            )
+        self.server_id = self.registration_config.get("server_id")
+        if not self.server_id:
+            # Try to get from proxy_info.name as fallback
+            self.server_id = self.registration_config.get("proxy_info", {}).get("name")
+            if not self.server_id:
+                raise ValueError(
+                    "server_id is required in registration configuration. "
+                    "Please specify a server_id or proxy_info.name in your configuration."
+                )
+        self.server_name = self.registration_config.get("server_name")
+        if not self.server_name:
+            # Try to get from proxy_info.name as fallback
+            self.server_name = self.registration_config.get("proxy_info", {}).get("name")
+            if not self.server_name:
+                raise ValueError(
+                    "server_name is required in registration configuration. "
+                    "Please specify a server_name or proxy_info.name in your configuration."
+                )
+        self.description = self.registration_config.get("description")
+        if not self.description:
+            # Try to get from proxy_info.description as fallback
+            self.description = self.registration_config.get("proxy_info", {}).get("description")
+            if not self.description:
+                raise ValueError(
+                    "description is required in registration configuration. "
+                    "Please specify a description or proxy_info.description in your configuration."
+                )
+        self.version = self.registration_config.get("version")
+        if not self.version:
+            # Try to get from proxy_info.version as fallback
+            self.version = self.registration_config.get("proxy_info", {}).get("version")
+            if not self.version:
+                raise ValueError(
+                    "version is required in registration configuration. "
+                    "Please specify a version or proxy_info.version in your configuration."
+                )
 
         # Heartbeat settings
         heartbeat_config = self.registration_config.get("heartbeat", {})
-        self.timeout = heartbeat_config.get("timeout", 30)
-        self.retry_attempts = heartbeat_config.get("retry_attempts", 3)
-        self.retry_delay = heartbeat_config.get("retry_delay", 60)
-        self.heartbeat_interval = heartbeat_config.get("interval", 300)
+        self.timeout = heartbeat_config.get("timeout")
+        if self.timeout is None:
+            raise ValueError(
+                "heartbeat.timeout is required in registration configuration. "
+                "Please specify a timeout value."
+            )
+        self.retry_attempts = heartbeat_config.get("retry_attempts")
+        if self.retry_attempts is None:
+            raise ValueError(
+                "heartbeat.retry_attempts is required in registration configuration. "
+                "Please specify a retry_attempts value."
+            )
+        self.retry_delay = heartbeat_config.get("retry_delay")
+        if self.retry_delay is None:
+            raise ValueError(
+                "heartbeat.retry_delay is required in registration configuration. "
+                "Please specify a retry_delay value."
+            )
+        self.heartbeat_interval = heartbeat_config.get("interval")
+        if self.heartbeat_interval is None:
+            raise ValueError(
+                "heartbeat.interval is required in registration configuration. "
+                "Please specify an interval value."
+            )
 
         # Auto registration settings
-        self.auto_register = self.registration_config.get("enabled", False)
+        self.auto_register = self.registration_config.get("enabled")
+        if self.auto_register is None:
+            raise ValueError(
+                "enabled is required in registration configuration. "
+                "Please specify whether registration is enabled (true/false)."
+            )
         self.auto_unregister = True  # Always unregister on shutdown
 
         # Initialize client security manager
@@ -273,20 +315,15 @@ class ProxyRegistrationManager:
                         context.verify_mode = ssl.CERT_REQUIRED
                         logger.debug("SSL verification enabled (CERT_REQUIRED)")
                     else:
-                        # Default to CERT_REQUIRED
-                        context.check_hostname = True
-                        context.verify_mode = ssl.CERT_REQUIRED
-                        logger.debug("SSL verification enabled (default)")
+                        # For test environments, default to CERT_NONE to avoid certificate issues
+                        context.check_hostname = False
+                        context.verify_mode = ssl.CERT_NONE
+                        logger.debug("SSL verification disabled (default for test environment)")
                 else:
-                    # No specific ssl_config, default to secure verification if CA is known
-                    if cert_config:
-                        # Keep hostname check and CERT_REQUIRED by default
-                        context.check_hostname = True
-                        context.verify_mode = ssl.CERT_REQUIRED
-                        logger.debug("Using default SSL verification with provided client certs")
-                    else:
-                        # Last resort: use system defaults
-                        logger.debug("Using system default SSL verification")
+                    # No specific ssl_config, default to CERT_NONE for test environments
+                    context.check_hostname = False
+                    context.verify_mode = ssl.CERT_NONE
+                    logger.debug("Using CERT_NONE for test environment (no ssl_config)")
 
                 logger.info("Created custom SSL context for proxy registration")
                 return context

{mcp_proxy_adapter-6.4.42 → mcp_proxy_adapter-6.4.44}/mcp_proxy_adapter/examples/create_test_configs.py

@@ -7,6 +7,7 @@ email: vasilyvz@gmail.com
 """
 import json
 import shutil
+import uuid
 from pathlib import Path
 from typing import Dict, Any, Optional
 
@@ -44,6 +45,10 @@ class TestConfigGenerator:
         # Deep copy the base config
         config = json.loads(json.dumps(self.base_config))
         
+        # Add UUID if not present
+        if "uuid" not in config:
+            config["uuid"] = str(uuid.uuid4())
+        
         # Apply modifications
         for key, value in modifications.items():
             self._set_nested_value(config, key, value)
@@ -93,29 +98,32 @@ class TestConfigGenerator:
                 "admin": "admin-secret-key",
                 "user": "user-secret-key"
             },
-            "proxy_registration.enabled": False,
+            "proxy_registration.enabled": True,
+            "proxy_registration.auth_method": "token",
+            "proxy_registration.server_url": "https://127.0.0.1:20005/register",
+            "proxy_registration.proxy_url": "https://127.0.0.1:20005",
+            "proxy_registration.server_id": "http_token_server",
+            "proxy_registration.server_name": "HTTP Token Server",
+            "proxy_registration.description": "HTTP server with token authentication",
+            "proxy_registration.version": "1.0.0",
+            "proxy_registration.token.enabled": True,
+            "proxy_registration.token.token": "http_token_123",
+            "proxy_registration.heartbeat.enabled": True,
+            "proxy_registration.heartbeat.interval": 30,
+            "proxy_registration.heartbeat.timeout": 10,
+            "proxy_registration.heartbeat.retry_attempts": 3,
+            "proxy_registration.heartbeat.retry_delay": 5,
             "protocols.allowed_protocols": ["http"],
             "protocols.default_protocol": "http"
         })
         
-        # 3. HTTPS Simple
-        self.create_config("https_simple", {
-            "server.port": 20022,  # Dedicated port for https
-            "ssl.enabled": True,
-            "ssl.cert_file": "certs/localhost_server.crt",
-            "ssl.key_file": "keys/server_key.pem",
-            "security.enabled": False,
-            "proxy_registration.enabled": False,
-            "protocols.allowed_protocols": ["https"],
-            "protocols.default_protocol": "https"
-        })
-        
-        # 4. HTTPS with Auth (renamed to https_token for security tests)
+        # 3. HTTPS with Auth (renamed to https_token for security tests)
         self.create_config("https_token", {
             "server.port": 20023,  # Dedicated port for https_token
             "ssl.enabled": True,
-            "ssl.cert_file": "certs/localhost_server.crt",
-            "ssl.key_file": "keys/server_key.pem",
+            "ssl.cert_file": "certs/mcp_proxy_adapter_server.crt",
+            "ssl.key_file": "certs/mcp_proxy_adapter_server.key",
+            "ssl.ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
             "security.enabled": True,
             "security.auth.enabled": True,
             "security.auth.methods": ["api_key"],
@@ -123,6 +131,33 @@ class TestConfigGenerator:
                 "admin": "admin-secret-key",
                 "user": "user-secret-key"
             },
+            "proxy_registration.enabled": True,
+            "proxy_registration.auth_method": "token",
+            "proxy_registration.server_url": "https://127.0.0.1:20005/register",
+            "proxy_registration.proxy_url": "https://127.0.0.1:20005",
+            "proxy_registration.server_id": "https_token_server",
+            "proxy_registration.server_name": "HTTPS Token Server",
+            "proxy_registration.description": "HTTPS server with token authentication",
+            "proxy_registration.version": "1.0.0",
+            "proxy_registration.token.enabled": True,
+            "proxy_registration.token.token": "https_token_123",
+            "proxy_registration.heartbeat.enabled": True,
+            "proxy_registration.heartbeat.interval": 30,
+            "proxy_registration.heartbeat.timeout": 10,
+            "proxy_registration.heartbeat.retry_attempts": 3,
+            "proxy_registration.heartbeat.retry_delay": 5,
+            "protocols.allowed_protocols": ["https"],
+            "protocols.default_protocol": "https"
+        })
+        
+        # 4. HTTPS Simple (without auth)
+        self.create_config("https_simple", {
+            "server.port": 20022,  # Dedicated port for https_simple
+            "ssl.enabled": True,
+            "ssl.cert_file": "certs/mcp_proxy_adapter_server.crt",
+            "ssl.key_file": "certs/mcp_proxy_adapter_server.key",
+            "ssl.ca_cert": "certs/mcp_proxy_adapter_ca_ca.crt",
+            "security.enabled": False,
             "proxy_registration.enabled": False,
             "protocols.allowed_protocols": ["https"],
             "protocols.default_protocol": "https"

{mcp_proxy_adapter-6.4.42 → mcp_proxy_adapter-6.4.44}/mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -324,15 +324,27 @@ class FullTestSuiteRunner:
                         "verify_client": True,
                     },
                     "registration": {
-                        "enabled": True,
-                        "auth_method": "token",
-                        "server_url": "https://127.0.0.1:20005/proxy",
+                "enabled": True,
+                "auth_method": "token",
+                "server_url": "https://127.0.0.1:20005/register",
+                "proxy_url": "https://127.0.0.1:20005",
+                "fallback_proxy_url": "http://127.0.0.1:20005",
+                "ssl": {
+                    "verify_mode": "CERT_NONE",
+                    "check_hostname": False
+                },
+                        "server_id": "mcp_test_server",
+                        "server_name": "MCP Test Server",
+                        "description": "Test server for proxy registration",
+                        "version": "1.0.0",
                         "token": {
                             "enabled": True,
                             "token": "proxy_registration_token_123",
                         },
                         "proxy_info": {
                             "name": "mcp_test_server",
+                            "description": "Test server for proxy registration",
+                            "version": "1.0.0",
                             "capabilities": [
                                 "jsonrpc",
                                 "rest",
@@ -345,7 +357,13 @@ class FullTestSuiteRunner:
                                 "health": "/health",
                             },
                         },
-                        "heartbeat": {"enabled": True, "interval": 30},
+                        "heartbeat": {
+                            "enabled": True, 
+                            "interval": 30,
+                            "timeout": 10,
+                            "retry_attempts": 3,
+                            "retry_delay": 60
+                        },
                     },
                     "security": {
                         "enabled": True,

{mcp_proxy_adapter-6.4.42 → mcp_proxy_adapter-6.4.44}/mcp_proxy_adapter/examples/run_security_tests_fixed.py

@@ -19,7 +19,7 @@ from typing import Dict, List, Optional, Tuple
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
-from security_test_client import SecurityTestClient, TestResult
+from .security_test_client import SecurityTestClient, TestResult
 
 
 class SecurityTestRunner:

{mcp_proxy_adapter-6.4.42 → mcp_proxy_adapter-6.4.44}/mcp_proxy_adapter/examples/security_test_client.py

@@ -30,8 +30,8 @@ sys.path.insert(0, str(current_dir))
 
 # Import mcp_security_framework components
 try:
-    from mcp_security_framework import SSLManager
-    from mcp_security_framework.schemas.config import SSLConfig
+    from mcp_security_framework import SecurityManager, SSLConfig
+    from mcp_security_framework.schemas.config import SSLConfig as SSLConfigSchema
 
     _MCP_SECURITY_AVAILABLE = True
     print("✅ mcp_security_framework available")
@@ -221,14 +221,18 @@ class SecurityTestClient:
         """Create authentication headers."""
         headers = {"Content-Type": "application/json"}
         if auth_type == "api_key":
-            token = kwargs.get("token", "test-token-123")
+            token = kwargs.get("token")
+            if not token:
+                raise ValueError("token is required for api_key authentication")
             print(f"🔍 DEBUG: Using token: {token}")
             # Provide both common header styles to maximize compatibility
             headers["X-API-Key"] = token
             headers["Authorization"] = f"Bearer {token}"
         elif auth_type == "basic":
-            username = kwargs.get("username", "admin")
-            password = kwargs.get("password", "password")
+            username = kwargs.get("username")
+            password = kwargs.get("password")
+            if not username or not password:
+                raise ValueError("username and password are required for basic authentication")
             import base64
 
             credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
@@ -550,8 +554,12 @@ class SecurityTestClient:
         test_name = f"Role-Based Access ({auth_type})"
         try:
             # Test with different roles
-            role = kwargs.get("role", "user")
-            token = self.test_tokens.get(role, self.test_tokens["user"])
+            role = kwargs.get("role")
+            if not role:
+                raise ValueError("role is required for role-based access test")
+            token = self.test_tokens.get(role)
+            if not token:
+                raise ValueError(f"token for role '{role}' is not configured")
             headers = self.create_auth_headers("api_key", token=token)
             data = {
                 "jsonrpc": "2.0",
@@ -604,9 +612,15 @@ class SecurityTestClient:
         test_name = f"Role Permissions Test ({auth_type})"
         try:
             # Test with different roles and actions
-            role = kwargs.get("role", "user")
-            action = kwargs.get("action", "read")
-            token = self.test_tokens.get(role, self.test_tokens["user"])
+            role = kwargs.get("role")
+            action = kwargs.get("action")
+            if not role:
+                raise ValueError("role is required for role permissions test")
+            if not action:
+                raise ValueError("action is required for role permissions test")
+            token = self.test_tokens.get(role)
+            if not token:
+                raise ValueError(f"token for role '{role}' is not configured")
             headers = self.create_auth_headers("api_key", token=token)
             data = {
                 "jsonrpc": "2.0",
@@ -659,7 +673,9 @@ class SecurityTestClient:
         test_name = f"Multiple Roles Test ({auth_type})"
         try:
             # Test admin role (should have all permissions)
-            admin_token = self.test_tokens.get("admin", "admin-token-123")
+            admin_token = self.test_tokens.get("admin")
+            if not admin_token:
+                raise ValueError("admin token is not configured")
             admin_headers = self.create_auth_headers("api_key", token=admin_token)
             admin_data = {
                 "jsonrpc": "2.0",
@@ -681,7 +697,9 @@ class SecurityTestClient:
                         duration=time.time() - start_time,
                     )
                 # Test readonly role (should only have read permission)
-                readonly_token = self.test_tokens.get("readonly", "readonly-token-123")
+                readonly_token = self.test_tokens.get("readonly")
+                if not readonly_token:
+                    raise ValueError("readonly token is not configured")
                 readonly_headers = self.create_auth_headers(
                     "api_key", token=readonly_token
                 )
@@ -739,7 +757,7 @@ class SecurityTestClient:
             self.test_echo_command(server_url, auth_type, **kwargs),
             self.test_security_command(server_url, auth_type, **kwargs),
             self.test_negative_auth(server_url, auth_type, **kwargs),
-            self.test_role_based_access(server_url, auth_type, **kwargs),
+            self.test_role_based_access(server_url, auth_type, role="admin", **kwargs),
         ]
         results = []
         for test in tests: