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

mcp_proxy_adapter/examples/queue_server_example.py

@@ -0,0 +1,85 @@
+"""
+Queue Server Example for MCP Proxy Adapter.
+
+This example demonstrates how to run an MCP server with queue integration
+for managing background jobs.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+from hypercorn.asyncio import serve
+from hypercorn.config import Config as HyperConfig
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.queue_commands import (
+    QueueAddJobCommand,
+    QueueStartJobCommand,
+    QueueStopJobCommand,
+    QueueDeleteJobCommand,
+    QueueGetJobStatusCommand,
+    QueueListJobsCommand,
+    QueueHealthCommand,
+)
+from mcp_proxy_adapter.integrations.queuemgr_integration import (
+    init_global_queue_manager,
+    shutdown_global_queue_manager,
+)
+
+
+async def setup_queue_commands():
+    """Setup queue management commands."""
+    print("🔧 Setting up queue management commands...")
+    
+    # Register queue commands
+    registry.register(QueueAddJobCommand())
+    registry.register(QueueStartJobCommand())
+    registry.register(QueueStopJobCommand())
+    registry.register(QueueDeleteJobCommand())
+    registry.register(QueueGetJobStatusCommand())
+    registry.register(QueueListJobsCommand())
+    registry.register(QueueHealthCommand())
+    
+    print("✅ Queue commands registered")
+
+
+def create_queue_server_app() -> any:
+    """Create MCP server application with queue integration."""
+    app = create_app()
+    
+    @app.on_event("startup")
+    async def _on_startup() -> None:
+        await init_global_queue_manager()
+        await setup_queue_commands()
+    
+    @app.on_event("shutdown")
+    async def _on_shutdown() -> None:
+        await shutdown_global_queue_manager()
+    
+    return app
+
+
+async def main():
+    """Main function to run the queue server with Hypercorn."""
+    print("🚀 Starting MCP Proxy Adapter Queue Server")
+    print("=" * 50)
+    
+    app = create_queue_server_app()
+
+    hc = HyperConfig()
+    hc.bind = ["0.0.0.0:8000"]
+    hc.loglevel = "info"
+
+    print("✅ MCP Queue Server will start at http://localhost:8000")
+    print("📝 Example usage:")
+    print("  curl -X POST http://localhost:8000/api/jsonrpc \\")
+    print("    -H 'Content-Type: application/json' \\")
+    print("    -d '{\"jsonrpc\": \"2.0\", \"method\": \"queue_health\", \"params\": {}, \"id\": 1}'")
+    print()
+
+    await serve(app, hc)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_proxy_adapter/examples/queue_server_simple.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+Simple Queue Server for MCP Proxy Adapter.
+
+This example demonstrates how to run an MCP server with queue integration
+using a minimal configuration.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import asyncio
+import uvicorn
+from mcp_proxy_adapter.api.app import create_app
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.queue_commands import (
+    QueueAddJobCommand,
+    QueueStartJobCommand,
+    QueueStopJobCommand,
+    QueueDeleteJobCommand,
+    QueueGetJobStatusCommand,
+    QueueListJobsCommand,
+    QueueHealthCommand,
+)
+
+
+def setup_queue_commands():
+    """Setup queue management commands."""
+    print("🔧 Setting up queue management commands...")
+    
+    # Register queue commands
+    registry.register_custom(QueueAddJobCommand())
+    registry.register_custom(QueueStartJobCommand())
+    registry.register_custom(QueueStopJobCommand())
+    registry.register_custom(QueueDeleteJobCommand())
+    registry.register_custom(QueueGetJobStatusCommand())
+    registry.register_custom(QueueListJobsCommand())
+    registry.register_custom(QueueHealthCommand())
+    
+    print("✅ Queue commands registered")
+
+
+def create_queue_server_app():
+    """Create MCP server application with queue integration."""
+    # Create minimal config
+    config = {
+        "uuid": "123e4567-e89b-42d3-8a56-426614174000",
+        "server": {
+            "host": "172.28.0.1",
+            "port": 8000,
+            "protocol": "http",
+            "debug": False,
+            "log_level": "INFO"
+        },
+        "logging": {
+            "level": "INFO",
+            "file": None,
+            "log_dir": "./logs",
+            "log_file": "mcp_proxy_adapter.log",
+            "error_log_file": "mcp_proxy_adapter_error.log",
+            "access_log_file": "mcp_proxy_adapter_access.log",
+            "max_file_size": "10MB",
+            "backup_count": 5,
+            "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "date_format": "%Y-%m-%d %H:%M:%S",
+            "console_output": True,
+            "file_output": True
+        },
+        "commands": {
+            "auto_discovery": True,
+            "commands_directory": "./commands",
+            "catalog_directory": "./catalog",
+            "plugin_servers": [],
+            "auto_install_dependencies": True,
+            "enabled_commands": ["health", "echo", "list", "help"],
+            "disabled_commands": [],
+            "custom_commands_path": "./commands"
+        },
+        "transport": {
+            "type": "http",
+            "port": 8000
+        },
+        "ssl": {
+            "enabled": False
+        },
+        "proxy_registration": {
+            "enabled": True,
+            "proxy_url": "https://172.28.0.4:3004",
+            "server_id": "mcp_queue_server",
+            "server_name": "MCP Queue Server",
+            "description": "Queue management server with mTLS",
+            "version": "6.9.28",
+            "protocol": "mtls",
+            "ssl": {
+                "enabled": True,
+                "verify_ssl": False,
+                "verify_hostname": False,
+                "verify_mode": "CERT_REQUIRED",
+                "ca_cert": "./mtls_certificates/ca/ca.crt",
+                "cert_file": "./mtls_certificates/client/test-client.crt",
+                "key_file": "./mtls_certificates/client/test-client.key"
+            },
+            "certificate": {
+                "cert_file": "./mtls_certificates/client/test-client.crt",
+                "key_file": "./mtls_certificates/client/test-client.key"
+            },
+            "registration_timeout": 30,
+            "retry_attempts": 3,
+            "retry_delay": 5,
+            "auto_register_on_startup": True,
+            "auto_unregister_on_shutdown": True,
+            "heartbeat": {
+                "enabled": True,
+                "interval": 30,
+                "timeout": 10,
+                "retry_attempts": 3,
+                "retry_delay": 5,
+                "url": "/heartbeat"
+            }
+        },
+        "debug": {
+            "enabled": False,
+            "level": "WARNING"
+        },
+        "security": {
+            "enabled": False
+        },
+        "roles": {
+            "enabled": False
+        }
+    }
+    
+    # Register commands before creating the app
+    setup_queue_commands()
+    
+    app = create_app(app_config=config)
+    
+    @app.on_event("startup")
+    
+    @app.on_event("shutdown")
+    
+    return app
+
+
+async def main():
+    """Main function to run the queue server."""
+    print("🚀 Starting MCP Proxy Adapter Queue Server")
+    print("=" * 50)
+    
+    # Create the app
+    app = create_queue_server_app()
+    
+    # Run the server
+    config = uvicorn.Config(
+        app=app,
+        host="0.0.0.0",
+        port=8000,
+        log_level="info"
+    )
+    server = uvicorn.Server(config)
+    
+    print("✅ MCP Queue Server started at http://localhost:8000")
+    print("📝 Example usage:")
+    print("  curl -X POST http://localhost:8000/api/jsonrpc \\")
+    print("    -H 'Content-Type: application/json' \\")
+    print("    -d '{\"jsonrpc\": \"2.0\", \"method\": \"queue_health\", \"params\": {}, \"id\": 1}'")
+    print()
+    
+    await server.serve()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_proxy_adapter/examples/required_certificates.py

@@ -7,8 +7,6 @@ Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
 
-from typing import Dict, List, Any
-from pathlib import Path
 
 # Base paths
 CERTS_DIR = Path("certs")

mcp_proxy_adapter/examples/run_full_test_suite.py

@@ -444,35 +444,6 @@ class FullTestSuiteRunner:
         # Process cleanup is handled by the test scripts themselves
         print("✅ Cleanup completed")
 
-    def cleanup_directories(self) -> bool:
-        """Clean up existing test directories before starting."""
-        self.print_info("Cleaning up existing test directories...")
-
-        try:
-            import shutil
-
-            # Directories to clean
-            dirs_to_clean = [self.configs_dir, self.certs_dir, self.keys_dir]
-            files_to_clean = [self.working_dir / "roles.json"]
-
-            # Remove directories
-            for dir_path in dirs_to_clean:
-                if dir_path.exists():
-                    shutil.rmtree(dir_path)
-                    print(f"🗑️  Removed directory: {dir_path}")
-
-            # Remove files
-            for file_path in files_to_clean:
-                if file_path.exists():
-                    file_path.unlink()
-                    print(f"🗑️  Removed file: {file_path}")
-
-            self.print_success("Directory cleanup completed")
-            return True
-
-        except Exception as e:
-            self.print_error(f"Failed to cleanup directories: {e}")
-            return False
 
     def test_all_configurations(self) -> bool:
         """Test all server configurations including proxy registration."""

mcp_proxy_adapter/examples/run_proxy_server.py

@@ -14,13 +14,9 @@ import asyncio
 import signal
 import sys
 from typing import Dict, List, Optional
-import json
-from datetime import datetime, timedelta
 
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-from mcp_proxy_adapter.core.server_adapter import UnifiedServerRunner
-
 
 # Simple in-memory storage for registered adapters
 registered_adapters: Dict[str, Dict] = {}
@@ -42,68 +38,33 @@ class ProxyRouter:
 
     def _setup_routes(self):
         @self.app.post("/register")
-        async def register_adapter(registration_data: dict):
-            """Register an adapter with the proxy."""
-            # Handle adapter format: server_id, server_url, server_name
-            adapter_id = registration_data["server_id"]
-            name = registration_data.get("server_name", adapter_id)
-            url = registration_data["server_url"]
-            capabilities = registration_data.get("capabilities", [])
-            metadata = {
-                "description": registration_data.get("description", ""),
-                "version": registration_data.get("version", ""),
-                "endpoints": registration_data.get("endpoints", {})
-            }
-            
-            registered_adapters[adapter_id] = {
-                "name": name,
-                "url": url,
-                "capabilities": capabilities,
-                "metadata": metadata,
-                "registered_at": datetime.now().isoformat(),
-                "last_heartbeat": datetime.now().isoformat(),
-                "status": "active",
-            }
-            print(f"✅ Registered adapter: {adapter_id} at {url}")
-            return {"status": "registered", "adapter_id": adapter_id, "success": True}
+        def register(adapter: AdapterRegistration):  # type: ignore[name-defined]
+            registered_adapters[adapter.name] = adapter.dict()
+            return {"status": "ok", "registered": adapter.name}
 
         @self.app.post("/unregister")
-        async def unregister_adapter(adapter_id: str):
-            """Unregister an adapter from the proxy."""
-            if adapter_id in registered_adapters:
-                del registered_adapters[adapter_id]
-                print(f"✅ Unregistered adapter: {adapter_id}")
-                return {"status": "unregistered", "adapter_id": adapter_id}
-            else:
-                raise HTTPException(status_code=404, detail="Adapter not found")
+        def unregister(adapter: AdapterRegistration):  # type: ignore[name-defined]
+            registered_adapters.pop(adapter.name, None)
+            return {"status": "ok", "unregistered": adapter.name}
+
+        @self.app.post("/proxy/heartbeat")
+        def heartbeat(adapter: AdapterRegistration):  # type: ignore[name-defined]
+            if adapter.name in registered_adapters:
+                return {"status": "ok", "heartbeat": adapter.name}
+            raise HTTPException(status_code=404, detail="Adapter not registered")
 
         @self.app.get("/proxy/list")
-        async def list_adapters():
-            """List all registered adapters."""
-            return {
-                "adapters": list(registered_adapters.values()),
-                "count": len(registered_adapters),
-            }
+        def list_registered():
+            return {"servers": list(registered_adapters.values())}
 
         @self.app.get("/proxy/health")
-        async def health_check():
-            """Health check endpoint."""
-            return {
-                "status": "healthy",
-                "timestamp": datetime.now().isoformat(),
-                "adapters_count": len(registered_adapters),
-            }
+        def proxy_health():
+            return {"status": "ok", "model": "mcp-local-proxy", "version": "1.0.0"}
 
-        @self.app.post("/proxy/heartbeat")
-        async def heartbeat(adapter_id: str):
-            """Receive heartbeat from adapter."""
-            if adapter_id in registered_adapters:
-                registered_adapters[adapter_id][
-                    "last_heartbeat"
-                ] = datetime.now().isoformat()
-                return {"status": "ok", "adapter_id": adapter_id}
-            else:
-                raise HTTPException(status_code=404, detail="Adapter not found")
+        # Compatibility endpoint expected by test instructions
+        @self.app.get("/servers")
+        def servers_plain():
+            return list(registered_adapters.values())
 
 
 def create_proxy_app() -> FastAPI:
@@ -135,8 +96,8 @@ def main() -> None:
     app = create_proxy_app()
 
     # Setup graceful shutdown
-    def signal_handler(signum, frame):
-        print("\n🛑 Shutting down proxy server...")
+    def signal_handler(signum, frame):  # type: ignore[no-redef]
+        print("\n🛑 Proxy server stopping...")
         sys.exit(0)
 
     signal.signal(signal.SIGINT, signal_handler)
@@ -153,16 +114,15 @@ def main() -> None:
     print("   POST /proxy/heartbeat   - Heartbeat from adapter")
     print("⚡ Press Ctrl+C to stop\n")
 
-    # Run server via unified runner (hypercorn under the hood)
-    runner = UnifiedServerRunner()
-    runner.run_server(
-        app,
-        {
-            "host": args.host,
-            "port": args.port,
-            "log_level": args.log_level,
-        },
-    )
+    # Run server with Hypercorn
+    from hypercorn.asyncio import serve
+    from hypercorn.config import Config
+
+    config = Config()
+    config.bind = [f"{args.host}:{args.port}"]
+    config.loglevel = args.log_level
+
+    asyncio.run(serve(app, config))
 
 
 if __name__ == "__main__":

mcp_proxy_adapter/examples/run_security_tests_fixed.py

@@ -9,12 +9,10 @@ email: vasilyvz@gmail.com
 import asyncio
 import json
 import os
-import signal
 import subprocess
 import sys
 import time
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
 
 # Add project root to path
 project_root = Path(__file__).parent.parent.parent
@@ -404,31 +402,6 @@ class SecurityTestRunner:
         
         return passed_tests == total_tests
 
-    def print_summary(self):
-        """Print test summary."""
-        if not self.test_results:
-            print("📊 No test results to display")
-            return
-            
-        total_tests = len(self.test_results)
-        passed_tests = sum(1 for result in self.test_results if result.success)
-        
-        print("\n" + "=" * 50)
-        print("📊 TEST SUMMARY")
-        print("=" * 50)
-        print(f"Total tests: {total_tests}")
-        print(f"Passed: {passed_tests}")
-        print(f"Failed: {total_tests - passed_tests}")
-        print(f"Success rate: {(passed_tests/total_tests)*100:.1f}%")
-        
-        if total_tests - passed_tests > 0:
-            print(f"\n📋 DETAILED RESULTS")
-            print("-" * 30)
-            for result in self.test_results:
-                status = "✅ PASS" if result.success else "❌ FAIL"
-                print(f"{status} {result.test_name}")
-                if not result.success and result.error_message:
-                    print(f"   Error: {result.error_message}")
 
 
 async def main():

mcp_proxy_adapter/examples/security_test/__init__.py

@@ -0,0 +1,18 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Security test package for MCP Proxy Adapter.
+"""
+
+from .test_result import TestResult
+from .ssl_context_manager import SSLContextManager
+from .auth_manager import AuthManager
+from .test_client import SecurityTestClient
+
+__all__ = [
+    "TestResult",
+    "SSLContextManager", 
+    "AuthManager",
+    "SecurityTestClient",
+]

mcp_proxy_adapter/examples/security_test/auth_manager.py

@@ -0,0 +1,14 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Authentication manager for security testing.
+"""
+
+import base64
+from typing import Dict
+
+
+class AuthManager:
+    """Manager for authentication in security testing."""
+

mcp_proxy_adapter/examples/security_test/ssl_context_manager.py

@@ -0,0 +1,28 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+SSL context manager for security testing.
+"""
+
+import os
+import ssl
+from pathlib import Path
+from typing import Optional
+
+
+class SSLContextManager:
+    """Manager for SSL contexts in security testing."""
+
+    def __init__(self, project_root: Optional[Path] = None):
+        """
+        Initialize SSL context manager.
+
+        Args:
+            project_root: Root directory of the project (optional)
+        """
+        if project_root is None:
+            project_root = Path(__file__).parent.parent.parent.parent
+        self.project_root = project_root
+
+