Recover from poisoned mutexes instead of crashing

Replace 56 .lock().unwrap() calls across 12 production files with .lock().unwrap_or_else(|e| e.into_inner()). Previously, if any thread panicked while holding a mutex, all subsequent lock attempts would cascade-panic and crash the app. The protected state (menu items, network discovery cache, file viewer sessions, search results, conflict resolution) is always safe to recover.
Test files left unchanged.

Author: vdavid

apps/desktop/src-tauri/src/commands/settings.rs

@@ -66,7 +66,7 @@ pub fn update_menu_accelerator(app: AppHandle, command_id: &str, shortcut: &str)
             let is_checked = menu_state
                 .view_mode_full
                 .lock()
-                .unwrap()
+                .unwrap_or_else(|e| e.into_inner())
                 .as_ref()
                 .and_then(|item| item.is_checked().ok())
                 .unwrap_or(false);
@@ -75,15 +75,15 @@ pub fn update_menu_accelerator(app: AppHandle, command_id: &str, shortcut: &str)
                 .map_err(|e| format!("Failed to update Full view accelerator: {e}"))?;
 
             // Update the reference in MenuState
-            *menu_state.view_mode_full.lock().unwrap() = Some(new_item);
+            *menu_state.view_mode_full.lock().unwrap_or_else(|e| e.into_inner()) = Some(new_item);
             Ok(())
         }
         "view.briefMode" => {
             // Get current checked state before updating
             let is_checked = menu_state
                 .view_mode_brief
                 .lock()
-                .unwrap()
+                .unwrap_or_else(|e| e.into_inner())
                 .as_ref()
                 .and_then(|item| item.is_checked().ok())
                 .unwrap_or(true);
@@ -92,7 +92,7 @@ pub fn update_menu_accelerator(app: AppHandle, command_id: &str, shortcut: &str)
                 .map_err(|e| format!("Failed to update Brief view accelerator: {e}"))?;
 
             // Update the reference in MenuState
-            *menu_state.view_mode_brief.lock().unwrap() = Some(new_item);
+            *menu_state.view_mode_brief.lock().unwrap_or_else(|e| e.into_inner()) = Some(new_item);
             Ok(())
         }
         _ => {

apps/desktop/src-tauri/src/commands/ui.rs

@@ -9,7 +9,7 @@ use tauri_plugin_opener::OpenerExt;
 #[tauri::command]
 pub fn update_menu_context<R: Runtime>(app: AppHandle<R>, path: String, filename: String) {
     let state = app.state::<MenuState<R>>();
-    let mut context = state.context.lock().unwrap();
+    let mut context = state.context.lock().unwrap_or_else(|e| e.into_inner());
     context.path = path;
     context.filename = filename;
 }
@@ -42,7 +42,7 @@ pub fn show_main_window<R: Runtime>(window: Window<R>) -> Result<(), String> {
 #[tauri::command]
 pub fn toggle_hidden_files<R: Runtime>(app: AppHandle<R>) -> Result<bool, String> {
     let menu_state = app.state::<MenuState<R>>();
-    let guard = menu_state.show_hidden_files.lock().unwrap();
+    let guard = menu_state.show_hidden_files.lock().unwrap_or_else(|e| e.into_inner());
     let Some(check_item) = guard.as_ref() else {
         return Err("Menu not initialized".to_string());
     };
@@ -64,8 +64,8 @@ pub fn toggle_hidden_files<R: Runtime>(app: AppHandle<R>) -> Result<bool, String
 #[tauri::command]
 pub fn set_view_mode<R: Runtime>(app: AppHandle<R>, mode: String) -> Result<(), String> {
     let menu_state = app.state::<MenuState<R>>();
-    let full_guard = menu_state.view_mode_full.lock().unwrap();
-    let brief_guard = menu_state.view_mode_brief.lock().unwrap();
+    let full_guard = menu_state.view_mode_full.lock().unwrap_or_else(|e| e.into_inner());
+    let brief_guard = menu_state.view_mode_brief.lock().unwrap_or_else(|e| e.into_inner());
 
     let (Some(full_item), Some(brief_item)) = (full_guard.as_ref(), brief_guard.as_ref()) else {
         return Err("Menu not initialized".to_string());
@@ -179,7 +179,7 @@ pub fn open_in_editor(_path: String) -> Result<(), String> {
 /// Executes a menu action for the current context.
 pub fn execute_menu_action<R: Runtime>(app: &AppHandle<R>, id: &str) {
     let state = app.state::<MenuState<R>>();
-    let context = state.context.lock().unwrap().clone();
+    let context = state.context.lock().unwrap_or_else(|e| e.into_inner()).clone();
 
     if context.path.is_empty() {
         return;

apps/desktop/src-tauri/src/file_system/write_operations/helpers.rs

@@ -360,7 +360,7 @@ pub(super) fn resolve_conflict(
             // Wait for user to call resolve_write_conflict.
             // The frontend cancels the operation if the dialog is destroyed, so this timeout
             // is only a safety net for when the frontend is completely dead (crash/hang).
-            let guard = state.conflict_mutex.lock().unwrap();
+            let guard = state.conflict_mutex.lock().unwrap_or_else(|e| e.into_inner());
             let (_guard, wait_result) = state
                 .conflict_condvar
                 .wait_timeout_while(guard, Duration::from_secs(300), |_| {

apps/desktop/src-tauri/src/file_system/write_operations/volume_conflict.rs

@@ -79,7 +79,7 @@ pub(super) fn resolve_volume_conflict(
             );
 
             // Wait for user to call resolve_write_conflict
-            let guard = state.conflict_mutex.lock().unwrap();
+            let guard = state.conflict_mutex.lock().unwrap_or_else(|e| e.into_inner());
             let _guard = state
                 .conflict_condvar
                 .wait_while(guard, |_| {

apps/desktop/src-tauri/src/file_viewer/byte_seek.rs

@@ -253,7 +253,7 @@ impl FileViewerBackend for ByteSeekBackend {
                     let mut search_start = 0;
                     while let Some(match_pos) = line_lower[search_start..].find(&query_lower) {
                         let col = search_start + match_pos;
-                        let mut matches = results.lock().unwrap();
+                        let mut matches = results.lock().unwrap_or_else(|e| e.into_inner());
                         matches.push(SearchMatch {
                             line: line_number,
                             column: col,
@@ -280,7 +280,7 @@ impl FileViewerBackend for ByteSeekBackend {
             let mut search_start = 0;
             while let Some(match_pos) = line_lower[search_start..].find(&query_lower) {
                 let col = search_start + match_pos;
-                let mut matches = results.lock().unwrap();
+                let mut matches = results.lock().unwrap_or_else(|e| e.into_inner());
                 matches.push(SearchMatch {
                     line: line_number,
                     column: col,

apps/desktop/src-tauri/src/file_viewer/full_load.rs

@@ -136,7 +136,7 @@ impl FileViewerBackend for FullLoadBackend {
             let mut search_start = 0;
             while let Some(pos) = line_lower[search_start..].find(&query_lower) {
                 let col = search_start + pos;
-                let mut matches = results.lock().unwrap();
+                let mut matches = results.lock().unwrap_or_else(|e| e.into_inner());
                 matches.push(SearchMatch {
                     line: line_idx,
                     column: col,

apps/desktop/src-tauri/src/file_viewer/line_index.rs

@@ -274,7 +274,7 @@ impl FileViewerBackend for LineIndexBackend {
                     let mut search_start = 0;
                     while let Some(match_pos) = line_lower[search_start..].find(&query_lower) {
                         let col = search_start + match_pos;
-                        let mut matches = results.lock().unwrap();
+                        let mut matches = results.lock().unwrap_or_else(|e| e.into_inner());
                         matches.push(SearchMatch {
                             line: line_number,
                             column: col,
@@ -300,7 +300,7 @@ impl FileViewerBackend for LineIndexBackend {
             let mut search_start = 0;
             while let Some(match_pos) = line_lower[search_start..].find(&query_lower) {
                 let col = search_start + match_pos;
-                let mut matches = results.lock().unwrap();
+                let mut matches = results.lock().unwrap_or_else(|e| e.into_inner());
                 matches.push(SearchMatch {
                     line: line_number,
                     column: col,

apps/desktop/src-tauri/src/file_viewer/session.rs

@@ -197,7 +197,7 @@ pub fn open_session(path: &str) -> Result<ViewerOpenResult, ViewerError> {
             match LineIndexBackend::open(&path_clone, &cancel_for_indexer) {
                 Ok(new_backend) => {
                     if !cancel_for_indexer.load(Ordering::Relaxed) {
-                        let mut sessions = SESSIONS.lock().unwrap();
+                        let mut sessions = SESSIONS.lock().unwrap_or_else(|e| e.into_inner());
                         if let Some(session) = sessions.get_mut(&session_id_clone) {
                             debug!(
                                 "Indexing completed for session {}, upgrading to LineIndex",
@@ -259,14 +259,17 @@ pub fn open_session(path: &str) -> Result<ViewerOpenResult, ViewerError> {
         is_indexing,
     };
 
-    SESSIONS.lock().unwrap().insert(session_id, session);
+    SESSIONS
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .insert(session_id, session);
 
     Ok(result)
 }
 
 /// Gets the current status of a session (backend type, indexing state).
 pub fn get_session_status(session_id: &str) -> Result<ViewerSessionStatus, ViewerError> {
-    let sessions = SESSIONS.lock().unwrap();
+    let sessions = SESSIONS.lock().unwrap_or_else(|e| e.into_inner());
     let session = sessions
         .get(session_id)
         .ok_or(ViewerError::SessionNotFound(session_id.to_string()))?;
@@ -280,7 +283,7 @@ pub fn get_session_status(session_id: &str) -> Result<ViewerSessionStatus, Viewe
 
 /// Gets a range of lines from a session.
 pub fn get_lines(session_id: &str, target: SeekTarget, count: usize) -> Result<LineChunk, ViewerError> {
-    let sessions = SESSIONS.lock().unwrap();
+    let sessions = SESSIONS.lock().unwrap_or_else(|e| e.into_inner());
     let session = sessions
         .get(session_id)
         .ok_or(ViewerError::SessionNotFound(session_id.to_string()))?;
@@ -313,7 +316,7 @@ pub fn search_start(session_id: &str, query: String) -> Result<(), ViewerError>
 
     // Get the file path from the session to open a fresh file handle in the search thread
     let path = {
-        let mut sessions = SESSIONS.lock().unwrap();
+        let mut sessions = SESSIONS.lock().unwrap_or_else(|e| e.into_inner());
         let session = sessions
             .get_mut(session_id)
             .ok_or(ViewerError::SessionNotFound(session_id.to_string()))?;
@@ -332,30 +335,30 @@ pub fn search_start(session_id: &str, query: String) -> Result<(), ViewerError>
         let backend = match ByteSeekBackend::open(&path) {
             Ok(b) => b,
             Err(_) => {
-                *status_clone.lock().unwrap() = SearchStatus::Done;
+                *status_clone.lock().unwrap_or_else(|e| e.into_inner()) = SearchStatus::Done;
                 return;
             }
         };
 
         let result = backend.search(&query, &cancel_clone, &matches_clone);
         let final_scanned: u64 = result.unwrap_or_default();
 
-        *bytes_scanned_clone.lock().unwrap() = final_scanned;
+        *bytes_scanned_clone.lock().unwrap_or_else(|e| e.into_inner()) = final_scanned;
 
         let final_status = if cancel_clone.load(Ordering::Relaxed) {
             SearchStatus::Cancelled
         } else {
             SearchStatus::Done
         };
-        *status_clone.lock().unwrap() = final_status;
+        *status_clone.lock().unwrap_or_else(|e| e.into_inner()) = final_status;
     });
 
     Ok(())
 }
 
 /// Polls search progress for a session.
 pub fn search_poll(session_id: &str) -> Result<SearchPollResult, ViewerError> {
-    let sessions = SESSIONS.lock().unwrap();
+    let sessions = SESSIONS.lock().unwrap_or_else(|e| e.into_inner());
     let session = sessions
         .get(session_id)
         .ok_or(ViewerError::SessionNotFound(session_id.to_string()))?;
@@ -370,9 +373,9 @@ pub fn search_poll(session_id: &str) -> Result<SearchPollResult, ViewerError> {
             bytes_scanned: 0,
         }),
         Some(search) => {
-            let status = search.status.lock().unwrap().clone();
-            let matches = search.matches.lock().unwrap().clone();
-            let bytes_scanned = *search.bytes_scanned.lock().unwrap();
+            let status = search.status.lock().unwrap_or_else(|e| e.into_inner()).clone();
+            let matches = search.matches.lock().unwrap_or_else(|e| e.into_inner()).clone();
+            let bytes_scanned = *search.bytes_scanned.lock().unwrap_or_else(|e| e.into_inner());
 
             Ok(SearchPollResult {
                 status,
@@ -386,7 +389,7 @@ pub fn search_poll(session_id: &str) -> Result<SearchPollResult, ViewerError> {
 
 /// Cancels an ongoing search.
 pub fn search_cancel(session_id: &str) -> Result<(), ViewerError> {
-    let mut sessions = SESSIONS.lock().unwrap();
+    let mut sessions = SESSIONS.lock().unwrap_or_else(|e| e.into_inner());
     let session = sessions
         .get_mut(session_id)
         .ok_or(ViewerError::SessionNotFound(session_id.to_string()))?;
@@ -401,7 +404,7 @@ pub fn search_cancel(session_id: &str) -> Result<(), ViewerError> {
 
 /// Closes a viewer session and frees resources.
 pub fn close_session(session_id: &str) -> Result<(), ViewerError> {
-    let mut sessions = SESSIONS.lock().unwrap();
+    let mut sessions = SESSIONS.lock().unwrap_or_else(|e| e.into_inner());
     if let Some(session) = sessions.remove(session_id) {
         // Cancel any ongoing search
         if let Some(search) = &session.search {

apps/desktop/src-tauri/src/lib.rs

@@ -166,12 +166,19 @@ pub fn run() {
 
             // Store the CheckMenuItem references in app state
             let menu_state = MenuState::default();
-            *menu_state.show_hidden_files.lock().unwrap() = Some(menu_items.show_hidden_files);
-            *menu_state.view_mode_full.lock().unwrap() = Some(menu_items.view_mode_full);
-            *menu_state.view_mode_brief.lock().unwrap() = Some(menu_items.view_mode_brief);
-            *menu_state.view_submenu.lock().unwrap() = Some(menu_items.view_submenu);
-            *menu_state.view_mode_full_position.lock().unwrap() = menu_items.view_mode_full_position;
-            *menu_state.view_mode_brief_position.lock().unwrap() = menu_items.view_mode_brief_position;
+            *menu_state.show_hidden_files.lock().unwrap_or_else(|e| e.into_inner()) =
+                Some(menu_items.show_hidden_files);
+            *menu_state.view_mode_full.lock().unwrap_or_else(|e| e.into_inner()) = Some(menu_items.view_mode_full);
+            *menu_state.view_mode_brief.lock().unwrap_or_else(|e| e.into_inner()) = Some(menu_items.view_mode_brief);
+            *menu_state.view_submenu.lock().unwrap_or_else(|e| e.into_inner()) = Some(menu_items.view_submenu);
+            *menu_state
+                .view_mode_full_position
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()) = menu_items.view_mode_full_position;
+            *menu_state
+                .view_mode_brief_position
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()) = menu_items.view_mode_brief_position;
             app.manage(menu_state);
 
             // Set window title based on license status
@@ -208,7 +215,7 @@ pub fn run() {
             if id == SHOW_HIDDEN_FILES_ID {
                 // Get the CheckMenuItem from app state
                 let menu_state = app.state::<MenuState<tauri::Wry>>();
-                let guard = menu_state.show_hidden_files.lock().unwrap();
+                let guard = menu_state.show_hidden_files.lock().unwrap_or_else(|e| e.into_inner());
                 let Some(check_item) = guard.as_ref() else {
                     return;
                 };
@@ -228,8 +235,8 @@ pub fn run() {
                 let menu_state = app.state::<MenuState<tauri::Wry>>();
 
                 let (full_guard, brief_guard) = (
-                    menu_state.view_mode_full.lock().unwrap(),
-                    menu_state.view_mode_brief.lock().unwrap(),
+                    menu_state.view_mode_full.lock().unwrap_or_else(|e| e.into_inner()),
+                    menu_state.view_mode_brief.lock().unwrap_or_else(|e| e.into_inner()),
                 );
 
                 if let (Some(full_item), Some(brief_item)) = (full_guard.as_ref(), brief_guard.as_ref()) {

apps/desktop/src-tauri/src/menu.rs

@@ -487,22 +487,28 @@ pub fn update_view_mode_accelerator<R: Runtime>(
     new_accelerator: Option<&str>,
     is_checked: bool,
 ) -> tauri::Result<CheckMenuItem<R>> {
-    let view_submenu_guard = menu_state.view_submenu.lock().unwrap();
+    let view_submenu_guard = menu_state.view_submenu.lock().unwrap_or_else(|e| e.into_inner());
     let view_submenu = view_submenu_guard
         .as_ref()
         .ok_or_else(|| tauri::Error::InvalidWindowHandle)?;
 
     let (menu_item_guard, position_guard, menu_id, label) = if is_full_mode {
         (
-            menu_state.view_mode_full.lock().unwrap(),
-            menu_state.view_mode_full_position.lock().unwrap(),
+            menu_state.view_mode_full.lock().unwrap_or_else(|e| e.into_inner()),
+            menu_state
+                .view_mode_full_position
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()),
             VIEW_MODE_FULL_ID,
             "Full view",
         )
     } else {
         (
-            menu_state.view_mode_brief.lock().unwrap(),
-            menu_state.view_mode_brief_position.lock().unwrap(),
+            menu_state.view_mode_brief.lock().unwrap_or_else(|e| e.into_inner()),
+            menu_state
+                .view_mode_brief_position
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()),
             VIEW_MODE_BRIEF_ID,
             "Brief view",
         )