mcp-proxy-adapter 4.1.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

mcp_proxy_adapter/commands/proxy_registration_command.py

@@ -0,0 +1,268 @@
+"""
+Command for managing proxy registration.
+
+This command allows manual registration, unregistration, and status checking
+for the proxy registration functionality.
+"""
+
+import asyncio
+from typing import Dict, Any, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+from mcp_proxy_adapter.core.proxy_registration import (
+    register_with_proxy, 
+    unregister_from_proxy, 
+    get_proxy_registration_status,
+    proxy_registration_manager
+)
+from mcp_proxy_adapter.core.logging import logger
+
+
+class ProxyRegistrationResult(CommandResult):
+    """Result class for proxy registration commands."""
+    
+    def __init__(self, success: bool, message: str, data: Optional[Dict[str, Any]] = None):
+        """
+        Initialize proxy registration result.
+        
+        Args:
+            success: Whether the operation was successful.
+            message: Result message.
+            data: Additional data.
+        """
+        self.success = success
+        self.message = message
+        self.data = data
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for this result.
+        
+        Returns:
+            JSON schema dictionary.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "success": {
+                    "type": "boolean",
+                    "description": "Whether the operation was successful"
+                },
+                "message": {
+                    "type": "string",
+                    "description": "Result message"
+                },
+                "data": {
+                    "type": "object",
+                    "description": "Additional data",
+                    "additionalProperties": True
+                }
+            },
+            "required": ["success", "message"]
+        }
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary.
+        
+        Returns:
+            Dictionary representation of the result.
+        """
+        result = {
+            "success": self.success,
+            "message": self.message
+        }
+        if self.data is not None:
+            result["data"] = self.data
+        return result
+
+
+class ProxyRegistrationCommand(Command):
+    """
+    Command for managing proxy registration.
+    
+    Supports registration, unregistration, and status checking.
+    """
+    
+    name = "proxy_registration"
+    
+    def __init__(self):
+        """Initialize the proxy registration command."""
+        super().__init__()
+    
+    async def execute(self, **kwargs) -> ProxyRegistrationResult:
+        """
+        Execute proxy registration command.
+        
+        Args:
+            **kwargs: Command parameters containing:
+                - action: "register", "unregister", or "status"
+                - server_url: (optional) Server URL for registration
+                
+        Returns:
+            ProxyRegistrationResult with operation result.
+        """
+        action = kwargs.get("action", "status")
+        
+        try:
+            if action == "register":
+                return await self._handle_register(kwargs)
+            elif action == "unregister":
+                return await self._handle_unregister(kwargs)
+            elif action == "status":
+                return await self._handle_status(kwargs)
+            else:
+                return ProxyRegistrationResult(
+                    success=False,
+                    message=f"Unknown action: {action}. Supported actions: register, unregister, status"
+                )
+                
+        except Exception as e:
+            logger.error(f"Proxy registration command failed: {e}")
+            return ProxyRegistrationResult(
+                success=False,
+                message=f"Command execution failed: {str(e)}"
+            )
+    
+    async def _handle_register(self, params: Dict[str, Any]) -> ProxyRegistrationResult:
+        """
+        Handle registration action.
+        
+        Args:
+            params: Command parameters.
+            
+        Returns:
+            ProxyRegistrationResult.
+        """
+        server_url = params.get("server_url")
+        
+        if not server_url:
+            # Use current server configuration
+            from mcp_proxy_adapter.config import config
+            
+            server_config = config.get("server", {})
+            server_host = server_config.get("host", "0.0.0.0")
+            server_port = server_config.get("port", 8000)
+            
+            # Determine server URL based on SSL configuration
+            ssl_config = config.get("ssl", {})
+            if ssl_config.get("enabled", False):
+                protocol = "https"
+            else:
+                protocol = "http"
+            
+            # Use localhost for external access if host is 0.0.0.0
+            if server_host == "0.0.0.0":
+                server_host = "localhost"
+            
+            server_url = f"{protocol}://{server_host}:{server_port}"
+        
+        logger.info(f"Attempting to register with proxy using URL: {server_url}")
+        
+        success = await register_with_proxy(server_url)
+        
+        if success:
+            status = get_proxy_registration_status()
+            return ProxyRegistrationResult(
+                success=True,
+                message="✅ Successfully registered with proxy",
+                data={
+                    "server_url": server_url,
+                    "server_key": status.get("server_key"),
+                    "registration_status": status
+                }
+            )
+        else:
+            return ProxyRegistrationResult(
+                success=False,
+                message="❌ Failed to register with proxy"
+            )
+    
+    async def _handle_unregister(self, params: Dict[str, Any]) -> ProxyRegistrationResult:
+        """
+        Handle unregistration action.
+        
+        Args:
+            params: Command parameters.
+            
+        Returns:
+            ProxyRegistrationResult.
+        """
+        logger.info("Attempting to unregister from proxy")
+        
+        success = await unregister_from_proxy()
+        
+        if success:
+            return ProxyRegistrationResult(
+                success=True,
+                message="✅ Successfully unregistered from proxy"
+            )
+        else:
+            return ProxyRegistrationResult(
+                success=False,
+                message="❌ Failed to unregister from proxy"
+            )
+    
+    async def _handle_status(self, params: Dict[str, Any]) -> ProxyRegistrationResult:
+        """
+        Handle status action.
+        
+        Args:
+            params: Command parameters.
+            
+        Returns:
+            ProxyRegistrationResult.
+        """
+        status = get_proxy_registration_status()
+        
+        return ProxyRegistrationResult(
+            success=True,
+            message="Proxy registration status retrieved successfully",
+            data={
+                "registration_status": status,
+                "enabled": status.get("enabled", False),
+                "registered": status.get("registered", False),
+                "server_key": status.get("server_key"),
+                "server_url": status.get("server_url"),
+                "proxy_url": status.get("proxy_url")
+            }
+        )
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get command schema.
+        
+        Returns:
+            Command schema.
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["register", "unregister", "status"],
+                    "description": "Action to perform: register, unregister, or status"
+                },
+                "server_url": {
+                    "type": "string",
+                    "description": "Server URL for registration (optional, uses current config if not provided)"
+                }
+            },
+            "required": ["action"]
+        }
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert command to dictionary.
+        
+        Returns:
+            Command dictionary representation.
+        """
+        return {
+            "name": self.name,
+            "description": "Manage proxy registration (register, unregister, status)",
+            "schema": self.__class__.get_schema()
+        } 

mcp_proxy_adapter/commands/reload_command.py

@@ -20,11 +20,11 @@ class ReloadResult:
     def __init__(
         self,
         config_reloaded: bool,
-        commands_discovered: int,
-        custom_commands_preserved: int,
-        total_commands: int,
-        built_in_commands: int,
+        builtin_commands: int,
         custom_commands: int,
+        loaded_commands: int,
+        remote_commands: int = 0,
+        total_commands: int = 0,
         server_restart_required: bool = True,
         success: bool = True,
         error_message: Optional[str] = None
@@ -34,21 +34,20 @@ class ReloadResult:
         
         Args:
             config_reloaded: Whether configuration was reloaded successfully
-            commands_discovered: Number of commands discovered
-            custom_commands_preserved: Number of custom commands preserved
+            builtin_commands: Number of built-in commands registered
+            custom_commands: Number of custom commands registered
+            loaded_commands: Number of commands loaded from directory
             total_commands: Total number of commands after reload
-            built_in_commands: Number of built-in commands
-            custom_commands: Number of custom commands
             server_restart_required: Whether server restart is required
             success: Whether reload was successful
             error_message: Error message if reload failed
         """
         self.config_reloaded = config_reloaded
-        self.commands_discovered = commands_discovered
-        self.custom_commands_preserved = custom_commands_preserved
-        self.total_commands = total_commands
-        self.built_in_commands = built_in_commands
+        self.builtin_commands = builtin_commands
         self.custom_commands = custom_commands
+        self.loaded_commands = loaded_commands
+        self.remote_commands = remote_commands
+        self.total_commands = total_commands
         self.server_restart_required = server_restart_required
         self.success = success
         self.error_message = error_message
@@ -63,11 +62,11 @@ class ReloadResult:
         return {
             "success": self.success,
             "config_reloaded": self.config_reloaded,
-            "commands_discovered": self.commands_discovered,
-            "custom_commands_preserved": self.custom_commands_preserved,
-            "total_commands": self.total_commands,
-            "built_in_commands": self.built_in_commands,
+            "builtin_commands": self.builtin_commands,
             "custom_commands": self.custom_commands,
+            "loaded_commands": self.loaded_commands,
+            "remote_commands": self.remote_commands,
+            "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
@@ -91,25 +90,25 @@ class ReloadResult:
                     "type": "boolean",
                     "description": "Whether configuration was reloaded successfully"
                 },
-                "commands_discovered": {
+                "builtin_commands": {
                     "type": "integer",
-                    "description": "Number of commands discovered"
+                    "description": "Number of built-in commands registered"
                 },
-                "custom_commands_preserved": {
+                "custom_commands": {
                     "type": "integer",
-                    "description": "Number of custom commands preserved"
+                    "description": "Number of custom commands registered"
                 },
-                "total_commands": {
+                "loaded_commands": {
                     "type": "integer",
-                    "description": "Total number of commands after reload"
+                    "description": "Number of commands loaded from directory"
                 },
-                "built_in_commands": {
+                "remote_commands": {
                     "type": "integer",
-                    "description": "Number of built-in commands"
+                    "description": "Number of commands loaded from remote plugins"
                 },
-                "custom_commands": {
+                "total_commands": {
                     "type": "integer",
-                    "description": "Number of custom commands"
+                    "description": "Total number of commands after reload"
                 },
                 "server_restart_required": {
                     "type": "boolean",
@@ -125,9 +124,8 @@ class ReloadResult:
                 }
             },
             "required": [
-                "success", "config_reloaded", "commands_discovered",
-                "custom_commands_preserved", "total_commands",
-                "built_in_commands", "custom_commands", "server_restart_required"
+                "success", "config_reloaded", "builtin_commands", "custom_commands",
+                "loaded_commands", "remote_commands", "total_commands", "server_restart_required"
             ]
         }
 
@@ -135,7 +133,7 @@ class ReloadResult:
 class ReloadCommand(Command):
     """
     Command for reloading configuration and rediscovering commands.
-    Note: This command will trigger a server restart to apply configuration changes.
+    Uses the unified initialization logic.
     """
     
     name = "reload"
@@ -145,7 +143,7 @@ class ReloadCommand(Command):
         Execute reload command.
         
         Args:
-            **params: Command parameters (currently unused)
+            **params: Command parameters (config_path)
             
         Returns:
             ReloadResult with reload information
@@ -153,18 +151,23 @@ class ReloadCommand(Command):
         try:
             logger.info("🔄 Starting configuration and commands reload...")
             
-            # Perform reload
-            reload_info = registry.reload_config_and_commands()
+            # 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),
-                commands_discovered=reload_info.get("commands_discovered", 0),
-                custom_commands_preserved=reload_info.get("custom_commands_preserved", 0),
-                total_commands=reload_info.get("total_commands", 0),
-                built_in_commands=reload_info.get("built_in_commands", 0),
+                builtin_commands=reload_info.get("builtin_commands", 0),
                 custom_commands=reload_info.get("custom_commands", 0),
-                server_restart_required=True,
+                loaded_commands=reload_info.get("loaded_commands", 0),
+                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
             )
             
@@ -175,11 +178,11 @@ class ReloadCommand(Command):
             logger.error(f"❌ Reload failed: {str(e)}")
             return ReloadResult(
                 config_reloaded=False,
-                commands_discovered=0,
-                custom_commands_preserved=0,
-                total_commands=0,
-                built_in_commands=0,
+                builtin_commands=0,
                 custom_commands=0,
+                loaded_commands=0,
+                remote_commands=0,
+                total_commands=0,
                 server_restart_required=False,
                 success=False,
                 error_message=str(e)
@@ -196,15 +199,10 @@ class ReloadCommand(Command):
         return {
             "type": "object",
             "properties": {
-                "package_path": {
+                "config_path": {
                     "type": "string",
-                    "description": "Path to package with commands to discover",
-                    "default": "mcp_proxy_adapter.commands"
-                },
-                "force_restart": {
-                    "type": "boolean",
-                    "description": "Force server restart to apply configuration changes",
-                    "default": True
+                    "description": "Path to configuration file to reload",
+                    "default": None
                 }
             },
             "additionalProperties": False

mcp_proxy_adapter/commands/result.py

@@ -150,6 +150,7 @@ class ErrorResult(CommandResult):
             details: Additional error details.
         """
         self.message = message
+        self.error = message  # For backward compatibility with tests
         self.code = code
         self.details = details or {}