Clipboard: Fix text clipboard in all windows

- Non-main windows (viewer, settings): `send_native_clipboard_action()` sends `copy:`/`cut:`/`paste:` through the responder chain via `NSApplication.sendAction:to:from:`, replicating what `PredefinedMenuItem` does internally
- Main window text inputs: `read_clipboard_text` Rust command reads `NSPasteboard` directly, bypassing WebKit's `navigator.clipboard.readText()` permission popup
- `edit.pasteAsMove` scoped to `FileScoped` (file-only, no text equivalent)

Author: vdavid

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

@@ -7,4 +7,4 @@ 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};
+pub use pasteboard::{read_file_urls_from_clipboard, read_text_from_clipboard, write_file_urls_to_clipboard};

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

@@ -107,3 +107,13 @@ pub fn read_file_urls_from_clipboard() -> Result<Vec<PathBuf>, String> {
 
     Ok(paths)
 }
+
+/// Reads plain text from the system pasteboard.
+///
+/// Used by the frontend to paste text into input fields without triggering
+/// WebKit's clipboard permission popup (which `navigator.clipboard.readText()` causes).
+pub fn read_text_from_clipboard() -> Option<String> {
+    let pasteboard = NSPasteboard::generalPasteboard();
+    let pasteboard_type = unsafe { NSPasteboardTypeString };
+    pasteboard.stringForType(pasteboard_type).map(|s| s.to_string())
+}

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

@@ -133,6 +133,30 @@ pub async fn read_clipboard_files(app: tauri::AppHandle) -> Result<ClipboardRead
     Ok(ClipboardReadResult { paths, is_cut })
 }
 
+/// Reads plain text from the system clipboard.
+///
+/// Used by the frontend to paste text into input fields. Going through Rust bypasses
+/// WebKit's `navigator.clipboard.readText()` permission popup.
+#[cfg(target_os = "macos")]
+#[tauri::command]
+pub async fn read_clipboard_text(app: tauri::AppHandle) -> Result<Option<String>, String> {
+    let (tx, rx) = std::sync::mpsc::channel();
+    app.run_on_main_thread(move || {
+        let text = clipboard::read_text_from_clipboard();
+        let _ = tx.send(text);
+    })
+    .map_err(|e| format!("Couldn't run on main thread: {e}"))?;
+
+    rx.recv()
+        .map_err(|e| format!("Couldn't receive pasteboard result: {e}"))
+}
+
+#[cfg(not(target_os = "macos"))]
+#[tauri::command]
+pub async fn read_clipboard_text(_app: tauri::AppHandle) -> Result<Option<String>, String> {
+    Err("Clipboard operations are not yet supported on this platform".to_string())
+}
+
 /// Clears the in-process cut state without touching the system clipboard.
 #[tauri::command]
 pub fn clear_clipboard_cut_state() {

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

@@ -108,10 +108,10 @@ mod volumes_linux;
 mod stubs;
 
 use menu::{
-    CLOSE_TAB_ID, CommandScope, MenuState, SHOW_HIDDEN_FILES_ID, SORT_ASCENDING_ID, SORT_BY_CREATED_ID,
-    SORT_BY_EXTENSION_ID, SORT_BY_MODIFIED_ID, SORT_BY_NAME_ID, SORT_BY_SIZE_ID, SORT_DESCENDING_ID, TAB_CLOSE_ID,
-    TAB_CLOSE_OTHERS_ID, TAB_PIN_ID, VIEW_MODE_BRIEF_ID, VIEW_MODE_FULL_ID, VIEWER_WORD_WRAP_ID, ViewMode,
-    menu_id_to_command,
+    CLOSE_TAB_ID, CommandScope, EDIT_COPY_ID, EDIT_CUT_ID, EDIT_PASTE_ID, MenuState, SHOW_HIDDEN_FILES_ID,
+    SORT_ASCENDING_ID, SORT_BY_CREATED_ID, SORT_BY_EXTENSION_ID, SORT_BY_MODIFIED_ID, SORT_BY_NAME_ID,
+    SORT_BY_SIZE_ID, SORT_DESCENDING_ID, TAB_CLOSE_ID, TAB_CLOSE_OTHERS_ID, TAB_PIN_ID, VIEW_MODE_BRIEF_ID,
+    VIEW_MODE_FULL_ID, VIEWER_WORD_WRAP_ID, ViewMode, menu_id_to_command,
 };
 use tauri::{Emitter, Manager};
 
@@ -121,6 +121,39 @@ fn greet(name: &str) -> String {
     format!("Hello, {}! You've been greeted from Rust!", name)
 }
 
+/// Sends a native clipboard action (copy:/cut:/paste:) through the responder chain.
+///
+/// Used when a non-main window is focused: the custom Edit menu items can't use the native
+/// responder chain like PredefinedMenuItems do, so we replicate it manually via
+/// `NSApplication.sendAction:to:from:` with nil target (routes to the first responder).
+#[cfg(target_os = "macos")]
+fn send_native_clipboard_action(menu_id: &str) {
+    use objc2::sel;
+    use objc2_app_kit::NSApplication;
+
+    let selector = match menu_id {
+        EDIT_CUT_ID => sel!(cut:),
+        EDIT_COPY_ID => sel!(copy:),
+        EDIT_PASTE_ID => sel!(paste:),
+        _ => return,
+    };
+
+    // Safety: we're on the main thread (called from on_menu_event which runs on the main thread).
+    let mtm = unsafe { objc2::MainThreadMarker::new_unchecked() };
+    let ns_app = NSApplication::sharedApplication(mtm);
+
+    // sendAction:to:from: with nil `to` sends to the first responder, exactly like
+    // PredefinedMenuItems do internally. This lets WKWebView handle text clipboard natively.
+    unsafe {
+        let _: bool = objc2::msg_send![
+            &ns_app,
+            sendAction: selector,
+            to: std::ptr::null::<objc2::runtime::AnyObject>(),
+            from: std::ptr::null::<objc2::runtime::AnyObject>(),
+        ];
+    }
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     let builder = tauri::Builder::default();
@@ -452,6 +485,34 @@ pub fn run() {
                 return;
             }
 
+            // === Clipboard exception: file clipboard in main window, native text clipboard elsewhere ===
+            // Custom MenuItems for Cut/Copy/Paste route through execute-command in the main window
+            // so the frontend can decide between file and text clipboard. In non-main windows
+            // (viewer, settings), we send the native action through the responder chain so
+            // WKWebView handles text clipboard natively — just like PredefinedMenuItems would.
+            if id == EDIT_CUT_ID || id == EDIT_COPY_ID || id == EDIT_PASTE_ID {
+                let main_focused = app
+                    .get_webview_window("main")
+                    .is_some_and(|w| w.is_focused().unwrap_or(false));
+                if main_focused {
+                    let command_id = match id {
+                        EDIT_CUT_ID => "edit.cut",
+                        EDIT_COPY_ID => "edit.copy",
+                        _ => "edit.paste",
+                    };
+                    let _ = app.emit_to(
+                        "main",
+                        "execute-command",
+                        serde_json::json!({ "commandId": command_id }),
+                    );
+                } else {
+                    // Send native clipboard action to the first responder chain
+                    #[cfg(target_os = "macos")]
+                    send_native_clipboard_action(id);
+                }
+                return;
+            }
+
             // === Unified dispatch: look up command ID from the mapping ===
             if let Some((command_id, scope)) = menu_id_to_command(id) {
                 if scope == CommandScope::FileScoped {
@@ -782,6 +843,7 @@ pub fn run() {
             commands::clipboard::copy_files_to_clipboard,
             commands::clipboard::cut_files_to_clipboard,
             commands::clipboard::read_clipboard_files,
+            commands::clipboard::read_clipboard_text,
             commands::clipboard::clear_clipboard_cut_state,
         ])
         .on_window_event(|window, event| {

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

@@ -108,11 +108,14 @@ also Window and Help.
 - **Tab as accelerator**: Switch pane uses Tab, which could conflict with menu bar accessibility
   navigation. If issues arise, omit the accelerator and rely on JS dispatch.
 - **Custom MenuItems for Cut/Copy/Paste**: The Edit menu uses custom MenuItems (not
-  PredefinedMenuItems) for Cut, Copy, Paste, and Move here. This routes ⌘C/⌘V/⌘X through
-  `execute-command` dispatch so the frontend can decide between text clipboard (when an input is
-  focused) and file clipboard (when the file list has focus). Text clipboard is handled via
-  `document.execCommand` / `navigator.clipboard` API in the frontend handler. Undo and Redo remain
-  PredefinedMenuItems since they only apply to text fields.
+  PredefinedMenuItems) for Cut, Copy, Paste, and Move here. In `on_menu_event`, these are handled
+  specially: if the main window is focused, they route through `execute-command` so the frontend can
+  decide between file clipboard and text clipboard (via `document.activeElement` check). If a
+  non-main window is focused (viewer, settings), `send_native_clipboard_action()` in `lib.rs` sends
+  the native `copy:`/`cut:`/`paste:` selector through the responder chain via
+  `NSApplication.sendAction:to:from:` — replicating what PredefinedMenuItems do internally. This
+  ensures text clipboard works natively in all windows. Undo and Redo remain PredefinedMenuItems
+  since they only apply to text fields.
 - **⌘A dual routing**: "Select all" uses ⌘A as a native menu accelerator (so it's visible in the
   Edit menu). Since macOS intercepts it before the webview, the frontend's `handleCommandExecute`
   checks `document.activeElement` — if it's an input/textarea, it calls `.select()` for text

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

@@ -100,12 +100,13 @@ pub fn menu_id_to_command(menu_id: &str) -> Option<(&'static str, CommandScope)>
         PIN_TAB_MENU_ID => Some(("tab.togglePin", CommandScope::FileScoped)),
         CLOSE_OTHER_TABS_ID => Some(("tab.closeOthers", CommandScope::FileScoped)),
 
-        // Clipboard operations (App scope — text clipboard must work in all windows;
-        // the frontend's activeElement check routes between text and file clipboard)
+        // Clipboard operations — cut/copy/paste are handled specially in on_menu_event
+        // (native responder chain for non-main windows, execute-command for main window).
+        // They're still listed here for command_id_to_menu_id reverse lookups.
         EDIT_CUT_ID => Some(("edit.cut", CommandScope::App)),
         EDIT_COPY_ID => Some(("edit.copy", CommandScope::App)),
         EDIT_PASTE_ID => Some(("edit.paste", CommandScope::App)),
-        EDIT_PASTE_MOVE_ID => Some(("edit.pasteAsMove", CommandScope::App)),
+        EDIT_PASTE_MOVE_ID => Some(("edit.pasteAsMove", CommandScope::FileScoped)),
 
         // File operations (file-scoped)
         OPEN_ID => Some(("nav.open", CommandScope::FileScoped)),

apps/desktop/src/lib/tauri-commands/clipboard-files.ts

@@ -41,6 +41,10 @@ export async function readClipboardFiles(): Promise<ClipboardReadResult> {
     return invoke<ClipboardReadResult>('read_clipboard_files')
 }
 
+export async function readClipboardText(): Promise<string | null> {
+    return invoke<string | null>('read_clipboard_text')
+}
+
 export async function clearClipboardCutState(): Promise<void> {
     await invoke('clear_clipboard_cut_state')
 }

apps/desktop/src/lib/tauri-commands/index.ts

@@ -277,6 +277,7 @@ export {
     copyFilesToClipboard,
     cutFilesToClipboard,
     readClipboardFiles,
+    readClipboardText,
     clearClipboardCutState,
 } from './clipboard-files'
 export type { ClipboardReadResult } from './clipboard-files'

apps/desktop/src/routes/(main)/+page.svelte

@@ -29,6 +29,7 @@
         setMenuContext,
         getWindowTitle,
         registerKnownDialogs,
+        readClipboardText,
     } from '$lib/tauri-commands'
     import { SOFT_DIALOG_REGISTRY } from '$lib/ui/dialog-registry'
     import { addToast } from '$lib/ui/toast'
@@ -991,17 +992,12 @@
                     active instanceof HTMLTextAreaElement ||
                     active?.closest('[contenteditable]')
                 ) {
-                    // execCommand('paste') is the native paste that works without WebKit's
-                    // clipboard permission popup. Falls back to navigator.clipboard API.
-                    // eslint-disable-next-line @typescript-eslint/no-deprecated -- No modern alternative for triggering native paste in text inputs
-                    if (!document.execCommand('paste')) {
-                        try {
-                            const text = await navigator.clipboard.readText()
-                            // eslint-disable-next-line @typescript-eslint/no-deprecated -- insertText is the only way to insert at cursor position in inputs
-                            document.execCommand('insertText', false, text)
-                        } catch {
-                            // Both methods failed — clipboard may be empty or inaccessible
-                        }
+                    // Read clipboard text via Rust (bypasses WebKit's navigator.clipboard
+                    // permission popup that shows a "Paste" button the user must click).
+                    const text = await readClipboardText()
+                    if (text) {
+                        // eslint-disable-next-line @typescript-eslint/no-deprecated -- insertText is the only way to insert at cursor position in inputs
+                        document.execCommand('insertText', false, text)
                     }
                     return
                 }