mcp-proxy-adapter 6.9.28__py3-none-any.whl → 6.9.30__py3-none-any.whl

mcp_proxy_adapter/commands/catalog/catalog_manager.py

@@ -0,0 +1,122 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main catalog manager for MCP Proxy Adapter.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from packaging import version as pkg_version
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.commands.dependency_manager import dependency_manager
+from mcp_proxy_adapter.config import config
+from .command_catalog import CommandCatalog
+from .catalog_loader import CatalogLoader
+from .catalog_syncer import CatalogSyncer
+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
+    get_global_logger().warning(
+        "requests library not available, HTTP/HTTPS functionality will be limited"
+    )
+
+
+class CatalogManager:
+    """
+    Manager for command catalog operations.
+
+    Handles loading, syncing, and managing command catalogs from various sources.
+    """
+
+    def __init__(self, catalog_dir: str):
+        """
+        Initialize catalog manager.
+
+        Args:
+            catalog_dir: Directory for catalog storage
+        """
+        self.catalog_dir = Path(catalog_dir)
+        self.logger = get_global_logger()
+        
+        # Initialize components
+        self.loader = CatalogLoader()
+        self.syncer = CatalogSyncer(catalog_dir)
+        self.dependency_manager = DependencyManager()
+        
+        # Load existing catalog
+        self.catalog: Dict[str, CommandCatalog] = {}
+        self._load_catalog()
+
+    def _load_catalog(self) -> None:
+        """Load catalog from local storage."""
+        catalog_file = self.catalog_dir / "catalog.json"
+        self.catalog = self.loader.load_catalog_from_file(catalog_file)
+
+    def _save_catalog(self) -> None:
+        """Save catalog to local storage."""
+        catalog_file = self.catalog_dir / "catalog.json"
+        self.loader.save_catalog_to_file(self.catalog, catalog_file)
+
+
+    def sync_with_servers(self, 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 self.syncer.sync_with_servers(server_urls)
+
+
+
+
+
+    def _extract_metadata_from_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        Extract metadata from command file.
+
+        Args:
+            file_path: Path to command file
+
+        Returns:
+            Dictionary of extracted metadata
+        """
+        metadata = {}
+        
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Extract basic metadata
+            for line in content.split('\n'):
+                line = line.strip()
+                if line.startswith('__version__'):
+                    metadata['version'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__author__'):
+                    metadata['author'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__description__'):
+                    metadata['description'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__category__'):
+                    metadata['category'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__email__'):
+                    metadata['email'] = line.split('=')[1].strip().strip('"\'')
+                elif line.startswith('__depends__'):
+                    deps_str = line.split('=')[1].strip().strip('[]"\'')
+                    if deps_str:
+                        metadata['depends'] = [dep.strip().strip('"\'') for dep in deps_str.split(',')]
+
+        except Exception as e:
+            self.logger.error(f"Failed to extract metadata from {file_path}: {e}")
+
+        return metadata

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