MTP: Make mkdir and copy work on MTP drives

- Fix connection issues
- Remove redundant MCP-specific copy dialog
- Fix bug that listed devices by the wrong name
- Make listing work flawlessly
- Fix copying, now it works both FROM and TO MTP devices
- Add file system watching
- Add debug logging

Author: vdavid

apps/desktop/coverage-allowlist.json

@@ -28,13 +28,11 @@
         "licensing-store.svelte.ts": { "reason": "Depends on Tauri store APIs" },
         "logger.ts": { "reason": "LogTape config, initialization code only" },
         "mtp/MtpBrowser.svelte": { "reason": "MTP file browser component, depends on Tauri APIs" },
-        "mtp/MtpCopyDialog.svelte": { "reason": "UI modal for MTP copy progress, depends on Tauri APIs" },
         "mtp/MtpDeleteDialog.svelte": { "reason": "UI modal for MTP delete confirmation" },
         "mtp/MtpNewFolderDialog.svelte": { "reason": "UI modal for MTP new folder" },
         "mtp/MtpProgressDialog.svelte": { "reason": "UI modal for MTP progress tracking" },
         "mtp/MtpRenameDialog.svelte": { "reason": "UI modal for MTP rename" },
         "mtp/PtpcameradDialog.svelte": { "reason": "UI modal for macOS MTP workaround" },
-        "mtp/mtp-path-utils.ts": { "reason": "MTP path utilities, tested implicitly via component usage" },
         "mtp/mtp-store.svelte.ts": { "reason": "Depends on Tauri APIs, tests planned in Phase 6" },
         "licensing/AboutWindow.svelte": { "reason": "UI component" },
         "licensing/CommercialReminderModal.svelte": { "reason": "UI component" },

apps/desktop/src-tauri/Cargo.lock

@@ -64,6 +64,7 @@ tower-http = { version = "0.6", features = ["cors"] }
 tauri-plugin-updater = "2"
 tauri-plugin-process = "2"
 memchr = "2"
+walkdir = "2"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

apps/desktop/src-tauri/Cargo.toml

@@ -1,6 +1,7 @@
 //! Tauri commands for MTP (Android device) operations.
 
 use log::debug;
+use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 use crate::file_system::FileEntry;
@@ -9,6 +10,18 @@ use crate::mtp::{
 };
 use tauri::AppHandle;
 
+/// Result of scanning an MTP path for copy operation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MtpScanResult {
+    /// Number of files found.
+    pub file_count: usize,
+    /// Number of directories found.
+    pub dir_count: usize,
+    /// Total bytes of all files.
+    pub total_bytes: u64,
+}
+
 /// Lists all connected MTP devices.
 ///
 /// This returns devices detected via USB that support MTP protocol.
@@ -121,11 +134,7 @@ pub async fn list_mtp_directory(
         .list_directory(&device_id, storage_id, &path)
         .await;
     match &result {
-        Ok(entries) => debug!(
-            "list_mtp_directory: SUCCESS - {} entries for {}",
-            entries.len(),
-            path
-        ),
+        Ok(entries) => debug!("list_mtp_directory: SUCCESS - {} entries for {}", entries.len(), path),
         Err(e) => debug!("list_mtp_directory: ERROR - {:?}", e),
     }
     result
@@ -276,3 +285,38 @@ pub async fn move_mtp_object(
         .move_object(&device_id, storage_id, &object_path, &new_parent_path)
         .await
 }
+
+// ============================================================================
+// Phase 5: Copy/Export Operations
+// ============================================================================
+
+/// Scans an MTP path for copy statistics.
+///
+/// Recursively scans the specified path to get file count, directory count,
+/// and total bytes. Useful for showing progress during copy operations.
+///
+/// # Arguments
+///
+/// * `device_id` - The connected device ID
+/// * `storage_id` - The storage ID within the device
+/// * `path` - Virtual path on the device to scan
+#[tauri::command]
+pub async fn scan_mtp_for_copy(
+    device_id: String,
+    storage_id: u32,
+    path: String,
+) -> Result<MtpScanResult, MtpConnectionError> {
+    debug!(
+        "scan_mtp_for_copy: device={}, storage={}, path={}",
+        device_id, storage_id, path
+    );
+    let result = mtp::connection_manager()
+        .scan_for_copy(&device_id, storage_id, &path)
+        .await?;
+
+    Ok(MtpScanResult {
+        file_count: result.file_count,
+        dir_count: result.dir_count,
+        total_bytes: result.total_bytes,
+    })
+}

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

@@ -37,7 +37,10 @@ pub use operations::get_paths_at_indices;
 pub use provider::FileSystemProvider;
 // Re-export volume types (some not used externally yet)
 #[allow(unused_imports, reason = "Public API re-exports for future use")]
-pub use volume::{InMemoryVolume, LocalPosixVolume, MtpVolume, Volume, VolumeError};
+pub use volume::{
+    ConflictInfo, CopyScanResult, InMemoryVolume, LocalPosixVolume, MtpVolume, SourceItemInfo, SpaceInfo, Volume,
+    VolumeError,
+};
 #[allow(unused_imports, reason = "Public API re-exports for future use")]
 pub use volume_manager::VolumeManager;
 // Watcher management - init_watcher_manager must be called from lib.rs
@@ -48,6 +51,10 @@ pub use write_operations::{
     cancel_write_operation, copy_files_start, delete_files_start, get_operation_status, list_active_operations,
     move_files_start,
 };
+// Re-export volume copy types and functions
+// TODO: Remove this allow once volume_copy is integrated into Tauri commands (Phase 5)
+#[allow(unused_imports, reason = "Volume copy not yet integrated into Tauri commands")]
+pub use write_operations::{VolumeCopyConfig, VolumeCopyScanResult, copy_between_volumes, scan_for_volume_copy};
 
 /// Global volume manager instance
 static VOLUME_MANAGER: LazyLock<VolumeManager> = LazyLock::new(VolumeManager::new);

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

@@ -1342,14 +1342,20 @@ fn read_directory_with_progress(
     listing_id: &str,
     state: &Arc<StreamingListingState>,
     volume_id: &str,
-    path: &PathBuf,
+    path: &Path,
     include_hidden: bool,
     sort_by: SortColumn,
     sort_order: SortOrder,
 ) -> Result<(), std::io::Error> {
     use tauri::Emitter;
 
     benchmark::log_event("read_directory_with_progress START");
+    log::debug!(
+        "read_directory_with_progress: listing_id={}, volume_id={}, path={}",
+        listing_id,
+        volume_id,
+        path.display()
+    );
 
     // Emit opening event - this is the slow part for network folders
     // (SMB connection establishment, directory handle creation, MTP queries)
@@ -1373,18 +1379,15 @@ fn read_directory_with_progress(
     }
 
     // Get the volume from VolumeManager
-    let volume = super::get_volume_manager().get(volume_id).ok_or_else(|| {
-        std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            format!("Volume not found: {}", volume_id),
-        )
-    })?;
+    let volume = super::get_volume_manager()
+        .get(volume_id)
+        .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, format!("Volume not found: {}", volume_id)))?;
 
     // Read directory entries via Volume abstraction
     let read_start = std::time::Instant::now();
     let mut entries = volume
         .list_directory(path)
-        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+        .map_err(|e| std::io::Error::other(e.to_string()))?;
     let read_dir_time = read_start.elapsed();
     benchmark::log_event_value("read_dir COMPLETE, entries", entries.len());
 
@@ -1434,7 +1437,7 @@ fn read_directory_with_progress(
             listing_id.to_string(),
             CachedListing {
                 volume_id: volume_id.to_string(),
-                path: path.clone(),
+                path: path.to_path_buf(),
                 entries,
                 sort_by,
                 sort_order,

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

@@ -1,9 +1,10 @@
 //! Local POSIX file system volume implementation.
 
-use super::{Volume, VolumeError};
+use super::{ConflictInfo, CopyScanResult, SourceItemInfo, SpaceInfo, Volume, VolumeError};
 use crate::file_system::FileEntry;
 use crate::file_system::operations::{get_single_entry, list_directory_core};
 use std::path::{Path, PathBuf};
+use walkdir::WalkDir;
 
 /// A volume backed by the local POSIX file system.
 ///
@@ -116,4 +117,144 @@ impl Volume for LocalPosixVolume {
         std::fs::rename(&from_abs, &to_abs)?;
         Ok(())
     }
+
+    fn supports_export(&self) -> bool {
+        true
+    }
+
+    fn scan_for_copy(&self, path: &Path) -> Result<CopyScanResult, VolumeError> {
+        let abs_path = self.resolve(path);
+        let mut file_count = 0;
+        let mut dir_count = 0;
+        let mut total_bytes = 0u64;
+
+        for entry in WalkDir::new(&abs_path).min_depth(0) {
+            let entry = entry.map_err(|e| VolumeError::IoError(e.to_string()))?;
+            let ft = entry.file_type();
+            if ft.is_file() {
+                file_count += 1;
+                if let Ok(meta) = entry.metadata() {
+                    total_bytes += meta.len();
+                }
+            } else if ft.is_dir() {
+                // Don't count the root itself if it's the starting point
+                if entry.depth() > 0 {
+                    dir_count += 1;
+                }
+            }
+        }
+
+        // If the path is a single file, count it
+        if let Ok(meta) = std::fs::metadata(&abs_path) {
+            if meta.is_file() && file_count == 0 {
+                file_count = 1;
+                total_bytes = meta.len();
+            } else if meta.is_dir() && dir_count == 0 && file_count == 0 {
+                dir_count = 1;
+            }
+        }
+
+        Ok(CopyScanResult {
+            file_count,
+            dir_count,
+            total_bytes,
+        })
+    }
+
+    fn export_to_local(&self, source: &Path, local_dest: &Path) -> Result<u64, VolumeError> {
+        let src_abs = self.resolve(source);
+        copy_recursive(&src_abs, local_dest)
+    }
+
+    fn import_from_local(&self, local_source: &Path, dest: &Path) -> Result<u64, VolumeError> {
+        let dest_abs = self.resolve(dest);
+        copy_recursive(local_source, &dest_abs)
+    }
+
+    fn scan_for_conflicts(
+        &self,
+        source_items: &[SourceItemInfo],
+        dest_path: &Path,
+    ) -> Result<Vec<ConflictInfo>, VolumeError> {
+        let dest_abs = self.resolve(dest_path);
+        let mut conflicts = Vec::new();
+
+        for item in source_items {
+            let dest_file_path = dest_abs.join(&item.name);
+            if dest_file_path.exists()
+                && let Ok(meta) = std::fs::metadata(&dest_file_path)
+            {
+                let dest_modified = meta
+                    .modified()
+                    .ok()
+                    .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok().map(|d| d.as_secs() as i64));
+
+                conflicts.push(ConflictInfo {
+                    source_path: item.name.clone(),
+                    dest_path: dest_file_path.to_string_lossy().to_string(),
+                    source_size: item.size,
+                    dest_size: meta.len(),
+                    source_modified: item.modified,
+                    dest_modified,
+                });
+            }
+        }
+
+        Ok(conflicts)
+    }
+
+    fn get_space_info(&self) -> Result<SpaceInfo, VolumeError> {
+        get_space_info_for_path(&self.root)
+    }
+}
+
+/// Recursively copies a file or directory from source to destination.
+/// Returns total bytes copied.
+fn copy_recursive(source: &Path, dest: &Path) -> Result<u64, VolumeError> {
+    let meta = std::fs::metadata(source)?;
+    let mut total_bytes = 0;
+
+    if meta.is_file() {
+        // Copy single file
+        std::fs::copy(source, dest)?;
+        total_bytes = meta.len();
+    } else if meta.is_dir() {
+        // Create destination directory
+        std::fs::create_dir_all(dest)?;
+
+        // Copy all contents
+        for entry in std::fs::read_dir(source)? {
+            let entry = entry?;
+            let src_path = entry.path();
+            let dest_path = dest.join(entry.file_name());
+            total_bytes += copy_recursive(&src_path, &dest_path)?;
+        }
+    }
+
+    Ok(total_bytes)
+}
+
+/// Gets space information for a path using statvfs.
+fn get_space_info_for_path(path: &Path) -> Result<SpaceInfo, VolumeError> {
+    use std::ffi::CString;
+
+    let path_c = CString::new(path.to_string_lossy().as_bytes()).map_err(|e| VolumeError::IoError(e.to_string()))?;
+
+    unsafe {
+        let mut stat: libc::statvfs = std::mem::zeroed();
+        if libc::statvfs(path_c.as_ptr(), &mut stat) == 0 {
+            let block_size = stat.f_frsize as u64;
+            let total_bytes = (stat.f_blocks as u64) * block_size;
+            let available_bytes = (stat.f_bavail as u64) * block_size;
+            let used_bytes = total_bytes.saturating_sub((stat.f_bfree as u64) * block_size);
+
+            Ok(SpaceInfo {
+                total_bytes,
+                available_bytes,
+                used_bytes,
+            })
+        } else {
+            Err(VolumeError::IoError("Failed to get space info".into()))
+        }
+    }
 }