fix: fix text injection after successfull groq whisper call

Author: DavidHruby1

src/audio.py

@@ -65,6 +65,10 @@ def default_input_device_id() -> int | None:
     return int(device_id)
 
 
+def _clean_device_name(name: str) -> str:
+    return name.removesuffix(" (Default input)").strip()
+
+
 class AudioRecorder:
     def __init__(self, device_id: int | None = None, sample_rate: int = SAMPLE_RATE) -> None:
         self._device_id = device_id
@@ -181,25 +185,38 @@ def stop(self) -> bytes:
 
 
 def resolve_device(preferred_id: int | None, preferred_name: str) -> int | None:
-    """ID → name search → None (use default)."""
+    """Resolve saved device ID/name, falling back to the current default input."""
     _require_sd()
+    clean_name = _clean_device_name(preferred_name)
+
     if preferred_id is not None:
         try:
             dev = sd.query_devices(preferred_id)
-            if dev["max_input_channels"] > 0:
+            dev_name = str(dev["name"])
+            if dev["max_input_channels"] > 0 and (
+                not clean_name or clean_name.lower() in dev_name.lower()
+            ):
                 return preferred_id
+            if dev["max_input_channels"] > 0:
+                log.warning(
+                    "Preferred device ID %d is now '%s', expected '%s'; trying name search",
+                    preferred_id,
+                    dev_name,
+                    clean_name,
+                )
         except (sd.PortAudioError, ValueError):
             log.warning("Preferred device ID %d not found; trying name search", preferred_id)
 
-    if preferred_name:
+    if clean_name:
         devices = sd.query_devices()
         for i, dev in enumerate(devices):
-            if dev["max_input_channels"] > 0 and preferred_name.lower() in dev["name"].lower():
-                log.info("Resolved device '%s' to ID %d", preferred_name, i)
+            if dev["max_input_channels"] > 0 and clean_name.lower() in dev["name"].lower():
+                log.info("Resolved device '%s' to ID %d", clean_name, i)
                 return i
 
-    log.info("No preferred device; using default")
-    return None
+    default_id = default_input_device_id()
+    log.info("Using current default input device: %s", default_id)
+    return default_id
 
 
 # ---------------------------------------------------------------------------

src/injector.py

@@ -33,8 +33,8 @@ def type_text(text: str, post_key: str | None = None) -> None:
     import ctypes.wintypes
 
     # --- SendInput struct definitions ---
-    # Copied from pynput/_util/win32.py (MIT-licensed) for correct alignment.
-    # See: https://github.com/moses-palmer/pynput
+    # SendInput requires cbSize to be the exact size of the Win32 INPUT union.
+    # Defining only KEYBDINPUT makes INPUT too small on 64-bit Windows.
 
     INPUT_KEYBOARD = 1
     KEYEVENTF_KEYUP = 0x0002
@@ -46,39 +46,73 @@ class KEYBDINPUT(ctypes.Structure):
             ("wScan", ctypes.wintypes.WORD),
             ("dwFlags", ctypes.wintypes.DWORD),
             ("time", ctypes.wintypes.DWORD),
-            ("dwExtraInfo", ctypes.POINTER(ctypes.c_ulong)),
+            ("dwExtraInfo", ctypes.c_size_t),
+        ]
+
+    class MOUSEINPUT(ctypes.Structure):
+        _fields_ = [
+            ("dx", ctypes.wintypes.LONG),
+            ("dy", ctypes.wintypes.LONG),
+            ("mouseData", ctypes.wintypes.DWORD),
+            ("dwFlags", ctypes.wintypes.DWORD),
+            ("time", ctypes.wintypes.DWORD),
+            ("dwExtraInfo", ctypes.c_size_t),
+        ]
+
+    class HARDWAREINPUT(ctypes.Structure):
+        _fields_ = [
+            ("uMsg", ctypes.wintypes.DWORD),
+            ("wParamL", ctypes.wintypes.WORD),
+            ("wParamH", ctypes.wintypes.WORD),
         ]
 
     class _INPUT_UNION(ctypes.Union):
-        _fields_ = [("ki", KEYBDINPUT)]
+        _fields_ = [
+            ("mi", MOUSEINPUT),
+            ("ki", KEYBDINPUT),
+            ("hi", HARDWAREINPUT),
+        ]
 
     class INPUT(ctypes.Structure):
+        _anonymous_ = ("union",)
         _fields_ = [
             ("type", ctypes.wintypes.DWORD),
             ("union", _INPUT_UNION),
         ]
 
-    user32 = ctypes.windll.user32  # type: ignore[attr-defined]
+    user32 = ctypes.WinDLL("user32", use_last_error=True)  # type: ignore[attr-defined]
+    user32.SendInput.argtypes = (ctypes.wintypes.UINT, ctypes.POINTER(INPUT), ctypes.c_int)
+    user32.SendInput.restype = ctypes.wintypes.UINT
+
+    def _raise_sendinput_failed(detail: str) -> None:
+        err = ctypes.get_last_error()
+        if err:
+            detail = f"{detail} (WinError {err})"
+        raise ScreamerError(AppError.INJECTION_FAILED, detail)
 
     def _send_unicode(char: str, key_up: bool = False) -> None:
         inp = INPUT()
         inp.type = INPUT_KEYBOARD
-        inp.union.ki.wScan = ord(char)
-        inp.union.ki.dwFlags = KEYEVENTF_UNICODE | (KEYEVENTF_KEYUP if key_up else 0)
-        if user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(INPUT)) == 0:
-            raise ScreamerError(AppError.INJECTION_FAILED, f"SendInput failed for U+{ord(char):04X}")
+        inp.ki.wScan = ord(char)
+        inp.ki.dwFlags = KEYEVENTF_UNICODE | (KEYEVENTF_KEYUP if key_up else 0)
+        if user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(INPUT)) != 1:
+            _raise_sendinput_failed(f"SendInput failed for U+{ord(char):04X}")
 
     def _send_vk(vk: int, key_up: bool = False) -> None:
         inp = INPUT()
         inp.type = INPUT_KEYBOARD
-        inp.union.ki.wVk = vk
-        inp.union.ki.dwFlags = KEYEVENTF_KEYUP if key_up else 0
-        if user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(INPUT)) == 0:
-            raise ScreamerError(AppError.INJECTION_FAILED, f"SendInput failed for VK 0x{vk:02X}")
+        inp.ki.wVk = vk
+        inp.ki.dwFlags = KEYEVENTF_KEYUP if key_up else 0
+        if user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(INPUT)) != 1:
+            _raise_sendinput_failed(f"SendInput failed for VK 0x{vk:02X}")
+
+    def _utf16_units(value: str) -> list[str]:
+        encoded = value.encode("utf-16-le", errors="surrogatepass")
+        return [chr(int.from_bytes(encoded[i : i + 2], "little")) for i in range(0, len(encoded), 2)]
 
     try:
         log.info("Typing %d characters", len(text))
-        for ch in text:
+        for ch in _utf16_units(text):
             _send_unicode(ch)
             _send_unicode(ch, key_up=True)
 

src/settings_dialog.py

@@ -325,6 +325,7 @@ def _populate(self, cfg: AppConfig) -> None:
         self._llm_fb_headers.setText(cfg.llm_fallback_custom_headers)
 
         # Audio
+        self._select_device(cfg)
         self._rms_spin.setValue(cfg.rms_threshold)
         self._rms_label.setText(f"Threshold: {cfg.rms_threshold:.1f}")
 
@@ -368,24 +369,50 @@ def _collect(self) -> None:
         cfg.audio_device_name = ""
         if cfg.audio_device_id is not None:
             text = self._device_combo.currentText()
-            cfg.audio_device_name = text.split("] ", 1)[1] if "] " in text else text
+            cfg.audio_device_name = _clean_device_name(
+                text.split("] ", 1)[1] if "] " in text else text
+            )
 
     # ------------------------------------------------------------------
     # Audio tab helpers
     # ------------------------------------------------------------------
 
     def _populate_devices(self) -> None:
         """Fill the device combo from the pre-fetched device list."""
-        self._device_combo.addItem("System Default (usually built-in laptop mic)", None)
+        default_name = next(
+            (
+                _clean_device_name(dev_name)
+                for _dev_id, dev_name in self._devices
+                if dev_name.endswith(" (Default input)")
+            ),
+            "usually built-in laptop mic",
+        )
+        self._device_combo.addItem(f"System Default ({default_name})", None)
         for dev_id, dev_name in self._devices:
             self._device_combo.addItem(f"[{dev_id}] {dev_name}", dev_id)
 
-        # Select the stored device.
-        if self._working.audio_device_id is not None:
+        self._select_device(self._working)
+
+    def _select_device(self, cfg: AppConfig) -> None:
+        """Select saved device by current ID, then by stable device name."""
+        self._device_combo.setCurrentIndex(0)
+        saved_name = _clean_device_name(cfg.audio_device_name).lower()
+
+        if cfg.audio_device_id is not None:
             for i in range(self._device_combo.count()):
-                if self._device_combo.itemData(i) == self._working.audio_device_id:
+                if self._device_combo.itemData(i) == cfg.audio_device_id:
+                    item_name = _clean_device_name(self._device_combo.itemText(i).split("] ", 1)[-1])
+                    if not saved_name or saved_name in item_name.lower():
+                        self._device_combo.setCurrentIndex(i)
+                        return
+
+        if saved_name:
+            for i in range(self._device_combo.count()):
+                item_data = self._device_combo.itemData(i)
+                item_name = _clean_device_name(self._device_combo.itemText(i).split("] ", 1)[-1])
+                if item_data is not None and saved_name in item_name.lower():
                     self._device_combo.setCurrentIndex(i)
-                    break
+                    return
 
     def _on_calibrate(self) -> None:
         """Run RMS auto-calibration via the provided callback."""
@@ -496,6 +523,10 @@ def _combo_index(combo: QComboBox, data: str) -> int:
     return -1
 
 
+def _clean_device_name(name: str) -> str:
+    return name.removesuffix(" (Default input)").strip()
+
+
 # ------------------------------------------------------------------
 # Standalone mode
 # ------------------------------------------------------------------