MTP: Export files directly, no guess-and-fallback

- `MtpVolume::export_to_local` and `export_to_local_with_progress` now call `download_file` directly instead of routing through `download_recursive`
- Remove `download_recursive`, `download_entries_recursive`, and `is_file_by_parent` from `bulk_ops.rs` (dead code)
- Eliminates the `ObjectNotFound` ERROR log spam that occurred on every file copy because `download_recursive` tried `list_directory` on file paths before falling back

Author: vdavid

apps/desktop/src-tauri/src/file_system/volume/mtp.rs

@@ -518,19 +518,23 @@ impl Volume for MtpVolume {
 
         let handle = tokio::runtime::Handle::current();
         let progress = SendSyncProgress(on_progress);
+        let operation_id = format!("export-{}", uuid::Uuid::new_v4());
 
         handle
             .block_on(async {
                 connection_manager()
-                    .download_recursive_with_progress(
+                    .download_file_with_progress(
                         &device_id,
                         storage_id,
                         &mtp_path,
                         &local_dest,
-                        &|bytes_done, bytes_total| progress.call(bytes_done, bytes_total),
+                        None,
+                        &operation_id,
+                        Some(&|bytes_done, bytes_total| progress.call(bytes_done, bytes_total)),
                     )
                     .await
             })
+            .map(|result| result.bytes_transferred)
             .map_err(map_mtp_error)
     }
 
@@ -549,13 +553,15 @@ impl Volume for MtpVolume {
         );
 
         let handle = tokio::runtime::Handle::current();
+        let operation_id = format!("export-{}", uuid::Uuid::new_v4());
 
         handle
             .block_on(async move {
                 connection_manager()
-                    .download_recursive(&device_id, storage_id, &mtp_path, &local_dest)
+                    .download_file(&device_id, storage_id, &mtp_path, &local_dest, None, &operation_id)
                     .await
             })
+            .map(|result| result.bytes_transferred)
             .map_err(map_mtp_error)
     }
 

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

@@ -20,7 +20,7 @@ On Linux, users may need udev rules for USB device permissions (see `resources/9
 | `connection/directory_ops.rs` | `list_directory()` (with lock-contention logging), `resolve_path_to_handle()` (cache-only) |
 | `connection/file_ops.rs` | `download_file()`, `upload_file()` — emit `mtp-transfer-progress` Tauri events |
 | `connection/mutation_ops.rs` | `delete()` (recursive, children-first), `create_folder()`, `rename()`, `move_object()` — no copy+delete fallback |
-| `connection/bulk_ops.rs` | `scan_for_copy()`, `download_recursive()`, `upload_recursive()` — use `Box::pin` for async recursion |
+| `connection/bulk_ops.rs` | `scan_for_copy()`, `upload_recursive()` — use `Box::pin` for async recursion |
 | `virtual_device.rs` | Virtual MTP device for E2E testing; creates backing dirs + registers device via `mtp-rs`. Gated behind `virtual-mtp` feature. Run with: `cd apps/desktop && pnpm tauri dev -c src-tauri/tauri.dev.json --features virtual-mtp` |
 
 ## Architecture / data flow

apps/desktop/src-tauri/src/mtp/connection/bulk_ops.rs

@@ -144,296 +144,6 @@ impl MtpConnectionManager {
         })
     }
 
-    /// Downloads a file or directory recursively from the MTP device to a local path.
-    ///
-    /// # Arguments
-    ///
-    /// * `device_id` - The connected device ID
-    /// * `storage_id` - The storage ID within the device
-    /// * `object_path` - Virtual path on the device to download
-    /// * `local_dest` - Local destination path
-    ///
-    /// # Returns
-    ///
-    /// Total bytes transferred.
-    pub async fn download_recursive(
-        &self,
-        device_id: &str,
-        storage_id: u32,
-        object_path: &str,
-        local_dest: &Path,
-    ) -> Result<u64, MtpConnectionError> {
-        debug!(
-            "MTP download_recursive: device={}, storage={}, path={}, dest={}",
-            device_id,
-            storage_id,
-            object_path,
-            local_dest.display()
-        );
-
-        // Try to list the path as a directory
-        match self.list_directory(device_id, storage_id, object_path).await {
-            Ok(entries) if !entries.is_empty() => {
-                // Directory with contents — download all entries
-                self.download_entries_recursive(device_id, storage_id, &entries, local_dest)
-                    .await
-            }
-            Ok(_) => {
-                // Empty result — disambiguate file vs empty directory
-                if self.is_file_by_parent(device_id, storage_id, object_path).await {
-                    debug!("MTP download_recursive: {} is a file, downloading", object_path);
-                    let operation_id = format!("download-{}", uuid::Uuid::new_v4());
-                    let result = self
-                        .download_file(device_id, storage_id, object_path, local_dest, None, &operation_id)
-                        .await?;
-                    Ok(result.bytes_transferred)
-                } else {
-                    debug!("MTP download_recursive: {} is an empty directory", object_path);
-                    tokio::fs::create_dir_all(local_dest)
-                        .await
-                        .map_err(|e| MtpConnectionError::Other {
-                            device_id: device_id.to_string(),
-                            message: format!("Failed to create local directory: {}", e),
-                        })?;
-                    Ok(0)
-                }
-            }
-            Err(e) => {
-                // list_directory failed — check if it's a file
-                debug!(
-                    "MTP download_recursive: list failed for '{}', checking if it's a file: {:?}",
-                    object_path, e
-                );
-                if self.is_file_by_parent(device_id, storage_id, object_path).await {
-                    debug!("MTP download_recursive: {} is a file, downloading", object_path);
-                    let operation_id = format!("download-{}", uuid::Uuid::new_v4());
-                    let result = self
-                        .download_file(device_id, storage_id, object_path, local_dest, None, &operation_id)
-                        .await?;
-                    Ok(result.bytes_transferred)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-
-    /// Downloads a list of already-known directory entries to a local path.
-    ///
-    /// Like `scan_entries_recursive`, this takes entries from a parent listing,
-    /// so files are handled directly and directories get one `list_directory` call each.
-    async fn download_entries_recursive(
-        &self,
-        device_id: &str,
-        storage_id: u32,
-        entries: &[FileEntry],
-        local_dest: &Path,
-    ) -> Result<u64, MtpConnectionError> {
-        tokio::fs::create_dir_all(local_dest)
-            .await
-            .map_err(|e| MtpConnectionError::Other {
-                device_id: device_id.to_string(),
-                message: format!("Failed to create local directory: {}", e),
-            })?;
-
-        let mut total_bytes = 0u64;
-
-        for entry in entries {
-            let child_dest = local_dest.join(&entry.name);
-
-            if entry.is_directory {
-                let children = self.list_directory(device_id, storage_id, &entry.path).await?;
-                if children.is_empty() {
-                    tokio::fs::create_dir_all(&child_dest)
-                        .await
-                        .map_err(|e| MtpConnectionError::Other {
-                            device_id: device_id.to_string(),
-                            message: format!("Failed to create local directory: {}", e),
-                        })?;
-                } else {
-                    let bytes =
-                        Box::pin(self.download_entries_recursive(device_id, storage_id, &children, &child_dest))
-                            .await?;
-                    total_bytes += bytes;
-                }
-            } else {
-                let operation_id = format!("download-{}", uuid::Uuid::new_v4());
-                let result = self
-                    .download_file(device_id, storage_id, &entry.path, &child_dest, None, &operation_id)
-                    .await?;
-                total_bytes += result.bytes_transferred;
-            }
-        }
-
-        debug!(
-            "MTP download_entries_recursive: directory {} complete, {} bytes",
-            local_dest.display(),
-            total_bytes
-        );
-        Ok(total_bytes)
-    }
-
-    /// Downloads a file or directory recursively with a progress/cancellation callback.
-    ///
-    /// Same as `download_recursive` but calls `on_progress(bytes_done, bytes_total)` per chunk.
-    /// Returns `ControlFlow::Break(())` from the callback to cancel.
-    pub async fn download_recursive_with_progress(
-        &self,
-        device_id: &str,
-        storage_id: u32,
-        object_path: &str,
-        local_dest: &Path,
-        on_progress: &(dyn Fn(u64, u64) -> std::ops::ControlFlow<()> + Send + Sync),
-    ) -> Result<u64, MtpConnectionError> {
-        debug!(
-            "MTP download_recursive_with_progress: device={}, storage={}, path={}, dest={}",
-            device_id,
-            storage_id,
-            object_path,
-            local_dest.display()
-        );
-
-        match self.list_directory(device_id, storage_id, object_path).await {
-            Ok(entries) if !entries.is_empty() => {
-                self.download_entries_recursive_with_progress(device_id, storage_id, &entries, local_dest, on_progress)
-                    .await
-            }
-            Ok(_) => {
-                if self.is_file_by_parent(device_id, storage_id, object_path).await {
-                    let operation_id = format!("download-{}", uuid::Uuid::new_v4());
-                    let result = self
-                        .download_file_with_progress(
-                            device_id,
-                            storage_id,
-                            object_path,
-                            local_dest,
-                            None,
-                            &operation_id,
-                            Some(on_progress),
-                        )
-                        .await?;
-                    Ok(result.bytes_transferred)
-                } else {
-                    tokio::fs::create_dir_all(local_dest)
-                        .await
-                        .map_err(|e| MtpConnectionError::Other {
-                            device_id: device_id.to_string(),
-                            message: format!("Failed to create local directory: {}", e),
-                        })?;
-                    Ok(0)
-                }
-            }
-            Err(e) => {
-                if self.is_file_by_parent(device_id, storage_id, object_path).await {
-                    let operation_id = format!("download-{}", uuid::Uuid::new_v4());
-                    let result = self
-                        .download_file_with_progress(
-                            device_id,
-                            storage_id,
-                            object_path,
-                            local_dest,
-                            None,
-                            &operation_id,
-                            Some(on_progress),
-                        )
-                        .await?;
-                    Ok(result.bytes_transferred)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-
-    /// Downloads directory entries recursively with a progress/cancellation callback.
-    async fn download_entries_recursive_with_progress(
-        &self,
-        device_id: &str,
-        storage_id: u32,
-        entries: &[FileEntry],
-        local_dest: &Path,
-        on_progress: &(dyn Fn(u64, u64) -> std::ops::ControlFlow<()> + Send + Sync),
-    ) -> Result<u64, MtpConnectionError> {
-        tokio::fs::create_dir_all(local_dest)
-            .await
-            .map_err(|e| MtpConnectionError::Other {
-                device_id: device_id.to_string(),
-                message: format!("Failed to create local directory: {}", e),
-            })?;
-
-        let mut total_bytes = 0u64;
-
-        for entry in entries {
-            let child_dest = local_dest.join(&entry.name);
-
-            if entry.is_directory {
-                let children = self.list_directory(device_id, storage_id, &entry.path).await?;
-                if children.is_empty() {
-                    tokio::fs::create_dir_all(&child_dest)
-                        .await
-                        .map_err(|e| MtpConnectionError::Other {
-                            device_id: device_id.to_string(),
-                            message: format!("Failed to create local directory: {}", e),
-                        })?;
-                } else {
-                    let bytes = Box::pin(self.download_entries_recursive_with_progress(
-                        device_id,
-                        storage_id,
-                        &children,
-                        &child_dest,
-                        on_progress,
-                    ))
-                    .await?;
-                    total_bytes += bytes;
-                }
-            } else {
-                let operation_id = format!("download-{}", uuid::Uuid::new_v4());
-                let result = self
-                    .download_file_with_progress(
-                        device_id,
-                        storage_id,
-                        &entry.path,
-                        &child_dest,
-                        None,
-                        &operation_id,
-                        Some(on_progress),
-                    )
-                    .await?;
-                total_bytes += result.bytes_transferred;
-            }
-        }
-
-        debug!(
-            "MTP download_entries_recursive_with_progress: directory {} complete, {} bytes",
-            local_dest.display(),
-            total_bytes
-        );
-        Ok(total_bytes)
-    }
-
-    /// Checks if a path is a file by looking it up in its parent directory listing.
-    async fn is_file_by_parent(&self, device_id: &str, storage_id: u32, path: &str) -> bool {
-        let path_buf = normalize_mtp_path(path);
-        let Some(parent) = path_buf.parent() else {
-            return false;
-        };
-        let Some(name) = path_buf.file_name().and_then(|n| n.to_str()) else {
-            return false;
-        };
-
-        if let Ok(parent_entries) = self
-            .list_directory(device_id, storage_id, &parent.to_string_lossy())
-            .await
-        {
-            parent_entries
-                .iter()
-                .find(|e| e.name == name)
-                .is_some_and(|e| !e.is_directory)
-        } else {
-            false
-        }
-    }
-
     /// Uploads a file or directory from local filesystem to MTP device recursively.
     ///
     /// If the source is a directory, creates the directory on the device and

apps/desktop/src-tauri/src/mtp/connection/mod.rs

@@ -494,7 +494,7 @@ impl MtpConnectionManager {
 // - event_loop.rs: start_event_loop, stop_event_loop, event handling
 // - file_ops.rs: download_file, upload_file, open_download_stream, upload_from_chunks
 // - mutation_ops.rs: delete_object, create_folder, rename_object, move_object
-// - bulk_ops.rs: scan_for_copy, download_recursive, upload_recursive
+// - bulk_ops.rs: scan_for_copy, upload_recursive
 
 /// Global connection manager instance.
 static CONNECTION_MANAGER: LazyLock<MtpConnectionManager> = LazyLock::new(MtpConnectionManager::new);