mcp-proxy-adapter 6.1.0__py3-none-any.whl → 6.2.0__py3-none-any.whl

mcp_proxy_adapter/examples/debug_role_chain.py

@@ -1,55 +1,40 @@
 #!/usr/bin/env python3
 """
 Debug Role Chain - Анализ цепочки блокировки ролей
-
 Этот скрипт анализирует всю цепочку от аутентификации до блокировки доступа.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import asyncio
 import json
 import sys
 from pathlib import Path
-
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
 sys.path.insert(0, str(project_root))
-
 from mcp_security_framework import SecurityManager, AuthManager, PermissionManager
 from mcp_security_framework.schemas.config import SecurityConfig, AuthConfig, PermissionConfig
-
-
 async def debug_role_chain():
     """Debug the complete role chain from authentication to blocking."""
-    
     print("🔍 АНАЛИЗ ЦЕПОЧКИ БЛОКИРОВКИ РОЛЕЙ")
     print("=" * 60)
-    
     # Load configuration
     config_path = project_root / "mcp_proxy_adapter" / "examples" / "server_configs" / "config_http_token.json"
-    
     with open(config_path) as f:
         config = json.load(f)
-    
     security_config = config.get("security", {})
-    
     print("📋 1. КОНФИГУРАЦИЯ API КЛЮЧЕЙ")
     print("-" * 30)
     api_keys = security_config.get("auth", {}).get("api_keys", {})
     for key, value in api_keys.items():
         print(f"  {key}: {value}")
-    
     print("\n📋 2. КОНФИГУРАЦИЯ РОЛЕЙ")
     print("-" * 30)
     roles_config = security_config.get("permissions", {}).get("roles", {})
     for role, permissions in roles_config.items():
         print(f"  {role}: {permissions}")
-    
     print("\n📋 3. СОЗДАНИЕ КОМПОНЕНТОВ БЕЗОПАСНОСТИ")
     print("-" * 30)
-    
     # Create permission config
     perm_config = PermissionConfig(
         roles_file=str(project_root / "mcp_proxy_adapter" / "examples" / "server_configs" / "roles.json"),
@@ -62,7 +47,6 @@ async def debug_role_chain():
         strict_mode=True,
         roles=roles_config
     )
-    
     # Create auth config
     auth_config = AuthConfig(
         enabled=security_config.get("auth", {}).get("enabled", True),
@@ -79,45 +63,34 @@ async def debug_role_chain():
         oauth2_config=security_config.get("auth", {}).get("oauth2_config"),
         public_paths=security_config.get("auth", {}).get("public_paths", [])
     )
-    
     # Create security config
     security_config_obj = SecurityConfig(
         auth=auth_config,
         permissions=perm_config
     )
-    
     print("✅ Конфигурации созданы")
-    
     print("\n📋 4. ИНИЦИАЛИЗАЦИЯ МЕНЕДЖЕРОВ")
     print("-" * 30)
-    
     # Initialize managers
     permission_manager = PermissionManager(perm_config)
     auth_manager = AuthManager(auth_config, permission_manager)
     security_manager = SecurityManager(security_config_obj)
-    
     print("✅ Менеджеры инициализированы")
-    
     print("\n📋 5. ТЕСТИРОВАНИЕ АУТЕНТИФИКАЦИИ")
     print("-" * 30)
-    
     # Test authentication with different tokens
     test_tokens = {
         "admin": "test-token-123",
-        "user": "user-token-456", 
+        "user": "user-token-456",
         "readonly": "readonly-token-123",
         "invalid": "invalid-token-999"
     }
-    
     auth_results = {}
-    
     for role, token in test_tokens.items():
         print(f"\n🔐 Тестирование токена для роли '{role}': {token}")
-        
         try:
             result = auth_manager.authenticate_api_key(token)
             auth_results[role] = result
-            
             print(f"  ✅ Аутентификация: {'УСПЕШНА' if result.is_valid else 'НЕУДАЧНА'}")
             if result.is_valid:
                 print(f"  👤 Пользователь: {result.username}")
@@ -125,81 +98,61 @@ async def debug_role_chain():
                 print(f"  🔑 Метод: {result.auth_method}")
             else:
                 print(f"  ❌ Ошибка: {result.error_message}")
-                
         except Exception as e:
             print(f"  ❌ Исключение: {e}")
             auth_results[role] = None
-    
     print("\n📋 6. ТЕСТИРОВАНИЕ ПРАВ ДОСТУПА")
     print("-" * 30)
-    
     # Test permissions for different actions
     test_actions = ["read", "write", "manage", "delete"]
-    
     for role, auth_result in auth_results.items():
         if auth_result and auth_result.is_valid:
             print(f"\n🔒 Тестирование прав для роли '{role}' (роли: {auth_result.roles})")
-            
             for action in test_actions:
                 try:
                     # Check permissions using permission manager
                     validation_result = permission_manager.validate_access(
-                        auth_result.roles, 
+                        auth_result.roles,
                         [action]
                     )
-                    
                     status = "✅ РАЗРЕШЕНО" if validation_result.is_valid else "❌ ЗАБЛОКИРОВАНО"
                     print(f"  {action}: {status}")
-                    
                     if not validation_result.is_valid:
                         print(f"    📝 Причина: {validation_result.error_message}")
                         print(f"    🎯 Эффективные права: {validation_result.effective_permissions}")
                         print(f"    ❌ Отсутствующие права: {validation_result.missing_permissions}")
-                        
                 except Exception as e:
                     print(f"  {action}: ❌ ОШИБКА - {e}")
-    
     print("\n📋 7. ТЕСТИРОВАНИЕ ПОЛНОЙ ЦЕПОЧКИ")
     print("-" * 30)
-    
     # Test complete request validation
     for role, token in test_tokens.items():
         print(f"\n🔄 Полная цепочка для роли '{role}'")
-        
         request_data = {
             "api_key": token,
             "required_permissions": ["write"],
             "client_ip": "127.0.0.1"
         }
-        
         try:
             result = security_manager.validate_request(request_data)
-            
             status = "✅ УСПЕШНО" if result.is_valid else "❌ ЗАБЛОКИРОВАНО"
             print(f"  Результат: {status}")
-            
             if not result.is_valid:
                 print(f"  📝 Причина: {result.error_message}")
-                
         except Exception as e:
             print(f"  ❌ ОШИБКА: {e}")
-    
     print("\n📋 8. АНАЛИЗ ПРОБЛЕМЫ")
     print("-" * 30)
-    
     print("🔍 ПРОБЛЕМА: Readonly роль получает доступ к write операциям")
     print("\n📋 ВОЗМОЖНЫЕ ПРИЧИНЫ:")
     print("1. Middleware не передает информацию о пользователе в request.state")
     print("2. Framework middleware не блокирует доступ на уровне middleware")
     print("3. Команда role_test не получает правильный контекст пользователя")
     print("4. Интеграция между middleware и командами не работает")
-    
     print("\n📋 РЕКОМЕНДАЦИИ:")
     print("1. Проверить, как framework middleware устанавливает user info")
     print("2. Добавить проверку прав на уровне middleware")
     print("3. Убедиться, что request.state содержит user info")
     print("4. Проверить интеграцию между middleware и командами")
-
-
 if __name__ == "__main__":
     asyncio.run(debug_role_chain())

mcp_proxy_adapter/examples/demo_client.py

@@ -1,88 +1,68 @@
 """
 Demo Client Script
-
 This script demonstrates how to use the UniversalClient with different
 authentication methods and connection types.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 import asyncio
 import json
 import sys
 from pathlib import Path
-
 # Add project root to path
 sys.path.insert(0, str(Path(__file__).parent.parent))
-
 from examples.universal_client import UniversalClient, create_client_config
-
-
 async def demo_from_config_file(config_file: str):
     """
     Demo client using configuration from file.
-    
     Args:
         config_file: Path to configuration file
     """
     print(f"🚀 Demo from config file: {config_file}")
     print("=" * 50)
-    
     try:
         # Load configuration
         with open(config_file, 'r') as f:
             config = json.load(f)
-        
         print(f"Configuration loaded: {config.get('security', {}).get('auth_method', 'none')} auth")
-        
         # Create and use client
         async with UniversalClient(config) as client:
             # Test connection
             success = await client.test_connection()
-            
             if success:
                 print("✅ Connection successful!")
-                
                 # Test security features
                 security_results = await client.test_security_features()
                 print("\nSecurity Features:")
                 for feature, status in security_results.items():
                     status_icon = "✅" if status else "❌"
                     print(f"  {status_icon} {feature}: {status}")
-                
                 # Make API calls
                 await demo_api_calls(client)
             else:
                 print("❌ Connection failed")
-                
     except FileNotFoundError:
         print(f"❌ Configuration file not found: {config_file}")
     except json.JSONDecodeError:
         print(f"❌ Invalid JSON in configuration file: {config_file}")
     except Exception as e:
         print(f"❌ Demo failed: {e}")
-
-
 async def demo_api_calls(client: UniversalClient):
     """Demonstrate various API calls."""
     print("\n📡 API Calls Demo:")
     print("-" * 30)
-    
     # Test health endpoint
     try:
         health = await client.get("/health")
         print(f"Health: {health}")
     except Exception as e:
         print(f"Health check failed: {e}")
-    
     # Test status endpoint
     try:
         status = await client.get("/api/status")
         print(f"Status: {status}")
     except Exception as e:
         print(f"Status check failed: {e}")
-    
     # Test JSON-RPC command
     try:
         command_data = {
@@ -94,12 +74,10 @@ async def demo_api_calls(client: UniversalClient):
             },
             "id": 1
         }
-        
         result = await client.post("/api/jsonrpc", command_data)
         print(f"Command Result: {result}")
     except Exception as e:
         print(f"Command execution failed: {e}")
-    
     # Test security command if available
     try:
         security_data = {
@@ -111,46 +89,33 @@ async def demo_api_calls(client: UniversalClient):
             },
             "id": 2
         }
-        
         result = await client.post("/api/jsonrpc", security_data)
         print(f"Security Status: {result}")
     except Exception as e:
         print(f"Security command failed: {e}")
-
-
 async def demo_all_configs():
     """Demo all available client configurations."""
     print("🚀 Demo All Client Configurations")
     print("=" * 50)
-    
     config_dir = Path(__file__).parent / "client_configs"
-    
     if not config_dir.exists():
         print(f"❌ Config directory not found: {config_dir}")
         return
-    
     config_files = list(config_dir.glob("*.json"))
-    
     if not config_files:
         print(f"❌ No configuration files found in {config_dir}")
         return
-    
     print(f"Found {len(config_files)} configuration files:")
     for config_file in config_files:
         print(f"  - {config_file.name}")
-    
     print("\n" + "=" * 50)
-    
     for config_file in config_files:
         await demo_from_config_file(str(config_file))
         print("\n" + "-" * 50)
-
-
 async def demo_programmatic_config():
     """Demo client with programmatically created configuration."""
     print("🚀 Demo Programmatic Configuration")
     print("=" * 50)
-    
     # Create different configurations programmatically
     configs = [
         {
@@ -191,40 +156,31 @@ async def demo_programmatic_config():
             )
         }
     ]
-    
     for config_info in configs:
         print(f"\n📋 Testing: {config_info['name']}")
         print("-" * 30)
-        
         try:
             async with UniversalClient(config_info["config"]) as client:
                 success = await client.test_connection()
-                
                 if success:
                     print("✅ Connection successful!")
                     await demo_api_calls(client)
                 else:
                     print("❌ Connection failed")
-                    
         except Exception as e:
             print(f"❌ Test failed: {e}")
-
-
 async def interactive_demo():
     """Interactive demo with user input."""
     print("🚀 Interactive Client Demo")
     print("=" * 50)
-    
     print("Available authentication methods:")
     print("1. No authentication")
     print("2. API Key")
     print("3. JWT Token")
     print("4. Certificate")
     print("5. Basic Authentication")
-    
     try:
         choice = input("\nSelect authentication method (1-5): ").strip()
-        
         auth_methods = {
             "1": "none",
             "2": "api_key",
@@ -232,26 +188,20 @@ async def interactive_demo():
             "4": "certificate",
             "5": "basic"
         }
-        
         if choice not in auth_methods:
             print("❌ Invalid choice")
             return
-        
         auth_method = auth_methods[choice]
-        
         # Get server URL
         server_url = input("Enter server URL (default: http://localhost:8000): ").strip()
         if not server_url:
             server_url = "http://localhost:8000"
-        
         # Create configuration based on choice
         config_kwargs = {}
-        
         if auth_method == "api_key":
             api_key = input("Enter API key: ").strip()
             if api_key:
                 config_kwargs["api_key"] = api_key
-        
         elif auth_method == "jwt":
             username = input("Enter username: ").strip()
             password = input("Enter password: ").strip()
@@ -262,7 +212,6 @@ async def interactive_demo():
                     "password": password,
                     "secret": secret
                 })
-        
         elif auth_method == "certificate":
             cert_file = input("Enter certificate file path: ").strip()
             key_file = input("Enter key file path: ").strip()
@@ -273,7 +222,6 @@ async def interactive_demo():
                     "key_file": key_file,
                     "ca_cert_file": ca_cert_file
                 })
-        
         elif auth_method == "basic":
             username = input("Enter username: ").strip()
             password = input("Enter password: ").strip()
@@ -282,50 +230,38 @@ async def interactive_demo():
                     "username": username,
                     "password": password
                 })
-        
         # Create configuration
         config = create_client_config(server_url, auth_method, **config_kwargs)
-        
         print(f"\nConfiguration created for {auth_method} authentication")
         print(f"Server URL: {server_url}")
-        
         # Test connection
         async with UniversalClient(config) as client:
             success = await client.test_connection()
-            
             if success:
                 print("✅ Connection successful!")
                 await demo_api_calls(client)
             else:
                 print("❌ Connection failed")
-                
     except KeyboardInterrupt:
         print("\n\nDemo interrupted by user")
     except Exception as e:
         print(f"❌ Interactive demo failed: {e}")
-
-
 def main():
     """Main demo function."""
     if len(sys.argv) > 1:
         command = sys.argv[1]
-        
         if command == "config":
             if len(sys.argv) > 2:
                 config_file = sys.argv[2]
                 asyncio.run(demo_from_config_file(config_file))
             else:
                 print("Usage: python demo_client.py config <config_file>")
-        
         elif command == "all":
             asyncio.run(demo_all_configs())
-        
         elif command == "programmatic":
             asyncio.run(demo_programmatic_config())
-        
         elif command == "interactive":
             asyncio.run(interactive_demo())
-        
         else:
             print("Unknown command. Available commands:")
             print("  config <file>     - Demo with config file")
@@ -335,7 +271,5 @@ def main():
     else:
         # Default: demo all configs
         asyncio.run(demo_all_configs())
-
-
 if __name__ == "__main__":
     main()

mcp_proxy_adapter/examples/full_application/__init__.py

@@ -0,0 +1,11 @@
+"""Full Application Example.
+
+This example demonstrates advanced usage of MCP Proxy Adapter including:
+- Proxy registration endpoints
+- Custom command hooks
+- Advanced security configurations
+- Role-based access control
+"""
+
+from .main import app
+from .proxy_endpoints import router as proxy_router

mcp_proxy_adapter/examples/full_application/commands/__init__.py

@@ -0,0 +1,7 @@
+"""Full Application Commands.
+
+Custom command implementations for the full application example.
+"""
+
+from .custom_echo_command import CustomEchoCommand
+from .dynamic_calculator_command import DynamicCalculatorCommand

mcp_proxy_adapter/examples/full_application/commands/custom_echo_command.py

@@ -1,25 +1,18 @@
 """
 Custom Echo Command
-
 This module demonstrates a custom command implementation for the full application example.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
-
-
 class CustomEchoResult(CommandResult):
     """Result class for custom echo command."""
-    
     def __init__(self, message: str, timestamp: str, echo_count: int):
         self.message = message
         self.timestamp = timestamp
         self.echo_count = echo_count
-    
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary."""
         return {
@@ -28,7 +21,6 @@ class CustomEchoResult(CommandResult):
             "echo_count": self.echo_count,
             "command_type": "custom_echo"
         }
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get result schema."""
         return {
@@ -41,23 +33,17 @@ class CustomEchoResult(CommandResult):
             },
             "required": ["message", "timestamp", "echo_count", "command_type"]
         }
-
-
 class CustomEchoCommand(BaseCommand):
     """Custom echo command implementation."""
-    
     def __init__(self):
         super().__init__()
         self.echo_count = 0
-    
     def get_name(self) -> str:
         """Get command name."""
         return "custom_echo"
-    
     def get_description(self) -> str:
         """Get command description."""
         return "Custom echo command with enhanced features"
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get command schema."""
         return {
@@ -78,20 +64,15 @@ class CustomEchoCommand(BaseCommand):
             },
             "required": ["message"]
         }
-    
     async def execute(self, params: Dict[str, Any]) -> CustomEchoResult:
         """Execute the custom echo command."""
         message = params.get("message", "Hello from custom echo!")
         repeat = min(max(params.get("repeat", 1), 1), 10)
-        
         self.echo_count += 1
-        
         from datetime import datetime
         timestamp = datetime.now().isoformat()
-        
         # Repeat the message
         echoed_message = " ".join([message] * repeat)
-        
         return CustomEchoResult(
             message=echoed_message,
             timestamp=timestamp,

mcp_proxy_adapter/examples/full_application/commands/dynamic_calculator_command.py

@@ -1,25 +1,18 @@
 """
 Dynamic Calculator Command
-
 This module demonstrates a dynamically loaded command implementation for the full application example.
-
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
-
 from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import BaseCommand
 from mcp_proxy_adapter.commands.result import CommandResult
-
-
 class CalculatorResult(CommandResult):
     """Result class for calculator command."""
-    
     def __init__(self, operation: str, result: float, expression: str):
         self.operation = operation
         self.result = result
         self.expression = expression
-    
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary."""
         return {
@@ -28,7 +21,6 @@ class CalculatorResult(CommandResult):
             "expression": self.expression,
             "command_type": "dynamic_calculator"
         }
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get result schema."""
         return {
@@ -41,19 +33,14 @@ class CalculatorResult(CommandResult):
             },
             "required": ["operation", "result", "expression", "command_type"]
         }
-
-
 class DynamicCalculatorCommand(BaseCommand):
     """Dynamic calculator command implementation."""
-    
     def get_name(self) -> str:
         """Get command name."""
         return "dynamic_calculator"
-    
     def get_description(self) -> str:
         """Get command description."""
         return "Dynamic calculator with basic mathematical operations"
-    
     def get_schema(self) -> Dict[str, Any]:
         """Get command schema."""
         return {
@@ -75,13 +62,11 @@ class DynamicCalculatorCommand(BaseCommand):
             },
             "required": ["operation", "a", "b"]
         }
-    
     async def execute(self, params: Dict[str, Any]) -> CalculatorResult:
         """Execute the calculator command."""
         operation = params.get("operation")
         a = params.get("a")
         b = params.get("b")
-        
         if operation == "add":
             result = a + b
             expression = f"{a} + {b}"
@@ -98,7 +83,6 @@ class DynamicCalculatorCommand(BaseCommand):
             expression = f"{a} / {b}"
         else:
             raise ValueError(f"Unknown operation: {operation}")
-        
         return CalculatorResult(
             operation=operation,
             result=result,

mcp_proxy_adapter/examples/full_application/hooks/__init__.py

@@ -0,0 +1,7 @@
+"""Full Application Hooks.
+
+Application and command hooks for the full application example.
+"""
+
+from .application_hooks import ApplicationHooks
+from .builtin_command_hooks import BuiltinCommandHooks