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

mcp_proxy_adapter/commands/health_command.py

@@ -0,0 +1,142 @@
+"""
+Module with health command implementation.
+"""
+
+import os
+import platform
+import sys
+import psutil
+from datetime import datetime
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.proxy_registration import get_proxy_registration_status
+
+
+class HealthResult(SuccessResult):
+    """
+    Result of the health command execution.
+    """
+
+    def __init__(
+        self, status: str, version: str, uptime: float, components: Dict[str, Any]
+    ):
+        """
+        Initialize health command result.
+
+        Args:
+            status: Server status ("ok" or "error")
+            version: Server version
+            uptime: Server uptime in seconds
+            components: Dictionary with components status
+        """
+        super().__init__(
+            data={
+                "status": status,
+                "version": version,
+                "uptime": uptime,
+                "components": components,
+            }
+        )
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for result validation.
+
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "object",
+                    "properties": {
+                        "status": {"type": "string"},
+                        "version": {"type": "string"},
+                        "uptime": {"type": "number"},
+                        "components": {
+                            "type": "object",
+                            "properties": {
+                                "system": {"type": "object"},
+                                "process": {"type": "object"},
+                                "commands": {"type": "object"},
+                            },
+                        },
+                    },
+                    "required": ["status", "version", "uptime", "components"],
+                }
+            },
+            "required": ["data"],
+        }
+
+
+class HealthCommand(Command):
+    """
+    Command that returns information about server health and status.
+    """
+
+    name = "health"
+    result_class = HealthResult
+
+    async def execute(self, **kwargs) -> HealthResult:
+        """
+        Execute health command.
+
+        Returns:
+            HealthResult: Health command result
+        """
+        # Get version from package
+        try:
+        except ImportError:
+            version = "unknown"
+
+        # 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 HealthResult(
+            status="ok",
+            version=version,
+            uptime=uptime_seconds,
+            components={
+                "system": {
+                    "python_version": sys.version,
+                    "platform": platform.platform(),
+                    "cpu_count": os.cpu_count(),
+                },
+                "process": {
+                    "pid": os.getpid(),
+                    "memory_usage_mb": memory_info.rss / (1024 * 1024),
+                    "start_time": start_time.isoformat(),
+                },
+                "commands": {"registered_count": len(registry.get_all_commands())},
+                "proxy_registration": {
+                    "enabled": get_proxy_registration_status().get("enabled", False),
+                    "registered": get_proxy_registration_status().get(
+                        "registered", False
+                    ),
+                    "server_key": get_proxy_registration_status().get("server_key"),
+                    "proxy_url": get_proxy_registration_status().get("proxy_url"),
+                },
+            },
+        )
+
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """
+        Get JSON schema for command parameters validation.
+
+        Returns:
+            Dict[str, Any]: JSON schema
+        """
+        return {
+            "type": "object",
+            "additionalProperties": False,
+            "description": "Command doesn't accept any parameters",
+        }

mcp_proxy_adapter/commands/help_command.py

@@ -0,0 +1,175 @@
+"""
+Module with help command implementation.
+"""
+
+from typing import Dict, Any, Optional
+import logging
+import traceback
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import CommandResult
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.errors import NotFoundError
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+# Добавляем логирование
+logger = logging.getLogger("mcp_proxy_adapter.commands.help_command")
+
+
+class HelpResult(CommandResult):
+    """
+    Result of the help command execution.
+    """
+
+    def __init__(
+        self,
+        commands_info: Optional[Dict[str, Any]] = None,
+        command_info: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize help command result.
+
+        Args:
+            commands_info: Information about all commands (for request without parameters)
+            command_info: Information about a specific command (for request with cmdname parameter)
+        """
+        get_global_logger().debug(
+            f"HelpResult.__init__: commands_info={commands_info is not None}, command_info={command_info is not None}"
+        )
+        self.commands_info = commands_info
+        self.command_info = command_info
+
+
+    @classmethod
+
+
+class HelpCommand(Command):
+    """
+    Command for getting help information about available commands.
+    """
+
+    name = "help"
+    result_class = HelpResult
+
+    async def execute(self, cmdname: Optional[str] = None, **kwargs) -> HelpResult:
+        """
+        Execute help command.
+
+        Args:
+            cmdname: Name of the command to get information about (optional)
+            **kwargs: Any additional parameters (will be ignored)
+
+        Returns:
+            HelpResult: Help command result
+
+        Raises:
+            NotFoundError: If specified command not found
+        """
+        get_global_logger().debug(f"HelpCommand.execute начало: cmdname={cmdname}, kwargs={kwargs}")
+
+        try:
+            # Handle case when cmdname is provided
+            if cmdname is not None and cmdname != "":
+                get_global_logger().debug(f"Обработка запроса для конкретной команды: {cmdname}")
+                try:
+                    # Get command info from registry
+                    command_info = registry.get_command_info(cmdname)
+                    if command_info is None:
+                        raise NotFoundError(f"Command '{cmdname}' not found")
+                    get_global_logger().debug(f"Получены метаданные для команды {cmdname}")
+                    return HelpResult(command_info=command_info)
+                except NotFoundError:
+                    get_global_logger().warning(f"Команда '{cmdname}' не найдена")
+                    # Получаем список всех команд
+                    all_commands = list(registry.get_all_commands().keys())
+                    if all_commands:
+                        example_cmd = all_commands[0]
+                        example = {
+                            "command": "help",
+                            "params": {"cmdname": example_cmd},
+                        }
+                        note = f"Use help with an existing command name to get detailed info. For example: help with cmdname '{example_cmd}'. To list all commands: call help without parameters."
+                    else:
+                        example = {"command": "help"}
+                        note = "No commands registered. To list all commands: call help without parameters."
+                    return HelpResult(
+                        commands_info={
+                            "commands": {},
+                            "error": f"Command '{cmdname}' not found",
+                            "example": example,
+                            "note": note,
+                        }
+                    )
+
+            # Otherwise, return information about all available commands
+            get_global_logger().debug("Обработка запроса для всех команд")
+
+            # Get info for all commands
+            all_commands_info = registry.get_all_commands_info()
+            get_global_logger().debug(
+                f"Получены метаданные для {len(all_commands_info.get('commands', {}))} команд"
+            )
+
+            # Prepare response format with tool metadata
+            result = {
+                "tool_info": {
+                    "name": "MCP-Proxy API Service",
+                    "description": "JSON-RPC API for microservice command execution",
+                    "version": "1.0.0",
+                },
+                "help_usage": {
+                    "description": "Get information about commands",
+                    "examples": [
+                        {
+                            "command": "help",
+                            "description": "List of all available commands",
+                        },
+                        {
+                            "command": "help",
+                            "params": {"cmdname": "command_name"},
+                            "description": "Get detailed information about a specific command",
+                        },
+                    ],
+                },
+                "commands": {},
+            }
+
+            # Add brief information about commands
+            commands_data = all_commands_info.get("commands", {})
+            for name, command_info in commands_data.items():
+                try:
+                    get_global_logger().debug(f"Обработка метаданных команды {name}")
+                    # Безопасное получение параметров с проверкой на наличие ключей
+                    metadata = command_info.get("metadata", {})
+                    schema = command_info.get("schema", {})
+                    result["commands"][name] = {
+                        "summary": metadata.get("summary", ""),
+                        "params_count": len(schema.get("properties", {})),
+                    }
+                except Exception as e:
+                    get_global_logger().error(f"Ошибка при обработке метаданных команды {name}: {e}")
+                    get_global_logger().debug(f"Метаданные команды {name}: {command_info}")
+                    # Пропускаем проблемную команду
+                    continue
+
+            get_global_logger().debug(
+                f"HelpCommand.execute завершение: возвращаем результат с {len(result['commands'])} командами"
+            )
+            return HelpResult(commands_info=result)
+        except Exception as e:
+            get_global_logger().error(f"Неожиданная ошибка в HelpCommand.execute: {e}")
+            get_global_logger().debug(f"Трассировка: {traceback.format_exc()}")
+            # В случае неожиданной ошибки возвращаем пустой результат вместо ошибки
+            return HelpResult(
+                commands_info={
+                    "tool_info": {
+                        "name": "MCP-Proxy API Service",
+                        "description": "JSON-RPC API for microservice command execution",
+                        "version": "1.0.0",
+                    },
+                    "commands": {},
+                    "error": str(e),
+                }
+            )
+
+    @classmethod

mcp_proxy_adapter/commands/hooks.py

@@ -0,0 +1,172 @@
+"""
+Module for command registration hooks.
+
+This module provides a hook system for registering custom commands
+that will be called during system initialization.
+"""
+
+from enum import Enum
+from dataclasses import dataclass
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class HookType(Enum):
+    """Types of hooks that can be registered."""
+
+    CUSTOM_COMMANDS = "custom_commands"
+    BEFORE_INIT = "before_init"
+    AFTER_INIT = "after_init"
+    BEFORE_COMMAND = "before_command"
+    AFTER_COMMAND = "after_command"
+    BEFORE_EXECUTION = "before_execution"
+    AFTER_EXECUTION = "after_execution"
+
+
+@dataclass
+class HookContext:
+    """Context object passed to hook functions."""
+
+    hook_type: HookType
+    command_name: Optional[str] = None
+    params: Optional[Dict[str, Any]] = None
+    result: Optional[Any] = None
+    registry: Optional[Any] = None
+    metadata: Optional[Dict[str, Any]] = None
+    standard_processing: bool = True
+
+    def __post_init__(self):
+        """Initialize metadata if not provided."""
+        if self.metadata is None:
+            self.metadata = {}
+
+
+class CommandHooks:
+    """
+    Hook system for command registration.
+    """
+
+    def __init__(self):
+        """
+        Initialize command hooks.
+        """
+        self._custom_commands_hooks: List[Callable] = []
+        self._before_init_hooks: List[Callable] = []
+        self._after_init_hooks: List[Callable] = []
+        self._before_command_hooks: List[Callable] = []
+        self._after_command_hooks: List[Callable] = []
+
+    def register_custom_commands_hook(self, hook_func: Callable) -> None:
+        """
+        Register a hook function for custom commands registration.
+
+        Args:
+            hook_func: Function that registers custom commands.
+                      Should accept registry as parameter.
+        """
+        self._custom_commands_hooks.append(hook_func)
+        get_global_logger().debug(f"Registered custom commands hook: {hook_func.__name__}")
+
+    def register_before_init_hook(self, hook_func: Callable) -> None:
+        """
+        Register a hook function to be called before system initialization.
+
+        Args:
+            hook_func: Function to call before initialization.
+        """
+        self._before_init_hooks.append(hook_func)
+        get_global_logger().debug(f"Registered before init hook: {hook_func.__name__}")
+
+    def register_after_init_hook(self, hook_func: Callable) -> None:
+        """
+        Register a hook function to be called after system initialization.
+
+        Args:
+            hook_func: Function to call after initialization.
+        """
+        self._after_init_hooks.append(hook_func)
+        get_global_logger().debug(f"Registered after init hook: {hook_func.__name__}")
+
+    def register_before_command_hook(self, hook_func: Callable) -> None:
+        """
+        Register a hook function to be called before command execution.
+
+        Args:
+            hook_func: Function to call before command execution.
+                      Should accept command_name and params as parameters.
+        """
+        self._before_command_hooks.append(hook_func)
+        get_global_logger().debug(f"Registered before command hook: {hook_func.__name__}")
+
+    def register_after_command_hook(self, hook_func: Callable) -> None:
+        """
+        Register a hook function to be called after command execution.
+
+        Args:
+            hook_func: Function to call after command execution.
+                      Should accept command_name, params, and result as parameters.
+        """
+        self._after_command_hooks.append(hook_func)
+        get_global_logger().debug(f"Registered after command hook: {hook_func.__name__}")
+
+
+
+
+
+
+
+
+# Global hooks instance
+hooks = CommandHooks()
+
+
+def register_custom_commands_hook(hook_func: Callable) -> None:
+    """
+    Register a hook function for custom commands registration.
+
+    Args:
+        hook_func: Function that registers custom commands.
+                  Should accept registry as parameter.
+    """
+    hooks.register_custom_commands_hook(hook_func)
+
+
+def register_before_init_hook(hook_func: Callable) -> None:
+    """
+    Register a hook function to be called before system initialization.
+
+    Args:
+        hook_func: Function to call before initialization.
+    """
+    hooks.register_before_init_hook(hook_func)
+
+
+def register_after_init_hook(hook_func: Callable) -> None:
+    """
+    Register a hook function to be called after system initialization.
+
+    Args:
+        hook_func: Function to call after initialization.
+    """
+    hooks.register_after_init_hook(hook_func)
+
+
+def register_before_command_hook(hook_func: Callable) -> None:
+    """
+    Register a hook function to be called before command execution.
+
+    Args:
+        hook_func: Function to call before command execution.
+                  Should accept command_name and params as parameters.
+    """
+    hooks.register_before_command_hook(hook_func)
+
+
+def register_after_command_hook(hook_func: Callable) -> None:
+    """
+    Register a hook function to be called after command execution.
+
+    Args:
+        hook_func: Function to call after command execution.
+                  Should accept command_name, params, and result as parameters.
+    """
+    hooks.register_after_command_hook(hook_func)