mcp-proxy-adapter 4.1.1__py3-none-any.whl → 6.1.0__py3-none-any.whl

mcp_proxy_adapter/commands/dependency_manager.py

@@ -0,0 +1,245 @@
+"""
+Dependency management system for remote plugins.
+
+This module handles automatic installation and verification of plugin dependencies
+using pip and other package management tools.
+"""
+
+import subprocess
+import sys
+import importlib
+import pkg_resources
+from typing import List, Dict, Any, Optional, Tuple
+from pathlib import Path
+
+from mcp_proxy_adapter.core.logging import logger
+
+
+class DependencyManager:
+    """
+    Manages plugin dependencies installation and verification.
+    """
+    
+    def __init__(self):
+        """Initialize dependency manager."""
+        self._installed_packages: Dict[str, str] = {}
+        self._load_installed_packages()
+    
+    def _load_installed_packages(self) -> None:
+        """Load list of currently installed packages."""
+        try:
+            installed = pkg_resources.working_set
+            for dist in installed:
+                self._installed_packages[dist.project_name.lower()] = dist.version
+        except Exception as e:
+            logger.warning(f"Failed to load installed packages: {e}")
+    
+    def check_dependencies(self, dependencies: List[str]) -> Tuple[bool, List[str], List[str]]:
+        """
+        Check if dependencies are satisfied.
+        
+        Args:
+            dependencies: List of dependency names
+            
+        Returns:
+            Tuple of (all_satisfied, missing_deps, installed_deps)
+        """
+        if not dependencies:
+            return True, [], []
+        
+        missing_deps = []
+        installed_deps = []
+        
+        for dep in dependencies:
+            if self._is_dependency_satisfied(dep):
+                installed_deps.append(dep)
+            else:
+                missing_deps.append(dep)
+        
+        all_satisfied = len(missing_deps) == 0
+        return all_satisfied, missing_deps, installed_deps
+    
+    def _is_dependency_satisfied(self, dependency: str) -> bool:
+        """
+        Check if a single dependency is satisfied.
+        
+        Args:
+            dependency: Dependency name or spec
+            
+        Returns:
+            True if dependency is satisfied, False otherwise
+        """
+        # Try to import the module
+        try:
+            importlib.import_module(dependency)
+            return True
+        except ImportError:
+            pass
+        
+        # Check if it's installed as a package
+        try:
+            pkg_resources.require(dependency)
+            return True
+        except (pkg_resources.DistributionNotFound, pkg_resources.VersionConflict):
+            pass
+        
+        # Check installed packages cache
+        dep_name = dependency.split('==')[0].split('>=')[0].split('<=')[0].split('!=')[0].split('~=')[0]
+        if dep_name.lower() in self._installed_packages:
+            return True
+        
+        return False
+    
+    def install_dependencies(self, dependencies: List[str], user_install: bool = False) -> Tuple[bool, List[str], List[str]]:
+        """
+        Install dependencies using pip.
+        
+        Args:
+            dependencies: List of dependency names to install
+            user_install: Whether to install for current user only
+            
+        Returns:
+            Tuple of (success, installed_deps, failed_deps)
+        """
+        if not dependencies:
+            return True, [], []
+        
+        installed_deps = []
+        failed_deps = []
+        
+        for dep in dependencies:
+            try:
+                if self._install_single_dependency(dep, user_install):
+                    installed_deps.append(dep)
+                    logger.info(f"Successfully installed dependency: {dep}")
+                else:
+                    failed_deps.append(dep)
+                    logger.error(f"Failed to install dependency: {dep}")
+            except Exception as e:
+                failed_deps.append(dep)
+                logger.error(f"Error installing dependency {dep}: {e}")
+        
+        success = len(failed_deps) == 0
+        
+        # Reload installed packages cache
+        if success:
+            self._load_installed_packages()
+        
+        return success, installed_deps, failed_deps
+    
+    def _install_single_dependency(self, dependency: str, user_install: bool = False) -> bool:
+        """
+        Install a single dependency using pip.
+        
+        Args:
+            dependency: Dependency name or spec
+            user_install: Whether to install for current user only
+            
+        Returns:
+            True if installation successful, False otherwise
+        """
+        try:
+            # Build pip command
+            cmd = [sys.executable, "-m", "pip", "install"]
+            
+            if user_install:
+                cmd.append("--user")
+            
+            # Add quiet flag to reduce output
+            cmd.append("--quiet")
+            
+            # Add dependency
+            cmd.append(dependency)
+            
+            logger.debug(f"Installing dependency: {' '.join(cmd)}")
+            
+            # Run pip install
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=300  # 5 minutes timeout
+            )
+            
+            if result.returncode == 0:
+                logger.debug(f"Successfully installed {dependency}")
+                return True
+            else:
+                logger.error(f"Failed to install {dependency}: {result.stderr}")
+                return False
+                
+        except subprocess.TimeoutExpired:
+            logger.error(f"Timeout while installing {dependency}")
+            return False
+        except Exception as e:
+            logger.error(f"Error installing {dependency}: {e}")
+            return False
+    
+    def verify_installation(self, dependencies: List[str]) -> Tuple[bool, List[str]]:
+        """
+        Verify that dependencies are properly installed.
+        
+        Args:
+            dependencies: List of dependencies to verify
+            
+        Returns:
+            Tuple of (all_verified, failed_verifications)
+        """
+        if not dependencies:
+            return True, []
+        
+        failed_verifications = []
+        
+        for dep in dependencies:
+            if not self._is_dependency_satisfied(dep):
+                failed_verifications.append(dep)
+        
+        all_verified = len(failed_verifications) == 0
+        return all_verified, failed_verifications
+    
+    def get_dependency_info(self, dependency: str) -> Dict[str, Any]:
+        """
+        Get information about a dependency.
+        
+        Args:
+            dependency: Dependency name
+            
+        Returns:
+            Dictionary with dependency information
+        """
+        info = {
+            "name": dependency,
+            "installed": False,
+            "version": None,
+            "importable": False
+        }
+        
+        # Check if it's installed
+        try:
+            dist = pkg_resources.get_distribution(dependency)
+            info["installed"] = True
+            info["version"] = dist.version
+        except pkg_resources.DistributionNotFound:
+            pass
+        
+        # Check if it's importable
+        try:
+            importlib.import_module(dependency)
+            info["importable"] = True
+        except ImportError:
+            pass
+        
+        return info
+    
+    def list_installed_dependencies(self) -> Dict[str, str]:
+        """
+        Get list of all installed packages.
+        
+        Returns:
+            Dictionary mapping package names to versions
+        """
+        return self._installed_packages.copy()
+
+
+# Global instance
+dependency_manager = DependencyManager() 

mcp_proxy_adapter/commands/echo_command.py

@@ -0,0 +1,81 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Echo command for testing purposes.
+"""
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.commands.result import SuccessResult
+
+
+class EchoCommandResult(SuccessResult):
+    """Result for echo command."""
+    
+    def __init__(self, message: str, timestamp: Optional[str] = None):
+        data = {"message": message}
+        if timestamp:
+            data["timestamp"] = timestamp
+        super().__init__(data=data, message=message)
+    
+    @classmethod
+    def get_schema(cls) -> Dict[str, Any]:
+        """Get JSON schema for result."""
+        return {
+            "type": "object",
+            "properties": {
+                "success": {"type": "boolean"},
+                "data": {
+                    "type": "object",
+                    "properties": {
+                        "message": {"type": "string"},
+                        "timestamp": {"type": "string", "nullable": True}
+                    }
+                },
+                "message": {"type": "string"}
+            },
+            "required": ["success", "data"]
+        }
+
+
+class EchoCommand(Command):
+    """Echo command for testing purposes."""
+    
+    name = "echo"
+    version = "1.0.0"
+    descr = "Echo command for testing"
+    category = "testing"
+    author = "Vasiliy Zdanovskiy"
+    email = "vasilyvz@gmail.com"
+    result_class = EchoCommandResult
+    
+    async def execute(self, **kwargs) -> EchoCommandResult:
+        """Execute echo command."""
+        message = kwargs.get("message", "Hello, World!")
+        timestamp = kwargs.get("timestamp")
+        
+        # Simulate some processing time
+        await asyncio.sleep(0.001)
+        
+        return EchoCommandResult(message=message, timestamp=timestamp)
+    
+    def get_schema(self) -> Dict[str, Any]:
+        """Get command schema."""
+        return {
+            "type": "object",
+            "properties": {
+                "message": {
+                    "type": "string",
+                    "description": "Message to echo",
+                    "default": "Hello, World!"
+                },
+                "timestamp": {
+                    "type": "string",
+                    "description": "Optional timestamp",
+                    "nullable": True
+                }
+            }
+        }

mcp_proxy_adapter/commands/health_command.py

@@ -12,6 +12,7 @@ from typing import Dict, Any, Optional
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
 from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.core.proxy_registration import get_proxy_registration_status
 
 
 class HealthResult(SuccessResult):
@@ -117,6 +118,12 @@ class HealthCommand(Command):
                 },
                 "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")
                 }
             }
         )

mcp_proxy_adapter/commands/help_command.py

@@ -46,13 +46,15 @@ class HelpResult(CommandResult):
             if self.command_info is not None:
                 logger.debug(f"HelpResult.to_dict: returning command_info for {self.command_info.get('name', 'unknown')}")
                 # Делаем безопасное получение всех полей с дефолтными значениями
+                metadata = self.command_info.get("metadata", {})
+                schema = self.command_info.get("schema", {})
                 return {
                     "cmdname": self.command_info.get("name", "unknown"),
                     "info": {
-                        "description": self.command_info.get("description", ""),
-                        "summary": self.command_info.get("summary", ""),
-                        "params": self.command_info.get("params", {}),
-                        "examples": self.command_info.get("examples", [])
+                        "description": metadata.get("description", ""),
+                        "summary": metadata.get("summary", ""),
+                        "params": schema.get("properties", {}),
+                        "examples": metadata.get("examples", [])
                     }
                 }
 
@@ -190,14 +192,16 @@ class HelpCommand(Command):
             if cmdname is not None and cmdname != "":
                 logger.debug(f"Обработка запроса для конкретной команды: {cmdname}")
                 try:
-                    # Get command metadata from registry
-                    command_metadata = registry.get_command_metadata(cmdname)
+                    # Get command info from registry
+                    command_info = registry.get_command_info(cmdname)
+                    if command_info is None:
+                        raise NotFoundError(f"Command '{cmdname}' not found")
                     logger.debug(f"Получены метаданные для команды {cmdname}")
-                    return HelpResult(command_info=command_metadata)
+                    return HelpResult(command_info=command_info)
                 except NotFoundError:
                     logger.warning(f"Команда '{cmdname}' не найдена")
                     # Получаем список всех команд
-                    all_commands = list(registry.get_all_metadata().keys())
+                    all_commands = list(registry.get_all_commands().keys())
                     if all_commands:
                         example_cmd = all_commands[0]
                         example = {
@@ -218,9 +222,9 @@ class HelpCommand(Command):
             # Otherwise, return information about all available commands
             logger.debug("Обработка запроса для всех команд")
 
-            # Get metadata for all commands
-            all_metadata = registry.get_all_metadata()
-            logger.debug(f"Получены метаданные для {len(all_metadata)} команд")
+            # Get info for all commands
+            all_commands_info = registry.get_all_commands_info()
+            logger.debug(f"Получены метаданные для {len(all_commands_info.get('commands', {}))} команд")
 
             # Prepare response format with tool metadata
             result = {
@@ -240,17 +244,20 @@ class HelpCommand(Command):
             }
 
             # Add brief information about commands
-            for name, metadata in all_metadata.items():
+            commands_data = all_commands_info.get("commands", {})
+            for name, command_info in commands_data.items():
                 try:
                     logger.debug(f"Обработка метаданных команды {name}")
                     # Безопасное получение параметров с проверкой на наличие ключей
+                    metadata = command_info.get("metadata", {})
+                    schema = command_info.get("schema", {})
                     result["commands"][name] = {
                         "summary": metadata.get("summary", ""),
-                        "params_count": len(metadata.get("params", {}))
+                        "params_count": len(schema.get("properties", {}))
                     }
                 except Exception as e:
                     logger.error(f"Ошибка при обработке метаданных команды {name}: {e}")
-                    logger.debug(f"Метаданные команды {name}: {metadata}")
+                    logger.debug(f"Метаданные команды {name}: {command_info}")
                     # Пропускаем проблемную команду
                     continue