MTP: Wire up delete, rename, and move

- New `delete_volume_files_with_progress` in `delete.rs`: scans via `volume.list_directory()`, deletes per-item with full progress events, cancellation, and dry-run support
- `delete_files` and `rename_file` commands accept optional `volume_id` — routes through Volume trait for non-root volumes
- MTP move implemented as two-phase copy+delete in `TransferProgressDialog`: copy via `copyBetweenVolumes`, then delete source with volume-aware delete. Three-stage progress UI (Scanning → Copying → Removing source)
- MTP move guard removed from `DualPaneExplorer`
- Rename flow threads `volumeId` through `FilePane` → `rename-flow` → `rename-operations` → `renameFile`, skipping `checkRenamePermission`/`checkRenameValidity` for MTP volumes
- Clipboard toasts updated to suggest F5/F6 instead of generic "not supported yet"
- Fixed `sourceVolumeId` bug in `pasteFromClipboard` (was using dest volume ID)
- Updated CLAUDE.md files: `commands`, `write_operations`, `file-operations`, `mtp`, `rename`

Author: vdavid

apps/desktop/src-tauri/src/commands/CLAUDE.md

@@ -61,6 +61,7 @@ The frontend has matching TypeScript types in `$lib/tauri-commands/ipc-types.ts`
 - **`expand_tilde`** is applied conditionally: for `list_directory` it's gated on `volume_id == "root"`, but for write operations (copy, move, delete, scan preview) it's always applied. MTP and network volume paths must never be tilde-expanded.
 - **AI commands** are registered directly from `ai::manager` and `ai::suggestions` — there is no `commands/ai.rs` file.
 - **Platform gates.** `volumes` is macOS-only; `mtp` and `network` are macOS+Linux; `volumes_linux` is Linux-only. Individual functions also use `#[cfg]` where behaviour differs (e.g., `sync_status`).
+- **`delete_files` and `rename_file` accept `volume_id`.** When set to a non-root volume, `delete_files` routes to the volume-aware delete path and skips local `validate_sources` (MTP virtual paths fail `symlink_metadata`). `rename_file` passes `volume_id` through for MTP rename support; permission checks are skipped for non-root volumes.
 - **`start_selection_drag`** requires the main thread. It uses `app.run_on_main_thread()` plus a `std::sync::mpsc` channel to return the result synchronously.
 - **`list_shares_with_credentials`** has `#[allow(clippy::too_many_arguments)]` because Tauri command parameters must be top-level arguments — no struct bundling.
 - **`set_menu_context` and Close tab (⌘W).** When the main window loses focus, `set_menu_context("other")` disables all

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

@@ -340,16 +340,23 @@ pub async fn move_files(
 }
 
 /// Recursively deletes files and directories. Same events as `copy_files`.
+/// When `volume_id` is provided and is not "root", routes through the Volume trait.
 #[tauri::command]
 pub async fn delete_files(
     app: tauri::AppHandle,
     sources: Vec<String>,
+    volume_id: Option<String>,
     config: Option<WriteOperationConfig>,
 ) -> Result<WriteOperationStartResult, WriteOperationError> {
-    let sources: Vec<PathBuf> = sources.iter().map(|s| PathBuf::from(expand_tilde(s))).collect();
+    let is_local = volume_id.as_deref().unwrap_or("root") == "root";
+    let sources: Vec<PathBuf> = if is_local {
+        sources.iter().map(|s| PathBuf::from(expand_tilde(s))).collect()
+    } else {
+        sources.iter().map(PathBuf::from).collect()
+    };
     let config = config.unwrap_or_default();
 
-    ops_delete_files_start(app, sources, config).await
+    ops_delete_files_start(app, sources, config, volume_id).await
 }
 
 /// Moves files to macOS Trash. Same events as `copy_files` but with `operationType: trash`.

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

@@ -92,26 +92,53 @@ pub async fn check_rename_validity(
 }
 
 /// Renames a file or directory. When `force` is true, proceeds even if the destination exists.
+///
+/// When `volume_id` is provided and not `"root"`, routes through the Volume trait
+/// (needed for MTP and other non-local volumes). Otherwise uses `std::fs::rename`.
 #[tauri::command]
-pub async fn rename_file(from: String, to: String, force: bool) -> Result<(), IpcError> {
-    let from_expanded = expand_tilde(&from);
-    let to_expanded = expand_tilde(&to);
-    let from_path = PathBuf::from(&from_expanded);
-    let to_path = PathBuf::from(&to_expanded);
-
-    tokio::time::timeout(
-        Duration::from_secs(5),
-        tokio::task::spawn_blocking(move || {
-            if !force && from_path != to_path && std::fs::symlink_metadata(&to_path).is_ok() {
-                return Err(format!("'{}' already exists", to_path.display()));
-            }
-            std::fs::rename(&from_path, &to_path).map_err(|e| format!("Rename failed: {}", e))
-        }),
-    )
-    .await
-    .map_err(|_| IpcError::timeout())?
-    .map_err(|e| IpcError::from_err(format!("Task failed: {}", e)))?
-    .map_err(IpcError::from_err)
+pub async fn rename_file(from: String, to: String, force: bool, volume_id: Option<String>) -> Result<(), IpcError> {
+    let volume_id_str = volume_id.unwrap_or_else(|| "root".to_string());
+
+    if volume_id_str != "root" {
+        // Volume-aware rename (MTP and other non-local volumes)
+        let volume = crate::file_system::get_volume_manager()
+            .get(&volume_id_str)
+            .ok_or_else(|| IpcError::from_err(format!("Volume '{}' not found", volume_id_str)))?;
+
+        let from_path = PathBuf::from(&from);
+        let to_path = PathBuf::from(&to);
+
+        tokio::time::timeout(
+            Duration::from_secs(5),
+            tokio::task::spawn_blocking(move || {
+                volume.rename(&from_path, &to_path, force).map_err(|e| format!("{}", e))
+            }),
+        )
+        .await
+        .map_err(|_| IpcError::timeout())?
+        .map_err(|e| IpcError::from_err(format!("Task failed: {}", e)))?
+        .map_err(IpcError::from_err)
+    } else {
+        // Local filesystem rename
+        let from_expanded = expand_tilde(&from);
+        let to_expanded = expand_tilde(&to);
+        let from_path = PathBuf::from(&from_expanded);
+        let to_path = PathBuf::from(&to_expanded);
+
+        tokio::time::timeout(
+            Duration::from_secs(5),
+            tokio::task::spawn_blocking(move || {
+                if !force && from_path != to_path && std::fs::symlink_metadata(&to_path).is_ok() {
+                    return Err(format!("'{}' already exists", to_path.display()));
+                }
+                std::fs::rename(&from_path, &to_path).map_err(|e| format!("Rename failed: {}", e))
+            }),
+        )
+        .await
+        .map_err(|_| IpcError::timeout())?
+        .map_err(|e| IpcError::from_err(format!("Task failed: {}", e)))?
+        .map_err(IpcError::from_err)
+    }
 }
 
 /// Synchronous permission check implementation.
@@ -430,6 +457,7 @@ mod tests {
             old.to_string_lossy().to_string(),
             new.to_string_lossy().to_string(),
             false,
+            None,
         )
         .await;
         assert!(result.is_ok());
@@ -450,6 +478,7 @@ mod tests {
             old.to_string_lossy().to_string(),
             new.to_string_lossy().to_string(),
             false,
+            None,
         )
         .await;
         assert!(result.is_err());
@@ -471,6 +500,7 @@ mod tests {
             old.to_string_lossy().to_string(),
             new.to_string_lossy().to_string(),
             true,
+            None,
         )
         .await;
         assert!(result.is_ok());

apps/desktop/src-tauri/src/file_system/write_operations/CLAUDE.md

@@ -19,7 +19,7 @@ network mounts, cross-filesystem moves, and name/path length limits.
 | `scan.rs` | `scan_sources` (recursive walk, emits progress), `dry_run_scan`, scan preview subsystem (`start_scan_preview`, `cancel_scan_preview`). |
 | `copy.rs` | `copy_files_with_progress`: scan → disk space check → per-file copy via `copy_single_item`. `CopyTransaction` for rollback. |
 | `move_op.rs` | Same-fs: `fs::rename`. Cross-fs: copy to `.cmdr-staging-<uuid>`, atomic rename, delete sources. |
-| `delete.rs` | Scan, delete files first, then directories in reverse/deepest-first order. Not rollbackable. |
+| `delete.rs` | Scan, delete files first, then directories in reverse/deepest-first order. Not rollbackable. Also contains `delete_volume_files_with_progress` for non-local volumes (MTP): scans via `volume.list_directory()`, deletes via `volume.delete()` per item. |
 | `trash.rs` | `move_to_trash_sync()` (macOS: ObjC `trashItemAtURL`; Linux: `trash` crate; reused by `commands/rename.rs`) and `trash_files_with_progress()` (batch trash with per-item progress, cancellation, partial failure). Uses `symlink_metadata()` for existence checks (handles dangling symlinks). |
 | `copy_strategy.rs` | Strategy selection per file: network FS → chunked copy; overwrite → temp+rename; macOS → `copyfile(3)`; Linux → `copy_file_range(2)`. |
 | `macos_copy.rs` | FFI to macOS `copyfile(3)`. Preserves xattrs, ACLs, resource forks, Finder metadata. Supports APFS `clonefile`. |
@@ -112,6 +112,9 @@ from pre-computed item sizes. Partial failure is supported: if some items fail,
 
 ## Key decisions
 
+**Decision**: `delete_files_start` routes to either `delete_files_with_progress` (local, uses `walkdir` + `fs::remove_file`) or `delete_volume_files_with_progress` (non-local, uses `Volume` trait) based on `volume_id`.
+**Why**: MTP volumes can't use `walkdir` or `fs::remove_*`. Rather than refactoring the existing local delete to go through the Volume trait (which would add overhead for local ops), we keep the fast local path and add a parallel volume-aware path. Both emit identical events so the frontend progress dialog works unchanged.
+
 **Decision**: Keep `exacl` crate for ACL copy in chunked copies (not custom FFI bindings).
 **Why**: `exacl` adds zero new transitive dependencies (all of its deps — `bitflags`, `log`, `scopeguard`, `uuid` — are already in our tree). It provides cross-platform ACL support (macOS, Linux, FreeBSD) and full ACL parsing/manipulation for potential future UI features. The crate appears unmaintained (last release Feb 2024) but ACL APIs are stable and don't change. Our usage is best-effort with graceful fallback — if `exacl` ever breaks, files still copy, they just lose ACLs. MIT licensed (compatible with BSL).