code-puppy 0.0.169__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/terminal_utils.py

@@ -0,0 +1,418 @@
+"""Terminal utilities for cross-platform terminal state management.
+
+Handles Windows console mode resets and Unix terminal sanity restoration.
+"""
+
+import os
+import platform
+import subprocess
+import sys
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+# Store the original console ctrl handler so we can restore it if needed
+_original_ctrl_handler: Optional[Callable] = None
+
+
+def reset_windows_terminal_ansi() -> None:
+    """Reset ANSI formatting on Windows stdout/stderr.
+
+    This is a lightweight reset that just clears ANSI escape sequences.
+    Use this for quick resets after output operations.
+    """
+    if platform.system() != "Windows":
+        return
+
+    try:
+        sys.stdout.write("\x1b[0m")  # Reset ANSI formatting
+        sys.stdout.flush()
+        sys.stderr.write("\x1b[0m")
+        sys.stderr.flush()
+    except Exception:
+        pass  # Silently ignore errors - best effort reset
+
+
+def reset_windows_console_mode() -> None:
+    """Full Windows console mode reset using ctypes.
+
+    This resets both stdout and stdin console modes to restore proper
+    terminal behavior after interrupts (Ctrl+C, Ctrl+D). Without this,
+    the terminal can become unresponsive (can't type characters).
+    """
+    if platform.system() != "Windows":
+        return
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Reset stdout
+        STD_OUTPUT_HANDLE = -11
+        handle = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+
+        # Enable virtual terminal processing and line input
+        mode = ctypes.c_ulong()
+        kernel32.GetConsoleMode(handle, ctypes.byref(mode))
+
+        # Console mode flags for stdout
+        ENABLE_PROCESSED_OUTPUT = 0x0001
+        ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+        ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+
+        new_mode = (
+            mode.value
+            | ENABLE_PROCESSED_OUTPUT
+            | ENABLE_WRAP_AT_EOL_OUTPUT
+            | ENABLE_VIRTUAL_TERMINAL_PROCESSING
+        )
+        kernel32.SetConsoleMode(handle, new_mode)
+
+        # Reset stdin
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Console mode flags for stdin
+        ENABLE_LINE_INPUT = 0x0002
+        ENABLE_ECHO_INPUT = 0x0004
+        ENABLE_PROCESSED_INPUT = 0x0001
+
+        stdin_mode = ctypes.c_ulong()
+        kernel32.GetConsoleMode(stdin_handle, ctypes.byref(stdin_mode))
+
+        new_stdin_mode = (
+            stdin_mode.value
+            | ENABLE_LINE_INPUT
+            | ENABLE_ECHO_INPUT
+            | ENABLE_PROCESSED_INPUT
+        )
+        kernel32.SetConsoleMode(stdin_handle, new_stdin_mode)
+
+    except Exception:
+        pass  # Silently ignore errors - best effort reset
+
+
+def flush_windows_keyboard_buffer() -> None:
+    """Flush the Windows keyboard buffer.
+
+    Clears any pending keyboard input that could interfere with
+    subsequent input operations after an interrupt.
+    """
+    if platform.system() != "Windows":
+        return
+
+    try:
+        import msvcrt
+
+        while msvcrt.kbhit():
+            msvcrt.getch()
+    except Exception:
+        pass  # Silently ignore errors - best effort flush
+
+
+def reset_windows_terminal_full() -> None:
+    """Perform a full Windows terminal reset (ANSI + console mode + keyboard buffer).
+
+    Combines ANSI reset, console mode reset, and keyboard buffer flush
+    for complete terminal state restoration after interrupts.
+    """
+    if platform.system() != "Windows":
+        return
+
+    reset_windows_terminal_ansi()
+    reset_windows_console_mode()
+    flush_windows_keyboard_buffer()
+
+
+def reset_unix_terminal() -> None:
+    """Reset Unix/Linux/macOS terminal to sane state.
+
+    Uses the `reset` command to restore terminal sanity.
+    Silently fails if the command isn't available.
+    """
+    if platform.system() == "Windows":
+        return
+
+    try:
+        subprocess.run(["reset"], check=True, capture_output=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass  # Silently fail if reset command isn't available
+
+
+def reset_terminal() -> None:
+    """Cross-platform terminal reset.
+
+    Automatically detects the platform and performs the appropriate
+    terminal reset operation.
+    """
+    if platform.system() == "Windows":
+        reset_windows_terminal_full()
+    else:
+        reset_unix_terminal()
+
+
+def disable_windows_ctrl_c() -> bool:
+    """Disable Ctrl+C processing at the Windows console input level.
+
+    This removes ENABLE_PROCESSED_INPUT from stdin, which prevents
+    Ctrl+C from being interpreted as a signal at all. Instead, it
+    becomes just a regular character (^C) that gets ignored.
+
+    This is more reliable than SetConsoleCtrlHandler because it
+    prevents Ctrl+C from being processed before it reaches any handler.
+
+    Returns:
+        True if successfully disabled, False otherwise.
+    """
+    global _original_ctrl_handler
+
+    if platform.system() != "Windows":
+        return False
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Get current console mode
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return False
+
+        # Save original mode for potential restoration
+        _original_ctrl_handler = mode.value
+
+        # Console mode flags
+        ENABLE_PROCESSED_INPUT = 0x0001  # This makes Ctrl+C generate signals
+
+        # Remove ENABLE_PROCESSED_INPUT to disable Ctrl+C signal generation
+        new_mode = mode.value & ~ENABLE_PROCESSED_INPUT
+
+        if kernel32.SetConsoleMode(stdin_handle, new_mode):
+            return True
+        return False
+
+    except Exception:
+        return False
+
+
+def enable_windows_ctrl_c() -> bool:
+    """Re-enable Ctrl+C at the Windows console level.
+
+    Restores the original console mode saved by disable_windows_ctrl_c().
+
+    Returns:
+        True if successfully re-enabled, False otherwise.
+    """
+    global _original_ctrl_handler
+
+    if platform.system() != "Windows":
+        return False
+
+    if _original_ctrl_handler is None:
+        return True  # Nothing to restore
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Restore original mode
+        if kernel32.SetConsoleMode(stdin_handle, _original_ctrl_handler):
+            _original_ctrl_handler = None
+            return True
+        return False
+
+    except Exception:
+        return False
+
+
+# Flag to track if we should keep Ctrl+C disabled
+_keep_ctrl_c_disabled: bool = False
+
+
+def set_keep_ctrl_c_disabled(value: bool) -> None:
+    """Set whether Ctrl+C should be kept disabled.
+
+    When True, ensure_ctrl_c_disabled() will re-disable Ctrl+C
+    even if something else (like prompt_toolkit) re-enables it.
+    """
+    global _keep_ctrl_c_disabled
+    _keep_ctrl_c_disabled = value
+
+
+def ensure_ctrl_c_disabled() -> bool:
+    """Ensure Ctrl+C is disabled if it should be.
+
+    Call this after operations that might restore console mode
+    (like prompt_toolkit input).
+
+    Returns:
+        True if Ctrl+C is now disabled (or wasn't needed), False on error.
+    """
+    if not _keep_ctrl_c_disabled:
+        return True
+
+    if platform.system() != "Windows":
+        return True
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Get current console mode
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return False
+
+        # Console mode flags
+        ENABLE_PROCESSED_INPUT = 0x0001
+
+        # Check if Ctrl+C processing is enabled
+        if mode.value & ENABLE_PROCESSED_INPUT:
+            # Disable it
+            new_mode = mode.value & ~ENABLE_PROCESSED_INPUT
+            return bool(kernel32.SetConsoleMode(stdin_handle, new_mode))
+
+        return True  # Already disabled
+
+    except Exception:
+        return False
+
+
+def detect_truecolor_support() -> bool:
+    """Detect if the terminal supports truecolor (24-bit color).
+
+    Checks multiple indicators:
+    1. COLORTERM environment variable (most reliable)
+    2. TERM environment variable patterns
+    3. Rich's Console color_system detection as fallback
+
+    Returns:
+        True if truecolor is supported, False otherwise.
+    """
+    # Check COLORTERM - this is the most reliable indicator
+    colorterm = os.environ.get("COLORTERM", "").lower()
+    if colorterm in ("truecolor", "24bit"):
+        return True
+
+    # Check TERM for known truecolor-capable terminals
+    term = os.environ.get("TERM", "").lower()
+    truecolor_terms = (
+        "xterm-direct",
+        "xterm-truecolor",
+        "iterm2",
+        "vte-256color",  # Many modern terminals set this
+    )
+    if any(t in term for t in truecolor_terms):
+        return True
+
+    # Some terminals like iTerm2, Kitty, Alacritty set specific env vars
+    if os.environ.get("ITERM_SESSION_ID"):
+        return True
+    if os.environ.get("KITTY_WINDOW_ID"):
+        return True
+    if os.environ.get("ALACRITTY_SOCKET"):
+        return True
+    if os.environ.get("WT_SESSION"):  # Windows Terminal
+        return True
+
+    # Use Rich's detection as a fallback
+    try:
+        from rich.console import Console
+
+        console = Console(force_terminal=True)
+        color_system = console.color_system
+        return color_system == "truecolor"
+    except Exception:
+        pass
+
+    return False
+
+
+def print_truecolor_warning(console: Optional["Console"] = None) -> None:
+    """Print a big fat red warning if truecolor is not supported.
+
+    Args:
+        console: Optional Rich Console instance. If None, creates a new one.
+    """
+    if detect_truecolor_support():
+        return  # All good, no warning needed
+
+    if console is None:
+        try:
+            from rich.console import Console
+
+            console = Console()
+        except ImportError:
+            # Rich not available, fall back to plain print
+            print("\n" + "=" * 70)
+            print("⚠️  WARNING: TERMINAL DOES NOT SUPPORT TRUECOLOR (24-BIT COLOR)")
+            print("=" * 70)
+            print("Code Puppy looks best with truecolor support.")
+            print("Consider using a modern terminal like:")
+            print("  • iTerm2 (macOS)")
+            print("  • Windows Terminal (Windows)")
+            print("  • Kitty, Alacritty, or any modern terminal emulator")
+            print("")
+            print("You can also try setting: export COLORTERM=truecolor")
+            print("")
+            print("Note: The built-in macOS Terminal.app does not support truecolor")
+            print("(Sequoia and earlier). You'll need a different terminal app.")
+            print("=" * 70 + "\n")
+            return
+
+    # Get detected color system for diagnostic info
+    color_system = console.color_system or "unknown"
+
+    # Build the warning box
+    warning_lines = [
+        "",
+        "[bold bright_red on red]" + "━" * 72 + "[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]"
+        + " " * 70
+        + "[/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]  ⚠️   WARNING: TERMINAL DOES NOT SUPPORT TRUECOLOR (24-BIT COLOR)  ⚠️   [/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]"
+        + " " * 70
+        + "[/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]" + "━" * 72 + "[/]",
+        "",
+        f"[yellow]Detected color system:[/] [bold]{color_system}[/]",
+        "",
+        "[bold white]Code Puppy uses rich colors and will look degraded without truecolor.[/]",
+        "",
+        "[cyan]Consider using a modern terminal emulator:[/]",
+        "  [green]•[/] [bold]iTerm2[/] (macOS) - https://iterm2.com",
+        "  [green]•[/] [bold]Windows Terminal[/] (Windows) - Built into Windows 11",
+        "  [green]•[/] [bold]Kitty[/] - https://sw.kovidgoyal.net/kitty",
+        "  [green]•[/] [bold]Alacritty[/] - https://alacritty.org",
+        "  [green]•[/] [bold]Warp[/] (macOS) - https://warp.dev",
+        "",
+        "[cyan]Or try setting the COLORTERM environment variable:[/]",
+        "  [dim]export COLORTERM=truecolor[/]",
+        "",
+        "[dim italic]Note: The built-in macOS Terminal.app does not support truecolor (Sequoia and earlier).[/]",
+        "[dim italic]Setting COLORTERM=truecolor won't help - you'll need a different terminal app.[/]",
+        "",
+        "[bold bright_red]" + "─" * 72 + "[/]",
+        "",
+    ]
+
+    for line in warning_lines:
+        console.print(line)

code_puppy/tools/__init__.py

@@ -1,20 +1,93 @@
 from code_puppy.messaging import emit_warning
-from code_puppy.tools.agent_tools import (
-    register_list_agents,
-    register_invoke_agent,
+from code_puppy.tools.agent_tools import register_invoke_agent, register_list_agents
+
+# Browser automation tools
+from code_puppy.tools.browser.browser_control import (
+    register_close_browser,
+    register_create_new_page,
+    register_get_browser_status,
+    register_initialize_browser,
+    register_list_pages,
+)
+from code_puppy.tools.browser.browser_interactions import (
+    register_browser_check,
+    register_browser_uncheck,
+    register_click_element,
+    register_double_click_element,
+    register_get_element_text,
+    register_get_element_value,
+    register_hover_element,
+    register_select_option,
+    register_set_element_text,
+)
+from code_puppy.tools.browser.browser_locators import (
+    register_find_buttons,
+    register_find_by_label,
+    register_find_by_placeholder,
+    register_find_by_role,
+    register_find_by_test_id,
+    register_find_by_text,
+    register_find_links,
+    register_run_xpath_query,
+)
+from code_puppy.tools.browser.browser_navigation import (
+    register_browser_go_back,
+    register_browser_go_forward,
+    register_get_page_info,
+    register_navigate_to_url,
+    register_reload_page,
+    register_wait_for_load_state,
+)
+from code_puppy.tools.browser.browser_screenshot import (
+    register_take_screenshot_and_analyze,
+)
+from code_puppy.tools.browser.browser_scripts import (
+    register_browser_clear_highlights,
+    register_browser_highlight_element,
+    register_execute_javascript,
+    register_scroll_page,
+    register_scroll_to_element,
+    register_set_viewport_size,
+    register_wait_for_element,
+)
+from code_puppy.tools.browser.browser_workflows import (
+    register_list_workflows,
+    register_read_workflow,
+    register_save_workflow,
+)
+from code_puppy.tools.browser.terminal_command_tools import (
+    register_run_terminal_command,
+    register_send_terminal_keys,
+    register_wait_terminal_output,
+)
+from code_puppy.tools.browser.terminal_screenshot_tools import (
+    register_load_image,
+    register_terminal_compare_mockup,
+    register_terminal_read_output,
+    register_terminal_screenshot,
+)
+
+# Terminal automation tools
+from code_puppy.tools.browser.terminal_tools import (
+    register_check_terminal_server,
+    register_close_terminal,
+    register_open_terminal,
+    register_start_api_server,
 )
 from code_puppy.tools.command_runner import (
     register_agent_run_shell_command,
     register_agent_share_your_reasoning,
 )
-from code_puppy.tools.file_modifications import register_edit_file, register_delete_file
+from code_puppy.tools.display import (
+    display_non_streamed_result as display_non_streamed_result,
+)
+from code_puppy.tools.file_modifications import register_delete_file, register_edit_file
 from code_puppy.tools.file_operations import (
+    register_grep,
     register_list_files,
     register_read_file,
-    register_grep,
 )
 
-
 # Map of tool names to their individual registration functions
 TOOL_REGISTRY = {
     # Agent Tools
@@ -30,6 +103,66 @@ TOOL_REGISTRY = {
     # Command Runner
     "agent_run_shell_command": register_agent_run_shell_command,
     "agent_share_your_reasoning": register_agent_share_your_reasoning,
+    # Browser Control
+    "browser_initialize": register_initialize_browser,
+    "browser_close": register_close_browser,
+    "browser_status": register_get_browser_status,
+    "browser_new_page": register_create_new_page,
+    "browser_list_pages": register_list_pages,
+    # Browser Navigation
+    "browser_navigate": register_navigate_to_url,
+    "browser_get_page_info": register_get_page_info,
+    "browser_go_back": register_browser_go_back,
+    "browser_go_forward": register_browser_go_forward,
+    "browser_reload": register_reload_page,
+    "browser_wait_for_load": register_wait_for_load_state,
+    # Browser Element Discovery
+    "browser_find_by_role": register_find_by_role,
+    "browser_find_by_text": register_find_by_text,
+    "browser_find_by_label": register_find_by_label,
+    "browser_find_by_placeholder": register_find_by_placeholder,
+    "browser_find_by_test_id": register_find_by_test_id,
+    "browser_xpath_query": register_run_xpath_query,
+    "browser_find_buttons": register_find_buttons,
+    "browser_find_links": register_find_links,
+    # Browser Element Interactions
+    "browser_click": register_click_element,
+    "browser_double_click": register_double_click_element,
+    "browser_hover": register_hover_element,
+    "browser_set_text": register_set_element_text,
+    "browser_get_text": register_get_element_text,
+    "browser_get_value": register_get_element_value,
+    "browser_select_option": register_select_option,
+    "browser_check": register_browser_check,
+    "browser_uncheck": register_browser_uncheck,
+    # Browser Scripts and Advanced Features
+    "browser_execute_js": register_execute_javascript,
+    "browser_scroll": register_scroll_page,
+    "browser_scroll_to_element": register_scroll_to_element,
+    "browser_set_viewport": register_set_viewport_size,
+    "browser_wait_for_element": register_wait_for_element,
+    "browser_highlight_element": register_browser_highlight_element,
+    "browser_clear_highlights": register_browser_clear_highlights,
+    # Browser Screenshots
+    "browser_screenshot_analyze": register_take_screenshot_and_analyze,
+    # Browser Workflows
+    "browser_save_workflow": register_save_workflow,
+    "browser_list_workflows": register_list_workflows,
+    "browser_read_workflow": register_read_workflow,
+    # Terminal Connection Tools
+    "terminal_check_server": register_check_terminal_server,
+    "terminal_open": register_open_terminal,
+    "terminal_close": register_close_terminal,
+    "start_api_server": register_start_api_server,
+    # Terminal Command Execution Tools
+    "terminal_run_command": register_run_terminal_command,
+    "terminal_send_keys": register_send_terminal_keys,
+    "terminal_wait_output": register_wait_terminal_output,
+    # Terminal Screenshot Tools
+    "terminal_screenshot_analyze": register_terminal_screenshot,
+    "terminal_read_output": register_terminal_read_output,
+    "terminal_compare_mockup": register_terminal_compare_mockup,
+    "load_image_for_analysis": register_load_image,
 }