Fix long text input dropping characters on Windows

_type() now tries ValuePattern.SetValue() before falling back to
SendInput keyboard simulation. This bypasses the message queue
entirely for elements that support it (e.g. Notepad). The SendInput
fallback also removes chunking in favor of a single atomic call.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: k4cper-g

cup/actions/_macos.py

@@ -208,6 +208,30 @@ def _get_element_center(element) -> tuple[float, float] | None:
     return x + w / 2.0, y + h / 2.0
 
 
+def _get_element_center_or_parent(element) -> tuple[float, float] | None:
+    """Get center point of an element, walking up parents if needed.
+
+    Some elements (e.g., offscreen web content nodes in Safari) don't
+    report valid bounds. This function walks up the AXParent chain to
+    find the nearest ancestor with bounds, falling back to the window
+    center as a last resort.
+    """
+    from ApplicationServices import AXUIElementCopyAttributeValue, kAXErrorSuccess
+
+    current = element
+    for _ in range(20):  # guard against infinite loops
+        center = _get_element_center(current)
+        if center is not None:
+            return center
+        # Walk up to parent
+        err, parent = AXUIElementCopyAttributeValue(current, "AXParent", None)
+        if err != kAXErrorSuccess or parent is None:
+            break
+        current = parent
+
+    return None
+
+
 def _send_mouse_click(
     x: float,
     y: float,
@@ -305,30 +329,39 @@ def _send_mouse_long_press(x: float, y: float, duration: float = 0.8) -> None:
 
 
 def _send_scroll(x: float, y: float, direction: str, amount: int = 5) -> None:
-    """Send scroll event at screen coordinates via Quartz CGEvents."""
+    """Send scroll event at screen coordinates via Quartz CGEvents.
+
+    Uses pixel-based scrolling (kCGScrollEventUnitPixel) for reliable
+    scrolling across all apps. Line-based scrolling (kCGScrollEventUnitLine)
+    is unreliable in apps like Safari where line units may be interpreted
+    as tiny or zero-pixel movements.
+    """
     from Quartz import (
         CGEventCreateScrollWheelEvent,
         CGEventPost,
         CGEventSetLocation,
         CGPointMake,
         kCGHIDEventTap,
-        kCGScrollEventUnitLine,
+        kCGScrollEventUnitPixel,
     )
 
     point = CGPointMake(x, y)
 
+    # Convert line amount to pixels (~80px per line is a reasonable default)
+    pixel_amount = amount * 80
+
     if direction == "up":
-        dy, dx = amount, 0
+        dy, dx = pixel_amount, 0
     elif direction == "down":
-        dy, dx = -amount, 0
+        dy, dx = -pixel_amount, 0
     elif direction == "left":
-        dy, dx = 0, amount
+        dy, dx = 0, pixel_amount
     elif direction == "right":
-        dy, dx = 0, -amount
+        dy, dx = 0, -pixel_amount
     else:
         dy, dx = 0, 0
 
-    event = CGEventCreateScrollWheelEvent(None, kCGScrollEventUnitLine, 2, dy, dx)
+    event = CGEventCreateScrollWheelEvent(None, kCGScrollEventUnitPixel, 2, dy, dx)
     CGEventSetLocation(event, point)
     CGEventPost(kCGHIDEventTap, event)
     time.sleep(0.02)
@@ -707,8 +740,10 @@ def _select(self, element) -> ActionResult:
         return self._click(element)
 
     def _scroll(self, element, direction: str) -> ActionResult:
-        # Get element center for scroll target
-        center = _get_element_center(element)
+        # Get element center for scroll target, walking up parents if needed.
+        # Some elements (e.g., offscreen nodes in Safari) have no bounds,
+        # so we fall back to the nearest ancestor with valid bounds.
+        center = _get_element_center(element) or _get_element_center_or_parent(element)
         if center:
             try:
                 _send_scroll(center[0], center[1], direction)

cup/actions/_windows.py

@@ -259,33 +259,67 @@ def _send_unicode_string(text: str) -> None:
     Unlike _send_key_combo which maps characters to virtual key codes
     (breaking special characters like :, /, -, .), this sends each
     character as a Unicode scan code — preserving all characters exactly.
+
+    Control characters (newlines, tabs) are sent as virtual-key presses
+    (VK_RETURN, VK_TAB) because many Windows apps — including the modern
+    Windows 11 Notepad — do not interpret these when delivered as Unicode
+    scan codes via KEYEVENTF_UNICODE.
+
+    Long strings are sent in chunks with brief pauses so the target app's
+    message queue can keep up.
     """
-    inputs = []
-    for char in text:
-        code = ord(char)
-        # Key down
-        inp_down = INPUT()
-        inp_down.type = INPUT_KEYBOARD
-        inp_down._input.ki.wVk = 0
-        inp_down._input.ki.wScan = code
-        inp_down._input.ki.dwFlags = KEYEVENTF_UNICODE
-        inputs.append(inp_down)
-        # Key up
-        inp_up = INPUT()
-        inp_up.type = INPUT_KEYBOARD
-        inp_up._input.ki.wVk = 0
-        inp_up._input.ki.wScan = code
-        inp_up._input.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP
-        inputs.append(inp_up)
+    # Normalize newlines: \r\n → \n, then standalone \r → \n.
+    # We'll emit VK_RETURN for every \n below.
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+
+    # Map control characters to their virtual-key codes.
+    _CONTROL_VK = {
+        "\n": 0x0D,  # VK_RETURN
+        "\t": 0x09,  # VK_TAB
+    }
 
+    inputs: list[INPUT] = []
+    for char in text:
+        vk = _CONTROL_VK.get(char)
+        if vk is not None:
+            # Send control character as a normal virtual-key press.
+            inputs.append(_make_key_input(vk, down=True))
+            inputs.append(_make_key_input(vk, down=False))
+        else:
+            code = ord(char)
+            # Key down
+            inp_down = INPUT()
+            inp_down.type = INPUT_KEYBOARD
+            inp_down._input.ki.wVk = 0
+            inp_down._input.ki.wScan = code
+            inp_down._input.ki.dwFlags = KEYEVENTF_UNICODE
+            inputs.append(inp_down)
+            # Key up
+            inp_up = INPUT()
+            inp_up.type = INPUT_KEYBOARD
+            inp_up._input.ki.wVk = 0
+            inp_up._input.ki.wScan = code
+            inp_up._input.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP
+            inputs.append(inp_up)
+
+    # Send all events in a single atomic SendInput call.
+    _flush_inputs(inputs)
+
+
+def _flush_inputs(inputs: list[INPUT]) -> None:
+    """Send a batch of INPUT events via SendInput with a brief trailing pause."""
     if not inputs:
         return
-
     arr = (INPUT * len(inputs))(*inputs)
     sent = ctypes.windll.user32.SendInput(len(inputs), arr, ctypes.sizeof(INPUT))
     if sent == 0:
         err = ctypes.get_last_error()
-        raise RuntimeError(f"SendInput (unicode) failed, sent 0/{len(inputs)} events (error={err})")
+        raise RuntimeError(
+            f"SendInput (unicode) failed, sent 0/{len(inputs)} events (error={err})"
+        )
+    # Brief pause gives the target app time to process the events before
+    # the next chunk arrives.
+    time.sleep(0.01)
 
 
 # ---------------------------------------------------------------------------
@@ -477,7 +511,25 @@ def _toggle(self, element) -> ActionResult:
         )
 
     def _type(self, element, text: str) -> ActionResult:
-        """Type text via Unicode SendInput (preserves all special characters)."""
+        """Type text into an element.
+
+        Prefers ValuePattern.SetValue (instant, lossless) when available.
+        Falls back to Unicode SendInput for elements that don't expose it.
+        """
+        import comtypes
+
+        # Fast path: use ValuePattern to set text directly (no keyboard sim).
+        try:
+            pat = _get_pattern(element, UIA_ValuePatternId, _IValue)
+            if pat:
+                element.SetFocus()
+                time.sleep(0.05)
+                pat.SetValue(text)
+                return ActionResult(success=True, message=f"Typed: {text}")
+        except (comtypes.COMError, Exception):
+            pass  # fall through to SendInput
+
+        # Fallback: keyboard simulation via Unicode SendInput.
         try:
             element.SetFocus()
             time.sleep(0.05)
@@ -685,7 +737,28 @@ def open_app(self, name: str) -> ActionResult:
                     error="Could not discover installed applications",
                 )
 
+            # Try matching against display names first.
             match = _fuzzy_match(name, list(apps.keys()))
+
+            # If no match on display names, try matching against AppIDs.
+            # This handles localized Windows where display names are
+            # translated (e.g. "Notatnik" for Notepad on Polish Windows)
+            # but AppIDs still contain the English name.
+            if match is None:
+                appid_to_name: dict[str, str] = {}
+                for display, appid in apps.items():
+                    # Extract a readable name from the AppID.
+                    # UWP: "Microsoft.WindowsNotepad_8wekyb3d8bbwe!App" -> "WindowsNotepad"
+                    # Path: just use the display name (already tried above).
+                    parts = appid.split(".")
+                    if len(parts) >= 2:
+                        # Take the component after "Microsoft." etc., strip the suffix
+                        raw = parts[-1].split("_")[0].split("!")[0]
+                        appid_to_name[raw.lower()] = display
+                appid_match = _fuzzy_match(name, list(appid_to_name.keys()))
+                if appid_match is not None:
+                    match = appid_to_name[appid_match]
+
             if match is None:
                 return ActionResult(
                     success=False,
@@ -847,7 +920,11 @@ def callback(hwnd, _lparam):
 
 def _run_powershell(command: str, timeout: int = 10) -> tuple[str, bool]:
     """Run a PowerShell command using base64-encoded input. Returns (output, success)."""
-    encoded = base64.b64encode(command.encode("utf-16le")).decode("ascii")
+    # Prepend a UTF-8 output-encoding directive so the stdout bytes are
+    # valid UTF-8 regardless of the system's default codepage (e.g. cp1250
+    # on Polish Windows which cannot represent many app names).
+    full_command = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; " + command
+    encoded = base64.b64encode(full_command.encode("utf-16le")).decode("ascii")
     try:
         result = subprocess.run(
             [
@@ -859,8 +936,9 @@ def _run_powershell(command: str, timeout: int = 10) -> tuple[str, bool]:
                 encoded,
             ],
             capture_output=True,
-            text=True,
             timeout=timeout,
+            encoding="utf-8",
+            errors="replace",
         )
         return result.stdout or "", result.returncode == 0
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError):