mcp-proxy-adapter 6.9.14__tar.gz → 6.9.16__tar.gz

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/PKG-INFO

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

@@ -116,12 +116,13 @@ def _determine_registration_url(config: Dict[str, Any]) -> str:
     return server_url
 
 
-def create_lifespan(config_path: Optional[str] = None):
+def create_lifespan(config_path: Optional[str] = None, current_config: Optional[Dict[str, Any]] = None):
     """
     Create lifespan manager for the FastAPI application.
 
     Args:
         config_path: Path to configuration file (optional)
+        current_config: Current configuration data (optional)
 
     Returns:
         Lifespan context manager
@@ -146,7 +147,17 @@ 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")
+        # Use current_config from closure or fallback to global config
+        config_to_use = current_config
+        if config_to_use is None:
+            # Fallback: try to get config from global instance
+            try:
+                from mcp_proxy_adapter.config import get_config
+                config_to_use = get_config().get_all()
+            except Exception:
+                config_to_use = {}
+        
+        server_config = config_to_use.get("server")
         if not server_config:
             raise ValueError("server configuration is required")
         server_host = server_config.get("host")
@@ -159,10 +170,6 @@ def create_lifespan(config_path: Optional[str] = None):
         # Check port availability BEFORE starting registration manager
         from mcp_proxy_adapter.core.utils import check_port_availability, handle_port_conflict
         
-        server_config = config.get("server", {})
-        server_host = server_config.get("host", "0.0.0.0")
-        server_port = server_config.get("port", 8000)
-        
         print(f"🔍 Checking external server port availability: {server_host}:{server_port}")
         if not check_port_availability(server_host, server_port):
             print(f"❌ CRITICAL: External server port {server_port} is occupied")
@@ -171,7 +178,7 @@ def create_lifespan(config_path: Optional[str] = None):
         print(f"✅ External server port {server_port} is available")
 
         # Determine registration URL using unified logic
-        early_server_url = _determine_registration_url(config)
+        early_server_url = _determine_registration_url(config_to_use)
         try:
             from mcp_proxy_adapter.core.proxy_registration import (
                 register_with_proxy,
@@ -190,10 +197,20 @@ def create_lifespan(config_path: Optional[str] = None):
             logger.error(f"Failed to initialize async registration: {e}")
 
         # Initialize system using unified logic (may perform registration)
+        # Set global config for reload_system
+        from mcp_proxy_adapter.config import Config
+        config_obj = Config()
+        config_obj.config_data = config_to_use
+        
+        # Set global config for command registry
+        from mcp_proxy_adapter.config import get_config
+        global_config = get_config()
+        global_config.config_data = config_to_use
+        
         if config_path:
-            init_result = await registry.reload_system(config_path=config_path)
+            init_result = await registry.reload_system(config_path=config_path, config_obj=config_obj)
         else:
-            init_result = await registry.reload_system()
+            init_result = await registry.reload_system(config_obj=config_obj)
 
         logger.info(
             f"Application started with {init_result['total_commands']} commands registered"
@@ -362,9 +379,16 @@ def create_app(
         elif hasattr(app_config, "keys"):
             current_config = app_config
         else:
-            current_config = config.get_all()
+            # If app_config is not a dict-like object, use it as is
+            current_config = app_config
     else:
-        current_config = config.get_all()
+        # If no app_config provided, try to get global config
+        try:
+            from mcp_proxy_adapter.config import get_config
+            current_config = get_config().get_all()
+        except Exception:
+            # If global config is not available, create empty config
+            current_config = {}
 
     # Debug: Check what config is passed to create_app
     if app_config:
@@ -559,7 +583,7 @@ def create_app(
         version=app_version,
         docs_url="/docs",
         redoc_url="/redoc",
-        lifespan=create_lifespan(config_path),
+        lifespan=create_lifespan(config_path, current_config),
     )
     
     # CRITICAL FIX: Register commands immediately during app creation

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/mcp_proxy_adapter/commands/command_registry.py

@@ -659,7 +659,7 @@ class CommandRegistry:
         self._loaded_commands.clear()
         self._instances.clear()
 
-    async def reload_system(self, config_path: Optional[str] = None) -> Dict[str, Any]:
+    async def reload_system(self, config_path: Optional[str] = None, config_obj: Optional[Any] = None) -> Dict[str, Any]:
         """
         Universal method for system initialization and reload.
         This method should be used both at startup and during reload.
@@ -675,13 +675,16 @@ class CommandRegistry:
         )
 
         # Step 1: Load configuration (preserve previous config for soft-fail)
-        previous_config = config.get_all()
+        if config_obj is None:
+            config_obj = config
+            
+        previous_config = config_obj.get_all()
         try:
             if config_path:
-                config.load_from_file(config_path)
+                config_obj.load_from_file(config_path)
                 logger.info(f"✅ Configuration loaded from: {config_path}")
             else:
-                config.load_config()
+                config_obj.load_config()
                 logger.info("✅ Configuration loaded from default path")
 
             config_reloaded = True
@@ -694,14 +697,14 @@ class CommandRegistry:
             from mcp_proxy_adapter.core.config_validator import ConfigValidator
 
             validator = ConfigValidator()
-            validation = validator.validate(config.get_all())
+            validation = validator.validate(config_obj.get_all())
             if not validation.is_valid:
                 logger.error("⚠️ Configuration validation failed during reload:")
                 for err in validation.errors:
                     logger.error(f"  - {err}")
                 # Do NOT exit on reload; restore previous configuration
                 try:
-                    config.config_data = previous_config
+                    config_obj.config_data = previous_config
                     config_reloaded = False
                     logger.error("ℹ️ Restored previous configuration due to validation errors")
                 except Exception as restore_ex:

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/mcp_proxy_adapter/config.py

@@ -52,7 +52,7 @@ class Config:
         if VALIDATION_AVAILABLE:
             self.validator = ConfigValidator()
         
-        self.load_config()
+        # Don't auto-load config - let user call load_from_file explicitly
 
     def load_config(self) -> None:
         """

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/mcp_proxy_adapter/core/app_factory.py

@@ -78,6 +78,8 @@ async def create_and_run_server(
             sys.exit(1)
 
         try:
+            from mcp_proxy_adapter.config import Config
+            config = Config()
             config.load_from_file(str(config_file))
             app_config = config.get_all()
             print(f"✅ Configuration loaded from: {config_path}")
@@ -169,7 +171,6 @@ async def create_and_run_server(
                             f"Fix your configuration file."
                         )
                     
-                    from pathlib import Path
                     if not Path(cert_file).exists():
                         raise ValueError(
                             f"CRITICAL CONFIG ERROR: SSL certificate file does not exist: {cert_file}. "
@@ -509,6 +510,8 @@ def validate_config_file(config_path: str) -> bool:
             return False
 
         # Try to load configuration to validate JSON format
+        from mcp_proxy_adapter.config import Config
+        config = Config()
         config.load_from_file(str(config_file))
         return True
 

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/mcp_proxy_adapter/core/config_validator.py

@@ -341,13 +341,18 @@ class ConfigValidator:
                     
                 section_data = self.config_data[section_name]
                 for key, expected_type in required_keys.items():
+                    # Check if key allows None (optional)
+                    is_optional = isinstance(expected_type, tuple) and type(None) in expected_type
+                    
                     if key not in section_data:
-                        self.validation_results.append(ValidationResult(
-                            level="error",
-                            message=f"Required key '{key}' is missing in section '{section_name}' for enabled feature",
-                            section=section_name,
-                            key=key
-                        ))
+                        # Only report error if key is not optional
+                        if not is_optional:
+                            self.validation_results.append(ValidationResult(
+                                level="error",
+                                message=f"Required key '{key}' is missing in section '{section_name}' for enabled feature",
+                                section=section_name,
+                                key=key
+                            ))
                     else:
                         # Validate type
                         value = section_data[key]
@@ -535,7 +540,11 @@ class ConfigValidator:
                 ])
         
         for file_key in file_keys:
-            file_path = self._get_nested_value(file_key)
+            # Skip if the key doesn't exist in the configuration
+            if not self._has_nested_key(file_key):
+                continue
+                
+            file_path = self._get_nested_value_safe(file_key)
             if file_path and not os.path.exists(file_path):
                 # Check if this is a required file based on enabled features
                 is_required = self._is_file_required_for_enabled_features(file_key)
@@ -685,15 +694,10 @@ class ConfigValidator:
             else:
                 key_file = self._get_nested_value("ssl.key_file")
             
-            if not self._has_nested_key("ssl.ca_cert"):
-                self.validation_results.append(ValidationResult(
-                    level="error",
-                    message="SSL is enabled but ca_cert is not specified",
-                    section="ssl",
-                    key="ca_cert"
-                ))
-            else:
-                ca_cert = self._get_nested_value("ssl.ca_cert")
+            # CA cert is optional for HTTPS but may be required for mTLS with client verification
+            ca_cert = None
+            if self._has_nested_key("ssl.ca_cert"):
+                ca_cert = self._get_nested_value_safe("ssl.ca_cert")
             
             # Check certificate file
             if not cert_file:

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/mcp_proxy_adapter/core/logging.py

@@ -120,46 +120,29 @@ def setup_logging(
     Returns:
         Configured logger.
     """
-    # Get parameters from configuration if not explicitly specified
-    level = level or get_config().get("logging.level", "INFO")
-
-    # Check debug level from config if debug is enabled
-    if get_config().get("debug.enabled", False):
-        debug_level = get_config().get("debug.level", "INFO")
-        # Use debug level if it's more verbose than the logging level
-        debug_level_num = getattr(logging, debug_level.upper(), logging.INFO)
-        level_num = getattr(logging, level.upper(), logging.INFO)
-        if debug_level_num < level_num:
-            level = debug_level
-            logger.debug(f"Using debug level from config: {debug_level}")
-
-    log_file = log_file or get_config().get("logging.file")
-    rotation_type = rotation_type or "size"  # Default to size-based rotation
-
-    # Get log directory and file settings from config
-    log_dir = get_config().get("logging.log_dir", "./logs")
-    log_file_name = get_config().get("logging.log_file", "mcp_proxy_adapter.log")
-    error_log_file = get_config().get("logging.error_log_file", "mcp_proxy_adapter_error.log")
-    access_log_file = get_config().get(
-        "logging.access_log_file", "mcp_proxy_adapter_access.log"
-    )
-
-    # Get rotation settings from config
-    max_file_size_str = get_config().get("logging.max_file_size", "10MB")
-    backup_count = backup_count or get_config().get("logging.backup_count", 5)
+    # Use provided parameters or defaults
+    level = level or "INFO"
+    log_file = log_file
+    rotation_type = rotation_type or "size"
+    log_dir = "./logs"
+    log_file_name = "mcp_proxy_adapter.log"
+    error_log_file = "mcp_proxy_adapter_error.log"
+    access_log_file = "mcp_proxy_adapter_access.log"
+
+    # Get rotation settings
+    max_file_size_str = "10MB"
+    backup_count = backup_count or 5
 
     # Parse max file size (e.g., "10MB" -> 10 * 1024 * 1024)
     max_bytes = max_bytes or _parse_file_size(max_file_size_str)
 
     # Get format settings
-    log_format = get_config().get(
-        "logging.format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-    date_format = get_config().get("logging.date_format", "%Y-%m-%d %H:%M:%S")
+    log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    date_format = "%Y-%m-%d %H:%M:%S"
 
     # Get output settings
-    console_output = get_config().get("logging.console_output", True)
-    file_output = get_config().get("logging.file_output", True)
+    console_output = True
+    file_output = True
 
     # Convert string logging level to constant
     numeric_level = getattr(logging, level.upper(), None)
@@ -227,7 +210,7 @@ def setup_logging(
             logger.addHandler(access_handler)
 
     # Configure loggers for external libraries
-    log_levels = get_config().get("logging.levels", {})
+    log_levels = {}
     for logger_name, logger_level in log_levels.items():
         lib_logger = logging.getLogger(logger_name)
         lib_logger.setLevel(getattr(logging, logger_level.upper(), logging.INFO))

mcp_proxy_adapter-6.9.16/mcp_proxy_adapter/examples/full_application/test_minimal_server.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""
+Minimal server test without lifespan issues.
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add the project root to the path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from fastapi import FastAPI
+from mcp_proxy_adapter.api.handlers import execute_command
+import uvicorn
+
+def main():
+    """Test minimal server startup."""
+    print("🚀 Testing Minimal Server Startup")
+    print("=" * 50)
+    
+    # Create minimal FastAPI app
+    app = FastAPI(
+        title="Test Server",
+        description="Minimal test server",
+        version="1.0.0"
+    )
+    
+    # Add health endpoint
+    @app.get("/health")
+    async def health():
+        return {"status": "ok", "message": "Server is running"}
+    
+    # Add JSON-RPC endpoint
+    @app.post("/api/jsonrpc")
+    async def jsonrpc_endpoint(request: dict):
+        try:
+            # Simple health command
+            if request.get("method") == "health":
+                return {
+                    "jsonrpc": "2.0",
+                    "id": request.get("id"),
+                    "result": {"status": "ok", "message": "Health check passed"}
+                }
+            else:
+                return {
+                    "jsonrpc": "2.0",
+                    "id": request.get("id"),
+                    "error": {"code": -32601, "message": "Method not found"}
+                }
+        except Exception as e:
+            return {
+                "jsonrpc": "2.0",
+                "id": request.get("id"),
+                "error": {"code": -32603, "message": str(e)}
+            }
+    
+    print("✅ FastAPI app created successfully")
+    
+    # Start server
+    print("🚀 Starting server on http://0.0.0.0:8000")
+    print("📡 Test with: curl -X POST http://localhost:8000/api/jsonrpc -H 'Content-Type: application/json' -d '{\"jsonrpc\": \"2.0\", \"method\": \"health\", \"id\": 1}'")
+    print("🛑 Press Ctrl+C to stop")
+    
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+if __name__ == "__main__":
+    main()

mcp_proxy_adapter-6.9.16/mcp_proxy_adapter/examples/full_application/test_simple_server.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Simple server test without complex lifespan.
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add the project root to the path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.config import Config
+import uvicorn
+
+def main():
+    """Test simple server startup."""
+    print("🚀 Testing Simple Server Startup")
+    print("=" * 50)
+    
+    # Load configuration
+    config_path = "configs/http_simple_correct.json"
+    if not os.path.exists(config_path):
+        print(f"❌ Configuration file not found: {config_path}")
+        return 1
+    
+    try:
+        # Load config
+        config = Config()
+        config.load_from_file(config_path)
+        app_config = config.get_all()
+        
+        print(f"✅ Configuration loaded: {config_path}")
+        print(f"🔍 Config keys: {list(app_config.keys())}")
+        
+        # Create app
+        app = create_app(
+            title="Test Server",
+            description="Simple test server",
+            version="1.0.0",
+            app_config=app_config
+        )
+        
+        print("✅ FastAPI app created successfully")
+        
+        # Start server
+        print("🚀 Starting server on http://0.0.0.0:8000")
+        print("📡 Test with: curl -X POST http://localhost:8000/api/jsonrpc -H 'Content-Type: application/json' -d '{\"jsonrpc\": \"2.0\", \"method\": \"health\", \"id\": 1}'")
+        print("🛑 Press Ctrl+C to stop")
+        
+        uvicorn.run(app, host="0.0.0.0", port=8000)
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/mcp_proxy_adapter/version.py

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

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/mcp_proxy_adapter.egg-info/PKG-INFO

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

@@ -127,7 +127,9 @@ setup.py
 ./mcp_proxy_adapter/examples/full_application/proxy_endpoints.py
 ./mcp_proxy_adapter/examples/full_application/run_mtls.py
 ./mcp_proxy_adapter/examples/full_application/run_simple.py
+./mcp_proxy_adapter/examples/full_application/test_minimal_server.py
 ./mcp_proxy_adapter/examples/full_application/test_server.py
+./mcp_proxy_adapter/examples/full_application/test_simple_server.py
 ./mcp_proxy_adapter/examples/full_application/commands/__init__.py
 ./mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py
 ./mcp_proxy_adapter/examples/full_application/commands/dynamic_calculator_command.py
@@ -271,7 +273,9 @@ mcp_proxy_adapter/examples/full_application/main.py
 mcp_proxy_adapter/examples/full_application/proxy_endpoints.py
 mcp_proxy_adapter/examples/full_application/run_mtls.py
 mcp_proxy_adapter/examples/full_application/run_simple.py
+mcp_proxy_adapter/examples/full_application/test_minimal_server.py
 mcp_proxy_adapter/examples/full_application/test_server.py
+mcp_proxy_adapter/examples/full_application/test_simple_server.py
 mcp_proxy_adapter/examples/full_application/commands/__init__.py
 mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py
 mcp_proxy_adapter/examples/full_application/commands/dynamic_calculator_command.py

{mcp_proxy_adapter-6.9.14 → mcp_proxy_adapter-6.9.16}/pyproject.toml

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