Merge PR #280

factorydroid · factorydroid · commit 694bfb77a181 · 2026-01-27T20:00:53.000Z
diff --git a/cortex-engine/src/file_utils.rs b/cortex-engine/src/file_utils.rs
@@ -141,8 +141,20 @@ pub fn format_bytes(bytes: u64) -> String {
     }
 }
 
-/// Read a file to string.
+/// Read a file to string with normalized line endings.
+///
+/// This function reads the file content and normalizes Windows CRLF line
+/// endings to Unix LF, ensuring consistent handling across platforms.
 pub async fn read_string(path: impl AsRef<Path>) -> Result<String> {
+    let content = fs::read_to_string(path.as_ref()).await?;
+    // Normalize CRLF to LF for consistent cross-platform handling
+    Ok(content.replace("\r\n", "\n").replace('\r', "\n"))
+}
+
+/// Read a file to string without line ending normalization.
+///
+/// Use this when you need to preserve the original line endings.
+pub async fn read_string_raw(path: impl AsRef<Path>) -> Result<String> {
     fs::read_to_string(path.as_ref()).await.map_err(Into::into)
 }
 
diff --git a/cortex-tui/src/runner/terminal.rs b/cortex-tui/src/runner/terminal.rs
@@ -30,6 +30,7 @@
 
 use std::io::{self, IsTerminal, Stdout, stdout};
 use std::panic;
+use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use anyhow::Result;
@@ -45,6 +46,9 @@ use crossterm::{
 use ratatui::Terminal;
 use ratatui::backend::CrosstermBackend;
 
+/// Global storage for the original terminal title to restore on exit.
+static ORIGINAL_TITLE: Mutex<Option<String>> = Mutex::new(None);
+
 /// Track whether the panic hook has been installed to avoid installing it multiple times.
 static PANIC_HOOK_INSTALLED: AtomicBool = AtomicBool::new(false);
 
@@ -59,7 +63,7 @@ static PANIC_HOOK_INSTALLED: AtomicBool = AtomicBool::new(false);
 ///
 /// ```rust,ignore
 /// // Guard is typically created internally by CortexTerminal
-/// let guard = TerminalGuard::new(true, true, true);
+/// let guard = TerminalGuard::new(true, true, true, true);
 /// // ... terminal operations ...
 /// // Terminal is restored when guard is dropped
 /// ```
@@ -70,6 +74,8 @@ pub struct TerminalGuard {
     mouse_capture: bool,
     /// Whether bracketed paste is enabled
     bracketed_paste: bool,
+    /// Whether to restore the original title
+    restore_title: bool,
 }
 
 impl TerminalGuard {
@@ -80,11 +86,18 @@ impl TerminalGuard {
     /// * `alternate_screen` - Whether alternate screen mode is enabled
     /// * `mouse_capture` - Whether mouse capture is enabled
     /// * `bracketed_paste` - Whether bracketed paste mode is enabled
-    fn new(alternate_screen: bool, mouse_capture: bool, bracketed_paste: bool) -> Self {
+    /// * `restore_title` - Whether to restore the original title on cleanup
+    fn new(
+        alternate_screen: bool,
+        mouse_capture: bool,
+        bracketed_paste: bool,
+        restore_title: bool,
+    ) -> Self {
         Self {
             alternate_screen,
             mouse_capture,
             bracketed_paste,
+            restore_title,
         }
     }
 }
@@ -95,6 +108,7 @@ impl Drop for TerminalGuard {
             self.alternate_screen,
             self.mouse_capture,
             self.bracketed_paste,
+            self.restore_title,
         );
     }
 }
@@ -281,10 +295,12 @@ impl CortexTerminal {
         let backend = CrosstermBackend::new(stdout());
         let terminal = Terminal::new(backend)?;
 
+        let restore_title = options.title.is_some();
         let guard = TerminalGuard::new(
             options.alternate_screen,
             options.mouse_capture,
             options.bracketed_paste,
+            restore_title,
         );
 
         Ok(Self {
@@ -453,6 +469,24 @@ fn init_terminal(options: &TerminalOptions) -> Result<()> {
     // Install panic hook to restore terminal on panic
     install_panic_hook();
 
+    // Save the original terminal title before we change it
+    // We use the current working directory as a fallback since most terminals
+    // set the title to something like "user@host: /path" which we can approximate
+    if options.title.is_some() {
+        if let Ok(mut guard) = ORIGINAL_TITLE.lock() {
+            if guard.is_none() {
+                // Try to get a reasonable default title to restore
+                // Most terminals show something like the current directory or shell
+                let fallback_title = std::env::current_dir()
+                    .map(|p| p.display().to_string())
+                    .unwrap_or_else(|_| String::new());
+                if !fallback_title.is_empty() {
+                    *guard = Some(fallback_title);
+                }
+            }
+        }
+    }
+
     // Enable raw mode
     enable_raw_mode()?;
 
@@ -500,6 +534,7 @@ fn init_terminal(options: &TerminalOptions) -> Result<()> {
 /// * `alternate_screen` - Whether alternate screen was enabled
 /// * `mouse_capture` - Whether mouse capture was enabled
 /// * `bracketed_paste` - Whether bracketed paste was enabled
+/// * `restore_title` - Whether to restore the original window title
 ///
 /// # Errors
 ///
@@ -510,6 +545,7 @@ fn restore_terminal_impl(
     alternate_screen: bool,
     mouse_capture: bool,
     bracketed_paste: bool,
+    restore_title: bool,
 ) -> Result<()> {
     let mut stdout = stdout();
 
@@ -531,6 +567,15 @@ fn restore_terminal_impl(
         execute!(stdout, LeaveAlternateScreen)?;
     }
 
+    // Restore original terminal title if we saved one
+    if restore_title {
+        if let Ok(guard) = ORIGINAL_TITLE.lock() {
+            if let Some(ref title) = *guard {
+                let _ = execute!(stdout, SetTitle(title));
+            }
+        }
+    }
+
     // Disable raw mode
     disable_raw_mode()?;
 
@@ -546,7 +591,7 @@ fn restore_terminal_impl(
 ///
 /// Returns an error if any terminal operation fails.
 pub fn restore_terminal() -> Result<()> {
-    restore_terminal_impl(true, true, true)
+    restore_terminal_impl(true, true, true, true)
 }
 
 /// Install a panic hook that restores the terminal.
@@ -688,6 +733,82 @@ pub fn supports_true_color() -> bool {
         .unwrap_or(false)
 }
 
+/// Check if clipboard is available.
+///
+/// This checks if the system clipboard can be accessed without relying on
+/// terminal escape sequences (OSC 52), which may leak as raw text in
+/// unsupported terminals like older PuTTY over SSH.
+///
+/// Returns `true` if a native clipboard is available (X11, Wayland, macOS, Windows).
+/// Returns `false` if we're likely in an SSH session without forwarding or
+/// in a terminal that doesn't have clipboard access.
+///
+/// Note: We never use OSC 52 escape sequences to avoid leaking raw escape
+/// sequences as visible text when the terminal doesn't support them.
+pub fn is_clipboard_available() -> bool {
+    // arboard will fail if no clipboard is available
+    // This is a quick check - actual clipboard operations may still fail
+    arboard::Clipboard::new().is_ok()
+}
+
+/// Safely copy text to clipboard without OSC 52 escape sequences.
+///
+/// This function uses native clipboard APIs (X11/Wayland on Linux, native on macOS/Windows)
+/// and never writes OSC 52 escape sequences that could leak as raw text in unsupported terminals.
+///
+/// # Arguments
+///
+/// * `text` - The text to copy to the clipboard
+///
+/// # Returns
+///
+/// Returns `true` if the text was successfully copied, `false` otherwise.
+/// Failures are logged as warnings but don't cause errors.
+pub fn safe_clipboard_copy(text: &str) -> bool {
+    match arboard::Clipboard::new() {
+        Ok(mut clipboard) => {
+            #[cfg(target_os = "linux")]
+            {
+                use arboard::SetExtLinux;
+                // On Linux, use wait() to ensure the clipboard manager receives the data
+                match clipboard.set().wait().text(text) {
+                    Ok(_) => true,
+                    Err(e) => {
+                        tracing::warn!("Clipboard copy failed: {}", e);
+                        false
+                    }
+                }
+            }
+            #[cfg(not(target_os = "linux"))]
+            {
+                match clipboard.set_text(text) {
+                    Ok(_) => true,
+                    Err(e) => {
+                        tracing::warn!("Clipboard copy failed: {}", e);
+                        false
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            tracing::debug!("Clipboard unavailable: {}", e);
+            false
+        }
+    }
+}
+
+/// Safely read text from clipboard.
+///
+/// # Returns
+///
+/// Returns the clipboard text content if available, None otherwise.
+pub fn safe_clipboard_paste() -> Option<String> {
+    match arboard::Clipboard::new() {
+        Ok(mut clipboard) => clipboard.get_text().ok(),
+        Err(_) => None,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -730,10 +851,11 @@ mod tests {
 
     #[test]
     fn test_terminal_guard_creation() {
-        let guard = TerminalGuard::new(true, true, true);
+        let guard = TerminalGuard::new(true, true, true, true);
         assert!(guard.alternate_screen);
         assert!(guard.mouse_capture);
         assert!(guard.bracketed_paste);
+        assert!(guard.restore_title);
     }
 
     // Note: Tests that actually create terminals are difficult to run
diff --git a/cortex-tui/src/ui/consts.rs b/cortex-tui/src/ui/consts.rs
@@ -72,9 +72,57 @@ pub const SPINNER_INTERVAL_MS: u64 = 80;
 /// Tool execution spinner frames (half-circles for smooth rotation)
 pub const TOOL_SPINNER_FRAMES: &[char] = &['◐', '◑', '◒', '◓'];
 
-/// Cursor blink interval in milliseconds.
+/// Default cursor blink interval in milliseconds.
 pub const CURSOR_BLINK_INTERVAL_MS: u64 = 500;
 
+/// Gets the cursor blink interval respecting system accessibility settings.
+///
+/// On Linux/GNOME, attempts to read the `cursor-blink-time` setting.
+/// On macOS, checks accessibility preferences.
+/// Falls back to the default interval if the system setting cannot be read.
+///
+/// Returns 0 if cursor blinking should be disabled.
+pub fn get_system_cursor_blink_interval() -> u64 {
+    // Check CORTEX_CURSOR_BLINK environment variable for user override
+    if let Ok(val) = std::env::var("CORTEX_CURSOR_BLINK") {
+        if val == "0" || val.to_lowercase() == "false" {
+            return 0; // Disable blinking
+        }
+        if let Ok(ms) = val.parse::<u64>() {
+            return ms;
+        }
+    }
+
+    // Try to detect system settings
+    #[cfg(target_os = "linux")]
+    {
+        // Try GNOME settings via gsettings output parsing
+        // cursor-blink-time is in milliseconds, cursor-blink is bool
+        if let Ok(output) = std::process::Command::new("gsettings")
+            .args(["get", "org.gnome.desktop.interface", "cursor-blink"])
+            .output()
+        {
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            if stdout.trim() == "false" {
+                return 0; // Blinking disabled
+            }
+        }
+
+        if let Ok(output) = std::process::Command::new("gsettings")
+            .args(["get", "org.gnome.desktop.interface", "cursor-blink-time"])
+            .output()
+        {
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            if let Ok(ms) = stdout.trim().parse::<u64>() {
+                return ms;
+            }
+        }
+    }
+
+    // Default interval
+    CURSOR_BLINK_INTERVAL_MS
+}
+
 /// Shimmer animation period in seconds.
 pub const SHIMMER_PERIOD_SECS: f32 = 2.0;
 
diff --git a/cortex-tui/src/widgets/command_palette.rs b/cortex-tui/src/widgets/command_palette.rs
@@ -296,29 +296,44 @@ impl CommandPaletteState {
         self.cursor_pos = self.query.len();
     }
 
-    /// Moves selection up.
+    /// Moves selection up with wrap-around.
     pub fn select_prev(&mut self) {
         let total = self.total_display_count();
-        if total > 0 && self.selected_index > 0 {
+        if total == 0 {
+            return;
+        }
+        if self.selected_index > 0 {
             self.selected_index -= 1;
-
             // Adjust scroll if needed
             if self.selected_index < self.scroll_offset {
                 self.scroll_offset = self.selected_index;
             }
+        } else {
+            // Wrap to last item
+            self.selected_index = total - 1;
+            // Scroll to show last items
+            if total > self.visible_count {
+                self.scroll_offset = total - self.visible_count;
+            }
         }
     }
 
-    /// Moves selection down.
+    /// Moves selection down with wrap-around.
     pub fn select_next(&mut self) {
         let total = self.total_display_count();
-        if total > 0 && self.selected_index < total.saturating_sub(1) {
+        if total == 0 {
+            return;
+        }
+        if self.selected_index < total.saturating_sub(1) {
             self.selected_index += 1;
-
             // Adjust scroll if needed
             if self.selected_index >= self.scroll_offset + self.visible_count {
                 self.scroll_offset = self.selected_index.saturating_sub(self.visible_count - 1);
             }
+        } else {
+            // Wrap to first item
+            self.selected_index = 0;
+            self.scroll_offset = 0;
         }
     }
 
diff --git a/cortex-tui/src/widgets/help_browser.rs b/cortex-tui/src/widgets/help_browser.rs
diff --git a/cortex-tui/src/widgets/model_picker.rs b/cortex-tui/src/widgets/model_picker.rs
