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

mcp_proxy_adapter/api/tools.py

@@ -72,14 +72,6 @@ class TSTCommandExecutor:
             raise
 
     @classmethod
-    def get_schema(cls) -> Dict[str, Any]:
-        """
-        Возвращает схему инструмента в формате OpenAPI.
-
-        Returns:
-            Словарь со схемой инструмента
-        """
-        return ToolIntegration.generate_tool_schema(cls.name, registry, cls.description)
 
     @classmethod
     def get_description(cls, format: str = "json") -> Union[Dict[str, Any], str]:
@@ -167,43 +159,5 @@ class TSTCommandExecutor:
 available_tools = {TSTCommandExecutor.name: TSTCommandExecutor}
 
 
-def get_tool_description(
-    tool_name: str, format: str = "json"
-) -> Union[Dict[str, Any], str]:
-    """
-    Получает описание инструмента API по имени.
-
-    Args:
-        tool_name: Имя инструмента API
-        format: Формат описания (json, markdown, html)
-
-    Returns:
-        Описание инструмента в указанном формате
 
-    Raises:
-        NotFoundError: Если инструмент не найден
-    """
-    if tool_name in available_tools:
-        return available_tools[tool_name].get_description(format)
-    else:
-        raise NotFoundError(f"Инструмент '{tool_name}' не найден")
-
-
-async def execute_tool(tool_name: str, **params) -> Dict[str, Any]:
-    """
-    Выполняет инструмент API с указанными параметрами.
 
-    Args:
-        tool_name: Имя инструмента API
-        **params: Параметры инструмента
-
-    Returns:
-        Результат выполнения инструмента
-
-    Raises:
-        NotFoundError: Если инструмент не найден
-    """
-    if tool_name in available_tools:
-        return await available_tools[tool_name].execute(**params)
-    else:
-        raise NotFoundError(f"Инструмент '{tool_name}' не найден")

mcp_proxy_adapter/cli/__init__.py

@@ -0,0 +1,12 @@
+"""
+MCP Proxy Adapter CLI Module
+
+This module provides command-line interface for MCP Proxy Adapter framework.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from .main import main
+
+__all__ = ['main']

mcp_proxy_adapter/cli/commands/__init__.py

@@ -0,0 +1,15 @@
+"""
+CLI Commands Module
+
+This module contains all CLI commands for MCP Proxy Adapter.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from .generate import GenerateCommand
+from .testconfig import TestConfigCommand
+from .server import ServerCommand
+from .sets import SetsCommand
+
+__all__ = ['GenerateCommand', 'TestConfigCommand', 'ServerCommand', 'SetsCommand']

mcp_proxy_adapter/cli/commands/client.py

@@ -0,0 +1,100 @@
+"""
+MCP Client Command
+
+Client CLI for calling health and JSON-RPC endpoints in various modes.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import requests
+from mcp_proxy_adapter.client.proxy import ProxyClient
+
+
+def _build_base_url(protocol: str, host: str, port: int) -> str:
+    scheme = "https" if protocol == "https" else "http"
+    return f"{scheme}://{host}:{port}"
+
+
+def _request_kwargs(protocol: str, token_header: Optional[str], token: Optional[str],
+                    cert: Optional[str], key: Optional[str], ca: Optional[str]) -> Dict[str, Any]:
+    headers: Dict[str, str] = {"Content-Type": "application/json"}
+    if token_header and token:
+        headers[token_header] = token
+
+    kwargs: Dict[str, Any] = {"headers": headers, "timeout": 10}
+
+    if protocol == "https":
+        if cert and key:
+            kwargs["cert"] = (cert, key)
+        # For examples we allow self-signed; if CA provided, use it, otherwise disable verification
+        if ca:
+            kwargs["verify"] = str(Path(ca))
+        else:
+            kwargs["verify"] = False
+
+    return kwargs
+
+
+def client_command(args) -> int:
+    """Dispatch client subcommands."""
+    protocol = args.protocol
+    host = args.host
+    port = args.port
+    base = _build_base_url(protocol, host, port)
+    kwargs = _request_kwargs(
+        protocol,
+        getattr(args, "token_header", None),
+        getattr(args, "token", None),
+        getattr(args, "cert", None),
+        getattr(args, "key", None),
+        getattr(args, "ca", None),
+    )
+
+    try:
+        if args.client_command == "health":
+            resp = requests.get(f"{base}/health", **kwargs)
+            print(json.dumps(resp.json(), ensure_ascii=False))
+            return 0 if resp.ok else 1
+
+        if args.client_command == "jsonrpc":
+            payload: Dict[str, Any] = {
+                "jsonrpc": "2.0",
+                "method": args.method,
+                "params": json.loads(args.params) if args.params else {},
+                "id": args.id,
+            }
+            resp = requests.post(f"{base}/api/jsonrpc", data=json.dumps(payload), **kwargs)
+            print(json.dumps(resp.json(), ensure_ascii=False))
+            return 0 if resp.ok else 1
+
+        if args.client_command == "proxy-register":
+            pc = ProxyClient(args.proxy_url)
+            res = pc.register(args.name, args.url, capabilities=args.capabilities or [], metadata=None)
+            print(json.dumps(res, ensure_ascii=False))
+            return 0
+
+        if args.client_command == "proxy-unregister":
+            pc = ProxyClient(args.proxy_url)
+            res = pc.unregister(args.name)
+            print(json.dumps(res, ensure_ascii=False))
+            return 0
+
+        if args.client_command == "proxy-list":
+            pc = ProxyClient(args.proxy_url)
+            res = pc.list_servers()
+            print(json.dumps(res, ensure_ascii=False))
+            return 0
+
+        print("Available: client health|jsonrpc")
+        return 1
+
+    except Exception as exc:  # noqa: BLE001 (keep simple CLI handling)
+        print(f"❌ Client error: {exc}")
+        return 1
+
+

mcp_proxy_adapter/cli/commands/config_generate.py

@@ -0,0 +1,21 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+CLI command: config generate (Simple configuration generator)
+"""
+
+from __future__ import annotations
+
+from argparse import Namespace
+
+from mcp_proxy_adapter.core.config.simple_config_generator import SimpleConfigGenerator
+
+
+def config_generate_command(args: Namespace) -> int:
+    generator = SimpleConfigGenerator()
+    out = generator.generate(protocol=args.protocol, with_proxy=args.with_proxy, out_path=args.out)
+    print(f"✅ Configuration generated: {out}")
+    return 0
+
+

mcp_proxy_adapter/cli/commands/config_validate.py

@@ -0,0 +1,36 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+CLI command: config validate (Simple configuration validation)
+"""
+
+from __future__ import annotations
+
+import sys
+from argparse import Namespace
+
+from mcp_proxy_adapter.core.config.simple_config import SimpleConfig
+from mcp_proxy_adapter.core.config.simple_config_validator import SimpleConfigValidator
+
+
+def config_validate_command(args: Namespace) -> int:
+    cfg = SimpleConfig(args.file)
+    try:
+        model = cfg.load()
+    except Exception as e:
+        print(f"❌ Failed to load config: {e}")
+        return 1
+
+    validator = SimpleConfigValidator()
+    errors = validator.validate(model)
+    if errors:
+        print("❌ Validation failed:")
+        for err in errors:
+            print(f"   - {err.message}")
+        return 1
+
+    print("✅ Validation OK")
+    return 0
+
+

mcp_proxy_adapter/cli/commands/generate.py

@@ -0,0 +1,259 @@
+"""
+Generate Command
+
+This module implements the generate command for creating configuration files.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Import the existing config generator
+try:
+    from mcp_proxy_adapter.examples.config_builder import generate_complete_config
+    from mcp_proxy_adapter.core.config_validator import ConfigValidator
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+    print("Warning: Configuration validation not available. Install the package to enable validation.")
+
+
+class GenerateCommand:
+    """Command for generating configuration files."""
+    
+    def __init__(self):
+        """Initialize the generate command."""
+        pass
+    
+    def execute(self, args: Dict[str, Any]) -> int:
+        """
+        Execute the generate command.
+        
+        Args:
+            args: Parsed command arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        try:
+            # Handle special cases
+            if args.get('all'):
+                return self._generate_all_configs(args)
+            
+            # Generate single configuration
+            return self._generate_single_config(args)
+            
+        except Exception as e:
+            print(f"❌ Error generating configuration: {e}")
+            return 1
+    
+    def _generate_single_config(self, args: Dict[str, Any]) -> int:
+        """Generate a single configuration file."""
+        # Create configuration
+        config = self._create_config_from_args(args)
+        
+        # Save configuration
+        if args.get('stdout'):
+            # Output to stdout
+            print(json.dumps(config, indent=2, ensure_ascii=False))
+        else:
+            # Save to file
+            config_file = self._save_config(config, args)
+            print(f"✅ Configuration saved to: {config_file}")
+        
+        return 0
+    
+    def _generate_all_configs(self, args: Dict[str, Any]) -> int:
+        """Generate all standard configurations."""
+        print("🔧 Generating MCP Proxy Adapter configurations...")
+        print("=" * 60)
+        
+        # Define all standard configurations
+        configs = [
+            # HTTP configurations
+            ("http", False, False, 20000),
+            ("http", True, True, 20001),  # token + roles
+            ("http", True, False, 20002),  # token only
+            
+            # HTTPS configurations
+            ("https", False, False, 20003),
+            ("https", True, True, 20004),  # token + roles
+            ("https", True, False, 20005),  # token only
+            
+            # mTLS configurations
+            ("mtls", False, False, 20006),
+            ("mtls", False, True, 20007),  # roles only (from certificate)
+        ]
+        
+        generated_files = []
+        
+        for protocol, token, roles, port in configs:
+            # Create configuration name
+            name_parts = [protocol]
+            if token:
+                name_parts.append("token")
+            if roles:
+                name_parts.append("roles")
+            
+            config_name = "_".join(name_parts)
+            
+            # Create args for this configuration
+            config_args = args.copy()
+            config_args.update({
+                'protocol': protocol,
+                'token': token,
+                'roles': roles,
+                'port': port
+            })
+            
+            # Generate configuration
+            config = self._create_config_from_args(config_args)
+            
+            # Save configuration
+            config_file = self._save_config(config, config_args, config_name)
+            generated_files.append(config_file)
+            
+            print(f"✅ Created {config_name}.json (port {port})")
+        
+        # Create roles.json file if any role-based configs were generated
+        self._create_roles_file(args.get('output_dir', './configs'))
+        
+        print(f"\n🎉 Generated {len(generated_files)} configurations in {args.get('output_dir', './configs')}/")
+        print("\n📋 Generated configurations:")
+        for config_file in generated_files:
+            print(f"  - {config_file.name}")
+        
+        return 0
+    
+    def _create_config_from_args(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """Create configuration dictionary from arguments."""
+        # Start with basic configuration
+        config = generate_complete_config(
+            args.get('host', '127.0.0.1'),
+            args.get('port', 8000)
+        )
+        
+        # Set protocol
+        config["server"]["protocol"] = args.get('protocol', 'http')
+        
+        # Configure SSL based on protocol
+        if args.get('protocol') == 'https':
+            config["ssl"]["enabled"] = True
+            config["ssl"]["cert_file"] = f"{args.get('cert_dir', './certs')}/server.crt"
+            config["ssl"]["key_file"] = f"{args.get('key_dir', './keys')}/server.key"
+        elif args.get('protocol') == 'mtls':
+            config["ssl"]["enabled"] = True
+            config["ssl"]["cert_file"] = f"{args.get('cert_dir', './certs')}/server.crt"
+            config["ssl"]["key_file"] = f"{args.get('key_dir', './keys')}/server.key"
+            config["ssl"]["ca_cert"] = f"{args.get('cert_dir', './certs')}/ca.crt"
+            config["transport"]["verify_client"] = True
+        
+        # Configure security if token authentication is enabled
+        if args.get('token'):
+            config["security"]["enabled"] = True
+            config["security"]["tokens"] = {
+                "admin": "admin-secret-key",
+                "user": "user-secret-key",
+                "readonly": "readonly-secret-key"
+            }
+            
+            if args.get('roles'):
+                config["security"]["roles"] = {
+                    "admin": ["read", "write", "delete", "admin"],
+                    "user": ["read", "write"],
+                    "readonly": ["read"]
+                }
+                config["security"]["roles_file"] = f"{args.get('output_dir', './configs')}/roles.json"
+                config["roles"]["enabled"] = True
+                config["roles"]["config_file"] = f"{args.get('output_dir', './configs')}/roles.json"
+        elif args.get('roles') and args.get('protocol') == 'mtls':
+            # For mTLS, roles can be enabled without tokens (from certificate)
+            config["roles"]["enabled"] = True
+            config["roles"]["config_file"] = f"{args.get('output_dir', './configs')}/roles.json"
+        
+        # Configure proxy registration if enabled
+        if args.get('proxy_url'):
+            config["proxy_registration"]["enabled"] = True
+            config["proxy_registration"]["proxy_url"] = args['proxy_url']
+            config["proxy_registration"]["server_id"] = args.get('server_id', 'mcp-proxy-adapter')
+        
+        return config
+    
+    def _save_config(self, config: Dict[str, Any], args: Dict[str, Any], filename: Optional[str] = None) -> Path:
+        """Save configuration to file with optional validation."""
+        output_dir = Path(args.get('output_dir', './configs'))
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Determine filename
+        if filename:
+            config_name = filename
+        elif args.get('output'):
+            config_name = args['output']
+        else:
+            # Generate filename from arguments
+            name_parts = [args.get('protocol', 'http')]
+            if args.get('token'):
+                name_parts.append("token")
+            if args.get('roles'):
+                name_parts.append("roles")
+            config_name = "_".join(name_parts)
+        
+        config_file = output_dir / f"{config_name}.json"
+        
+        # Save configuration
+        with open(config_file, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+        
+        # Validate configuration if requested and validation is available
+        if not args.get('no_validate') and VALIDATION_AVAILABLE:
+            print(f"🔍 Validating configuration: {config_file}")
+            validator = ConfigValidator()
+            validator.config_data = config
+            results = validator.validate_config()
+            
+            if results:
+                print("⚠️  Validation issues found:")
+                for result in results:
+                    level_symbol = "❌" if result.level == "error" else "⚠️" if result.level == "warning" else "ℹ️"
+                    print(f"  {level_symbol} {result.message}")
+                    if hasattr(result, 'suggestion') and result.suggestion:
+                        print(f"     Suggestion: {result.suggestion}")
+            else:
+                print("✅ Configuration validation passed!")
+        
+        return config_file
+    
+    def _create_roles_file(self, output_dir: str) -> None:
+        """Create roles.json file for role-based configurations."""
+        roles_config = {
+            "enabled": True,
+            "default_policy": {
+                "deny_by_default": False,
+                "require_role_match": False,
+                "case_sensitive": False,
+                "allow_wildcard": False
+            },
+            "roles": {
+                "admin": ["read", "write", "delete", "admin"],
+                "user": ["read", "write"],
+                "readonly": ["read"],
+                "guest": ["read"],
+                "proxy": ["read", "write"]
+            },
+            "permissions": {
+                "read": ["GET"],
+                "write": ["POST", "PUT", "PATCH"],
+                "delete": ["DELETE"],
+                "admin": ["*"]
+            }
+        }
+        
+        roles_file = Path(output_dir) / "roles.json"
+        with open(roles_file, 'w', encoding='utf-8') as f:
+            json.dump(roles_config, f, indent=2, ensure_ascii=False)
+        print(f"✅ Created roles.json")
+
+

mcp_proxy_adapter/cli/commands/server.py

@@ -0,0 +1,174 @@
+"""
+Server Command
+
+This module implements the server command for starting MCP Proxy Adapter server.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+try:
+    from mcp_proxy_adapter.core.config_validator import ConfigValidator
+    from mcp_proxy_adapter.core.server_adapter import UnifiedServerRunner
+    from mcp_proxy_adapter.api.app import create_app
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+
+
+class ServerCommand:
+    """Command for starting the MCP Proxy Adapter server."""
+    
+    def __init__(self):
+        """Initialize the server command."""
+        pass
+    
+    def execute(self, args: Dict[str, Any]) -> int:
+        """
+        Execute the server command.
+        
+        Args:
+            args: Parsed command arguments
+            
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        config_file = args['config']
+        no_validate = args.get('no_validate', False)
+        
+        try:
+            # Load configuration
+            print(f"🔍 Loading configuration from: {config_file}")
+            with open(config_file, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+            
+            # Validate configuration if not disabled
+            if not no_validate and VALIDATION_AVAILABLE:
+                print("🔍 Validating configuration...")
+                if not self._validate_config(config, config_file):
+                    print("❌ Configuration validation failed. Server not started.")
+                    return 1
+                print("✅ Configuration validation passed!")
+            elif no_validate:
+                print("⚠️  Configuration validation skipped (--no-validate)")
+            else:
+                print("⚠️  Configuration validation not available")
+            
+            # Override configuration with command line arguments
+            if args.get('port'):
+                config['server']['port'] = args['port']
+                print(f"🔧 Overriding port to: {args['port']}")
+            
+            if args.get('host'):
+                config['server']['host'] = args['host']
+                print(f"🔧 Overriding host to: {args['host']}")
+            
+            # Create and start server
+            print("🚀 Starting MCP Proxy Adapter server...")
+            self._start_server(config, args)
+            
+        except FileNotFoundError:
+            print(f"❌ Configuration file not found: {config_file}")
+            return 1
+        except json.JSONDecodeError as e:
+            print(f"❌ Invalid JSON in configuration file: {e}")
+            return 1
+        except Exception as e:
+            print(f"❌ Error starting server: {e}")
+            return 1
+    
+    def _validate_config(self, config: Dict[str, Any], config_file: str) -> bool:
+        """
+        Validate configuration using ConfigValidator.
+        
+        Args:
+            config: Configuration dictionary
+            config_file: Path to configuration file
+            
+        Returns:
+            True if configuration is valid, False otherwise
+        """
+        try:
+            validator = ConfigValidator()
+            validator.config_data = config
+            results = validator.validate_config()
+            
+            # Check for errors
+            errors = [r for r in results if r.level == "error"]
+            warnings = [r for r in results if r.level == "warning"]
+            
+            if errors:
+                print("❌ Configuration validation errors:")
+                for error in errors:
+                    print(f"  • {error.message}")
+                    if hasattr(error, 'suggestion') and error.suggestion:
+                        print(f"    → {error.suggestion}")
+                return False
+            
+            if warnings:
+                print("⚠️  Configuration validation warnings:")
+                for warning in warnings:
+                    print(f"  • {warning.message}")
+                    if hasattr(warning, 'suggestion') and warning.suggestion:
+                        print(f"    → {warning.suggestion}")
+            
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error during configuration validation: {e}")
+            return False
+    
+    def _start_server(self, config: Dict[str, Any], args: Dict[str, Any]) -> None:
+        """
+        Start the MCP Proxy Adapter server.
+        
+        Args:
+            config: Server configuration
+            args: Command line arguments
+        """
+        try:
+            # Create ASGI application
+            app = create_app(config)
+            
+            # Prepare server configuration
+            server_config = {
+                'host': config['server']['host'],
+                'port': config['server']['port'],
+                'log_level': config['server'].get('log_level', 'INFO'),
+                'reload': args.get('reload', False)
+            }
+            
+            # Add SSL configuration if present
+            if 'ssl' in config and config['ssl'].get('enabled'):
+                server_config.update({
+                    'certfile': config['ssl'].get('cert_file'),
+                    'keyfile': config['ssl'].get('key_file'),
+                    'ca_certs': config['ssl'].get('ca_cert'),
+                    'verify_mode': 'CERT_REQUIRED' if config.get('transport', {}).get('verify_client') else 'CERT_NONE'
+                })
+            
+            # Start server
+            print(f"🌐 Server starting on {server_config['host']}:{server_config['port']}")
+            print(f"📋 Protocol: {config['server']['protocol']}")
+            print(f"🔐 Security: {'Enabled' if config.get('security', {}).get('enabled') else 'Disabled'}")
+            print(f"🔑 Authentication: {'Token-based' if config.get('security', {}).get('tokens') else 'Certificate-based' if config['server']['protocol'] == 'mtls' else 'None'}")
+            print(f"👥 Roles: {'Enabled' if config.get('roles', {}).get('enabled') else 'Disabled'}")
+            print("=" * 60)
+            
+            # Use UnifiedServerRunner to start the server
+            runner = UnifiedServerRunner()
+            runner.run_server(app, server_config)
+            
+        except ImportError as e:
+            print(f"❌ Missing required dependencies: {e}")
+            print("💡 Install required packages: pip install hypercorn")
+            raise
+        except Exception as e:
+            print(f"❌ Failed to start server: {e}")
+            raise
+
+