mcp-proxy-adapter 6.7.0__tar.gz → 6.7.2__tar.gz

{mcp_proxy_adapter-6.7.0 → mcp_proxy_adapter-6.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.7.0
+Version: 6.7.2
 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.7.2/mcp_proxy_adapter/core/mtls_proxy.py

@@ -0,0 +1,181 @@
+"""
+mTLS Proxy for MCP Proxy Adapter
+
+This module provides mTLS proxy functionality that accepts mTLS connections
+and proxies them to the internal hypercorn server.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import ssl
+import logging
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class MTLSProxy:
+    """
+    mTLS Proxy that accepts mTLS connections and proxies them to internal server.
+    """
+    
+    def __init__(self, 
+                 external_host: str,
+                 external_port: int,
+                 internal_host: str = "127.0.0.1",
+                 internal_port: int = 9000,
+                 cert_file: Optional[str] = None,
+                 key_file: Optional[str] = None,
+                 ca_cert: Optional[str] = None):
+        """
+        Initialize mTLS Proxy.
+        
+        Args:
+            external_host: External host to bind to
+            external_port: External port to bind to
+            internal_host: Internal server host
+            internal_port: Internal server port
+            cert_file: Server certificate file
+            key_file: Server private key file
+            ca_cert: CA certificate file for client verification
+        """
+        self.external_host = external_host
+        self.external_port = external_port
+        self.internal_host = internal_host
+        self.internal_port = internal_port
+        self.cert_file = cert_file
+        self.key_file = key_file
+        self.ca_cert = ca_cert
+        self.server = None
+        
+    async def start(self):
+        """Start the mTLS proxy server."""
+        try:
+            # Create SSL context
+            ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            ssl_context.load_cert_chain(self.cert_file, self.key_file)
+            
+            if self.ca_cert:
+                ssl_context.load_verify_locations(self.ca_cert)
+                ssl_context.verify_mode = ssl.CERT_REQUIRED
+            else:
+                ssl_context.verify_mode = ssl.CERT_NONE
+                
+            # Start server
+            self.server = await asyncio.start_server(
+                self._handle_client,
+                self.external_host,
+                self.external_port,
+                ssl=ssl_context
+            )
+            
+            logger.info(f"🔐 mTLS Proxy started on {self.external_host}:{self.external_port}")
+            logger.info(f"🌐 Proxying to {self.internal_host}:{self.internal_port}")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to start mTLS proxy: {e}")
+            raise
+            
+    async def stop(self):
+        """Stop the mTLS proxy server."""
+        if self.server:
+            self.server.close()
+            await self.server.wait_closed()
+            logger.info("🔐 mTLS Proxy stopped")
+            
+    async def _handle_client(self, reader, writer):
+        """Handle client connection."""
+        try:
+            # Get client address
+            client_addr = writer.get_extra_info('peername')
+            logger.info(f"🔐 mTLS connection from {client_addr}")
+            
+            # Connect to internal server
+            internal_reader, internal_writer = await asyncio.open_connection(
+                self.internal_host, self.internal_port
+            )
+            
+            # Create bidirectional proxy
+            await asyncio.gather(
+                self._proxy_data(reader, internal_writer, "client->server"),
+                self._proxy_data(internal_reader, writer, "server->client")
+            )
+            
+        except Exception as e:
+            logger.error(f"❌ Error handling client connection: {e}")
+        finally:
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except:
+                pass
+                
+    async def _proxy_data(self, reader, writer, direction):
+        """Proxy data between reader and writer."""
+        try:
+            while True:
+                data = await reader.read(4096)
+                if not data:
+                    break
+                writer.write(data)
+                await writer.drain()
+        except Exception as e:
+            logger.debug(f"Proxy connection closed ({direction}): {e}")
+        finally:
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except:
+                pass
+
+
+async def start_mtls_proxy(config: Dict[str, Any]) -> Optional[MTLSProxy]:
+    """
+    Start mTLS proxy based on configuration.
+    
+    Args:
+        config: Application configuration
+        
+    Returns:
+        MTLSProxy instance if started, None otherwise
+    """
+    # Check if mTLS is enabled
+    protocol = config.get("server", {}).get("protocol", "http")
+    verify_client = config.get("transport", {}).get("verify_client", False)
+    
+    # Only start mTLS proxy if mTLS is explicitly enabled
+    if protocol != "mtls" and not verify_client:
+        logger.info("🌐 Regular mode: no mTLS proxy needed")
+        return None
+        
+    # Get configuration
+    server_config = config.get("server", {})
+    transport_config = config.get("transport", {})
+    
+    external_host = server_config.get("host", "0.0.0.0")
+    external_port = server_config.get("port", 8000)
+    internal_port = external_port + 1000  # Internal port
+    
+    cert_file = transport_config.get("cert_file")
+    key_file = transport_config.get("key_file")
+    ca_cert = transport_config.get("ca_cert")
+    
+    if not cert_file or not key_file:
+        logger.warning("⚠️  mTLS enabled but certificates not configured")
+        return None
+        
+    # Create and start proxy
+    proxy = MTLSProxy(
+        external_host=external_host,
+        external_port=external_port,
+        internal_port=internal_port,
+        cert_file=cert_file,
+        key_file=key_file,
+        ca_cert=ca_cert
+    )
+    
+    await proxy.start()
+    return proxy

{mcp_proxy_adapter-6.7.0 → mcp_proxy_adapter-6.7.2}/mcp_proxy_adapter/core/proxy_registration.py

@@ -132,40 +132,43 @@ class ProxyRegistrationManager:
         # Heartbeat settings - only validate if enabled
         if self.enabled:
             heartbeat_config = self.registration_config.get("heartbeat", {})
-            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."
-                )
+            heartbeat_enabled = heartbeat_config.get("enabled", True)
+            
+            if heartbeat_enabled:
+                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."
+                    )
+            else:
+                # Heartbeat disabled - use defaults
+                self.timeout = heartbeat_config.get("timeout", 30)
+                self.retry_attempts = heartbeat_config.get("retry_attempts", 3)
+                self.retry_delay = heartbeat_config.get("retry_delay", 5)
+                self.heartbeat_interval = heartbeat_config.get("interval", 30)
         else:
             self.timeout = None
             self.retry_attempts = None
-            
-        if self.enabled:
-            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."
-                )
-        else:
             self.retry_delay = None
-            
-        if self.enabled:
-            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."
-                )
-        else:
             self.heartbeat_interval = None
 
         # Auto registration settings
@@ -782,6 +785,15 @@ class ProxyRegistrationManager:
             except Exception as e:
                 logger.error(f"Heartbeat error: {e}")
 
+    async def heartbeat(self) -> bool:
+        """
+        Public method to send heartbeat to proxy server.
+        
+        Returns:
+            True if heartbeat was successful, False otherwise.
+        """
+        return await self._send_heartbeat()
+
     async def _send_heartbeat(self) -> bool:
         """Send heartbeat to proxy server."""
         if not self.server_key:

{mcp_proxy_adapter-6.7.0 → mcp_proxy_adapter-6.7.2}/mcp_proxy_adapter/main.py

@@ -89,8 +89,23 @@ def main():
     verify_client = config.get("transport.verify_client", False)
     chk_hostname = config.get("transport.chk_hostname", False)
     
-    # SSL enabled if protocol is HTTPS or mTLS (verify_client=True)
-    ssl_enabled = protocol in ["https", "mtls"] or verify_client
+    # Check if mTLS is required
+    is_mtls_mode = protocol == "mtls" or verify_client
+    
+    if is_mtls_mode:
+        # mTLS mode: hypercorn on localhost, mTLS proxy on external port
+        hypercorn_host = "127.0.0.1"  # localhost only
+        hypercorn_port = port + 1000   # internal port
+        mtls_proxy_port = port         # external port
+        ssl_enabled = True
+        print(f"🔐 mTLS Mode: hypercorn on {hypercorn_host}:{hypercorn_port}, mTLS proxy on {host}:{mtls_proxy_port}")
+    else:
+        # Regular mode: hypercorn on external port (no proxy needed)
+        hypercorn_host = host
+        hypercorn_port = port
+        mtls_proxy_port = None
+        ssl_enabled = protocol == "https"
+        print(f"🌐 Regular Mode: hypercorn on {hypercorn_host}:{hypercorn_port}")
     
     # SSL configuration based on protocol
     ssl_cert_file = None
@@ -118,7 +133,11 @@ def main():
     print("🔍 Source: configuration")
 
     print("🚀 Starting MCP Proxy Adapter")
-    print(f"🌐 Server: {host}:{port}")
+    if mtls_proxy_port:
+        print(f"🔐 mTLS Proxy: {host}:{mtls_proxy_port}")
+        print(f"🌐 Internal Server: {hypercorn_host}:{hypercorn_port}")
+    else:
+        print(f"🌐 Server: {hypercorn_host}:{hypercorn_port}")
     print(f"🔒 Protocol: {protocol}")
     if ssl_enabled:
         print("🔐 SSL: Enabled")
@@ -131,7 +150,7 @@ def main():
 
     # Configure hypercorn using framework
     config_hypercorn = hypercorn.config.Config()
-    config_hypercorn.bind = [f"{host}:{port}"]
+    config_hypercorn.bind = [f"{hypercorn_host}:{hypercorn_port}"]
 
     if ssl_enabled and ssl_cert_file and ssl_key_file:
         # Use framework to convert SSL configuration
@@ -201,7 +220,33 @@ def main():
 
     # Run the server
     try:
-        asyncio.run(hypercorn.asyncio.serve(app, config_hypercorn))
+        if is_mtls_mode:
+            # mTLS mode: start hypercorn and mTLS proxy
+            print("🔐 Starting mTLS mode with proxy...")
+            
+            async def run_mtls_mode():
+                # Start hypercorn server on localhost
+                hypercorn_task = asyncio.create_task(
+                    hypercorn.asyncio.serve(app, config_hypercorn)
+                )
+                
+                # Start mTLS proxy on external port
+                from mcp_proxy_adapter.core.mtls_proxy import start_mtls_proxy
+                proxy = await start_mtls_proxy(config.get_all())
+                
+                if proxy:
+                    print("✅ mTLS proxy started successfully")
+                else:
+                    print("⚠️  mTLS proxy not started, running hypercorn only")
+                
+                # Wait for hypercorn
+                await hypercorn_task
+                
+            asyncio.run(run_mtls_mode())
+        else:
+            # Regular mode: start hypercorn only (no proxy needed)
+            print("🌐 Starting regular mode...")
+            asyncio.run(hypercorn.asyncio.serve(app, config_hypercorn))
     except KeyboardInterrupt:
         print("\n🛑 Server stopped by user (Ctrl+C)")
         if is_shutdown_requested():

{mcp_proxy_adapter-6.7.0 → mcp_proxy_adapter-6.7.2}/mcp_proxy_adapter/version.py

@@ -2,4 +2,4 @@
 Version information for MCP Proxy Adapter.
 """
 
-__version__ = "6.7.0"
+__version__ = "6.7.2"

{mcp_proxy_adapter-6.7.0 → mcp_proxy_adapter-6.7.2}/mcp_proxy_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.7.0
+Version: 6.7.2
 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.7.0 → mcp_proxy_adapter-6.7.2}/mcp_proxy_adapter.egg-info/SOURCES.txt

@@ -72,6 +72,7 @@ setup.py
 ./mcp_proxy_adapter/core/logging.py
 ./mcp_proxy_adapter/core/mtls_asgi.py
 ./mcp_proxy_adapter/core/mtls_asgi_app.py
+./mcp_proxy_adapter/core/mtls_proxy.py
 ./mcp_proxy_adapter/core/mtls_server.py
 ./mcp_proxy_adapter/core/protocol_manager.py
 ./mcp_proxy_adapter/core/proxy_client.py
@@ -214,6 +215,7 @@ mcp_proxy_adapter/core/errors.py
 mcp_proxy_adapter/core/logging.py
 mcp_proxy_adapter/core/mtls_asgi.py
 mcp_proxy_adapter/core/mtls_asgi_app.py
+mcp_proxy_adapter/core/mtls_proxy.py
 mcp_proxy_adapter/core/mtls_server.py
 mcp_proxy_adapter/core/protocol_manager.py
 mcp_proxy_adapter/core/proxy_client.py

{mcp_proxy_adapter-6.7.0 → mcp_proxy_adapter-6.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-proxy-adapter"
-version = "6.7.0"
+version = "6.7.2"
 description = "Powerful JSON-RPC microservices framework with built-in security, authentication, and proxy registration"
 readme = "README.md"
 license = {text = "MIT"}