mcp-proxy-adapter 6.9.16__py3-none-any.whl → 6.9.18__py3-none-any.whl

mcp_proxy_adapter/commands/base.py

@@ -16,7 +16,7 @@ from mcp_proxy_adapter.core.errors import (
     NotFoundError,
     ValidationError,
 )
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 T = TypeVar("T", bound=CommandResult)
@@ -131,7 +131,7 @@ class Command(ABC):
 
             # Log warning about invalid parameters
             if invalid_params:
-                logger.warning(
+                get_global_logger().warning(
                     f"Command {self.__class__.__name__} received invalid parameters: {invalid_params}. "
                     f"Allowed parameters: {list(allowed_properties)}"
                 )
@@ -168,7 +168,7 @@ class Command(ABC):
         context = kwargs.pop("context", {}) if "context" in kwargs else {}
 
         try:
-            logger.debug(f"Running command {cls.__name__} with params: {kwargs}")
+            get_global_logger().debug(f"Running command {cls.__name__} with params: {kwargs}")
 
             # Import registry here to avoid circular imports
             from mcp_proxy_adapter.commands.command_registry import registry
@@ -197,31 +197,31 @@ class Command(ABC):
             # Execute command with validated parameters and context
             result = await command.execute(**validated_params, context=context)
 
-            logger.debug(f"Command {cls.__name__} executed successfully")
+            get_global_logger().debug(f"Command {cls.__name__} executed successfully")
             return result
         except ValidationError as e:
             # Ошибка валидации параметров
-            logger.error(f"Validation error in command {cls.__name__}: {e}")
+            get_global_logger().error(f"Validation error in command {cls.__name__}: {e}")
             return ErrorResult(message=str(e), code=e.code, details=e.data)
         except InvalidParamsError as e:
             # Ошибка в параметрах команды
-            logger.error(f"Invalid parameters error in command {cls.__name__}: {e}")
+            get_global_logger().error(f"Invalid parameters error in command {cls.__name__}: {e}")
             return ErrorResult(message=str(e), code=e.code, details=e.data)
         except NotFoundError as e:
             # Ресурс не найден
-            logger.error(f"Resource not found error in command {cls.__name__}: {e}")
+            get_global_logger().error(f"Resource not found error in command {cls.__name__}: {e}")
             return ErrorResult(message=str(e), code=e.code, details=e.data)
         except TimeoutError as e:
             # Превышено время ожидания
-            logger.error(f"Timeout error in command {cls.__name__}: {e}")
+            get_global_logger().error(f"Timeout error in command {cls.__name__}: {e}")
             return ErrorResult(message=str(e), code=e.code, details=e.data)
         except CommandError as e:
             # Ошибка выполнения команды
-            logger.error(f"Command error in {cls.__name__}: {e}")
+            get_global_logger().error(f"Command error in {cls.__name__}: {e}")
             return ErrorResult(message=str(e), code=e.code, details=e.data)
         except Exception as e:
             # Непредвиденная ошибка
-            logger.exception(f"Unexpected error executing command {cls.__name__}: {e}")
+            get_global_logger().exception(f"Unexpected error executing command {cls.__name__}: {e}")
             internal_error = InternalError(f"Command execution error: {str(e)}")
             return ErrorResult(
                 message=internal_error.message,

mcp_proxy_adapter/commands/builtin_commands.py

@@ -23,7 +23,7 @@ from mcp_proxy_adapter.commands.proxy_registration_command import (
 )
 from mcp_proxy_adapter.commands.echo_command import EchoCommand
 from mcp_proxy_adapter.commands.role_test_command import RoleTestCommand
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 def register_builtin_commands() -> int:
@@ -33,7 +33,7 @@ def register_builtin_commands() -> int:
     Returns:
         Number of built-in commands registered.
     """
-    logger.debug("Registering built-in framework commands...")
+    get_global_logger().debug("Registering built-in framework commands...")
 
     builtin_commands = [
         HelpCommand,
@@ -63,7 +63,7 @@ def register_builtin_commands() -> int:
 
             # Check if command already exists (should not happen for built-in)
             if registry.command_exists(command_name):
-                logger.warning(
+                get_global_logger().warning(
                     f"Built-in command '{command_name}' already exists, skipping"
                 )
                 continue
@@ -71,14 +71,14 @@ def register_builtin_commands() -> int:
             # Register the command
             registry.register_builtin(command_class)
             registered_count += 1
-            logger.debug(f"Registered built-in command: {command_name}")
+            get_global_logger().debug(f"Registered built-in command: {command_name}")
 
         except Exception as e:
-            logger.error(
+            get_global_logger().error(
                 f"Failed to register built-in command {command_class.__name__}: {e}"
             )
 
-    logger.info(f"Registered {registered_count} built-in framework commands")
+    get_global_logger().info(f"Registered {registered_count} built-in framework commands")
     return registered_count
 
 

mcp_proxy_adapter/commands/catalog_manager.py

@@ -16,7 +16,7 @@ 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 logger
+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
 
@@ -27,7 +27,7 @@ try:
     REQUESTS_AVAILABLE = True
 except ImportError:
     REQUESTS_AVAILABLE = False
-    logger.warning(
+    get_global_logger().warning(
         "requests library not available, HTTP/HTTPS functionality will be limited"
     )
 
@@ -128,13 +128,13 @@ class CatalogManager:
 
     def _load_catalog(self) -> None:
         """DEPRECATED: Catalog is not cached locally."""
-        logger.warning(
+        get_global_logger().warning(
             "_load_catalog() is deprecated - catalog is always fetched fresh from servers"
         )
 
     def _save_catalog(self) -> None:
         """DEPRECATED: Catalog is not cached locally."""
-        logger.warning(
+        get_global_logger().warning(
             "_save_catalog() is deprecated - catalog is always fetched fresh from servers"
         )
 
@@ -152,7 +152,7 @@ class CatalogManager:
             Dictionary of parsed CommandCatalog objects
         """
         if not isinstance(server_catalog, dict):
-            logger.error(
+            get_global_logger().error(
                 f"Invalid catalog format: expected dict, got {type(server_catalog)}"
             )
             return {}
@@ -165,7 +165,7 @@ class CatalogManager:
             commands_data = server_catalog.get("commands", [])
 
             if not isinstance(commands_data, list):
-                logger.error(
+                get_global_logger().error(
                     f"Invalid commands format: expected list, got {type(commands_data)}"
                 )
                 return {}
@@ -173,24 +173,24 @@ class CatalogManager:
             for cmd_data in commands_data:
                 try:
                     if not isinstance(cmd_data, dict):
-                        logger.warning(
+                        get_global_logger().warning(
                             f"Skipping invalid command data: expected dict, got {type(cmd_data)}"
                         )
                         continue
 
                     name = cmd_data.get("name")
                     if not name or not isinstance(name, str):
-                        logger.warning(f"Skipping command without valid name")
+                        get_global_logger().warning(f"Skipping command without valid name")
                         continue
 
                     version = cmd_data.get("version", "0.1")
                     if not isinstance(version, str):
-                        logger.warning(f"Invalid version format for {name}: {version}")
+                        get_global_logger().warning(f"Invalid version format for {name}: {version}")
                         version = "0.1"
 
                     source_url = cmd_data.get("source_url", "")
                     if not isinstance(source_url, str):
-                        logger.warning(f"Invalid source_url for {name}: {source_url}")
+                        get_global_logger().warning(f"Invalid source_url for {name}: {source_url}")
                         source_url = ""
 
                     catalog = CommandCatalog(
@@ -208,14 +208,14 @@ class CatalogManager:
                     result[name] = catalog
 
                 except Exception as e:
-                    logger.error(f"Error processing command data: {e}")
+                    get_global_logger().error(f"Error processing command data: {e}")
                     continue
         else:
             # New format: {"id": {"plugin": "...", "descr": "...", ...}}
             for command_id, cmd_data in server_catalog.items():
                 try:
                     if not isinstance(cmd_data, dict):
-                        logger.warning(
+                        get_global_logger().warning(
                             f"Skipping invalid command data for {command_id}: expected dict, got {type(cmd_data)}"
                         )
                         continue
@@ -223,14 +223,14 @@ class CatalogManager:
                     # Use command_id as name if name is not provided
                     name = cmd_data.get("name", command_id)
                     if not isinstance(name, str):
-                        logger.warning(
+                        get_global_logger().warning(
                             f"Skipping command {command_id} without valid name"
                         )
                         continue
 
                     version = cmd_data.get("version", "0.1")
                     if not isinstance(version, str):
-                        logger.warning(f"Invalid version format for {name}: {version}")
+                        get_global_logger().warning(f"Invalid version format for {name}: {version}")
                         version = "0.1"
 
                     # For new format, construct source_url from server_url and plugin filename
@@ -269,7 +269,7 @@ class CatalogManager:
                     result[name] = catalog
 
                 except Exception as e:
-                    logger.error(f"Error processing command {command_id}: {e}")
+                    get_global_logger().error(f"Error processing command {command_id}: {e}")
                     continue
 
         return result
@@ -285,7 +285,7 @@ class CatalogManager:
             Dictionary of commands available on the server
         """
         if not REQUESTS_AVAILABLE:
-            logger.error(
+            get_global_logger().error(
                 "requests library not available, cannot fetch catalog from remote server"
             )
             return {}
@@ -293,55 +293,55 @@ class CatalogManager:
         try:
             # Validate URL format
             if not server_url.startswith(("http://", "https://")):
-                logger.error(f"Invalid server URL format: {server_url}")
+                get_global_logger().error(f"Invalid server URL format: {server_url}")
                 return {}
 
             # Fetch catalog from server (use URL as-is)
-            logger.debug(f"Fetching catalog from: {server_url}")
+            get_global_logger().debug(f"Fetching catalog from: {server_url}")
 
             response = requests.get(server_url, timeout=30)
             response.raise_for_status()
 
             # Validate response content
             if not response.content:
-                logger.error(f"Empty response from {server_url}")
+                get_global_logger().error(f"Empty response from {server_url}")
                 return {}
 
             try:
                 server_catalog = response.json()
             except json.JSONDecodeError as e:
-                logger.error(f"Invalid JSON response from {server_url}: {e}")
+                get_global_logger().error(f"Invalid JSON response from {server_url}: {e}")
                 return {}
 
             if not isinstance(server_catalog, dict):
-                logger.error(
+                get_global_logger().error(
                     f"Invalid catalog format from {server_url}: expected dict, got {type(server_catalog)}"
                 )
                 return {}
 
             result = self._parse_catalog_data(server_catalog, server_url)
 
-            logger.info(
+            get_global_logger().info(
                 f"Successfully fetched catalog from {server_url}: {len(result)} commands"
             )
             return result
 
         except requests.exceptions.Timeout:
-            logger.error(f"Timeout while fetching catalog from {server_url}")
+            get_global_logger().error(f"Timeout while fetching catalog from {server_url}")
             return {}
         except requests.exceptions.ConnectionError as e:
-            logger.error(
+            get_global_logger().error(
                 f"Connection error while fetching catalog from {server_url}: {e}"
             )
             return {}
         except requests.exceptions.HTTPError as e:
-            logger.error(f"HTTP error while fetching catalog from {server_url}: {e}")
+            get_global_logger().error(f"HTTP error while fetching catalog from {server_url}: {e}")
             return {}
         except requests.exceptions.RequestException as e:
-            logger.error(f"Request error while fetching catalog from {server_url}: {e}")
+            get_global_logger().error(f"Request error while fetching catalog from {server_url}: {e}")
             return {}
         except Exception as e:
-            logger.error(
+            get_global_logger().error(
                 f"Unexpected error while fetching catalog from {server_url}: {e}"
             )
             return {}
@@ -367,13 +367,13 @@ class CatalogManager:
         )
 
         if not all_satisfied:
-            logger.warning(
+            get_global_logger().warning(
                 f"Command {command_name} has missing dependencies: {missing_deps}"
             )
-            logger.info(f"Installed dependencies: {installed_deps}")
+            get_global_logger().info(f"Installed dependencies: {installed_deps}")
             return False
 
-        logger.debug(
+        get_global_logger().debug(
             f"All dependencies satisfied for command {command_name}: {server_cmd.depends}"
         )
         return True
@@ -405,22 +405,22 @@ class CatalogManager:
         )
 
         if all_satisfied:
-            logger.info(
+            get_global_logger().info(
                 f"All dependencies already satisfied for {command_name}: {server_cmd.depends}"
             )
             return True
 
         if not auto_install:
-            logger.warning(
+            get_global_logger().warning(
                 f"Command {command_name} has missing dependencies: {missing_deps}"
             )
-            logger.info(
+            get_global_logger().info(
                 f"Auto-install is disabled. Please install manually: pip install {' '.join(missing_deps)}"
             )
             return False
 
         # Try to install missing dependencies
-        logger.info(
+        get_global_logger().info(
             f"Installing missing dependencies for {command_name}: {missing_deps}"
         )
 
@@ -429,7 +429,7 @@ class CatalogManager:
         )
 
         if success:
-            logger.info(
+            get_global_logger().info(
                 f"Successfully installed all dependencies for {command_name}: {installed_deps}"
             )
 
@@ -438,18 +438,18 @@ class CatalogManager:
                 server_cmd.depends
             )
             if all_verified:
-                logger.info(f"All dependencies verified for {command_name}")
+                get_global_logger().info(f"All dependencies verified for {command_name}")
                 return True
             else:
-                logger.error(
+                get_global_logger().error(
                     f"Failed to verify dependencies for {command_name}: {failed_verifications}"
                 )
                 return False
         else:
-            logger.error(
+            get_global_logger().error(
                 f"Failed to install dependencies for {command_name}: {failed_deps}"
             )
-            logger.error(
+            get_global_logger().error(
                 f"Please install manually: pip install {' '.join(failed_deps)}"
             )
             return False
@@ -471,7 +471,7 @@ class CatalogManager:
 
         # If local file doesn't exist, download
         if not local_file.exists():
-            logger.info(f"New command found: {command_name} v{server_cmd.version}")
+            get_global_logger().info(f"New command found: {command_name} v{server_cmd.version}")
             return True
 
         # Try to extract version from local file
@@ -484,18 +484,18 @@ class CatalogManager:
             local_ver = pkg_version.parse(local_version)
 
             if server_ver > local_ver:
-                logger.info(
+                get_global_logger().info(
                     f"Newer version available for {command_name}: {local_ver} -> {server_ver}"
                 )
                 return True
             else:
-                logger.debug(
+                get_global_logger().debug(
                     f"Local version {local_ver} is same or newer than server version {server_ver}"
                 )
                 return False
 
         except Exception as e:
-            logger.warning(f"Failed to compare versions for {command_name}: {e}")
+            get_global_logger().warning(f"Failed to compare versions for {command_name}: {e}")
             # If version comparison fails, download anyway
             return True
 
@@ -512,7 +512,7 @@ class CatalogManager:
         Returns:
             True if command was downloaded, False otherwise
         """
-        logger.warning(
+        get_global_logger().warning(
             "update_command() is deprecated - always downloading fresh from server (use _download_command directly)"
         )
 
@@ -534,14 +534,14 @@ class CatalogManager:
             True if download successful, False otherwise
         """
         if not REQUESTS_AVAILABLE:
-            logger.error(
+            get_global_logger().error(
                 "requests library not available, cannot download command from remote server"
             )
             return False
 
         # Step 1: Check and install dependencies
         if not self._install_dependencies(command_name, server_cmd):
-            logger.error(
+            get_global_logger().error(
                 f"Cannot download {command_name}: failed to install dependencies"
             )
             return False
@@ -549,20 +549,20 @@ class CatalogManager:
         try:
             # Validate source URL
             if not server_cmd.source_url.startswith(("http://", "https://")):
-                logger.error(
+                get_global_logger().error(
                     f"Invalid source URL for {command_name}: {server_cmd.source_url}"
                 )
                 return False
 
             # Download command file (use source_url as-is)
-            logger.debug(f"Downloading {command_name} from: {server_cmd.source_url}")
+            get_global_logger().debug(f"Downloading {command_name} from: {server_cmd.source_url}")
 
             response = requests.get(server_cmd.source_url, timeout=30)
             response.raise_for_status()
 
             # Validate response content
             if not response.content:
-                logger.error(
+                get_global_logger().error(
                     f"Empty response when downloading {command_name} from {server_cmd.source_url}"
                 )
                 return False
@@ -570,7 +570,7 @@ class CatalogManager:
             # Validate Python file content
             content = response.text
             if not content.strip():
-                logger.error(
+                get_global_logger().error(
                     f"Empty file content for {command_name} from {server_cmd.source_url}"
                 )
                 return False
@@ -587,7 +587,7 @@ class CatalogManager:
                     for keyword in ["class", "def", "import", "from", '"""', "'''", "#"]
                 )
             ):
-                logger.warning(
+                get_global_logger().warning(
                     f"File {command_name}_command.py doesn't look like a valid Python file"
                 )
 
@@ -616,12 +616,12 @@ class CatalogManager:
                             hasattr(module, attr) and attr.endswith("Command")
                             for attr in dir(module)
                         ):
-                            logger.warning(
+                            get_global_logger().warning(
                                 f"Module {command_name}_command.py doesn't contain a Command class"
                             )
 
                 except Exception as e:
-                    logger.error(f"Failed to validate {command_name}_command.py: {e}")
+                    get_global_logger().error(f"Failed to validate {command_name}_command.py: {e}")
                     return False
 
                 # If validation passed, move to final location
@@ -659,15 +659,15 @@ class CatalogManager:
                         # Update full metadata
                         server_cmd.metadata.update(metadata)
 
-                        logger.debug(
+                        get_global_logger().debug(
                             f"Extracted metadata for {command_name}: {metadata}"
                         )
                 except Exception as e:
-                    logger.warning(
+                    get_global_logger().warning(
                         f"Failed to extract metadata from {command_name}: {e}"
                     )
 
-                logger.info(
+                get_global_logger().info(
                     f"Successfully downloaded and validated {command_name} v{server_cmd.version}"
                 )
                 return True
@@ -678,35 +678,35 @@ class CatalogManager:
                     try:
                         os.unlink(temp_file.name)
                     except Exception as e:
-                        logger.warning(
+                        get_global_logger().warning(
                             f"Failed to clean up temporary file {temp_file.name}: {e}"
                         )
 
         except requests.exceptions.Timeout:
-            logger.error(
+            get_global_logger().error(
                 f"Timeout while downloading {command_name} from {server_cmd.source_url}"
             )
             return False
         except requests.exceptions.ConnectionError as e:
-            logger.error(
+            get_global_logger().error(
                 f"Connection error while downloading {command_name} from {server_cmd.source_url}: {e}"
             )
             return False
         except requests.exceptions.HTTPError as e:
-            logger.error(
+            get_global_logger().error(
                 f"HTTP error while downloading {command_name} from {server_cmd.source_url}: {e}"
             )
             return False
         except requests.exceptions.RequestException as e:
-            logger.error(
+            get_global_logger().error(
                 f"Request error while downloading {command_name} from {server_cmd.source_url}: {e}"
             )
             return False
         except OSError as e:
-            logger.error(f"File system error while downloading {command_name}: {e}")
+            get_global_logger().error(f"File system error while downloading {command_name}: {e}")
             return False
         except Exception as e:
-            logger.error(f"Unexpected error while downloading {command_name}: {e}")
+            get_global_logger().error(f"Unexpected error while downloading {command_name}: {e}")
             return False
 
     def sync_with_servers(self, server_urls: List[str]) -> Dict[str, Any]:
@@ -719,7 +719,7 @@ class CatalogManager:
         Returns:
             Dictionary with sync results
         """
-        logger.info(f"Loading fresh catalog from {len(server_urls)} servers")
+        get_global_logger().info(f"Loading fresh catalog from {len(server_urls)} servers")
 
         # Clear local catalog - always start fresh
         self.catalog = {}
@@ -750,16 +750,16 @@ class CatalogManager:
                             self.catalog[command_name] = server_cmd
                     else:
                         # Command already exists with same or newer version
-                        logger.debug(
+                        get_global_logger().debug(
                             f"Command {command_name} already exists with same or newer version"
                         )
 
             except Exception as e:
                 error_msg = f"Failed to sync with {server_url}: {e}"
                 results["errors"].append(error_msg)
-                logger.error(error_msg)
+                get_global_logger().error(error_msg)
 
-        logger.info(f"Fresh catalog loaded: {results}")
+        get_global_logger().info(f"Fresh catalog loaded: {results}")
         return results
 
     def get_local_commands(self) -> List[str]:
@@ -773,7 +773,7 @@ class CatalogManager:
         for file_path in self.commands_dir.glob("*_command.py"):
             commands.append(str(file_path))
 
-        logger.debug(
+        get_global_logger().debug(
             f"Found {len(commands)} local command files: {[Path(c).name for c in commands]}"
         )
         return commands
@@ -813,11 +813,11 @@ class CatalogManager:
             del self.catalog[command_name]
             self._save_catalog()
 
-            logger.info(f"Removed command: {command_name}")
+            get_global_logger().info(f"Removed command: {command_name}")
             return True
 
         except Exception as e:
-            logger.error(f"Failed to remove command {command_name}: {e}")
+            get_global_logger().error(f"Failed to remove command {command_name}: {e}")
             return False
 
     def extract_metadata_from_file(self, file_path: str) -> Dict[str, Any]:
@@ -909,11 +909,11 @@ class CatalogManager:
                         except json.JSONDecodeError:
                             continue
 
-            logger.debug(f"Extracted metadata from {file_path}: {metadata}")
+            get_global_logger().debug(f"Extracted metadata from {file_path}: {metadata}")
             return metadata
 
         except Exception as e:
-            logger.error(f"Failed to extract metadata from {file_path}: {e}")
+            get_global_logger().error(f"Failed to extract metadata from {file_path}: {e}")
             return {}
 
     def update_local_command_metadata(self, command_name: str) -> bool:
@@ -957,11 +957,11 @@ class CatalogManager:
                 # Save catalog
                 self._save_catalog()
 
-                logger.info(f"Updated metadata for {command_name}")
+                get_global_logger().info(f"Updated metadata for {command_name}")
                 return True
 
             return False
 
         except Exception as e:
-            logger.error(f"Failed to update metadata for {command_name}: {e}")
+            get_global_logger().error(f"Failed to update metadata for {command_name}: {e}")
             return False