feat: implement 6 upstream PRs for enhanced functionality

- PR cjpais#477: Graceful handling when no microphone is connected
  - Validate device config before spawning worker thread
  - Use HandyError with user-friendly messages and recovery suggestions

- PR cjpais#930: Transcription hook for external script processing
  - Add transcription_hook_enabled and transcription_hook_path settings
  - Pipe transcription through external scripts for custom processing

- PR cjpais#814: Secure API key storage in OS keychain
  - Add keyring module for macOS Keychain, Windows Credential Manager, Linux Secret Service
  - Commands: set_api_key, get_api_key, delete_api_key, get_masked_api_key

- PR cjpais#455: Text replacements with regex and magic commands
  - Support literal and regex pattern matching
  - Magic commands: [date], [time], [datetime]
  - Import/export functionality for replacement rules

- PR cjpais#851: Per-entry post-process button for history
  - Retroactively post-process transcription history entries
  - Store post-processed text and prompt used

- PR cjpais#618: Wake-word detection for Active Listening trigger
  - Transcript-based wake phrase detection
  - Configurable trigger actions, cooldown, and threshold

Author: thukabjj

src-tauri/Cargo.toml

@@ -79,6 +79,7 @@ specta-typescript = "0.0.9"
 tauri-specta = { version = "=2.0.0-rc.21", features = ["derive", "typescript"] }
 tauri-plugin-dialog = "~2.4"
 symphonia = { version = "0.5", features = ["mp3", "aac", "flac", "vorbis", "isomp4"] }
+keyring = "3"
 
 [target.'cfg(unix)'.dependencies]
 signal-hook = "0.3"

src-tauri/src/actions.rs

@@ -56,7 +56,9 @@ fn build_system_prompt(prompt_template: &str) -> String {
     prompt_template.replace("${output}", "").trim().to_string()
 }
 
-async fn post_process_transcription(settings: &AppSettings, transcription: &str) -> Option<String> {
+/// Process transcription text through the configured LLM provider.
+/// Returns the processed text or None if post-processing is not available/fails.
+pub async fn post_process_transcription(settings: &AppSettings, transcription: &str) -> Option<String> {
     let provider = match settings.active_post_process_provider().cloned() {
         Some(provider) => provider,
         None => {

src-tauri/src/audio_toolkit/audio/recorder.rs

@@ -65,19 +65,34 @@ impl AudioRecorder {
         let host = crate::audio_toolkit::get_cpal_host();
         let device = match device {
             Some(dev) => dev,
-            None => host
-                .default_input_device()
-                .ok_or_else(|| Error::new(std::io::ErrorKind::NotFound, "No input device found"))?,
+            None => host.default_input_device().ok_or_else(|| {
+                Error::new(
+                    std::io::ErrorKind::NotFound,
+                    "No microphone found. Please connect a microphone and try again.",
+                )
+            })?,
         };
 
+        // Validate device configuration BEFORE spawning worker thread
+        // This prevents silent failures and provides better error messages
+        let config = AudioRecorder::get_preferred_config(&device).map_err(|e| {
+            Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!(
+                    "Microphone configuration error: {}. Try selecting a different microphone.",
+                    e
+                ),
+            )
+        })?;
+
         let thread_device = device.clone();
+        let thread_config = config.clone();
         let vad = self.vad.clone();
         // Move the optional level callback into the worker thread
         let level_cb = self.level_cb.clone();
 
         let worker = std::thread::spawn(move || {
-            let config = AudioRecorder::get_preferred_config(&thread_device)
-                .expect("failed to fetch preferred config");
+            let config = thread_config;
 
             let sample_rate = config.sample_rate().0;
             let channels = config.channels() as usize;

src-tauri/src/commands/history.rs

@@ -1,4 +1,6 @@
+use crate::actions::post_process_transcription;
 use crate::managers::history::{HistoryEntry, HistoryManager};
+use crate::settings::get_settings;
 use std::sync::Arc;
 use tauri::{AppHandle, State};
 
@@ -99,3 +101,67 @@ pub async fn update_recording_retention_period(
 
     Ok(())
 }
+
+/// Post-process a history entry using the current LLM settings.
+/// Returns the processed text if successful.
+#[tauri::command]
+#[specta::specta]
+pub async fn post_process_history_entry(
+    app: AppHandle,
+    history_manager: State<'_, Arc<HistoryManager>>,
+    id: i64,
+) -> Result<String, String> {
+    // Get the entry
+    let entry = history_manager
+        .get_entry_by_id(id)
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("History entry with id {} not found", id))?;
+
+    // Get current settings for post-processing config
+    let settings = get_settings(&app);
+
+    // Use the original transcription text for post-processing
+    let text_to_process = &entry.transcription_text;
+
+    // Post-process using the configured LLM
+    let processed_text = post_process_transcription(&settings, text_to_process)
+        .await
+        .ok_or_else(|| {
+            "Post-processing failed. Please check your LLM provider settings.".to_string()
+        })?;
+
+    // Get the prompt that was used
+    let post_process_prompt = settings
+        .post_process_selected_prompt_id
+        .as_ref()
+        .and_then(|prompt_id| {
+            settings
+                .post_process_prompts
+                .iter()
+                .find(|p| &p.id == prompt_id)
+                .map(|p| p.prompt.clone())
+        });
+
+    // Update the entry with the processed text
+    history_manager
+        .update_post_processed_text(id, processed_text.clone(), post_process_prompt)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(processed_text)
+}
+
+/// Get a specific history entry by ID.
+#[tauri::command]
+#[specta::specta]
+pub async fn get_history_entry_by_id(
+    _app: AppHandle,
+    history_manager: State<'_, Arc<HistoryManager>>,
+    id: i64,
+) -> Result<Option<HistoryEntry>, String> {
+    history_manager
+        .get_entry_by_id(id)
+        .await
+        .map_err(|e| e.to_string())
+}

src-tauri/src/commands/keyring.rs

@@ -0,0 +1,50 @@
+//! Tauri commands for secure API key management via OS keychain.
+
+use crate::keyring;
+
+/// Store an API key in the system keyring.
+#[tauri::command]
+#[specta::specta]
+pub fn set_api_key(provider_id: String, api_key: String) -> Result<(), String> {
+    keyring::set_api_key(&provider_id, &api_key)
+}
+
+/// Get an API key from the system keyring.
+/// Returns None if the key doesn't exist.
+#[tauri::command]
+#[specta::specta]
+pub fn get_api_key(provider_id: String) -> Result<Option<String>, String> {
+    keyring::get_api_key(&provider_id)
+}
+
+/// Delete an API key from the system keyring.
+#[tauri::command]
+#[specta::specta]
+pub fn delete_api_key(provider_id: String) -> Result<(), String> {
+    keyring::delete_api_key(&provider_id)
+}
+
+/// Check if an API key exists in the system keyring.
+#[tauri::command]
+#[specta::specta]
+pub fn has_api_key(provider_id: String) -> bool {
+    keyring::has_api_key(&provider_id)
+}
+
+/// Get a masked version of the API key for display (e.g., "sk-••••••••xxxx").
+/// Returns None if no key exists.
+#[tauri::command]
+#[specta::specta]
+pub fn get_masked_api_key(provider_id: String) -> Result<Option<String>, String> {
+    match keyring::get_api_key(&provider_id)? {
+        Some(key) => {
+            if key.len() <= 8 {
+                Ok(Some("••••••••".to_string()))
+            } else {
+                let last_four = &key[key.len() - 4..];
+                Ok(Some(format!("••••••••{}", last_four)))
+            }
+        }
+        None => Ok(None),
+    }
+}

src-tauri/src/commands/mod.rs

@@ -3,13 +3,16 @@ pub mod ask_ai;
 pub mod audio;
 pub mod batch_processing;
 pub mod history;
+pub mod keyring;
 pub mod models;
 pub mod rag;
+pub mod replacements;
 pub mod suggestions;
 pub mod tasks;
 pub mod transcription;
 pub mod sound_detection;
 pub mod vocabulary;
+pub mod wake_word;
 
 use crate::settings::{get_settings, write_settings, AppSettings, LogLevel};
 use crate::utils::cancel_current_operation;