fix(windows): clipboard paste — probe first, real backoff, in-band fallback

The Windows clipboard open is system-global exclusive and WebView2's
process snapshots it around the paste event; clipboard-win's built-in
retries are Sleep(0) scheduler yields that burn out inside that window,
and the failure was swallowed into an empty list after the frontend had
already preventDefault'ed — a completely silent dead paste.

- Read probes CF_HDROP without opening the clipboard (text and image
  pastes no longer touch the contended open at all), retries the open
  with a real 10ms backoff, and surfaces the final failure instead of
  faking an empty file list.
- Write replaces the yield-spin with the same backoff.
- The paste handler captures the first file item of ANY kind (not just
  images) synchronously — when the native path read fails, the file's
  in-band bytes and real filename still open the preview.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: JSKitty

src-tauri/src/commands/clipboard.rs

@@ -73,10 +73,30 @@ fn read_clipboard_files_impl() -> Result<Vec<String>, String> {
 
 #[cfg(target_os = "windows")]
 fn read_clipboard_files_impl() -> Result<Vec<String>, String> {
-    // CF_HDROP → Vec<String> of paths. Absent format (text/image/empty clipboard)
-    // or a transient open failure both yield an empty list so paste falls back,
-    // mirroring the other platforms (a missing file list is not an error here).
-    Ok(clipboard_win::get_clipboard(clipboard_win::formats::FileList).unwrap_or_default())
+    // Probe CF_HDROP WITHOUT opening the clipboard (IsClipboardFormatAvailable):
+    // this runs on every paste, and a text/image clipboard must not contend for
+    // the open at all. Absent format = no file paste, not an error.
+    if !clipboard_win::is_format_avail(clipboard_win::formats::CF_HDROP) {
+        return Ok(Vec::new());
+    }
+    // The open races the WebView2 PROCESS, which snapshots the clipboard around
+    // the paste event — and clipboard-win's built-in retries are Sleep(0)
+    // scheduler yields that burn out inside that window. Retry with a real
+    // backoff, and surface the final failure instead of swallowing it into an
+    // empty list: the frontend catches and falls back to the in-band file blob.
+    let mut last_err = String::new();
+    for attempt in 0..20u32 {
+        match clipboard_win::get_clipboard::<Vec<String>, _>(clipboard_win::formats::FileList) {
+            Ok(paths) => return Ok(paths),
+            Err(e) => {
+                last_err = e.to_string();
+                if attempt < 19 {
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+            }
+        }
+    }
+    Err(format!("clipboard file read failed: {last_err}"))
 }
 
 #[cfg(target_os = "linux")]
@@ -165,7 +185,21 @@ fn write_clipboard_files_impl(paths: Vec<String>) -> Result<(), String> {
     // `set_clipboard` helper can't reach it — call the trait method on a slice
     // under our own clipboard guard instead.
     use clipboard_win::{formats::FileList, Clipboard, Setter};
-    let _clip = Clipboard::new_attempts(10).map_err(|e| format!("Failed to open clipboard: {}", e))?;
+    // new_attempts retries are Sleep(0) yields — worthless against another
+    // process holding the clipboard (WebView2, clipboard-history tools). Real
+    // backoff: ~200ms worst case before giving up.
+    let mut clip = None;
+    for attempt in 0..20u32 {
+        match Clipboard::new_attempts(0) {
+            Ok(c) => {
+                clip = Some(c);
+                break;
+            }
+            Err(e) if attempt == 19 => return Err(format!("Failed to open clipboard: {}", e)),
+            Err(_) => std::thread::sleep(std::time::Duration::from_millis(10)),
+        }
+    }
+    let _clip = clip;
     FileList
         .write_clipboard(&paths[..])
         .map_err(|e| format!("Clipboard write failed: {}", e))

src/main.js

@@ -11888,12 +11888,16 @@ window.addEventListener("DOMContentLoaded", async () => {
     document.onpaste = async (evt) => {
         if (strOpenChat) {
             const dt = evt.clipboardData;
-            // clipboardData is only valid during synchronous dispatch — capture the
-            // image item + its blob NOW, since the await below would invalidate it.
+            // clipboardData is only valid during synchronous dispatch — capture any
+            // file item + its blob NOW, since the await below would invalidate it.
+            // ANY file kind, not just images: when the native path read fails (a
+            // clipboard held by another process, a manager that dropped CF_HDROP),
+            // the in-band blob is the universal fallback and carries a real name.
             const arrItems = Array.from(dt?.items || []);
-            const imageItem = arrItems.find(item => item.type.startsWith('image/'));
-            const imageBlob = imageItem ? imageItem.getAsFile() : null;
-            const imageType = imageItem ? imageItem.type : '';
+            const fileItem = arrItems.find(item => item.kind === 'file')
+                || arrItems.find(item => item.type.startsWith('image/'));
+            const fileBlob = fileItem ? fileItem.getAsFile() : null;
+            const fileMime = fileItem ? fileItem.type : '';
 
             // A file copy (Finder/Explorer) also carries a text representation of the
             // path, so the default paste inserts the filename into the input. We must
@@ -11903,7 +11907,7 @@ window.addEventListener("DOMContentLoaded", async () => {
             const hasFile = (dt?.files && dt.files.length > 0)
                 || arrItems.some(it => it.kind === 'file')
                 || dtTypes.includes('Files');
-            if (hasFile || imageBlob) evt.preventDefault();
+            if (hasFile || fileBlob) evt.preventDefault();
 
             // Snapshot the composer so we can scrub any filename text that still
             // slipped in (e.g. a folder copy whose sync signal we couldn't read).
@@ -11939,33 +11943,40 @@ window.addEventListener("DOMContentLoaded", async () => {
                 console.warn('[paste] native file read failed, falling back to image bytes:', e);
             }
 
-            // Fall back to raw image bytes (screenshot data with no file reference).
-            if (imageBlob) {
+            // Fall back to the in-band blob: screenshot bytes, or a copied file
+            // whose native path read failed (its content still rides the event).
+            if (fileBlob) {
                 restoreInput();
 
                 // Read the blob as bytes
-                const arrayBuffer = await imageBlob.arrayBuffer();
+                const arrayBuffer = await fileBlob.arrayBuffer();
                 const bytes = new Uint8Array(arrayBuffer);
 
-                // Determine file extension from MIME type
-                const mimeType = imageType;
+                // Prefer the blob's real filename; synthesize one from the MIME
+                // type only for anonymous data (screenshots).
                 let ext = 'png'; // Default
-                if (mimeType.includes('jpeg') || mimeType.includes('jpg')) {
+                if (fileMime.includes('jpeg') || fileMime.includes('jpg')) {
                     ext = 'jpg';
-                } else if (mimeType.includes('gif')) {
+                } else if (fileMime.includes('gif')) {
                     ext = 'gif';
-                } else if (mimeType.includes('webp')) {
+                } else if (fileMime.includes('webp')) {
                     ext = 'webp';
-                } else if (mimeType.includes('png')) {
+                } else if (fileMime.includes('png')) {
                     ext = 'png';
-                } else if (mimeType.includes('tiff')) {
+                } else if (fileMime.includes('tiff')) {
                     ext = 'tiff';
-                } else if (mimeType.includes('bmp')) {
+                } else if (fileMime.includes('bmp')) {
                     ext = 'bmp';
+                } else if (!fileMime.startsWith('image/')) {
+                    ext = 'bin';
+                }
+                let fileName = `pasted_image.${ext}`;
+                if (fileBlob.name && fileBlob.name.includes('.')) {
+                    fileName = fileBlob.name;
+                    ext = fileBlob.name.split('.').pop().toLowerCase();
+                } else if (fileBlob.name) {
+                    fileName = fileBlob.name;
                 }
-
-                // Generate a filename
-                const fileName = `pasted_image.${ext}`;
 
                 // Get reply reference before opening preview
                 const strReplyRef = strCurrentReplyReference;