feat(tray): add Recent Transcriptions copy, Recording Mode submenu, and Check for Updates; sync Dashboard↔Tray mode changes; refresh tray on history changes

Author: moinulmoin

src-tauri/src/commands/audio.rs

@@ -1350,6 +1350,11 @@ pub async fn save_transcription(app: AppHandle, text: String, model: String) ->
     // Emit the new transcription data to frontend for append-only update
     let _ = emit_to_window(&app, "main", "transcription-added", transcription_data);
 
+    // Refresh tray menu (best-effort) so Recent Transcriptions stays updated
+    if let Err(e) = crate::commands::settings::update_tray_menu(app.clone()).await {
+        log::warn!("Failed to update tray menu after saving transcription: {}", e);
+    }
+
     log::info!("Saved transcription with {} characters", text.len());
     Ok(())
 }
@@ -1686,6 +1691,11 @@ pub async fn delete_transcription_entry(app: AppHandle, timestamp: String) -> Re
     // Emit event to update UI
     let _ = emit_to_window(&app, "main", "history-updated", ());
 
+    // Refresh tray menu to reflect removal
+    if let Err(e) = crate::commands::settings::update_tray_menu(app.clone()).await {
+        log::warn!("Failed to update tray menu after deletion: {}", e);
+    }
+
     log::info!("Deleted transcription entry: {}", timestamp);
     Ok(())
 }
@@ -1714,6 +1724,11 @@ pub async fn clear_all_transcriptions(app: AppHandle) -> Result<(), String> {
     // Emit event to update UI
     let _ = emit_to_window(&app, "main", "history-updated", ());
 
+    // Refresh tray menu after clearing
+    if let Err(e) = crate::commands::settings::update_tray_menu(app.clone()).await {
+        log::warn!("Failed to update tray menu after clearing history: {}", e);
+    }
+
     log::info!("Cleared all transcription entries: {} items", count);
     Ok(())
 }

src-tauri/src/commands/settings.rs

@@ -131,11 +131,15 @@ pub async fn get_settings(app: AppHandle) -> Result<Settings, String> {
 pub async fn save_settings(app: AppHandle, settings: Settings) -> Result<(), String> {
     let store = app.store("settings").map_err(|e| e.to_string())?;
 
-    // Check if model changed
+    // Check if model and recording mode changed
     let old_model = store
         .get("current_model")
         .and_then(|v| v.as_str().map(|s| s.to_string()))
         .unwrap_or_default();
+    let old_mode = store
+        .get("recording_mode")
+        .and_then(|v| v.as_str().map(|s| s.to_string()))
+        .unwrap_or_else(|| Settings::default().recording_mode);
 
     store.set("hotkey", json!(settings.hotkey));
     store.set("current_model", json!(settings.current_model));
@@ -260,6 +264,13 @@ pub async fn save_settings(app: AppHandle, settings: Settings) -> Result<(), Str
         }
     }
 
+    // If recording mode changed, refresh tray to update checked state
+    if old_mode != settings.recording_mode {
+        if let Err(e) = update_tray_menu(app.clone()).await {
+            log::warn!("Failed to update tray menu after mode change: {}", e);
+        }
+    }
+
     Ok(())
 }
 

src-tauri/src/commands/text.rs

@@ -52,6 +52,21 @@ pub async fn insert_text(app: tauri::AppHandle, text: String) -> Result<(), Stri
     .map_err(|e| format!("Task failed: {}", e))?
 }
 
+/// Copy plain text to the system clipboard without attempting to paste
+#[tauri::command]
+pub async fn copy_text_to_clipboard(text: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        let mut clipboard =
+            Clipboard::new().map_err(|e| format!("Failed to initialize clipboard: {}", e))?;
+        clipboard
+            .set_text(&text)
+            .map_err(|e| format!("Failed to set clipboard: {}", e))?;
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
 fn insert_via_clipboard(text: String, has_accessibility_permission: bool, app_handle: Option<tauri::AppHandle>) -> Result<(), String> {
     // This function handles both copying text to clipboard AND pasting it at cursor
     // Initialize clipboard

src-tauri/src/lib.rs

@@ -195,9 +195,85 @@ async fn build_tray_menu<R: tauri::Runtime>(
         None
     };
 
+    // Recent transcriptions (last 5)
+    use tauri_plugin_store::StoreExt;
+    let mut recent_owned: Vec<tauri::menu::MenuItem<R>> = Vec::new();
+    {
+        if let Ok(store) = app.store("transcriptions") {
+            let mut entries: Vec<(String, serde_json::Value)> = Vec::new();
+            for key in store.keys() {
+                if let Some(value) = store.get(&key) {
+                    entries.push((key.to_string(), value));
+                }
+            }
+            entries.sort_by(|a, b| b.0.cmp(&a.0));
+            entries.truncate(5);
+
+            for (ts, entry) in entries {
+                let mut label = entry
+                    .get("text")
+                    .and_then(|v| v.as_str())
+                    .map(|s| {
+                        let first_line = s.lines().next().unwrap_or("").trim();
+                        if first_line.len() > 40 {
+                            format!("{}…", &first_line[..40])
+                        } else if first_line.is_empty() {
+                            "(empty)".to_string()
+                        } else {
+                            first_line.to_string()
+                        }
+                    })
+                    .unwrap_or_else(|| "(unknown)".to_string());
+
+                if label.is_empty() { label = "(empty)".to_string(); }
+
+                let item = tauri::menu::MenuItem::with_id(
+                    app,
+                    &format!("recent_copy_{}", ts),
+                    label,
+                    true,
+                    None::<&str>,
+                )?;
+                recent_owned.push(item);
+            }
+        }
+    }
+    let mut recent_refs: Vec<&dyn tauri::menu::IsMenuItem<_>> = Vec::new();
+    for item in &recent_owned { recent_refs.push(item); }
+
+    // Recording mode submenu (Toggle / Push-to-Talk)
+    let (toggle_item, ptt_item) = {
+        let recording_mode = match app.store("settings") {
+            Ok(store) => store
+                .get("recording_mode")
+                .and_then(|v| v.as_str().map(|s| s.to_string()))
+                .unwrap_or_else(|| "toggle".to_string()),
+            Err(_) => "toggle".to_string(),
+        };
+
+        let toggle = tauri::menu::CheckMenuItem::with_id(
+            app,
+            "recording_mode_toggle",
+            "Toggle",
+            true,
+            recording_mode == "toggle",
+            None::<&str>,
+        )?;
+        let ptt = tauri::menu::CheckMenuItem::with_id(
+            app,
+            "recording_mode_push_to_talk",
+            "Push-to-Talk",
+            true,
+            recording_mode == "push_to_talk",
+            None::<&str>,
+        )?;
+        (toggle, ptt)
+    };
+
     // Create menu items
     let separator1 = PredefinedMenuItem::separator(app)?;
     let settings_i = MenuItem::with_id(app, "settings", "Dashboard", true, None::<&str>)?;
+    let check_updates_i = MenuItem::with_id(app, "check_updates", "Check for Updates", true, None::<&str>)?;
     let separator2 = PredefinedMenuItem::separator(app)?;
     let quit_i = MenuItem::with_id(app, "quit", "Quit VoiceTypr", true, None::<&str>)?;
 
@@ -211,9 +287,27 @@ async fn build_tray_menu<R: tauri::Runtime>(
         menu_builder = menu_builder.item(&microphone_submenu);
     }
 
+    // Add Recent Transcriptions submenu if we have items
+    if !recent_refs.is_empty() {
+        let recent_submenu = Submenu::with_id_and_items(
+            app,
+            "recent",
+            "Recent Transcriptions",
+            true,
+            &recent_refs,
+        )?;
+        menu_builder = menu_builder.item(&recent_submenu);
+    }
+
+    // Recording mode submenu
+    let mode_items: Vec<&dyn tauri::menu::IsMenuItem<_>> = vec![&toggle_item, &ptt_item];
+    let mode_submenu = Submenu::with_id_and_items(app, "recording_mode", "Recording Mode", true, &mode_items)?;
+    menu_builder = menu_builder.item(&mode_submenu);
+
     let menu = menu_builder
         .item(&separator1)
         .item(&settings_i)
+        .item(&check_updates_i)
         .item(&separator2)
         .item(&quit_i)
         .build()?;
@@ -1014,7 +1108,7 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
                 .menu(&menu)
                 .on_menu_event(move |app, event| {
                     log::info!("Tray menu event: {:?}", event.id);
-                    let event_id = event.id.as_ref();
+                    let event_id = event.id.as_ref().to_string();
 
                     if event_id == "settings" {
                         if let Some(window) = app.get_webview_window("main") {
@@ -1025,6 +1119,8 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
                         }
                     } else if event_id == "quit" {
                         app.exit(0);
+                    } else if event_id == "check_updates" {
+                        let _ = app.emit("tray-check-updates", ());
                     } else if event_id.starts_with("model_") {
                         // Handle model selection
                         let model_name = match event_id.strip_prefix("model_") {
@@ -1086,6 +1182,59 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
                             }
                         });
                     }
+                    // Recent transcriptions copy handler
+                    else if let Some(ts) = event_id.strip_prefix("recent_copy_") {
+                        let ts_owned = ts.to_string();
+                        let app_handle = app.app_handle().clone();
+                        tauri::async_runtime::spawn(async move {
+                            // Read text by timestamp and copy
+                            match app_handle.store("transcriptions") {
+                                Ok(store) => {
+                                    if let Some(val) = store.get(&ts_owned) {
+                                        if let Some(text) = val.get("text").and_then(|v| v.as_str()) {
+                                            if let Err(e) = crate::commands::text::copy_text_to_clipboard(text.to_string()).await {
+                                                log::error!("Failed to copy recent transcription: {}", e);
+                                                let _ = app_handle.emit("tray-action-error", &format!("Failed to copy: {}", e));
+                                            } else {
+                                                log::info!("Copied recent transcription to clipboard");
+                                            }
+                                        }
+                                    }
+                                }
+                                Err(e) => {
+                                    log::error!("Failed to open transcriptions store: {}", e);
+                                }
+                            }
+                        });
+                    }
+                    // Recording mode switchers
+                    else if event_id == "recording_mode_toggle" || event_id == "recording_mode_push_to_talk" {
+                        let app_handle = app.app_handle().clone();
+                        let mode = if event_id.ends_with("push_to_talk") { "push_to_talk" } else { "toggle" };
+                        tauri::async_runtime::spawn(async move {
+                            match crate::commands::settings::get_settings(app_handle.clone()).await {
+                                Ok(mut s) => {
+                                    s.recording_mode = mode.to_string();
+                                    match crate::commands::settings::save_settings(app_handle.clone(), s).await {
+                                        Err(e) => {
+                                            log::error!("Failed to save recording mode from tray: {}", e);
+                                            let _ = app_handle.emit("tray-action-error", &format!("Failed to change recording mode: {}", e));
+                                        }
+                                        Ok(()) => {
+                                            if let Err(e) = crate::commands::settings::update_tray_menu(app_handle.clone()).await {
+                                                log::warn!("Failed to refresh tray after mode change: {}", e);
+                                            }
+                                            // Notify frontend so SettingsContext refreshes
+                                            let _ = app_handle.emit("settings-changed", ());
+                                        }
+                                    }
+                                }
+                                Err(e) => {
+                                    log::error!("Failed to get settings for mode change: {}", e);
+                                }
+                            }
+                        });
+                    }
                 })
                 .on_tray_icon_event(|tray, event| {
                     if let TrayIconEvent::Click {
@@ -1479,6 +1628,7 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
             reset_app_data,
             copy_image_to_clipboard,
             save_image_to_file,
+            copy_text_to_clipboard,
             get_ai_settings,
             get_ai_settings_for_provider,
             cache_ai_api_key,

src/components/AppContainer.tsx

@@ -80,6 +80,16 @@ export function AppContainer() {
           setActiveSection("overview");
         });
 
+        // Listen for manual update checks triggered from tray
+        registerEvent("tray-check-updates", async () => {
+          try {
+            await updateService.checkForUpdatesManually();
+          } catch (e) {
+            console.error("Manual update check failed:", e);
+            toast.error("Failed to check for updates");
+          }
+        });
+
         // Listen for tray action errors
         registerEvent("tray-action-error", (event) => {
           console.error("Tray action error:", event.payload);