Bugfix: Copy → "Cancel" rolled back copied files

vdavid · vdavid · commit 3042f2349d44 · 2026-04-03T17:12:43.000+02:00
- Cancel (keep partial files) triggered a race: `handleCancel(false)` sent `rollback=false`, then `onDestroy` immediately sent `rollback=true`, overwriting the user's choice
- Frontend: added `operationSettled` flag set in all five terminal paths (complete, error, cancelled event, cancel button, rollback button) — `onDestroy` safety net now skips if already handled
- Backend: `cancel_write_operation` now uses `AtomicBool::swap` — first caller's rollback decision wins, subsequent calls are no-ops
- `onDestroy` safety net now passes `rollback=false` — unexpected teardown (hot-reload, window close) stops the operation but never silently deletes files in the background
diff --git a/apps/desktop/src-tauri/src/file_system/write_operations/state.rs b/apps/desktop/src-tauri/src/file_system/write_operations/state.rs
@@ -185,7 +185,12 @@ pub fn cancel_write_operation(operation_id: &str, rollback: bool) {
     if let Ok(cache) = WRITE_OPERATION_STATE.read()
         && let Some(state) = cache.get(operation_id)
     {
-        state.cancelled.store(true, Ordering::Relaxed);
+        // If already cancelled, don't overwrite skip_rollback — the first caller's
+        // decision wins. This prevents a later safety-net cancel from changing the
+        // rollback policy that the user explicitly chose.
+        if state.cancelled.swap(true, Ordering::Relaxed) {
+            return;
+        }
         state.skip_rollback.store(!rollback, Ordering::Relaxed);
         // Wake up any waiting conflict resolution
         let _guard = state.conflict_mutex.lock();
diff --git a/apps/desktop/src/lib/file-operations/transfer/TransferProgressDialog.svelte b/apps/desktop/src/lib/file-operations/transfer/TransferProgressDialog.svelte
@@ -153,6 +153,9 @@
     let isCancelling = $state(false)
     let isRollingBack = $state(false)
     let destroyed = false
+    /** Set when the operation reaches a terminal state (complete, error, cancel, rollback).
+     *  Prevents onDestroy's safety-net cancel from interfering with an already-handled outcome. */
+    let operationSettled = false
 
     // Events that arrived before we know our operationId (from the command response).
     // Without buffering, a stale event from a previous operation could claim the ID slot first.
@@ -299,6 +302,7 @@
             bytesProcessed: event.bytesProcessed,
         })
 
+        operationSettled = true
         cleanup()
 
         const totalFiles = event.filesProcessed
@@ -321,6 +325,7 @@
 
         log.error('{op} error: {errorType}', { op: operationLabel, errorType: event.error.type, error: event.error })
 
+        operationSettled = true
         cleanup()
         onError(event.error)
     }
@@ -334,6 +339,7 @@
             rolledBack: event.rolledBack,
         })
 
+        operationSettled = true
         cleanup()
         onCancelled(event.filesProcessed)
     }
@@ -511,6 +517,7 @@
         if (rollback) {
             // Rollback: keep dialog open, show "Rolling back...", wait for event
             log.info('Rolling back operation: {operationId}', { operationId })
+            operationSettled = true
             isRollingBack = true
             isCancelling = true
             try {
@@ -530,6 +537,7 @@
                 await cancelWriteOperation(operationId, false)
                 log.debug('Cancel request sent successfully')
                 // Close immediately without waiting for backend confirmation
+                operationSettled = true
                 cleanup()
                 onCancelled(filesDone)
             } catch (err) {
@@ -665,11 +673,10 @@
             void cancelScanPreview(previewId)
         }
         cleanupScanListeners()
-        if (operationId) {
-            // Cancel with rollback on unexpected teardown (hot-reload, navigation, crash).
-            // Normal user-initiated cancel/complete already ran cleanup() + callbacks,
-            // and the backend ignores cancel on finished operations (idempotent).
-            void cancelWriteOperation(operationId, true)
+        if (operationId && !operationSettled) {
+            // Unexpected teardown (hot-reload, navigation, window close): stop the operation
+            // but don't roll back — never do silent background work without visual feedback.
+            void cancelWriteOperation(operationId, false)
         }
         cleanup()
     })
