mirror of
https://github.com/openai/codex.git
synced 2026-04-24 22:54:54 +00:00
b6dc1be5dd
Add explicit prefix-approval decision and wire it through execpolicy/UI snapshots update doc mutating in memory policy instead of reloading using RW locks clippy refactor: adding allow_prefix into ApprovedAllowPrefix fmt do not send allow_prefix if execpolicy is disabled moving args around cleanup exec_policy getters undo diff fixing rw lock bug causing tui to hang updating phrasing integration test . fix compile fix flaky test fix compile error running test with single thread fixup allow_prefix_if_applicable fix formatting fix approvals test only cloning when needed docs add docstring fix rebase bug fixing rebase issues Revert "fixing rebase issues" This reverts commit 79ce7e1f2fc0378c2c0b362408e2e544566540fd. fix rebase errors
798 lines
27 KiB
Rust
798 lines
27 KiB
Rust
//! Bottom pane: shows the ChatComposer or a BottomPaneView, if one is active.
|
|
use std::path::PathBuf;
|
|
|
|
use crate::app_event_sender::AppEventSender;
|
|
use crate::bottom_pane::queued_user_messages::QueuedUserMessages;
|
|
use crate::render::renderable::FlexRenderable;
|
|
use crate::render::renderable::Renderable;
|
|
use crate::render::renderable::RenderableItem;
|
|
use crate::tui::FrameRequester;
|
|
use bottom_pane_view::BottomPaneView;
|
|
use codex_file_search::FileMatch;
|
|
use crossterm::event::KeyCode;
|
|
use crossterm::event::KeyEvent;
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
use std::time::Duration;
|
|
|
|
mod approval_overlay;
|
|
pub(crate) use approval_overlay::ApprovalOverlay;
|
|
pub(crate) use approval_overlay::ApprovalRequest;
|
|
mod bottom_pane_view;
|
|
mod chat_composer;
|
|
mod chat_composer_history;
|
|
mod command_popup;
|
|
pub mod custom_prompt_view;
|
|
mod file_search_popup;
|
|
mod footer;
|
|
mod list_selection_view;
|
|
mod prompt_args;
|
|
pub(crate) use list_selection_view::SelectionViewParams;
|
|
mod feedback_view;
|
|
pub(crate) use feedback_view::feedback_selection_params;
|
|
pub(crate) use feedback_view::feedback_upload_consent_params;
|
|
mod paste_burst;
|
|
pub mod popup_consts;
|
|
mod queued_user_messages;
|
|
mod scroll_state;
|
|
mod selection_popup_common;
|
|
mod textarea;
|
|
pub(crate) use feedback_view::FeedbackNoteView;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub(crate) enum CancellationEvent {
|
|
Handled,
|
|
NotHandled,
|
|
}
|
|
|
|
pub(crate) use chat_composer::ChatComposer;
|
|
pub(crate) use chat_composer::InputResult;
|
|
use codex_protocol::custom_prompts::CustomPrompt;
|
|
|
|
use crate::status_indicator_widget::StatusIndicatorWidget;
|
|
pub(crate) use list_selection_view::SelectionAction;
|
|
pub(crate) use list_selection_view::SelectionItem;
|
|
|
|
/// Pane displayed in the lower half of the chat UI.
|
|
pub(crate) struct BottomPane {
|
|
/// Composer is retained even when a BottomPaneView is displayed so the
|
|
/// input state is retained when the view is closed.
|
|
composer: ChatComposer,
|
|
|
|
/// Stack of views displayed instead of the composer (e.g. popups/modals).
|
|
view_stack: Vec<Box<dyn BottomPaneView>>,
|
|
|
|
app_event_tx: AppEventSender,
|
|
frame_requester: FrameRequester,
|
|
|
|
has_input_focus: bool,
|
|
is_task_running: bool,
|
|
ctrl_c_quit_hint: bool,
|
|
esc_backtrack_hint: bool,
|
|
animations_enabled: bool,
|
|
|
|
/// Inline status indicator shown above the composer while a task is running.
|
|
status: Option<StatusIndicatorWidget>,
|
|
/// Queued user messages to show above the composer while a turn is running.
|
|
queued_user_messages: QueuedUserMessages,
|
|
context_window_percent: Option<i64>,
|
|
context_window_used_tokens: Option<i64>,
|
|
}
|
|
|
|
pub(crate) struct BottomPaneParams {
|
|
pub(crate) app_event_tx: AppEventSender,
|
|
pub(crate) frame_requester: FrameRequester,
|
|
pub(crate) has_input_focus: bool,
|
|
pub(crate) enhanced_keys_supported: bool,
|
|
pub(crate) placeholder_text: String,
|
|
pub(crate) disable_paste_burst: bool,
|
|
pub(crate) animations_enabled: bool,
|
|
}
|
|
|
|
impl BottomPane {
|
|
pub fn new(params: BottomPaneParams) -> Self {
|
|
let BottomPaneParams {
|
|
app_event_tx,
|
|
frame_requester,
|
|
has_input_focus,
|
|
enhanced_keys_supported,
|
|
placeholder_text,
|
|
disable_paste_burst,
|
|
animations_enabled,
|
|
} = params;
|
|
Self {
|
|
composer: ChatComposer::new(
|
|
has_input_focus,
|
|
app_event_tx.clone(),
|
|
enhanced_keys_supported,
|
|
placeholder_text,
|
|
disable_paste_burst,
|
|
),
|
|
view_stack: Vec::new(),
|
|
app_event_tx,
|
|
frame_requester,
|
|
has_input_focus,
|
|
is_task_running: false,
|
|
ctrl_c_quit_hint: false,
|
|
status: None,
|
|
queued_user_messages: QueuedUserMessages::new(),
|
|
esc_backtrack_hint: false,
|
|
animations_enabled,
|
|
context_window_percent: None,
|
|
context_window_used_tokens: None,
|
|
}
|
|
}
|
|
|
|
pub fn status_widget(&self) -> Option<&StatusIndicatorWidget> {
|
|
self.status.as_ref()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn context_window_percent(&self) -> Option<i64> {
|
|
self.context_window_percent
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn context_window_used_tokens(&self) -> Option<i64> {
|
|
self.context_window_used_tokens
|
|
}
|
|
|
|
fn active_view(&self) -> Option<&dyn BottomPaneView> {
|
|
self.view_stack.last().map(std::convert::AsRef::as_ref)
|
|
}
|
|
|
|
fn push_view(&mut self, view: Box<dyn BottomPaneView>) {
|
|
self.view_stack.push(view);
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Forward a key event to the active view or the composer.
|
|
pub fn handle_key_event(&mut self, key_event: KeyEvent) -> InputResult {
|
|
// If a modal/view is active, handle it here; otherwise forward to composer.
|
|
if let Some(view) = self.view_stack.last_mut() {
|
|
if key_event.code == KeyCode::Esc
|
|
&& matches!(view.on_ctrl_c(), CancellationEvent::Handled)
|
|
&& view.is_complete()
|
|
{
|
|
self.view_stack.pop();
|
|
self.on_active_view_complete();
|
|
} else {
|
|
view.handle_key_event(key_event);
|
|
if view.is_complete() {
|
|
self.view_stack.clear();
|
|
self.on_active_view_complete();
|
|
}
|
|
}
|
|
self.request_redraw();
|
|
InputResult::None
|
|
} else {
|
|
// If a task is running and a status line is visible, allow Esc to
|
|
// send an interrupt even while the composer has focus.
|
|
if matches!(key_event.code, crossterm::event::KeyCode::Esc)
|
|
&& self.is_task_running
|
|
&& let Some(status) = &self.status
|
|
{
|
|
// Send Op::Interrupt
|
|
status.interrupt();
|
|
self.request_redraw();
|
|
return InputResult::None;
|
|
}
|
|
let (input_result, needs_redraw) = self.composer.handle_key_event(key_event);
|
|
if needs_redraw {
|
|
self.request_redraw();
|
|
}
|
|
if self.composer.is_in_paste_burst() {
|
|
self.request_redraw_in(ChatComposer::recommended_paste_flush_delay());
|
|
}
|
|
input_result
|
|
}
|
|
}
|
|
|
|
/// Handle Ctrl-C in the bottom pane. If a modal view is active it gets a
|
|
/// chance to consume the event (e.g. to dismiss itself).
|
|
pub(crate) fn on_ctrl_c(&mut self) -> CancellationEvent {
|
|
if let Some(view) = self.view_stack.last_mut() {
|
|
let event = view.on_ctrl_c();
|
|
if matches!(event, CancellationEvent::Handled) {
|
|
if view.is_complete() {
|
|
self.view_stack.pop();
|
|
self.on_active_view_complete();
|
|
}
|
|
self.show_ctrl_c_quit_hint();
|
|
}
|
|
event
|
|
} else if self.composer_is_empty() {
|
|
CancellationEvent::NotHandled
|
|
} else {
|
|
self.view_stack.pop();
|
|
self.clear_composer_for_ctrl_c();
|
|
self.show_ctrl_c_quit_hint();
|
|
CancellationEvent::Handled
|
|
}
|
|
}
|
|
|
|
pub fn handle_paste(&mut self, pasted: String) {
|
|
if let Some(view) = self.view_stack.last_mut() {
|
|
let needs_redraw = view.handle_paste(pasted);
|
|
if view.is_complete() {
|
|
self.on_active_view_complete();
|
|
}
|
|
if needs_redraw {
|
|
self.request_redraw();
|
|
}
|
|
} else {
|
|
let needs_redraw = self.composer.handle_paste(pasted);
|
|
if needs_redraw {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn insert_str(&mut self, text: &str) {
|
|
self.composer.insert_str(text);
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Replace the composer text with `text`.
|
|
pub(crate) fn set_composer_text(&mut self, text: String) {
|
|
self.composer.set_text_content(text);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn clear_composer_for_ctrl_c(&mut self) {
|
|
self.composer.clear_for_ctrl_c();
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Get the current composer text (for tests and programmatic checks).
|
|
pub(crate) fn composer_text(&self) -> String {
|
|
self.composer.current_text()
|
|
}
|
|
|
|
/// Update the animated header shown to the left of the brackets in the
|
|
/// status indicator (defaults to "Working"). No-ops if the status
|
|
/// indicator is not active.
|
|
pub(crate) fn update_status_header(&mut self, header: String) {
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.update_header(header);
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn show_ctrl_c_quit_hint(&mut self) {
|
|
self.ctrl_c_quit_hint = true;
|
|
self.composer
|
|
.set_ctrl_c_quit_hint(true, self.has_input_focus);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn clear_ctrl_c_quit_hint(&mut self) {
|
|
if self.ctrl_c_quit_hint {
|
|
self.ctrl_c_quit_hint = false;
|
|
self.composer
|
|
.set_ctrl_c_quit_hint(false, self.has_input_focus);
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn ctrl_c_quit_hint_visible(&self) -> bool {
|
|
self.ctrl_c_quit_hint
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn status_indicator_visible(&self) -> bool {
|
|
self.status.is_some()
|
|
}
|
|
|
|
pub(crate) fn show_esc_backtrack_hint(&mut self) {
|
|
self.esc_backtrack_hint = true;
|
|
self.composer.set_esc_backtrack_hint(true);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn clear_esc_backtrack_hint(&mut self) {
|
|
if self.esc_backtrack_hint {
|
|
self.esc_backtrack_hint = false;
|
|
self.composer.set_esc_backtrack_hint(false);
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
// esc_backtrack_hint_visible removed; hints are controlled internally.
|
|
|
|
pub fn set_task_running(&mut self, running: bool) {
|
|
let was_running = self.is_task_running;
|
|
self.is_task_running = running;
|
|
self.composer.set_task_running(running);
|
|
|
|
if running {
|
|
if !was_running {
|
|
if self.status.is_none() {
|
|
self.status = Some(StatusIndicatorWidget::new(
|
|
self.app_event_tx.clone(),
|
|
self.frame_requester.clone(),
|
|
self.animations_enabled,
|
|
));
|
|
}
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.set_interrupt_hint_visible(true);
|
|
}
|
|
self.request_redraw();
|
|
}
|
|
} else {
|
|
// Hide the status indicator when a task completes, but keep other modal views.
|
|
self.hide_status_indicator();
|
|
}
|
|
}
|
|
|
|
/// Hide the status indicator while leaving task-running state untouched.
|
|
pub(crate) fn hide_status_indicator(&mut self) {
|
|
if self.status.take().is_some() {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn ensure_status_indicator(&mut self) {
|
|
if self.status.is_none() {
|
|
self.status = Some(StatusIndicatorWidget::new(
|
|
self.app_event_tx.clone(),
|
|
self.frame_requester.clone(),
|
|
self.animations_enabled,
|
|
));
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_interrupt_hint_visible(&mut self, visible: bool) {
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.set_interrupt_hint_visible(visible);
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_context_window(&mut self, percent: Option<i64>, used_tokens: Option<i64>) {
|
|
if self.context_window_percent == percent && self.context_window_used_tokens == used_tokens
|
|
{
|
|
return;
|
|
}
|
|
|
|
self.context_window_percent = percent;
|
|
self.context_window_used_tokens = used_tokens;
|
|
self.composer
|
|
.set_context_window(percent, self.context_window_used_tokens);
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Show a generic list selection view with the provided items.
|
|
pub(crate) fn show_selection_view(&mut self, params: list_selection_view::SelectionViewParams) {
|
|
let view = list_selection_view::ListSelectionView::new(params, self.app_event_tx.clone());
|
|
self.push_view(Box::new(view));
|
|
}
|
|
|
|
/// Update the queued messages preview shown above the composer.
|
|
pub(crate) fn set_queued_user_messages(&mut self, queued: Vec<String>) {
|
|
self.queued_user_messages.messages = queued;
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Update custom prompts available for the slash popup.
|
|
pub(crate) fn set_custom_prompts(&mut self, prompts: Vec<CustomPrompt>) {
|
|
self.composer.set_custom_prompts(prompts);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn composer_is_empty(&self) -> bool {
|
|
self.composer.is_empty()
|
|
}
|
|
|
|
pub(crate) fn is_task_running(&self) -> bool {
|
|
self.is_task_running
|
|
}
|
|
|
|
/// Return true when the pane is in the regular composer state without any
|
|
/// overlays or popups and not running a task. This is the safe context to
|
|
/// use Esc-Esc for backtracking from the main view.
|
|
pub(crate) fn is_normal_backtrack_mode(&self) -> bool {
|
|
!self.is_task_running && self.view_stack.is_empty() && !self.composer.popup_active()
|
|
}
|
|
|
|
pub(crate) fn show_view(&mut self, view: Box<dyn BottomPaneView>) {
|
|
self.push_view(view);
|
|
}
|
|
|
|
/// Called when the agent requests user approval.
|
|
pub fn push_approval_request(&mut self, request: ApprovalRequest) {
|
|
let request = if let Some(view) = self.view_stack.last_mut() {
|
|
match view.try_consume_approval_request(request) {
|
|
Some(request) => request,
|
|
None => {
|
|
self.request_redraw();
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
request
|
|
};
|
|
|
|
// Otherwise create a new approval modal overlay.
|
|
let modal = ApprovalOverlay::new(request, self.app_event_tx.clone());
|
|
self.pause_status_timer_for_modal();
|
|
self.push_view(Box::new(modal));
|
|
}
|
|
|
|
fn on_active_view_complete(&mut self) {
|
|
self.resume_status_timer_after_modal();
|
|
}
|
|
|
|
fn pause_status_timer_for_modal(&mut self) {
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.pause_timer();
|
|
}
|
|
}
|
|
|
|
fn resume_status_timer_after_modal(&mut self) {
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.resume_timer();
|
|
}
|
|
}
|
|
|
|
/// Height (terminal rows) required by the current bottom pane.
|
|
pub(crate) fn request_redraw(&self) {
|
|
self.frame_requester.schedule_frame();
|
|
}
|
|
|
|
pub(crate) fn request_redraw_in(&self, dur: Duration) {
|
|
self.frame_requester.schedule_frame_in(dur);
|
|
}
|
|
|
|
// --- History helpers ---
|
|
|
|
pub(crate) fn set_history_metadata(&mut self, log_id: u64, entry_count: usize) {
|
|
self.composer.set_history_metadata(log_id, entry_count);
|
|
}
|
|
|
|
pub(crate) fn flush_paste_burst_if_due(&mut self) -> bool {
|
|
self.composer.flush_paste_burst_if_due()
|
|
}
|
|
|
|
pub(crate) fn is_in_paste_burst(&self) -> bool {
|
|
self.composer.is_in_paste_burst()
|
|
}
|
|
|
|
pub(crate) fn on_history_entry_response(
|
|
&mut self,
|
|
log_id: u64,
|
|
offset: usize,
|
|
entry: Option<String>,
|
|
) {
|
|
let updated = self
|
|
.composer
|
|
.on_history_entry_response(log_id, offset, entry);
|
|
|
|
if updated {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn on_file_search_result(&mut self, query: String, matches: Vec<FileMatch>) {
|
|
self.composer.on_file_search_result(query, matches);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn attach_image(
|
|
&mut self,
|
|
path: PathBuf,
|
|
width: u32,
|
|
height: u32,
|
|
format_label: &str,
|
|
) {
|
|
if self.view_stack.is_empty() {
|
|
self.composer
|
|
.attach_image(path, width, height, format_label);
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn take_recent_submission_images(&mut self) -> Vec<PathBuf> {
|
|
self.composer.take_recent_submission_images()
|
|
}
|
|
|
|
fn as_renderable(&'_ self) -> RenderableItem<'_> {
|
|
if let Some(view) = self.active_view() {
|
|
RenderableItem::Borrowed(view)
|
|
} else {
|
|
let mut flex = FlexRenderable::new();
|
|
if let Some(status) = &self.status {
|
|
flex.push(0, RenderableItem::Borrowed(status));
|
|
}
|
|
flex.push(1, RenderableItem::Borrowed(&self.queued_user_messages));
|
|
if self.status.is_some() || !self.queued_user_messages.messages.is_empty() {
|
|
flex.push(0, RenderableItem::Owned("".into()));
|
|
}
|
|
let mut flex2 = FlexRenderable::new();
|
|
flex2.push(1, RenderableItem::Owned(flex.into()));
|
|
flex2.push(0, RenderableItem::Borrowed(&self.composer));
|
|
RenderableItem::Owned(Box::new(flex2))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Renderable for BottomPane {
|
|
fn render(&self, area: Rect, buf: &mut Buffer) {
|
|
self.as_renderable().render(area, buf);
|
|
}
|
|
fn desired_height(&self, width: u16) -> u16 {
|
|
self.as_renderable().desired_height(width)
|
|
}
|
|
fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
|
|
self.as_renderable().cursor_pos(area)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::app_event::AppEvent;
|
|
use insta::assert_snapshot;
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
use tokio::sync::mpsc::unbounded_channel;
|
|
|
|
fn snapshot_buffer(buf: &Buffer) -> String {
|
|
let mut lines = Vec::new();
|
|
for y in 0..buf.area().height {
|
|
let mut row = String::new();
|
|
for x in 0..buf.area().width {
|
|
row.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
|
|
}
|
|
lines.push(row);
|
|
}
|
|
lines.join("\n")
|
|
}
|
|
|
|
fn render_snapshot(pane: &BottomPane, area: Rect) -> String {
|
|
let mut buf = Buffer::empty(area);
|
|
pane.render(area, &mut buf);
|
|
snapshot_buffer(&buf)
|
|
}
|
|
|
|
fn exec_request() -> ApprovalRequest {
|
|
ApprovalRequest::Exec {
|
|
id: "1".to_string(),
|
|
command: vec!["echo".into(), "ok".into()],
|
|
reason: None,
|
|
risk: None,
|
|
allow_prefix: None,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn ctrl_c_on_modal_consumes_and_shows_quit_hint() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = BottomPane::new(BottomPaneParams {
|
|
app_event_tx: tx,
|
|
frame_requester: FrameRequester::test_dummy(),
|
|
has_input_focus: true,
|
|
enhanced_keys_supported: false,
|
|
placeholder_text: "Ask Codex to do anything".to_string(),
|
|
disable_paste_burst: false,
|
|
animations_enabled: true,
|
|
});
|
|
pane.push_approval_request(exec_request());
|
|
assert_eq!(CancellationEvent::Handled, pane.on_ctrl_c());
|
|
assert!(pane.ctrl_c_quit_hint_visible());
|
|
assert_eq!(CancellationEvent::NotHandled, pane.on_ctrl_c());
|
|
}
|
|
|
|
// live ring removed; related tests deleted.
|
|
|
|
#[test]
|
|
fn overlay_not_shown_above_approval_modal() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = BottomPane::new(BottomPaneParams {
|
|
app_event_tx: tx,
|
|
frame_requester: FrameRequester::test_dummy(),
|
|
has_input_focus: true,
|
|
enhanced_keys_supported: false,
|
|
placeholder_text: "Ask Codex to do anything".to_string(),
|
|
disable_paste_burst: false,
|
|
animations_enabled: true,
|
|
});
|
|
|
|
// Create an approval modal (active view).
|
|
pane.push_approval_request(exec_request());
|
|
|
|
// Render and verify the top row does not include an overlay.
|
|
let area = Rect::new(0, 0, 60, 6);
|
|
let mut buf = Buffer::empty(area);
|
|
pane.render(area, &mut buf);
|
|
|
|
let mut r0 = String::new();
|
|
for x in 0..area.width {
|
|
r0.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
|
|
}
|
|
assert!(
|
|
!r0.contains("Working"),
|
|
"overlay should not render above modal"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn composer_shown_after_denied_while_task_running() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = BottomPane::new(BottomPaneParams {
|
|
app_event_tx: tx,
|
|
frame_requester: FrameRequester::test_dummy(),
|
|
has_input_focus: true,
|
|
enhanced_keys_supported: false,
|
|
placeholder_text: "Ask Codex to do anything".to_string(),
|
|
disable_paste_burst: false,
|
|
animations_enabled: true,
|
|
});
|
|
|
|
// Start a running task so the status indicator is active above the composer.
|
|
pane.set_task_running(true);
|
|
|
|
// Push an approval modal (e.g., command approval) which should hide the status view.
|
|
pane.push_approval_request(exec_request());
|
|
|
|
// Simulate pressing 'n' (No) on the modal.
|
|
use crossterm::event::KeyCode;
|
|
use crossterm::event::KeyEvent;
|
|
use crossterm::event::KeyModifiers;
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
|
|
|
|
// After denial, since the task is still running, the status indicator should be
|
|
// visible above the composer. The modal should be gone.
|
|
assert!(
|
|
pane.view_stack.is_empty(),
|
|
"no active modal view after denial"
|
|
);
|
|
|
|
// Render and ensure the top row includes the Working header and a composer line below.
|
|
// Give the animation thread a moment to tick.
|
|
std::thread::sleep(Duration::from_millis(120));
|
|
let area = Rect::new(0, 0, 40, 6);
|
|
let mut buf = Buffer::empty(area);
|
|
pane.render(area, &mut buf);
|
|
let mut row0 = String::new();
|
|
for x in 0..area.width {
|
|
row0.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
|
|
}
|
|
assert!(
|
|
row0.contains("Working"),
|
|
"expected Working header after denial on row 0: {row0:?}"
|
|
);
|
|
|
|
// Composer placeholder should be visible somewhere below.
|
|
let mut found_composer = false;
|
|
for y in 1..area.height {
|
|
let mut row = String::new();
|
|
for x in 0..area.width {
|
|
row.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
|
|
}
|
|
if row.contains("Ask Codex") {
|
|
found_composer = true;
|
|
break;
|
|
}
|
|
}
|
|
assert!(
|
|
found_composer,
|
|
"expected composer visible under status line"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn status_indicator_visible_during_command_execution() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = BottomPane::new(BottomPaneParams {
|
|
app_event_tx: tx,
|
|
frame_requester: FrameRequester::test_dummy(),
|
|
has_input_focus: true,
|
|
enhanced_keys_supported: false,
|
|
placeholder_text: "Ask Codex to do anything".to_string(),
|
|
disable_paste_burst: false,
|
|
animations_enabled: true,
|
|
});
|
|
|
|
// Begin a task: show initial status.
|
|
pane.set_task_running(true);
|
|
|
|
// Use a height that allows the status line to be visible above the composer.
|
|
let area = Rect::new(0, 0, 40, 6);
|
|
let mut buf = Buffer::empty(area);
|
|
pane.render(area, &mut buf);
|
|
|
|
let bufs = snapshot_buffer(&buf);
|
|
assert!(bufs.contains("• Working"), "expected Working header");
|
|
}
|
|
|
|
#[test]
|
|
fn status_and_composer_fill_height_without_bottom_padding() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = BottomPane::new(BottomPaneParams {
|
|
app_event_tx: tx,
|
|
frame_requester: FrameRequester::test_dummy(),
|
|
has_input_focus: true,
|
|
enhanced_keys_supported: false,
|
|
placeholder_text: "Ask Codex to do anything".to_string(),
|
|
disable_paste_burst: false,
|
|
animations_enabled: true,
|
|
});
|
|
|
|
// Activate spinner (status view replaces composer) with no live ring.
|
|
pane.set_task_running(true);
|
|
|
|
// Use height == desired_height; expect spacer + status + composer rows without trailing padding.
|
|
let height = pane.desired_height(30);
|
|
assert!(
|
|
height >= 3,
|
|
"expected at least 3 rows to render spacer, status, and composer; got {height}"
|
|
);
|
|
let area = Rect::new(0, 0, 30, height);
|
|
assert_snapshot!(
|
|
"status_and_composer_fill_height_without_bottom_padding",
|
|
render_snapshot(&pane, area)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn queued_messages_visible_when_status_hidden_snapshot() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = BottomPane::new(BottomPaneParams {
|
|
app_event_tx: tx,
|
|
frame_requester: FrameRequester::test_dummy(),
|
|
has_input_focus: true,
|
|
enhanced_keys_supported: false,
|
|
placeholder_text: "Ask Codex to do anything".to_string(),
|
|
disable_paste_burst: false,
|
|
animations_enabled: true,
|
|
});
|
|
|
|
pane.set_task_running(true);
|
|
pane.set_queued_user_messages(vec!["Queued follow-up question".to_string()]);
|
|
pane.hide_status_indicator();
|
|
|
|
let width = 48;
|
|
let height = pane.desired_height(width);
|
|
let area = Rect::new(0, 0, width, height);
|
|
assert_snapshot!(
|
|
"queued_messages_visible_when_status_hidden_snapshot",
|
|
render_snapshot(&pane, area)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn status_and_queued_messages_snapshot() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = BottomPane::new(BottomPaneParams {
|
|
app_event_tx: tx,
|
|
frame_requester: FrameRequester::test_dummy(),
|
|
has_input_focus: true,
|
|
enhanced_keys_supported: false,
|
|
placeholder_text: "Ask Codex to do anything".to_string(),
|
|
disable_paste_burst: false,
|
|
animations_enabled: true,
|
|
});
|
|
|
|
pane.set_task_running(true);
|
|
pane.set_queued_user_messages(vec!["Queued follow-up question".to_string()]);
|
|
|
|
let width = 48;
|
|
let height = pane.desired_height(width);
|
|
let area = Rect::new(0, 0, width, height);
|
|
assert_snapshot!(
|
|
"status_and_queued_messages_snapshot",
|
|
render_snapshot(&pane, area)
|
|
);
|
|
}
|
|
}
|