Merge branch 'main' into post_process_hotkey

- Resolved conflicts in src-tauri/src/actions.rs
  - Kept both TranscribeWithPostProcessAction and new CancelAction
- Resolved conflicts in src-tauri/src/lib.rs
  - Accepted specta_builder and typescript bindings export from main
- Resolved conflicts in src-tauri/src/settings.rs
  - Kept both transcribe_with_post_process and cancel bindings

Author: sammcj

.github/workflows/prettier.yml

@@ -0,0 +1,18 @@
+name: "prettier"
+on: [pull_request]
+
+jobs:
+  prettier:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run prettier
+        run: bun run format:check

README.md

@@ -82,6 +82,18 @@ This project is actively being developed and has some [known issues](https://git
 **Wayland Support (Linux):**
 
 - Limited or no support for Wayland display server
+- On Wayland the clipboard-based paste options (`Clipboard (CTRL+V)` / `Clipboard (Shift+Insert)`) copy the transcription once, then try to run [`wtype`](https://github.com/atx/wtype) (preferred) or [`dotool`](https://sr.ht/~geb/dotool/) to fire the paste keystroke. Install one of these tools to let Handy drive the compositor-friendly paste shortcut; otherwise it falls back to Enigo-generated key events, which may not work on Wayland.
+
+### Linux Notes
+
+- The recording overlay is disabled by default on Linux (`Overlay Position: None`) because certain compositors treat it as the active window. When the overlay is visible it can steal focus, which prevents Handy from pasting back into the application that triggered transcription. If you enable the overlay anyway, be aware that clipboard-based pasting might fail or end up in the wrong window.
+- You can manage global shortcuts outside of Handy and still control the app via signals. Sending `SIGUSR2` to the Handy process toggles recording on/off, which lets Wayland window managers or other hotkey daemons keep ownership of keybindings. Example (Sway):
+
+  ```ini
+  bindsym $mod+o exec pkill -USR2 -n handy
+  ```
+
+  `pkill` here simply delivers the signal—it does not terminate the process.
 
 ### Platform Support
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "handy-app",
   "private": true,
-  "version": "0.6.2",
+  "version": "0.6.4",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "handy"
-version = "0.6.2"
+version = "0.6.4"
 description = "Handy"
 authors = ["cjpais"]
 edition = "2021"
@@ -68,6 +68,9 @@ tar = "0.4.44"
 flate2 = "1.0"
 transcribe-rs = "0.1.4"
 ferrous-opencc = "0.2.3"
+specta = "=2.0.0-rc.22"
+specta-typescript = "0.0.9"
+tauri-specta = { version = "=2.0.0-rc.21", features = ["derive", "typescript"] }
 
 [target.'cfg(unix)'.dependencies]
 signal-hook = "0.3"
@@ -83,6 +86,8 @@ windows = { version = "0.61.3", features = [
   "Win32_Media_Audio_Endpoints",
   "Win32_System_Com_StructuredStorage",
   "Win32_System_Variant",
+  "Win32_Foundation",
+  "Win32_UI_WindowsAndMessaging",
 ] }
 
 [target.'cfg(target_os = "macos")'.dependencies]

src-tauri/Cargo.toml

@@ -2,10 +2,10 @@ use crate::audio_feedback::{play_feedback_sound, play_feedback_sound_blocking, S
 use crate::managers::audio::AudioRecordingManager;
 use crate::managers::history::HistoryManager;
 use crate::managers::transcription::TranscriptionManager;
-use crate::overlay::{show_recording_overlay, show_transcribing_overlay};
 use crate::settings::{get_settings, AppSettings};
+use crate::shortcut;
 use crate::tray::{change_tray_icon, TrayIconState};
-use crate::utils;
+use crate::utils::{self, show_recording_overlay, show_transcribing_overlay};
 use async_openai::types::{
     ChatCompletionRequestMessage, ChatCompletionRequestUserMessageArgs,
     CreateChatCompletionRequestArgs,
@@ -226,6 +226,7 @@ impl ShortcutAction for TranscribeAction {
         let is_always_on = settings.always_on_microphone;
         debug!("Microphone mode - always_on: {}", is_always_on);
 
+        let mut recording_started = false;
         if is_always_on {
             // Always-on mode: Play audio feedback immediately, then apply mute after sound finishes
             debug!("Always-on mode: Playing audio feedback immediately");
@@ -238,14 +239,15 @@ impl ShortcutAction for TranscribeAction {
                 rm_clone.apply_mute();
             });
 
-            let recording_started = rm.try_start_recording(&binding_id);
+            recording_started = rm.try_start_recording(&binding_id);
             debug!("Recording started: {}", recording_started);
         } else {
             // On-demand mode: Start recording first, then play audio feedback, then apply mute
             // This allows the microphone to be activated before playing the sound
             debug!("On-demand mode: Starting recording first, then audio feedback");
             let recording_start_time = Instant::now();
             if rm.try_start_recording(&binding_id) {
+                recording_started = true;
                 debug!("Recording started in {:?}", recording_start_time.elapsed());
                 // Small delay to ensure microphone stream is active
                 let app_clone = app.clone();
@@ -263,13 +265,21 @@ impl ShortcutAction for TranscribeAction {
             }
         }
 
+        if recording_started {
+            // Dynamically register the cancel shortcut in a separate task to avoid deadlock
+            shortcut::register_cancel_shortcut(app);
+        }
+
         debug!(
             "TranscribeAction::start completed in {:?}",
             start_time.elapsed()
         );
     }
 
     fn stop(&self, app: &AppHandle, binding_id: &str, _shortcut_str: &str) {
+        // Unregister the cancel shortcut when transcription stops
+        shortcut::unregister_cancel_shortcut(app);
+
         let stop_time = Instant::now();
         debug!("TranscribeAction::stop called for binding: {}", binding_id);
 
@@ -609,6 +619,19 @@ impl ShortcutAction for TranscribeWithPostProcessAction {
     }
 }
 
+// Cancel Action
+struct CancelAction;
+
+impl ShortcutAction for CancelAction {
+    fn start(&self, app: &AppHandle, _binding_id: &str, _shortcut_str: &str) {
+        utils::cancel_current_operation(app);
+    }
+
+    fn stop(&self, _app: &AppHandle, _binding_id: &str, _shortcut_str: &str) {
+        // Nothing to do on stop for cancel
+    }
+}
+
 // Test Action
 struct TestAction;
 
@@ -643,6 +666,10 @@ pub static ACTION_MAP: Lazy<HashMap<String, Arc<dyn ShortcutAction>>> = Lazy::ne
         "transcribe_with_post_process".to_string(),
         Arc::new(TranscribeWithPostProcessAction) as Arc<dyn ShortcutAction>,
     );
+    map.insert(
+        "cancel".to_string(),
+        Arc::new(CancelAction) as Arc<dyn ShortcutAction>,
+    );
     map.insert(
         "test".to_string(),
         Arc::new(TestAction) as Arc<dyn ShortcutAction>,

src-tauri/src/actions.rs

@@ -63,7 +63,7 @@ pub fn play_feedback_sound_blocking(app: &AppHandle, sound_type: SoundType) {
 pub fn play_test_sound(app: &AppHandle, sound_type: SoundType) {
     let settings = settings::get_settings(app);
     if let Some(path) = resolve_sound_path(app, &settings, sound_type) {
-        play_sound_async(app, path);
+        play_sound_blocking(app, &path);
     }
 }
 

src-tauri/src/audio_feedback.rs

@@ -204,19 +204,36 @@ impl AudioRecorder {
         device: &cpal::Device,
     ) -> Result<cpal::SupportedStreamConfig, Box<dyn std::error::Error>> {
         let supported_configs = device.supported_input_configs()?;
+        let mut best_config: Option<cpal::SupportedStreamConfigRange> = None;
 
-        // Try to find a config that supports 16kHz
+        // Try to find a config that supports 16kHz, prioritizing better formats
         for config_range in supported_configs {
             if config_range.min_sample_rate().0 <= constants::WHISPER_SAMPLE_RATE
                 && config_range.max_sample_rate().0 >= constants::WHISPER_SAMPLE_RATE
             {
-                // Found a config that supports 16kHz, use it
-                return Ok(
-                    config_range.with_sample_rate(cpal::SampleRate(constants::WHISPER_SAMPLE_RATE))
-                );
+                match best_config {
+                    None => best_config = Some(config_range),
+                    Some(ref current) => {
+                        // Prioritize F32 > I16 > I32 > others
+                        let score = |fmt: cpal::SampleFormat| match fmt {
+                            cpal::SampleFormat::F32 => 4,
+                            cpal::SampleFormat::I16 => 3,
+                            cpal::SampleFormat::I32 => 2,
+                            _ => 1,
+                        };
+
+                        if score(config_range.sample_format()) > score(current.sample_format()) {
+                            best_config = Some(config_range);
+                        }
+                    }
+                }
             }
         }
 
+        if let Some(config) = best_config {
+            return Ok(config.with_sample_rate(cpal::SampleRate(constants::WHISPER_SAMPLE_RATE)));
+        }
+
         // If no config supports 16kHz, fall back to default
         Ok(device.default_input_config()?)
     }