mcp-proxy-adapter 6.4.8__tar.gz → 6.4.10__tar.gz

{mcp_proxy_adapter-6.4.8 → mcp_proxy_adapter-6.4.10}/PKG-INFO

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

@@ -169,7 +169,7 @@ def create_lifespan(config_path: Optional[str] = None):
             except Exception:
                 pass
 
-            logger.info("🔍 Registration server_url resolved to: %s", server_url)
+            logger.debug("Registration server_url resolved to: %s", server_url)
             try:
                 print("🔍 Registration server_url resolved to (print):", server_url)
             except Exception:
@@ -494,6 +494,17 @@ def create_app(
         redoc_url="/redoc",
         lifespan=create_lifespan(config_path),
     )
+    
+    # CRITICAL FIX: Register commands immediately during app creation
+    # This ensures commands are available before the server starts accepting requests
+    try:
+        from mcp_proxy_adapter.commands.builtin_commands import register_builtin_commands
+        logger.info("Registering built-in commands during app creation...")
+        registered_count = register_builtin_commands()
+        logger.info(f"Registered {registered_count} built-in commands during app creation")
+    except Exception as e:
+        logger.error(f"Failed to register built-in commands during app creation: {e}")
+        # Don't fail app creation, but log the error
 
     # Configure CORS
     app.add_middleware(
@@ -507,14 +518,13 @@ def create_app(
     # Add request logging middleware for debugging
     @app.middleware("http")
     async def debug_request_middleware(request: Request, call_next):
-        logger.info(f"🔍 FastAPI Request START: {request.method} {request.url.path}")
-        logger.info(f"🔍 FastAPI Request Headers: {dict(request.headers)}")
+        logger.debug(f"FastAPI Request START: {request.method} {request.url.path}")
         try:
             response = await call_next(request)
-            logger.info(f"🔍 FastAPI Request COMPLETED: {response.status_code}")
+            logger.debug(f"FastAPI Request COMPLETED: {response.status_code}")
             return response
         except Exception as e:
-            logger.error(f"🔍 FastAPI Request ERROR: {e}", exc_info=True)
+            logger.error(f"FastAPI Request ERROR: {e}", exc_info=True)
             raise
 
     # Setup middleware using the new middleware package

{mcp_proxy_adapter-6.4.8 → mcp_proxy_adapter-6.4.10}/mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -97,26 +97,19 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Response object
         """
-        logger.info(f"🔍 PROTOCOL STEP 1: ProtocolMiddleware.dispatch START - {request.method} {request.url.path}")
-        logger.info(f"🔍 PROTOCOL STEP 1.1: Request scheme: {request.url.scheme}")
-        logger.info(f"🔍 PROTOCOL STEP 1.2: Request headers: {dict(request.headers)}")
-        logger.info(f"🔍 PROTOCOL STEP 1.3: Request scope: {request.scope}")
-        logger.info(f"🔍 PROTOCOL STEP 1.4: Protocol manager enabled: {self.protocol_manager.enabled}")
-        logger.info(f"🔍 PROTOCOL STEP 1.5: Protocol manager allowed_protocols: {self.protocol_manager.allowed_protocols}")
+        logger.debug(f"ProtocolMiddleware processing {request.method} {request.url.path}")
         
         try:
             # Get protocol from request
-            logger.info(f"🔍 PROTOCOL STEP 2: Getting request protocol...")
             protocol = self._get_request_protocol(request)
-            logger.info(f"🔍 PROTOCOL STEP 3: Detected protocol: {protocol} for {request.method} {request.url.path}")
+            logger.debug(f"Detected protocol: {protocol} for {request.method} {request.url.path}")
 
             # Check if protocol is allowed
-            logger.info(f"🔍 PROTOCOL STEP 4: Checking if protocol '{protocol}' is allowed...")
             is_allowed = self.protocol_manager.is_protocol_allowed(protocol)
-            logger.info(f"🔍 PROTOCOL STEP 5: Protocol '{protocol}' allowed: {is_allowed}")
+            logger.debug(f"Protocol '{protocol}' allowed: {is_allowed}")
             
             if not is_allowed:
-                logger.warning(f"❌ PROTOCOL STEP ERROR: Protocol '{protocol}' not allowed for request to {request.url.path}")
+                logger.warning(f"Protocol '{protocol}' not allowed for request to {request.url.path}")
                 return JSONResponse(
                     status_code=403,
                     content={
@@ -127,17 +120,11 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
                 )
 
             # Continue processing
-            logger.info(f"✅ PROTOCOL STEP 6: Protocol '{protocol}' allowed, proceeding...")
-            logger.info(f"🔍 PROTOCOL STEP 7: Adding protocol '{protocol}' to request state...")
             request.state.protocol = protocol
-            logger.info(f"🔍 PROTOCOL STEP 8: Protocol '{protocol}' added to request state")
+            logger.debug(f"Protocol '{protocol}' added to request state")
             
-            logger.info(f"🔍 PROTOCOL STEP 9: Calling next middleware/endpoint...")
             response = await call_next(request)
-            logger.info(f"🔍 PROTOCOL STEP 10: Next middleware/endpoint completed with status: {response.status_code}")
-            logger.info(f"🔍 PROTOCOL STEP 10.1: Response headers: {dict(response.headers)}")
-            
-            logger.info(f"✅ PROTOCOL STEP 11: ProtocolMiddleware completed successfully")
+            logger.debug(f"ProtocolMiddleware completed with status: {response.status_code}")
             return response
 
         except Exception as e:
@@ -157,63 +144,33 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Protocol name (http, https, mtls)
         """
-        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol START")
-        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - request.url.scheme: {request.url.scheme}")
-        
         try:
             # Check if request is secure (HTTPS)
             if request.url.scheme:
                 scheme = request.url.scheme.lower()
-                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - scheme: {scheme}")
 
                 # If HTTPS, check if client certificate is provided (MTLS)
                 if scheme == "https":
-                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - HTTPS detected, checking for mTLS")
-                    
                     # Check for client certificate in ASGI scope
                     try:
                         # Method 1: Check transport info in ASGI scope
                         if hasattr(request, "scope") and request.scope:
-                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - ASGI scope available")
-                            # Check for client certificate in transport layer
                             transport = request.scope.get("transport")
                             if transport and hasattr(transport, "get_extra_info"):
-                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - transport available, checking SSL object")
                                 try:
                                     ssl_object = transport.get_extra_info("ssl_object")
                                     if ssl_object:
-                                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - SSL object available, checking peer cert")
                                         try:
                                             cert = ssl_object.getpeercert()
                                             if cert:
-                                                logger.debug(f"✅ ProtocolMiddleware._get_request_protocol - mTLS client certificate detected: {cert.get('subject', 'unknown')}")
+                                                logger.debug(f"mTLS client certificate detected: {cert.get('subject', 'unknown')}")
                                                 return "mtls"
-                                            else:
-                                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No peer certificate found")
-                                        except Exception as e:
-                                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking client certificate: {e}")
-                                    else:
-                                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No SSL object found")
-                                except Exception as e:
-                                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error getting SSL object from transport: {e}")
-                            else:
-                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No transport or get_extra_info method")
-                            
-                            # Method 2: Check client info in ASGI scope
-                            try:
-                                client_info = request.scope.get("client")
-                                if client_info and len(client_info) > 2:
-                                    # client_info format: (host, port, additional_info...)
-                                    # Additional info might contain certificate information
-                                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Client info detected, might be mTLS: {client_info}")
-                                else:
-                                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Client info: {client_info}")
-                            except Exception as e:
-                                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking client info: {e}")
-                        else:
-                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No ASGI scope available")
-                    except Exception as e:
-                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking ASGI scope for mTLS: {e}")
+                                        except Exception:
+                                            pass
+                                except Exception:
+                                    pass
+                    except Exception:
+                        pass
 
                     # Check for client certificate in headers (proxy forwarded)
                     try:
@@ -224,31 +181,25 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
                             request.headers.get("x-forwarded-client-cert")
                         ]
                         if any(mtls_headers):
-                            logger.debug(f"✅ ProtocolMiddleware._get_request_protocol - mTLS client certificate detected in headers")
+                            logger.debug("mTLS client certificate detected in headers")
                             return "mtls"
-                        else:
-                            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - No mTLS headers found")
-                    except Exception as e:
-                        logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Error checking headers for mTLS: {e}")
+                    except Exception:
+                        pass
 
-                    logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Returning 'https' (no mTLS detected)")
                     return "https"
 
-                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Returning scheme: {scheme}")
                 return scheme
 
             # Fallback to checking headers
             x_forwarded_proto = request.headers.get("x-forwarded-proto")
             if x_forwarded_proto:
-                logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Using x-forwarded-proto: {x_forwarded_proto}")
                 return x_forwarded_proto.lower()
 
             # Default to HTTP
-            logger.debug(f"🔍 ProtocolMiddleware._get_request_protocol - Defaulting to 'http'")
             return "http"
             
         except Exception as e:
-            logger.error(f"❌ ProtocolMiddleware._get_request_protocol - Error: {e}", exc_info=True)
+            logger.error(f"Error extracting protocol from request: {e}", exc_info=True)
             # Fallback to HTTP if there's any error
             return "http"
 
@@ -261,43 +212,25 @@ def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
         app: FastAPI application
         app_config: Application configuration dictionary (optional)
     """
-    logger.info(f"🔍 SETUP STEP 1: setup_protocol_middleware - app_config type: {type(app_config)}")
-
     # Check if protocol management is enabled
     if app_config is None:
-        logger.info(f"🔍 SETUP STEP 2: app_config is None, loading from global config...")
         from mcp_proxy_adapter.config import config
-
         app_config = config.get_all()
-        logger.info(f"🔍 SETUP STEP 3: loaded from global config, type: {type(app_config)}")
-
-    logger.info(f"🔍 SETUP STEP 4: final app_config type: {type(app_config)}")
 
     if hasattr(app_config, "get"):
-        logger.info(f"🔍 SETUP STEP 5: app_config has 'get' method")
-        logger.info(f"🔍 SETUP STEP 5.1: app_config keys: {list(app_config.keys()) if hasattr(app_config, 'keys') else 'no keys'}")
         protocols_config = app_config.get("protocols", {})
-        logger.info(f"🔍 SETUP STEP 6: protocols_config: {protocols_config}")
-        logger.info(f"🔍 SETUP STEP 6.1: protocols_config type: {type(protocols_config)}")
         enabled = (
             protocols_config.get("enabled", True)
             if hasattr(protocols_config, "get")
             else True
         )
-        logger.info(f"🔍 SETUP STEP 7: protocols_config.get('enabled', True) = {enabled}")
     else:
-        logger.info(f"🔍 SETUP STEP 5: app_config is not dict-like: {repr(app_config)}")
         enabled = True
 
-    logger.info(f"🔍 SETUP STEP 8: protocol management enabled: {enabled}")
-
     if enabled:
         # Create protocol middleware with current configuration
-        logger.info(f"🔍 SETUP STEP 9: Creating ProtocolMiddleware with config type: {type(app_config)}")
         middleware = ProtocolMiddleware(app, app_config)
-        logger.info(f"🔍 SETUP STEP 10: ProtocolMiddleware created successfully")
-        logger.info(f"🔍 SETUP STEP 11: Adding ProtocolMiddleware to app...")
         app.add_middleware(ProtocolMiddleware, app_config=app_config)
-        logger.info(f"✅ SETUP STEP 12: Protocol middleware added to application")
+        logger.info("Protocol middleware added to application")
     else:
-        logger.info(f"✅ SETUP STEP 9: Protocol management is disabled, skipping protocol middleware")
+        logger.info("Protocol management is disabled, skipping protocol middleware")

{mcp_proxy_adapter-6.4.8 → mcp_proxy_adapter-6.4.10}/mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.4.8 → mcp_proxy_adapter-6.4.10}/pyproject.toml

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