feat: handle bracketed paste and batch-insert pasted text (input + script editor)

Author: swananan

ghostscope-ui/src/components/app.rs

@@ -5,7 +5,9 @@ use crate::model::ui_state::LayoutMode;
 use crate::model::AppState;
 use anyhow::Result;
 use crossterm::{
-    event::{Event, EventStream, KeyCode, KeyEventKind},
+    event::{
+        DisableBracketedPaste, EnableBracketedPaste, Event, EventStream, KeyCode, KeyEventKind,
+    },
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
@@ -33,6 +35,8 @@ impl App {
         enable_raw_mode()?;
         let mut stdout = io::stdout();
         execute!(stdout, EnterAlternateScreen)?;
+        // Enable bracketed paste to detect paste events (does not affect mouse selection copy)
+        execute!(stdout, EnableBracketedPaste)?;
         // Mouse capture disabled to allow standard copy/paste functionality
         let backend = CrosstermBackend::new(stdout);
         let terminal = Terminal::new(backend)?;
@@ -67,6 +71,8 @@ impl App {
         enable_raw_mode()?;
         let mut stdout = io::stdout();
         execute!(stdout, EnterAlternateScreen)?;
+        // Enable bracketed paste to detect paste events (does not affect mouse selection copy)
+        execute!(stdout, EnableBracketedPaste)?;
         // Mouse capture disabled to allow standard copy/paste functionality
         let backend = CrosstermBackend::new(stdout);
         let terminal = Terminal::new(backend)?;
@@ -204,10 +210,6 @@ impl App {
 
     /// Handle terminal events and convert to actions
     async fn handle_event(&mut self, event: Event) -> Result<bool> {
-        // Only log non-mouse events to reduce noise
-        if !matches!(event, Event::Mouse(_)) {
-            tracing::debug!("handle_event called with: {:?}", event);
-        }
         let mut actions_to_process = Vec::new();
 
         match event {
@@ -395,6 +397,39 @@ impl App {
             Event::Resize(width, height) => {
                 actions_to_process.push(Action::Resize(width, height));
             }
+            Event::Paste(pasted) => {
+                tracing::debug!("Event received: paste_len={}", pasted.len());
+                // Batch insert pasted text depending on focused panel and mode
+                match self.state.ui.focus.current_panel {
+                    PanelType::InteractiveCommand => {
+                        match self.state.command_panel.mode {
+                            crate::model::panel_state::InteractionMode::Input => {
+                                let actions = self
+                                    .state
+                                    .command_input_handler
+                                    .insert_str(&mut self.state.command_panel, &pasted);
+                                actions_to_process.extend(actions);
+                                self.state.command_renderer.mark_pending_updates();
+                            }
+                            crate::model::panel_state::InteractionMode::ScriptEditor => {
+                                let actions =
+                                    crate::components::command_panel::ScriptEditor::insert_text(
+                                        &mut self.state.command_panel,
+                                        &pasted,
+                                    );
+                                actions_to_process.extend(actions);
+                                self.state.command_renderer.mark_pending_updates();
+                            }
+                            crate::model::panel_state::InteractionMode::Command => {
+                                // Ignore paste in command mode
+                            }
+                        }
+                    }
+                    _ => {
+                        // Ignore paste in other panels
+                    }
+                }
+            }
             _ => {}
         }
 
@@ -3357,6 +3392,8 @@ impl App {
     /// Cleanup terminal
     async fn cleanup(&mut self) -> Result<()> {
         disable_raw_mode()?;
+        // Disable bracketed paste before leaving alternate screen
+        execute!(self.terminal.backend_mut(), DisableBracketedPaste)?;
         execute!(self.terminal.backend_mut(), LeaveAlternateScreen)?;
         // Mouse capture was not enabled, so no need to disable it
         self.terminal.show_cursor()?;

ghostscope-ui/src/components/command_panel/optimized_input.rs

@@ -57,6 +57,43 @@ impl OptimizedInputHandler {
         result
     }
 
+    /// Insert a full string at the current cursor position efficiently (batch paste)
+    /// - In Input mode: inserts as single line (newlines converted to spaces), updates suggestion once
+    /// - In ScriptEditor: delegates to ScriptEditor for multi-line aware insertion
+    pub fn insert_str(&mut self, state: &mut CommandPanelState, text: &str) -> Vec<Action> {
+        self.last_input_time = Instant::now();
+
+        match state.mode {
+            InteractionMode::Input => {
+                // Cancel any pending jk escape
+                state.jk_escape_state = JkEscapeState::None;
+                state.jk_timer = None;
+
+                // Normalize pasted text to a single line for command input
+                // Convert CRLF/CR to LF, then LF to space
+                let normalized = text.replace("\r\n", "\n").replace('\r', "\n");
+                let sanitized = normalized.replace('\n', " ");
+                if sanitized.is_empty() {
+                    return Vec::new();
+                }
+
+                let byte_pos = self.char_pos_to_byte_pos(&state.input_text, state.cursor_position);
+                state.input_text.insert_str(byte_pos, &sanitized);
+                state.cursor_position += sanitized.chars().count();
+
+                // Update auto suggestion once after batch insert
+                state.update_auto_suggestion();
+                Vec::new()
+            }
+            InteractionMode::ScriptEditor => {
+                // Delegate to script editor for multi-line aware insertion
+                use crate::components::command_panel::ScriptEditor;
+                ScriptEditor::insert_text(state, text)
+            }
+            InteractionMode::Command => Vec::new(),
+        }
+    }
+
     /// Handle character input in Input mode (normal typing)
     fn handle_input_mode_char(&mut self, state: &mut CommandPanelState, ch: char) -> Vec<Action> {
         // Handle jk escape sequence first

ghostscope-ui/src/components/command_panel/script_editor.rs

@@ -195,6 +195,52 @@ impl ScriptEditor {
         Vec::new()
     }
 
+    /// Insert a string at the cursor position (supports newlines)
+    pub fn insert_text(state: &mut CommandPanelState, text: &str) -> Vec<Action> {
+        if let Some(ref mut cache) = state.script_cache {
+            // Normalize line endings to LF
+            let normalized = text.replace("\r\n", "\n").replace('\r', "\n");
+            let mut iter = normalized.split('\n');
+
+            if cache.cursor_line >= cache.lines.len() {
+                cache.lines.push(String::new());
+                cache.cursor_line = cache.lines.len() - 1;
+                cache.cursor_col = 0;
+            }
+
+            // Insert first segment into current line
+            if let Some(first) = iter.next() {
+                let line = &mut cache.lines[cache.cursor_line];
+                let byte_pos = Self::char_pos_to_byte_pos(line, cache.cursor_col);
+                line.insert_str(byte_pos, first);
+                cache.cursor_col += first.chars().count();
+            }
+
+            // Remaining segments: create new lines
+            let mut is_first_newline = true;
+            for seg in iter {
+                // Split current line at cursor once to move the right part down
+                if is_first_newline {
+                    let byte_pos = Self::char_pos_to_byte_pos(
+                        &cache.lines[cache.cursor_line],
+                        cache.cursor_col,
+                    );
+                    let right = cache.lines[cache.cursor_line].split_off(byte_pos);
+                    let new_line = format!("{seg}{right}");
+                    cache.cursor_line += 1;
+                    cache.lines.insert(cache.cursor_line, new_line);
+                    cache.cursor_col = seg.chars().count();
+                    is_first_newline = false;
+                } else {
+                    cache.cursor_line += 1;
+                    cache.lines.insert(cache.cursor_line, seg.to_string());
+                    cache.cursor_col = seg.chars().count();
+                }
+            }
+        }
+        Vec::new()
+    }
+
     /// Insert a newline at the cursor position
     pub fn insert_newline(state: &mut CommandPanelState) -> Vec<Action> {
         if let Some(ref mut cache) = state.script_cache {