pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/cli/error_handler.py

@@ -0,0 +1,151 @@
+import traceback
+from difflib import SequenceMatcher
+from typing import List, Optional, Tuple
+
+from pygeai import logger
+from pygeai.cli.commands import Command, Option
+from pygeai.core.utils.console import Console
+
+
+FUZZY_MATCH_THRESHOLD = 0.6
+MAX_FUZZY_SUGGESTIONS = 3
+
+
+class ExitCode:
+    SUCCESS = 0
+    USER_INPUT_ERROR = 1
+    MISSING_REQUIREMENT = 2
+    SERVICE_ERROR = 3
+    KEYBOARD_INTERRUPT = 130
+    UNEXPECTED_ERROR = 255
+
+
+class ErrorHandler:
+
+    @staticmethod
+    def format_error(
+        error_type: str, 
+        message: str, 
+        suggestion: Optional[str] = None, 
+        show_help: bool = True,
+        example: Optional[str] = None
+    ) -> str:
+        """
+        Formats an error message with optional suggestion and example.
+
+        :param error_type: str - Type of error (e.g., "Unknown Command").
+        :param message: str - The error message.
+        :param suggestion: Optional[str] - Suggested fix or next steps.
+        :param show_help: bool - Whether to show help command hint.
+        :param example: Optional[str] - Example of correct usage.
+        :return: str - Formatted error message.
+        """
+        output = f"ERROR [{error_type}]: {message}"
+        
+        if suggestion:
+            output += f"\n  → {suggestion}"
+        
+        if example:
+            output += f"\n\n  Example:\n    {example}"
+        
+        if show_help:
+            output += "\n\nRun 'geai help' for usage information."
+        
+        return output
+
+    @staticmethod
+    def find_similar_items(
+        item: str, 
+        available_items: List[str], 
+        threshold: float = FUZZY_MATCH_THRESHOLD
+    ) -> List[str]:
+        """
+        Finds similar items using fuzzy string matching.
+
+        :param item: str - The item to match against.
+        :param available_items: List[str] - List of available items.
+        :param threshold: float - Minimum similarity ratio (0.0 to 1.0).
+        :return: List[str] - List of similar items, up to MAX_FUZZY_SUGGESTIONS.
+        """
+        similarities: List[Tuple[str, float]] = []
+        for available in available_items:
+            ratio = SequenceMatcher(None, item.lower(), available.lower()).ratio()
+            if ratio >= threshold:
+                similarities.append((available, ratio))
+        
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return [item[0] for item in similarities[:MAX_FUZZY_SUGGESTIONS]]
+
+    @staticmethod
+    def get_available_commands(commands: List[Command]) -> List[str]:
+        all_identifiers = []
+        for cmd in commands:
+            all_identifiers.extend(cmd.identifiers)
+        return all_identifiers
+
+    @staticmethod
+    def get_available_options(options: List[Option]) -> List[str]:
+        all_identifiers = []
+        for opt in options:
+            all_identifiers.extend(opt.identifiers)
+        return all_identifiers
+
+    @staticmethod
+    def handle_unknown_command(command: str, available_commands: List[Command]) -> str:
+        cmd_identifiers = ErrorHandler.get_available_commands(available_commands)
+        similar = ErrorHandler.find_similar_items(command, cmd_identifiers)
+        
+        message = f"'{command}' is not a valid command."
+        
+        if similar:
+            suggestion = f"Did you mean: {', '.join(similar)}?"
+        else:
+            suggestion = f"Available commands: {', '.join(sorted(set([cmd.identifiers[0] for cmd in available_commands])))}"
+        
+        return ErrorHandler.format_error("Unknown Command", message, suggestion)
+
+    @staticmethod
+    def handle_unknown_option(option: str, available_options: List[Option]) -> str:
+        opt_identifiers = ErrorHandler.get_available_options(available_options)
+        similar = ErrorHandler.find_similar_items(option, opt_identifiers)
+        
+        message = f"'{option}' is not a valid option."
+        
+        if similar:
+            suggestion = f"Did you mean: {', '.join(similar)}?"
+        else:
+            suggestion = f"Available options: {', '.join(sorted(set([opt.identifiers[0] for opt in available_options])))}"
+        
+        return ErrorHandler.format_error("Unknown Option", message, suggestion)
+
+    @staticmethod
+    def handle_missing_requirement(requirement_message: str) -> str:
+        message = requirement_message
+        suggestion = "Please provide all required parameters."
+        return ErrorHandler.format_error("Missing Requirement", message, suggestion)
+
+    @staticmethod
+    def handle_invalid_agent(error_message: str) -> str:
+        message = f"Failed to retrieve or validate the agent.\n  Details: {error_message}"
+        suggestion = "Check your agent configuration and ensure the agent exists."
+        return ErrorHandler.format_error("Invalid Agent", message, suggestion)
+
+    @staticmethod
+    def handle_wrong_argument(error_message: str, usage: str) -> str:
+        Console.write_stderr(f"usage: {usage}")
+        message = error_message
+        suggestion = "Check the command syntax and try again."
+        return ErrorHandler.format_error("Invalid Argument", message, suggestion)
+
+    @staticmethod
+    def handle_keyboard_interrupt() -> str:
+        return "\n\nOperation cancelled by user."
+
+    @staticmethod
+    def handle_unexpected_error(exception: Exception) -> str:
+        logger.error(f"Unexpected error occurred: {exception}")
+        logger.error(traceback.format_exc())
+        
+        message = "An unexpected error occurred. This may be a bug."
+        suggestion = f"Please report this issue to geai-sdk@globant.com with the following details:\n  Error: {str(exception)}\n  Run with geai-dbg for more details."
+        return ErrorHandler.format_error("Critical Error", message, suggestion, show_help=False)

pygeai/cli/geai.py

@@ -1,37 +1,104 @@
 import sys
+import logging
+from typing import List, Optional
 
 from pygeai import logger
 from pygeai.cli.commands.base import base_commands, base_options
 from pygeai.cli.commands import ArgumentsEnum, Command
 from pygeai.cli.parsers import CommandParser
 from pygeai.cli.texts.help import CLI_USAGE
+from pygeai.cli.error_handler import ErrorHandler, ExitCode
 from pygeai.core.base.session import get_session
-from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequirementException, WrongArgumentError
-
-
-def main():
-    driver = CLIDriver()
-    return driver.main()
+from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequirementException, WrongArgumentError, \
+    InvalidAgentException
+from pygeai.core.utils.console import Console
+
+
+def setup_verbose_logging() -> None:
+    """
+    Configure verbose logging for the CLI.
+    
+    Sets up a console handler with DEBUG level logging and a formatted output
+    that includes timestamp, logger name, level, and message.
+    """
+    if logger.handlers:
+        for handler in logger.handlers:
+            if not isinstance(handler, logging.NullHandler):
+                return
+    
+    logger.setLevel(logging.DEBUG)
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setLevel(logging.DEBUG)
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    logger.propagate = False
+    logger.debug("Verbose mode enabled")
+
+
+def main() -> int:
+    """
+    Main entry point for the GEAI CLI application.
+
+    :return: int - Exit code indicating success or error.
+    """
+    try:
+        driver = CLIDriver()
+        return driver.main()
+    except MissingRequirementException as e:
+        error_msg = ErrorHandler.handle_missing_requirement(str(e))
+        Console.write_stderr(error_msg)
+        return ExitCode.MISSING_REQUIREMENT
 
 
 class CLIDriver:
-
-    def __init__(self, session=None):
+    """
+    Main CLI driver for the GEAI command-line interface.
+    
+    The CLIDriver orchestrates command parsing, execution, and error handling
+    for all GEAI CLI operations. It supports multi-profile session management
+    via the --alias flag and provides comprehensive error handling with
+    user-friendly messages.
+    """
+
+    def __init__(self, session=None, credentials_file=None) -> None:
         """
-        Sets session to be used while running the command, either with a specified alias,
-        environment variables or function parameters.
-        Once the session is defined, it won't change during the curse of the execution.
+        Initialize the CLI driver with optional session and credentials file.
+        
+        Sets up the session to be used while running commands, either with a 
+        specified alias, environment variables, or function parameters.
+        Once the session is defined, it won't change during the execution.
+        
+        :param session: Optional session object. If None, uses 'default' or
+                       alias-specified session from command-line arguments.
+        :param credentials_file: Optional path to custom credentials file.
         """
+        from pygeai.core.common.config import get_settings
+        
         arguments = sys.argv
+        
+        if credentials_file or "--credentials" in arguments or "--creds" in arguments:
+            if not credentials_file:
+                credentials_file = self._get_credentials_file(arguments)
+            get_settings(credentials_file=credentials_file)
+            logger.debug(f"Using custom credentials file: {credentials_file}")
+        
         if "-a" in arguments or "--alias" in arguments:
             alias = self._get_alias(arguments)
             session = get_session(alias)
 
-        self.session = get_session() if session is None else session
+        self.session = get_session("default") if session is None else session
 
-    def _get_alias(self, arguments: list):
+    def _get_alias(self, arguments: List[str]) -> str:
         """
-        Retrieves and removes alias and alias flag from argument list
+        Retrieves and removes alias and alias flag from argument list.
+
+        :param arguments: List[str] - Command line arguments.
+        :return: str - The alias value.
+        :raises ValueError: If alias flag is present but no value provided.
         """
         alias_index = None
 
@@ -43,64 +110,136 @@ class CLIDriver:
         _ = arguments.pop(alias_index)
         alias = arguments.pop(alias_index)
         return alias
+    
+    def _get_credentials_file(self, arguments: List[str]) -> str:
+        """
+        Retrieves and removes credentials file path and flag from argument list.
+
+        :param arguments: List[str] - Command line arguments.
+        :return: str - The credentials file path.
+        :raises ValueError: If credentials flag is present but no value provided.
+        """
+        creds_index = None
 
-    def main(self, args=None):
+        if "--credentials" in arguments:
+            creds_index = arguments.index("--credentials")
+        elif "--creds" in arguments:
+            creds_index = arguments.index("--creds")
+
+        _ = arguments.pop(creds_index)
+        credentials_file = arguments.pop(creds_index)
+        return credentials_file
+
+    def main(self, args: Optional[List[str]] = None) -> int:
         """
-        If not argument is received, it defaults to help (first command in base_command list).
+        Execute the CLI command based on provided arguments.
+        
+        If no argument is received, it defaults to help (first command in base_command list).
         Otherwise, it parses the arguments received to identify the appropriate command and either
         execute it or parse it again to detect subcommands.
+
+        :param args: Optional[List[str]] - Command line arguments. If None, uses sys.argv.
+        :return: int - Exit code (0 for success, non-zero for errors).
         """
         try:
-            logger.info(f"Running geai with: {sys.argv}")
-            if len(sys.argv) > 1:
-                arg = sys.argv[1] if args is None else args[1]
-                arguments = sys.argv[2:] if args is None else args[2:]
-
+            argv = sys.argv if args is None else args
+            
+            if "--verbose" in argv or "-v" in argv:
+                setup_verbose_logging()
+                argv_copy = [a for a in argv if a not in ("--verbose", "-v")]
+                if args is None:
+                    sys.argv = argv_copy
+                else:
+                    args = argv_copy
+                argv = argv_copy
+            
+            logger.debug(f"Running geai with: {' '.join(a for a in argv)}")
+            logger.debug(f"Session: {self.session.alias if hasattr(self.session, 'alias') else 'default'}")
+            
+            if len(argv) > 1:
+                arg = argv[1] if args is None else args[1]
+                arguments = argv[2:] if args is None else args[2:]
+                
+                logger.debug(f"Identifying command for argument: {arg}")
                 command = CommandParser(base_commands, base_options).identify_command(arg)
+                logger.debug(f"Command identified: {command.name}")
             else:
+                logger.debug("No arguments provided, defaulting to help command")
                 command = base_commands[0]
                 arguments = []
 
             self.process_command(command, arguments)
-        except (UnknownArgumentError, WrongArgumentError) as e:
-            sys.stderr.write(f"usage: {CLI_USAGE}")
-            sys.stderr.write(str(e))
-            sys.stderr.write("\n")
+            logger.debug(f"Command completed successfully")
+            return ExitCode.SUCCESS
+        except UnknownArgumentError as e:
+            if hasattr(e, 'available_commands') and e.available_commands:
+                error_msg = ErrorHandler.handle_unknown_command(e.arg, e.available_commands)
+            elif hasattr(e, 'available_options') and e.available_options:
+                error_msg = ErrorHandler.handle_unknown_option(e.arg, e.available_options)
+            else:
+                error_msg = ErrorHandler.format_error("Unknown Argument", str(e))
+            
+            Console.write_stderr(error_msg)
+            return ExitCode.USER_INPUT_ERROR
+        except WrongArgumentError as e:
+            error_msg = ErrorHandler.handle_wrong_argument(str(e), CLI_USAGE)
+            Console.write_stderr(error_msg)
+            return ExitCode.USER_INPUT_ERROR
         except MissingRequirementException as e:
-            sys.stderr.write(f"ERROR: Something is missing! {e}")
+            error_msg = ErrorHandler.handle_missing_requirement(str(e))
+            Console.write_stderr(error_msg)
+            return ExitCode.MISSING_REQUIREMENT
+        except InvalidAgentException as e:
+            error_msg = ErrorHandler.handle_invalid_agent(str(e))
+            Console.write_stderr(error_msg)
+            return ExitCode.SERVICE_ERROR
         except KeyboardInterrupt:
-            sys.stdout.write("\n")
+            message = ErrorHandler.handle_keyboard_interrupt()
+            Console.write_stdout(message)
+            return ExitCode.KEYBOARD_INTERRUPT
         except Exception as e:
-            sys.stderr.write(f"Unexpected error. Please report this bug to the developers. Error: {e}")
-            return 255
+            error_msg = ErrorHandler.handle_unexpected_error(e)
+            Console.write_stderr(error_msg)
+            return ExitCode.UNEXPECTED_ERROR
 
     def process_command(self, command: Command, arguments: list[str]):
         """
         If the command has no action associated with it, it means it has subcommands, so it must be parsed again
         to identify it.
         """
+        logger.debug(f"Processing command: {command.name}, arguments: {arguments}")
+        
         if command.action:
             if command.additional_args == ArgumentsEnum.NOT_AVAILABLE:
+                logger.debug(f"Executing command {command.name} without arguments")
                 command.action()
             else:
+                logger.debug(f"Extracting options for command {command.name}")
                 option_list = CommandParser(base_commands, command.options).extract_option_list(arguments)
+                logger.debug(f"Options extracted: {len(option_list)} items")
                 command.action(option_list)
         elif command.subcommands:
             subcommand_arg = arguments[0] if len(arguments) > 0 else None
             subcommand_arguments = arguments[1:] if len(arguments) > 1 else []
-
+            
+            logger.debug(f"Command has subcommands, identifying: {subcommand_arg}")
+            
             available_commands = command.subcommands
             available_options = command.options
             parser = CommandParser(available_commands, available_options)
 
             if not subcommand_arg:
+                logger.debug(f"No subcommand specified, using default: {command.subcommands[0].name}")
                 subcommand = command.subcommands[0]
             else:
                 subcommand = parser.identify_command(subcommand_arg)
+                logger.debug(f"Subcommand identified: {subcommand.name}")
 
             if subcommand.additional_args == ArgumentsEnum.NOT_AVAILABLE:
+                logger.debug(f"Executing subcommand {subcommand.name} without arguments")
                 subcommand.action()
             else:
+                logger.debug(f"Extracting options for subcommand {subcommand.name}")
                 option_list = CommandParser(None, subcommand.options).extract_option_list(subcommand_arguments)
+                logger.debug(f"Options extracted: {len(option_list)} items")
                 subcommand.action(option_list)
-

pygeai/cli/geai_proxy.py

@@ -2,13 +2,45 @@
 import json
 import asyncio
 import sys
+from typing import Final
 import argparse
 import uuid
 import yaml
 from pygeai import logger
 from pygeai.proxy.managers import ServerManager
 from pygeai.proxy.config import ProxySettingsManager
-
+from pygeai.admin.clients import AdminClient
+from pygeai.core.utils.console import Console, StreamWriter
+class CustomProxyStream(StreamWriter):
+    """
+    Custom stream writer for proxy output with color support for TTY terminals.
+    """
+    IS_TTY: Final[bool] = sys.stderr.isatty()
+    RED: Final[str] = "\033[91m" if IS_TTY else ""
+    RESET: Final[str] = "\033[0m" if IS_TTY else ""
+
+    def write_stdout(self, message: str, end: str = "\n"):
+        """
+        Write message to stdout and log as info.
+        """
+        sys.stdout.write(f"{message}{end}")
+        logger.info(f"{message}{end}")
+
+    def write_stderr(self, message: str, end: str = "\n"):
+        """
+        Write message to stderr with red color and log as error.
+        """
+        sys.stderr.write(f"{self.RED}{message}{self.RESET}{end}")
+        logger.error(f"{message}{end}")
+
+    def write_exception(self, message: str, exception: Exception, end: str = "\n"):
+        """
+        Write exception message to stderr with red color and log as exception.
+        """
+        sys.stderr.write(f"{self.RED}{message}{self.RESET} {str(exception)}{end}")
+        logger.exception(f"{message}{end}", exception)
+
+Console.set_writer(CustomProxyStream())
 
 def load_config(path: str) -> list:
     """
@@ -22,13 +54,22 @@ def load_config(path: str) -> list:
     try:
         with open(path, 'r', encoding='utf-8') as f:
             config = yaml.safe_load(f) if path.endswith(('.yaml', '.yml')) else json.load(f)
-            if 'mcpServers' not in config:
-                raise ValueError(f"Config file '{path}' must contain 'mcpServers' key")
-            
             servers = []
-            for name, server_cfg in config['mcpServers'].items():
-                server_cfg['name'] = name
-                servers.append(server_cfg)
+            if 'mcpServers' in config:
+                for name, server_cfg in config['mcpServers'].items():
+                    server_cfg['name'] = name
+                    server_cfg['type'] = 'mcp'
+                    servers.append(server_cfg)
+
+            if 'a2aServers' in config:
+                for name, server_cfg in config['a2aServers'].items():
+                    server_cfg['name'] = name
+                    server_cfg['type'] = 'a2a'
+                    servers.append(server_cfg)
+            
+            if not 'a2aServers' in config and not 'mcpServers' in config:
+                Console.write_stderr("Error: MCP servers or A2A servers are required")
+
             return servers
     except FileNotFoundError as exc:
         raise FileNotFoundError(f"Configuration file '{path}' not found") from exc
@@ -58,12 +99,12 @@ def configure_proxy_settings(settings: ProxySettingsManager, args: argparse.Name
     #first_time = all(not x for x in [ current_id, current_name, current_description, current_api_key, current_base_url])
 
     if not only_missing or any(not x for x in [current_id, current_name, current_description, current_api_key, current_base_url]):
-        sys.stdout.write("# Configuring GEAI proxy settings...\n")
+        Console.write_stdout("# Configuring GEAI proxy settings...")
         
         if not current_id:
             current_id = uuid.uuid4()
             settings.set_proxy_id(current_id, alias)
-            sys.stdout.write(f"Generated new proxy ID: {current_id}\n")
+            Console.write_stdout(f"Generated new proxy ID: {current_id}")
         
         if not only_missing or not current_id:
             server_id = input(f"-> Insert proxy ID (UUID) (Current: {current_id}, Leave empty to keep): ")
@@ -71,7 +112,7 @@ def configure_proxy_settings(settings: ProxySettingsManager, args: argparse.Name
                 try:
                     settings.set_proxy_id(uuid.UUID(server_id), alias)
                 except ValueError:
-                    sys.stderr.write("Error: Invalid UUID format\n")
+                    Console.write_stdout("Error: Invalid UUID format")
                     return
         if not only_missing or not current_api_key:
             if current_api_key:
@@ -122,7 +163,7 @@ def configure_proxy_settings(settings: ProxySettingsManager, args: argparse.Name
             try:
                 settings.set_proxy_id(uuid.UUID(args.proxy_id), alias)
             except ValueError:
-                sys.stderr.write("Error: Invalid UUID format for proxy ID\n")
+                Console.write_stderr("Error: Invalid UUID format for proxy ID")
                 return
         elif not only_missing or not settings.get_proxy_id(alias):
             # Generate new UUID if no ID is provided
@@ -130,7 +171,7 @@ def configure_proxy_settings(settings: ProxySettingsManager, args: argparse.Name
             if not current_id:
                 current_id = uuid.uuid4()
                 settings.set_proxy_id(current_id, alias)
-                sys.stdout.write(f"Generated new proxy ID: {current_id}\n")
+                Console.write_stdout(f"Generated new proxy ID: {current_id}")
 
         if args.proxy_name:
             settings.set_proxy_name(args.proxy_name, alias)
@@ -151,7 +192,7 @@ def configure_proxy_settings(settings: ProxySettingsManager, args: argparse.Name
         #elif not only_missing or not settings.get_proxy_affinity(alias):
         #    pass  # Affinity is not requested if not in args and only_missing is True
 
-    sys.stdout.write(f"Proxy settings for alias '{alias}' saved successfully!\n")
+    Console.write_stdout(f"Proxy settings for alias '{alias}' saved successfully!")
 
 
 async def main():
@@ -160,6 +201,7 @@ async def main():
 
     :return: int - Exit code (0 for success, 1 for error)
     """
+    
     logger.info("Starting GEAI proxy CLI")
     parser = argparse.ArgumentParser(
         description="Proxy CLI between GEAI and MCP servers",
@@ -183,7 +225,7 @@ async def main():
     else:
         settings.set_current_alias(args.alias)
 
-    sys.stdout.write(f"Using alias: {args.alias}\n")
+    Console.write_stdout(f"Using alias: {args.alias}")
     
     only_configure = args.configure
     while True:
@@ -196,35 +238,54 @@ async def main():
         ]):
             
             if args.alias not in settings.config:
-                sys.stdout.write(f"Created new alias '{args.alias}' in the configuration file.\n\n")
+                Console.write_stdout(f"Created new alias '{args.alias}' in the configuration file.","\n\n")
                 settings.config.add_section(args.alias)
             else:
                 if not args.configure:
-                    sys.stdout.write("\nProxy configuration required. Please complete all required fields.\n\n")
+                    Console.write_stdout("\nProxy configuration required. Please complete all required fields.","\n\n")
                 else:
-                    sys.stdout.write("\nProxy configuration.\n\n")
+                    Console.write_stdout("\nProxy configuration.","\n\n")
 
                 if (key := settings.get_api_key(args.alias)):
-                    sys.stdout.write(f"API_KEY: {key}\n")
+                    Console.write_stdout(f"API_KEY: {key}")
                 if (url := settings.get_base_url(args.alias)):
-                    sys.stdout.write(f"BASE_URL: {url}\n")
+                    Console.write_stdout(f"BASE_URL: {url}")
 
-            sys.stdout.write("\n")
+            Console.write_stdout("")
             configure_proxy_settings(settings, args, only_missing=not args.configure)
             args.configure = False
         else:
             break
 
     if only_configure:
-        sys.stdout.write("Proxy configuration completed successfully!\n")
+        Console.write_stdout("Proxy configuration completed successfully!")
         return 0
 
     if not args.config:
-        sys.stderr.write("Error: MCP servers Configuration file path is required\n")
+        Console.write_stderr("Error: MCP servers Configuration file path is required")
         return 1
 
     servers_cfg = load_config(args.config)
     server_manager = ServerManager(servers_cfg, settings)
+
+    try:
+        Console.write_stdout(f"Contacting Globant Enteprise AI at {settings.get_base_url(args.alias)}...","")
+        admin_client = AdminClient(api_key=settings.get_api_key(args.alias), base_url=settings.get_base_url(args.alias))
+        result = admin_client.validate_api_token()
+        if result.get('errors'):
+            Console.write_stdout("Invalid API token")
+            for error in result.get('errors'):
+                Console.write_stderr(f"{error.get('description')}")
+
+            return 1
+        else:
+            Console.write_stdout(f" Done!")
+            Console.write_stdout(f"Organization: {result.get('organizationName')}")
+            Console.write_stdout(f"Project: {result.get('projectName')}")
+    except Exception as e:
+        Console.write_exception("Error:", e, "\n")
+        return 1
+
     await server_manager.start()
 
     return 0
@@ -239,10 +300,10 @@ def cli_entry() -> int:
     try:
         return asyncio.run(main())
     except KeyboardInterrupt:
-        sys.stdout.write("\nExiting...\n")
+        Console.write_stdout("\nExiting...")
         return 0
     except (RuntimeError, ConnectionError, ValueError) as e:
-        sys.stderr.write(f"Error: {e}\n")
+        Console.write_exception("Error:", e, "\n")
         return 1
 
 
@@ -251,7 +312,7 @@ if __name__ == "__main__":
         import os
         script_dir = os.path.dirname(os.path.abspath(__file__))
         config_path = os.path.join(os.path.dirname(script_dir), "proxy", "sample-mcp-config.json")
-        sys.stdout.write(f"Config file path: {config_path}\n")
+        Console.write_stdout(f"Config file path: {config_path}")
         
         sys.argv.extend([config_path])
     sys.exit(cli_entry())