mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/api/handlers.py

@@ -11,13 +11,24 @@ from fastapi.responses import JSONResponse
 
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.core.errors import (
-    MicroserviceError, NotFoundError, ParseError, InvalidRequestError,
-    MethodNotFoundError, InvalidParamsError, InternalError, CommandError
+    MicroserviceError,
+    NotFoundError,
+    ParseError,
+    InvalidRequestError,
+    MethodNotFoundError,
+    InvalidParamsError,
+    InternalError,
+    CommandError,
 )
 from mcp_proxy_adapter.core.logging import logger, RequestLogger, get_logger
 
 
-async def execute_command(command_name: str, params: Dict[str, Any], request_id: Optional[str] = None, request: Optional[Request] = None) -> Dict[str, Any]:
+async def execute_command(
+    command_name: str,
+    params: Dict[str, Any],
+    request_id: Optional[str] = None,
+    request: Optional[Request] = None,
+) -> Dict[str, Any]:
     """
     Executes a command with the specified name and parameters.
 
@@ -35,47 +46,48 @@ async def execute_command(command_name: str, params: Dict[str, Any], request_id:
     """
     # Create request logger if request_id is provided
     log = RequestLogger(__name__, request_id) if request_id else logger
-    
+
     try:
         log.info(f"Executing command: {command_name}")
-        
+
         # Execute before command hooks
         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'])
+        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"]),
             }
-        
+
         result = await command_class.run(**params, context=context)
-        
+
         execution_time = time.time() - start_time
-        
+
         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:
@@ -87,10 +99,14 @@ async def execute_command(command_name: str, params: Dict[str, Any], request_id:
         if isinstance(e, MicroserviceError):
             raise e
         # Все остальные ошибки оборачиваем в InternalError
-        raise InternalError(f"Error executing command: {str(e)}", data={"original_error": str(e)})
+        raise InternalError(
+            f"Error executing command: {str(e)}", data={"original_error": str(e)}
+        )
 
 
-async def handle_batch_json_rpc(batch_requests: List[Dict[str, Any]], request: Optional[Request] = None) -> List[Dict[str, Any]]:
+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.
 
@@ -102,19 +118,23 @@ async def handle_batch_json_rpc(batch_requests: List[Dict[str, Any]], request: O
         List of JSON-RPC responses.
     """
     responses = []
-    
+
     # Get request_id from request state if available
     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)
-    
+
     return responses
 
 
-async def handle_json_rpc(request_data: Dict[str, Any], request_id: Optional[str] = None, request: Optional[Request] = None) -> Dict[str, Any]:
+async def handle_json_rpc(
+    request_data: Dict[str, Any],
+    request_id: Optional[str] = None,
+    request: Optional[Request] = None,
+) -> Dict[str, Any]:
     """
     Handles JSON-RPC request.
 
@@ -127,37 +147,32 @@ async def handle_json_rpc(request_data: Dict[str, Any], request_id: Optional[str
     """
     # Create request logger if request_id is provided
     log = RequestLogger(__name__, request_id) if request_id else logger
-    
+
     # Check JSON-RPC version
     if request_data.get("jsonrpc") != "2.0":
         return _create_error_response(
             InvalidRequestError("Invalid Request. Expected jsonrpc: 2.0"),
-            request_data.get("id")
+            request_data.get("id"),
         )
-    
+
     # Get method and parameters
     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
+            InvalidRequestError("Invalid Request. Method is required"), json_rpc_id
         )
-    
+
     log.info(f"Executing JSON-RPC method: {method}")
-    
+
     try:
         # Execute command
         result = await execute_command(method, params, request_id, request)
-        
+
         # Form successful response
-        return {
-            "jsonrpc": "2.0",
-            "result": result,
-            "id": json_rpc_id
-        }
+        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)}")
@@ -166,8 +181,7 @@ async def handle_json_rpc(request_data: Dict[str, Any], request_id: Optional[str
         # Internal server error
         log.exception(f"Unhandled error in JSON-RPC handler: {e}")
         return _create_error_response(
-            InternalError("Internal error", data={"error": str(e)}),
-            json_rpc_id
+            InternalError("Internal error", data={"error": str(e)}), json_rpc_id
         )
 
 
@@ -182,11 +196,7 @@ def _create_error_response(error: MicroserviceError, request_id: Any) -> Dict[st
     Returns:
         JSON-RPC error response dictionary.
     """
-    return {
-        "jsonrpc": "2.0",
-        "error": error.to_dict(),
-        "id": request_id
-    }
+    return {"jsonrpc": "2.0", "error": error.to_dict(), "id": request_id}
 
 
 async def get_server_health() -> Dict[str, Any]:
@@ -201,15 +211,15 @@ async def get_server_health() -> Dict[str, Any]:
     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()
-    
+
     return {
         "status": "ok",
         "version": "1.0.0",  # Should be replaced with actual version
@@ -218,17 +228,15 @@ async def get_server_health() -> Dict[str, Any]:
             "system": {
                 "python_version": sys.version,
                 "platform": platform.platform(),
-                "cpu_count": os.cpu_count()
+                "cpu_count": os.cpu_count(),
             },
             "process": {
                 "pid": os.getpid(),
                 "memory_usage_mb": memory_info.rss / (1024 * 1024),
-                "start_time": start_time.isoformat()
+                "start_time": start_time.isoformat(),
             },
-            "commands": {
-                "registered_count": len(registry.get_all_commands())
-            }
-        }
+            "commands": {"registered_count": len(registry.get_all_commands())},
+        },
     }
 
 
@@ -240,19 +248,19 @@ async def get_commands_list() -> Dict[str, Dict[str, Any]]:
         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", "")
+            "description": schema.get("description", ""),
         }
-    
+
     return result

mcp_proxy_adapter/api/middleware/__init__.py

@@ -12,6 +12,7 @@ from .base import BaseMiddleware
 from .factory import MiddlewareFactory
 from .protocol_middleware import setup_protocol_middleware
 
+
 def setup_middleware(app: FastAPI, app_config: Optional[Dict[str, Any]] = None) -> None:
     """
     Sets up middleware for application using the new middleware factory.
@@ -22,7 +23,7 @@ def setup_middleware(app: FastAPI, app_config: Optional[Dict[str, Any]] = None)
     """
     # 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)
 
@@ -40,16 +41,17 @@ def setup_middleware(app: FastAPI, app_config: Optional[Dict[str, Any]] = None)
     # 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'):
+        if hasattr(middleware, "dispatch"):
             # This is a proper ASGI middleware
             app.middleware("http")(middleware.dispatch)
         else:
-            logger.warning(f"Middleware {middleware.__class__.__name__} doesn't have dispatch method")
-    
+            logger.warning(
+                f"Middleware {middleware.__class__.__name__} doesn't have dispatch method"
+            )
+
     # Log middleware information
     middleware_info = factory.get_middleware_info()
     logger.info(f"Middleware setup completed:")
     logger.info(f"  - Total middleware: {middleware_info['total_middleware']}")
     logger.info(f"  - Types: {', '.join(middleware_info['middleware_types'])}")
     logger.info(f"  - Security enabled: {middleware_info['security_enabled']}")
- 

mcp_proxy_adapter/api/middleware/base.py

@@ -10,70 +10,73 @@ from fastapi import Request, Response
 
 from mcp_proxy_adapter.core.logging import logger
 
+
 class BaseMiddleware(BaseHTTPMiddleware):
     """
     Base class for all middleware.
     """
-    
-    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+
+    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.
         """
         try:
             # Process request before calling the main handler
             await self.before_request(request)
-            
+
             # Call the next middleware or main handler
             response = await call_next(request)
-            
+
             # Process response after calling the main handler
             response = await self.after_response(request, response)
-            
+
             return response
         except Exception as e:
             logger.exception(f"Error in middleware: {str(e)}")
             # If an error occurred, call the error handler
             return await self.handle_error(request, e)
-    
+
     async def before_request(self, request: Request) -> None:
         """
         Method for processing request before calling the main handler.
-        
+
         Args:
             request: Request.
         """
         pass
-    
+
     async def after_response(self, request: Request, response: Response) -> Response:
         """
         Method for processing response after calling the main handler.
-        
+
         Args:
             request: Request.
             response: Response.
-            
+
         Returns:
             Processed response.
         """
         return response
-    
+
     async def handle_error(self, request: Request, exception: Exception) -> Response:
         """
         Method for handling errors that occurred in middleware.
-        
+
         Args:
             request: Request.
             exception: Exception.
-            
+
         Returns:
             Error response.
         """
         # By default, just pass the error further
-        raise exception 
+        raise exception

mcp_proxy_adapter/api/middleware/command_permission_middleware.py

@@ -19,22 +19,22 @@ from mcp_proxy_adapter.core.logging import logger
 class CommandPermissionMiddleware(BaseHTTPMiddleware):
     """
     Middleware for checking command permissions.
-    
+
     This middleware checks if the authenticated user has the required
     permissions to execute specific commands.
     """
-    
+
     def __init__(self, app, config: Dict[str, Any]):
         """
         Initialize command permission middleware.
-        
+
         Args:
             app: FastAPI application
             config: Configuration dictionary
         """
         super().__init__(app)
         self.config = config
-        
+
         # Define command permissions
         self.command_permissions = {
             "echo": ["read"],
@@ -44,105 +44,115 @@ class CommandPermissionMiddleware(BaseHTTPMiddleware):
             "help": ["read"],
             # Add more commands as needed
         }
-        
+
         logger.info("Command permission middleware initialized")
-    
-    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+
+    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:
                 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", [])
-            
-            logger.debug(f"Checking permissions for {method}: user_roles={user_roles}, required={required_permissions}")
-            
+
+            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)
-            
+            has_permission = self._check_permissions(
+                user_roles, user_permissions, required_permissions
+            )
+
             if not has_permission:
-                logger.warning(f"Permission denied for {method}: user_roles={user_roles}, required={required_permissions}")
-                
+                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"
+                        "type": "permission_denied",
                     }
                 }
-                
+
                 return Response(
                     content=json.dumps(error_response),
                     status_code=403,
-                    media_type="application/json"
+                    media_type="application/json",
                 )
-            
+
             logger.debug(f"Permission granted for {method}")
             return await call_next(request)
-            
+
         except Exception as e:
             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) -> bool:
+
+    def _check_permissions(
+        self, user_roles: list, user_permissions: list, required_permissions: list
+    ) -> bool:
         """
         Check if user has required permissions.
-        
+
         Args:
             user_roles: User roles
             user_permissions: User permissions
             required_permissions: Required permissions
-            
+
         Returns:
             True if user has required permissions
         """
         # Admin has all permissions
         if "admin" in user_roles or "*" in user_permissions:
             return True
-        
+
         # Check if user has all required permissions
         for required in required_permissions:
             if required not in user_permissions:
                 return False
-        
+
         return True