A free, open source, and extensible speech-to-text application that works completely offline.
//! Keyboard shortcut management module
//!
//! This module provides a unified interface for keyboard shortcuts with
//! multiple backend implementations:
//!
//! - `tauri`: Uses Tauri's built-in global-shortcut plugin
//! - `handy_keys`: Uses the handy-keys library for more control
//!
//! The active implementation is determined by the `keyboard_implementation`
//! setting and can be changed at runtime.
mod handler;
pub mod handy_keys;
pub mod tauri_impl;
use log::{debug, error, info, warn};
use serde::Serialize;
use specta::Type;
use std::sync::atomic::{AtomicBool, Ordering};
use tauri::{AppHandle, Emitter, Manager};
#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
use crate::settings::APPLE_INTELLIGENCE_DEFAULT_MODEL_ID;
use crate::settings::{
self, get_settings, AutoSubmitKey, ChineseScript, ClipboardHandling, KeyboardImplementation,
LLMPrompt, LanguageDetectionMode, OverlayPosition, OverlayStyle, PasteMethod,
ShortcutActivation, ShortcutBinding, SoundTheme, Theme, TypingTool, VadBackend,
APPLE_INTELLIGENCE_PROVIDER_ID,
};
use crate::tray;
// Note: Commands are accessed via shortcut::handy_keys:: in lib.rs
/// Initialize shortcuts using the configured implementation
pub fn init_shortcuts(app: &AppHandle) {
let user_settings = settings::load_or_create_app_settings(app);
// Check which implementation to use
match user_settings.keyboard_implementation {
KeyboardImplementation::Tauri => {
tauri_impl::init_shortcuts(app);
}
KeyboardImplementation::HandyKeys => {
if let Err(e) = handy_keys::init_shortcuts(app) {
error!("Failed to initialize handy-keys shortcuts: {}", e);
// Fall back to Tauri implementation and persist this fallback
warn!("Falling back to Tauri global shortcut implementation and saving fallback to settings");
// Update settings to persist the fallback so we don't retry HandyKeys on next launch
let mut settings = settings::get_settings(app);
settings.keyboard_implementation = KeyboardImplementation::Tauri;
settings::write_settings(app, settings);
tauri_impl::init_shortcuts(app);
}
}
KeyboardImplementation::None => {
info!("Built-in keyboard shortcuts disabled; use CLI flags or signals");
}
}
}
/// Whether the recording lifecycle currently wants the cancel shortcut.
/// Written synchronously by start/stop, so it always holds the latest request.
static CANCEL_REQUESTED: AtomicBool = AtomicBool::new(false);
/// Whether the cancel shortcut is actually registered with the backend.
/// The lock also serializes reconciliation passes.
#[cfg(not(target_os = "linux"))]
static CANCEL_REGISTERED: std::sync::Mutex<bool> = std::sync::Mutex::new(false);
/// Register the cancel shortcut (called when recording starts)
pub fn register_cancel_shortcut(app: &AppHandle) {
// Track recording lifecycle independently of the current implementation so
// switching implementations mid-recording cannot leave stale fallback state.
crate::secure_input::register_cancel_fallback(app);
CANCEL_REQUESTED.store(true, Ordering::SeqCst);
schedule_cancel_reconcile(app);
}
/// Unregister the cancel shortcut (called when recording stops)
pub fn unregister_cancel_shortcut(app: &AppHandle) {
crate::secure_input::unregister_cancel_fallback(app);
CANCEL_REQUESTED.store(false, Ordering::SeqCst);
schedule_cancel_reconcile(app);
}
/// Apply the requested cancel state off the calling thread. Start and stop run
/// on the shortcut handler thread, which must not block on registration, so the
/// work is spawned. Spawned tasks may run in any order (a very short recording
/// can see its unregister task run before its register task), so each pass
/// applies the latest request instead of the action that scheduled it.
fn schedule_cancel_reconcile(app: &AppHandle) {
let app = app.clone();
tauri::async_runtime::spawn(async move {
reconcile_cancel_shortcut(&app);
});
}
fn reconcile_cancel_shortcut(app: &AppHandle) {
// Cancel shortcut is disabled on Linux due to instability with dynamic shortcut registration
#[cfg(target_os = "linux")]
{
let _ = app;
return;
}
#[cfg(not(target_os = "linux"))]
{
let mut registered = CANCEL_REGISTERED.lock().unwrap_or_else(|e| e.into_inner());
let requested = CANCEL_REQUESTED.load(Ordering::SeqCst);
if requested == *registered {
return;
}
let Some(cancel_binding) = get_settings(app).bindings.get("cancel").cloned() else {
return;
};
if requested {
match register_shortcut(app, cancel_binding) {
Ok(()) => *registered = true,
Err(e) => error!("Failed to register cancel shortcut: {}", e),
}
} else {
match unregister_shortcut(app, cancel_binding) {
Ok(()) => *registered = false,
Err(e) => error!("Failed to unregister cancel shortcut: {}", e),
}
}
}
}
/// Register a shortcut using the appropriate implementation
pub fn register_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), String> {
let settings = get_settings(app);
match settings.keyboard_implementation {
KeyboardImplementation::Tauri => tauri_impl::register_shortcut(app, binding),
KeyboardImplementation::HandyKeys => handy_keys::register_shortcut(app, binding),
KeyboardImplementation::None => Ok(()),
}
}
/// Unregister a shortcut using the appropriate implementation
pub fn unregister_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), String> {
let settings = get_settings(app);
match settings.keyboard_implementation {
KeyboardImplementation::Tauri => tauri_impl::unregister_shortcut(app, binding),
KeyboardImplementation::HandyKeys => handy_keys::unregister_shortcut(app, binding),
KeyboardImplementation::None => Ok(()),
}
}
// ============================================================================
// Binding Management Commands
// ============================================================================
#[derive(Serialize, Type)]
pub struct BindingResponse {
success: bool,
binding: Option<ShortcutBinding>,
error: Option<String>,
}
#[tauri::command]
#[specta::specta]
pub fn change_binding(
app: AppHandle,
id: String,
binding: String,
) -> Result<BindingResponse, String> {
// Reject empty bindings — every shortcut should have a value
if binding.trim().is_empty() {
return Err("Binding cannot be empty".to_string());
}
let mut settings = settings::get_settings(&app);
// Get the binding to modify, or create it from defaults if it doesn't exist
let binding_to_modify = match settings.bindings.get(&id) {
Some(binding) => binding.clone(),
None => {
// Try to get the default binding for this id
let default_settings = settings::get_default_settings();
match default_settings.bindings.get(&id) {
Some(default_binding) => {
warn!(
"Binding '{}' not found in settings, creating from defaults",
id
);
default_binding.clone()
}
None => {
let error_msg = format!("Binding with id '{}' not found in defaults", id);
warn!("change_binding error: {}", error_msg);
return Ok(BindingResponse {
success: false,
binding: None,
error: Some(error_msg),
});
}
}
}
};
// If this is the cancel binding, just update the settings and return
// It's managed dynamically, so we don't register/unregister here
if id == "cancel" {
if let Some(mut b) = settings.bindings.get(&id).cloned() {
b.current_binding = binding;
settings.bindings.insert(id.clone(), b.clone());
settings::write_settings(&app, settings);
crate::secure_input::reconcile_fallback(&app);
return Ok(BindingResponse {
success: true,
binding: Some(b.clone()),
error: None,
});
}
}
// Unregister the existing binding
if let Err(e) = unregister_shortcut(&app, binding_to_modify.clone()) {
let error_msg = format!("Failed to unregister shortcut: {}", e);
error!("change_binding error: {}", error_msg);
}
// Validate the new shortcut for the current keyboard implementation
if let Err(e) = validate_shortcut_for_implementation(&binding, settings.keyboard_implementation)
{
warn!("change_binding validation error: {}", e);
restore_registration(&app, &binding_to_modify);
return Err(e);
}
// Create an updated binding
let mut updated_binding = binding_to_modify.clone();
updated_binding.current_binding = binding;
// Register the new binding
if let Err(e) = register_shortcut(&app, updated_binding.clone()) {
let error_msg = format!("Failed to register shortcut: {}", e);
error!("change_binding error: {}", error_msg);
restore_registration(&app, &binding_to_modify);
return Ok(BindingResponse {
success: false,
binding: None,
error: Some(error_msg),
});
}
// Update the binding in the settings
settings.bindings.insert(id, updated_binding.clone());
// Save the settings and synchronize any active Secure Input shadows.
settings::write_settings(&app, settings);
crate::secure_input::reconcile_fallback(&app);
// Return the updated binding
Ok(BindingResponse {
success: true,
binding: Some(updated_binding),
error: None,
})
}
/// Best-effort re-register of the previous binding after a failed change,
/// so a failure leaves the user's shortcut working exactly as before.
fn restore_registration(app: &AppHandle, binding: &ShortcutBinding) {
if let Err(e) = register_shortcut(app, binding.clone()) {
error!(
"Failed to restore previous binding '{}' ({}): {}",
binding.id, binding.current_binding, e
);
}
}
#[tauri::command]
#[specta::specta]
pub fn reset_binding(app: AppHandle, id: String) -> Result<BindingResponse, String> {
let binding = settings::get_stored_binding(&settings::get_settings(&app), &id)?;
change_binding(app, id, binding.default_binding)
}
/// Unregister every binding while the user is recording a new shortcut in
/// the UI, so no existing shortcut can fire — or swallow the keystrokes —
/// mid-capture. The "cancel" binding is untouched: it is managed dynamically
/// by the recording lifecycle.
pub fn suspend_all_shortcuts(app: &AppHandle) {
for (id, binding) in settings::get_bindings(app) {
if id == "cancel" {
continue;
}
if let Err(e) = unregister_shortcut(app, binding) {
debug!(
"suspend_all_shortcuts: could not unregister '{}': {}",
id, e
);
}
}
}
/// Re-register every binding from settings after shortcut recording ends.
/// Registering an already-registered shortcut fails cleanly in both
/// implementations, so this is idempotent and safe on every exit path.
pub fn resume_all_shortcuts(app: &AppHandle) {
let settings = get_settings(app);
for (id, binding) in &settings.bindings {
if id == "cancel" {
continue;
}
if id == "transcribe_with_post_process" && !settings.post_process_enabled {
continue;
}
if let Err(e) = register_shortcut(app, binding.clone()) {
debug!("resume_all_shortcuts: could not register '{}': {}", id, e);
}
}
}
/// Temporarily unregister all bindings while the user is recording a
/// shortcut in the UI. This avoids firing actions while keys are recorded.
#[tauri::command]
#[specta::specta]
pub fn suspend_all_bindings(app: AppHandle) -> Result<(), String> {
suspend_all_shortcuts(&app);
Ok(())
}
/// Re-register all bindings after the user has finished recording.
#[tauri::command]
#[specta::specta]
pub fn resume_all_bindings(app: AppHandle) -> Result<(), String> {
resume_all_shortcuts(&app);
Ok(())
}
// ============================================================================
// Keyboard Implementation Switching
// ============================================================================
/// Result of changing keyboard implementation
#[derive(Serialize, Type)]
pub struct ImplementationChangeResult {
pub success: bool,
/// List of binding IDs that were reset to defaults due to incompatibility
pub reset_bindings: Vec<String>,
}
/// Change the keyboard implementation with runtime switching.
/// This will unregister all shortcuts from the old implementation,
/// validate shortcuts for the new implementation (resetting invalid ones to defaults),
/// and register them with the new implementation.
#[tauri::command]
#[specta::specta]
pub fn change_keyboard_implementation_setting(
app: AppHandle,
implementation: String,
) -> Result<ImplementationChangeResult, String> {
let current_settings = settings::get_settings(&app);
let current_impl = current_settings.keyboard_implementation;
let new_impl = parse_keyboard_implementation(&implementation);
// If same implementation, nothing to do
if current_impl == new_impl {
return Ok(ImplementationChangeResult {
success: true,
reset_bindings: vec![],
});
}
info!(
"Switching keyboard implementation from {:?} to {:?}",
current_impl, new_impl
);
// Unregister all shortcuts from the current implementation
unregister_all_shortcuts(&app, current_impl);
// Update the setting
let mut settings = settings::get_settings(&app);
settings.keyboard_implementation = new_impl;
settings::write_settings(&app, settings);
// Carbon fallback registrations use the Tauri plugin. Remove them before
// registering the full Tauri implementation to avoid duplicate conflicts.
if new_impl == KeyboardImplementation::Tauri {
crate::secure_input::reconcile_fallback(&app);
}
// Initialize new implementation if needed (HandyKeys needs state)
if new_impl == KeyboardImplementation::HandyKeys && initialize_handy_keys_with_rollback(&app)? {
// Shortcuts already registered during init.
crate::secure_input::reconcile_fallback(&app);
return Ok(ImplementationChangeResult {
success: true,
reset_bindings: vec![],
});
}
// Register all shortcuts with new implementation, resetting invalid ones
let reset_bindings = register_all_shortcuts_for_implementation(&app, new_impl);
crate::secure_input::reconcile_fallback(&app);
// Emit event to notify frontend of the change
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "keyboard_implementation",
"value": implementation,
"reset_bindings": reset_bindings
}),
);
info!("Keyboard implementation switched to {:?}", new_impl);
Ok(ImplementationChangeResult {
success: true,
reset_bindings,
})
}
/// Get the current keyboard implementation
#[tauri::command]
#[specta::specta]
pub fn get_keyboard_implementation(app: AppHandle) -> String {
let settings = settings::get_settings(&app);
match settings.keyboard_implementation {
KeyboardImplementation::Tauri => "tauri".to_string(),
KeyboardImplementation::HandyKeys => "handy_keys".to_string(),
KeyboardImplementation::None => "none".to_string(),
}
}
// ============================================================================
// Validation Helpers
// ============================================================================
/// Validate a shortcut for a specific implementation
fn validate_shortcut_for_implementation(
raw: &str,
implementation: KeyboardImplementation,
) -> Result<(), String> {
match implementation {
KeyboardImplementation::Tauri => tauri_impl::validate_shortcut(raw),
KeyboardImplementation::HandyKeys => handy_keys::validate_shortcut(raw),
KeyboardImplementation::None => Ok(()),
}
}
/// Parse a keyboard implementation string into the enum
fn parse_keyboard_implementation(s: &str) -> KeyboardImplementation {
match s {
"tauri" => KeyboardImplementation::Tauri,
"handy_keys" => KeyboardImplementation::HandyKeys,
"none" => KeyboardImplementation::None,
other => {
warn!(
"Invalid keyboard implementation '{}', defaulting to tauri",
other
);
KeyboardImplementation::Tauri
}
}
}
/// Unregister all shortcuts for the current implementation
fn unregister_all_shortcuts(app: &AppHandle, implementation: KeyboardImplementation) {
let bindings = settings::get_bindings(app);
for (id, binding) in bindings {
// Skip cancel shortcut as it's dynamically registered
if id == "cancel" {
continue;
}
let result = match implementation {
KeyboardImplementation::Tauri => tauri_impl::unregister_shortcut(app, binding),
KeyboardImplementation::HandyKeys => handy_keys::unregister_shortcut(app, binding),
KeyboardImplementation::None => Ok(()),
};
if let Err(e) = result {
warn!(
"Failed to unregister shortcut '{}' during switch: {}",
id, e
);
}
}
}
/// Register all shortcuts for a specific implementation, validating and resetting invalid ones
fn register_all_shortcuts_for_implementation(
app: &AppHandle,
implementation: KeyboardImplementation,
) -> Vec<String> {
let mut reset_bindings = Vec::new();
let default_bindings = settings::get_default_settings().bindings;
let mut current_settings = settings::get_settings(app);
for (id, default_binding) in &default_bindings {
// Skip cancel shortcut as it's dynamically registered
if id == "cancel" {
continue;
}
// Skip post-processing shortcut when the feature is disabled
if id == "transcribe_with_post_process" && !current_settings.post_process_enabled {
continue;
}
let mut binding = current_settings
.bindings
.get(id)
.cloned()
.unwrap_or_else(|| default_binding.clone());
// Validate the shortcut for the target implementation
if let Err(e) =
validate_shortcut_for_implementation(&binding.current_binding, implementation)
{
info!(
"Shortcut '{}' ({}) is invalid for {:?}: {}. Resetting to default.",
id, binding.current_binding, implementation, e
);
// Reset to default
binding.current_binding = default_binding.current_binding.clone();
current_settings
.bindings
.insert(id.clone(), binding.clone());
reset_bindings.push(id.clone());
}
// Register with the appropriate implementation
let result = match implementation {
KeyboardImplementation::Tauri => tauri_impl::register_shortcut(app, binding),
KeyboardImplementation::HandyKeys => handy_keys::register_shortcut(app, binding),
KeyboardImplementation::None => Ok(()),
};
if let Err(e) = result {
error!(
"Failed to register shortcut '{}' for {:?}: {}",
id, implementation, e
);
}
}
// Save settings if any bindings were reset
if !reset_bindings.is_empty() {
settings::write_settings(app, current_settings);
}
reset_bindings
}
/// Initialize HandyKeys if not already initialized, with rollback on failure
fn initialize_handy_keys_with_rollback(app: &AppHandle) -> Result<bool, String> {
if app.try_state::<handy_keys::HandyKeysState>().is_some() {
return Ok(false); // Already initialized, caller should continue
}
if let Err(e) = handy_keys::init_shortcuts(app) {
error!("Failed to initialize HandyKeys: {}", e);
// Rollback to Tauri
let mut settings = settings::get_settings(app);
settings.keyboard_implementation = KeyboardImplementation::Tauri;
settings::write_settings(app, settings);
crate::secure_input::reconcile_fallback(app);
tauri_impl::init_shortcuts(app);
return Err(format!(
"Failed to initialize HandyKeys: {}. Reverted to Tauri.",
e
));
}
// init_shortcuts already registered shortcuts
Ok(true)
}
// ============================================================================
// General Settings Commands
// ============================================================================
#[tauri::command]
#[specta::specta]
pub fn change_shortcut_activation_setting(
app: AppHandle,
activation: ShortcutActivation,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.shortcut_activation = activation;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_hold_threshold_ms_setting(app: AppHandle, ms: u64) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.hold_threshold_ms = ms;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_audio_feedback_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.audio_feedback = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_audio_feedback_volume_setting(app: AppHandle, volume: f32) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.audio_feedback_volume = volume;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_sound_theme_setting(app: AppHandle, theme: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match theme.as_str() {
"marimba" => SoundTheme::Marimba,
"pop" => SoundTheme::Pop,
"custom" => SoundTheme::Custom,
other => {
warn!("Invalid sound theme '{}', defaulting to marimba", other);
SoundTheme::Marimba
}
};
settings.sound_theme = parsed;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_theme_setting(app: AppHandle, theme: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match theme.as_str() {
"system" => Theme::System,
"light" => Theme::Light,
"dark" => Theme::Dark,
other => {
warn!("Invalid theme '{}', defaulting to system", other);
Theme::System
}
};
settings.theme = parsed;
settings::write_settings(&app, settings);
#[cfg(any(target_os = "windows", target_os = "macos"))]
apply_window_theme(&app, parsed);
// Notify other webviews (the recording overlay) so they re-apply the palette
// live — they set `data-theme` on their own document and can't see this one.
let _ = app.emit("theme-changed", parsed);
Ok(())
}
/// Applies the appearance setting to the native window chrome (title bar), which
/// CSS `data-theme` cannot reach. `System` clears the override so the window
/// follows the OS. Call this on startup and whenever the setting changes to keep
/// the title bar in sync with the in-app palette.
///
/// On Windows this themes the title bar only. On macOS `set_theme` sets
/// `NSApp.appearance` app-wide, which is what we want here: it darkens the title
/// bar and keeps the overlay in step. Linux is left to `data-theme` alone, since
/// its window theming is backend-dependent and unreliable.
#[cfg(any(target_os = "windows", target_os = "macos"))]
pub fn apply_window_theme(app: &AppHandle, theme: Theme) {
let window_theme = match theme {
Theme::System => None,
Theme::Light => Some(tauri::Theme::Light),
Theme::Dark => Some(tauri::Theme::Dark),
};
if let Some(window) = app.get_webview_window("main") {
if let Err(e) = window.set_theme(window_theme) {
warn!("Failed to apply window theme: {}", e);
}
}
}
#[tauri::command]
#[specta::specta]
pub fn change_translate_to_english_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.translate_to_english = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_selected_language_setting(app: AppHandle, language: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.selected_language = language.clone();
settings::write_settings(&app, settings);
tray::update_tray_menu(&app);
// The tray can change it too; keep the settings window in sync.
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "selected_language",
"value": language
}),
);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_spoken_languages_setting(
app: AppHandle,
languages: Vec<String>,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.spoken_languages = languages;
settings::write_settings(&app, settings);
tray::update_tray_menu(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_overlay_position_setting(app: AppHandle, position: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match position.as_str() {
// "none" is retired (visibility is overlay_style now); fold legacy callers
// onto Bottom rather than warn.
"none" | "bottom" => OverlayPosition::Bottom,
"top" => OverlayPosition::Top,
other => {
warn!("Invalid overlay position '{}', defaulting to bottom", other);
OverlayPosition::Bottom
}
};
settings.overlay_position = parsed;
settings::write_settings(&app, settings);
// Whether the overlay shows at all is owned by overlay_style now; position
// only ever toggles Top/Bottom, so the enabled cache is untouched here.
// Update overlay position without recreating window
crate::utils::update_overlay_position(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_overlay_style_setting(app: AppHandle, style: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match style.as_str() {
"none" => OverlayStyle::None,
"minimal" => OverlayStyle::Minimal,
"live" => OverlayStyle::Live,
other => {
warn!("Invalid overlay style '{}', defaulting to minimal", other);
OverlayStyle::Minimal
}
};
settings.overlay_style = parsed;
settings::write_settings(&app, settings);
// Keep the cached overlay-enabled flag in sync so emit_levels stops (or
// resumes) emitting on the next audio callback.
crate::overlay::update_overlay_enabled_cache(parsed != OverlayStyle::None);
// Reposition in case the window needs to re-center for the new style.
crate::utils::update_overlay_position(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_debug_mode_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.debug_mode = enabled;
settings::write_settings(&app, settings);
// Keep webview log streaming in sync: the live log viewer only exists in
// debug mode, so logs are forwarded to the frontend only while it is on.
crate::WEBVIEW_LOG_STREAMING.store(enabled, std::sync::atomic::Ordering::Relaxed);
// Emit event to notify frontend of debug mode change
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "debug_mode",
"value": enabled
}),
);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_start_hidden_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.start_hidden = enabled;
settings::write_settings(&app, settings);
// Notify frontend
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "start_hidden",
"value": enabled
}),
);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_autostart_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.autostart_enabled = enabled;
settings::write_settings(&app, settings);
// Apply the autostart setting immediately
crate::autostart::apply_autostart(&app, enabled);
// Notify frontend
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "autostart_enabled",
"value": enabled
}),
);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_update_checks_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
if settings::update_checks_forced_disabled() {
return Err(
"Update checks are disabled by system configuration (HANDY_DISABLE_UPDATER)".into(),
);
}
let mut settings = settings::get_settings(&app);
settings.update_checks_enabled = enabled;
settings::write_settings(&app, settings);
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "update_checks_enabled",
"value": enabled
}),
);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_show_whats_new_on_update_setting(
app: AppHandle,
enabled: bool,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.show_whats_new_on_update = enabled;
settings::write_settings(&app, settings);
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "show_whats_new_on_update",
"value": enabled
}),
);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_whats_new_last_seen_version_setting(
app: AppHandle,
version: String,
) -> Result<(), String> {
let version = version.trim().to_string();
let mut settings = settings::get_settings(&app);
settings.whats_new_last_seen_version = version.clone();
settings::write_settings(&app, settings);
let _ = app.emit(
"settings-changed",
serde_json::json!({
"setting": "whats_new_last_seen_version",
"value": version
}),
);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn update_custom_words(app: AppHandle, words: Vec<String>) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.custom_words = words;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_word_correction_threshold_setting(
app: AppHandle,
threshold: f64,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.word_correction_threshold = threshold;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_language_detection_setting(
app: AppHandle,
mode: LanguageDetectionMode,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.language_detection = mode;
settings::write_settings(&app, settings);
tray::update_tray_menu(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_language_detection_window_setting(app: AppHandle, secs: u32) -> Result<(), String> {
let (min, max) = settings::LANGUAGE_DETECTION_WINDOW_SECS.into_inner();
let mut settings = settings::get_settings(&app);
settings.language_detection_window_secs = secs.clamp(min, max);
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_extra_recording_buffer_setting(app: AppHandle, ms: u64) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.extra_recording_buffer_ms = ms;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_paste_delay_ms_setting(app: AppHandle, ms: u64) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.paste_delay_ms = ms;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_paste_delay_after_ms_setting(app: AppHandle, ms: u64) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.paste_delay_after_ms = ms;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_reliable_paste_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.reliable_paste = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_paste_method_setting(app: AppHandle, method: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match method.as_str() {
"ctrl_v" => PasteMethod::CtrlV,
"direct" => PasteMethod::Direct,
"none" => PasteMethod::None,
"shift_insert" => PasteMethod::ShiftInsert,
"ctrl_shift_v" => PasteMethod::CtrlShiftV,
"external_script" => PasteMethod::ExternalScript,
other => {
warn!("Invalid paste method '{}', defaulting to ctrl_v", other);
PasteMethod::CtrlV
}
};
settings.paste_method = parsed;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn get_available_typing_tools() -> Vec<String> {
#[cfg(target_os = "linux")]
{
crate::clipboard::get_available_typing_tools()
}
#[cfg(not(target_os = "linux"))]
{
vec!["auto".to_string()]
}
}
#[tauri::command]
#[specta::specta]
pub fn change_typing_tool_setting(app: AppHandle, tool: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match tool.as_str() {
"auto" => TypingTool::Auto,
"wtype" => TypingTool::Wtype,
"kwtype" => TypingTool::Kwtype,
"dotool" => TypingTool::Dotool,
"ydotool" => TypingTool::Ydotool,
"xdotool" => TypingTool::Xdotool,
other => {
warn!("Invalid typing tool '{}', defaulting to auto", other);
TypingTool::Auto
}
};
settings.typing_tool = parsed;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_external_script_path_setting(
app: AppHandle,
path: Option<String>,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.external_script_path = path;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_clipboard_handling_setting(app: AppHandle, handling: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match handling.as_str() {
"dont_modify" => ClipboardHandling::DontModify,
"copy_to_clipboard" => ClipboardHandling::CopyToClipboard,
other => {
warn!(
"Invalid clipboard handling '{}', defaulting to dont_modify",
other
);
ClipboardHandling::DontModify
}
};
settings.clipboard_handling = parsed;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_auto_submit_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.auto_submit = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_auto_submit_key_setting(app: AppHandle, key: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let parsed = match key.as_str() {
"enter" => AutoSubmitKey::Enter,
"ctrl_enter" => AutoSubmitKey::CtrlEnter,
"cmd_enter" => AutoSubmitKey::CmdEnter,
other => {
warn!("Invalid auto submit key '{}', defaulting to enter", other);
AutoSubmitKey::Enter
}
};
settings.auto_submit_key = parsed;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_post_process_enabled_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.post_process_enabled = enabled;
settings::write_settings(&app, settings.clone());
// Register or unregister the post-processing shortcut
if let Some(binding) = settings
.bindings
.get("transcribe_with_post_process")
.cloned()
{
if enabled {
let _ = register_shortcut(&app, binding);
} else {
let _ = unregister_shortcut(&app, binding);
}
}
crate::secure_input::reconcile_fallback(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_experimental_enabled_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.experimental_enabled = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_post_process_base_url_setting(
app: AppHandle,
provider_id: String,
base_url: String,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let label = settings
.post_process_provider(&provider_id)
.map(|provider| provider.label.clone())
.ok_or_else(|| format!("Provider '{}' not found", provider_id))?;
let provider = settings
.post_process_provider_mut(&provider_id)
.expect("Provider looked up above must exist");
if provider.id != "custom" {
return Err(format!(
"Provider '{}' does not allow editing the base URL",
label
));
}
provider.base_url = base_url;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_post_process_api_format_setting(
app: AppHandle,
provider_id: String,
api_format: settings::PostProcessApiFormat,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
let provider = settings
.post_process_provider_mut(&provider_id)
.ok_or_else(|| format!("Provider '{}' not found", provider_id))?;
if provider.id != "custom" {
return Err(format!(
"Provider '{}' does not allow changing the API format",
provider.label
));
}
provider.api_format = api_format;
settings::write_settings(&app, settings);
Ok(())
}
/// Generic helper to validate provider exists
fn validate_provider_exists(
settings: &settings::AppSettings,
provider_id: &str,
) -> Result<(), String> {
if !settings
.post_process_providers
.iter()
.any(|provider| provider.id == provider_id)
{
return Err(format!("Provider '{}' not found", provider_id));
}
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_post_process_api_key_setting(
app: AppHandle,
provider_id: String,
api_key: String,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
validate_provider_exists(&settings, &provider_id)?;
settings.post_process_api_keys.insert(provider_id, api_key);
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_post_process_model_setting(
app: AppHandle,
provider_id: String,
model: String,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
validate_provider_exists(&settings, &provider_id)?;
settings.post_process_models.insert(provider_id, model);
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn set_post_process_provider(app: AppHandle, provider_id: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
validate_provider_exists(&settings, &provider_id)?;
settings.post_process_provider_id = provider_id;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn add_post_process_prompt(
app: AppHandle,
name: String,
prompt: String,
) -> Result<LLMPrompt, String> {
let mut settings = settings::get_settings(&app);
// Generate unique ID using timestamp and random component
let id = format!("prompt_{}", chrono::Utc::now().timestamp_millis());
let new_prompt = LLMPrompt {
id: id.clone(),
name,
prompt,
};
settings.post_process_prompts.push(new_prompt.clone());
settings::write_settings(&app, settings);
Ok(new_prompt)
}
#[tauri::command]
#[specta::specta]
pub fn update_post_process_prompt(
app: AppHandle,
id: String,
name: String,
prompt: String,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
if let Some(existing_prompt) = settings
.post_process_prompts
.iter_mut()
.find(|p| p.id == id)
{
existing_prompt.name = name;
existing_prompt.prompt = prompt;
settings::write_settings(&app, settings);
Ok(())
} else {
Err(format!("Prompt with id '{}' not found", id))
}
}
#[tauri::command]
#[specta::specta]
pub fn delete_post_process_prompt(app: AppHandle, id: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
// Don't allow deleting the last prompt
if settings.post_process_prompts.len() <= 1 {
return Err("Cannot delete the last prompt".to_string());
}
// Find and remove the prompt
let original_len = settings.post_process_prompts.len();
settings.post_process_prompts.retain(|p| p.id != id);
if settings.post_process_prompts.len() == original_len {
return Err(format!("Prompt with id '{}' not found", id));
}
// If the deleted prompt was selected, select the first one or None
if settings.post_process_selected_prompt_id.as_ref() == Some(&id) {
settings.post_process_selected_prompt_id =
settings.post_process_prompts.first().map(|p| p.id.clone());
}
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub async fn fetch_post_process_models(
app: AppHandle,
provider_id: String,
) -> Result<Vec<String>, String> {
let settings = settings::get_settings(&app);
// Find the provider
let provider = settings
.post_process_providers
.iter()
.find(|p| p.id == provider_id)
.ok_or_else(|| format!("Provider '{}' not found", provider_id))?;
if provider.id == APPLE_INTELLIGENCE_PROVIDER_ID {
#[cfg(all(target_os = "macos", target_arch = "aarch64"))]
{
return Ok(vec![APPLE_INTELLIGENCE_DEFAULT_MODEL_ID.to_string()]);
}
#[cfg(not(all(target_os = "macos", target_arch = "aarch64")))]
{
return Err("Apple Intelligence is only available on Apple silicon Macs running macOS 15 or later.".to_string());
}
}
// Get API key
let api_key = settings
.post_process_api_keys
.get(&provider_id)
.cloned()
.unwrap_or_default();
// Skip fetching if no API key for providers that typically need one
if api_key.trim().is_empty() && provider.id != "custom" {
return Err(format!(
"API key is required for {}. Please add an API key to list available models.",
provider.label
));
}
crate::llm_client::fetch_models(provider, api_key).await
}
#[tauri::command]
#[specta::specta]
pub fn set_post_process_selected_prompt(app: AppHandle, id: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
// Verify the prompt exists
if !settings.post_process_prompts.iter().any(|p| p.id == id) {
return Err(format!("Prompt with id '{}' not found", id));
}
settings.post_process_selected_prompt_id = Some(id);
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_mute_while_recording_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.mute_while_recording = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_append_trailing_space_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.append_trailing_space = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_lazy_stream_close_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.lazy_stream_close = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_vad_enabled_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.vad_enabled = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_long_form_chunking_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.long_form_chunking = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub async fn change_vad_backend_setting(app: AppHandle, backend: VadBackend) -> Result<(), String> {
if settings::get_settings(&app).vad_backend == backend {
return Ok(());
}
// Construct/swap the detector and, when necessary, reopen cpal away from
// the webview thread. Persist only after the runtime change succeeds so a
// rejected in-progress switch or failed microphone reopen rolls back cleanly.
let manager = app
.state::<std::sync::Arc<crate::managers::audio::AudioRecordingManager>>()
.inner()
.clone();
tokio::task::spawn_blocking(move || manager.update_vad_backend(backend))
.await
.map_err(|e| format!("audio task join failed: {e}"))?
.map_err(|e| format!("Failed to update VAD backend: {e}"))?;
let mut current_settings = settings::get_settings(&app);
current_settings.vad_backend = backend;
settings::write_settings(&app, current_settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_filler_word_removal_enabled_setting(
app: AppHandle,
enabled: bool,
) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.filler_word_removal_enabled = enabled;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_chinese_script_setting(app: AppHandle, script: ChineseScript) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.chinese_script = script;
settings::write_settings(&app, settings);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_app_language_setting(app: AppHandle, language: String) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.app_language = language.clone();
settings::write_settings(&app, settings);
// Refresh the tray menu with the new language
tray::update_tray_menu(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_show_tray_icon_setting(app: AppHandle, enabled: bool) -> Result<(), String> {
let mut settings = settings::get_settings(&app);
settings.show_tray_icon = enabled;
settings::write_settings(&app, settings);
// Apply change immediately
tray::set_tray_visibility(&app, enabled);
Ok(())
}
/// Save accelerator settings and make the next model use reload with them.
/// The currently running transcription, if any, keeps its existing engine.
fn save_accelerator_and_reload_next_use(app: &AppHandle, s: settings::AppSettings) {
settings::write_settings(app, s);
let tm = app.state::<std::sync::Arc<crate::managers::transcription::TranscriptionManager>>();
tm.reload_model_on_next_use();
}
#[tauri::command]
#[specta::specta]
pub fn change_transcribe_accelerator_setting(
app: AppHandle,
accelerator: settings::TranscribeAcceleratorSetting,
) -> Result<(), String> {
let mut s = settings::get_settings(&app);
s.transcribe_accelerator = accelerator;
save_accelerator_and_reload_next_use(&app, s);
app.state::<std::sync::Arc<crate::managers::transcription::TranscriptionManager>>()
.retry_transcribe_gpu("the transcribe.cpp accelerator setting changed");
Ok(())
}
#[tauri::command]
#[specta::specta]
pub fn change_transcribe_gpu_device(app: AppHandle, device: Option<String>) -> Result<(), String> {
let mut s = settings::get_settings(&app);
s.transcribe_gpu_device = device;
save_accelerator_and_reload_next_use(&app, s);
app.state::<std::sync::Arc<crate::managers::transcription::TranscriptionManager>>()
.retry_transcribe_gpu("the transcribe.cpp GPU device setting changed");
Ok(())
}
/// Return which accelerators and GPU devices are available for this build.
///
/// First-call cost is dominated by enumerating GPU devices through the
/// transcribe.cpp Metal/Vulkan backend, which loads dynamic libraries and
/// probes hardware. Run it on the blocking pool so the webview thread
/// stays responsive — see also the startup pre-warm in `lib.rs`.
#[tauri::command]
#[specta::specta]
pub async fn get_available_accelerators(
app: AppHandle,
) -> crate::managers::transcription::AvailableAccelerators {
tauri::async_runtime::spawn_blocking(move || {
let tm =
app.state::<std::sync::Arc<crate::managers::transcription::TranscriptionManager>>();
crate::managers::transcription::get_available_accelerators(&tm)
})
.await
.expect("get_available_accelerators panicked")
}
#[cfg(test)]
mod tests {
use handy_keys::Hotkey;
use tauri_plugin_global_shortcut::Shortcut;
#[test]
fn compound_shortcut_keys_parse_on_both_backends() {
for key in [
"scrolllock",
"capslock",
"numlock",
"pageup",
"pagedown",
"printscreen",
] {
assert!(key.parse::<Shortcut>().is_ok(), "Tauri rejected {key}");
assert!(key.parse::<Hotkey>().is_ok(), "HandyKeys rejected {key}");
}
}
}