Clipboard: Add Cmd+C/V/X for files, Finder interop

- New `clipboard/` Rust module: NSPasteboard FFI via objc2 (write/read file URLs + plain text), in-process cut state tracking
- Four Tauri commands: `copy_files_to_clipboard`, `cut_files_to_clipboard`, `read_clipboard_files`, `clear_clipboard_cut_state`
- Frontend: command registry entries, handlers in `+page.svelte` with `activeElement` routing (text input → native clipboard, file list → file clipboard), `DualPaneExplorer` methods, `startTransferProgress` for direct paste into `TransferProgressDialog`
- Menu: replaced PredefinedMenuItem cut/copy/paste with custom MenuItems routing through `execute-command` dispatch, added "Move here" (⌥⌘V)
- Cmd+X sets internal cut flag; Cmd+V after cut moves files; stale cut state auto-cleared if clipboard changes between cut and paste
- MTP paths excluded with notification
- Linux: stubs return errors, menu items added with Ctrl accelerators

Author: vdavid

apps/desktop/src-tauri/Cargo.toml

@@ -125,7 +125,7 @@ objc2-foundation = { version = "0.3", features = [
 ] }
 objc2-app-kit = { version = "0.3", features = [
     "NSDragging", "NSDraggingItem", "NSImage", "NSColor", "NSColorSpace",
-    "NSApplication", "NSMenu", "NSMenuItem", "NSRunningApplication",
+    "NSApplication", "NSMenu", "NSMenuItem", "NSPasteboard", "NSRunningApplication",
 ] }
 block2 = "0.6"
 security-framework = "3.2"

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

@@ -0,0 +1,10 @@
+//! Clipboard file operations for copy/cut/paste workflows.
+
+#[cfg(target_os = "macos")]
+mod pasteboard;
+mod state;
+
+pub use state::{clear_cut_state, get_cut_state, set_cut_state};
+
+#[cfg(target_os = "macos")]
+pub use pasteboard::{read_file_urls_from_clipboard, write_file_urls_to_clipboard};

apps/desktop/src-tauri/src/clipboard/pasteboard.rs

@@ -0,0 +1,109 @@
+//! macOS NSPasteboard FFI for file URL clipboard operations.
+//!
+//! All functions assume they are called on the main thread. Callers must use
+//! `app.run_on_main_thread()` when invoking from async Tauri commands.
+
+use std::path::PathBuf;
+
+use objc2::ClassType;
+use objc2::msg_send;
+use objc2::rc::Retained;
+use objc2::runtime::AnyObject;
+use objc2_app_kit::{
+    NSPasteboard, NSPasteboardReadingOptionKey, NSPasteboardTypeString, NSPasteboardURLReadingFileURLsOnlyKey,
+};
+use objc2_foundation::{NSArray, NSDictionary, NSString, NSURL};
+
+/// Writes file URLs to the system pasteboard.
+///
+/// Places both file URL items (for Finder-compatible paste) and plain-text
+/// newline-separated paths (for pasting into text editors).
+pub fn write_file_urls_to_clipboard(paths: &[PathBuf]) -> Result<(), String> {
+    if paths.is_empty() {
+        return Err("No paths to write to clipboard".to_string());
+    }
+
+    let pasteboard = NSPasteboard::generalPasteboard();
+
+    // Build NSURL objects for each path
+    let urls: Vec<Retained<NSURL>> = paths
+        .iter()
+        .map(|p| {
+            let ns_path = NSString::from_str(&p.to_string_lossy());
+            NSURL::fileURLWithPath(&ns_path)
+        })
+        .collect();
+
+    // Clear existing contents
+    pasteboard.clearContents();
+
+    // Write file URLs via writeObjects. NSURL conforms to NSPasteboardWriting,
+    // so we use msg_send! to pass the array without ProtocolObject generic juggling.
+    let url_refs: Vec<&NSURL> = urls.iter().map(|u| &**u).collect();
+    let url_array = NSArray::from_slice(&url_refs);
+    let success: bool = unsafe { msg_send![&pasteboard, writeObjects: &*url_array] };
+    if !success {
+        return Err("NSPasteboard writeObjects returned false".to_string());
+    }
+
+    // Also write plain-text paths (newline-separated) so pasting into text editors works
+    let text = paths.iter().map(|p| p.to_string_lossy()).collect::<Vec<_>>().join("\n");
+    let ns_text = NSString::from_str(&text);
+    let pasteboard_type = unsafe { NSPasteboardTypeString };
+    pasteboard.setString_forType(&ns_text, pasteboard_type);
+
+    log::info!("Wrote {} file URL(s) to clipboard", paths.len());
+    Ok(())
+}
+
+/// Reads file URLs from the system pasteboard.
+///
+/// Uses `readObjectsForClasses:options:` with `NSURL` and `fileURLsOnly` to retrieve
+/// only local file URLs (not remote HTTP URLs).
+pub fn read_file_urls_from_clipboard() -> Result<Vec<PathBuf>, String> {
+    let pasteboard = NSPasteboard::generalPasteboard();
+
+    // Build class array containing NSURL's class
+    let nsurl_class = NSURL::class();
+    let class_array: Retained<NSArray<objc2::runtime::AnyClass>> = unsafe {
+        // NSArray<AnyClass> from a single class pointer
+        msg_send![
+            objc2::runtime::AnyClass::get(c"NSArray").ok_or("NSArray class not found")?,
+            arrayWithObject: nsurl_class,
+        ]
+    };
+
+    // Options: fileURLsOnly = true
+    let file_urls_only_key = unsafe { NSPasteboardURLReadingFileURLsOnlyKey };
+    let yes_value: Retained<AnyObject> = unsafe {
+        let cls = objc2::runtime::AnyClass::get(c"NSNumber").ok_or("NSNumber class not found")?;
+        let obj: *mut AnyObject = msg_send![cls, numberWithBool: true];
+        Retained::retain(obj).ok_or("Couldn't create NSNumber")?
+    };
+
+    let options: Retained<NSDictionary<NSPasteboardReadingOptionKey, AnyObject>> = unsafe {
+        msg_send![
+            objc2::runtime::AnyClass::get(c"NSDictionary").ok_or("NSDictionary class not found")?,
+            dictionaryWithObject: &*yes_value,
+            forKey: file_urls_only_key,
+        ]
+    };
+
+    let objects = unsafe { pasteboard.readObjectsForClasses_options(&class_array, Some(&options)) };
+
+    let Some(objects) = objects else {
+        return Ok(Vec::new());
+    };
+
+    let count = objects.len();
+    let mut paths = Vec::with_capacity(count);
+    for i in 0..count {
+        let obj: &AnyObject = unsafe { msg_send![&objects, objectAtIndex: i] };
+        let path_str: Option<Retained<NSString>> = unsafe { msg_send![obj, path] };
+        if let Some(ns_str) = path_str {
+            paths.push(PathBuf::from(ns_str.to_string()));
+        }
+    }
+
+    Ok(paths)
+}

apps/desktop/src-tauri/src/clipboard/state.rs

@@ -0,0 +1,29 @@
+//! In-process cut state tracking.
+//!
+//! When the user cuts files, we write them to the system clipboard (same as copy)
+//! and also record the source paths here. On paste, we check whether the clipboard
+//! still matches the cut set to decide between copy and move semantics.
+
+use std::path::PathBuf;
+use std::sync::{LazyLock, RwLock};
+
+struct CutState {
+    source_paths: Vec<PathBuf>,
+}
+
+static CUT_STATE: LazyLock<RwLock<Option<CutState>>> = LazyLock::new(|| RwLock::new(None));
+
+pub fn set_cut_state(paths: Vec<PathBuf>) {
+    let mut guard = CUT_STATE.write().unwrap_or_else(|e| e.into_inner());
+    *guard = Some(CutState { source_paths: paths });
+}
+
+pub fn clear_cut_state() {
+    let mut guard = CUT_STATE.write().unwrap_or_else(|e| e.into_inner());
+    *guard = None;
+}
+
+pub fn get_cut_state() -> Option<Vec<PathBuf>> {
+    let guard = CUT_STATE.read().unwrap_or_else(|e| e.into_inner());
+    guard.as_ref().map(|s| s.source_paths.clone())
+}

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

@@ -22,6 +22,7 @@ immediately to business-logic modules. No significant logic lives here.
 | `settings.rs` | Settings | Port availability check, watcher debounce setting, menu accelerator updates |
 | `licensing.rs` | Licensing | Status query, activation, expiry, reminder, key validation |
 | `indexing.rs` | Drive index | `start_drive_index`, `stop_drive_index`, `get_index_status`, `get_dir_stats`, `get_dir_stats_batch`, `prioritize_dir`, `cancel_nav_priority`, `clear_drive_index`, `set_indexing_enabled`. Uses `State<IndexManagerState>`. |
+| `clipboard.rs` | Clipboard file ops | `copy_files_to_clipboard`, `cut_files_to_clipboard`, `read_clipboard_files`, `clear_clipboard_cut_state`. macOS uses NSPasteboard via `clipboard::pasteboard`; non-macOS stubs return errors. |
 | `sync_status.rs` | Cloud sync status | `get_sync_status` — macOS delegates to `file_system::sync_status`; non-macOS returns empty map via `#[cfg]` on the function itself (not the module). |
 
 ## Key decisions

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

@@ -0,0 +1,191 @@
+//! Tauri commands for clipboard file operations (copy/cut/paste).
+
+use std::collections::HashSet;
+use std::path::PathBuf;
+
+#[cfg(target_os = "macos")]
+use crate::file_system::get_paths_at_indices as ops_get_paths_at_indices;
+
+use crate::clipboard;
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClipboardReadResult {
+    paths: Vec<String>,
+    is_cut: bool,
+}
+
+/// Resolves selected file paths and writes them to the system clipboard.
+/// Clears any existing cut state (this is a copy, not a cut).
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub async fn copy_files_to_clipboard(
+    app: tauri::AppHandle,
+    listing_id: String,
+    selected_indices: Vec<usize>,
+    cursor_index: usize,
+    has_parent: bool,
+    include_hidden: bool,
+) -> Result<usize, String> {
+    let indices = resolve_indices(&selected_indices, cursor_index, has_parent);
+    let paths = ops_get_paths_at_indices(&listing_id, &indices, include_hidden, has_parent)?;
+
+    if paths.is_empty() {
+        return Err("No files to copy".to_string());
+    }
+
+    let count = paths.len();
+
+    // Write to pasteboard on the main thread (NSPasteboard requires it)
+    let (tx, rx) = std::sync::mpsc::channel();
+    app.run_on_main_thread(move || {
+        let result = clipboard::write_file_urls_to_clipboard(&paths);
+        let _ = tx.send(result);
+    })
+    .map_err(|e| format!("Couldn't run on main thread: {e}"))?;
+
+    rx.recv()
+        .map_err(|e| format!("Couldn't receive pasteboard result: {e}"))??;
+
+    clipboard::clear_cut_state();
+
+    Ok(count)
+}
+
+/// Resolves selected file paths, writes them to the system clipboard, and marks them as cut.
+/// On paste, files will be moved instead of copied.
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub async fn cut_files_to_clipboard(
+    app: tauri::AppHandle,
+    listing_id: String,
+    selected_indices: Vec<usize>,
+    cursor_index: usize,
+    has_parent: bool,
+    include_hidden: bool,
+) -> Result<usize, String> {
+    let indices = resolve_indices(&selected_indices, cursor_index, has_parent);
+    let paths = ops_get_paths_at_indices(&listing_id, &indices, include_hidden, has_parent)?;
+
+    if paths.is_empty() {
+        return Err("No files to cut".to_string());
+    }
+
+    let count = paths.len();
+    let cut_paths = paths.clone();
+
+    // Write to pasteboard on the main thread
+    let (tx, rx) = std::sync::mpsc::channel();
+    app.run_on_main_thread(move || {
+        let result = clipboard::write_file_urls_to_clipboard(&paths);
+        let _ = tx.send(result);
+    })
+    .map_err(|e| format!("Couldn't run on main thread: {e}"))?;
+
+    rx.recv()
+        .map_err(|e| format!("Couldn't receive pasteboard result: {e}"))??;
+
+    clipboard::set_cut_state(cut_paths);
+
+    Ok(count)
+}
+
+/// Reads file URLs from the system clipboard and checks whether they were cut.
+///
+/// If the clipboard contents no longer match the recorded cut state (the user copied
+/// something else), the stale cut state is automatically cleared.
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub async fn read_clipboard_files(app: tauri::AppHandle) -> Result<ClipboardReadResult, String> {
+    // Read from pasteboard on the main thread
+    let (tx, rx) = std::sync::mpsc::channel();
+    app.run_on_main_thread(move || {
+        let result = clipboard::read_file_urls_from_clipboard();
+        let _ = tx.send(result);
+    })
+    .map_err(|e| format!("Couldn't run on main thread: {e}"))?;
+
+    let clipboard_paths = rx
+        .recv()
+        .map_err(|e| format!("Couldn't receive pasteboard result: {e}"))??;
+
+    // Check cut state: if set, verify paths match (order-insensitive)
+    let is_cut = if let Some(cut_paths) = clipboard::get_cut_state() {
+        let clipboard_set: HashSet<&PathBuf> = clipboard_paths.iter().collect();
+        let cut_set: HashSet<&PathBuf> = cut_paths.iter().collect();
+
+        if clipboard_set == cut_set {
+            true
+        } else {
+            // Clipboard changed since the cut -- clear stale state
+            clipboard::clear_cut_state();
+            false
+        }
+    } else {
+        false
+    };
+
+    let paths: Vec<String> = clipboard_paths
+        .iter()
+        .map(|p| p.to_string_lossy().into_owned())
+        .collect();
+
+    Ok(ClipboardReadResult { paths, is_cut })
+}
+
+/// Clears the in-process cut state without touching the system clipboard.
+#[tauri::command]
+pub fn clear_clipboard_cut_state() {
+    clipboard::clear_cut_state();
+}
+
+// --- Linux stubs ---
+
+#[cfg(not(target_os = "macos"))]
+#[tauri::command]
+pub async fn copy_files_to_clipboard(
+    _app: tauri::AppHandle,
+    _listing_id: String,
+    _selected_indices: Vec<usize>,
+    _cursor_index: usize,
+    _has_parent: bool,
+    _include_hidden: bool,
+) -> Result<usize, String> {
+    Err("Clipboard file operations are not yet supported on this platform".to_string())
+}
+
+#[cfg(not(target_os = "macos"))]
+#[tauri::command]
+pub async fn cut_files_to_clipboard(
+    _app: tauri::AppHandle,
+    _listing_id: String,
+    _selected_indices: Vec<usize>,
+    _cursor_index: usize,
+    _has_parent: bool,
+    _include_hidden: bool,
+) -> Result<usize, String> {
+    Err("Clipboard file operations are not yet supported on this platform".to_string())
+}
+
+#[cfg(not(target_os = "macos"))]
+#[tauri::command]
+pub async fn read_clipboard_files(_app: tauri::AppHandle) -> Result<ClipboardReadResult, String> {
+    Err("Clipboard file operations are not yet supported on this platform".to_string())
+}
+
+// --- Helpers ---
+
+/// When no files are selected, falls back to the cursor index (adjusting for the ".." entry).
+fn resolve_indices(selected_indices: &[usize], cursor_index: usize, has_parent: bool) -> Vec<usize> {
+    if !selected_indices.is_empty() {
+        return selected_indices.to_vec();
+    }
+
+    // Nothing selected -- use the cursor position.
+    // If the cursor is on ".." (index 0 with has_parent), skip it.
+    if has_parent && cursor_index == 0 {
+        return Vec::new();
+    }
+
+    vec![cursor_index]
+}

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

@@ -1,5 +1,6 @@
 //! Tauri commands module.
 
+pub mod clipboard;
 pub mod e2e;
 pub mod file_system;
 pub mod file_viewer;

apps/desktop/src-tauri/src/lib.rs

@@ -67,6 +67,7 @@ mod accent_color;
 mod accent_color_linux;
 mod ai;
 pub mod benchmark;
+mod clipboard;
 mod commands;
 pub mod config;
 #[cfg(target_os = "macos")]
@@ -777,6 +778,11 @@ pub fn run() {
             commands::indexing::set_indexing_enabled,
             // E2E test support
             commands::e2e::get_e2e_start_path,
+            // Clipboard file operations
+            commands::clipboard::copy_files_to_clipboard,
+            commands::clipboard::cut_files_to_clipboard,
+            commands::clipboard::read_clipboard_files,
+            commands::clipboard::clear_clipboard_cut_state,
         ])
         .on_window_event(|window, event| {
             // When the main window is closed, quit the entire app (including settings/debug/viewer windows)