iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/terminal/emulator/pen.py

@@ -0,0 +1,158 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Graphic rendition: the pen that styles every cell, and the SGR sequence that changes it."""
+
+from __future__ import annotations
+
+from enum import IntFlag
+from functools import lru_cache
+from typing import NamedTuple
+
+
+class Rgb(NamedTuple):
+    """A direct 24-bit color."""
+
+    red: int
+    green: int
+    blue: int
+
+
+type Color = int | Rgb
+"""A palette index (0-255) or a direct color. ``None`` stands for the terminal default."""
+
+
+class Attribute(IntFlag):
+    """Character attributes that SGR can switch on and off."""
+
+    NONE = 0
+    BOLD = 1
+    DIM = 2
+    ITALIC = 4
+    UNDERLINE = 8
+    DOUBLE_UNDERLINE = 16
+    BLINK = 32
+    REVERSE = 64
+    CONCEAL = 128
+    STRIKE = 256
+    OVERLINE = 512
+
+
+class Pen(NamedTuple):
+    """The rendition applied to a cell. Immutable, so cells share pens freely."""
+
+    foreground: Color | None = None
+    background: Color | None = None
+    attributes: Attribute = Attribute.NONE
+    link: str | None = None
+
+    @property
+    def eraser(self) -> Pen:
+        """The pen erased cells take: only the background survives (background color erase)."""
+        if self.background is None:
+            return DEFAULT_PEN
+        return Pen(background=self.background)
+
+
+DEFAULT_PEN = Pen()
+
+_SET_ATTRIBUTE = {
+    1: Attribute.BOLD,
+    2: Attribute.DIM,
+    3: Attribute.ITALIC,
+    4: Attribute.UNDERLINE,
+    5: Attribute.BLINK,
+    6: Attribute.BLINK,
+    7: Attribute.REVERSE,
+    8: Attribute.CONCEAL,
+    9: Attribute.STRIKE,
+    21: Attribute.DOUBLE_UNDERLINE,
+    53: Attribute.OVERLINE,
+}
+_CLEAR_ATTRIBUTE = {
+    22: Attribute.BOLD | Attribute.DIM,
+    23: Attribute.ITALIC,
+    24: Attribute.UNDERLINE | Attribute.DOUBLE_UNDERLINE,
+    25: Attribute.BLINK,
+    27: Attribute.REVERSE,
+    28: Attribute.CONCEAL,
+    29: Attribute.STRIKE,
+    55: Attribute.OVERLINE,
+}
+_UNDERLINES = Attribute.UNDERLINE | Attribute.DOUBLE_UNDERLINE
+_EXTENDED_FOREGROUND, _EXTENDED_BACKGROUND, _EXTENDED_UNDERLINE = 38, 48, 58
+_MAX_PARAMETER = 0xFFFF
+
+
+def _number(field: str) -> int:
+    """An SGR field as a number; empty means zero and junk can never match a code."""
+    if not field:
+        return 0
+    return min(int(field), _MAX_PARAMETER) if field.isdecimal() else -1
+
+
+def _direct_color(fields: list[int]) -> Color | None:
+    """Decode the fields after a 38/48/58 introducer, or ``None`` when they name no color."""
+    match fields:
+        case [5, index, *_] if 0 <= index <= 255:
+            return index
+        case [2, red, green, blue] | [2, _, red, green, blue, *_]:
+            if all(0 <= channel <= 255 for channel in (red, green, blue)):
+                return Rgb(red, green, blue)
+    return None
+
+
+@lru_cache(maxsize=4096)
+def apply_sgr(pen: Pen, parameters: str) -> Pen:
+    """Return ``pen`` after a Select Graphic Rendition sequence with the given raw parameters.
+
+    Extended colors are accepted in both spellings: the legacy ``38;2;R;G;B`` that spends following
+    parameters, and the ITU T.416 ``38:2::R:G:B`` that keeps everything in one parameter's
+    sub-fields (with or without the color-space slot). Unknown codes are skipped.
+    """
+    foreground, background, attributes, link = pen
+    groups = parameters.split(";")
+    position = 0
+    while position < len(groups):
+        code_field, *sub_fields = groups[position].split(":")
+        code = _number(code_field)
+        position += 1
+        if code == 0:
+            foreground = background = None
+            attributes = Attribute.NONE
+        elif code == 4 and sub_fields:
+            attributes &= ~_UNDERLINES
+            if (shape := _number(sub_fields[0])) == 2:
+                attributes |= Attribute.DOUBLE_UNDERLINE
+            elif shape:
+                attributes |= Attribute.UNDERLINE
+        elif (flag := _SET_ATTRIBUTE.get(code)) is not None:
+            attributes |= flag
+        elif (flags := _CLEAR_ATTRIBUTE.get(code)) is not None:
+            attributes &= ~flags
+        elif 30 <= code <= 37:
+            foreground = code - 30
+        elif 40 <= code <= 47:
+            background = code - 40
+        elif 90 <= code <= 97:
+            foreground = code - 90 + 8
+        elif 100 <= code <= 107:
+            background = code - 100 + 8
+        elif code == 39:
+            foreground = None
+        elif code == 49:
+            background = None
+        elif code in (_EXTENDED_FOREGROUND, _EXTENDED_BACKGROUND, _EXTENDED_UNDERLINE):
+            if sub_fields:
+                color = _direct_color([_number(field) for field in sub_fields])
+            else:
+                following = [_number(field.partition(":")[0]) for field in groups[position : position + 4]]
+                color = _direct_color(following[:2] if following[:1] == [5] else following)
+                # A legacy introducer spends its operands even when they name no usable color.
+                position += 2 if following[:1] == [5] else 4 if following[:1] == [2] else 0
+            if color is None:
+                continue
+            if code == _EXTENDED_FOREGROUND:
+                foreground = color
+            elif code == _EXTENDED_BACKGROUND:
+                background = color
+    return Pen(foreground, background, attributes, link)

chrys/app/tui/terminal/launcher.py

@@ -0,0 +1,455 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Terminal launcher helpers for opening additional Chrys windows."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+
+from chrys.foundation.branding import APP_DISPLAY_NAME
+from chrys.foundation.i18n import MessageRef, msg
+from chrys.foundation.i18n.formatting import format_message
+from chrys.foundation.platform import get_platform
+
+_SSH_ENV_VARS = ("SSH_CONNECTION", "SSH_CLIENT", "SSH_TTY")
+_HOSTED_WORKSPACE_ENV_VARS = ("GITPOD_WORKSPACE_ID", "REPL_ID")
+_HOSTED_WORKSPACE_FLAG_ENV_VARS = ("CODESPACES", "CLOUD_SHELL")
+_TEXTUAL_WEB_DRIVER = "textual.drivers.web_driver:WebDriver"
+_LINUX_DESKTOP_ENV_VARS = ("DISPLAY", "WAYLAND_DISPLAY", "MIR_SOCKET")
+_CORE_GRAPHICS_PATH = "/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics"
+_CORE_FOUNDATION_PATH = "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"
+_TUI_SUBPROCESS_COMMAND = "__tui_subprocess__"
+_GHOSTTY_APP_NAME = "Ghostty"
+_ITERM_APP_NAME = "iTerm2"
+_QUICK_LAUNCH_TIMEOUT_SECONDS = 0.25
+
+_TERMINAL_LAUNCH_UNAVAILABLE = msg(
+    "tui.terminal.launch.unavailable",
+    fallback="Opening a new {app} window is not available in the current environment.",
+)
+_TERMINAL_LAUNCH_MACOS_FAILED = msg(
+    "tui.terminal.launch.macos_failed",
+    fallback="Could not open Terminal: {error}",
+)
+_TERMINAL_LAUNCH_WINDOWS_FAILED = msg(
+    "tui.terminal.launch.windows_failed",
+    fallback="Could not open a new command window: {error}",
+)
+_TERMINAL_LAUNCH_UNSUPPORTED = msg(
+    "tui.terminal.launch.unsupported",
+    fallback="No supported terminal emulator was found.",
+)
+_TERMINAL_LAUNCH_EXITED = msg(
+    "tui.terminal.launch.exited",
+    fallback="Could not open {label}: launcher exited with status {failure_code}.",
+)
+
+
+class TerminalLaunchError(RuntimeError):
+    """Raised when Chrys cannot open a new terminal window."""
+
+    def __init__(self, message: str, *, display_message: MessageRef | None = None) -> None:
+        self.display_message = display_message
+        super().__init__(message)
+
+
+def is_remote_ssh_session(env: Mapping[str, str] | None = None) -> bool:
+    """Return True when Chrys is running inside an SSH login session."""
+    values = os.environ if env is None else env
+    return any(bool(values.get(name)) for name in _SSH_ENV_VARS)
+
+
+def is_remote_execution_environment(env: Mapping[str, str] | None = None) -> bool:
+    """Return whether the active frontend is hosted away from this desktop."""
+    values = os.environ if env is None else env
+    if is_remote_ssh_session(values) or values.get("TEXTUAL_DRIVER") == _TEXTUAL_WEB_DRIVER:
+        return True
+    if any(bool(values.get(name)) for name in _HOSTED_WORKSPACE_ENV_VARS):
+        return True
+    return any(_env_flag_is_true(values.get(name)) for name in _HOSTED_WORKSPACE_FLAG_ENV_VARS)
+
+
+def can_access_local_desktop(env: Mapping[str, str] | None = None) -> bool:
+    """Return whether this process is attached to a desktop that can show windows.
+
+    ``env`` overrides environment-marker inputs only. The Windows window-station
+    and macOS Quartz probes always inspect the current process's real session.
+    """
+    values = os.environ if env is None else env
+    if is_remote_execution_environment(values):
+        return False
+    platform = get_platform()
+    if platform.is_windows:
+        return _windows_desktop_shell_is_visible()
+    if platform.is_macos:
+        return _macos_window_server_session_is_available()
+    return any(bool(values.get(name)) for name in _LINUX_DESKTOP_ENV_VARS)
+
+
+def can_open_new_chrys_window(env: Mapping[str, str] | None = None) -> bool:
+    """Return whether the current host can reasonably open a local Chrys window."""
+    return can_access_local_desktop(env)
+
+
+def build_chrys_tui_argv(session_id: str) -> list[str]:
+    """Return argv that opens Chrys TUI and restores *session_id*."""
+    return [*_entrypoint_argv(), _TUI_SUBPROCESS_COMMAND, "--session", session_id]
+
+
+def launch_new_chrys_window(session_id: str, *, cwd: str | None = None) -> None:
+    """Open a new local terminal window running Chrys for *session_id*."""
+    if not can_open_new_chrys_window():
+        display_message = _TERMINAL_LAUNCH_UNAVAILABLE.bind(app=APP_DISPLAY_NAME)
+        raise TerminalLaunchError(format_message(display_message), display_message=display_message)
+    argv = build_chrys_tui_argv(session_id)
+    platform = get_platform()
+    if platform.is_macos:
+        _launch_macos(argv, cwd=cwd)
+        return
+    if platform.is_windows:
+        _launch_windows(argv, cwd=cwd)
+        return
+    _launch_linux(argv, cwd=cwd)
+
+
+def _env_flag_is_true(value: str | None) -> bool:
+    return (value or "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _macos_window_server_session_is_available() -> bool:
+    """Return whether this process belongs to a macOS Quartz GUI session."""
+    import ctypes
+
+    try:
+        core_graphics = ctypes.CDLL(_CORE_GRAPHICS_PATH)
+        core_foundation = ctypes.CDLL(_CORE_FOUNDATION_PATH)
+        copy_current_session = core_graphics.CGSessionCopyCurrentDictionary
+        copy_current_session.argtypes = ()
+        copy_current_session.restype = ctypes.c_void_p
+        release = core_foundation.CFRelease
+        release.argtypes = (ctypes.c_void_p,)
+        release.restype = None
+    except AttributeError, OSError:
+        return False
+
+    session = copy_current_session()
+    if not session:
+        return False
+    release(session)
+    return True
+
+
+def _windows_desktop_shell_is_visible() -> bool:
+    """Return whether this Windows process owns a visible window station with Explorer's shell window."""
+    import ctypes
+    from ctypes import wintypes
+    from typing import Any, cast
+
+    class UserObjectFlags(ctypes.Structure):
+        _fields_ = (("inherit", wintypes.BOOL), ("reserved", wintypes.BOOL), ("flags", wintypes.DWORD))
+
+    try:
+        windows_ctypes = cast(Any, ctypes)
+        user32 = windows_ctypes.WinDLL("user32", use_last_error=True)
+    except OSError:
+        return False
+    get_window_station = user32.GetProcessWindowStation
+    get_window_station.argtypes = ()
+    get_window_station.restype = wintypes.HANDLE
+    window_station = get_window_station()
+    if not window_station:
+        return False
+
+    get_user_object_info = user32.GetUserObjectInformationW
+    get_user_object_info.argtypes = (
+        wintypes.HANDLE,
+        ctypes.c_int,
+        wintypes.LPVOID,
+        wintypes.DWORD,
+        ctypes.POINTER(wintypes.DWORD),
+    )
+    get_user_object_info.restype = wintypes.BOOL
+    flags = UserObjectFlags()
+    needed = wintypes.DWORD()
+    if not get_user_object_info(window_station, 1, ctypes.byref(flags), ctypes.sizeof(flags), ctypes.byref(needed)):
+        return False
+
+    get_shell_window = user32.GetShellWindow
+    get_shell_window.argtypes = ()
+    get_shell_window.restype = wintypes.HWND
+    return bool(flags.flags & 1) and bool(get_shell_window())
+
+
+def _entrypoint_argv() -> list[str]:
+    pyapp_launcher = os.environ.get("PYAPP")
+    if pyapp_launcher and pyapp_launcher != "1" and Path(pyapp_launcher).is_file():
+        return [pyapp_launcher]
+    if _looks_like_python(sys.executable):
+        return [sys.executable, "-m", "chrys.app.cli.app"]
+    return [sys.argv[0]]
+
+
+def _looks_like_python(executable: str) -> bool:
+    name = executable.replace("\\", "/").rsplit("/", 1)[-1].lower()
+    return name.startswith(("python", "pypy"))
+
+
+def _launch_macos(argv: list[str], *, cwd: str | None) -> None:
+    if _is_ghostty_session() and _try_launch_macos_ghostty(argv, cwd=cwd):
+        return
+    if _is_wezterm_session() and _try_launch_wezterm_tab(argv, cwd=cwd):
+        return
+    if _is_iterm_session() and _try_launch_macos_iterm_tab(argv, cwd=cwd):
+        return
+    command = _shell_command(argv, cwd=cwd)
+    script = f'tell application "Terminal"\n do script "{_applescript_quote(command)}"\n activate\nend tell'
+    try:
+        _spawn_or_raise(
+            ["/usr/bin/osascript", "-e", script],
+            label="Terminal",
+            verify_quick_exit=True,
+        )
+    except OSError as exc:
+        display_message = _TERMINAL_LAUNCH_MACOS_FAILED.bind(error=str(exc))
+        raise TerminalLaunchError(format_message(display_message), display_message=display_message) from exc
+
+
+def _try_launch_macos_iterm_tab(argv: list[str], *, cwd: str | None) -> bool:
+    command = _shell_command(argv, cwd=cwd)
+    escaped = _applescript_quote(command)
+    script = (
+        f'tell application "{_ITERM_APP_NAME}"\n'
+        "  activate\n"
+        "  if (count of windows) = 0 then\n"
+        f'    create window with default profile command "{escaped}"\n'
+        "  else\n"
+        f'    tell current window to create tab with default profile command "{escaped}"\n'
+        "  end if\n"
+        "end tell"
+    )
+    return _try_spawn(["/usr/bin/osascript", "-e", script], verify_quick_exit=True)
+
+
+def _is_ghostty_session(env: Mapping[str, str] | None = None) -> bool:
+    return _env_contains("ghostty", env=env) or _env_has_any(("GHOSTTY_BIN_DIR", "GHOSTTY_RESOURCES_DIR"), env=env)
+
+
+def _try_launch_macos_ghostty(argv: list[str], *, cwd: str | None) -> bool:
+    command = _shell_command(argv, cwd=cwd)
+    ghostty_args = ["-e", "/bin/sh", "-lc", command]
+    ghostty_path = _ghostty_cli_path()
+    if ghostty_path is not None:
+        args = [ghostty_path, *ghostty_args]
+    else:
+        args = ["/usr/bin/open", "-na", _GHOSTTY_APP_NAME, "--args", *ghostty_args]
+    return _try_spawn(args, verify_quick_exit=True)
+
+
+def _ghostty_cli_path(env: Mapping[str, str] | None = None) -> str | None:
+    values = os.environ if env is None else env
+    bin_dir = values.get("GHOSTTY_BIN_DIR", "")
+    if bin_dir:
+        candidate = Path(bin_dir) / "ghostty"
+        if candidate.exists():
+            return str(candidate)
+    return shutil.which("ghostty")
+
+
+def _is_iterm_session(env: Mapping[str, str] | None = None) -> bool:
+    return _env_contains("iterm", env=env)
+
+
+def _is_wezterm_session(env: Mapping[str, str] | None = None) -> bool:
+    return _env_contains("wezterm", env=env) or _env_has_any(("WEZTERM_EXECUTABLE", "WEZTERM_PANE"), env=env)
+
+
+def _try_launch_wezterm_tab(argv: list[str], *, cwd: str | None) -> bool:
+    wezterm = shutil.which("wezterm")
+    if wezterm is None:
+        return False
+    args = [wezterm, "cli", "spawn", "--new-tab"]
+    if cwd:
+        args.extend(["--cwd", cwd])
+    args.extend(["--", *argv])
+    return _try_spawn(args, verify_quick_exit=True)
+
+
+def _launch_windows(argv: list[str], *, cwd: str | None) -> None:
+    if _is_windows_terminal_session() and _try_launch_windows_terminal_tab(argv, cwd=cwd):
+        return
+    comspec = os.environ.get("COMSPEC") or r"C:\Windows\System32\cmd.exe"
+    try:
+        _spawn_or_raise(
+            [comspec, "/c", "start", "", *argv],
+            cwd=cwd,
+            label="command window",
+            verify_quick_exit=True,
+        )
+    except OSError as exc:
+        display_message = _TERMINAL_LAUNCH_WINDOWS_FAILED.bind(error=str(exc))
+        raise TerminalLaunchError(format_message(display_message), display_message=display_message) from exc
+
+
+def _is_windows_terminal_session(env: Mapping[str, str] | None = None) -> bool:
+    return _env_has_any(("WT_SESSION", "WT_PROFILE_ID"), env=env)
+
+
+def _try_launch_windows_terminal_tab(argv: list[str], *, cwd: str | None) -> bool:
+    wt = shutil.which("wt")
+    if wt is None:
+        return False
+    args = [wt, "-w", "0", "new-tab"]
+    if cwd:
+        args.extend(["-d", cwd])
+    args.extend(argv)
+    return _try_spawn(args, verify_quick_exit=True)
+
+
+def _launch_linux(argv: list[str], *, cwd: str | None) -> None:
+    if _is_wezterm_session() and _try_launch_wezterm_tab(argv, cwd=cwd):
+        return
+    if _is_kitty_session() and _try_launch_kitty_tab(argv, cwd=cwd):
+        return
+    if _is_gnome_terminal_session() and _try_launch_gnome_terminal_tab(argv, cwd=cwd):
+        return
+    if _is_konsole_session() and _try_launch_konsole_tab(argv, cwd=cwd):
+        return
+
+    launchers = (
+        ("x-terminal-emulator", ["-e", *argv]),
+        ("gnome-terminal", ["--", *argv]),
+        ("konsole", ["-e", *argv]),
+        ("xterm", ["-e", *argv]),
+    )
+    for executable, args in launchers:
+        path = shutil.which(executable)
+        if path is None:
+            continue
+        try:
+            if not _try_spawn(
+                [path, *args],
+                cwd=cwd,
+                verify_quick_exit=True,
+            ):
+                continue
+        except OSError:
+            continue
+        return
+    display_message = _TERMINAL_LAUNCH_UNSUPPORTED.bind()
+    raise TerminalLaunchError(format_message(display_message), display_message=display_message)
+
+
+def _is_kitty_session(env: Mapping[str, str] | None = None) -> bool:
+    return _env_has_any(("KITTY_LISTEN_ON",), env=env)
+
+
+def _try_launch_kitty_tab(argv: list[str], *, cwd: str | None) -> bool:
+    kitty = shutil.which("kitty")
+    if kitty is None:
+        return False
+    args = [kitty, "@", "launch", "--type=tab"]
+    if cwd:
+        args.extend(["--cwd", cwd])
+    args.extend(["--", *argv])
+    return _try_spawn(args, verify_quick_exit=True)
+
+
+def _is_gnome_terminal_session(env: Mapping[str, str] | None = None) -> bool:
+    return _env_has_any(("GNOME_TERMINAL_SCREEN", "GNOME_TERMINAL_SERVICE"), env=env)
+
+
+def _try_launch_gnome_terminal_tab(argv: list[str], *, cwd: str | None) -> bool:
+    terminal = shutil.which("gnome-terminal")
+    if terminal is None:
+        return False
+    args = [terminal, "--tab", "--", *argv]
+    return _try_spawn(args, cwd=cwd, verify_quick_exit=True)
+
+
+def _is_konsole_session(env: Mapping[str, str] | None = None) -> bool:
+    return _env_has_any(("KONSOLE_VERSION", "KONSOLE_DBUS_SESSION", "KONSOLE_DBUS_WINDOW"), env=env)
+
+
+def _try_launch_konsole_tab(argv: list[str], *, cwd: str | None) -> bool:
+    konsole = shutil.which("konsole")
+    if konsole is None:
+        return False
+    args = [konsole, "--new-tab", "-e", *argv]
+    return _try_spawn(args, cwd=cwd, verify_quick_exit=True)
+
+
+def _env_contains(needle: str, *, env: Mapping[str, str] | None = None) -> bool:
+    values = os.environ if env is None else env
+    lower_needle = needle.lower()
+    terminal_markers = (
+        values.get("TERM_PROGRAM", ""),
+        values.get("LC_TERMINAL", ""),
+        values.get("TERMINAL_EMULATOR", ""),
+        values.get("TERM", ""),
+    )
+    return any(lower_needle in marker.lower() for marker in terminal_markers)
+
+
+def _env_has_any(names: tuple[str, ...], *, env: Mapping[str, str] | None = None) -> bool:
+    values = os.environ if env is None else env
+    return any(bool(values.get(name)) for name in names)
+
+
+def _shell_command(argv: list[str], *, cwd: str | None) -> str:
+    command = shlex.join(argv)
+    if not cwd:
+        return command
+    return f"cd {shlex.quote(cwd)} && {command}"
+
+
+def _try_spawn(args: list[str], *, cwd: str | None = None, verify_quick_exit: bool = False) -> bool:
+    try:
+        process = _spawn(args, cwd=cwd)
+    except OSError:
+        return False
+    if verify_quick_exit:
+        return _quick_launch_failure_code(process) is None
+    return True
+
+
+def _spawn_or_raise(
+    args: list[str],
+    *,
+    cwd: str | None = None,
+    label: str,
+    verify_quick_exit: bool = False,
+) -> None:
+    process = _spawn(args, cwd=cwd)
+    if verify_quick_exit:
+        failure_code = _quick_launch_failure_code(process)
+        if failure_code is not None:
+            display_message = _TERMINAL_LAUNCH_EXITED.bind(label=label, failure_code=failure_code)
+            raise TerminalLaunchError(format_message(display_message), display_message=display_message)
+
+
+def _spawn(args: list[str], *, cwd: str | None = None) -> subprocess.Popen[bytes]:
+    return subprocess.Popen(  # noqa: S603
+        args,
+        cwd=cwd,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+def _quick_launch_failure_code(process: subprocess.Popen[bytes]) -> int | None:
+    try:
+        return_code = process.wait(timeout=_QUICK_LAUNCH_TIMEOUT_SECONDS)
+    except subprocess.TimeoutExpired:
+        return None
+    return return_code if return_code != 0 else None
+
+
+def _applescript_quote(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')

chrys/app/tui/terminal/leaked_reports.py

@@ -0,0 +1,44 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Recognizing the outer terminal's own reports when they arrive as typed keys.
+
+The terminal the app runs in answers focus and mouse tracking with escape sequences. When the
+app's input parser gives up on one partway (Windows Terminal splits them under load), the rest
+arrives as ordinary key presses: ``[``, ``I``. Forwarded to the embedded program they would be
+typed at its prompt, so the widget holds the keys that follow an Escape for as long as they could
+still be such a report, and drops them once they turn out to be one.
+"""
+
+from __future__ import annotations
+
+import re
+from enum import Enum
+from typing import Final
+
+_FOCUS_REPORTS: Final = ("\x1b[I", "\x1b[O")
+# SGR and urxvt mouse reports are numeric; X10 is ``CSI M`` and three raw bytes.
+_NUMERIC_MOUSE_REPORT = re.compile(r"\x1b\[<?-?\d+(?:;-?\d+){1,2}[mM]")
+_NUMERIC_MOUSE_PREFIX = re.compile(r"\x1b\[<?[-\d;]*")
+_X10_MOUSE_PREFIX: Final = "\x1b[M"
+_X10_MOUSE_LENGTH: Final = len(_X10_MOUSE_PREFIX) + 3
+
+MAX_HELD_LENGTH: Final = 32
+"""A would-be report longer than this is not one; the keys are released rather than held forever."""
+
+
+class ReportMatch(Enum):
+    COMPLETE = "complete"
+    PARTIAL = "partial"
+    NONE = "none"
+
+
+def match_outer_report(sequence: str) -> ReportMatch:
+    """Whether ``sequence``, which starts with ESC, is or may yet become a focus or mouse report."""
+    if sequence in _FOCUS_REPORTS or _NUMERIC_MOUSE_REPORT.fullmatch(sequence):
+        return ReportMatch.COMPLETE
+    if sequence.startswith(_X10_MOUSE_PREFIX):
+        return ReportMatch.COMPLETE if len(sequence) == _X10_MOUSE_LENGTH else ReportMatch.PARTIAL
+    if len(sequence) > MAX_HELD_LENGTH:
+        return ReportMatch.NONE
+    could_grow = any(report.startswith(sequence) for report in (*_FOCUS_REPORTS, _X10_MOUSE_PREFIX))
+    return ReportMatch.PARTIAL if could_grow or _NUMERIC_MOUSE_PREFIX.fullmatch(sequence) else ReportMatch.NONE