Update 2026-03-13

Author: vimalinx

docs/assistant-key-detector.html

@@ -226,6 +226,56 @@ def test_rear_button_state_matrix(self) -> None:
                     self.assertEqual(worker_calls, [])
                     self.assertEqual(send_enter_calls, ["enter"])
 
+    def test_recording_submit_press_stops_recording_and_routes_to_openclaw(self) -> None:
+        subject = self._make_subject()
+        recording = SimpleNamespace(duration_s=0.7, path=Path("/tmp/submit.wav"))
+        setattr(
+            subject,
+            "_recorder",
+            SimpleNamespace(is_recording=True, stop_and_save=lambda: recording),
+        )
+        setattr(subject, "_config", SimpleNamespace(enter_mode="enter"))
+
+        status_values: list[bool] = []
+        worker_calls: list[tuple[object, str]] = []
+        send_enter_calls: list[str] = []
+        setattr(
+            subject, "_set_recording_status", lambda value: status_values.append(value)
+        )
+        setattr(
+            subject,
+            "_start_transcription_worker",
+            lambda rec, *, output_target: worker_calls.append((rec, output_target)),
+        )
+        setattr(
+            subject,
+            "_output",
+            SimpleNamespace(send_enter=lambda mode: send_enter_calls.append(mode)),
+        )
+
+        on_submit = cast(
+            Callable[[], None], getattr(subject, "_on_recording_submit_press")
+        )
+        on_submit()
+
+        self.assertEqual(status_values, [False])
+        self.assertEqual(worker_calls, [(recording, "openclaw")])
+        self.assertEqual(send_enter_calls, [])
+
+    def test_recording_submit_press_is_ignored_when_idle(self) -> None:
+        subject = self._make_subject()
+        setattr(subject, "_recorder", SimpleNamespace(is_recording=False))
+
+        rear_calls: list[bool] = []
+        setattr(subject, "_on_rear_press", lambda: rear_calls.append(True))
+
+        on_submit = cast(
+            Callable[[], None], getattr(subject, "_on_recording_submit_press")
+        )
+        on_submit()
+
+        self.assertEqual(rear_calls, [])
+
     def test_transcribe_and_output_openclaw_uses_openclaw_sender(self) -> None:
         subject = self._make_subject()
         recording = SimpleNamespace(duration_s=1.0, path=Path("/tmp/transcribe.wav"))

tests/test_app.py

@@ -36,6 +36,7 @@ def test_defaults_disable_trust_remote_code(self) -> None:
         self.assertEqual(config.front_button, "x1")
         self.assertEqual(config.rear_button, "x2")
         self.assertEqual(config.record_hotkey_keycodes, (42, 125, 193))
+        self.assertIsNone(config.recording_submit_keycode)
 
     def test_record_hotkey_keycodes_can_be_configured(self) -> None:
         with patch.dict(
@@ -67,6 +68,26 @@ def test_duplicate_record_hotkey_keycodes_are_rejected(self) -> None:
             ):
                 _ = load_config()
 
+    def test_recording_submit_keycode_can_be_configured(self) -> None:
+        with patch.dict(
+            os.environ,
+            {"VIBEMOUSE_RECORDING_SUBMIT_KEYCODE": "28"},
+            clear=True,
+        ):
+            config = load_config()
+
+        self.assertEqual(config.recording_submit_keycode, 28)
+
+    def test_blank_recording_submit_keycode_disables_listener(self) -> None:
+        with patch.dict(
+            os.environ,
+            {"VIBEMOUSE_RECORDING_SUBMIT_KEYCODE": ""},
+            clear=True,
+        ):
+            config = load_config()
+
+        self.assertIsNone(config.recording_submit_keycode)
+
     def test_trust_remote_code_can_be_enabled(self) -> None:
         with patch.dict(
             os.environ, {"VIBEMOUSE_TRUST_REMOTE_CODE": "true"}, clear=True

tests/test_config.py

@@ -1041,7 +1041,7 @@ def _mark_gesture(direction: str) -> None:
         finish_capture.assert_not_called()
 
 
-    def test_front_click_path_skips_button_suppress_grab(self) -> None:
+    def test_front_click_path_does_not_use_button_suppress_grab(self) -> None:
         class _FakeEvent:
             def __init__(self, event_type: int, code: int, value: int) -> None:
                 self.type = event_type

tests/test_mouse_listener.py

@@ -11,12 +11,18 @@
 
 
 class _FakeKeyboardController:
-    def __init__(self, *, fail_on_press: bool = False) -> None:
+    def __init__(
+        self,
+        *,
+        fail_on_press: bool = False,
+        fail_on_press_key: object | None = None,
+    ) -> None:
         self.events: list[tuple[str, object]] = []
         self._fail_on_press: bool = fail_on_press
+        self._fail_on_press_key: object | None = fail_on_press_key
 
     def press(self, key: object) -> None:
-        if self._fail_on_press:
+        if self._fail_on_press or key == self._fail_on_press_key:
             raise RuntimeError("press failed")
         self.events.append(("press", key))
 
@@ -614,6 +620,39 @@ def test_auto_paste_non_hyprland_shortcut_failure_falls_back_to_ctrl_v(
             ],
         )
 
+    def test_auto_paste_ctrl_v_failure_releases_ctrl_and_falls_back_to_clipboard(
+        self,
+    ) -> None:
+        subject = self._make_subject()
+        keyboard = _FakeKeyboardController(fail_on_press_key="v")
+        self._bind_keyboard(subject, keyboard)
+        setattr(subject, "_is_text_input_focused", self._not_focused)
+        setattr(subject, "_hyprland_session", False)
+        setattr(
+            subject,
+            "_system_integration",
+            SimpleNamespace(
+                send_shortcut=lambda mod, key: False,
+                is_terminal_window_active=lambda: False,
+                paste_shortcuts=lambda terminal_active: (),
+                send_enter_via_accessibility=lambda: None,
+                is_text_input_focused=lambda: None,
+            ),
+        )
+
+        with patch("vibemouse.output.pyperclip.copy") as copy_mock:
+            route = subject.inject_or_clipboard("hello", auto_paste=True)
+
+        self.assertEqual(route, "clipboard")
+        self.assertEqual(copy_mock.call_count, 1)
+        self.assertEqual(
+            keyboard.events,
+            [
+                ("press", "CTRL"),
+                ("release", "CTRL"),
+            ],
+        )
+
     def test_hyprland_terminal_detection_by_window_class(self) -> None:
         subject = self._make_subject()
         keyboard = _FakeKeyboardController()
@@ -827,6 +866,22 @@ def test_send_enter_supports_ctrl_enter(self) -> None:
             ],
         )
 
+    def test_send_enter_ctrl_enter_failure_releases_modifier(self) -> None:
+        subject = self._make_subject()
+        keyboard = _FakeKeyboardController(fail_on_press_key="ENTER")
+        self._bind_keyboard(subject, keyboard)
+
+        with self.assertRaisesRegex(RuntimeError, "press failed"):
+            subject.send_enter(mode="ctrl_enter")
+
+        self.assertEqual(
+            keyboard.events,
+            [
+                ("press", "CTRL"),
+                ("release", "CTRL"),
+            ],
+        )
+
     def test_send_enter_supports_shift_enter(self) -> None:
         subject = self._make_subject()
         keyboard = _FakeKeyboardController()

tests/test_output.py

@@ -60,6 +60,13 @@ def __init__(self, config: AppConfig) -> None:
             keycodes=config.record_hotkey_keycodes,
             debounce_s=config.button_debounce_ms / 1000.0,
         )
+        self._recording_submit_listener: KeyboardHotkeyListener | None = None
+        if config.recording_submit_keycode is not None:
+            self._recording_submit_listener = KeyboardHotkeyListener(
+                on_hotkey=self._on_recording_submit_press,
+                keycodes=(config.recording_submit_keycode,),
+                debounce_s=config.button_debounce_ms / 1000.0,
+            )
         self._stop_event: threading.Event = threading.Event()
         self._transcribe_lock: threading.Lock = threading.Lock()
         self._workers_lock: threading.Lock = threading.Lock()
@@ -69,14 +76,18 @@ def __init__(self, config: AppConfig) -> None:
     def run(self) -> None:
         self._listener.start()
         self._keyboard_listener.start()
+        if self._recording_submit_listener is not None:
+            self._recording_submit_listener.start()
         self._set_recording_status(False)
+        recording_submit_hotkey = self._config.recording_submit_keycode
         _LOG.info(
             "VibeMouse ready. "
             + f"Model={self._config.model_name}, preferred_device={self._config.device}, "
             + f"backend={self._config.transcriber_backend}, auto_paste={self._config.auto_paste}, "
             + f"enter_mode={self._config.enter_mode}, debounce_ms={self._config.button_debounce_ms}, "
             + f"front_button={self._config.front_button}, rear_button={self._config.rear_button}, "
             + f"record_hotkey_keycodes={self._config.record_hotkey_keycodes}, "
+            + f"recording_submit_keycode={recording_submit_hotkey}, "
             + f"gestures_enabled={self._config.gestures_enabled}, "
             + f"gesture_trigger={self._config.gesture_trigger_button}, "
             + f"gesture_threshold_px={self._config.gesture_threshold_px}, "
@@ -97,6 +108,8 @@ def run(self) -> None:
     def shutdown(self) -> None:
         self._listener.stop()
         self._keyboard_listener.stop()
+        if self._recording_submit_listener is not None:
+            self._recording_submit_listener.stop()
         self._recorder.cancel()
         self._set_recording_status(False)
         with self._workers_lock:
@@ -159,6 +172,12 @@ def _on_rear_press(self) -> None:
         except Exception as error:
             _LOG.exception("Failed to send Enter: %s", error)
 
+    def _on_recording_submit_press(self) -> None:
+        if not self._recorder.is_recording:
+            return
+        _LOG.info("Recording submit hotkey pressed, routing to rear-button logic")
+        self._on_rear_press()
+
     def _on_gesture(self, direction: str) -> None:
         action = self._resolve_gesture_action(direction)
         if action == "noop":

vibemouse/app.py

@@ -23,6 +23,19 @@ def _read_int(name: str, default: int) -> int:
         raise ValueError(f"{name} must be an integer, got {raw!r}") from error
 
 
+def _read_optional_int(name: str) -> int | None:
+    raw = os.getenv(name)
+    if raw is None:
+        return None
+    normalized = raw.strip()
+    if not normalized:
+        return None
+    try:
+        return int(normalized)
+    except ValueError as error:
+        raise ValueError(f"{name} must be an integer, got {raw!r}") from error
+
+
 def _read_float(name: str, default: float) -> float:
     raw = os.getenv(name)
     if raw is None:
@@ -111,6 +124,7 @@ class AppConfig:
     front_button: str
     rear_button: str
     record_hotkey_keycodes: tuple[int, ...]
+    recording_submit_keycode: int | None
     temp_dir: Path
 
 
@@ -157,6 +171,14 @@ def load_config() -> AppConfig:
     )
     if len(record_hotkey_keycodes) != 3:
         raise ValueError("VIBEMOUSE_RECORD_HOTKEY_CODE_1/2/3 must be distinct")
+    recording_submit_keycode = _read_optional_int(
+        "VIBEMOUSE_RECORDING_SUBMIT_KEYCODE"
+    )
+    if recording_submit_keycode is not None:
+        recording_submit_keycode = _require_non_negative(
+            "VIBEMOUSE_RECORDING_SUBMIT_KEYCODE",
+            recording_submit_keycode,
+        )
     if front_button == rear_button:
         raise ValueError("VIBEMOUSE_FRONT_BUTTON and VIBEMOUSE_REAR_BUTTON must differ")
     button_debounce_ms = _require_non_negative(
@@ -269,5 +291,6 @@ def load_config() -> AppConfig:
         front_button=front_button,
         rear_button=rear_button,
         record_hotkey_keycodes=record_hotkey_keycodes,
+        recording_submit_keycode=recording_submit_keycode,
         temp_dir=temp_dir,
     )

vibemouse/config.py

@@ -179,10 +179,27 @@ def _paste_clipboard(self) -> None:
         ):
             return
 
-        self._kb.press(self._ctrl_key)
-        self._kb.press("v")
-        self._kb.release("v")
-        self._kb.release(self._ctrl_key)
+        self._send_ctrl_v_via_keyboard()
+
+    def _send_ctrl_v_via_keyboard(self) -> None:
+        pressed_ctrl = False
+        pressed_v = False
+        try:
+            self._kb.press(self._ctrl_key)
+            pressed_ctrl = True
+            self._kb.press("v")
+            pressed_v = True
+        finally:
+            if pressed_v:
+                try:
+                    self._kb.release("v")
+                except Exception:
+                    pass
+            if pressed_ctrl:
+                try:
+                    self._kb.release(self._ctrl_key)
+                except Exception:
+                    pass
 
     def _send_ctrl_shift_v_via_keyboard(self) -> bool:
         pressed_ctrl = False
@@ -244,11 +261,25 @@ def _tap_key(self, key: object) -> None:
         self._kb.release(key)
 
     def _tap_modified_key(self, modifier: object, key: object) -> None:
-        self._kb.press(modifier)
-        self._kb.press(key)
-        time.sleep(0.012)
-        self._kb.release(key)
-        self._kb.release(modifier)
+        pressed_modifier = False
+        pressed_key = False
+        try:
+            self._kb.press(modifier)
+            pressed_modifier = True
+            self._kb.press(key)
+            pressed_key = True
+            time.sleep(0.012)
+        finally:
+            if pressed_key:
+                try:
+                    self._kb.release(key)
+                except Exception:
+                    pass
+            if pressed_modifier:
+                try:
+                    self._kb.release(modifier)
+                except Exception:
+                    pass
 
     def _send_enter_via_atspi(self) -> bool:
         try: