mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.29__py3-none-any.whl

mcp_proxy_adapter/core/config_converter.py

@@ -186,196 +186,10 @@ class ConfigConverter:
             return ConfigConverter._get_default_security_config()
 
     @staticmethod
-    def from_security_framework_config(
-        security_config: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Convert SecurityConfig format to mcp_proxy_adapter configuration.
-
-        Args:
-            security_config: SecurityConfig compatible dictionary
-
-        Returns:
-            mcp_proxy_adapter configuration dictionary
-        """
-        try:
-            mcp_config = {
-                "security": {"framework": "mcp_security_framework", "enabled": True}
-            }
-
-            # Convert auth config
-            if "auth" in security_config:
-                auth_config = security_config["auth"]
-                mcp_config["security"]["auth"] = {
-                    "enabled": auth_config.get("enabled", True),
-                    "methods": auth_config.get("methods", ["api_key"]),
-                    "api_keys": auth_config.get("api_keys", {}),
-                    "jwt_secret": auth_config.get("jwt_secret", ""),
-                    "jwt_algorithm": auth_config.get("jwt_algorithm", "HS256"),
-                }
-
-            # Convert SSL config
-            if "ssl" in security_config:
-                ssl_config = security_config["ssl"]
-                mcp_config["security"]["ssl"] = {
-                    "enabled": ssl_config.get("enabled", False),
-                    "cert_file": ssl_config.get("cert_file"),
-                    "key_file": ssl_config.get("key_file"),
-                    "ca_cert": ssl_config.get("ca_cert"),
-                    "min_tls_version": ssl_config.get("min_tls_version", "TLSv1.2"),
-                    "verify_client": ssl_config.get("verify_client", False),
-                    "client_cert_required": ssl_config.get(
-                        "client_cert_required", False
-                    ),
-                }
-
-            # Convert permissions config
-            if "permissions" in security_config:
-                permissions_config = security_config["permissions"]
-                mcp_config["security"]["permissions"] = {
-                    "enabled": permissions_config.get("enabled", True),
-                    "roles_file": permissions_config.get("roles_file", "roles.json"),
-                    "default_role": permissions_config.get("default_role", "user"),
-                    "deny_by_default": permissions_config.get("deny_by_default", True),
-                }
-
-            # Convert rate limit config
-            if "rate_limit" in security_config:
-                rate_limit_config = security_config["rate_limit"]
-                mcp_config["security"]["rate_limit"] = {
-                    "enabled": rate_limit_config.get("enabled", True),
-                    "requests_per_minute": rate_limit_config.get(
-                        "requests_per_minute", 60
-                    ),
-                    "requests_per_hour": rate_limit_config.get(
-                        "requests_per_hour", 1000
-                    ),
-                    "burst_limit": rate_limit_config.get("burst_limit", 10),
-                    "by_ip": rate_limit_config.get("by_ip", True),
-                    "by_user": rate_limit_config.get("by_user", True),
-                }
-
-            get_global_logger().info(
-                "Configuration converted from security framework format successfully"
-            )
-            return mcp_config
-
-        except Exception as e:
-            get_global_logger().error(
-                f"Failed to convert configuration from security framework format: {e}"
-            )
-            return ConfigConverter._get_default_mcp_config()
 
     @staticmethod
-    def migrate_legacy_config(
-        config_path: str, output_path: Optional[str] = None
-    ) -> bool:
-        """
-        Migrate legacy configuration to new security framework format.
-
-        Args:
-            config_path: Path to legacy configuration file
-            output_path: Path to output migrated configuration file (optional)
-
-        Returns:
-            True if migration successful, False otherwise
-        """
-        try:
-            # Read legacy configuration
-            with open(config_path, "r", encoding="utf-8") as f:
-                legacy_config = json.load(f)
-
-            # Convert to new format
-            new_config = ConfigConverter.to_security_framework_config(legacy_config)
-
-            # Add security section to legacy config
-            legacy_config["security"] = new_config
-
-            # Determine output path
-            if output_path is None:
-                output_path = config_path.replace(".json", "_migrated.json")
-
-            # Write migrated configuration
-            with open(output_path, "w", encoding="utf-8") as f:
-                json.dump(legacy_config, f, indent=2, ensure_ascii=False)
-
-            get_global_logger().info(f"Configuration migrated successfully to {output_path}")
-            return True
-
-        except Exception as e:
-            get_global_logger().error(f"Failed to migrate configuration: {e}")
-            return False
 
     @staticmethod
-    def validate_security_config(config: Dict[str, Any]) -> bool:
-        """
-        Validate security configuration format.
-
-        Args:
-            config: Configuration dictionary to validate
-
-        Returns:
-            True if configuration is valid, False otherwise
-        """
-        try:
-            # Check if security section exists
-            if "security" not in config:
-                get_global_logger().error("Security section not found in configuration")
-                return False
-
-            security_section = config["security"]
-
-            # Validate required fields
-            required_sections = ["auth", "ssl", "permissions", "rate_limit"]
-            for section in required_sections:
-                if section not in security_section:
-                    get_global_logger().error(
-                        f"Required section '{section}' not found in security configuration"
-                    )
-                    return False
-
-                if not isinstance(security_section[section], dict):
-                    get_global_logger().error(f"Section '{section}' must be a dictionary")
-                    return False
-
-            # Validate auth configuration
-            auth_config = security_section["auth"]
-            if not isinstance(auth_config.get("methods", []), list):
-                get_global_logger().error("Auth methods must be a list")
-                return False
-
-            if not isinstance(auth_config.get("api_keys", {}), dict):
-                get_global_logger().error("API keys must be a dictionary")
-                return False
-
-            # Validate SSL configuration
-            ssl_config = security_section["ssl"]
-            if not isinstance(ssl_config.get("enabled", False), bool):
-                get_global_logger().error("SSL enabled must be a boolean")
-                return False
-
-            # Validate permissions configuration
-            permissions_config = security_section["permissions"]
-            if not isinstance(permissions_config.get("enabled", True), bool):
-                get_global_logger().error("Permissions enabled must be a boolean")
-                return False
-
-            # Validate rate limit configuration
-            rate_limit_config = security_section["rate_limit"]
-            if not isinstance(rate_limit_config.get("enabled", True), bool):
-                get_global_logger().error("Rate limit enabled must be a boolean")
-                return False
-
-            if not isinstance(rate_limit_config.get("requests_per_minute", 60), int):
-                get_global_logger().error("Requests per minute must be an integer")
-                return False
-
-            get_global_logger().info("Security configuration validation passed")
-            return True
-
-        except Exception as e:
-            get_global_logger().error(f"Configuration validation failed: {e}")
-            return False
 
     @staticmethod
     def _get_default_security_config() -> Dict[str, Any]: