mcp-proxy-adapter 6.6.8__tar.gz → 6.6.9__tar.gz

{mcp_proxy_adapter-6.6.8 → mcp_proxy_adapter-6.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.6.8
+Version: 6.6.9
 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.6.8 → mcp_proxy_adapter-6.6.9}/mcp_proxy_adapter/api/app.py

@@ -41,6 +41,81 @@ from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.custom_openapi import custom_openapi_with_fallback
 
 
+def _determine_registration_url(config: Dict[str, Any]) -> str:
+    """
+    Determine the registration URL for proxy registration.
+    
+    Logic:
+    1. Protocol: registration.protocol > server.protocol > fallback to http
+    2. Host: public_host > hostname (if server.host is 0.0.0.0/127.0.0.1) > server.host
+    3. Port: public_port > server.port
+    
+    Args:
+        config: Application configuration
+        
+    Returns:
+        Complete registration URL
+    """
+    import os
+    import socket
+    
+    # Get server configuration
+    server_config = config.get("server", {})
+    server_host = server_config.get("host", "0.0.0.0")
+    server_port = server_config.get("port", 8000)
+    server_protocol = server_config.get("protocol", "http")
+    
+    # Get registration configuration
+    reg_cfg = config.get("registration", config.get("proxy_registration", {}))
+    public_host = reg_cfg.get("public_host")
+    public_port = reg_cfg.get("public_port")
+    registration_protocol = reg_cfg.get("protocol")
+    
+    # Determine protocol
+    if registration_protocol:
+        # Use protocol from registration configuration
+        # Convert mtls to https for URL construction (mTLS is still HTTPS)
+        protocol = "https" if registration_protocol == "mtls" else registration_protocol
+        logger.info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
+    else:
+        # Fallback to server protocol
+        verify_client = config.get("transport", {}).get("verify_client", False)
+        ssl_enabled = server_protocol in ["https", "mtls"] or verify_client
+        protocol = "https" if ssl_enabled else "http"
+        logger.info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client})")
+    
+    # Determine host
+    if not public_host:
+        if server_host in ("0.0.0.0", "127.0.0.1"):
+            # Try to get hostname, fallback to docker host addr
+            try:
+                hostname = socket.gethostname()
+                # Use hostname if it's not localhost
+                if hostname and hostname not in ("localhost", "127.0.0.1"):
+                    resolved_host = hostname
+                else:
+                    resolved_host = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+            except Exception:
+                resolved_host = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
+        else:
+            resolved_host = server_host
+    else:
+        resolved_host = public_host
+        
+    # Determine port
+    resolved_port = public_port or server_port
+    
+    # Build URL
+    server_url = f"{protocol}://{resolved_host}:{resolved_port}"
+    
+    logger.info(
+        "🔍 Registration URL selection: server_host=%s, server_port=%s, public_host=%s, public_port=%s, protocol=%s, resolved_host=%s, resolved_port=%s, server_url=%s",
+        server_host, server_port, public_host, public_port, protocol, resolved_host, resolved_port, server_url
+    )
+    
+    return server_url
+
+
 def create_lifespan(config_path: Optional[str] = None):
     """
     Create lifespan manager for the FastAPI application.
@@ -81,33 +156,8 @@ def create_lifespan(config_path: Optional[str] = None):
         if not server_port:
             raise ValueError("server.port is required")
 
-        reg_cfg = config.get("registration", {})
-        public_host = reg_cfg.get("public_host")
-        public_port = reg_cfg.get("public_port")
-
-        # Check SSL configuration from new structure
-        # Priority: registration.protocol > server.protocol > fallback to http
-        reg_cfg = config.get("registration", {})
-        registration_protocol = reg_cfg.get("protocol")
-        server_protocol = config.get("server.protocol", "http")
-        
-        if registration_protocol:
-            # Use protocol from registration configuration
-            # Convert mtls to https for URL construction (mTLS is still HTTPS)
-            protocol = "https" if registration_protocol == "mtls" else registration_protocol
-            logger.info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
-        else:
-            # Fallback to server protocol
-            verify_client = config.get("transport.verify_client", False)
-            ssl_enabled = server_protocol in ["https", "mtls"] or verify_client
-            protocol = "https" if ssl_enabled else "http"
-            logger.info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client})")
-
-        import os
-        docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
-        target_host = public_host or (docker_host_addr if server_host == "0.0.0.0" else server_host)
-        target_port = public_port or server_port
-        early_server_url = f"{protocol}://{target_host}:{target_port}"
+        # Determine registration URL using unified logic
+        early_server_url = _determine_registration_url(config)
         try:
             from mcp_proxy_adapter.core.proxy_registration import (
                 proxy_registration_manager,
@@ -142,57 +192,8 @@ def create_lifespan(config_path: Optional[str] = None):
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
 
-            reg_cfg = final_config.get("registration", final_config.get("proxy_registration", {}))
-            public_host = reg_cfg.get("public_host")
-            public_port = reg_cfg.get("public_port")
-
-            # Determine protocol using the new configuration structure
-            # Priority: registration.protocol > server.protocol > fallback to http
-            reg_cfg = final_config.get("registration", final_config.get("proxy_registration", {}))
-            registration_protocol = reg_cfg.get("protocol")
-            server_protocol = final_config.get("server", {}).get("protocol", "http")
-            
-            if registration_protocol:
-                # Use protocol from registration configuration
-                # Convert mtls to https for URL construction (mTLS is still HTTPS)
-                protocol = "https" if registration_protocol == "mtls" else registration_protocol
-                logger.info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
-            else:
-                # Fallback to server protocol
-                verify_client_cfg = final_config.get("transport", {}).get("verify_client", False)
-                ssl_enabled_final = server_protocol in ["https", "mtls"] or verify_client_cfg
-                protocol = "https" if ssl_enabled_final else "http"
-                logger.info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client_cfg})")
-
-            import os
-            docker_host_addr = os.getenv("DOCKER_HOST_ADDR", "172.17.0.1")
-            resolved_host = public_host or (docker_host_addr if server_host == "0.0.0.0" else server_host)
-            resolved_port = public_port or server_port
-            server_url = f"{protocol}://{resolved_host}:{resolved_port}"
-
-            logger.info(
-                "🔍 Registration URL selection: server_host=%s, server_port=%s, public_host=%s, public_port=%s, protocol=%s",
-                server_host,
-                server_port,
-                public_host,
-                public_port,
-                protocol,
-            )
-            try:
-                print(
-                    "🔍 Registration URL selection (print):",
-                    {
-                        "server_host": server_host,
-                        "server_port": server_port,
-                        "public_host": public_host,
-                        "public_port": public_port,
-                        "protocol": protocol,
-                    },
-                )
-            except Exception:
-                pass
-
-            logger.debug("Registration server_url resolved to: %s", server_url)
+            # Determine registration URL using unified logic
+            server_url = _determine_registration_url(final_config)
             try:
                 print("🔍 Registration server_url resolved to (print):", server_url)
             except Exception:

{mcp_proxy_adapter-6.6.8 → mcp_proxy_adapter-6.6.9}/mcp_proxy_adapter/examples/config_builder.py

@@ -83,13 +83,13 @@ class ConfigBuilder:
             "registration": {
                 "enabled": False,
                 "proxy_url": "http://localhost:3004",
-                "public_host": None,
-                "public_port": None,
-                "protocol": None,  # Will be set based on server protocol
+                "public_host": None,  # Auto-determined from hostname or server.host
+                "public_port": None,  # Auto-determined from server.port
+                "protocol": None,     # Auto-determined from server.protocol
                 "server_id": "mcp_proxy_adapter",
                 "server_name": "MCP Proxy Adapter",
                 "description": "JSON-RPC API for interacting with MCP Proxy",
-                "version": "6.6.7",
+                "version": "6.6.9",
                 "heartbeat": {
                     "enabled": True,
                     "interval": 30,
@@ -172,9 +172,9 @@ class ConfigBuilder:
         return self
     
     def set_proxy_registration(self, enabled: bool = True, proxy_url: str = "http://localhost:3004", 
-                              public_host: Optional[str] = None, public_port: Optional[int] = None,
-                              server_id: str = "mcp_proxy_adapter", server_name: str = "MCP Proxy Adapter",
-                              description: str = "JSON-RPC API for interacting with MCP Proxy"):
+                               public_host: Optional[str] = None, public_port: Optional[int] = None,
+                               server_id: str = "mcp_proxy_adapter", server_name: str = "MCP Proxy Adapter",
+                               description: str = "JSON-RPC API for interacting with MCP Proxy"):
         """Set proxy registration configuration."""
         self.config["registration"]["enabled"] = enabled
         self.config["registration"]["proxy_url"] = proxy_url
@@ -190,6 +190,35 @@ class ConfigBuilder:
         
         return self
     
+    def enable_auto_registration(self, proxy_url: str = "http://localhost:3004", 
+                                server_id: str = "mcp_proxy_adapter", 
+                                server_name: str = "MCP Proxy Adapter",
+                                description: str = "JSON-RPC API for interacting with MCP Proxy"):
+        """
+        Enable automatic proxy registration with auto-determined parameters.
+        
+        This method enables registration with automatic determination of:
+        - public_host: from hostname (if server.host is 0.0.0.0/127.0.0.1) or server.host
+        - public_port: from server.port
+        - protocol: from server.protocol
+        
+        Args:
+            proxy_url: URL of the proxy server
+            server_id: Unique identifier for this server
+            server_name: Human-readable name for this server
+            description: Description of this server
+        """
+        self.config["registration"]["enabled"] = True
+        self.config["registration"]["proxy_url"] = proxy_url
+        self.config["registration"]["public_host"] = None  # Auto-determined
+        self.config["registration"]["public_port"] = None  # Auto-determined
+        self.config["registration"]["protocol"] = None     # Auto-determined
+        self.config["registration"]["server_id"] = server_id
+        self.config["registration"]["server_name"] = server_name
+        self.config["registration"]["description"] = description
+        
+        return self
+    
     def build(self) -> Dict[str, Any]:
         """Build and return the configuration."""
         return self.config.copy()
@@ -307,10 +336,41 @@ class ConfigFactory:
                 .set_server(port=port)
                 .set_proxy_registration(proxy_url=proxy_url)
                 .build())
+    
+    @staticmethod
+    def create_http_with_auto_registration(port: int = 8009, proxy_url: str = "http://localhost:3004", 
+                                         server_id: str = "mcp_proxy_adapter") -> Dict[str, Any]:
+        """Create HTTP configuration with automatic proxy registration."""
+        return (ConfigBuilder()
+                .set_protocol(Protocol.HTTP)
+                .set_server(port=port)
+                .enable_auto_registration(proxy_url=proxy_url, server_id=server_id)
+                .build())
+    
+    @staticmethod
+    def create_https_with_auto_registration(port: int = 8010, proxy_url: str = "https://localhost:3004", 
+                                          server_id: str = "mcp_proxy_adapter") -> Dict[str, Any]:
+        """Create HTTPS configuration with automatic proxy registration."""
+        return (ConfigBuilder()
+                .set_protocol(Protocol.HTTPS)
+                .set_server(port=port)
+                .enable_auto_registration(proxy_url=proxy_url, server_id=server_id)
+                .build())
+    
+    @staticmethod
+    def create_mtls_with_auto_registration(port: int = 8011, proxy_url: str = "https://localhost:3004", 
+                                         server_id: str = "mcp_proxy_adapter") -> Dict[str, Any]:
+        """Create mTLS configuration with automatic proxy registration."""
+        return (ConfigBuilder()
+                .set_protocol(Protocol.MTLS)
+                .set_server(port=port)
+                .enable_auto_registration(proxy_url=proxy_url, server_id=server_id)
+                .build())
 
 
 def create_config_from_flags(protocol: str, token: bool = False, roles: bool = False, port: int = 8000, 
-                           proxy_registration: bool = False, proxy_url: str = "http://localhost:3004") -> Dict[str, Any]:
+                           proxy_registration: bool = False, proxy_url: str = "http://localhost:3004",
+                           auto_registration: bool = False, server_id: str = "mcp_proxy_adapter") -> Dict[str, Any]:
     """
     Create configuration from command line flags.
     
@@ -319,8 +379,10 @@ def create_config_from_flags(protocol: str, token: bool = False, roles: bool = F
         token: Enable token authentication
         roles: Enable role-based access control
         port: Server port
-        proxy_registration: Enable proxy registration
+        proxy_registration: Enable proxy registration with manual settings
         proxy_url: Proxy URL for registration
+        auto_registration: Enable automatic proxy registration (auto-determined parameters)
+        server_id: Server ID for registration
         
     Returns:
         Configuration dictionary
@@ -344,7 +406,11 @@ def create_config_from_flags(protocol: str, token: bool = False, roles: bool = F
         builder.set_auth(AuthMethod.NONE)
     
     # Enable proxy registration if requested
-    if proxy_registration:
+    if auto_registration:
+        # Use automatic registration with auto-determined parameters
+        builder.enable_auto_registration(proxy_url=proxy_url, server_id=server_id)
+    elif proxy_registration:
+        # Use manual registration settings
         builder.set_proxy_registration(proxy_url=proxy_url)
     
     return builder.build()

{mcp_proxy_adapter-6.6.8 → mcp_proxy_adapter-6.6.9}/mcp_proxy_adapter/examples/generate_config.py

@@ -241,8 +241,11 @@ Examples:
   # Generate mTLS configuration with roles
   python generate_config.py --protocol mtls --roles
   
-  # Generate mTLS configuration with proxy registration
-  python generate_config.py --protocol mtls --proxy-registration --proxy-url https://mcp-proxy:3004
+        # Generate mTLS configuration with automatic proxy registration
+        python generate_config.py --protocol mtls --auto-registration --proxy-url https://mcp-proxy:3004
+        
+        # Generate HTTP configuration with automatic proxy registration
+        python generate_config.py --protocol http --proxy-registration --proxy-url http://localhost:3004
         """
     )
     
@@ -254,9 +257,11 @@ Examples:
     parser.add_argument("--roles", action="store_true", 
                        help="Enable role-based access control")
     parser.add_argument("--proxy-registration", action="store_true", 
-                       help="Enable proxy registration")
+                       help="Enable proxy registration with auto-determined parameters")
     parser.add_argument("--proxy-url", default="http://localhost:3004", 
                        help="Proxy URL for registration (default: http://localhost:3004)")
+    parser.add_argument("--auto-registration", action="store_true",
+                       help="Enable automatic proxy registration (same as --proxy-registration)")
     parser.add_argument("--all", action="store_true", 
                        help="Generate all standard configurations")
     parser.add_argument("--full-config", action="store_true", 
@@ -308,18 +313,15 @@ Examples:
                 print(f"✅ Full configuration saved to: {config_file}")
         elif args.protocol:
             # Generate specific configuration
-            config = create_config_from_flags(
-                protocol=args.protocol,
-                token=args.token,
-                roles=args.roles,
-                host=args.host,
-                port=args.port,
-                cert_dir=args.cert_dir,
-                key_dir=args.key_dir,
-                output_dir=args.output_dir,
-                proxy_registration=args.proxy_registration,
-                proxy_url=args.proxy_url
-            )
+                config = create_config_from_flags(
+                    protocol=args.protocol,
+                    token=args.token,
+                    roles=args.roles,
+                    port=args.port,
+                    proxy_registration=args.proxy_registration,
+                    proxy_url=args.proxy_url,
+                    auto_registration=args.auto_registration
+                )
             
             if args.stdout:
                 # Output to stdout

{mcp_proxy_adapter-6.6.8 → mcp_proxy_adapter-6.6.9}/mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.6.8 → mcp_proxy_adapter-6.6.9}/mcp_proxy_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-proxy-adapter
-Version: 6.6.8
+Version: 6.6.9
 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.6.8 → mcp_proxy_adapter-6.6.9}/pyproject.toml

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