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

mcp_proxy_adapter/api/handlers.py

@@ -1,27 +1,29 @@
 """
-Module with API request handlers.
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+HTTP handlers for the MCP Proxy Adapter API.
+Provides JSON-RPC handling and health/commands endpoints.
 """
 
+from __future__ import annotations
+
 import asyncio
-import json
 import time
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
-from fastapi import HTTPException, Request
-from fastapi.responses import JSONResponse
+from fastapi import Request
 
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.core.errors import (
     MicroserviceError,
     NotFoundError,
-    ParseError,
     InvalidRequestError,
     MethodNotFoundError,
     InvalidParamsError,
     InternalError,
-    CommandError,
 )
-from mcp_proxy_adapter.core.logging import get_global_logger, RequestLogger, get_logger
+from mcp_proxy_adapter.core.logging import get_global_logger, RequestLogger
 
 
 async def execute_command(
@@ -30,113 +32,64 @@ async def execute_command(
     request_id: Optional[str] = None,
     request: Optional[Request] = None,
 ) -> Dict[str, Any]:
-    """
-    Executes a command with the specified name and parameters.
+    """Execute a registered command by name with parameters.
 
-    Args:
-        command_name: Command name.
-        params: Command parameters.
-        request_id: Optional request identifier for logging context.
-
-    Returns:
-        Command execution result.
-
-    Raises:
-        MethodNotFoundError: If command is not found.
-        MicroserviceError: In case of command execution error.
+    Raises MethodNotFoundError if command is not found.
+    Wraps unexpected exceptions into InternalError.
     """
-    # Create request get_global_logger() if request_id is provided
-    log = RequestLogger(__name__, request_id) if request_id else get_global_logger()
+    logger = RequestLogger(__name__, request_id) if request_id else get_global_logger()
 
     try:
-        log.info(f"Executing command: {command_name}")
+        logger.info(f"Executing command: {command_name}")
 
-        # Execute before command hooks
+        # Resolve command
         try:
-            from mcp_proxy_adapter.commands.hooks import hooks
-
-            hooks.execute_before_command_hooks(command_name, params)
-            log.debug(f"Executed before command hooks for: {command_name}")
-        except Exception as e:
-            log.warning(f"Failed to execute before command hooks: {e}")
-
-        # Get command class from registry and execute with parameters
-        start_time = time.time()
-
-        # Use Command.run that handles instances with dependencies properly
-        command_class = registry.get_command(command_name)
-
-        # Create context with user info from request state
-        context = {}
-        if request and hasattr(request.state, "user_id"):
-            context["user"] = {
-                "id": getattr(request.state, "user_id", None),
-                "role": getattr(request.state, "user_role", "guest"),
-                "roles": getattr(request.state, "user_roles", ["guest"]),
-                "permissions": getattr(request.state, "user_permissions", ["read"]),
-            }
-
-        # Add timeout to prevent hanging commands
+            command_class = registry.get_command(command_name)
+        except Exception:
+            raise MethodNotFoundError(f"Method not found: {command_name}")
+
+        # Build context (user info if middleware set state)
+        context: Dict[str, Any] = {}
+        if request is not None and hasattr(request, "state"):
+            user_id = getattr(request.state, "user_id", None)
+            user_role = getattr(request.state, "user_role", None)
+            user_roles = getattr(request.state, "user_roles", None)
+            if user_id or user_role or user_roles:
+                context["user"] = {
+                    "id": user_id,
+                    "role": user_role,
+                    "roles": user_roles or [],
+                }
+
+        # Execute with timeout
+        started_at = time.time()
         try:
-            result = await asyncio.wait_for(
-                command_class.run(**params, context=context),
-                timeout=10.0  # 10 seconds timeout
+            result_obj = await asyncio.wait_for(
+                command_class.run(**params, context=context), timeout=30.0
             )
         except asyncio.TimeoutError:
-            execution_time = time.time() - start_time
-            log.error(f"⏰ Command '{command_name}' timed out after {execution_time:.3f} sec")
-            raise InternalError(f"Command execution timed out after 10 seconds")
+            elapsed = time.time() - started_at
+            raise InternalError(f"Command timed out after {elapsed:.2f}s")
 
-        execution_time = time.time() - start_time
+        elapsed = time.time() - started_at
+        logger.info(f"Command '{command_name}' executed in {elapsed:.3f}s")
+        return result_obj.to_dict()
 
-        log.info(f"Command '{command_name}' executed in {execution_time:.3f} sec")
-
-        # Execute after command hooks
-        try:
-            hooks.execute_after_command_hooks(command_name, params, result)
-            log.debug(f"Executed after command hooks for: {command_name}")
-        except Exception as e:
-            log.warning(f"Failed to execute after command hooks: {e}")
-
-        # Return result
-        return result.to_dict()
-    except NotFoundError as e:
-        log.error(f"Command not found: {command_name}")
-        # Преобразуем в MethodNotFoundError для соответствия JSON-RPC
-        raise MethodNotFoundError(f"Method not found: {command_name}")
-    except Exception as e:
-        log.exception(f"Error executing command '{command_name}': {e}")
-        if isinstance(e, MicroserviceError):
-            raise e
-        # Все остальные ошибки оборачиваем в InternalError
-        raise InternalError(
-            f"Error executing command: {str(e)}", data={"original_error": str(e)}
-        )
+    except MicroserviceError:
+        raise
+    except Exception as exc:
+        logger.exception(f"Unhandled error in command '{command_name}': {exc}")
+        raise InternalError("Internal error", data={"error": str(exc)})
 
 
 async def handle_batch_json_rpc(
     batch_requests: List[Dict[str, Any]], request: Optional[Request] = None
 ) -> List[Dict[str, Any]]:
-    """
-    Handles batch JSON-RPC requests.
-
-    Args:
-        batch_requests: List of JSON-RPC request data.
-        request: Original FastAPI request object.
-
-    Returns:
-        List of JSON-RPC responses.
-    """
-    responses = []
-
-    # Get request_id from request state if available
+    """Handle batch JSON-RPC requests."""
+    responses: List[Dict[str, Any]] = []
     request_id = getattr(request.state, "request_id", None) if request else None
-
-    for request_data in batch_requests:
-        # Process each request in the batch
-        response = await handle_json_rpc(request_data, request_id, request)
-        responses.append(response)
-
+    for item in batch_requests:
+        responses.append(await handle_json_rpc(item, request_id, request))
     return responses
 
 
@@ -145,120 +98,63 @@ async def handle_json_rpc(
     request_id: Optional[str] = None,
     request: Optional[Request] = None,
 ) -> Dict[str, Any]:
-    """
-    Handles JSON-RPC request with support for both standard JSON-RPC and simplified formats.
+    """Handle a single JSON-RPC request with strict 2.0 compatibility.
 
-    Args:
-        request_data: JSON-RPC request data.
-        request_id: Optional request identifier for logging context.
-
-    Returns:
-        JSON-RPC response.
+    Also supports simplified form: {"command": "echo", "params": {...}}.
     """
-    # Create request get_global_logger() if request_id is provided
-    log = RequestLogger(__name__, request_id) if request_id else get_global_logger()
+    logger = RequestLogger(__name__, request_id) if request_id else get_global_logger()
 
-    # Support both standard JSON-RPC and simplified formats
-    method = None
-    params = {}
-    json_rpc_id = None
+    method: Optional[str]
+    params: Dict[str, Any]
+    json_rpc_id: Any
 
-    # Check if it's a standard JSON-RPC request
     if "jsonrpc" in request_data:
-        # Standard JSON-RPC format
         if request_data.get("jsonrpc") != "2.0":
-            return _create_error_response(
-                InvalidRequestError("Invalid Request. Expected jsonrpc: 2.0"),
-                request_data.get("id"),
-            )
-        
+            return _error_response(InvalidRequestError("Invalid Request: jsonrpc must be '2.0'"), request_data.get("id"))
         method = request_data.get("method")
         params = request_data.get("params", {})
         json_rpc_id = request_data.get("id")
-        
         if not method:
-            return _create_error_response(
-                InvalidRequestError("Invalid Request. Method is required"), json_rpc_id
-            )
+            return _error_response(InvalidRequestError("Invalid Request: method is required"), json_rpc_id)
     else:
-        # Simplified format: {"command": "help"} or {"command": "echo", "params": {...}}
+        # Simplified
         method = request_data.get("command")
         params = request_data.get("params", {})
-        json_rpc_id = request_data.get("id", 1)  # Default ID for simplified format
-        
+        json_rpc_id = request_data.get("id", 1)
         if not method:
-            return _create_error_response(
-                InvalidRequestError("Invalid Request. Command is required"), json_rpc_id
-            )
-        
-        log.info(f"Using simplified format for command: {method}")
-
-    log.info(f"Executing JSON-RPC method: {method}")
+            return _error_response(InvalidRequestError("Invalid Request: command is required"), json_rpc_id)
 
     try:
-        # Execute command with detailed logging
-        log.info(f"🔍 Starting command execution: {method}")
-        log.debug(f"📋 Command params: {params}")
-        
         result = await execute_command(method, params, request_id, request)
-
-        log.info(f"✅ Command {method} completed successfully")
-        
-        # Form successful response
         return {"jsonrpc": "2.0", "result": result, "id": json_rpc_id}
-    except MicroserviceError as e:
-        # Method execution error
-        log.error(f"❌ Method execution error: {str(e)}")
-        log.error(f"📊 Error type: {type(e).__name__}")
-        return _create_error_response(e, json_rpc_id)
-    except Exception as e:
-        # Internal server error
-        log.exception(f"❌ Unhandled error in JSON-RPC handler: {e}")
-        log.error(f"📊 Exception type: {type(e).__name__}")
-        log.error(f"📊 Exception details: {repr(e)}")
-        return _create_error_response(
-            InternalError("Internal error", data={"error": str(e), "error_type": type(e).__name__}), json_rpc_id
-        )
+    except MicroserviceError as err:
+        return _error_response(err, json_rpc_id)
+    except Exception as exc:
+        logger.exception(f"Unhandled error in JSON-RPC handler: {exc}")
+        return _error_response(InternalError("Internal error", data={"error": str(exc)}), json_rpc_id)
 
 
-def _create_error_response(error: MicroserviceError, request_id: Any) -> Dict[str, Any]:
-    """
-    Creates JSON-RPC error response.
-
-    Args:
-        error: Error object.
-        request_id: Request ID from client.
-
-    Returns:
-        JSON-RPC error response dictionary.
-    """
+def _error_response(error: MicroserviceError, request_id: Any) -> Dict[str, Any]:
     return {"jsonrpc": "2.0", "error": error.to_dict(), "id": request_id}
 
 
 async def get_server_health() -> Dict[str, Any]:
-    """
-    Gets server health information.
-
-    Returns:
-        Dictionary with server health information.
-    """
+    """Return server health info."""
     import os
     import platform
     import sys
     import psutil
     from datetime import datetime
 
-    # Get process start time
     process = psutil.Process(os.getpid())
     start_time = datetime.fromtimestamp(process.create_time())
     uptime_seconds = (datetime.now() - start_time).total_seconds()
-
-    # Get system information
-    memory_info = process.memory_info()
+    mem = process.memory_info().rss / (1024 * 1024)
 
     return {
         "status": "ok",
-        "version": "1.0.0",  # Should be replaced with actual version
+        "model": "mcp-proxy-adapter",
+        "version": "1.0.0",
         "uptime": uptime_seconds,
         "components": {
             "system": {
@@ -268,7 +164,7 @@ async def get_server_health() -> Dict[str, Any]:
             },
             "process": {
                 "pid": os.getpid(),
-                "memory_usage_mb": memory_info.rss / (1024 * 1024),
+                "memory_usage_mb": mem,
                 "start_time": start_time.isoformat(),
             },
             "commands": {"registered_count": len(registry.get_all_commands())},
@@ -277,26 +173,9 @@ async def get_server_health() -> Dict[str, Any]:
 
 
 async def get_commands_list() -> Dict[str, Dict[str, Any]]:
-    """
-    Gets list of available commands.
-
-    Returns:
-        Dictionary with information about available commands.
-    """
-    result = {}
-
-    # Get all registered commands
-    all_commands = registry.get_all_commands()
-
-    for command_name, command_class in all_commands.items():
-        # Get schema information for the command
-        schema = command_class.get_schema()
-
-        # Add to result
-        result[command_name] = {
-            "name": command_name,
-            "schema": schema,
-            "description": schema.get("description", ""),
-        }
-
+    """Return list of registered commands with schemas."""
+    result: Dict[str, Dict[str, Any]] = {}
+    for name, cls in registry.get_all_commands().items():
+        schema = cls.get_schema()
+        result[name] = {"name": name, "schema": schema, "description": schema.get("description", "")}
     return result

mcp_proxy_adapter/api/middleware/__init__.py

@@ -8,9 +8,8 @@ from fastapi import FastAPI
 
 from mcp_proxy_adapter.core.logging import get_global_logger
 from mcp_proxy_adapter.config import config
-from .base import BaseMiddleware
 from .factory import MiddlewareFactory
-from .protocol_middleware import setup_protocol_middleware
+# from .protocol_middleware import setup_protocol_middleware
 
 # Export mcp_security_framework availability
 try:
@@ -20,45 +19,3 @@ except ImportError:
     mcp_security_framework = False
 
 
-def setup_middleware(app: FastAPI, app_config: Optional[Dict[str, Any]] = None) -> None:
-    """
-    Sets up middleware for application using the new middleware factory.
-
-    Args:
-        app: FastAPI application instance.
-        app_config: Application configuration dictionary (optional)
-    """
-    # Use provided configuration or fallback to global config
-    current_config = app_config if app_config is not None else config.get_all()
-
-    # Add protocol middleware FIRST (before other middleware)
-    setup_protocol_middleware(app, current_config)
-
-    # Create middleware factory
-    factory = MiddlewareFactory(app, current_config)
-
-    # Validate middleware configuration
-    if not factory.validate_middleware_config():
-        get_global_logger().error("Middleware configuration validation failed")
-        raise SystemExit(1)
-
-    get_global_logger().info("Using unified security middleware")
-    middleware_list = factory.create_all_middleware()
-
-    # Add middleware to application AFTER protocol middleware
-    for middleware in middleware_list:
-        # For ASGI middleware, we need to wrap the application
-        if hasattr(middleware, "dispatch"):
-            # This is a proper ASGI middleware
-            app.middleware("http")(middleware.dispatch)
-        else:
-            get_global_logger().warning(
-                f"Middleware {middleware.__class__.__name__} doesn't have dispatch method"
-            )
-
-    # Log middleware information
-    middleware_info = factory.get_middleware_info()
-    get_global_logger().info(f"Middleware setup completed:")
-    get_global_logger().info(f"  - Total middleware: {middleware_info['total_middleware']}")
-    get_global_logger().info(f"  - Types: {', '.join(middleware_info['middleware_types'])}")
-    get_global_logger().info(f"  - Security enabled: {middleware_info['security_enabled']}")

mcp_proxy_adapter/api/middleware/base.py

@@ -16,48 +16,6 @@ class BaseMiddleware(BaseHTTPMiddleware):
     Base class for all middleware.
     """
 
-    async def dispatch(
-        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
-    ) -> Response:
-        """
-        Method that will be overridden in child classes.
-
-        Args:
-            request: Request.
-            call_next: Next handler.
-
-        Returns:
-            Response.
-        """
-        middleware_name = self.__class__.__name__
-        get_global_logger().info(f"🔍 STEP 1: {middleware_name}.dispatch START - {request.method} {request.url.path}")
-        get_global_logger().info(f"🔍 STEP 1.1: {middleware_name} - Request headers: {dict(request.headers)}")
-        get_global_logger().info(f"🔍 STEP 1.2: {middleware_name} - Request URL: {request.url}")
-        get_global_logger().info(f"🔍 STEP 1.3: {middleware_name} - Request scope: {request.scope}")
-        
-        try:
-            # Process request before calling the main handler
-            get_global_logger().info(f"🔍 STEP 2: {middleware_name}.before_request START")
-            await self.before_request(request)
-            get_global_logger().info(f"🔍 STEP 3: {middleware_name}.before_request COMPLETED")
-
-            # Call the next middleware or main handler
-            get_global_logger().info(f"🔍 STEP 4: {middleware_name}.call_next START - About to call next middleware/endpoint")
-            response = await call_next(request)
-            get_global_logger().info(f"🔍 STEP 5: {middleware_name}.call_next COMPLETED - Status: {response.status_code}")
-            get_global_logger().info(f"🔍 STEP 5.1: {middleware_name} - Response headers: {dict(response.headers)}")
-
-            # Process response after calling the main handler
-            get_global_logger().info(f"🔍 STEP 6: {middleware_name}.after_response START")
-            response = await self.after_response(request, response)
-            get_global_logger().info(f"🔍 STEP 7: {middleware_name}.after_response COMPLETED")
-
-            get_global_logger().info(f"🔍 STEP 8: {middleware_name}.dispatch COMPLETED SUCCESSFULLY")
-            return response
-        except Exception as e:
-            get_global_logger().error(f"❌ STEP ERROR: {middleware_name}.dispatch ERROR: {str(e)}", exc_info=True)
-            # If an error occurred, call the error handler
-            return await self.handle_error(request, e)
 
     async def before_request(self, request: Request) -> None:
         """

mcp_proxy_adapter/api/middleware/command_permission_middleware.py

@@ -9,7 +9,6 @@ email: vasilyvz@gmail.com
 
 import json
 import logging
-from typing import Dict, Any, Optional, Callable, Awaitable
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 
@@ -47,90 +46,6 @@ class CommandPermissionMiddleware(BaseHTTPMiddleware):
 
         get_global_logger().info("Command permission middleware initialized")
 
-    async def dispatch(
-        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
-    ) -> Response:
-        """
-        Process request and check command permissions.
-
-        Args:
-            request: Request object
-            call_next: Next handler
-
-        Returns:
-            Response object
-        """
-        # Only check permissions for /cmd endpoint
-        if request.url.path != "/cmd":
-            return await call_next(request)
-
-        try:
-            # Get request body
-            body = await request.body()
-            if not body:
-                return await call_next(request)
-
-            # Parse JSON-RPC request
-            try:
-                data = json.loads(body)
-            except json.JSONDecodeError:
-                return await call_next(request)
-
-            # Extract method (command name)
-            method = data.get("method")
-            if not method:
-                return await call_next(request)
-
-            # Check if method requires permissions
-            if method not in self.command_permissions:
-                return await call_next(request)
-
-            required_permissions = self.command_permissions[method]
-
-            # Get user info from request state
-            user_info = getattr(request.state, "user", None)
-            if not user_info:
-                get_global_logger().warning(f"No user info found for command {method}")
-                return await call_next(request)
-
-            user_roles = user_info.get("roles", [])
-            user_permissions = user_info.get("permissions", [])
-
-            get_global_logger().debug(
-                f"Checking permissions for {method}: user_roles={user_roles}, required={required_permissions}"
-            )
-
-            # Check if user has required permissions
-            has_permission = self._check_permissions(
-                user_roles, user_permissions, required_permissions
-            )
-
-            if not has_permission:
-                get_global_logger().warning(
-                    f"Permission denied for {method}: user_roles={user_roles}, required={required_permissions}"
-                )
-
-                # Return permission denied response
-                error_response = {
-                    "error": {
-                        "code": 403,
-                        "message": f"Permission denied: {method} requires {required_permissions}",
-                        "type": "permission_denied",
-                    }
-                }
-
-                return Response(
-                    content=json.dumps(error_response),
-                    status_code=403,
-                    media_type="application/json",
-                )
-
-            get_global_logger().debug(f"Permission granted for {method}")
-            return await call_next(request)
-
-        except Exception as e:
-            get_global_logger().error(f"Error in command permission middleware: {e}")
-            return await call_next(request)
 
     def _check_permissions(
         self, user_roles: list, user_permissions: list, required_permissions: list