This tool finds and clicks an element on the page using either CSS selector
    or XPath. It will wait for the element to be clickable before attempting
    to click it.
    
    Args:
        selector (str): The selector to find the element
        by (str, optional): The selector type. Either "css" or "xpath". Defaults to "css"
    
    Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - message (str): Status message
    
    Example:
        {"tool": "click", "args": {"selector": "#submit-button"}}
        {"tool": "click", "args": {"selector": "//button[@type='submit']", "by": "xpath"}}
    

    This tool closes the current Chrome browser window and cleans up resources.
    It's safe to call this even if no browser is open.
    
    Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - message (str): Status message
    
    Example:
        {"tool": "close_browser"}
    

    Retrieve stored credentials from system keychain
    
    Args:
        site: Website domain
        username: User's username
    

    This tool finds all elements matching the selector and returns their text
    content and HTML.
    
    Args:
        selector (str): The selector to find the elements
        by (str, optional): The selector type. Either "css" or "xpath". Defaults to "css"
    
    Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - message (str): Status message
            - data (List[Dict]): List of elements, each containing:
                - text (str): The text content of the element
                - html (str): The outer HTML of the element
    
    Example:
        {"tool": "get_elements", "args": {"selector": ".item"}}
        {"tool": "get_elements", "args": {"selector": "//li[@class='item']", "by": "xpath"}}
    

    This tool finds an element and returns its text content.
    
    Args:
        selector (str): The selector to find the element
        by (str, optional): The selector type. Either "css" or "xpath". Defaults to "css"
    
    Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - message (str): Status message
            - data (str): The text content of the element
    
    Example:
        {"tool": "get_text", "args": {"selector": "h1"}}
        {"tool": "get_text", "args": {"selector": "//div[@class='content']", "by": "xpath"}}
    

    This tool navigates the browser to the specified URL. If no browser
    is open, it will automatically open one.
    
    Args:
        url (str): The URL to navigate to (must include protocol, e.g., 'https://')
    
    Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - message (str): Status message
    
    Example:
        {"tool": "navigate", "args": {"url": "https://www.example.com"}}
    

    This tool initializes a new Chrome browser window. If a browser instance
    already exists, it will reuse that instance.
    
    Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - message (str): Status message
    
    Example:
        {"tool": "open_browser"}
    

    Securely save credentials
    
    Args:
        site: Website domain
        username: User's username
        password: Password
    

    This tool finds an input element and types the specified text into it.
    It will clear any existing text in the element before typing.
    
    Args:
        selector (str): The selector to find the element
        text (str): The text to type into the element
        by (str, optional): The selector type. Either "css" or "xpath". Defaults to "css"
    
    Returns:
        Dict[str, Any]: A dictionary containing:
            - success (bool): Whether the operation was successful
            - message (str): Status message
    
    Example:
        {"tool": "type", "args": {"selector": "#search-input", "text": "search query"}}
        {"tool": "type", "args": {"selector": "//input[@name='q']", "text": "search", "by": "xpath"}}
    

    Perform website login

    This tool attempts to log in to the provided URL. It waits for automatic
    input prevention (CAPTCHA) to be detected before allowing the user to manually resolve it.

    Args:
        url (str): Login page URL
        credentials (Dict[str, str]): Login credentials
            - username: User ID
            - password: Password
        selectors (Dict[str, str]): CSS selectors for login form elements
            - username: ID input field selector
            - password: Password input field selector
            - submit: Login button selector
        auth_type (str, optional): Authentication type. Defaults to "form"
            - form: Regular form-based login
            - oauth: OAuth authentication
            - api: API-based authentication
        wait_for (Optional[str], optional): CSS selector for element to wait for after login

    Returns:
        Dict[str, Any]: Login result
            - success (bool): Login success status
            - message (str): Status message
            - session_data (Dict): Login success session information
                - cookies: Cookie information
                - localStorage: Local storage data
                - sessionStorage: Session storage data

    Special handling:
        1. CAPTCHA detection
            - If reCAPTCHA or standard CAPTCHA is detected, wait for user to manually resolve
            - Automatically continue login process after resolution
        2. Naver login
            - Automatic detection of various special situations like automatic input prevention, 2-step authentication
            - Detailed error message analysis and return

    Example:
        >>> result = tool_web_login(
        ...     url="https://nid.naver.com/nidlogin.login",
        ...     credentials={
        ...         "username": "your_username",
        ...         "password": "your_password"
        ...     },
        ...     selectors={
        ...         "username": "#id",
        ...         "password": "#pw",
        ...         "submit": ".btn_login"
        ...     }
        ... )
        >>> if not result["success"] and "CAPTCHA" in result["message"]:
        ...     # Wait for user input for CAPTCHA resolution
        ...     print("Please solve the CAPTCHA in the browser")