Implement background operations for file transfers

Author: dividebysandwich

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rat-commander"
-version = "1.2.4"
+version = "1.3.0"
 edition = "2024"
 description = "A self-contained Norton/Midnight-Commander-style TUI file manager"
 license = "GPL-2.0-only"

Cargo.toml

@@ -85,6 +85,19 @@ impl AppState {
                 // Keep the progress dialog until TaskDone confirms cancellation.
                 Flow::Continue
             }
+            DialogResult::Background(id) => {
+                // Dismiss the progress dialog but keep the transfer running; it
+                // lives on in `tasks`/`task_progress` and shows in the mini bar.
+                if let Some(Dialog::Progress(p)) = &self.dialog
+                    && p.id == id
+                {
+                    self.dialog = None;
+                }
+                // Remote (FTP) transfers: open a fresh browsing connection so the
+                // panel isn't blocked sharing the transfer's single connection.
+                self.background_reconnect_ftp(id).await;
+                Flow::Continue
+            }
             DialogResult::Overwrite(id, decision) => {
                 // Send the decision back to the paused engine, then restore the
                 // operation's progress dialog. (On Abort, TaskDone will close it.)
@@ -127,6 +140,12 @@ impl AppState {
                 }
             }
             Submit::Compress(sources, name) => self.start_compress(sources, name),
+            Submit::ForegroundTask(id) => {
+                // Re-open the progress dialog for a backgrounded transfer.
+                if self.tasks.contains_key(&id) {
+                    self.dialog = Some(Dialog::Progress(self.progress_dialog_for(id)));
+                }
+            }
             Submit::Checksum { path, kind, expected } => self.start_checksum(path, kind, expected),
             Submit::Connect(side, creds) => self.connect_remote(side, creds).await,
             Submit::UserCommand(tpl) => self.pending_run = Some(self.expand_macros(&tpl)),

src/app/state/dialogs.rs

@@ -97,6 +97,19 @@ impl AppState {
             OpKind::Move => "Moving",
             OpKind::Delete => "Deleting",
         };
+        // Remote backend schemes this op touches, so a later "To background" can
+        // reopen a browsing connection for FTP (which blocks while transferring).
+        let mut schemes: Vec<String> = Vec::new();
+        let src_scheme = self.panels[self.active].cwd.scheme.clone();
+        if src_scheme != "file" {
+            schemes.push(src_scheme);
+        }
+        if let Some(d) = &dst_dir
+            && d.scheme != "file"
+            && !schemes.contains(&d.scheme)
+        {
+            schemes.push(d.scheme.clone());
+        }
         let req = OpRequest {
             kind,
             src_fs: self.panels[self.active].backend.clone(),
@@ -108,7 +121,72 @@ impl AppState {
         };
         let handle = spawn_op(id, req, self.tx.clone());
         self.tasks.insert(id, handle);
-        self.dialog = Some(Dialog::Progress(ProgressDialog::new(id, verb)));
+        // Track it as a backgroundable transfer (drives the mini bar / list).
+        self.task_progress.insert(id, BgTransfer { verb, update: None, schemes });
+        let mut pd = ProgressDialog::new(id, verb);
+        pd.backgroundable = true;
+        self.dialog = Some(Dialog::Progress(pd));
+    }
+
+    /// One list row per tracked transfer, ordered by id (stable across updates).
+    fn background_rows(&self) -> Vec<BgRow> {
+        let mut rows: Vec<BgRow> = self
+            .task_progress
+            .iter()
+            .map(|(id, t)| {
+                let (done, total, name) = t
+                    .update
+                    .as_ref()
+                    .map(|u| (u.total_done, u.total_total, u.current_name.clone()))
+                    .unwrap_or((0, 0, String::new()));
+                let ratio = if total > 0 { done as f64 / total as f64 } else { 0.0 };
+                let label = if name.is_empty() {
+                    t.verb.to_string()
+                } else {
+                    format!("{}  {name}", t.verb)
+                };
+                BgRow { id: *id, label, ratio }
+            })
+            .collect();
+        rows.sort_by_key(|r| r.id);
+        rows
+    }
+
+    /// Open the "Background operations" list of running transfers.
+    pub(in crate::app::state) fn open_background_ops(&mut self) {
+        let rows = self.background_rows();
+        if rows.is_empty() {
+            self.show_info("Background operations", "No background operations are running.");
+            return;
+        }
+        self.dialog = Some(Dialog::BackgroundOps(BackgroundOpsDialog::new(rows)));
+    }
+
+    /// Refresh the open "Background operations" list from the latest progress so
+    /// its bars advance live. Closes the list once no transfers remain.
+    pub(in crate::app::state) fn refresh_background_ops(&mut self) {
+        if !matches!(self.dialog, Some(Dialog::BackgroundOps(_))) {
+            return;
+        }
+        let rows = self.background_rows();
+        if rows.is_empty() {
+            self.dialog = None;
+        } else if let Some(Dialog::BackgroundOps(d)) = &mut self.dialog {
+            d.set_rows(rows);
+        }
+    }
+
+    /// Rebuild a progress dialog for a (possibly backgrounded) transfer from its
+    /// latest snapshot — used to foreground it (from the list, or when it hits an
+    /// overwrite conflict).
+    pub(in crate::app::state) fn progress_dialog_for(&self, id: TaskId) -> ProgressDialog {
+        let verb = self.task_progress.get(&id).map(|t| t.verb).unwrap_or("Copying");
+        let mut d = ProgressDialog::new(id, verb);
+        d.backgroundable = true;
+        if let Some(u) = self.task_progress.get(&id).and_then(|t| t.update.as_ref()) {
+            d.update(u);
+        }
+        d
     }
 
     /// Open the multi-rename dialog for the currently *selected* files. Requires

src/app/state/fileops.rs

@@ -182,6 +182,7 @@ impl AppState {
             MenuAction::Symlink => self.open_symlink(),
             MenuAction::Compress => self.open_compress(),
             MenuAction::Checksum => self.open_checksum(),
+            MenuAction::BackgroundOps => self.open_background_ops(),
             MenuAction::SelectGroup => self.open_select_group(true),
             MenuAction::UnselectGroup => self.open_select_group(false),
             MenuAction::Invert => self.invert_selection(),

src/app/state/keys.rs

@@ -41,6 +41,7 @@ impl AppState {
             sessions: Vec::new(),
             last_local_cwd: [cwd.clone(), cwd],
             tasks: HashMap::new(),
+            task_progress: HashMap::new(),
             next_task_id: 1,
             next_session_id: 0,
             tx,
@@ -185,6 +186,45 @@ impl AppState {
         }
     }
 
+    /// Aggregate progress of the **background** transfers (those not currently
+    /// shown as the foreground progress dialog): `(bytes done, bytes total,
+    /// count)`, or `None` when nothing is running in the background.
+    pub(crate) fn background_summary(&self) -> Option<(u64, u64, usize)> {
+        let foreground = match &self.dialog {
+            Some(Dialog::Progress(p)) => Some(p.id),
+            _ => None,
+        };
+        let (mut done, mut total, mut count) = (0u64, 0u64, 0usize);
+        for (id, t) in &self.task_progress {
+            if Some(*id) == foreground {
+                continue;
+            }
+            count += 1;
+            if let Some(u) = &t.update {
+                done += u.total_done;
+                total += u.total_total;
+            }
+        }
+        (count > 0).then_some((done, total, count))
+    }
+
+    /// The menu-bar rect for the mini background-progress bar (left of the
+    /// system-status widget), or `None` when nothing runs in the background.
+    /// Shared by the renderer and mouse hit-testing so they stay in sync.
+    pub(crate) fn menu_progress_rect(&self, menubar_row: Rect) -> Option<Rect> {
+        self.background_summary()?;
+        let mini_w = 24u16.min(menubar_row.width);
+        let status_shown = self.config.system_status
+            && menubar_row.width >= crate::ui::menubar::STATUS_MIN_WIDTH;
+        let right_edge = if status_shown {
+            menubar_row.x + menubar_row.width.saturating_sub(crate::ui::menubar::STATUS_WIDTH)
+        } else {
+            menubar_row.x + menubar_row.width
+        };
+        let x = right_edge.saturating_sub(mini_w).max(menubar_row.x);
+        Some(Rect { x, y: menubar_row.y, width: mini_w, height: 1 })
+    }
+
     // -- Event handling ----------------------------------------------------
 
     pub async fn apply_event(&mut self, ev: AppEvent) {
@@ -195,22 +235,33 @@ impl AppState {
                 {
                     p.update(&u);
                 }
+                // Keep the background snapshot current even with no visible dialog
+                // (drives the menu-bar mini bar and the Background-operations list).
+                if let Some(t) = self.task_progress.get_mut(&u.id) {
+                    t.update = Some(u);
+                }
+                // Advance the open "Background operations" list live.
+                self.refresh_background_ops();
             }
             AppEvent::Conflict(info) => {
-                // The engine is paused awaiting a decision. Stash the progress
-                // dialog and raise the overwrite prompt over it.
-                if let Some(Dialog::Progress(p)) = self.dialog.take() {
-                    self.stashed_progress = Some(p);
-                }
+                // The engine is paused awaiting a decision. Bring the conflicting
+                // transfer to the foreground (rebuild its progress dialog from the
+                // latest snapshot) and raise the overwrite prompt over it; the
+                // Overwrite reply restores the stashed progress dialog. This works
+                // whether the task was foreground or in the background.
+                self.stashed_progress = Some(self.progress_dialog_for(info.id));
                 self.dialog = Some(Dialog::Overwrite(OverwriteDialog::new(info)));
             }
             AppEvent::TaskDone { id, outcome } => {
                 self.tasks.remove(&id);
+                self.task_progress.remove(&id);
                 if let Some(Dialog::Progress(p)) = &self.dialog
                     && p.id == id
                 {
                     self.dialog = None;
                 }
+                // Drop the finished task from an open "Background operations" list.
+                self.refresh_background_ops();
                 if let TaskOutcome::Failed(msg) = outcome {
                     self.dialog = Some(Dialog::Message(MessageDialog::error(msg)));
                 }

src/app/state/lifecycle.rs

@@ -15,8 +15,8 @@ use crate::panel::{Panel, ViewFormat};
 use crate::proc::{ProcSignal, ProcView};
 use crate::ui::cmdline::CommandLine;
 use crate::ui::dialog::{
-    BusyDialog, ChecksumResultDialog, CompareDialog, CompareMode, ConfirmDialog, Dialog,
-    DialogResult, DriveDialog,
+    BackgroundOpsDialog, BgRow, BusyDialog, ChecksumResultDialog, CompareDialog, CompareMode,
+    ConfirmDialog, Dialog, DialogResult, DriveDialog,
     DupCriteria, FileBrowserDialog, FindDialog, FindParams, FlashTargetDialog, FormDialog, GotoDialog,
     ImageSaveDialog, InputDialog, InputPurpose, MessageDialog, MultiRenameDialog, OverwriteDialog,
     ProgressDialog, SaveAsDialog, SearchReplaceDialog, SearchReplaceParams, SelectDialog, Submit,
@@ -85,6 +85,23 @@ pub struct RemoteSession {
     pub label: String,
     /// The last directory visited on this session, restored on switch-back.
     pub cwd: VfsPath,
+    /// Credentials (including the in-memory password) used to open this session,
+    /// kept so a *second* connection can be opened for browsing when a transfer
+    /// on this session is sent to the background (see FTP reconnect). Retained in
+    /// memory only for the session's lifetime — never persisted.
+    pub creds: RemoteCreds,
+}
+
+/// A file transfer that can run in the background: the state kept for the
+/// menu-bar mini progress bar and the "Background operations" list once its
+/// modal progress dialog has been dismissed.
+pub(in crate::app::state) struct BgTransfer {
+    /// "Copying" / "Moving" / "Deleting".
+    pub verb: &'static str,
+    /// Latest progress snapshot (`None` until the first update arrives).
+    pub update: Option<ProgressUpdate>,
+    /// Remote backend schemes this op touches (used to decide FTP reconnect).
+    pub schemes: Vec<String>,
 }
 
 /// How to execute a privileged command on the background task.
@@ -152,6 +169,11 @@ pub struct AppState {
     /// returns to where it was before going remote (drive-letter style).
     last_local_cwd: [VfsPath; 2],
     tasks: HashMap<TaskId, TaskHandle>,
+    /// Live progress state for backgroundable transfers (copy/move/delete),
+    /// keyed by task id. Populated for every such task so the menu-bar mini bar
+    /// and the "Background operations" list keep updating even when the task's
+    /// progress dialog is not the foreground one.
+    pub(in crate::app::state) task_progress: HashMap<TaskId, BgTransfer>,
     next_task_id: TaskId,
     next_session_id: usize,
     tx: AppSender,

src/app/state/mod.rs

@@ -157,6 +157,17 @@ impl AppState {
                 if let Some(flow) = self.fkey_bar_click(area, col, row).await {
                     return flow;
                 }
+                // A click on the menu-bar mini progress bar opens the list of
+                // background operations.
+                let menubar_row = Rect { x: area.x, y: area.y, width: area.width, height: 1 };
+                if let Some(mr) = self.menu_progress_rect(menubar_row)
+                    && col >= mr.x
+                    && col < mr.x + mr.width
+                    && row == mr.y
+                {
+                    self.open_background_ops();
+                    return Flow::Continue;
+                }
                 // A click on the menu bar (top row) opens that menu.
                 if let Some(i) = MenuBarState::title_index_at(area, col, row) {
                     self.menu = Some(MenuBarState::new(i, &self.session_list()));

src/app/state/mouse.rs

@@ -83,6 +83,7 @@ impl AppState {
                     scheme,
                     label: conn.label,
                     cwd,
+                    creds: creds.clone(),
                 });
 
                 // Remember this server (without the password) for the dropdown.
@@ -99,6 +100,54 @@ impl AppState {
         }
     }
 
+    /// When a transfer is sent to the background, open a fresh browsing
+    /// connection for any panel sitting on an **FTP** session that the transfer
+    /// uses — FTP holds a single control connection for the whole transfer, so
+    /// browsing would otherwise block. SFTP/SCP multiplex safely and are left
+    /// alone. The transfer keeps its own backend `Arc`, so re-registering schemes
+    /// never disturbs it.
+    pub(in crate::app::state) async fn background_reconnect_ftp(&mut self, id: TaskId) {
+        let schemes = match self.task_progress.get(&id) {
+            Some(t) if !t.schemes.is_empty() => t.schemes.clone(),
+            _ => return,
+        };
+        for side in 0..2 {
+            let scheme = self.panels[side].cwd.scheme.clone();
+            if !schemes.contains(&scheme) {
+                continue;
+            }
+            let Some(sess_idx) = self.sessions.iter().position(|s| s.scheme == scheme) else {
+                continue;
+            };
+            if self.sessions[sess_idx].creds.protocol != crate::vfs::remote::Protocol::Ftp {
+                continue;
+            }
+            let creds = self.sessions[sess_idx].creds.clone();
+            match crate::vfs::remote::connect(&creds).await {
+                Ok(conn) => {
+                    let new_id = self.next_session_id;
+                    self.next_session_id += 1;
+                    let new_scheme = format!("{}-{}", creds.protocol.scheme_prefix(), new_id);
+                    self.registry.register(new_scheme.clone(), conn.backend.clone());
+                    // Safe: the transfer holds its own Arc, not the registry entry.
+                    self.registry.unregister(&scheme);
+                    let path = self.panels[side].cwd.path.clone();
+                    let new_cwd =
+                        VfsPath { scheme: new_scheme.clone(), path, container: None };
+                    self.panels[side].cwd = new_cwd.clone();
+                    self.panels[side].backend = conn.backend;
+                    let _ = self.panels[side].reload().await;
+                    // Repoint the session record in place (same id/label, new scheme).
+                    self.sessions[sess_idx].scheme = new_scheme;
+                    self.sessions[sess_idx].cwd = new_cwd;
+                }
+                Err(e) => {
+                    self.show_error(format!("Could not open a browsing connection: {e}"))
+                }
+            }
+        }
+    }
+
     /// Switch panel `side` to an already-open remote session, landing on the
     /// directory it was last viewing there.
     pub(in crate::app::state) async fn switch_to_session(&mut self, side: usize, id: usize) {