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

mcp_proxy_adapter/commands/catalog/catalog_syncer.py

@@ -0,0 +1,149 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Catalog synchronization utilities for MCP Proxy Adapter.
+"""
+
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from packaging import version as pkg_version
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .command_catalog import CommandCatalog
+from .catalog_loader import CatalogLoader
+from .dependency_manager import DependencyManager
+
+# Try to import requests, but don't fail if not available
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+
+
+class CatalogSyncer:
+    """Synchronizer for command catalogs."""
+
+    def __init__(self, catalog_dir: str):
+        """
+        Initialize catalog syncer.
+
+        Args:
+            catalog_dir: Directory for catalog storage
+        """
+        self.catalog_dir = Path(catalog_dir)
+        self.logger = get_global_logger()
+        self.loader = CatalogLoader()
+        self.dependency_manager = DependencyManager()
+
+
+    def _should_download_command(self, command_name: str, server_cmd: CommandCatalog) -> bool:
+        """
+        Check if command should be downloaded.
+
+        Args:
+            command_name: Name of the command
+            server_cmd: Server command catalog entry
+
+        Returns:
+            True if command should be downloaded, False otherwise
+        """
+        # Check if command exists locally
+        local_file = self.catalog_dir / f"{command_name}.py"
+        if not local_file.exists():
+            return True
+
+        # Check version
+        try:
+            local_version = self._get_local_version(command_name)
+            if local_version:
+                return pkg_version.parse(server_cmd.version) > pkg_version.parse(local_version)
+        except Exception as e:
+            self.logger.warning(f"Failed to compare versions for {command_name}: {e}")
+
+        return True
+
+    def _download_command(self, command_name: str, server_cmd: CommandCatalog) -> bool:
+        """
+        Download command from server.
+
+        Args:
+            command_name: Name of the command
+            server_cmd: Server command catalog entry
+
+        Returns:
+            True if download successful, False otherwise
+        """
+        if not REQUESTS_AVAILABLE:
+            self.logger.error("requests library not available, cannot download command")
+            return False
+
+        try:
+            # Download command file
+            response = requests.get(server_cmd.source_url, timeout=30)
+            response.raise_for_status()
+
+            # Save to local file
+            local_file = self.catalog_dir / f"{command_name}.py"
+            with open(local_file, 'w', encoding='utf-8') as f:
+                f.write(response.text)
+
+            # Update local catalog
+            server_cmd.file_path = str(local_file)
+            self._update_local_catalog(command_name, server_cmd)
+
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to download command {command_name}: {e}")
+            return False
+
+    def _get_local_version(self, command_name: str) -> Optional[str]:
+        """
+        Get local version of command.
+
+        Args:
+            command_name: Name of the command
+
+        Returns:
+            Local version string or None
+        """
+        try:
+            local_file = self.catalog_dir / f"{command_name}.py"
+            if local_file.exists():
+                with open(local_file, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                # Extract version from file content
+                for line in content.split('\n'):
+                    if line.strip().startswith('__version__'):
+                        return line.split('=')[1].strip().strip('"\'')
+        except Exception:
+            pass
+        
+        return None
+
+    def _update_local_catalog(self, command_name: str, command_catalog: CommandCatalog) -> None:
+        """
+        Update local catalog with command information.
+
+        Args:
+            command_name: Name of the command
+            command_catalog: Command catalog entry
+        """
+        try:
+            catalog_file = self.catalog_dir / "catalog.json"
+            if catalog_file.exists():
+                with open(catalog_file, 'r', encoding='utf-8') as f:
+                    catalog_data = json.load(f)
+            else:
+                catalog_data = {}
+
+            catalog_data[command_name] = command_catalog.to_dict()
+
+            with open(catalog_file, 'w', encoding='utf-8') as f:
+                json.dump(catalog_data, f, indent=2, ensure_ascii=False)
+
+        except Exception as e:
+            self.logger.error(f"Failed to update local catalog for {command_name}: {e}")

mcp_proxy_adapter/commands/catalog/command_catalog.py

@@ -0,0 +1,43 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Command catalog data model for MCP Proxy Adapter.
+"""
+
+from typing import Dict, List, Optional, Any
+
+
+class CommandCatalog:
+    """
+    Represents a command in the catalog with metadata.
+    """
+
+    def __init__(
+        self, name: str, version: str, source_url: str, file_path: Optional[str] = None
+    ):
+        """
+        Initialize command catalog entry.
+
+        Args:
+            name: Command name
+            version: Command version
+            source_url: Source URL for the command
+            file_path: Local file path (optional)
+        """
+        self.name = name
+        self.version = version
+        self.source_url = source_url
+        self.file_path = file_path
+        self.metadata: Dict[str, Any] = {}
+
+        # Standard metadata fields
+        self.plugin: Optional[str] = None
+        self.descr: Optional[str] = None
+        self.category: Optional[str] = None
+        self.author: Optional[str] = None
+        self.email: Optional[str] = None
+        self.depends: Optional[List[str]] = None  # New field for dependencies
+
+
+    @classmethod

mcp_proxy_adapter/commands/catalog/dependency_manager.py

@@ -0,0 +1,37 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Dependency management for command catalogs.
+"""
+
+import subprocess
+import sys
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class DependencyManager:
+    """Manager for command dependencies."""
+
+    def __init__(self):
+        """Initialize dependency manager."""
+        self.logger = get_global_logger()
+
+
+
+    def _is_package_installed(self, package_name: str) -> bool:
+        """
+        Check if a package is installed.
+
+        Args:
+            package_name: Name of the package to check
+
+        Returns:
+            True if package is installed, False otherwise
+        """
+        try:
+            __import__(package_name)
+            return True
+        except ImportError:
+            return False

mcp_proxy_adapter/commands/catalog_manager.py

@@ -0,0 +1,97 @@
+"""
+Command catalog management system.
+
+This module handles the command catalog, including:
+- Loading commands from remote plugin servers
+- Version comparison and updates
+- Local command storage and management
+- Automatic dependency installation
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from typing import Dict, List, Optional, Any
+
+from .catalog import CommandCatalog, CatalogManager
+
+
+# Global catalog manager instance
+_catalog_manager: Optional[CatalogManager] = None
+
+
+def get_catalog_manager() -> CatalogManager:
+    """
+    Get the global catalog manager instance.
+
+    Returns:
+        Catalog manager instance
+    """
+    global _catalog_manager
+    if _catalog_manager is None:
+        from mcp_proxy_adapter.config import config
+        catalog_dir = config.get("catalog", {}).get("directory", "catalog")
+        _catalog_manager = CatalogManager(catalog_dir)
+    return _catalog_manager
+
+
+def get_catalog_from_server(server_url: str) -> Dict[str, CommandCatalog]:
+    """
+    Get catalog from remote server.
+
+    Args:
+        server_url: Server URL to load catalog from
+
+    Returns:
+        Dictionary of command catalogs
+    """
+    return get_catalog_manager().get_catalog_from_server(server_url)
+
+
+def sync_with_servers(server_urls: List[str]) -> Dict[str, Any]:
+    """
+    Synchronize catalog with remote servers.
+
+    Args:
+        server_urls: List of server URLs to sync with
+
+    Returns:
+        Dictionary with sync results
+    """
+    return get_catalog_manager().sync_with_servers(server_urls)
+
+
+def get_local_commands() -> List[str]:
+    """
+    Get list of locally available commands.
+
+    Returns:
+        List of command names
+    """
+    return get_catalog_manager().get_local_commands()
+
+
+def get_command_info(command_name: str) -> Optional[CommandCatalog]:
+    """
+    Get information about a specific command.
+
+    Args:
+        command_name: Name of the command
+
+    Returns:
+        Command catalog entry or None if not found
+    """
+    return get_catalog_manager().get_command_info(command_name)
+
+
+def remove_command(command_name: str) -> bool:
+    """
+    Remove command from catalog.
+
+    Args:
+        command_name: Name of the command to remove
+
+    Returns:
+        True if successful, False otherwise
+    """
+    return get_catalog_manager().remove_command(command_name)