mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.6__py3-none-any.whl

mcp_proxy_adapter/commands/proxy_registration_command.py

@@ -22,77 +22,68 @@ from mcp_proxy_adapter.core.logging import logger
 @dataclass
 class ProxyRegistrationCommandResult(SuccessResult):
     """Result of proxy registration command."""
-    
+
     operation: str
     success: bool
     server_key: Optional[str] = None
     message: str = ""
     details: Optional[Dict[str, Any]] = None
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary."""
         result = {
             "operation": self.operation,
             "success": self.success,
-            "message": self.message
+            "message": self.message,
         }
-        
+
         if self.server_key:
             result["server_key"] = self.server_key
-        
+
         if self.details:
             result["details"] = self.details
-        
+
         return result
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get JSON schema for result."""
         return {
             "type": "object",
             "properties": {
-                "operation": {
-                    "type": "string",
-                    "description": "Operation performed"
-                },
+                "operation": {"type": "string", "description": "Operation performed"},
                 "success": {
                     "type": "boolean",
-                    "description": "Whether operation was successful"
+                    "description": "Whether operation was successful",
                 },
                 "server_key": {
                     "type": "string",
-                    "description": "Server key for registered server"
+                    "description": "Server key for registered server",
                 },
-                "message": {
-                    "type": "string",
-                    "description": "Result message"
-                },
-                "details": {
-                    "type": "object",
-                    "description": "Additional details"
-                }
+                "message": {"type": "string", "description": "Result message"},
+                "details": {"type": "object", "description": "Additional details"},
             },
-            "required": ["operation", "success", "message"]
+            "required": ["operation", "success", "message"],
         }
 
 
 class ProxyRegistrationCommand(Command):
     """Proxy registration command with security framework integration."""
-    
+
     name = "proxy_registration"
     descr = "Proxy registration operations (register, unregister, heartbeat, discover)"
     category = "proxy"
     author = "Vasiliy Zdanovskiy"
     email = "vasilyvz@gmail.com"
-    
+
     # In-memory registry for testing
     _registry: Dict[str, Dict[str, Any]] = {}
     _server_counter = 1
-    
+
     async def execute(self, **kwargs) -> ProxyRegistrationCommandResult:
         """
         Execute proxy registration command.
-        
+
         Args:
             operation: Operation to perform (register, unregister, heartbeat, discover)
             server_id: Server ID for registration
@@ -108,39 +99,43 @@ class ProxyRegistrationCommand(Command):
             copy_number: Copy number for unregistration
             timestamp: Timestamp for heartbeat
             status: Status for heartbeat
-            
+
         Returns:
             ProxyRegistrationCommandResult
         """
         operation = kwargs.get("operation", "register")
-        
+
         # Check user permissions
         context = kwargs.get("context", {})
         user_info = context.get("user", {})
         user_permissions = user_info.get("permissions", [])
-        
+
         # Define required permissions for each operation
         operation_permissions = {
             "register": ["register"],
             "unregister": ["unregister"],
             "heartbeat": ["heartbeat"],
-            "discover": ["discover"]
+            "discover": ["discover"],
         }
-        
+
         required_permissions = operation_permissions.get(operation, ["read"])
-        
+
         # Check if user has required permissions
-        logger.info(f"Checking permissions: user_permissions={user_permissions}, required={required_permissions}")
+        logger.info(
+            f"Checking permissions: user_permissions={user_permissions}, required={required_permissions}"
+        )
         if not self._check_permissions(user_permissions, required_permissions):
             return ProxyRegistrationCommandResult(
                 operation=operation,
                 success=False,
-                message=f"Permission denied: {operation} requires {required_permissions}"
+                message=f"Permission denied: {operation} requires {required_permissions}",
             )
-        
+
         logger.info(f"Executing proxy registration operation: {operation}")
-        logger.debug(f"User permissions: {user_permissions}, required: {required_permissions}")
-        
+        logger.debug(
+            f"User permissions: {user_permissions}, required: {required_permissions}"
+        )
+
         if operation == "register":
             return await self._handle_register(kwargs)
         elif operation == "unregister":
@@ -153,10 +148,12 @@ class ProxyRegistrationCommand(Command):
             return ProxyRegistrationCommandResult(
                 operation=operation,
                 success=False,
-                message=f"Unknown operation: {operation}"
+                message=f"Unknown operation: {operation}",
             )
-    
-    async def _handle_register(self, kwargs: Dict[str, Any]) -> ProxyRegistrationCommandResult:
+
+    async def _handle_register(
+        self, kwargs: Dict[str, Any]
+    ) -> ProxyRegistrationCommandResult:
         """Handle registration operation."""
         server_id = kwargs.get("server_id")
         server_url = kwargs.get("server_url")
@@ -167,19 +164,21 @@ class ProxyRegistrationCommand(Command):
         endpoints = kwargs.get("endpoints", {})
         auth_method = kwargs.get("auth_method", "none")
         security_enabled = kwargs.get("security_enabled", False)
-        
+
         if not server_id or not server_url:
             return ProxyRegistrationCommandResult(
                 operation="register",
                 success=False,
-                message="Missing required parameters: server_id and server_url"
+                message="Missing required parameters: server_id and server_url",
             )
-        
+
         # Check if server already exists
-        existing_servers = [key for key in self._registry.keys() if key.startswith(server_id)]
+        existing_servers = [
+            key for key in self._registry.keys() if key.startswith(server_id)
+        ]
         copy_number = len(existing_servers) + 1
         server_key = f"{server_id}_{copy_number}"
-        
+
         # Create server record
         server_record = {
             "server_id": server_id,
@@ -193,13 +192,13 @@ class ProxyRegistrationCommand(Command):
             "security_enabled": security_enabled,
             "registered_at": int(time.time()),
             "last_heartbeat": int(time.time()),
-            "status": "active"
+            "status": "active",
         }
-        
+
         self._registry[server_key] = server_record
-        
+
         logger.info(f"Registered server: {server_key} at {server_url}")
-        
+
         return ProxyRegistrationCommandResult(
             operation="register",
             success=True,
@@ -208,62 +207,66 @@ class ProxyRegistrationCommand(Command):
             details={
                 "server_id": server_id,
                 "copy_number": copy_number,
-                "registered_at": server_record["registered_at"]
-            }
+                "registered_at": server_record["registered_at"],
+            },
         )
-    
-    async def _handle_unregister(self, kwargs: Dict[str, Any]) -> ProxyRegistrationCommandResult:
+
+    async def _handle_unregister(
+        self, kwargs: Dict[str, Any]
+    ) -> ProxyRegistrationCommandResult:
         """Handle unregistration operation."""
         server_id = kwargs.get("server_id")
         copy_number = kwargs.get("copy_number", 1)
-        
+
         if not server_id:
             return ProxyRegistrationCommandResult(
                 operation="unregister",
                 success=False,
-                message="Missing required parameter: server_id"
+                message="Missing required parameter: server_id",
             )
-        
+
         server_key = f"{server_id}_{copy_number}"
-        
+
         if server_key in self._registry:
             del self._registry[server_key]
             logger.info(f"Unregistered server: {server_key}")
-            
+
             return ProxyRegistrationCommandResult(
                 operation="unregister",
                 success=True,
                 message=f"Server unregistered successfully: {server_key}",
-                details={"unregistered": True}
+                details={"unregistered": True},
             )
         else:
             return ProxyRegistrationCommandResult(
                 operation="unregister",
                 success=True,
                 message=f"Server not found in registry: {server_key}",
-                details={"unregistered": False}
+                details={"unregistered": False},
             )
-    
-    async def _handle_heartbeat(self, kwargs: Dict[str, Any]) -> ProxyRegistrationCommandResult:
+
+    async def _handle_heartbeat(
+        self, kwargs: Dict[str, Any]
+    ) -> ProxyRegistrationCommandResult:
         """Handle heartbeat operation."""
         server_id = kwargs.get("server_id")
         server_key = kwargs.get("server_key")
         timestamp = kwargs.get("timestamp", int(time.time()))
         status = kwargs.get("status", "healthy")
-        
+
         if not server_key:
             return ProxyRegistrationCommandResult(
                 operation="heartbeat",
                 success=False,
-                message="Missing required parameter: server_key"
+                message="Missing required parameter: server_key",
             )
-        
+
         if server_key in self._registry:
             self._registry[server_key]["last_heartbeat"] = timestamp
             self._registry[server_key]["status"] = status
-            
+
             logger.debug(f"Heartbeat received for server: {server_key}")
-            
+
             return ProxyRegistrationCommandResult(
                 operation="heartbeat",
                 success=True,
@@ -271,21 +274,23 @@ class ProxyRegistrationCommand(Command):
                 details={
                     "server_key": server_key,
                     "timestamp": timestamp,
-                    "status": status
-                }
+                    "status": status,
+                },
             )
         else:
             return ProxyRegistrationCommandResult(
                 operation="heartbeat",
                 success=False,
-                message=f"Server not found: {server_key}"
+                message=f"Server not found: {server_key}",
             )
-    
-    async def _handle_discover(self, kwargs: Dict[str, Any]) -> ProxyRegistrationCommandResult:
+
+    async def _handle_discover(
+        self, kwargs: Dict[str, Any]
+    ) -> ProxyRegistrationCommandResult:
         """Handle discovery operation."""
         # Return all registered servers
         proxies = []
-        
+
         for server_key, server_record in self._registry.items():
             # Check if server is active (heartbeat within last 5 minutes)
             last_heartbeat = server_record.get("last_heartbeat", 0)
@@ -303,41 +308,43 @@ class ProxyRegistrationCommand(Command):
                     "security_enabled": server_record["security_enabled"],
                     "registered_at": server_record["registered_at"],
                     "last_heartbeat": server_record["last_heartbeat"],
-                    "status": server_record["status"]
+                    "status": server_record["status"],
                 }
                 proxies.append(proxy_info)
-        
+
         logger.info(f"Discovery request returned {len(proxies)} active servers")
-        
+
         return ProxyRegistrationCommandResult(
             operation="discover",
             success=True,
             message=f"Found {len(proxies)} active proxy servers",
-            details={"proxies": proxies}
+            details={"proxies": proxies},
         )
-    
-    def _check_permissions(self, user_permissions: List[str], required_permissions: List[str]) -> bool:
+
+    def _check_permissions(
+        self, user_permissions: List[str], required_permissions: List[str]
+    ) -> bool:
         """
         Check if user has required permissions.
-        
+
         Args:
             user_permissions: User's permissions
             required_permissions: Required permissions
-            
+
         Returns:
             True if user has required permissions
         """
         # Admin has all permissions
         if "*" in user_permissions:
             return True
-        
+
         # Check if user has all required permissions
         for required in required_permissions:
             if required not in user_permissions:
                 return False
-        
+
         return True
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """Get JSON schema for command parameters."""
@@ -348,62 +355,47 @@ class ProxyRegistrationCommand(Command):
                     "type": "string",
                     "enum": ["register", "unregister", "heartbeat", "discover"],
                     "description": "Operation to perform",
-                    "default": "register"
+                    "default": "register",
                 },
                 "server_id": {
                     "type": "string",
-                    "description": "Server ID for registration"
+                    "description": "Server ID for registration",
                 },
                 "server_url": {
                     "type": "string",
-                    "description": "Server URL for registration"
-                },
-                "server_name": {
-                    "type": "string",
-                    "description": "Server name"
-                },
-                "description": {
-                    "type": "string",
-                    "description": "Server description"
-                },
-                "version": {
-                    "type": "string",
-                    "description": "Server version"
+                    "description": "Server URL for registration",
                 },
+                "server_name": {"type": "string", "description": "Server name"},
+                "description": {"type": "string", "description": "Server description"},
+                "version": {"type": "string", "description": "Server version"},
                 "capabilities": {
                     "type": "array",
                     "items": {"type": "string"},
-                    "description": "Server capabilities"
-                },
-                "endpoints": {
-                    "type": "object",
-                    "description": "Server endpoints"
+                    "description": "Server capabilities",
                 },
+                "endpoints": {"type": "object", "description": "Server endpoints"},
                 "auth_method": {
                     "type": "string",
-                    "description": "Authentication method"
+                    "description": "Authentication method",
                 },
                 "security_enabled": {
                     "type": "boolean",
-                    "description": "Whether security is enabled"
+                    "description": "Whether security is enabled",
                 },
                 "server_key": {
                     "type": "string",
-                    "description": "Server key for unregistration/heartbeat"
+                    "description": "Server key for unregistration/heartbeat",
                 },
                 "copy_number": {
                     "type": "integer",
-                    "description": "Copy number for unregistration"
+                    "description": "Copy number for unregistration",
                 },
                 "timestamp": {
                     "type": "integer",
-                    "description": "Timestamp for heartbeat"
+                    "description": "Timestamp for heartbeat",
                 },
-                "status": {
-                    "type": "string",
-                    "description": "Status for heartbeat"
-                }
+                "status": {"type": "string", "description": "Status for heartbeat"},
             },
             "required": ["operation"],
-            "additionalProperties": False
-        } 
+            "additionalProperties": False,
+        }

mcp_proxy_adapter/commands/reload_command.py

@@ -16,7 +16,7 @@ class ReloadResult:
     """
     Result of reload operation.
     """
-    
+
     def __init__(
         self,
         config_reloaded: bool,
@@ -27,11 +27,11 @@ class ReloadResult:
         total_commands: int = 0,
         server_restart_required: bool = True,
         success: bool = True,
-        error_message: Optional[str] = None
+        error_message: Optional[str] = None,
     ):
         """
         Initialize reload result.
-        
+
         Args:
             config_reloaded: Whether configuration was reloaded successfully
             builtin_commands: Number of built-in commands registered
@@ -51,11 +51,11 @@ class ReloadResult:
         self.server_restart_required = server_restart_required
         self.success = success
         self.error_message = error_message
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """
         Convert result to dictionary.
-        
+
         Returns:
             Dictionary representation of the result.
         """
@@ -69,9 +69,9 @@ class ReloadResult:
             "total_commands": self.total_commands,
             "server_restart_required": self.server_restart_required,
             "message": "Server restart required to apply configuration changes",
-            "error_message": self.error_message
+            "error_message": self.error_message,
         }
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
@@ -85,49 +85,55 @@ class ReloadResult:
             "properties": {
                 "success": {
                     "type": "boolean",
-                    "description": "Whether reload was successful"
+                    "description": "Whether reload was successful",
                 },
                 "config_reloaded": {
                     "type": "boolean",
-                    "description": "Whether configuration was reloaded successfully"
+                    "description": "Whether configuration was reloaded successfully",
                 },
                 "builtin_commands": {
                     "type": "integer",
-                    "description": "Number of built-in commands registered"
+                    "description": "Number of built-in commands registered",
                 },
                 "custom_commands": {
                     "type": "integer",
-                    "description": "Number of custom commands registered"
+                    "description": "Number of custom commands registered",
                 },
                 "loaded_commands": {
                     "type": "integer",
-                    "description": "Number of commands loaded from directory"
+                    "description": "Number of commands loaded from directory",
                 },
                 "remote_commands": {
                     "type": "integer",
-                    "description": "Number of commands loaded from remote plugins"
+                    "description": "Number of commands loaded from remote plugins",
                 },
                 "total_commands": {
                     "type": "integer",
-                    "description": "Total number of commands after reload"
+                    "description": "Total number of commands after reload",
                 },
                 "server_restart_required": {
                     "type": "boolean",
-                    "description": "Whether server restart is required to apply changes"
+                    "description": "Whether server restart is required to apply changes",
                 },
                 "message": {
                     "type": "string",
-                    "description": "Information message about the reload operation"
+                    "description": "Information message about the reload operation",
                 },
                 "error_message": {
                     "type": ["string", "null"],
-                    "description": "Error message if reload failed"
-                }
+                    "description": "Error message if reload failed",
+                },
             },
             "required": [
-                "success", "config_reloaded", "builtin_commands", "custom_commands",
-                "loaded_commands", "remote_commands", "total_commands", "server_restart_required"
-            ]
+                "success",
+                "config_reloaded",
+                "builtin_commands",
+                "custom_commands",
+                "loaded_commands",
+                "remote_commands",
+                "total_commands",
+                "server_restart_required",
+            ],
         }
 
 
@@ -136,30 +142,30 @@ class ReloadCommand(Command):
     Command for reloading configuration and rediscovering commands.
     Uses the unified initialization logic.
     """
-    
+
     name = "reload"
-    
+
     async def execute(self, **params) -> ReloadResult:
         """
         Execute reload command.
-        
+
         Args:
             **params: Command parameters (config_path)
-            
+
         Returns:
             ReloadResult with reload information
         """
         try:
             logger.info("🔄 Starting configuration and commands reload...")
-            
+
             # Get config path from parameters
             config_path = params.get("config_path")
             if not config_path:
                 logger.warning("No config_path provided, using default configuration")
-            
+
             # Perform reload using unified initialization
             reload_info = registry.reload_system(config_path=config_path)
-            
+
             # Create result
             result = ReloadResult(
                 config_reloaded=reload_info.get("config_reloaded", False),
@@ -169,12 +175,12 @@ class ReloadCommand(Command):
                 remote_commands=reload_info.get("remote_commands", 0),
                 total_commands=reload_info.get("total_commands", 0),
                 server_restart_required=True,  # Default to True as per tests
-                success=True
+                success=True,
             )
-            
+
             logger.info(f"✅ Reload completed successfully: {result.to_dict()}")
             return result
-            
+
         except Exception as e:
             logger.error(f"❌ Reload failed: {str(e)}")
             return ReloadResult(
@@ -186,14 +192,14 @@ class ReloadCommand(Command):
                 total_commands=0,
                 server_restart_required=False,
                 success=False,
-                error_message=str(e)
+                error_message=str(e),
             )
-    
+
     @classmethod
     def get_schema(cls) -> Dict[str, Any]:
         """
         Get JSON schema for command parameters.
-        
+
         Returns:
             JSON schema dictionary.
         """
@@ -203,8 +209,8 @@ class ReloadCommand(Command):
                 "config_path": {
                     "type": "string",
                     "description": "Path to configuration file to reload",
-                    "default": None
+                    "default": None,
                 }
             },
-            "additionalProperties": False
-        } 
+            "additionalProperties": False,
+        }