Add mouse text selection and right-click paste support

Since EnableMouseCapture prevents native terminal text selection, this adds
buffer-based selection (left-click drag with visual highlight, auto-copy to
system clipboard on release) and right-click paste into any active text input.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: trepidity

Cargo.lock

@@ -57,6 +57,9 @@ clap = { version = "4", features = ["derive"] }
 # Credentials
 keyring = "3"
 
+# Clipboard
+arboard = "3"
+
 # Utilities
 base64 = "0.22"
 chrono = { version = "0.4", features = ["serde"] }

Cargo.toml

@@ -24,3 +24,4 @@ strum = { workspace = true }
 anyhow = { workspace = true }
 tracing = { workspace = true }
 chrono = { workspace = true }
+arboard = { workspace = true }

crates/loom-tui/Cargo.toml

@@ -150,6 +150,9 @@ pub enum Action {
     ConnMgrDelete(usize),                       // delete saved profile by index
     ConnMgrConnect(usize),                      // connect from connections manager
 
+    // Paste
+    PasteText(String),
+
     // No-op
     None,
 }

crates/loom-tui/src/action.rs

@@ -2,7 +2,9 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use crossterm::event::MouseEventKind;
+use ratatui::buffer::Buffer;
 use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::style::Style;
 use tokio::sync::Mutex;
 use tracing::{debug, error};
 
@@ -52,6 +54,14 @@ enum DragTarget {
     Detail,
 }
 
+/// Mouse text selection state.
+#[derive(Debug, Clone)]
+struct TextSelection {
+    anchor: (u16, u16),
+    end: (u16, u16),
+    text: Option<String>,
+}
+
 /// Backend for a connection tab — either live LDAP or offline/example.
 enum TabBackend {
     Live(Arc<Mutex<LdapConnection>>),
@@ -133,6 +143,10 @@ pub struct App {
     detail_split_pct: u16, // top panels height as % of content area
     drag_target: Option<DragTarget>,
 
+    // Mouse text selection & clipboard
+    text_selection: Option<TextSelection>,
+    clipboard: Option<arboard::Clipboard>,
+
     // Async communication
     action_tx: tokio::sync::mpsc::UnboundedSender<Action>,
     action_rx: tokio::sync::mpsc::UnboundedReceiver<Action>,
@@ -187,6 +201,8 @@ impl App {
             tree_split_pct: 25,
             detail_split_pct: 75,
             drag_target: None,
+            text_selection: None,
+            clipboard: arboard::Clipboard::new().ok(),
             action_tx,
             action_rx,
         }
@@ -1012,20 +1028,31 @@ impl App {
     }
 
     fn handle_mouse(&mut self, mouse: crossterm::event::MouseEvent) -> Action {
-        // Popups block mouse events; also clear any drag
+        // Popups block mouse events; also clear any drag/selection
         if self.popup_active() {
             self.drag_target = None;
+            self.text_selection = None;
             return Action::None;
         }
 
         match mouse.kind {
             MouseEventKind::Down(crossterm::event::MouseButton::Left) => {
+                // Clear any previous selection
+                self.text_selection = None;
+
                 // Check if click is on a panel divider (start drag)
                 if let Some(target) = self.divider_hit(mouse.column, mouse.row) {
                     self.drag_target = Some(target);
                     return Action::None;
                 }
 
+                // Start a text selection
+                self.text_selection = Some(TextSelection {
+                    anchor: (mouse.column, mouse.row),
+                    end: (mouse.column, mouse.row),
+                    text: None,
+                });
+
                 let pos = Rect::new(mouse.column, mouse.row, 1, 1);
 
                 // Check layout bar clicks
@@ -1076,13 +1103,40 @@ impl App {
             MouseEventKind::Drag(crossterm::event::MouseButton::Left) => {
                 if let Some(target) = self.drag_target {
                     self.apply_drag(target, mouse.column, mouse.row);
+                } else if let Some(ref mut sel) = self.text_selection {
+                    sel.end = (mouse.column, mouse.row);
+                }
+                Action::None
+            }
+            MouseEventKind::Up(crossterm::event::MouseButton::Left) => {
+                self.drag_target = None;
+                // Copy selected text to clipboard on mouse-up
+                if let Some(ref sel) = self.text_selection {
+                    if let Some(ref text) = sel.text {
+                        if !text.is_empty() {
+                            if let Some(ref mut cb) = self.clipboard {
+                                let _ = cb.set_text(text.clone());
+                            }
+                        }
+                    }
                 }
                 Action::None
             }
             MouseEventKind::Up(_) => {
                 self.drag_target = None;
                 Action::None
             }
+            MouseEventKind::Down(crossterm::event::MouseButton::Right) => {
+                // Right-click paste
+                if let Some(ref mut cb) = self.clipboard {
+                    if let Ok(text) = cb.get_text() {
+                        if !text.is_empty() {
+                            return Action::PasteText(text);
+                        }
+                    }
+                }
+                Action::None
+            }
             _ => Action::None,
         }
     }
@@ -1786,6 +1840,10 @@ impl App {
                 }
             }
 
+            Action::PasteText(text) => {
+                self.paste_into_active_input(&text);
+            }
+
             Action::Tick => {
                 // Dispatch tick to attribute editor for debounced DN search
                 if self.attribute_editor.visible {
@@ -2008,9 +2066,107 @@ impl App {
         if self.log_panel.visible {
             self.log_panel.render(frame, full);
         }
+
+        // Draw text selection overlay (after all widgets/popups)
+        if let Some(ref sel) = self.text_selection {
+            if sel.anchor != sel.end {
+                let style = self.theme.selection_highlight;
+                extract_and_highlight_selection(
+                    frame.buffer_mut(),
+                    &mut self.text_selection,
+                    style,
+                );
+            }
+        }
+    }
+
+    fn paste_into_active_input(&mut self, text: &str) {
+        if self.attribute_editor.visible {
+            self.attribute_editor.paste_text(text);
+        } else if self.attribute_picker.visible {
+            self.attribute_picker.paste_text(text);
+        } else if self.new_connection_dialog.visible {
+            self.new_connection_dialog.paste_text(text);
+        } else if self.credential_prompt.visible {
+            self.credential_prompt.paste_text(text);
+        } else if self.search_dialog.visible {
+            // search_dialog has no text input
+        } else if self.export_dialog.visible {
+            self.export_dialog.paste_text(text);
+        } else if self.bulk_update_dialog.visible {
+            self.bulk_update_dialog.paste_text(text);
+        } else if self.create_entry_dialog.visible {
+            self.create_entry_dialog.paste_text(text);
+        } else if self.schema_viewer.visible {
+            self.schema_viewer.paste_text(text);
+        } else if self.command_panel.input_active
+            && self.active_layout == ActiveLayout::Browser
+        {
+            self.command_panel.paste_text(text);
+        } else if self.connection_form.is_editing()
+            && self.active_layout == ActiveLayout::Profiles
+        {
+            self.connection_form.paste_text(text);
+        }
     }
 }
 
+fn extract_and_highlight_selection(
+    buf: &mut Buffer,
+    sel: &mut Option<TextSelection>,
+    style: Style,
+) {
+    let selection = match sel.as_mut() {
+        Some(s) => s,
+        None => return,
+    };
+
+    let (ax, ay) = selection.anchor;
+    let (ex, ey) = selection.end;
+
+    // Normalize so start is top-left
+    let (start_row, start_col, end_row, end_col) = if (ay, ax) <= (ey, ex) {
+        (ay, ax, ey, ex)
+    } else {
+        (ey, ex, ay, ax)
+    };
+
+    let buf_area = buf.area;
+    let mut lines: Vec<String> = Vec::new();
+
+    for row in start_row..=end_row {
+        if row < buf_area.y || row >= buf_area.y + buf_area.height {
+            continue;
+        }
+        let col_start = if row == start_row { start_col } else { buf_area.x };
+        let col_end = if row == end_row {
+            end_col
+        } else {
+            buf_area.x + buf_area.width - 1
+        };
+
+        let mut line = String::new();
+        for col in col_start..=col_end {
+            if col < buf_area.x || col >= buf_area.x + buf_area.width {
+                continue;
+            }
+            let cell = &buf[(col, row)];
+            let sym = cell.symbol();
+            // Skip empty symbols (wide-char continuations)
+            if !sym.is_empty() && sym != "\0" {
+                line.push_str(sym);
+            }
+            // Apply highlight style
+            buf[(col, row)].set_style(style);
+        }
+        // Trim trailing whitespace from each line
+        let trimmed = line.trim_end().to_string();
+        lines.push(trimmed);
+    }
+
+    selection.text = Some(lines.join("\n"));
+}
+
 /// Resolve password from the connection profile's credential method.
 /// Returns empty string for Prompt method when LOOM_PASSWORD is not set,
 /// which signals the caller to show an interactive credential prompt.

crates/loom-tui/src/app.rs

@@ -144,6 +144,17 @@ impl AttributeEditor {
         }
     }
 
+    pub fn paste_text(&mut self, text: &str) {
+        if self.focus == EditorFocus::Input {
+            let filtered: String = text.chars().filter(|c| !c.is_control()).collect();
+            self.input_buffer.insert_str(self.cursor_pos, &filtered);
+            self.cursor_pos += filtered.len();
+            if self.is_dn_search {
+                self.search_dirty = true;
+            }
+        }
+    }
+
     pub fn hide(&mut self) {
         self.visible = false;
         self.op = None;

crates/loom-tui/src/components/attribute_editor.rs

@@ -48,6 +48,13 @@ impl AttributePicker {
     }
 
     /// Open the picker with the given DN and candidate attributes.
+    pub fn paste_text(&mut self, text: &str) {
+        let filtered: String = text.chars().filter(|c| !c.is_control()).collect();
+        self.input.insert_str(self.cursor, &filtered);
+        self.cursor += filtered.len();
+        self.refilter();
+    }
+
     pub fn show(&mut self, dn: String, candidates: Vec<(String, String)>) {
         self.dn = dn;
         self.input.clear();

crates/loom-tui/src/components/attribute_picker.rs

@@ -68,6 +68,11 @@ impl BulkUpdateDialog {
         }
     }
 
+    pub fn paste_text(&mut self, text: &str) {
+        let filtered: String = text.chars().filter(|c| !c.is_control()).collect();
+        self.active_buffer_mut().push_str(&filtered);
+    }
+
     pub fn show(&mut self) {
         self.filter.clear();
         self.attribute.clear();

crates/loom-tui/src/components/bulk_update_dialog.rs

@@ -24,6 +24,13 @@ pub struct StatusMessage {
 }
 
 impl CommandPanel {
+    pub fn paste_text(&mut self, text: &str) {
+        if self.input_active {
+            let filtered: String = text.chars().filter(|c| !c.is_control()).collect();
+            self.input_buffer.push_str(&filtered);
+        }
+    }
+
     pub fn new(theme: Theme) -> Self {
         Self {
             messages: Vec::new(),

crates/loom-tui/src/components/command_panel.rs

@@ -253,6 +253,24 @@ impl ConnectionForm {
         }
     }
 
+    pub fn paste_text(&mut self, text: &str) {
+        if !self.is_editing() {
+            return;
+        }
+        let filtered: String = text.chars().filter(|c| !c.is_control()).collect();
+        if matches!(
+            self.active_field,
+            Field::Port | Field::PageSize | Field::Timeout
+        ) {
+            let digits: String = filtered.chars().filter(|c| c.is_ascii_digit()).collect();
+            if let Some(buf) = self.active_buffer_mut() {
+                buf.push_str(&digits);
+            }
+        } else if let Some(buf) = self.active_buffer_mut() {
+            buf.push_str(&filtered);
+        }
+    }
+
     fn active_buffer_mut(&mut self) -> Option<&mut String> {
         match self.active_field {
             Field::Name => Some(&mut self.name),