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

mcp_proxy_adapter/client/jsonrpc_client/proxy_api.py

@@ -0,0 +1,224 @@
+"""Proxy registration helpers for JsonRpcClient.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
+
+import httpx
+
+from mcp_proxy_adapter.client.jsonrpc_client.transport import JsonRpcTransport
+
+
+class ProxyApiMixin(JsonRpcTransport):
+    """Mixin providing proxy registration helpers."""
+
+    async def register_with_proxy(
+        self,
+        proxy_url: str,
+        server_name: str,
+        server_url: str,
+        capabilities: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        cert: Optional[Tuple[str, str]] = None,
+        verify: Optional[Union[bool, str]] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "server_id": server_name,
+            "server_url": server_url,
+            "capabilities": capabilities or [],
+            "metadata": metadata or {},
+        }
+
+        ssl_verify = verify if verify is not None else self.verify
+        ssl_cert = cert if cert is not None else self.cert
+
+        proxy_base = proxy_url.rstrip("/")
+        register_url = (
+            proxy_base if proxy_base.endswith("/register") else f"{proxy_base}/register"
+        )
+
+        logger = logging.getLogger(__name__)
+        logger.debug(
+            "Registering with proxy: %s, cert=%s, verify=%s",
+            register_url,
+            ssl_cert is not None,
+            ssl_verify,
+        )
+
+        try:
+            async with httpx.AsyncClient(
+                verify=ssl_verify, cert=ssl_cert, timeout=10.0
+            ) as client:
+                response = await client.post(register_url, json=payload)
+
+                if response.status_code == 400:
+                    error_data = cast(Dict[str, Any], response.json())
+                    error_msg = error_data.get("error", "").lower()
+                    if "already registered" in error_msg:
+                        await self._retry_registration_after_unregister(
+                            client,
+                            proxy_base,
+                            register_url,
+                            server_name,
+                            server_url,
+                            capabilities,
+                            metadata,
+                            error_data,
+                        )
+
+                if response.status_code >= 400:
+                    try:
+                        error_data = cast(Dict[str, Any], response.json())
+                        error_msg = error_data.get(
+                            "error",
+                            error_data.get("message", f"HTTP {response.status_code}"),
+                        )
+                        raise httpx.HTTPStatusError(
+                            f"Registration failed: {error_msg}",
+                            request=response.request,
+                            response=response,
+                        )
+                    except (ValueError, KeyError):
+                        response.raise_for_status()
+
+                response.raise_for_status()
+                return cast(Dict[str, Any], response.json())
+        except httpx.ConnectError as exc:  # noqa: BLE001
+            error_msg = f"Connection failed to {register_url}"
+            if hasattr(exc, "request"):
+                error_msg += f" (request: {exc.request.url})"
+            raise ConnectionError(error_msg) from exc
+        except httpx.TimeoutException as exc:  # noqa: BLE001
+            raise TimeoutError(f"Request timeout to {register_url}") from exc
+        except httpx.HTTPError as exc:  # noqa: BLE001
+            raise ConnectionError(
+                f"HTTP error connecting to {register_url}: {exc}"
+            ) from exc
+
+    async def unregister_from_proxy(
+        self,
+        proxy_url: str,
+        server_name: str,
+        cert: Optional[Tuple[str, str]] = None,
+        verify: Optional[Union[bool, str]] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "server_id": server_name,
+            "server_url": "",
+            "capabilities": [],
+            "metadata": {},
+        }
+
+        ssl_verify = verify if verify is not None else self.verify
+        ssl_cert = cert if cert is not None else self.cert
+
+        proxy_base = proxy_url.rstrip("/")
+        unregister_url = (
+            proxy_base
+            if proxy_base.endswith("/unregister")
+            else f"{proxy_base}/unregister"
+        )
+
+        async with httpx.AsyncClient(
+            verify=ssl_verify, cert=ssl_cert, timeout=10.0
+        ) as client:
+            response = await client.post(unregister_url, json=payload)
+            response.raise_for_status()
+            return cast(Dict[str, Any], response.json())
+
+    async def heartbeat_to_proxy(
+        self,
+        proxy_url: str,
+        server_name: str,
+        server_url: str,
+        capabilities: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        cert: Optional[Tuple[str, str]] = None,
+        verify: Optional[Union[bool, str]] = None,
+    ) -> None:
+        payload: Dict[str, Any] = {
+            "server_id": server_name,
+            "server_url": server_url,
+            "capabilities": capabilities or [],
+            "metadata": metadata or {},
+        }
+
+        ssl_verify = verify if verify is not None else self.verify
+        ssl_cert = cert if cert is not None else self.cert
+
+        proxy_base = proxy_url.rstrip("/")
+        async with httpx.AsyncClient(
+            verify=ssl_verify, cert=ssl_cert, timeout=10.0
+        ) as client:
+            response = await client.post(
+                f"{proxy_base}/proxy/heartbeat",
+                json=payload,
+            )
+            response.raise_for_status()
+
+    async def list_proxy_servers(self, proxy_url: str) -> Dict[str, Any]:
+        proxy_base = proxy_url.rstrip("/")
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(f"{proxy_base}/proxy/list")
+            response.raise_for_status()
+            return cast(Dict[str, Any], response.json())
+
+    async def get_proxy_health(self, proxy_url: str) -> Dict[str, Any]:
+        proxy_base = proxy_url.rstrip("/")
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(f"{proxy_base}/proxy/health")
+            response.raise_for_status()
+            return cast(Dict[str, Any], response.json())
+
+    async def _retry_registration_after_unregister(
+        self,
+        client: httpx.AsyncClient,
+        proxy_base: str,
+        register_url: str,
+        server_name: str,
+        server_url: str,
+        capabilities: Optional[List[str]],
+        metadata: Optional[Dict[str, Any]],
+        error_data: Dict[str, Any],
+    ) -> None:
+        match = re.search(
+            r"already registered as ([^\s,]+)",
+            error_data.get("error", ""),
+            re.IGNORECASE,
+        )
+        if not match:
+            return
+
+        registered_server_key = match.group(1)
+        original_server_id = (
+            re.sub(r"_\d+$", "", registered_server_key)
+            if "_" in registered_server_key
+            else registered_server_key
+        )
+
+        unregister_payload: Dict[str, Any] = {
+            "server_id": original_server_id,
+            "server_url": "",
+            "capabilities": [],
+            "metadata": {},
+        }
+        unregister_response = await client.post(
+            f"{proxy_base}/unregister",
+            json=unregister_payload,
+        )
+        if unregister_response.status_code != 200:
+            return
+
+        retry_payload: Dict[str, Any] = {
+            "server_id": server_name,
+            "server_url": server_url,
+            "capabilities": capabilities or [],
+            "metadata": metadata or {},
+        }
+        await client.post(register_url, json=retry_payload)

mcp_proxy_adapter/client/jsonrpc_client/queue_api.py

@@ -0,0 +1,60 @@
+"""Queue management 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 QueueApiMixin(JsonRpcTransport):
+    """Mixin with queue-related JSON-RPC shortcuts."""
+
+    async def queue_health(self) -> Dict[str, Any]:
+        response = await self.jsonrpc_call("queue_health", {})
+        return self._extract_result(response)
+
+    async def queue_add_job(
+        self,
+        job_type: str,
+        job_id: str,
+        params: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        payload = {"job_type": job_type, "job_id": job_id, "params": params}
+        response = await self.jsonrpc_call("queue_add_job", payload)
+        return self._extract_result(response)
+
+    async def queue_start_job(self, job_id: str) -> Dict[str, Any]:
+        response = await self.jsonrpc_call("queue_start_job", {"job_id": job_id})
+        return self._extract_result(response)
+
+    async def queue_stop_job(self, job_id: str) -> Dict[str, Any]:
+        response = await self.jsonrpc_call("queue_stop_job", {"job_id": job_id})
+        return self._extract_result(response)
+
+    async def queue_delete_job(self, job_id: str) -> Dict[str, Any]:
+        response = await self.jsonrpc_call("queue_delete_job", {"job_id": job_id})
+        return self._extract_result(response)
+
+    async def queue_get_job_status(self, job_id: str) -> Dict[str, Any]:
+        response = await self.jsonrpc_call(
+            "queue_get_job_status", {"job_id": job_id}
+        )
+        return self._extract_result(response)
+
+    async def queue_list_jobs(
+        self,
+        status: Optional[str] = None,
+        job_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if status:
+            params["status"] = status
+        if job_type:
+            params["job_type"] = job_type
+        response = await self.jsonrpc_call("queue_list_jobs", params)
+        return self._extract_result(response)

mcp_proxy_adapter/client/jsonrpc_client/transport.py

@@ -0,0 +1,108 @@
+"""Transport utilities for asynchronous JSON-RPC client.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple, Union, cast
+
+import httpx
+
+
+class JsonRpcTransport:
+    """Base transport class providing HTTP primitives."""
+
+    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:
+        scheme = "https" if protocol in ("https", "mtls") else "http"
+        self.base_url = f"{scheme}://{host}:{port}"
+
+        self.headers: Dict[str, str] = {"Content-Type": "application/json"}
+        if token_header and token:
+            self.headers[token_header] = token
+
+        self.verify: Union[bool, str] = True
+        self.cert: Optional[Tuple[str, str]] = None
+
+        if protocol in ("https", "mtls"):
+            if cert and key:
+                self.cert = (str(Path(cert)), str(Path(key)))
+            if ca:
+                self.verify = str(Path(ca))
+            else:
+                self.verify = False
+
+        self.timeout = 30.0
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Return cached async HTTP client or create it lazily."""
+
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                verify=self.verify,
+                cert=self.cert,
+                timeout=self.timeout,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        """Close underlying HTTPX client."""
+
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def health(self) -> Dict[str, Any]:
+        """Fetch health information from service."""
+
+        client = await self._get_client()
+        response = await client.get(f"{self.base_url}/health", headers=self.headers)
+        response.raise_for_status()
+        return cast(Dict[str, Any], response.json())
+
+    async def jsonrpc_call(
+        self,
+        method: str,
+        params: Dict[str, Any],
+        req_id: int = 1,
+    ) -> Dict[str, Any]:
+        """Perform JSON-RPC request and return raw response payload."""
+
+        payload: Dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params,
+            "id": req_id,
+        }
+        client = await self._get_client()
+        response = await client.post(
+            f"{self.base_url}/api/jsonrpc",
+            json=payload,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return cast(Dict[str, Any], response.json())
+
+    def _extract_result(self, response: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract ``result`` part from JSON-RPC reply raising on error."""
+
+        if "error" in response:
+            error = response["error"]
+            message = error.get("message", "Unknown error")
+            code = error.get("code", -1)
+            raise RuntimeError(f"JSON-RPC error: {message} (code: {code})")
+        result_data = response.get("result", {})
+        return cast(Dict[str, Any], result_data)

mcp_proxy_adapter/client/proxy.py

@@ -0,0 +1,123 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Lightweight asynchronous client library for registry (proxy) server used in examples.
+"""
+
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+
+class ProxyClient:
+    """Asynchronous client for proxy server."""
+
+    def __init__(self, base_url: str):
+        """
+        Initialize proxy client.
+
+        Args:
+            base_url: Base URL of the proxy server
+        """
+        self.base_url = base_url.rstrip("/")
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create async HTTP client."""
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=5.0)
+        return self._client
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def health(self) -> Dict[str, Any]:
+        """
+        Get proxy server health status.
+
+        Returns:
+            Health status information
+        """
+        client = await self._get_client()
+        r = await client.get(f"{self.base_url}/proxy/health")
+        r.raise_for_status()
+        return r.json()  # type: ignore[no-any-return]
+
+    async def register(
+        self,
+        name: str,
+        url: str,
+        capabilities: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Register a server with the proxy.
+
+        Args:
+            name: Server name
+            url: Server URL
+            capabilities: Optional list of capabilities
+            metadata: Optional metadata dictionary
+
+        Returns:
+            Registration result
+        """
+        payload = {
+            "name": name,
+            "url": url,
+            "capabilities": capabilities or [],
+            "metadata": metadata or {},
+        }
+        client = await self._get_client()
+        r = await client.post(f"{self.base_url}/register", json=payload)
+        r.raise_for_status()
+        return r.json()  # type: ignore[no-any-return]
+
+    async def unregister(self, name: str) -> Dict[str, Any]:
+        """
+        Unregister a server from the proxy.
+
+        Args:
+            name: Server name
+
+        Returns:
+            Unregistration result
+        """
+        payload = {"name": name, "url": "", "capabilities": [], "metadata": {}}
+        client = await self._get_client()
+        r = await client.post(f"{self.base_url}/unregister", json=payload)
+        r.raise_for_status()
+        return r.json()  # type: ignore[no-any-return]
+
+    async def list_servers(self) -> Dict[str, Any]:
+        """
+        List all servers registered with the proxy.
+
+        Returns:
+            List of registered servers
+        """
+        client = await self._get_client()
+        r = await client.get(f"{self.base_url}/proxy/list")
+        r.raise_for_status()
+        return r.json()  # type: ignore[no-any-return]
+
+    async def heartbeat(self, name: str, url: str) -> Dict[str, Any]:
+        """
+        Send heartbeat to the proxy.
+
+        Args:
+            name: Server name
+            url: Server URL
+
+        Returns:
+            Heartbeat result
+        """
+        payload = {"name": name, "url": url, "capabilities": [], "metadata": {}}
+        client = await self._get_client()
+        r = await client.post(f"{self.base_url}/proxy/heartbeat", json=payload)
+        r.raise_for_status()
+        return r.json()  # type: ignore[no-any-return]

mcp_proxy_adapter/commands/__init__.py

@@ -0,0 +1,66 @@
+"""
+Commands module initialization file.
+"""
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.command_registry import registry, CommandRegistry
+from mcp_proxy_adapter.commands.dependency_container import (
+    container,
+    DependencyContainer,
+)
+from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult, ErrorResult
+# from mcp_proxy_adapter.commands.auth_validation_command import AuthValidationCommand
+# from mcp_proxy_adapter.commands.ssl_setup_command import SSLSetupCommand
+# from mcp_proxy_adapter.commands.certificate_management_command import (
+#     CertificateManagementCommand,
+# )
+# from mcp_proxy_adapter.commands.key_management_command import KeyManagementCommand
+# from mcp_proxy_adapter.commands.cert_monitor_command import CertMonitorCommand
+# from mcp_proxy_adapter.commands.transport_management_command import (
+#     TransportManagementCommand,
+# )
+# from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
+# from mcp_proxy_adapter.commands.echo_command import EchoCommand
+# from mcp_proxy_adapter.commands.proxy_registration_command import (
+#     ProxyRegistrationCommand,
+# )
+# from mcp_proxy_adapter.commands.registration_status_command import (
+#     RegistrationStatusCommand,
+# )
+# from mcp_proxy_adapter.commands.queue_commands import (
+#     QueueAddJobCommand,
+#     QueueStartJobCommand,
+#     QueueStopJobCommand,
+#     QueueDeleteJobCommand,
+#     QueueGetJobStatusCommand,
+#     QueueListJobsCommand,
+#     QueueHealthCommand,
+# )
+
+__all__ = [
+    "Command",
+    "CommandResult",
+    "SuccessResult",
+    "ErrorResult",
+    "registry",
+    "CommandRegistry",
+    "container",
+    "DependencyContainer",
+    # "AuthValidationCommand",
+    # "SSLSetupCommand",
+    # "CertificateManagementCommand",
+    # "KeyManagementCommand",
+    # "CertMonitorCommand",
+    # "TransportManagementCommand",
+    # "RoleTestCommand",
+    # "EchoCommand",
+    # "ProxyRegistrationCommand",
+    # "RegistrationStatusCommand",
+    # "QueueAddJobCommand",
+    # "QueueStartJobCommand",
+    # "QueueStopJobCommand",
+    # "QueueDeleteJobCommand",
+    # "QueueGetJobStatusCommand",
+    # "QueueListJobsCommand",
+    # "QueueHealthCommand",
+]

mcp_proxy_adapter/commands/auth_validation_command.py

@@ -0,0 +1,69 @@
+"""
+Authentication Validation Commands
+
+This module provides commands for validating different types of authentication:
+- Universal authentication validation
+- Certificate validation
+- Token validation
+- mTLS validation
+- SSL validation
+
+Author: MCP Proxy Adapter Team
+Version: 1.0.0
+"""
+
+import logging
+from typing import Union, Dict, Any
+
+from ..commands.base import Command
+from ..commands.result import SuccessResult, ErrorResult
+
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+class AuthValidationCommand(Command):
+    """
+    Authentication validation commands.
+
+    Provides commands for validating different types of authentication
+    using the universal AuthValidator.
+    """
+
+    def __init__(self):
+        """Initialize authentication validation command."""
+        super().__init__()
+        self.validator = AuthValidator()
+        self.logger = logging.getLogger(__name__)
+
+
+
+
+
+
+    async def execute(self, **kwargs) -> Union[SuccessResult, ErrorResult]:
+        """
+        Execute authentication validation command.
+
+        This is a placeholder method to satisfy the abstract base class.
+        Individual validation methods should be called directly.
+
+        Args:
+            **kwargs: Command parameters
+
+        Returns:
+            Command result
+        """
+        return ErrorResult(
+            message="Method not found. Use specific validation methods instead.",
+            code=-32601,
+        )
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for auth validation command."""
+        return {
+            "type": "object",
+            "properties": {
+                "method": {"type": "string", "enum": ["validate_token", "validate_certificate", "validate_mtls"]},
+                "params": {"type": "object"}
+            }
+        }