Lightweight coding agent that runs in your terminal
Rust
Fix recall of command-line initial prompts in the TUI (#55372)
Joe Savona0d337e5fe788
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex 2e03905e1c..235139f802 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -963,6 +963,11 @@ async fn enqueue_primary_thread_session_replays_turns_before_initial_prompt_subm}]));+ for expected in ["follow-up after replay", "earlier prompt"] {+ app.chat_widget.handle_key_event(KeyCode::Up.into());+ assert_eq!(app.chat_widget.composer_text_with_pending(), expected);+ }+Ok(())}diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rsindex 756c2d6840..57d5b49ac0 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs@@ -5,6 +5,8 @@//! bursts, especially on Windows. Paste timing uses Tokio's clock so asynchronous flush deadlines//! and input classification share a clock, including in paused-time tests. Copy shortcuts and right//! clicks preserve selected draft text.+//! Local recall retains full draft metadata for composer submissions and accepted command-line+//! initial prompts; transcript replay seeds earlier prompts separately.//! When enabled, fullscreen right-click paste requires an editable composer without a selection,//! search, or blocking view. The app reads clipboard text asynchronously and delivers a normal//! paste only while the same thread, draft, and cursor remain eligible. Intervening input or focus@@ -1243,6 +1245,10 @@ impl ChatComposer {true}+ pub(crate) fn record_local_user_message_history(&mut self, entry: HistoryEntry) {+ self.history.record_local_submission(entry);+ }+pub(crate) fn record_replayed_user_message_history(&mut self, entry: HistoryEntry) {self.history.record_replayed_submission(entry);}diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rsindex 90ed97e811..ca77db8794 100644--- a/codex-rs/tui/src/bottom_pane/mod.rs+++ b/codex-rs/tui/src/bottom_pane/mod.rs@@ -2331,6 +2331,10 @@ impl BottomPane {}}+ pub(crate) fn record_local_user_message_history(&mut self, entry: HistoryEntry) {+ self.composer.record_local_user_message_history(entry);+ }+pub(crate) fn record_replayed_user_message_history(&mut self, entry: HistoryEntry) {self.composer.record_replayed_user_message_history(entry);}diff --git a/codex-rs/tui/src/chatwidget/input_restore.rs b/codex-rs/tui/src/chatwidget/input_restore.rsindex 1f21ca9a7a..b4114ec109 100644--- a/codex-rs/tui/src/chatwidget/input_restore.rs+++ b/codex-rs/tui/src/chatwidget/input_restore.rs@@ -2,6 +2,8 @@use std::collections::HashSet;+use codex_protocol::models::local_image_label_text;+use crate::bottom_pane::ComposerDraftSnapshot;use crate::bottom_pane::KillBufferSnapshot;@@ -177,7 +179,46 @@ impl ChatWidget {return;}if let Some(user_message) = self.initial_user_message.take() {- self.submit_user_message(user_message);+ // Command-line input bypasses the composer, which normally records local recall.+ let mut entry = HistoryEntry {+ text: user_message.text.clone(),+ text_elements: user_message.text_elements.clone(),+ local_image_paths: user_message+ .local_images+ .iter()+ .map(|image| image.path.clone())+ .collect(),+ remote_image_urls: user_message.remote_image_urls.clone(),+ mention_bindings: user_message.mention_bindings.clone(),+ pending_pastes: Vec::new(),+ };+ // CLI images have no composer elements. Give recalled attachments owned placeholders+ // so the composer retains them when the user submits the recalled prompt again.+ for index in 0..entry.local_image_paths.len() {+ let placeholder = local_image_label_text(entry.remote_image_urls.len() + index + 1);+ if entry+ .text_elements+ .iter()+ .any(|element| element.placeholder(&entry.text) == Some(placeholder.as_str()))+ {+ continue;+ }+ if !entry.text.is_empty() {+ entry.text.push(' ');+ }+ let start = entry.text.len();+ entry.text.push_str(&placeholder);+ entry.text_elements.push(TextElement::new(+ (start..entry.text.len()).into(),+ Some(placeholder),+ ));+ }+ if self.submit_user_message_with_history_record(+ user_message,+ UserMessageHistoryRecord::UserMessageText,+ ) {+ self.bottom_pane.record_local_user_message_history(entry);+ }}}diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__initial_prompt_recalled_composer.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__initial_prompt_recalled_composer.snapnew file mode 100644index 0000000000..1ce688b471--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__initial_prompt_recalled_composer.snap@@ -0,0 +1,7 @@+---+source: tui/src/chatwidget/tests/startup_submission_tests.rs+expression: "super::helpers::normalize_snapshot_paths(render_bottom_popup(&chat, 80))"+---+› CURRENT_A++ GPT-5.6-Sol default · /tmp/projectdiff --git a/codex-rs/tui/src/chatwidget/tests/startup_submission_tests.rs b/codex-rs/tui/src/chatwidget/tests/startup_submission_tests.rsindex cebcd5650c..68737acb03 100644--- a/codex-rs/tui/src/chatwidget/tests/startup_submission_tests.rs+++ b/codex-rs/tui/src/chatwidget/tests/startup_submission_tests.rs@@ -1,6 +1,237 @@use super::*;+use crate::app_event::HistoryLookupResponse;use pretty_assertions::assert_eq;+#[tokio::test]+async fn initial_prompt_recall_precedes_cross_session_history() {+ for submit_follow_up in [false, true] {+ let (mut chat, mut events, mut ops) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.bottom_pane+ .set_history_metadata(thread_id, /*log_id*/ 7, /*entry_count*/ 1);+ chat.initial_user_message =+ create_initial_user_message(Some("CURRENT_A".into()), Vec::new(), Vec::new());++ chat.submit_initial_user_message_if_pending();+ chat.submit_initial_user_message_if_pending();+ assert_matches!(next_submit_op(&mut ops), Op::UserTurn { items, .. }+ if items == vec![UserInput::Text { text: "CURRENT_A".into(), text_elements: Vec::new() }]);+ assert_no_submit_op(&mut ops);+ handle_turn_started(&mut chat, "initial");+ handle_turn_completed(&mut chat, "initial", /*duration_ms*/ None);++ let mut expected = vec!["CURRENT_A"];+ if submit_follow_up {+ chat.handle_paste("CURRENT_B".into());+ chat.handle_key_event(KeyCode::Enter.into());+ assert_matches!(next_submit_op(&mut ops), Op::UserTurn { .. });+ handle_turn_started(&mut chat, "follow-up");+ handle_turn_completed(&mut chat, "follow-up", /*duration_ms*/ None);+ expected.insert(0, "CURRENT_B");+ }+ let persisted = std::iter::from_fn(|| events.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::AppendMessageHistoryEntry {+ thread_id: owner,+ text,+ } => {+ assert_eq!(owner, thread_id);+ Some(text)+ }+ _ => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(+ persisted,+ expected.iter().rev().copied().collect::<Vec<_>>()+ );++ for text in expected {+ chat.handle_key_event(KeyCode::Up.into());+ assert_eq!(chat.bottom_pane.composer_text(), text);+ assert!(+ events.try_recv().is_err(),+ "local recall must not fetch shared history"+ );+ }+ if submit_follow_up {+ assert_chatwidget_snapshot!(+ "initial_prompt_recalled_composer",+ super::helpers::normalize_snapshot_paths(render_bottom_popup(+ &chat, /*width*/ 80+ ))+ );+ }+ chat.handle_key_event(KeyCode::Up.into());+ let AppEvent::LookupMessageHistoryEntry {+ thread_id: owner,+ log_id,+ offset,+ } = events+ .try_recv()+ .expect("shared history lookup after current prompts")+ else {+ panic!("expected shared history lookup");+ };+ assert_eq!((owner, log_id, offset), (thread_id, 7, 0));+ chat.bottom_pane+ .on_history_lookup_response(HistoryLookupResponse::Entry {+ log_id,+ offset,+ entry: Some("FOREIGN_X".into()),+ });+ assert_eq!(chat.bottom_pane.composer_text(), "FOREIGN_X");+ }+}++#[tokio::test]+async fn initial_prompt_image_preparation_preserves_recall_metadata() {+ let directory = tempfile::tempdir().unwrap();+ let path = directory.path().join("image.png");+ image::RgbImage::new(/*width*/ 1, /*height*/ 1)+ .save(&path)+ .unwrap();+ let placeholder = "[Image #1]";+ for (input, elements, recalled_text, placeholder_start) in [+ (+ "describe",+ Vec::new(),+ "describe [Image #1]",+ "describe ".len(),+ ),+ (+ "[Image #1] describe",+ vec![TextElement::new(+ (0..placeholder.len()).into(),+ Some(placeholder.into()),+ )],+ "[Image #1] describe",+ 0,+ ),+ ] {+ let (mut chat, mut events, mut ops) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.bottom_pane+ .set_history_metadata(thread_id, /*log_id*/ 7, /*entry_count*/ 1);+ chat.snapshot_local_images = true;+ let text_elements = vec![TextElement::new(+ (placeholder_start..placeholder_start + placeholder.len()).into(),+ Some(placeholder.into()),+ )];+ chat.initial_user_message =+ create_initial_user_message(Some(input.into()), vec![path.clone()], elements);++ chat.submit_initial_user_message_if_pending();+ assert!(chat.pending_image_submission.is_some());+ tokio::time::timeout(Duration::from_secs(10), async {+ loop {+ if let AppEvent::ImagesPrepared(id) = events.recv().await.unwrap() {+ chat.on_images_prepared(id);+ break;+ }+ }+ })+ .await+ .expect("initial image preparation");+ assert_matches!(next_submit_op(&mut ops), Op::UserTurn { items, .. }+ if items.iter().any(|item| matches!(item, UserInput::Text { text, .. } if text == input)));+ chat.submit_initial_user_message_if_pending();+ assert_no_submit_op(&mut ops);+ handle_turn_started(&mut chat, "initial");+ handle_turn_completed(&mut chat, "initial", /*duration_ms*/ None);+ while events.try_recv().is_ok() {}++ chat.handle_key_event(KeyCode::Up.into());+ let recalled = chat.bottom_pane.composer_draft_snapshot();+ assert_eq!(+ (+ recalled.text,+ recalled.text_elements,+ recalled.local_images,+ recalled.pending_pastes+ ),+ (+ recalled_text.into(),+ text_elements,+ vec![LocalImageAttachment {+ placeholder: placeholder.into(),+ path: path.clone()+ }],+ Vec::new()+ ),+ );+ chat.handle_key_event(KeyCode::Up.into());+ assert_matches!(+ events.try_recv(),+ Ok(AppEvent::LookupMessageHistoryEntry { offset: 0, .. })+ );++ chat.handle_key_event(KeyCode::Enter.into());+ tokio::time::timeout(Duration::from_secs(10), async {+ loop {+ if let AppEvent::ImagesPrepared(id) = events.recv().await.unwrap() {+ chat.on_images_prepared(id);+ break;+ }+ }+ })+ .await+ .expect("recalled image preparation");+ assert_matches!(next_submit_op(&mut ops), Op::UserTurn { items, .. }+ if items.iter().any(|item| matches!(item, UserInput::Image { .. })));+ }+}++#[tokio::test]+async fn initial_prompt_queued_before_session_is_recalled_once_after_dispatch() {+ let (mut chat, mut events, mut ops) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.initial_user_message = Some("CURRENT_A".into());+ chat.submit_initial_user_message_if_pending();+ assert_no_submit_op(&mut ops);+ assert_eq!(chat.queued_user_message_texts(), vec!["CURRENT_A"]);++ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.bottom_pane+ .set_history_metadata(thread_id, /*log_id*/ 7, /*entry_count*/ 1);+ assert!(chat.maybe_send_next_queued_input());+ assert_matches!(next_submit_op(&mut ops), Op::UserTurn { .. });+ handle_turn_started(&mut chat, "initial");+ handle_turn_completed(&mut chat, "initial", /*duration_ms*/ None);+ while events.try_recv().is_ok() {}++ chat.handle_key_event(KeyCode::Up.into());+ assert_eq!(chat.bottom_pane.composer_text(), "CURRENT_A");+ chat.handle_key_event(KeyCode::Up.into());+ assert_matches!(+ events.try_recv(),+ Ok(AppEvent::LookupMessageHistoryEntry { offset: 0, .. })+ );+}++#[tokio::test]+async fn rejected_initial_prompt_is_not_recorded_in_recall_history() {+ let (mut chat, mut events, mut ops) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.bottom_pane+ .set_history_metadata(thread_id, /*log_id*/ 7, /*entry_count*/ 1);+ // A disconnected submission channel rejects the initial prompt synchronously.+ ops.close();+ chat.initial_user_message = Some("CURRENT_A".into());+ chat.submit_initial_user_message_if_pending();+ assert_no_submit_op(&mut ops);+ while events.try_recv().is_ok() {}++ chat.handle_key_event(KeyCode::Up.into());+ assert_matches!(+ events.try_recv(),+ Ok(AppEvent::LookupMessageHistoryEntry { offset: 0, .. })+ );+}+#[tokio::test]async fn startup_submission_waits_for_session_and_sends_exactly_once() {let (mut source, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;