fix(tui): improve clipboard handling for Linux and Windows (#493)

This fixes clipboard issues in the login screen where:
- On Linux: clipboard content was dropped when the Clipboard object went
  out of scope before the clipboard manager received the data
- On Windows: clipboard content could be released too quickly

Changes:
1. login_screen.rs: Use the existing safe_clipboard_copy() function instead
   of directly using arboard::Clipboard. This centralizes clipboard logic.

2. terminal.rs: Improve safe_clipboard_copy() with platform-specific handling:
   - Linux: Already uses SetExtLinux::wait() to ensure clipboard manager
     receives data before the Clipboard object is dropped
   - Windows: Added a small delay (10ms) after set_text() to ensure the
     clipboard operation completes before the object is dropped
   - Other platforms: Standard behavior

The safe_clipboard_copy function now properly handles clipboard operations
across all major platforms.

Co-authored-by: Droid Agent <droid@factory.ai>

Author: echobt

cortex-tui/src/runner/login_screen.rs

@@ -502,10 +502,10 @@ impl LoginScreen {
                 self.async_rx = None;
             }
             KeyCode::Char('c') | KeyCode::Char('C') => {
-                // Copy URL to clipboard
+                // Copy URL to clipboard using the safe clipboard function
+                // This properly handles Linux (with wait()) and Windows clipboard behavior
                 let url = self.get_direct_url();
-                if let Ok(mut clipboard) = arboard::Clipboard::new() {
-                    let _ = clipboard.set_text(&url);
+                if super::terminal::safe_clipboard_copy(&url) {
                     self.copied_notification = Some(Instant::now());
                 }
             }

cortex-tui/src/runner/terminal.rs

@@ -863,6 +863,8 @@ pub fn safe_clipboard_copy(text: &str) -> bool {
             {
                 use arboard::SetExtLinux;
                 // On Linux, use wait() to ensure the clipboard manager receives the data
+                // before the Clipboard object is dropped. This is critical because X11/Wayland
+                // clipboards require the source application to remain available.
                 match clipboard.set().wait().text(text) {
                     Ok(_) => true,
                     Err(e) => {
@@ -871,7 +873,24 @@ pub fn safe_clipboard_copy(text: &str) -> bool {
                     }
                 }
             }
-            #[cfg(not(target_os = "linux"))]
+            #[cfg(target_os = "windows")]
+            {
+                // On Windows, clipboard content persists after the Clipboard object is dropped,
+                // but we need to ensure the set operation completes successfully.
+                // Small delay helps ensure clipboard is fully populated before returning.
+                match clipboard.set_text(text) {
+                    Ok(_) => {
+                        // Give Windows a moment to finalize the clipboard operation
+                        std::thread::sleep(std::time::Duration::from_millis(10));
+                        true
+                    }
+                    Err(e) => {
+                        tracing::warn!("Clipboard copy failed: {}", e);
+                        false
+                    }
+                }
+            }
+            #[cfg(not(any(target_os = "linux", target_os = "windows")))]
             {
                 match clipboard.set_text(text) {
                     Ok(_) => true,