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

mcp_proxy_adapter/commands/plugins_command.py

@@ -0,0 +1,235 @@
+"""
+Module with plugins command implementation.
+"""
+
+from typing import Dict, Any, Optional, List
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.config import config as config_instance
+
+
+class PluginsResult(SuccessResult):
+    """
+    Result of the plugins command execution.
+    """
+    
+    def __init__(self, success: bool, plugins_server: str, plugins: list, total_plugins: int, error: Optional[str] = None):
+        """
+        Initialize plugins command result.
+        
+        Args:
+            success: Whether operation was successful
+            plugins_server: URL of the plugins server
+            plugins: List of available plugins
+            total_plugins: Total number of plugins
+            error: Error message if operation failed
+        """
+        data = {
+            "success": success,
+            "plugins_server": plugins_server,
+            "plugins": plugins,
+            "total_plugins": total_plugins
+        }
+        if error:
+            data["error"] = error
+            
+        message = f"Found {total_plugins} plugins from {plugins_server}"
+        if error:
+            message = f"Failed to load plugins from {plugins_server}: {error}"
+            
+        super().__init__(data=data, message=message)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result validation.
+        
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "object",
+                    "properties": {
+                        "success": {"type": "boolean"},
+                        "plugins_server": {"type": "string"},
+                        "plugins": {
+                            "type": "array",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "name": {"type": "string"},
+                                    "description": {"type": "string"},
+                                    "url": {"type": "string"},
+                                    "version": {"type": "string"},
+                                    "author": {"type": "string"}
+                                }
+                            }
+                        },
+                        "total_plugins": {"type": "integer"},
+                        "error": {"type": "string"}
+                    },
+                    "required": ["success", "plugins_server", "plugins", "total_plugins"]
+                }
+            },
+            "required": ["data"]
+        }
+
+
+class PluginsCommand(Command):
+    """
+    Command that reads and displays available plugins from a plugins server.
+    
+    This command fetches a JSON file from a configured plugins server URL that contains
+    a list of available plugins. Each plugin in the list typically contains metadata
+    such as name, description, URL, version, and author information.
+    
+    The plugins server URL is configured in the system configuration under
+    'commands.plugins_server'. The JSON file should contain an array of plugin objects
+    with the following structure:
+    
+    {
+        "plugins": [
+            {
+                "name": "plugin_name",
+                "description": "Plugin description",
+                "url": "https://server.com/plugin.py",
+                "version": "1.0.0",
+                "author": "Author Name"
+            }
+        ]
+    }
+    
+    This command is useful for:
+    - Discovering available plugins without manually browsing the server
+    - Getting metadata about plugins before loading them
+    - Building plugin management interfaces
+    - Checking plugin availability and versions
+    
+    The command will return the list of all available plugins along with their
+    metadata, making it easy to choose which plugins to load.
+    """
+    
+    name = "plugins"
+    result_class = PluginsResult
+    
+    async def execute(self, **kwargs) -> PluginsResult:
+        """
+        Execute plugins command.
+        
+        Args:
+            **kwargs: Additional parameters
+            
+        Returns:
+            PluginsResult: Plugins command result
+        """
+        try:
+            # Get configuration from the global config instance
+            plugins_server_url = config_instance.get("commands.plugins_server")
+            
+            if not plugins_server_url:
+                return PluginsResult(
+                    success=False,
+                    plugins_server="",
+                    plugins=[],
+                    total_plugins=0,
+                    error="Plugins server URL not configured"
+                )
+            
+            # Import requests if available
+            try:
+                import requests
+            except ImportError:
+                return PluginsResult(
+                    success=False,
+                    plugins_server=plugins_server_url,
+                    plugins=[],
+                    total_plugins=0,
+                    error="requests library not available"
+                )
+            
+            # Fetch plugins list
+            response = requests.get(plugins_server_url, timeout=30)
+            response.raise_for_status()
+            
+            # Parse JSON response
+            plugins_data = response.json()
+            
+            # Handle different JSON formats
+            if isinstance(plugins_data, list):
+                # Direct array format
+                plugins_list = plugins_data
+            elif "plugins" in plugins_data:
+                # Standard plugins format
+                plugins_list = plugins_data.get("plugins", [])
+            elif "plugin" in plugins_data:
+                # Single plugin format (like from plugins.techsup.od.ua/)
+                plugins_list = [{
+                    "name": plugins_data.get("plugin", "").replace(".py", ""),
+                    "description": plugins_data.get("descr", ""),
+                    "url": f"{plugins_server_url.rstrip('/')}/{plugins_data.get('plugin', '')}",
+                    "version": "1.0.0",
+                    "author": "Unknown",
+                    "category": plugins_data.get("category", "")
+                }]
+            else:
+                # Unknown format, try to extract any plugin-like data
+                plugins_list = []
+                for key, value in plugins_data.items():
+                    if isinstance(value, dict) and any(k in value for k in ["name", "plugin", "url"]):
+                        plugins_list.append(value)
+            
+            return PluginsResult(
+                success=True,
+                plugins_server=plugins_server_url,
+                plugins=plugins_list,
+                total_plugins=len(plugins_list)
+            )
+            
+        except Exception as e:
+            return PluginsResult(
+                success=False,
+                plugins_server=plugins_server_url if 'plugins_server_url' in locals() else "",
+                plugins=[],
+                total_plugins=0,
+                error=str(e)
+            )
+    
+    @classmethod
+    def get_metadata(cls) -> Dict[str, Any]:
+        """
+        Get command metadata.
+        
+        Returns:
+            Dict[str, Any]: Command metadata
+        """
+        return {
+            "name": cls.name,
+            "summary": "Command that reads and displays available plugins from a plugins server",
+            "description": cls.__doc__,
+            "parameters": {},
+            "examples": cls._generate_examples({}),
+            "schema": cls.result_class.get_schema()
+        }
+    
+    @classmethod
+    def _generate_examples(cls, params: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """
+        Generate examples for the command.
+        
+        Args:
+            params: Command parameters schema
+            
+        Returns:
+            List[Dict[str, Any]]: List of examples
+        """
+        examples = [
+            {"command": cls.name, "description": "Get list of available plugins from configured server"},
+            {"command": cls.name, "description": "Discover plugins without parameters"},
+            {"command": cls.name, "description": "Check plugin availability and metadata"}
+        ]
+        return examples 

mcp_proxy_adapter/commands/protocol_management_command.py

@@ -0,0 +1,232 @@
+"""
+Protocol management command module.
+
+This module provides commands for managing and querying protocol configurations,
+including HTTP, HTTPS, and MTLS protocols.
+"""
+
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult, ErrorResult
+from mcp_proxy_adapter.core.protocol_manager import protocol_manager
+from mcp_proxy_adapter.core.logging import logger
+
+
+@dataclass
+class ProtocolInfo:
+    """Protocol information data class."""
+    name: str
+    enabled: bool
+    allowed: bool
+    port: Optional[int]
+    requires_ssl: bool
+    ssl_context_available: bool
+
+
+@dataclass
+class ProtocolManagementResult:
+    """Result data for protocol management operations."""
+    protocols: Dict[str, Dict[str, Any]]
+    allowed_protocols: List[str]
+    validation_errors: List[str]
+    total_protocols: int
+    enabled_protocols: int
+
+
+class ProtocolManagementCommand(Command):
+    """
+    Command for managing and querying protocol configurations.
+    
+    This command provides functionality to:
+    - Get information about all configured protocols
+    - Check protocol validation status
+    - Get allowed protocols list
+    - Validate protocol configurations
+    """
+    
+    name = "protocol_management"
+    descr = "Manage and query protocol configurations (HTTP, HTTPS, MTLS)"
+        
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get command schema.
+        
+        Returns:
+            Command schema dictionary
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "action": {
+                    "type": "string",
+                    "enum": ["get_info", "validate_config", "get_allowed", "check_protocol"],
+                    "description": "Action to perform"
+                },
+                "protocol": {
+                    "type": "string",
+                    "enum": ["http", "https", "mtls"],
+                    "description": "Protocol to check (for check_protocol action)"
+                }
+            },
+            "required": ["action"]
+        }
+        
+    async def execute(self, **kwargs) -> SuccessResult | ErrorResult:
+        """
+        Execute protocol management command.
+        
+        Args:
+            action: Action to perform (get_info, validate_config, get_allowed, check_protocol)
+            protocol: Protocol name for check_protocol action
+            
+        Returns:
+            Command execution result
+        """
+        try:
+            action = kwargs.get("action")
+            
+            if action == "get_info":
+                return await self._get_protocol_info()
+            elif action == "validate_config":
+                return await self._validate_configuration()
+            elif action == "get_allowed":
+                return await self._get_allowed_protocols()
+            elif action == "check_protocol":
+                protocol = kwargs.get("protocol")
+                if not protocol:
+                    return ErrorResult("Protocol parameter required for check_protocol action")
+                return await self._check_protocol(protocol)
+            else:
+                return ErrorResult(f"Unknown action: {action}")
+                
+        except Exception as e:
+            logger.error(f"Protocol management command error: {e}")
+            return ErrorResult(f"Protocol management error: {str(e)}")
+    
+    async def _get_protocol_info(self) -> SuccessResult:
+        """
+        Get information about all protocols.
+        
+        Returns:
+            Success result with protocol information
+        """
+        try:
+            protocol_info = protocol_manager.get_protocol_info()
+            allowed_protocols = protocol_manager.get_allowed_protocols()
+            validation_errors = protocol_manager.validate_protocol_configuration()
+            
+            enabled_count = sum(1 for info in protocol_info.values() if info["enabled"])
+            
+            result_data = ProtocolManagementResult(
+                protocols=protocol_info,
+                allowed_protocols=allowed_protocols,
+                validation_errors=validation_errors,
+                total_protocols=len(protocol_info),
+                enabled_protocols=enabled_count
+            )
+            
+            return SuccessResult(
+                data={
+                    "protocol_info": result_data.protocols,
+                    "allowed_protocols": result_data.allowed_protocols,
+                    "validation_errors": result_data.validation_errors,
+                    "total_protocols": result_data.total_protocols,
+                    "enabled_protocols": result_data.enabled_protocols,
+                    "protocols_enabled": protocol_manager.enabled
+                },
+                message="Protocol information retrieved successfully"
+            )
+            
+        except Exception as e:
+            logger.error(f"Error getting protocol info: {e}")
+            return ErrorResult(f"Failed to get protocol info: {str(e)}")
+    
+    async def _validate_configuration(self) -> SuccessResult:
+        """
+        Validate protocol configuration.
+        
+        Returns:
+            Success result with validation results
+        """
+        try:
+            validation_errors = protocol_manager.validate_protocol_configuration()
+            is_valid = len(validation_errors) == 0
+            
+            return SuccessResult(
+                data={
+                    "is_valid": is_valid,
+                    "validation_errors": validation_errors,
+                    "error_count": len(validation_errors)
+                },
+                message=f"Configuration validation {'passed' if is_valid else 'failed'}"
+            )
+            
+        except Exception as e:
+            logger.error(f"Error validating configuration: {e}")
+            return ErrorResult(f"Failed to validate configuration: {str(e)}")
+    
+    async def _get_allowed_protocols(self) -> SuccessResult:
+        """
+        Get list of allowed protocols.
+        
+        Returns:
+            Success result with allowed protocols
+        """
+        try:
+            allowed_protocols = protocol_manager.get_allowed_protocols()
+            
+            return SuccessResult(
+                data={
+                    "allowed_protocols": allowed_protocols,
+                    "count": len(allowed_protocols)
+                },
+                message="Allowed protocols retrieved successfully"
+            )
+            
+        except Exception as e:
+            logger.error(f"Error getting allowed protocols: {e}")
+            return ErrorResult(f"Failed to get allowed protocols: {str(e)}")
+    
+    async def _check_protocol(self, protocol: str) -> SuccessResult:
+        """
+        Check specific protocol configuration.
+        
+        Args:
+            protocol: Protocol name to check
+            
+        Returns:
+            Success result with protocol check results
+        """
+        try:
+            protocol_lower = protocol.lower()
+            
+            if protocol_lower not in ["http", "https", "mtls"]:
+                return ErrorResult(f"Unknown protocol: {protocol}")
+            
+            is_allowed = protocol_manager.is_protocol_allowed(protocol_lower)
+            port = protocol_manager.get_protocol_port(protocol_lower)
+            config = protocol_manager.get_protocol_config(protocol_lower)
+            
+            ssl_context_available = None
+            if protocol_lower in ["https", "mtls"]:
+                ssl_context_available = protocol_manager.get_ssl_context_for_protocol(protocol_lower) is not None
+            
+            return SuccessResult(
+                data={
+                    "protocol": protocol_lower,
+                    "is_allowed": is_allowed,
+                    "port": port,
+                    "enabled": config.get("enabled", False),
+                    "requires_ssl": protocol_lower in ["https", "mtls"],
+                    "ssl_context_available": ssl_context_available,
+                    "configuration": config
+                },
+                message=f"Protocol '{protocol}' check completed"
+            )
+            
+        except Exception as e:
+            logger.error(f"Error checking protocol {protocol}: {e}")
+            return ErrorResult(f"Failed to check protocol {protocol}: {str(e)}")