mcp-proxy-adapter 6.0.0__py3-none-any.whl → 6.0.1__py3-none-any.whl

mcp_proxy_adapter/schemas/openapi_schema.json

@@ -1,314 +0,0 @@
-{
-  "openapi": "3.0.2",
-  "info": {
-    "title": "MCP Microservice API",
-    "description": "API для выполнения команд микросервиса",
-    "version": "1.0.0"
-  },
-  "paths": {
-    "/cmd": {
-      "post": {
-        "summary": "Execute Command",
-        "description": "Executes a command via JSON-RPC protocol.",
-        "operationId": "execute_command",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "oneOf": [
-                  { "$ref": "#/components/schemas/CommandRequest" },
-                  { "$ref": "#/components/schemas/JsonRpcRequest" }
-                ]
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "oneOf": [
-                    { "$ref": "#/components/schemas/CommandResponse" },
-                    { "$ref": "#/components/schemas/JsonRpcResponse" }
-                  ]
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HTTPValidationError"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/health": {
-      "get": {
-        "summary": "Проверить работоспособность сервиса",
-        "description": "Возвращает информацию о состоянии сервиса",
-        "operationId": "health_check",
-        "responses": {
-          "200": {
-            "description": "Информация о состоянии сервиса",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HealthResponse"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/openapi.json": {
-      "get": {
-        "summary": "Get Openapi Schema",
-        "description": "Returns OpenAPI schema.",
-        "operationId": "get_openapi_schema_openapi_json_get",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {}
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/commands": {
-      "get": {
-        "summary": "Get Commands",
-        "description": "Returns list of available commands with their descriptions.",
-        "operationId": "get_commands_api_commands_get",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {}
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  "components": {
-    "schemas": {
-      "CommandRequest": {
-        "title": "CommandRequest",
-        "description": "Запрос на выполнение команды",
-        "type": "object",
-        "required": [
-          "command"
-        ],
-        "properties": {
-          "command": {
-            "title": "Command",
-            "description": "Команда для выполнения",
-            "type": "string"
-          },
-          "params": {
-            "title": "Parameters",
-            "description": "Параметры команды, зависят от типа команды",
-            "type": "object",
-            "additionalProperties": true
-          }
-        }
-      },
-      "CommandResponse": {
-        "title": "CommandResponse",
-        "description": "Ответ на выполнение команды",
-        "type": "object",
-        "required": [
-          "result"
-        ],
-        "properties": {
-          "result": {
-            "title": "Result",
-            "description": "Результат выполнения команды"
-          }
-        }
-      },
-      "JsonRpcRequest": {
-        "properties": {
-          "jsonrpc": {
-            "type": "string",
-            "title": "Jsonrpc",
-            "description": "JSON-RPC version",
-            "default": "2.0"
-          },
-          "method": {
-            "type": "string",
-            "title": "Method",
-            "description": "Method name to call"
-          },
-          "params": {
-            "additionalProperties": true,
-            "type": "object",
-            "title": "Params",
-            "description": "Method parameters",
-            "default": {}
-          },
-          "id": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "integer"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Id",
-            "description": "Request identifier"
-          }
-        },
-        "type": "object",
-        "required": [
-          "method"
-        ],
-        "title": "JsonRpcRequest",
-        "description": "Base model for JSON-RPC requests."
-      },
-      "JsonRpcResponse": {
-        "properties": {
-          "jsonrpc": {
-            "type": "string",
-            "title": "Jsonrpc",
-            "description": "JSON-RPC version",
-            "default": "2.0"
-          },
-          "result": {
-            "anyOf": [
-              {},
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Result",
-            "description": "Method execution result"
-          },
-          "error": {
-            "anyOf": [
-              {
-                "additionalProperties": true,
-                "type": "object"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Error",
-            "description": "Error information"
-          },
-          "id": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "integer"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Id",
-            "description": "Request identifier"
-          }
-        },
-        "type": "object",
-        "title": "JsonRpcResponse",
-        "description": "Base model for JSON-RPC responses."
-      },
-      "HealthResponse": {
-        "title": "HealthResponse",
-        "description": "Информация о состоянии сервиса",
-        "type": "object",
-        "required": [
-          "status",
-          "model",
-          "version"
-        ],
-        "properties": {
-          "status": {
-            "title": "Status",
-            "description": "Статус сервиса (ok/error)",
-            "type": "string"
-          },
-          "model": {
-            "title": "Model",
-            "description": "Текущая активная модель",
-            "type": "string"
-          },
-          "version": {
-            "title": "Version",
-            "description": "Версия сервиса",
-            "type": "string"
-          }
-        }
-      },
-      "HTTPValidationError": {
-        "properties": {
-          "detail": {
-            "items": {
-              "$ref": "#/components/schemas/ValidationError"
-            },
-            "type": "array",
-            "title": "Detail"
-          }
-        },
-        "type": "object",
-        "title": "HTTPValidationError"
-      },
-      "ValidationError": {
-        "properties": {
-          "loc": {
-            "items": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "integer"
-                }
-              ]
-            },
-            "type": "array",
-            "title": "Location"
-          },
-          "msg": {
-            "type": "string",
-            "title": "Message"
-          },
-          "type": {
-            "type": "string",
-            "title": "Error Type"
-          }
-        },
-        "type": "object",
-        "required": [
-          "loc",
-          "msg",
-          "type"
-        ],
-        "title": "ValidationError"
-      }
-    }
-  }
-} 

mcp_proxy_adapter/schemas/roles_schema.json

@@ -1,162 +0,0 @@
-{
-  "roles": {
-    "admin": {
-      "description": "Administrator with full access",
-      "allowed_servers": ["*"],
-      "allowed_clients": ["*"],
-      "permissions": ["read", "write", "delete", "admin"],
-      "priority": 100
-    },
-    "super-admin": {
-      "description": "Super administrator with system-level access",
-      "allowed_servers": ["*"],
-      "allowed_clients": ["*"],
-      "permissions": ["read", "write", "delete", "admin", "system"],
-      "priority": 200
-    },
-    "kubernetes_service": {
-      "description": "Kubernetes service with cluster management access",
-      "allowed_servers": ["kubernetes_manager", "kubernetes_api", "cluster_monitor", "k8s_operator"],
-      "allowed_clients": ["admin", "super-admin", "kubernetes_service", "ca_root", "ca_intermediate"],
-      "permissions": ["read", "write", "system"],
-      "priority": 120
-    },
-    "ca_root": {
-      "description": "Root Certificate Authority with full certificate management",
-      "allowed_servers": ["*"],
-      "allowed_clients": ["admin", "super-admin", "ca_root", "ca_intermediate"],
-      "permissions": ["read", "write", "delete", "admin", "system"],
-      "priority": 180
-    },
-    "ca_intermediate": {
-      "description": "Intermediate Certificate Authority with delegated certificate management",
-      "allowed_servers": ["certificate_manager", "ssl_manager", "tls_manager"],
-      "allowed_clients": ["admin", "super-admin", "ca_root", "ca_intermediate", "kubernetes_service"],
-      "permissions": ["read", "write", "admin"],
-      "priority": 140
-    },
-    "operator": {
-      "description": "Operator with limited access",
-      "allowed_servers": ["kubernetes_manager", "docker_manager", "monitor", "aiadm"],
-      "allowed_clients": ["admin", "super-admin", "operator"],
-      "permissions": ["read", "write"],
-      "priority": 50
-    },
-    "user": {
-      "description": "Regular user with basic access",
-      "allowed_servers": ["basic_commands", "info_commands"],
-      "allowed_clients": ["admin", "super-admin", "operator", "user"],
-      "permissions": ["read"],
-      "priority": 10
-    },
-    "guest": {
-      "description": "Guest user with minimal access",
-      "allowed_servers": ["help", "info"],
-      "allowed_clients": ["admin", "super-admin", "operator", "user", "guest"],
-      "permissions": ["read"],
-      "priority": 1
-    },
-    "system": {
-      "description": "System service with internal access",
-      "allowed_servers": ["*"],
-      "allowed_clients": ["admin", "super-admin", "system"],
-      "permissions": ["read", "write", "system"],
-      "priority": 150
-    }
-  },
-  "default_policy": {
-    "deny_by_default": true,
-    "require_role_match": true,
-    "case_sensitive": false,
-    "allow_wildcard": true
-  },
-  "role_hierarchy": {
-    "super-admin": ["admin", "user"],
-    "admin": ["operator", "user"],
-    "kubernetes_service": ["operator", "user"],
-    "ca_root": ["admin", "ca_intermediate", "kubernetes_service"],
-    "ca_intermediate": ["operator", "user"],
-    "operator": ["user"],
-    "user": ["guest"],
-    "system": ["admin", "user"]
-  },
-  "permissions": {
-    "read": {
-      "description": "Read access to data and commands",
-      "level": 1
-    },
-    "write": {
-      "description": "Write access to data and commands",
-      "level": 2
-    },
-    "delete": {
-      "description": "Delete access to data and commands",
-      "level": 3
-    },
-    "admin": {
-      "description": "Administrative access",
-      "level": 4
-    },
-    "system": {
-      "description": "System-level access",
-      "level": 5
-    }
-  },
-  "server_roles": {
-    "kubernetes_manager": {
-      "description": "Kubernetes management server",
-      "required_roles": ["admin", "operator", "kubernetes_service"],
-      "allowed_commands": ["k8s_*", "system_monitor"]
-    },
-    "kubernetes_api": {
-      "description": "Kubernetes API server",
-      "required_roles": ["kubernetes_service", "admin"],
-      "allowed_commands": ["k8s_api_*", "cluster_*"]
-    },
-    "cluster_monitor": {
-      "description": "Kubernetes cluster monitoring server",
-      "required_roles": ["kubernetes_service", "admin"],
-      "allowed_commands": ["monitor_*", "metrics_*"]
-    },
-    "k8s_operator": {
-      "description": "Kubernetes operator server",
-      "required_roles": ["kubernetes_service", "admin"],
-      "allowed_commands": ["operator_*", "crd_*"]
-    },
-    "certificate_manager": {
-      "description": "Certificate management server",
-      "required_roles": ["ca_root", "ca_intermediate", "admin"],
-      "allowed_commands": ["cert_*", "ca_*", "ssl_*"]
-    },
-    "ssl_manager": {
-      "description": "SSL/TLS management server",
-      "required_roles": ["ca_intermediate", "admin"],
-      "allowed_commands": ["ssl_*", "tls_*", "cert_*"]
-    },
-    "tls_manager": {
-      "description": "TLS management server",
-      "required_roles": ["ca_intermediate", "admin"],
-      "allowed_commands": ["tls_*", "mtls_*", "cert_*"]
-    },
-    "docker_manager": {
-      "description": "Docker management server",
-      "required_roles": ["admin", "operator"],
-      "allowed_commands": ["docker_*", "system_monitor"]
-    },
-    "aiadm": {
-      "description": "AI Admin server",
-      "required_roles": ["admin", "operator"],
-      "allowed_commands": ["*"]
-    },
-    "basic_commands": {
-      "description": "Basic command server",
-      "required_roles": ["user", "admin", "operator"],
-      "allowed_commands": ["help", "config", "health", "info"]
-    },
-    "help": {
-      "description": "Help server",
-      "required_roles": ["guest", "user", "admin", "operator"],
-      "allowed_commands": ["help"]
-    }
-  }
-} 

mcp_proxy_adapter/tests/api/__init__.py

@@ -1,3 +0,0 @@
-"""
-API tests package.
-""" 

mcp_proxy_adapter/tests/api/test_cmd_endpoint.py

@@ -1,115 +0,0 @@
-"""
-Tests for the /cmd endpoint.
-"""
-
-import pytest
-from unittest.mock import patch, MagicMock, ANY
-from fastapi.testclient import TestClient
-
-from mcp_proxy_adapter.api.app import app
-from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.core.errors import MicroserviceError
-
-
-@pytest.fixture
-def client():
-    """Test client for FastAPI app."""
-    return TestClient(app)
-
-
-@pytest.fixture
-def mock_registry():
-    """Mock for command registry."""
-    with patch("mcp_proxy_adapter.api.app.registry") as mock_reg:
-        yield mock_reg
-
-
-@pytest.fixture
-def mock_execute_command():
-    """Mock for execute_command function."""
-    with patch("mcp_proxy_adapter.api.app.execute_command") as mock_exec:
-        yield mock_exec
-
-
-def test_cmd_endpoint_basic(client, mock_registry, mock_execute_command):
-    """Test basic execution of /cmd endpoint."""
-    # Setup mocks
-    mock_registry.command_exists.return_value = True
-    mock_execute_command.return_value = {"key": "value"}
-    
-    # Send request
-    response = client.post(
-        "/cmd",
-        json={"command": "test_command", "params": {"param1": "value1"}}
-    )
-    
-    # Check result
-    assert response.status_code == 200
-    assert response.json() == {"result": {"key": "value"}}
-    
-    # Verify mock calls with ANY for request_id since it can be dynamic
-    mock_registry.command_exists.assert_called_once_with("test_command")
-    mock_execute_command.assert_called_once_with(
-        "test_command", {"param1": "value1"}, ANY
-    )
-
-
-def test_cmd_endpoint_missing_command(client):
-    """Test /cmd endpoint with missing 'command' field."""
-    response = client.post("/cmd", json={})
-    
-    assert response.status_code == 200
-    assert "error" in response.json()
-    assert response.json()["error"]["code"] == -32600
-    assert "Отсутствует обязательное поле 'command'" in response.json()["error"]["message"]
-
-
-def test_cmd_endpoint_command_not_found(client, mock_registry):
-    """Test /cmd endpoint with non-existent command."""
-    # Setup mocks
-    mock_registry.command_exists.return_value = False
-    
-    # Send request
-    response = client.post("/cmd", json={"command": "non_existent"})
-    
-    # Check result
-    assert response.status_code == 200
-    assert "error" in response.json()
-    assert response.json()["error"]["code"] == -32601
-    assert "не найдена" in response.json()["error"]["message"]
-
-
-def test_cmd_endpoint_error_handling(client, mock_registry, mock_execute_command):
-    """Test error handling in /cmd endpoint."""
-    # Setup mocks
-    mock_registry.command_exists.return_value = True
-    
-    error = MicroserviceError("Test error", code=-32000)
-    error.to_dict = MagicMock(return_value={"code": -32000, "message": "Test error"})
-    mock_execute_command.side_effect = error
-    
-    # Send request
-    response = client.post("/cmd", json={"command": "test_command"})
-    
-    # Check result
-    assert response.status_code == 200
-    assert "error" in response.json()
-    assert response.json()["error"]["code"] == -32000
-    assert response.json()["error"]["message"] == "Test error"
-
-
-def test_cmd_endpoint_internal_error(client, mock_registry, mock_execute_command):
-    """Test internal error handling in /cmd endpoint."""
-    # Setup mocks
-    mock_registry.command_exists.return_value = True
-    mock_execute_command.side_effect = Exception("Unexpected error")
-    
-    # Send request
-    response = client.post("/cmd", json={"command": "test_command"})
-    
-    # Check result
-    assert response.status_code == 200
-    assert "error" in response.json()
-    assert response.json()["error"]["code"] == -32603
-    assert "Internal error" in response.json()["error"]["message"]
-    assert "Unexpected error" in response.json()["error"]["data"]["details"]