feat: implement all remaining upstream Handy PRs

- Local OpenAI-compatible API server on /v1/audio/transcriptions (cjpais#509)
- GNOME system shortcuts via gsettings for Wayland (cjpais#572)
- Wake word detection infrastructure with settings (cjpais#618)
- Live transcription mode settings (overlay/clipboard) (cjpais#832)
- Qwen3-ASR engine type placeholder for future transcribe-rs (cjpais#957)
- Prioritized microphone device list with fallback (cjpais#1070)
- Flatpak detection helper (cjpais#548)
- Storybook dev script (cjpais#784)

Author: DylanBricar

package.json

@@ -18,7 +18,8 @@
     "format:backend": "cd src-tauri && cargo fmt",
     "test:playwright": "playwright test",
     "test:playwright:ui": "playwright test --ui",
-    "check:translations": "bun scripts/check-translations.ts"
+    "check:translations": "bun scripts/check-translations.ts",
+    "storybook": "bunx --bun ladle serve --port 1422"
   },
   "dependencies": {
     "@tailwindcss/vite": "^4.1.16",

src-tauri/Cargo.lock

@@ -55,8 +55,10 @@ hound = "3.5.1"
 base64 = "0.22"
 log = "0.4.25"
 env_filter = "0.1.0"
-tokio = { version = "1.43.0", features = ["time"] }
+tokio = { version = "1.43.0", features = ["time", "rt", "macros"] }
 vad-rs = { git = "https://github.com/cjpais/vad-rs", default-features = false }
+axum = { version = "0.8", features = ["multipart"] }
+tower-http = { version = "0.6", features = ["cors"] }
 enigo = "0.6.1"
 arboard = "3.6"
 rodio = { git = "https://github.com/cjpais/rodio.git" }

src-tauri/Cargo.toml

@@ -0,0 +1,166 @@
+use axum::{
+    extract::{Multipart, State},
+    http::StatusCode,
+    response::Json,
+    routing::post,
+    Router,
+};
+use log::{error, info};
+use serde::Serialize;
+use std::sync::Arc;
+use tower_http::cors::CorsLayer;
+
+use crate::managers::transcription::TranscriptionManager;
+
+#[derive(Serialize)]
+struct TranscriptionResponse {
+    text: String,
+}
+
+#[derive(Serialize)]
+struct ErrorResponse {
+    error: ErrorDetail,
+}
+
+#[derive(Serialize)]
+struct ErrorDetail {
+    message: String,
+    r#type: String,
+}
+
+struct ApiState {
+    transcription_manager: Arc<TranscriptionManager>,
+}
+
+async fn transcribe_audio(
+    State(state): State<Arc<ApiState>>,
+    mut multipart: Multipart,
+) -> Result<Json<TranscriptionResponse>, (StatusCode, Json<ErrorResponse>)> {
+    let mut audio_data: Option<Vec<u8>> = None;
+    let mut _language: Option<String> = None;
+
+    while let Ok(Some(field)) = multipart.next_field().await {
+        let name = field.name().unwrap_or("").to_string();
+        match name.as_str() {
+            "file" => {
+                audio_data = field.bytes().await.ok().map(|b| b.to_vec());
+            }
+            "language" => {
+                _language = field.text().await.ok();
+            }
+            _ => {}
+        }
+    }
+
+    let audio_bytes = audio_data.ok_or_else(|| {
+        (
+            StatusCode::BAD_REQUEST,
+            Json(ErrorResponse {
+                error: ErrorDetail {
+                    message: "No audio file provided".to_string(),
+                    r#type: "invalid_request_error".to_string(),
+                },
+            }),
+        )
+    })?;
+
+    let samples = match load_audio_from_bytes(&audio_bytes) {
+        Ok(s) => s,
+        Err(e) => {
+            return Err((
+                StatusCode::BAD_REQUEST,
+                Json(ErrorResponse {
+                    error: ErrorDetail {
+                        message: format!("Failed to decode audio: {}", e),
+                        r#type: "invalid_request_error".to_string(),
+                    },
+                }),
+            ));
+        }
+    };
+
+    match state.transcription_manager.transcribe(samples, None) {
+        Ok(text) => Ok(Json(TranscriptionResponse { text })),
+        Err(e) => Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ErrorResponse {
+                error: ErrorDetail {
+                    message: format!("Transcription failed: {}", e),
+                    r#type: "server_error".to_string(),
+                },
+            }),
+        )),
+    }
+}
+
+fn load_audio_from_bytes(bytes: &[u8]) -> Result<Vec<f32>, String> {
+    use std::io::Cursor;
+    let reader = hound::WavReader::new(Cursor::new(bytes))
+        .map_err(|e| format!("Invalid WAV format: {}", e))?;
+
+    let spec = reader.spec();
+    let samples: Vec<f32> = match spec.sample_format {
+        hound::SampleFormat::Float => reader
+            .into_samples::<f32>()
+            .filter_map(|s| s.ok())
+            .collect(),
+        hound::SampleFormat::Int => {
+            let bits = spec.bits_per_sample;
+            let max_val = (1 << (bits - 1)) as f32;
+            reader
+                .into_samples::<i32>()
+                .filter_map(|s| s.ok())
+                .map(|s| s as f32 / max_val)
+                .collect()
+        }
+    };
+
+    let mono = if spec.channels > 1 {
+        samples
+            .chunks(spec.channels as usize)
+            .map(|frame| frame.iter().sum::<f32>() / spec.channels as f32)
+            .collect()
+    } else {
+        samples
+    };
+
+    Ok(mono)
+}
+
+pub fn start_api_server(
+    transcription_manager: Arc<TranscriptionManager>,
+    port: u16,
+) {
+    let state = Arc::new(ApiState {
+        transcription_manager,
+    });
+
+    std::thread::spawn(move || {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("Failed to create API server runtime");
+
+        rt.block_on(async {
+            let app = Router::new()
+                .route("/v1/audio/transcriptions", post(transcribe_audio))
+                .layer(CorsLayer::permissive())
+                .with_state(state);
+
+            let addr = format!("127.0.0.1:{}", port);
+            info!("Starting local API server on {}", addr);
+
+            let listener = tokio::net::TcpListener::bind(&addr).await;
+            match listener {
+                Ok(listener) => {
+                    if let Err(e) = axum::serve(listener, app).await {
+                        error!("API server error: {}", e);
+                    }
+                }
+                Err(e) => {
+                    error!("Failed to bind API server to {}: {}", addr, e);
+                }
+            }
+        });
+    });
+}

src-tauri/src/api_server.rs

@@ -1 +1,2 @@
 pub mod clamshell;
+pub mod platform;

src-tauri/src/helpers/mod.rs

@@ -0,0 +1,3 @@
+pub fn is_flatpak() -> bool {
+    std::path::Path::new("/.flatpak-info").exists()
+}