mcp-proxy-adapter 2.0.1__py3-none-any.whl → 6.9.50__py3-none-any.whl

mcp_proxy_adapter/cli/parser.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+"""
+CLI Argument Parser for MCP Proxy Adapter
+Multi-level help system with detailed parameter descriptions
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import argparse
+
+
+def create_main_parser() -> argparse.ArgumentParser:
+    """Create top-level CLI parser with subcommands."""
+    parser = argparse.ArgumentParser(prog="mcp-cli", description="MCP Proxy Adapter CLI")
+    subparsers = parser.add_subparsers(dest='command', metavar='command')
+
+    # generate
+    generate_parser = subparsers.add_parser('generate', help='Generate configuration (legacy)')
+    _setup_generate_parser(generate_parser)
+
+    # testconfig
+    testconfig_parser = subparsers.add_parser('testconfig', help='Validate configuration (legacy)')
+    _setup_testconfig_parser(testconfig_parser)
+
+    # sets
+    sets_parser = subparsers.add_parser('sets', help='Generate preset configuration set (legacy)')
+    _setup_sets_parser(sets_parser)
+
+    # server
+    server_parser = subparsers.add_parser('server', help='Run server (legacy)')
+    _setup_server_parser(server_parser)
+
+    # simple config commands (new)
+    config_parser = subparsers.add_parser('config', help='Simple config utilities')
+    config_sub = config_parser.add_subparsers(dest='config_command')
+
+    # config generate
+    cfg_gen = config_sub.add_parser('generate', help='Generate simple configuration')
+    cfg_gen.add_argument('--protocol', required=True, choices=['http', 'https', 'mtls'], help='Server/proxy protocol')
+    cfg_gen.add_argument('--with-proxy', action='store_true', help='Include proxy_client section')
+    cfg_gen.add_argument('--out', default='config.json', help='Output config path (default: config.json)')
+    
+    # Server parameters
+    cfg_gen.add_argument('--server-host', help='Server host (default: 0.0.0.0)')
+    cfg_gen.add_argument('--server-port', type=int, help='Server port (default: 8080)')
+    cfg_gen.add_argument('--server-cert-file', help='Server certificate file path')
+    cfg_gen.add_argument('--server-key-file', help='Server key file path')
+    cfg_gen.add_argument('--server-ca-cert-file', help='Server CA certificate file path')
+    
+    # Proxy parameters
+    cfg_gen.add_argument('--proxy-host', help='Proxy host (default: localhost)')
+    cfg_gen.add_argument('--proxy-port', type=int, help='Proxy port (default: 3005)')
+    cfg_gen.add_argument('--proxy-cert-file', help='Proxy client certificate file path')
+    cfg_gen.add_argument('--proxy-key-file', help='Proxy client key file path')
+    cfg_gen.add_argument('--proxy-ca-cert-file', help='Proxy CA certificate file path')
+
+    # config validate
+    cfg_val = config_sub.add_parser('validate', help='Validate simple configuration file')
+    cfg_val.add_argument('--file', required=True, help='Path to configuration file')
+
+    # client
+    client_parser = subparsers.add_parser('client', help='HTTP/HTTPS/mTLS client for health and JSON-RPC')
+    _setup_client_parser(client_parser)
+
+    return parser
+
+
+def _setup_generate_parser(parser: argparse.ArgumentParser):
+    """Setup generate command parser"""
+    
+    # Protocol selection
+    protocol_group = parser.add_argument_group(
+        'Protocol Configuration',
+        'Select the communication protocol and security level'
+    )
+    protocol_group.add_argument(
+        '--protocol',
+        choices=['http', 'https', 'mtls'],
+        required=True,
+        help='''Communication protocol:
+  http  - Plain HTTP (no encryption)
+  https - HTTP with SSL/TLS encryption
+  mtls  - Mutual TLS with client certificate verification'''
+    )
+    
+    # Security options
+    security_group = parser.add_argument_group(
+        'Security Configuration',
+        'Configure authentication and authorization'
+    )
+    security_group.add_argument(
+        '--token',
+        action='store_true',
+        help='Enable token-based authentication (API keys)'
+    )
+    security_group.add_argument(
+        '--roles',
+        action='store_true',
+        help='Enable role-based access control (requires --token)'
+    )
+    
+    # Server configuration
+    server_group = parser.add_argument_group(
+        'Server Configuration',
+        'Configure server host and port settings'
+    )
+    server_group.add_argument(
+        '--host',
+        default='127.0.0.1',
+        help='Server host address (default: 127.0.0.1)'
+    )
+    server_group.add_argument(
+        '--port',
+        type=int,
+        default=8000,
+        help='Server port number (default: 8000)'
+    )
+    
+    # SSL/TLS configuration
+    ssl_group = parser.add_argument_group(
+        'SSL/TLS Configuration',
+        'Configure SSL certificates and keys (required for https/mtls)'
+    )
+    ssl_group.add_argument(
+        '--cert-dir',
+        default='./certs',
+        help='Directory containing SSL certificates (default: ./certs)'
+    )
+    ssl_group.add_argument(
+        '--key-dir',
+        default='./keys',
+        help='Directory containing SSL private keys (default: ./keys)'
+    )
+    
+    # Proxy registration
+    proxy_group = parser.add_argument_group(
+        'Proxy Registration',
+        'Configure automatic registration with MCP proxy'
+    )
+    proxy_group.add_argument(
+        '--proxy-registration',
+        action='store_true',
+        help='Enable automatic proxy registration'
+    )
+    proxy_group.add_argument(
+        '--proxy-url',
+        help='Proxy URL for registration (required with --proxy-registration)'
+    )
+    proxy_group.add_argument(
+        '--server-id',
+        default='mcp_proxy_adapter',
+        help='Server ID for proxy registration (default: mcp_proxy_adapter)'
+    )
+    
+    # Output options
+    output_group = parser.add_argument_group(
+        'Output Configuration',
+        'Configure output file and directory settings'
+    )
+    output_group.add_argument(
+        '--output-dir',
+        default='./configs',
+        help='Output directory for configuration files (default: ./configs)'
+    )
+    output_group.add_argument(
+        '--output',
+        help='Output filename (without extension, auto-generated if not specified)'
+    )
+    output_group.add_argument(
+        '--stdout',
+        action='store_true',
+        help='Output configuration to stdout instead of file'
+    )
+    output_group.add_argument(
+        '--no-validate',
+        action='store_true',
+        help='Skip configuration validation after generation'
+    )
+
+
+def _setup_testconfig_parser(parser: argparse.ArgumentParser):
+    """Setup testconfig command parser"""
+    
+    parser.add_argument(
+        '--config',
+        required=True,
+        help='Path to configuration file to validate'
+    )
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='Enable verbose output with detailed validation results'
+    )
+    parser.add_argument(
+        '--fix',
+        action='store_true',
+        help='Attempt to fix common configuration issues automatically'
+    )
+
+
+def _setup_sets_parser(parser: argparse.ArgumentParser):
+    """Setup sets command parser"""
+    
+    # Mode selection (positional argument)
+    parser.add_argument(
+        'set_name',
+        choices=['http', 'https', 'mtls'],
+        help='''Configuration mode:
+  http  - HTTP basic configuration
+  https - HTTPS with SSL/TLS
+  mtls  - Mutual TLS with client certificates'''
+    )
+    
+    # Modifiers
+    parser.add_argument(
+        '--modifiers',
+        nargs='+',
+        choices=['token', 'roles'],
+        help='''Configuration modifiers:
+  token - Add token authentication
+  roles - Add role-based access control (requires token)'''
+    )
+    parser.add_argument(
+        '--no-dns-check',
+        action='store_true',
+        help='Disable DNS hostname checking (useful for Docker networks)'
+    )
+    
+    # SSL configuration for https/mtls
+    ssl_group = parser.add_argument_group('SSL Configuration')
+    ssl_group.add_argument(
+        '--cert-dir',
+        default='./mtls_certificates/server',
+        help='Directory containing SSL certificates (default: ./mtls_certificates/server)'
+    )
+    ssl_group.add_argument(
+        '--key-dir',
+        default='./mtls_certificates/server',
+        help='Directory containing SSL private keys (default: ./mtls_certificates/server)'
+    )
+    
+    # Output options
+    output_group = parser.add_argument_group('Output Options')
+    output_group.add_argument(
+        '--output-dir',
+        default='./configs',
+        help='Output directory for configuration files (default: ./configs)'
+    )
+    output_group.add_argument(
+        '--host',
+        default='127.0.0.1',
+        help='Server host address (default: 127.0.0.1)'
+    )
+    output_group.add_argument(
+        '--port',
+        type=int,
+        default=8000,
+        help='Server port number (default: 8000)'
+    )
+    output_group.add_argument(
+        '--proxy-url',
+        help='Proxy URL for registration (auto-generated if not specified)'
+    )
+
+
+def _setup_server_parser(parser: argparse.ArgumentParser):
+    """Setup server command parser"""
+    
+    parser.add_argument(
+        '--config',
+        required=True,
+        help='Path to configuration file'
+    )
+    parser.add_argument(
+        '--host',
+        help='Override server host from configuration'
+    )
+    parser.add_argument(
+        '--port',
+        type=int,
+        help='Override server port from configuration'
+    )
+    parser.add_argument(
+        '--debug',
+        action='store_true',
+        help='Enable debug mode with verbose logging'
+    )
+    parser.add_argument(
+        '--reload',
+        action='store_true',
+        help='Enable auto-reload on configuration changes'
+    )
+
+
+def _setup_client_parser(parser: argparse.ArgumentParser):
+    """Setup client command parser"""
+
+    sub = parser.add_subparsers(dest='client_command')
+
+    # health
+    health = sub.add_parser('health', help='Call GET /health')
+    health.add_argument('--protocol', choices=['http', 'https'], required=True, help='Connection protocol')
+    health.add_argument('--host', default='127.0.0.1', help='Server host (default: 127.0.0.1)')
+    health.add_argument('--port', type=int, required=True, help='Server port')
+    health.add_argument('--token-header', default='X-API-Key', help='API key header name (default: X-API-Key)')
+    health.add_argument('--token', help='API key token value')
+    health.add_argument('--cert', help='Client cert path (for mTLS/HTTPS testing)')
+    health.add_argument('--key', help='Client key path (for mTLS/HTTPS testing)')
+    health.add_argument('--ca', help='CA cert path (verify server with this CA)')
+
+    # jsonrpc
+    j = sub.add_parser('jsonrpc', help='Call POST /api/jsonrpc')
+    j.add_argument('--protocol', choices=['http', 'https'], required=True, help='Connection protocol')
+    j.add_argument('--host', default='127.0.0.1', help='Server host (default: 127.0.0.1)')
+    j.add_argument('--port', type=int, required=True, help='Server port')
+    j.add_argument('--token-header', default='X-API-Key', help='API key header name (default: X-API-Key)')
+    j.add_argument('--token', help='API key token value')
+    j.add_argument('--cert', help='Client cert path (for mTLS/HTTPS testing)')
+    j.add_argument('--key', help='Client key path (for mTLS/HTTPS testing)')
+    j.add_argument('--ca', help='CA cert path (verify server with this CA)')
+    j.add_argument('--method', required=True, help='JSON-RPC method')
+    j.add_argument('--params', help='JSON string with params, default {}')
+    j.add_argument('--id', type=int, default=1, help='Request id (default: 1)')
+
+    # proxy register/unregister/list
+    preg = sub.add_parser('proxy-register', help='Register adapter on registry')
+    preg.add_argument('--proxy-url', required=True, help='Registry base URL, e.g. http://localhost:3005')
+    preg.add_argument('--name', required=True, help='Adapter name')
+    preg.add_argument('--url', required=True, help='Adapter base URL')
+    preg.add_argument('--capabilities', nargs='*', help='Capabilities list')
+
+    punreg = sub.add_parser('proxy-unregister', help='Unregister adapter from registry')
+    punreg.add_argument('--proxy-url', required=True)
+    punreg.add_argument('--name', required=True)
+
+    plist = sub.add_parser('proxy-list', help='List registered adapters')
+    plist.add_argument('--proxy-url', required=True)

mcp_proxy_adapter/cli/validators.py

@@ -0,0 +1,231 @@
+"""
+CLI Parameter Validators
+
+This module provides validation functions for CLI parameters and their combinations.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import sys
+from pathlib import Path
+
+
+class ValidationError(Exception):
+    """Exception raised when parameter validation fails."""
+    pass
+
+
+class ParameterValidator:
+    """Validates CLI parameters and their combinations."""
+    
+    @staticmethod
+    def validate_protocol(protocol: str) -> bool:
+        """
+        Validate protocol parameter.
+        
+        Args:
+            protocol: Protocol string to validate
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If protocol is invalid
+        """
+        valid_protocols = ['http', 'https', 'mtls']
+        if protocol not in valid_protocols:
+            raise ValidationError(
+                f"Invalid protocol '{protocol}'. Must be one of: {', '.join(valid_protocols)}"
+            )
+        return True
+    
+    @staticmethod
+    def validate_token_with_protocol(token: bool, protocol: str) -> bool:
+        """
+        Validate token parameter with protocol.
+        
+        Args:
+            token: Whether token authentication is enabled
+            protocol: Protocol being used
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If token is not compatible with protocol
+        """
+        if token and protocol == 'mtls':
+            raise ValidationError(
+                "Token authentication is not supported with mTLS protocol. "
+                "mTLS uses client certificates for authentication."
+            )
+        return True
+    
+    @staticmethod
+    def validate_roles_with_auth(roles: bool, token: bool, protocol: str) -> bool:
+        """
+        Validate roles parameter with authentication method.
+        
+        Args:
+            roles: Whether roles are enabled
+            token: Whether token authentication is enabled
+            protocol: Protocol being used
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If roles are not compatible with authentication method
+        """
+        if roles and protocol in ['http', 'https'] and not token:
+            raise ValidationError(
+                f"Roles require token authentication for {protocol} protocol. "
+                "Use --token flag when enabling --roles."
+            )
+        return True
+    
+    @staticmethod
+    def validate_port(port: int) -> bool:
+        """
+        Validate port number.
+        
+        Args:
+            port: Port number to validate
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If port is invalid
+        """
+        if not isinstance(port, int) or port < 1 or port > 65535:
+            raise ValidationError(f"Invalid port '{port}'. Must be an integer between 1 and 65535.")
+        return True
+    
+    @staticmethod
+    def validate_host(host: str) -> bool:
+        """
+        Validate host address.
+        
+        Args:
+            host: Host address to validate
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If host is invalid
+        """
+        if not host or not isinstance(host, str):
+            raise ValidationError("Host must be a non-empty string.")
+        return True
+    
+    @staticmethod
+    def validate_file_path(file_path: str, must_exist: bool = False) -> bool:
+        """
+        Validate file path.
+        
+        Args:
+            file_path: File path to validate
+            must_exist: Whether file must exist
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If file path is invalid
+        """
+        if not file_path or not isinstance(file_path, str):
+            raise ValidationError("File path must be a non-empty string.")
+        
+        if must_exist and not Path(file_path).exists():
+            raise ValidationError(f"File does not exist: {file_path}")
+        
+        return True
+    
+    @staticmethod
+    def validate_directory_path(dir_path: str, must_exist: bool = False) -> bool:
+        """
+        Validate directory path.
+        
+        Args:
+            dir_path: Directory path to validate
+            must_exist: Whether directory must exist
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If directory path is invalid
+        """
+        if not dir_path or not isinstance(dir_path, str):
+            raise ValidationError("Directory path must be a non-empty string.")
+        
+        if must_exist and not Path(dir_path).exists():
+            raise ValidationError(f"Directory does not exist: {dir_path}")
+        
+        return True
+    
+    @staticmethod
+    def validate_url(url: str) -> bool:
+        """
+        Validate URL format.
+        
+        Args:
+            url: URL to validate
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If URL is invalid
+        """
+        if not url or not isinstance(url, str):
+            raise ValidationError("URL must be a non-empty string.")
+        
+        # Basic URL validation
+        if not (url.startswith('http://') or url.startswith('https://')):
+            raise ValidationError("URL must start with 'http://' or 'https://'")
+        
+        return True
+    
+    @staticmethod
+    def validate_server_id(server_id: str) -> bool:
+        """
+        Validate server ID.
+        
+        Args:
+            server_id: Server ID to validate
+            
+        Returns:
+            True if valid
+            
+        Raises:
+            ValidationError: If server ID is invalid
+        """
+        if not server_id or not isinstance(server_id, str):
+            raise ValidationError("Server ID must be a non-empty string.")
+        
+        # Check for valid characters (alphanumeric, hyphens, underscores)
+        import re
+        if not re.match(r'^[a-zA-Z0-9_-]+$', server_id):
+            raise ValidationError(
+                "Server ID must contain only alphanumeric characters, hyphens, and underscores."
+            )
+        
+        return True
+
+
+class ConfigurationValidator:
+    """Validates configuration combinations and dependencies."""
+    
+    @staticmethod
+    
+    @staticmethod
+    
+    @staticmethod
+    
+    @staticmethod
+
+

mcp_proxy_adapter/client/jsonrpc_client/__init__.py

@@ -0,0 +1,9 @@
+"""JSON-RPC client package facade.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from mcp_proxy_adapter.client.jsonrpc_client.client import JsonRpcClient
+
+__all__ = ["JsonRpcClient"]

mcp_proxy_adapter/client/jsonrpc_client/client.py

@@ -0,0 +1,42 @@
+"""Facade JsonRpcClient combining transport and feature mixins.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from mcp_proxy_adapter.client.jsonrpc_client.command_api import CommandApiMixin
+from mcp_proxy_adapter.client.jsonrpc_client.proxy_api import ProxyApiMixin
+from mcp_proxy_adapter.client.jsonrpc_client.queue_api import QueueApiMixin
+
+
+class JsonRpcClient(ProxyApiMixin, QueueApiMixin, CommandApiMixin):
+    """High-level asynchronous JSON-RPC client facade."""
+
+    def __init__(
+        self,
+        protocol: str = "http",
+        host: str = "127.0.0.1",
+        port: int = 8080,
+        token_header: Optional[str] = None,
+        token: Optional[str] = None,
+        cert: Optional[str] = None,
+        key: Optional[str] = None,
+        ca: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            protocol=protocol,
+            host=host,
+            port=port,
+            token_header=token_header,
+            token=token,
+            cert=cert,
+            key=key,
+            ca=ca,
+        )
+
+
+__all__ = ["JsonRpcClient"]

mcp_proxy_adapter/client/jsonrpc_client/command_api.py

@@ -0,0 +1,45 @@
+"""Command helpers for JsonRpcClient.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from mcp_proxy_adapter.client.jsonrpc_client.transport import JsonRpcTransport
+
+
+class CommandApiMixin(JsonRpcTransport):
+    """Mixin providing standard JSON-RPC command helpers."""
+
+    async def echo(
+        self, message: str = "Hello, World!", timestamp: Optional[str] = None
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"message": message}
+        if timestamp:
+            params["timestamp"] = timestamp
+        response = await self.jsonrpc_call("echo", params)
+        return self._extract_result(response)
+
+    async def help(
+        self, command_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if command_name:
+            params["command"] = command_name
+        response = await self.jsonrpc_call("help", params)
+        return self._extract_result(response)
+
+    async def get_config(self) -> Dict[str, Any]:
+        response = await self.jsonrpc_call("config", {})
+        return self._extract_result(response)
+
+    async def long_task(self, seconds: int) -> Dict[str, Any]:
+        response = await self.jsonrpc_call("long_task", {"seconds": seconds})
+        return self._extract_result(response)
+
+    async def job_status(self, job_id: str) -> Dict[str, Any]:
+        response = await self.jsonrpc_call("job_status", {"job_id": job_id})
+        return self._extract_result(response)