tui: try text clipboard before image paste on paste shortcut

Author: dolzhenko.e4

codex-rs/tui/src/chatwidget.rs

@@ -52,6 +52,9 @@ use crate::bottom_pane::StatusLinePreviewData;
 use crate::bottom_pane::StatusLineSetupView;
 use crate::bottom_pane::TerminalTitleItem;
 use crate::bottom_pane::TerminalTitleSetupView;
+use crate::clipboard_shortcut::ShortcutPasteAction;
+use crate::clipboard_shortcut::ShortcutPasteRequest;
+use crate::clipboard_shortcut::resolve_shortcut_paste;
 use crate::mention_codec::LinkedMention;
 use crate::mention_codec::encode_history_mentions;
 use crate::model_catalog::ModelCatalog;
@@ -316,7 +319,6 @@ use crate::bottom_pane::SelectionItem;
 use crate::bottom_pane::SelectionViewParams;
 use crate::bottom_pane::custom_prompt_view::CustomPromptView;
 use crate::bottom_pane::popup_consts::standard_popup_hint_line;
-use crate::clipboard_paste::paste_image_to_temp_png;
 use crate::clipboard_text;
 use crate::collaboration_modes;
 use crate::diff_render::display_path_for;
@@ -955,6 +957,8 @@ pub(crate) struct ChatWidget {
     realtime_conversation: RealtimeConversationUiState,
     last_rendered_user_message_event: Option<RenderedUserMessageEvent>,
     last_non_retry_error: Option<(String, String)>,
+    #[cfg(test)]
+    shortcut_paste_handler: Option<fn(ShortcutPasteRequest) -> ShortcutPasteAction>,
 }
 
 /// Cached nickname and role for a collab agent thread, used to attach human-readable labels to
@@ -4716,6 +4720,8 @@ impl ChatWidget {
             realtime_conversation: RealtimeConversationUiState::default(),
             last_rendered_user_message_event: None,
             last_non_retry_error: None,
+            #[cfg(test)]
+            shortcut_paste_handler: None,
         };
 
         widget
@@ -4778,33 +4784,6 @@ impl ChatWidget {
                 self.quit_shortcut_expires_at = None;
                 self.quit_shortcut_key = None;
             }
-            KeyEvent {
-                code: KeyCode::Char(c),
-                modifiers,
-                kind: KeyEventKind::Press,
-                ..
-            } if modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT)
-                && c.eq_ignore_ascii_case(&'v') =>
-            {
-                match paste_image_to_temp_png() {
-                    Ok((path, info)) => {
-                        tracing::debug!(
-                            "pasted image size={}x{} format={}",
-                            info.width,
-                            info.height,
-                            info.encoded_format.label()
-                        );
-                        self.attach_image(path);
-                    }
-                    Err(err) => {
-                        tracing::warn!("failed to paste image: {err}");
-                        self.add_to_history(history_cell::new_error_event(format!(
-                            "Failed to paste image: {err}",
-                        )));
-                    }
-                }
-                return;
-            }
             other if other.kind == KeyEventKind::Press => {
                 self.bottom_pane.clear_quit_shortcut_hint();
                 self.quit_shortcut_expires_at = None;
@@ -4813,6 +4792,10 @@ impl ChatWidget {
             _ => {}
         }
 
+        if self.handle_shortcut_paste_key(key_event) {
+            return;
+        }
+
         if key_event.kind == KeyEventKind::Press
             && self.queued_message_edit_binding.is_press(key_event)
             && self.has_queued_follow_up_messages()
@@ -4926,6 +4909,63 @@ impl ChatWidget {
         }
     }
 
+    fn handle_shortcut_paste_key(&mut self, key_event: KeyEvent) -> bool {
+        let request = match key_event {
+            KeyEvent {
+                code: KeyCode::Char(c),
+                modifiers,
+                kind: KeyEventKind::Press,
+                ..
+            } if modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT)
+                && c.eq_ignore_ascii_case(&'v') =>
+            {
+                Some(if modifiers == KeyModifiers::ALT {
+                    ShortcutPasteRequest::AltV
+                } else {
+                    ShortcutPasteRequest::CtrlV
+                })
+            }
+            _ => None,
+        };
+
+        let Some(request) = request else {
+            return false;
+        };
+
+        let action = {
+            #[cfg(test)]
+            if let Some(handler) = self.shortcut_paste_handler {
+                handler(request)
+            } else {
+                resolve_shortcut_paste(request)
+            }
+
+            #[cfg(not(test))]
+            {
+                resolve_shortcut_paste(request)
+            }
+        };
+
+        match action {
+            ShortcutPasteAction::Text(text) => self.handle_paste(text),
+            ShortcutPasteAction::Image { path, info } => {
+                tracing::debug!(
+                    "pasted image size={}x{} format={}",
+                    info.width,
+                    info.height,
+                    info.encoded_format.label()
+                );
+                self.attach_image(path);
+            }
+            ShortcutPasteAction::Error(message) => {
+                warn!("{message}");
+                self.add_to_history(history_cell::new_error_event(message));
+            }
+        }
+
+        true
+    }
+
     /// Attach a local image to the composer when the active model supports image inputs.
     ///
     /// When the model does not advertise image support, we keep the draft unchanged and surface a
@@ -10337,6 +10377,14 @@ impl ChatWidget {
         self.bottom_pane.is_task_running()
     }
 
+    #[cfg(test)]
+    pub(crate) fn set_shortcut_paste_handler_for_test(
+        &mut self,
+        handler: fn(ShortcutPasteRequest) -> ShortcutPasteAction,
+    ) {
+        self.shortcut_paste_handler = Some(handler);
+    }
+
     pub(crate) fn submit_user_message_with_mode(
         &mut self,
         text: String,

codex-rs/tui/src/chatwidget/tests/composer_submission.rs

@@ -1,6 +1,86 @@
 use super::*;
 use pretty_assertions::assert_eq;
 
+fn shortcut_paste_text(
+    _request: crate::clipboard_shortcut::ShortcutPasteRequest,
+) -> crate::clipboard_shortcut::ShortcutPasteAction {
+    crate::clipboard_shortcut::ShortcutPasteAction::Text("hello from clipboard".to_string())
+}
+
+fn shortcut_paste_image(
+    _request: crate::clipboard_shortcut::ShortcutPasteRequest,
+) -> crate::clipboard_shortcut::ShortcutPasteAction {
+    crate::clipboard_shortcut::ShortcutPasteAction::Image {
+        path: PathBuf::from("/tmp/from-shortcut.png"),
+        info: crate::clipboard_paste::PastedImageInfo {
+            width: 120,
+            height: 80,
+            encoded_format: crate::clipboard_paste::EncodedImageFormat::Png,
+        },
+    }
+}
+
+fn shortcut_paste_error(
+    _request: crate::clipboard_shortcut::ShortcutPasteRequest,
+) -> crate::clipboard_shortcut::ShortcutPasteAction {
+    crate::clipboard_shortcut::ShortcutPasteAction::Error(
+        "Failed to paste clipboard contents: no text or image available on the clipboard."
+            .to_string(),
+    )
+}
+
+#[tokio::test]
+async fn ctrl_v_pastes_text_into_the_composer() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+    chat.set_shortcut_paste_handler_for_test(shortcut_paste_text);
+
+    chat.handle_key_event(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::CONTROL));
+
+    assert_eq!(chat.bottom_pane.composer_text(), "hello from clipboard");
+    assert!(drain_insert_history(&mut rx).is_empty());
+}
+
+#[tokio::test]
+async fn ctrl_v_can_attach_an_image_when_the_shortcut_policy_falls_back_to_image() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+    chat.set_shortcut_paste_handler_for_test(shortcut_paste_image);
+
+    chat.handle_key_event(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::CONTROL));
+
+    assert_eq!(
+        chat.bottom_pane.composer_local_image_paths(),
+        vec![PathBuf::from("/tmp/from-shortcut.png")]
+    );
+    assert_eq!(chat.bottom_pane.composer_text(), "[Image #1]");
+    assert!(drain_insert_history(&mut rx).is_empty());
+}
+
+#[tokio::test]
+async fn alt_v_uses_the_same_shortcut_paste_resolution_path() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+    chat.set_shortcut_paste_handler_for_test(shortcut_paste_text);
+
+    chat.handle_key_event(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::ALT));
+
+    assert_eq!(chat.bottom_pane.composer_text(), "hello from clipboard");
+    assert!(drain_insert_history(&mut rx).is_empty());
+}
+
+#[tokio::test]
+async fn ctrl_v_reports_a_user_visible_error_when_clipboard_paste_fails() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+    chat.set_shortcut_paste_handler_for_test(shortcut_paste_error);
+
+    chat.handle_key_event(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::CONTROL));
+
+    let rendered = drain_insert_history(&mut rx)
+        .into_iter()
+        .map(|lines| lines_to_single_string(&lines))
+        .collect::<Vec<_>>()
+        .join("\n");
+    assert!(rendered.contains("Failed to paste clipboard contents"));
+}
+
 #[tokio::test]
 async fn submission_preserves_text_elements_and_local_images() {
     let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;

codex-rs/tui/src/chatwidget/tests/helpers.rs

@@ -287,6 +287,7 @@ pub(super) async fn make_chatwidget_manual(
         realtime_conversation: RealtimeConversationUiState::default(),
         last_rendered_user_message_event: None,
         last_non_retry_error: None,
+        shortcut_paste_handler: None,
     };
     widget.set_model(&resolved_model);
     (widget, rx, op_rx)

codex-rs/tui/src/clipboard_shortcut.rs

@@ -0,0 +1,52 @@
+use std::path::PathBuf;
+
+use crate::clipboard_paste::PasteImageError;
+use crate::clipboard_paste::PastedImageInfo;
+use crate::clipboard_paste::paste_image_to_temp_png;
+use crate::clipboard_text::ReadClipboardTextError;
+use crate::clipboard_text::read_text_from_clipboard;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ShortcutPasteRequest {
+    CtrlV,
+    AltV,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum ShortcutPasteAction {
+    Text(String),
+    Image {
+        path: PathBuf,
+        info: PastedImageInfo,
+    },
+    Error(String),
+}
+
+pub(crate) fn resolve_shortcut_paste(request: ShortcutPasteRequest) -> ShortcutPasteAction {
+    let _ = request;
+
+    match read_text_from_clipboard() {
+        Ok(Some(text)) => ShortcutPasteAction::Text(text),
+        Ok(None) => match paste_image_to_temp_png() {
+            Ok((path, info)) => ShortcutPasteAction::Image { path, info },
+            Err(PasteImageError::NoImage(_)) => ShortcutPasteAction::Error(
+                "Failed to paste clipboard contents: no text or image available on the clipboard."
+                    .to_string(),
+            ),
+            Err(err) => {
+                ShortcutPasteAction::Error(format!("Failed to paste clipboard image: {err}"))
+            }
+        },
+        Err(ReadClipboardTextError::ClipboardUnavailable(text_err)) => {
+            match paste_image_to_temp_png() {
+                Ok((path, info)) => ShortcutPasteAction::Image { path, info },
+                Err(PasteImageError::NoImage(_)) => ShortcutPasteAction::Error(format!(
+                    "Failed to paste clipboard text or image: clipboard text unavailable: {text_err}; no image on clipboard."
+                )),
+                Err(err) => ShortcutPasteAction::Error(format!(
+                    "Failed to paste clipboard text or image: clipboard text unavailable: {text_err}; image paste failed: {err}"
+                )),
+            }
+        }
+    }
+}