mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
## Why Startup configuration warnings can reflect settings from when the background server started, even after those settings have been fixed. A restart lets users refresh the server without leaving the TUI. ## What changed - Add a confirmed restart action to `/daemon`, warning that active or queued work in other chats may be interrupted. Reconnect automatically and let an in-progress restart finish if the TUI exits. - Verify that Codex manages a local server before enabling restart, including servers discovered with auto-start disabled and those started by `codex agents`. - Show a restart hint on the first startup configuration warning for managed servers, preserving the original diagnostic for copying and dismissal. - Repaint the full surface of centered dialogs to restore background colors over cached blank cells. ## Testing Add CLI integration coverage for agents startup and restarting a discovered daemon with auto-start disabled. Extend TUI tests for confirmation, cancellation, unmanaged servers, warning hints and dismissal, and dialog background rendering. GitOrigin-RevId: 8e4319fab84f13bf6e7335deb93364fccaff14a7
4215 lines
154 KiB
Rust
4215 lines
154 KiB
Rust
//! The bottom pane is the interactive footer of the chat UI.
|
|
//!
|
|
//! The pane owns the [`ChatComposer`] (editable prompt input) and a stack of transient
|
|
//! [`BottomPaneView`]s (popups/modals) that temporarily replace the composer for focused
|
|
//! interactions like selection lists. Centered views retain earlier views as a backdrop,
|
|
//! while input remains routed exclusively to the top of the stack.
|
|
//! Modal insertion, replacement, and dismissal invalidate pending key chords, including when a
|
|
//! deferred prompt appears or an approval queue advances without changing keymap contexts.
|
|
//!
|
|
//! Input routing is layered: `BottomPane` decides which local surface receives a key (view vs
|
|
//! composer), while higher-level intent such as "interrupt" or "quit" is decided by the parent
|
|
//! widget (`ChatWidget`). This split matters for Ctrl+C/Ctrl+D: the bottom pane gives the active
|
|
//! view the first chance to consume Ctrl+C (typically to dismiss itself), then lets an active
|
|
//! composer history search consume Ctrl+C as cancellation, and `ChatWidget` may treat an unhandled
|
|
//! Ctrl+C as an interrupt or as the first press of a double-press quit shortcut.
|
|
//!
|
|
//! Some UI is time-based rather than input-based, such as the transient "press again to quit"
|
|
//! hint. The pane schedules redraws so those hints can expire even when the UI is otherwise idle.
|
|
//! Inline banners sit above the composer. Number shortcuts apply only to an empty, idle composer;
|
|
//! drafts, paste bursts, and active dialogs keep their normal input routing.
|
|
//! Owned transcripts separate activity from the transcript and reserve their shared hint row
|
|
//! below activity and previews, above the composer.
|
|
pub(crate) use chat_composer::CommandPopupPlacement;
|
|
pub(crate) use chat_composer::ComposerRenderOptions;
|
|
pub(crate) use chat_composer::TranscriptFooter;
|
|
pub(crate) use composer_gap::ComposerGap;
|
|
pub(crate) use footer::footer_hint_items_line;
|
|
pub(crate) use footer::inset_footer_hint_area;
|
|
use std::collections::VecDeque;
|
|
use std::path::PathBuf;
|
|
|
|
use crate::app::app_server_requests::ResolvedAppServerRequest;
|
|
use crate::app_event::AppEvent;
|
|
use crate::app_event::ConnectorsSnapshot;
|
|
use crate::app_event::HistoryLookupResponse;
|
|
use crate::app_event_sender::AppEventSender;
|
|
use crate::bottom_pane::pending_input_preview::PendingInputPreview;
|
|
use crate::bottom_pane::pending_thread_approvals::PendingThreadApprovals;
|
|
use crate::bottom_pane::unified_exec_footer::UnifiedExecFooter;
|
|
use crate::key_hint;
|
|
use crate::key_hint::KeyBinding;
|
|
use crate::key_hint::KeyBindingListExt;
|
|
use crate::keymap::KeymapContext;
|
|
use crate::keymap::KeymapContextSet;
|
|
use crate::keymap::RuntimeKeymap;
|
|
use crate::render::renderable::FlexRenderable;
|
|
use crate::render::renderable::Renderable;
|
|
use crate::render::renderable::RenderableItem;
|
|
use crate::terminal_palette::effective_stdout_color_level;
|
|
use crate::tui::FrameRequester;
|
|
pub(crate) use bottom_pane_view::BottomPaneView;
|
|
pub(crate) use bottom_pane_view::ViewCompletion;
|
|
pub(crate) use bottom_pane_view::ViewPresentation;
|
|
use codex_app_server_protocol::SkillMetadata;
|
|
use codex_app_server_protocol::ToolRequestUserInputParams;
|
|
use codex_features::Features;
|
|
use codex_file_search::FileMatch;
|
|
use codex_plugin::PluginCapabilitySummary;
|
|
use codex_protocol::ThreadId;
|
|
use codex_protocol::openai_models::ReasoningEffort;
|
|
use codex_protocol::user_input::TextElement;
|
|
use crossterm::event::KeyCode;
|
|
use crossterm::event::KeyEvent;
|
|
use crossterm::event::KeyEventKind;
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
use ratatui::style::Stylize;
|
|
use ratatui::text::Line;
|
|
use ratatui::text::Span;
|
|
use ratatui::widgets::Paragraph;
|
|
use std::time::Duration;
|
|
use std::time::Instant;
|
|
|
|
mod action_required_title;
|
|
mod actionable_banner;
|
|
mod app_link_view;
|
|
mod apply_patch_header;
|
|
mod approval_overlay;
|
|
mod async_questions;
|
|
mod config_panel;
|
|
mod empty_state_policy;
|
|
mod hook_status;
|
|
mod mcp_server_elicitation;
|
|
mod multi_select_picker;
|
|
pub(crate) use multi_select_picker::MultiSelectItem;
|
|
pub(crate) use multi_select_picker::MultiSelectPicker;
|
|
#[cfg(test)]
|
|
#[path = "questions_tests.rs"]
|
|
mod question_tests;
|
|
mod questions;
|
|
mod request_user_input;
|
|
mod status_line_setup;
|
|
mod status_line_style;
|
|
mod status_surface_preview;
|
|
mod title_setup;
|
|
pub(crate) mod user_verification;
|
|
mod voice_strip;
|
|
mod warnings;
|
|
mod warnings_view;
|
|
pub(crate) use action_required_title::ACTION_REQUIRED_PREVIEW_PREFIX;
|
|
pub(crate) use action_required_title::build_action_required_title_text;
|
|
pub(crate) use actionable_banner::ActionableBanner;
|
|
pub(crate) use actionable_banner::BannerDismissal;
|
|
pub(crate) use app_link_view::AppLinkElicitationTarget;
|
|
pub(crate) use app_link_view::AppLinkSuggestionType;
|
|
pub(crate) use app_link_view::AppLinkView;
|
|
pub(crate) use app_link_view::AppLinkViewParams;
|
|
pub(crate) use approval_overlay::ApplyPatchApprovalRequest;
|
|
pub(crate) use approval_overlay::ApprovalOverlay;
|
|
pub(crate) use approval_overlay::ApprovalRequest;
|
|
pub(crate) use approval_overlay::ExecApprovalRequest;
|
|
pub(crate) use approval_overlay::McpElicitationApprovalRequest;
|
|
pub(crate) use approval_overlay::PermissionsApprovalRequest;
|
|
pub(crate) use approval_overlay::format_requested_permissions_rule;
|
|
pub(crate) use async_questions::AsyncQuestions;
|
|
pub(crate) use async_questions::QuestionState;
|
|
pub(crate) use async_questions::QuestionSubmission;
|
|
pub(crate) use mcp_server_elicitation::McpServerElicitationFormRequest;
|
|
pub(crate) use mcp_server_elicitation::McpServerElicitationOverlay;
|
|
pub(crate) use request_user_input::RequestUserInputOverlay;
|
|
pub(crate) use status_line_style::status_line_from_segments;
|
|
pub(crate) use voice_strip::VoiceStripPhase;
|
|
pub(crate) use voice_strip::VoiceStripState;
|
|
mod bottom_pane_view;
|
|
mod composer_gap;
|
|
mod effort_ignition;
|
|
mod view_stack;
|
|
pub(crate) use view_stack::CenteredView;
|
|
pub(crate) use view_stack::DialogOverlay;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub(crate) struct LocalImageAttachment {
|
|
pub(crate) placeholder: String,
|
|
pub(crate) path: PathBuf,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub(crate) struct MentionBinding {
|
|
/// Visible mention sigil (`$` or `@`).
|
|
pub(crate) sigil: char,
|
|
/// Mention token text without the leading sigil (`$` or `@`).
|
|
pub(crate) mention: String,
|
|
/// Canonical mention target (for example `app://...` or absolute SKILL.md path).
|
|
pub(crate) path: String,
|
|
}
|
|
mod chat_composer;
|
|
mod chat_composer_history;
|
|
mod command_popup;
|
|
pub(crate) mod custom_prompt_view;
|
|
mod effort_status_line;
|
|
mod experimental_features_view;
|
|
mod file_search_popup;
|
|
mod footer;
|
|
mod list_selection_view;
|
|
mod memories_settings_view;
|
|
mod mentions_v2;
|
|
mod picker_presets;
|
|
mod picker_rows;
|
|
mod picker_style;
|
|
mod shortcut_overlay;
|
|
pub(crate) use picker_style::active_tab_style;
|
|
pub(crate) use picker_style::selection_style;
|
|
pub(crate) mod prompt_args;
|
|
mod selection_picker_layout;
|
|
mod skill_popup;
|
|
mod skills_toggle_view;
|
|
pub(crate) mod slash_commands;
|
|
pub(crate) use footer::CollaborationModeIndicator;
|
|
pub(crate) use footer::GoalStatusIndicator;
|
|
#[cfg(test)]
|
|
pub(crate) use footer::goal_status_indicator_line;
|
|
pub(crate) use list_selection_view::ColumnWidthMode;
|
|
pub(crate) use list_selection_view::ListSelectionView;
|
|
pub(crate) use list_selection_view::OnSelectionChangedCallback;
|
|
pub(crate) use list_selection_view::PickerSurface;
|
|
pub(crate) use list_selection_view::SearchMode;
|
|
pub(crate) use list_selection_view::SelectionDescriptionLayout;
|
|
pub(crate) use list_selection_view::SelectionRowDisplay;
|
|
pub(crate) use list_selection_view::SelectionToggle;
|
|
pub(crate) use list_selection_view::SelectionViewParams;
|
|
pub(crate) use list_selection_view::SideContentWidth;
|
|
pub(crate) use list_selection_view::popup_content_width;
|
|
pub(crate) use list_selection_view::side_by_side_layout_widths;
|
|
pub(crate) use memories_settings_view::MemoriesSettingsView;
|
|
use slash_commands::ServiceTierCommand;
|
|
mod feedback_note_view;
|
|
mod feedback_view;
|
|
mod hooks_browser_view;
|
|
pub(crate) use feedback_view::FeedbackAudience;
|
|
pub(crate) use feedback_view::feedback_classification;
|
|
pub(crate) use feedback_view::feedback_disabled_params;
|
|
pub(crate) use feedback_view::feedback_selection_params;
|
|
pub(crate) use feedback_view::feedback_success_cell;
|
|
pub(crate) use feedback_view::feedback_upload_consent_params;
|
|
pub(crate) use skills_toggle_view::SkillsToggleItem;
|
|
pub(crate) use skills_toggle_view::SkillsToggleView;
|
|
pub(crate) use status_line_setup::StatusLineItem;
|
|
pub(crate) use status_line_setup::StatusLineSetupView;
|
|
pub(crate) use status_surface_preview::StatusSurfacePreviewData;
|
|
pub(crate) use status_surface_preview::StatusSurfacePreviewItem;
|
|
pub(crate) use title_setup::TerminalTitleItem;
|
|
pub(crate) use title_setup::TerminalTitleSetupView;
|
|
#[cfg(test)]
|
|
pub(crate) use title_setup::preview_line_for_title_items;
|
|
mod paste_burst;
|
|
mod pending_input_preview;
|
|
mod pending_thread_approvals;
|
|
mod picker_option;
|
|
pub(crate) use picker_option::picker_option_list;
|
|
pub(crate) use picker_option::picker_option_row;
|
|
pub(crate) mod popup_consts;
|
|
mod scroll_state;
|
|
mod selection_popup_common;
|
|
pub(crate) use selection_popup_common::menu_surface_padding_height;
|
|
pub(crate) use selection_popup_common::render_menu_surface;
|
|
mod selection_row_layout;
|
|
mod selection_tabs;
|
|
pub(crate) use selection_tabs::render_filled_tab_bar;
|
|
mod startup;
|
|
mod textarea;
|
|
pub(crate) use textarea::TextArea;
|
|
pub(crate) use textarea::TextAreaState;
|
|
mod unified_exec_footer;
|
|
pub(crate) use feedback_note_view::FeedbackNoteView;
|
|
pub(crate) use hooks_browser_view::HooksBrowserView;
|
|
pub(crate) use selection_tabs::SelectionTab;
|
|
|
|
/// How long the "press again to quit" hint stays visible.
|
|
///
|
|
/// This is shared between:
|
|
/// - `ChatWidget`: arming the double-press quit shortcut.
|
|
/// - `BottomPane`/`ChatComposer`: rendering and expiring the footer hint.
|
|
///
|
|
/// Keeping a single value ensures Ctrl+C and Ctrl+D behave identically.
|
|
pub(crate) const QUIT_SHORTCUT_TIMEOUT: Duration = Duration::from_secs(1);
|
|
|
|
const APPROVAL_PROMPT_TYPING_IDLE_DELAY: Duration = Duration::from_secs(1);
|
|
|
|
/// Whether Ctrl+C/Ctrl+D require a second press to quit.
|
|
///
|
|
/// This UX experiment was enabled by default, but requiring a double press to quit feels janky in
|
|
/// practice (especially for users accustomed to shells and other TUIs). Disable it for now while we
|
|
/// rethink a better quit/interrupt design.
|
|
pub(crate) const DOUBLE_PRESS_QUIT_SHORTCUT_ENABLED: bool = false;
|
|
|
|
/// The result of offering a cancellation key to a bottom-pane surface.
|
|
///
|
|
/// This is primarily used for Ctrl+C routing: active views can consume the key to dismiss
|
|
/// themselves, and the caller can decide what higher-level action (if any) to take when the key is
|
|
/// not handled locally.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub(crate) enum CancellationEvent {
|
|
Handled,
|
|
NotHandled,
|
|
}
|
|
|
|
use crate::bottom_pane::prompt_args::parse_slash_name;
|
|
pub(crate) use chat_composer::ChatComposer;
|
|
pub(crate) use chat_composer::ChatComposerConfig;
|
|
pub(crate) use chat_composer::ComposerDraftSnapshot;
|
|
pub(crate) use chat_composer::InputResult;
|
|
pub(crate) use chat_composer::QueuedInputAction;
|
|
pub(crate) use chat_composer::RestrictedInputMode;
|
|
pub(crate) use chat_composer_history::HistoryEntry;
|
|
pub(crate) use textarea::KillBufferSnapshot;
|
|
|
|
use crate::status_indicator_widget::StatusDetailsCapitalization;
|
|
use crate::status_indicator_widget::StatusIndicatorWidget;
|
|
#[cfg(test)]
|
|
pub(crate) use experimental_features_view::ExperimentalFeatureItem;
|
|
pub(crate) use experimental_features_view::ExperimentalFeaturesView;
|
|
pub(crate) use list_selection_view::SELECTION_TOGGLE_BLOCKED_PREFIX;
|
|
pub(crate) use list_selection_view::SELECTION_TOGGLE_UNAVAILABLE_PREFIX;
|
|
pub(crate) use list_selection_view::SelectionAction;
|
|
pub(crate) use list_selection_view::SelectionItem;
|
|
pub(crate) use list_selection_view::SelectionSecondaryAction;
|
|
|
|
struct DelayedApprovalRequest {
|
|
request: ApprovalRequest,
|
|
features: Features,
|
|
}
|
|
|
|
/// Pane displayed in the lower half of the chat UI.
|
|
///
|
|
/// This is the owning container for the prompt input (`ChatComposer`) and the view stack
|
|
/// (`BottomPaneView`). It performs local input routing and renders time-based hints, while leaving
|
|
/// process-level decisions (quit, interrupt, shutdown) to `ChatWidget`.
|
|
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>>,
|
|
pub(crate) key_chord_reset_requested: bool,
|
|
warnings_view: Option<warnings_view::WarningsView>,
|
|
/// A keep press can close the viewer; its remaining repeats must not edit the draft.
|
|
pub(crate) suppress_warning_keep_repeat: bool,
|
|
view_transition_key_guard: Option<crate::activation_key_guard::ActivationKeyGuard>,
|
|
pub(crate) questions: Option<Box<AsyncQuestions>>,
|
|
delayed_approval_requests: VecDeque<DelayedApprovalRequest>,
|
|
last_composer_activity_at: Option<Instant>,
|
|
|
|
app_event_tx: AppEventSender,
|
|
frame_requester: FrameRequester,
|
|
thread_id: Option<ThreadId>,
|
|
|
|
has_input_focus: bool,
|
|
enhanced_keys_supported: bool,
|
|
disable_paste_burst: bool,
|
|
is_task_running: bool,
|
|
esc_backtrack_hint: bool,
|
|
animations_enabled: bool,
|
|
effects: codex_config::types::TuiEffects,
|
|
|
|
/// Inline status indicator shown above the composer while a task is running.
|
|
status: Option<StatusIndicatorWidget>,
|
|
/// Running-hook summary supplied by the lifecycle owner after its reveal delay.
|
|
hook_status_message: Option<String>,
|
|
inline_banner: Option<actionable_banner::InlineBanner>,
|
|
/// Streaming may drop the row without losing its elapsed time or modal pause.
|
|
status_timer: crate::status_indicator_widget::StatusTimer,
|
|
/// Unified exec session summary source.
|
|
///
|
|
/// When a status row exists, this summary is mirrored inline in that row;
|
|
/// when no status row exists, it renders as its own footer row.
|
|
unified_exec_footer: UnifiedExecFooter,
|
|
/// Preview of pending steers and queued drafts shown above the composer.
|
|
pending_input_preview: PendingInputPreview,
|
|
/// Inactive threads with pending approval requests.
|
|
pending_thread_approvals: PendingThreadApprovals,
|
|
context_window_percent: Option<i64>,
|
|
context_window_used_tokens: Option<i64>,
|
|
keymap: RuntimeKeymap,
|
|
}
|
|
|
|
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,
|
|
pub(crate) effects: codex_config::types::TuiEffects,
|
|
pub(crate) skills: Option<Vec<SkillMetadata>>,
|
|
}
|
|
|
|
impl BottomPane {
|
|
pub fn new(params: BottomPaneParams) -> Self {
|
|
Self::new_with_composer_config(params, ChatComposerConfig::default())
|
|
}
|
|
|
|
/// Construct a bottom pane with explicitly restricted composer behavior.
|
|
pub(crate) fn new_with_composer_config(
|
|
params: BottomPaneParams,
|
|
composer_config: ChatComposerConfig,
|
|
) -> Self {
|
|
let BottomPaneParams {
|
|
app_event_tx,
|
|
frame_requester,
|
|
has_input_focus,
|
|
enhanced_keys_supported,
|
|
placeholder_text,
|
|
disable_paste_burst,
|
|
animations_enabled,
|
|
effects,
|
|
skills,
|
|
} = params;
|
|
let mut composer = ChatComposer::new_with_config(
|
|
has_input_focus,
|
|
app_event_tx.clone(),
|
|
enhanced_keys_supported,
|
|
placeholder_text,
|
|
disable_paste_burst,
|
|
composer_config,
|
|
);
|
|
composer.set_frame_requester(frame_requester.clone());
|
|
let keymap = RuntimeKeymap::defaults();
|
|
composer.set_keymap_bindings(&keymap);
|
|
composer.set_skill_mentions(skills);
|
|
Self {
|
|
composer,
|
|
view_stack: Vec::new(),
|
|
key_chord_reset_requested: false,
|
|
warnings_view: None,
|
|
suppress_warning_keep_repeat: false,
|
|
view_transition_key_guard: None,
|
|
questions: None,
|
|
delayed_approval_requests: VecDeque::new(),
|
|
last_composer_activity_at: None,
|
|
app_event_tx,
|
|
frame_requester,
|
|
thread_id: None,
|
|
has_input_focus,
|
|
enhanced_keys_supported,
|
|
disable_paste_burst,
|
|
is_task_running: false,
|
|
status: None,
|
|
hook_status_message: None,
|
|
inline_banner: None,
|
|
status_timer: crate::status_indicator_widget::StatusTimer::default(),
|
|
unified_exec_footer: UnifiedExecFooter::new(),
|
|
pending_input_preview: PendingInputPreview::new(),
|
|
pending_thread_approvals: PendingThreadApprovals::new(),
|
|
esc_backtrack_hint: false,
|
|
animations_enabled,
|
|
effects,
|
|
context_window_percent: None,
|
|
context_window_used_tokens: None,
|
|
keymap,
|
|
}
|
|
}
|
|
|
|
pub fn set_skills(&mut self, skills: Option<Vec<SkillMetadata>>) {
|
|
self.composer.set_skill_mentions(skills);
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Update image-paste behavior for the active composer and repaint immediately.
|
|
///
|
|
/// Callers use this to keep composer affordances aligned with model capabilities.
|
|
pub fn set_image_paste_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_image_paste_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Mirrors the effective reasoning effort into the composer so its next
|
|
/// visible frame can play a one-shot Max/Ultra effect.
|
|
pub(crate) fn set_active_reasoning_effort(&mut self, effort: Option<&ReasoningEffort>) {
|
|
let animations_enabled = effort_ignition::effort_animation_enabled(
|
|
self.animations_enabled && self.effects.effort,
|
|
effective_stdout_color_level(),
|
|
);
|
|
if self
|
|
.composer
|
|
.set_active_reasoning_effort(effort, animations_enabled)
|
|
{
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
/// Establishes a restored thread's effort without replaying its one-shot animation.
|
|
pub(crate) fn set_active_reasoning_effort_baseline(
|
|
&mut self,
|
|
effort: Option<&ReasoningEffort>,
|
|
) {
|
|
self.composer.set_active_reasoning_effort_baseline(effort);
|
|
}
|
|
|
|
pub fn set_connectors_snapshot(&mut self, snapshot: Option<ConnectorsSnapshot>) {
|
|
self.composer.set_connector_mentions(snapshot);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_plugin_mentions(&mut self, plugins: Option<Vec<PluginCapabilitySummary>>) {
|
|
self.composer.set_plugin_mentions(plugins);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_agents_navigation_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_agents_navigation_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn agents_navigation_key_available(&self) -> bool {
|
|
let left = KeyEvent::from(KeyCode::Left);
|
|
self.composer.agents_navigation_key_available()
|
|
&& !crate::keymap::keymap_action_ids()
|
|
.filter(|action| {
|
|
matches!(
|
|
action.context,
|
|
KeymapContext::Global | KeymapContext::Chat | KeymapContext::Voice
|
|
)
|
|
})
|
|
.any(|action| {
|
|
crate::keymap::bindings_for_action(
|
|
&self.keymap,
|
|
action.context.config_name(),
|
|
action.action,
|
|
)
|
|
.is_some_and(|bindings| bindings.is_pressed(left))
|
|
})
|
|
&& !self.keymap.chords.bindings.iter().any(|binding| {
|
|
matches!(
|
|
binding.action.context,
|
|
KeymapContext::Global | KeymapContext::Chat | KeymapContext::Voice
|
|
) && binding.chord.prefix.is_press(left)
|
|
})
|
|
}
|
|
|
|
pub(crate) fn set_task_mentions_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_task_mentions_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn task_mentions_enabled(&self) -> bool {
|
|
self.composer.task_mentions_enabled()
|
|
}
|
|
|
|
pub(crate) fn on_task_search_result(
|
|
&mut self,
|
|
query: &str,
|
|
matches: Vec<crate::task_mentions::TaskMention>,
|
|
) {
|
|
self.composer.on_task_search_result(query, matches);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_plugins_command_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_plugins_command_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_token_activity_command_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_token_activity_command_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_mentions_v2_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_mentions_v2_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn take_mention_bindings(&mut self) -> Vec<MentionBinding> {
|
|
self.composer.take_mention_bindings()
|
|
}
|
|
|
|
pub fn take_recent_submission_mention_bindings(&mut self) -> Vec<MentionBinding> {
|
|
self.composer.take_recent_submission_mention_bindings()
|
|
}
|
|
|
|
/// Add a staged slash-command draft to the composer's local recall list.
|
|
///
|
|
/// This should be called exactly once after `ChatWidget` dispatches a recognized command.
|
|
/// Slash recall records the submitted command text regardless of whether the command succeeds.
|
|
pub(crate) fn record_pending_slash_command_history(&mut self) {
|
|
self.composer.record_pending_slash_command_history();
|
|
}
|
|
|
|
/// Replace all bottom-pane keymap caches from one resolved runtime keymap.
|
|
///
|
|
/// The bottom pane owns several input surfaces: composer, overlays, and
|
|
/// selection views. Applying one snapshot through this method keeps those
|
|
/// surfaces synchronized after config reloads or interactive remaps. Callers
|
|
/// should not update the composer directly unless they deliberately want
|
|
/// overlays and selection views to continue using the previous bindings.
|
|
pub fn set_keymap_bindings(&mut self, keymap: &RuntimeKeymap) {
|
|
self.keymap = keymap.clone();
|
|
if let Some(view) = &mut self.warnings_view {
|
|
view.set_keymap(keymap);
|
|
}
|
|
self.composer.set_keymap_bindings(keymap);
|
|
if let Some(questions) = &mut self.questions {
|
|
questions.set_keymap(keymap);
|
|
}
|
|
// Show the first shortcut from the same keymap ChatWidget uses to handle queued edits.
|
|
self.pending_input_preview
|
|
.set_edit_binding(keymap.primary_hint(KeymapContext::Chat, "edit_queued_message"));
|
|
let interrupt_binding = keymap.primary_hint(KeymapContext::Chat, "interrupt_turn");
|
|
self.pending_input_preview
|
|
.set_interrupt_binding(interrupt_binding);
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.set_interrupt_binding(interrupt_binding);
|
|
}
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn transcript_shortcut_hint(&self) -> Option<crate::key_hint::ShortcutHint> {
|
|
self.keymap
|
|
.primary_hint(KeymapContext::Global, "open_transcript")
|
|
}
|
|
|
|
/// Clear pending attachments and mention bindings e.g. when a slash command doesn't submit text.
|
|
pub(crate) fn drain_pending_submission_state(&mut self) {
|
|
let _ = self.take_recent_submission_images_with_placeholders();
|
|
let _ = self.take_remote_image_urls();
|
|
let _ = self.take_recent_submission_mention_bindings();
|
|
let _ = self.take_mention_bindings();
|
|
}
|
|
|
|
pub fn set_collaboration_modes_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_collaboration_modes_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_connectors_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_connectors_enabled(enabled);
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub fn set_windows_degraded_sandbox_active(&mut self, enabled: bool) {
|
|
self.composer.set_windows_degraded_sandbox_active(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_collaboration_mode_indicator(
|
|
&mut self,
|
|
indicator: Option<CollaborationModeIndicator>,
|
|
) {
|
|
self.composer.set_collaboration_mode_indicator(indicator);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_goal_status_indicator(&mut self, indicator: Option<GoalStatusIndicator>) {
|
|
self.composer.set_goal_status_indicator(indicator);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_ide_context_active(&mut self, active: bool) {
|
|
self.composer.set_ide_context_active(active);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_worktrees_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_worktrees_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_service_tier_commands_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_service_tier_commands_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_daybreak_command_description(&mut self, description: Option<&'static str>) {
|
|
self.composer.set_daybreak_command_description(description);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_service_tier_commands(&mut self, commands: Vec<ServiceTierCommand>) {
|
|
self.composer.set_service_tier_commands(commands);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_goal_command_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_goal_command_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn set_voice_command_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_voice_command_enabled(enabled);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_side_conversation_active(&mut self, active: bool) {
|
|
self.composer.set_side_conversation_active(active);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_placeholder_text(&mut self, placeholder: String) {
|
|
self.composer.set_placeholder_text(placeholder);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_parent_owned_thread(&mut self) {
|
|
self.composer.set_parent_owned_thread();
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_vim_enabled(&mut self, enabled: bool) {
|
|
self.composer.set_vim_enabled(enabled);
|
|
if let Some(questions) = &mut self.questions {
|
|
questions.set_vim_enabled(enabled);
|
|
}
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn take_kill_buffer_snapshot(&mut self) -> KillBufferSnapshot {
|
|
self.composer.take_kill_buffer_snapshot()
|
|
}
|
|
|
|
pub(crate) fn restore_kill_buffer_snapshot(&mut self, snapshot: KillBufferSnapshot) {
|
|
self.composer.restore_kill_buffer_snapshot(snapshot);
|
|
}
|
|
|
|
pub(crate) fn toggle_vim_enabled(&mut self) -> bool {
|
|
let enabled = self.composer.toggle_vim_enabled();
|
|
if let Some(questions) = &mut self.questions {
|
|
questions.set_vim_enabled(enabled);
|
|
}
|
|
self.request_redraw();
|
|
enabled
|
|
}
|
|
|
|
pub fn status_widget(&self) -> Option<&StatusIndicatorWidget> {
|
|
self.status.as_ref()
|
|
}
|
|
|
|
pub(crate) fn status_elapsed(&self) -> Option<Duration> {
|
|
self.is_task_running
|
|
.then(|| self.status_timer.elapsed_at(Instant::now()))
|
|
}
|
|
|
|
pub(crate) fn reset_status_timer(&mut self, elapsed: Duration) {
|
|
self.status_timer.reset(elapsed);
|
|
}
|
|
|
|
pub(crate) fn set_status_timer_origin(&mut self, started_at: Option<Instant>) {
|
|
self.status_timer.display_started_at = started_at;
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub fn skills(&self) -> Option<&Vec<SkillMetadata>> {
|
|
self.composer.skills()
|
|
}
|
|
|
|
pub fn plugins(&self) -> Option<&Vec<PluginCapabilitySummary>> {
|
|
self.composer.plugins()
|
|
}
|
|
|
|
#[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.key_chord_reset_requested = true;
|
|
self.view_stack.push(view);
|
|
self.schedule_active_view_frame();
|
|
self.request_redraw();
|
|
}
|
|
|
|
fn pop_active_view_with_completion(&mut self, completion: Option<ViewCompletion>) {
|
|
if self.view_stack.pop().is_some() {
|
|
match completion {
|
|
Some(ViewCompletion::Accepted) => {
|
|
while self
|
|
.view_stack
|
|
.last()
|
|
.is_some_and(|view| view.dismiss_after_child_accept())
|
|
{
|
|
self.view_stack.pop();
|
|
}
|
|
}
|
|
Some(ViewCompletion::Cancelled) => {
|
|
if let Some(view) = self.view_stack.last_mut() {
|
|
view.clear_dismiss_after_child_accept();
|
|
}
|
|
}
|
|
None => {}
|
|
}
|
|
self.on_view_stack_depth_decreased();
|
|
}
|
|
}
|
|
|
|
fn on_view_stack_depth_decreased(&mut self) {
|
|
self.key_chord_reset_requested = true;
|
|
if self.view_stack.is_empty() {
|
|
self.on_active_view_complete();
|
|
}
|
|
}
|
|
|
|
fn approval_prompt_delay_remaining(&self, now: Instant) -> Option<Duration> {
|
|
self.last_composer_activity_at.and_then(|last_activity_at| {
|
|
last_activity_at
|
|
.checked_add(APPROVAL_PROMPT_TYPING_IDLE_DELAY)
|
|
.and_then(|show_at| show_at.checked_duration_since(now))
|
|
.filter(|delay| !delay.is_zero())
|
|
})
|
|
}
|
|
|
|
pub(crate) fn record_composer_activity_at(&mut self, now: Instant) {
|
|
self.last_composer_activity_at = Some(now);
|
|
if self.has_pending_approval()
|
|
&& let Some(delay) = self.approval_prompt_delay_remaining(now)
|
|
{
|
|
self.request_redraw_in(delay);
|
|
}
|
|
}
|
|
|
|
fn maybe_show_delayed_approval_requests_at(&mut self, now: Instant) {
|
|
if !self.has_pending_approval() || !self.view_stack.is_empty() {
|
|
return;
|
|
}
|
|
if let Some(delay) = self.approval_prompt_delay_remaining(now) {
|
|
self.request_redraw_in(delay);
|
|
return;
|
|
}
|
|
|
|
// Promote the oldest delayed approval once typing has been idle long enough.
|
|
// `ApprovalOverlay` advances its internal queue with `pop()`, so drain the
|
|
// remaining delayed approvals from the back to preserve FIFO display order.
|
|
let Some(first) = self.delayed_approval_requests.pop_front() else {
|
|
return;
|
|
};
|
|
let mut modal = ApprovalOverlay::new(
|
|
first.request,
|
|
self.app_event_tx.clone(),
|
|
first.features,
|
|
self.keymap.approval.clone(),
|
|
self.keymap.list.clone(),
|
|
);
|
|
while let Some(delayed) = self.delayed_approval_requests.pop_back() {
|
|
modal.enqueue_request(delayed.request);
|
|
}
|
|
self.pause_status_timer_for_modal();
|
|
self.push_view(Box::new(modal));
|
|
}
|
|
|
|
/// Preserve restricted drafts, allowing recovery commands only for connected unavailable threads.
|
|
pub(crate) fn handle_restricted_key(
|
|
&mut self,
|
|
key: KeyEvent,
|
|
mode: RestrictedInputMode,
|
|
) -> InputResult {
|
|
self.view_stack.clear();
|
|
self.warnings_view = None;
|
|
self.delayed_approval_requests.clear();
|
|
self.composer
|
|
.set_input_enabled(/*enabled*/ true, /*placeholder*/ None);
|
|
let result = self.composer.handle_restricted_key(key, mode);
|
|
self.request_redraw();
|
|
result
|
|
}
|
|
|
|
/// Forward a key event to the active view or the composer.
|
|
pub fn handle_key_event(&mut self, key_event: KeyEvent) -> InputResult {
|
|
self.handle_key_event_with_activation_key(key_event, /*activation_key*/ None)
|
|
}
|
|
|
|
pub(crate) fn handle_key_event_with_activation_key(
|
|
&mut self,
|
|
key_event: KeyEvent,
|
|
activation_key: Option<KeyBinding>,
|
|
) -> InputResult {
|
|
let routed_key = activation_key.unwrap_or_else(|| KeyBinding::from_event(key_event));
|
|
if self.consume_view_transition_key(routed_key, key_event.kind) {
|
|
return InputResult::None;
|
|
}
|
|
if key_event.kind == KeyEventKind::Release {
|
|
// A modal may cover the config panel while its child editor is queued.
|
|
// Let the panel see the release so the next fresh press is not swallowed.
|
|
for view in &mut self.view_stack {
|
|
view.handle_key_release(key_event);
|
|
}
|
|
} else if matches!(key_event.kind, KeyEventKind::Press | KeyEventKind::Repeat)
|
|
&& self.view_stack.len() > 1
|
|
{
|
|
let covered_view_count = self.view_stack.len() - 1;
|
|
for view in &mut self.view_stack[..covered_view_count] {
|
|
view.observe_key_event_while_covered(key_event, routed_key);
|
|
}
|
|
}
|
|
let records_composer_activity =
|
|
matches!(key_event.kind, KeyEventKind::Press | KeyEventKind::Repeat)
|
|
&& !key_hint::has_ctrl_or_alt(key_event.modifiers)
|
|
&& matches!(
|
|
key_event.code,
|
|
KeyCode::Char(_)
|
|
| KeyCode::Backspace
|
|
| KeyCode::Delete
|
|
| KeyCode::Enter
|
|
| KeyCode::Tab
|
|
);
|
|
if self.warnings_active() {
|
|
if matches!(key_event.kind, KeyEventKind::Press | KeyEventKind::Repeat) {
|
|
self.record_composer_activity_at(Instant::now());
|
|
}
|
|
if self
|
|
.warnings_view
|
|
.as_mut()
|
|
.is_some_and(|view| view.handle_key(key_event))
|
|
&& let Some(view) = self.warnings_view.take()
|
|
{
|
|
self.suppress_warning_keep_repeat =
|
|
key_hint::plain(KeyCode::Char('k')).is_press(key_event);
|
|
view.close();
|
|
}
|
|
self.request_redraw();
|
|
return InputResult::None;
|
|
}
|
|
if self.view_stack.is_empty()
|
|
&& let Some(questions) = self.questions.as_mut().filter(|q| q.expanded)
|
|
{
|
|
questions
|
|
.composer
|
|
.copy_history_for_key(&self.composer, key_event);
|
|
questions.composer.set_task_running(self.is_task_running);
|
|
questions.handle_key_event(key_event);
|
|
if records_composer_activity {
|
|
self.record_composer_activity_at(Instant::now());
|
|
}
|
|
self.request_redraw();
|
|
self.schedule_active_view_frame();
|
|
return InputResult::None;
|
|
}
|
|
// If a modal/view is active, handle it here; otherwise forward to composer.
|
|
if !self.view_stack.is_empty() {
|
|
if key_event.kind == KeyEventKind::Release {
|
|
return InputResult::None;
|
|
}
|
|
|
|
// We need three pieces of information after routing the key:
|
|
// whether Esc completed the view, whether the view finished for any
|
|
// reason, and whether a paste-burst timer should be scheduled.
|
|
let (ctrl_c_completed, view_complete, completion, view_in_paste_burst) = {
|
|
let last_index = self.view_stack.len() - 1;
|
|
let view = &mut self.view_stack[last_index];
|
|
let prefer_esc =
|
|
key_event.code == KeyCode::Esc && view.prefer_esc_to_handle_key_event();
|
|
let ctrl_c_completed = key_event.code == KeyCode::Esc
|
|
&& !prefer_esc
|
|
&& matches!(view.on_ctrl_c(), CancellationEvent::Handled)
|
|
&& view.is_complete();
|
|
if ctrl_c_completed {
|
|
(true, true, view.completion(), false)
|
|
} else {
|
|
view.handle_key_event_with_activation_key(key_event, activation_key);
|
|
(
|
|
false,
|
|
view.is_complete(),
|
|
view.completion(),
|
|
view.is_in_paste_burst(),
|
|
)
|
|
}
|
|
};
|
|
|
|
if ctrl_c_completed {
|
|
self.pop_active_view_with_completion(completion);
|
|
if let Some(next_view) = self.view_stack.last()
|
|
&& next_view.is_in_paste_burst()
|
|
{
|
|
self.request_redraw_in(ChatComposer::recommended_paste_flush_delay());
|
|
}
|
|
} else if view_complete {
|
|
self.pop_active_view_with_completion(completion);
|
|
} else if view_in_paste_burst {
|
|
self.request_redraw_in(ChatComposer::recommended_paste_flush_delay());
|
|
}
|
|
self.request_redraw();
|
|
InputResult::None
|
|
} else {
|
|
if self.handle_inline_banner_key(key_event) {
|
|
return InputResult::None;
|
|
}
|
|
// Allow the configured interrupt while a task is running, even when its
|
|
// status row is hidden or the composer has focus.
|
|
// When a popup is active, prefer dismissing it over interrupting the task.
|
|
if self.should_interrupt_running_task(key_event) {
|
|
if let Some(status) = &self.status {
|
|
status.interrupt();
|
|
} else {
|
|
self.app_event_tx.interrupt();
|
|
}
|
|
self.request_redraw();
|
|
return InputResult::None;
|
|
}
|
|
let (input_result, needs_redraw) = self.composer.handle_key_event(key_event);
|
|
if records_composer_activity {
|
|
self.record_composer_activity_at(Instant::now());
|
|
}
|
|
if needs_redraw {
|
|
self.request_redraw();
|
|
}
|
|
if self.composer.is_in_paste_burst() {
|
|
self.request_redraw_in(ChatComposer::recommended_paste_flush_delay());
|
|
}
|
|
input_result
|
|
}
|
|
}
|
|
|
|
/// Return the contexts whose ordinary handlers can consume the next key.
|
|
pub(crate) fn keymap_contexts(&self) -> KeymapContextSet {
|
|
if self.warnings_active()
|
|
&& let Some(view) = &self.warnings_view
|
|
{
|
|
return view.keymap_contexts();
|
|
}
|
|
if let Some(view) = self.view_stack.last() {
|
|
view.keymap_contexts()
|
|
} else if let Some(questions) = self.questions.as_ref().filter(|q| q.expanded) {
|
|
questions.keymap_contexts()
|
|
} else {
|
|
self.composer.keymap_contexts()
|
|
}
|
|
}
|
|
|
|
/// Handles a Ctrl+C press within the bottom pane.
|
|
///
|
|
/// An active modal view is given the first chance to consume the key (typically to dismiss
|
|
/// itself). If no view is active, Ctrl+C cancels active history search before falling back to
|
|
/// clearing draft composer input.
|
|
///
|
|
/// This method may show the quit shortcut hint as a user-visible acknowledgement that Ctrl+C
|
|
/// was received, but it does not decide whether the process should exit; `ChatWidget` owns the
|
|
/// quit/interrupt state machine and uses the result to decide what happens next.
|
|
pub(crate) fn on_ctrl_c(&mut self) -> CancellationEvent {
|
|
if self.warnings_active() {
|
|
if let Some(view) = self.warnings_view.take() {
|
|
view.close();
|
|
}
|
|
self.request_redraw();
|
|
return CancellationEvent::Handled;
|
|
}
|
|
if self.view_stack.is_empty()
|
|
&& let Some(questions) = self.questions.as_mut().filter(|q| q.expanded)
|
|
{
|
|
return questions.on_ctrl_c();
|
|
}
|
|
if let Some(view) = self.view_stack.last_mut() {
|
|
let event = view.on_ctrl_c();
|
|
let view_complete = view.is_complete();
|
|
let completion = view.completion();
|
|
if matches!(event, CancellationEvent::Handled) {
|
|
if view_complete {
|
|
self.pop_active_view_with_completion(completion);
|
|
}
|
|
self.show_quit_shortcut_hint(key_hint::ctrl(KeyCode::Char('c')));
|
|
self.request_redraw();
|
|
}
|
|
event
|
|
} else if self.composer.cancel_vim_search() || self.composer.cancel_history_search() {
|
|
self.request_redraw();
|
|
CancellationEvent::Handled
|
|
} else if self.composer_is_empty() {
|
|
CancellationEvent::NotHandled
|
|
} else {
|
|
self.view_stack.pop();
|
|
self.clear_composer_for_ctrl_c();
|
|
self.show_quit_shortcut_hint(key_hint::ctrl(KeyCode::Char('c')));
|
|
self.request_redraw();
|
|
CancellationEvent::Handled
|
|
}
|
|
}
|
|
|
|
pub fn handle_paste(&mut self, pasted: String) {
|
|
self.interrupt_config_editor_transition();
|
|
if self.warnings_active() {
|
|
if !pasted.is_empty() {
|
|
self.record_composer_activity_at(Instant::now());
|
|
}
|
|
self.request_redraw();
|
|
return;
|
|
}
|
|
if self.view_stack.is_empty()
|
|
&& let Some(questions) = self.questions.as_mut().filter(|q| q.expanded)
|
|
{
|
|
questions.handle_paste(pasted);
|
|
self.record_composer_activity_at(Instant::now());
|
|
self.request_redraw();
|
|
return;
|
|
}
|
|
let has_pasted_text = !pasted.is_empty();
|
|
if let Some(view) = self.view_stack.last_mut() {
|
|
let needs_redraw = view.handle_paste(pasted);
|
|
let view_complete = view.is_complete();
|
|
if view_complete {
|
|
self.view_stack.clear();
|
|
self.on_active_view_complete();
|
|
}
|
|
if needs_redraw || view_complete {
|
|
self.request_redraw();
|
|
}
|
|
} else {
|
|
let needs_redraw = self.composer.handle_paste(pasted);
|
|
if has_pasted_text {
|
|
self.record_composer_activity_at(Instant::now());
|
|
}
|
|
if needs_redraw {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn insert_str(&mut self, text: &str) {
|
|
self.composer.insert_str(text);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn pre_draw_tick(&mut self) {
|
|
self.pre_draw_tick_at(Instant::now());
|
|
}
|
|
|
|
fn pre_draw_tick_at(&mut self, now: Instant) {
|
|
self.composer.sync_popups();
|
|
self.maybe_show_delayed_approval_requests_at(now);
|
|
self.tick_active_view(now);
|
|
self.schedule_active_view_frame();
|
|
}
|
|
|
|
fn tick_active_view(&mut self, now: Instant) {
|
|
let Some(view) = self.view_stack.last_mut() else {
|
|
return;
|
|
};
|
|
let needs_redraw = view.pre_draw_tick(now);
|
|
let view_complete = view.is_complete();
|
|
if view_complete {
|
|
self.view_stack.clear();
|
|
self.on_active_view_complete();
|
|
}
|
|
if needs_redraw || view_complete {
|
|
self.key_chord_reset_requested = true;
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
fn schedule_active_view_frame(&self) {
|
|
if let Some(questions) = &self.questions {
|
|
if let Some(delay) = questions.next_frame_delay() {
|
|
self.request_redraw_in(delay);
|
|
}
|
|
if questions.is_in_paste_burst() {
|
|
self.request_redraw_in(ChatComposer::recommended_paste_flush_delay());
|
|
}
|
|
}
|
|
if let Some(delay) = self.active_view().map_or_else(
|
|
|| self.composer.footer_flash_delay(),
|
|
BottomPaneView::next_frame_delay,
|
|
) {
|
|
self.request_redraw_in(delay);
|
|
}
|
|
}
|
|
|
|
/// Replace the composer text with `text`.
|
|
///
|
|
/// This is intended for fresh input where mention linkage does not need to
|
|
/// survive; it routes to `ChatComposer::set_text_content`, which resets
|
|
/// mention bindings.
|
|
pub(crate) fn set_composer_text(
|
|
&mut self,
|
|
text: String,
|
|
text_elements: Vec<TextElement>,
|
|
local_image_paths: Vec<PathBuf>,
|
|
) {
|
|
self.composer
|
|
.set_text_content(text, text_elements, local_image_paths);
|
|
self.composer.move_cursor_to_end();
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Replace the composer text while preserving mention link targets.
|
|
///
|
|
/// Use this when rehydrating a draft after a local validation/gating
|
|
/// failure (for example unsupported image submit) so previously selected
|
|
/// mention targets remain stable across retry.
|
|
pub(crate) fn set_composer_text_with_mention_bindings(
|
|
&mut self,
|
|
text: String,
|
|
text_elements: Vec<TextElement>,
|
|
local_image_paths: Vec<PathBuf>,
|
|
mention_bindings: Vec<MentionBinding>,
|
|
) {
|
|
self.composer.edit_stored_draft(|composer| {
|
|
composer.set_text_content_with_mention_bindings(
|
|
text,
|
|
text_elements,
|
|
local_image_paths,
|
|
mention_bindings,
|
|
);
|
|
composer.move_cursor_to_end();
|
|
});
|
|
self.request_redraw();
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub(crate) fn set_composer_input_enabled(
|
|
&mut self,
|
|
enabled: bool,
|
|
placeholder: Option<String>,
|
|
) {
|
|
self.composer.set_input_enabled(enabled, placeholder);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn show_shutdown_in_progress(&mut self) {
|
|
self.view_stack.clear();
|
|
self.warnings_view = None;
|
|
self.composer.show_shutdown_in_progress();
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn clear_composer_for_ctrl_c(&mut self) {
|
|
if let Some(text) = self.composer.clear_for_ctrl_c() {
|
|
if let Some(thread_id) = self.thread_id {
|
|
self.app_event_tx
|
|
.send(AppEvent::AppendMessageHistoryEntry { thread_id, text });
|
|
} else {
|
|
tracing::warn!(
|
|
"failed to append Ctrl+C-cleared draft to history: no active thread id"
|
|
);
|
|
}
|
|
}
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Get the current composer text (for tests and programmatic checks).
|
|
pub(crate) fn composer_text(&self) -> String {
|
|
self.composer.current_text()
|
|
}
|
|
|
|
pub(crate) fn composer_cursor(&self) -> usize {
|
|
self.composer.current_cursor()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn composer_text_elements(&self) -> Vec<TextElement> {
|
|
self.composer.text_elements()
|
|
}
|
|
|
|
pub(crate) fn composer_local_images(&self) -> Vec<LocalImageAttachment> {
|
|
self.composer.local_images()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn composer_local_image_paths(&self) -> Vec<PathBuf> {
|
|
self.composer.local_image_paths()
|
|
}
|
|
|
|
pub(crate) fn composer_text_with_pending(&self) -> String {
|
|
self.composer.current_text_with_pending()
|
|
}
|
|
|
|
/// Returns whether the composer currently accepts interactive draft edits.
|
|
pub(crate) fn composer_input_enabled(&self) -> bool {
|
|
self.composer.input_enabled()
|
|
}
|
|
|
|
pub(crate) fn composer_pending_pastes(&self) -> Vec<(String, String)> {
|
|
self.composer.draft_snapshot().pending_pastes
|
|
}
|
|
|
|
pub(crate) fn apply_external_edit(&mut self, text: String) {
|
|
self.composer.apply_external_edit(text);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_footer_hint_override(&mut self, items: Option<Vec<(String, String)>>) {
|
|
if let Some(view) = &mut self.warnings_view {
|
|
view.pending_hint = items.clone();
|
|
}
|
|
self.composer.set_footer_hint_override(items);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_voice_strip(&mut self, state: Option<VoiceStripState>) {
|
|
self.composer
|
|
.set_voice_strip(state, self.frame_requester.clone());
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_remote_image_urls(&mut self, urls: Vec<String>) {
|
|
self.composer
|
|
.edit_stored_draft(|composer| composer.set_remote_image_urls(urls));
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn remote_image_urls(&self) -> Vec<String> {
|
|
self.composer.remote_image_urls()
|
|
}
|
|
|
|
pub(crate) fn take_remote_image_urls(&mut self) -> Vec<String> {
|
|
let urls = self.composer.take_remote_image_urls();
|
|
self.request_redraw();
|
|
urls
|
|
}
|
|
|
|
pub(crate) fn set_composer_pending_pastes(&mut self, pending_pastes: Vec<(String, String)>) {
|
|
self.composer
|
|
.edit_stored_draft(|composer| composer.set_pending_pastes(pending_pastes));
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Update the status indicator header (defaults to "Working") and details below it.
|
|
///
|
|
/// Passing `None` clears any existing details. Returns whether the active status indicator
|
|
/// was updated and requested a redraw.
|
|
pub(crate) fn update_status(
|
|
&mut self,
|
|
header: String,
|
|
details: Option<String>,
|
|
details_capitalization: StatusDetailsCapitalization,
|
|
details_max_lines: usize,
|
|
) -> bool {
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.update_header(header);
|
|
status.update_details(details, details_capitalization, details_max_lines.max(1));
|
|
self.request_redraw();
|
|
return true;
|
|
}
|
|
false
|
|
}
|
|
|
|
/// Show the transient "press again to quit" hint for `key`.
|
|
///
|
|
/// `ChatWidget` owns the quit shortcut state machine (it decides when quit is
|
|
/// allowed), while the bottom pane owns rendering. We also schedule a redraw
|
|
/// after [`QUIT_SHORTCUT_TIMEOUT`] so the hint disappears even if the user
|
|
/// stops typing and no other events trigger a draw.
|
|
pub(crate) fn show_quit_shortcut_hint(&mut self, key: KeyBinding) {
|
|
if !DOUBLE_PRESS_QUIT_SHORTCUT_ENABLED {
|
|
return;
|
|
}
|
|
|
|
self.composer
|
|
.show_quit_shortcut_hint(key, self.has_input_focus);
|
|
let frame_requester = self.frame_requester.clone();
|
|
if let Ok(handle) = tokio::runtime::Handle::try_current() {
|
|
handle.spawn(async move {
|
|
tokio::time::sleep(QUIT_SHORTCUT_TIMEOUT).await;
|
|
frame_requester.schedule_frame();
|
|
});
|
|
} else {
|
|
// In tests (and other non-Tokio contexts), fall back to a thread so
|
|
// the hint can still expire without requiring an explicit draw.
|
|
std::thread::spawn(move || {
|
|
std::thread::sleep(QUIT_SHORTCUT_TIMEOUT);
|
|
frame_requester.schedule_frame();
|
|
});
|
|
}
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Clear the "press again to quit" hint immediately.
|
|
pub(crate) fn clear_quit_shortcut_hint(&mut self) {
|
|
self.composer.clear_quit_shortcut_hint(self.has_input_focus);
|
|
self.request_redraw();
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn quit_shortcut_hint_visible(&self) -> bool {
|
|
self.composer.quit_shortcut_hint_visible()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn status_indicator_visible(&self) -> bool {
|
|
self.status_widget().is_some()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn status_line_text(&self) -> Option<String> {
|
|
self.composer.status_line_text()
|
|
}
|
|
|
|
pub(crate) fn show_esc_backtrack_hint(&mut self) {
|
|
self.esc_backtrack_hint = true;
|
|
self.composer.set_esc_backtrack_hint(/*show*/ 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(/*show*/ 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 {
|
|
self.status_timer.reset(Duration::ZERO);
|
|
if self.status.is_none() {
|
|
self.status = Some(StatusIndicatorWidget::new(
|
|
self.app_event_tx.clone(),
|
|
self.frame_requester.clone(),
|
|
self.animations_enabled,
|
|
self.effects,
|
|
));
|
|
}
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.set_interrupt_hint_visible(/*visible*/ true);
|
|
status.set_interrupt_binding(
|
|
self.keymap
|
|
.primary_hint(KeymapContext::Chat, "interrupt_turn"),
|
|
);
|
|
}
|
|
self.sync_status_inline_message();
|
|
self.request_redraw();
|
|
}
|
|
} else {
|
|
// Hide the status indicator when a task completes, but keep other modal views.
|
|
self.hide_status_indicator();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_queue_submissions(&mut self, queue_submissions: bool) {
|
|
self.composer.set_queue_submissions(queue_submissions);
|
|
}
|
|
|
|
/// 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.get_or_insert_with(|| {
|
|
StatusIndicatorWidget::new(
|
|
self.app_event_tx.clone(),
|
|
self.frame_requester.clone(),
|
|
self.animations_enabled,
|
|
self.effects,
|
|
)
|
|
});
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.set_interrupt_binding(
|
|
self.keymap
|
|
.primary_hint(KeymapContext::Chat, "interrupt_turn"),
|
|
);
|
|
}
|
|
self.sync_status_inline_message();
|
|
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();
|
|
}
|
|
|
|
pub(crate) fn set_context_window_pending(&mut self, pending: bool) {
|
|
self.composer.set_context_window_pending(pending);
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Show a generic list selection view with the provided items.
|
|
pub(crate) fn show_selection_view(
|
|
&mut self,
|
|
mut params: list_selection_view::SelectionViewParams,
|
|
) {
|
|
self.apply_standard_popup_hint(&mut params);
|
|
let view = list_selection_view::ListSelectionView::new(
|
|
params,
|
|
self.app_event_tx.clone(),
|
|
self.keymap.list.clone(),
|
|
);
|
|
self.push_view(Box::new(view));
|
|
}
|
|
|
|
fn apply_standard_popup_hint(&self, params: &mut list_selection_view::SelectionViewParams) {
|
|
// Configured list actions take precedence over optional row shortcuts.
|
|
for item in &mut params.items {
|
|
if item.secondary_action.as_ref().is_some_and(|secondary| {
|
|
let (code, modifiers) = secondary.key.parts();
|
|
self.keymap
|
|
.list
|
|
.action_for(KeyEvent::new(code, modifiers))
|
|
.is_some()
|
|
}) {
|
|
item.secondary_action = None;
|
|
}
|
|
}
|
|
if !params.allow_cancel {
|
|
if params.footer_hint.is_none()
|
|
|| params.footer_hint.as_ref() == Some(&popup_consts::standard_popup_hint_line())
|
|
{
|
|
params.footer_hint = None;
|
|
}
|
|
return;
|
|
}
|
|
if params.footer_hint.is_none()
|
|
|| params.footer_hint.as_ref() == Some(&popup_consts::standard_popup_hint_line())
|
|
{
|
|
params.footer_hint = Some(popup_consts::picker_hint_line_for_keymap(&self.keymap.list));
|
|
}
|
|
}
|
|
|
|
/// Replace the active selection view when it matches `view_id`.
|
|
pub(crate) fn replace_selection_view_if_active(
|
|
&mut self,
|
|
view_id: &'static str,
|
|
mut params: list_selection_view::SelectionViewParams,
|
|
) -> bool {
|
|
let is_match = self
|
|
.view_stack
|
|
.last()
|
|
.is_some_and(|view| view.view_id() == Some(view_id));
|
|
if !is_match {
|
|
return false;
|
|
}
|
|
|
|
let search_query = if params.is_searchable {
|
|
self.view_stack
|
|
.last()
|
|
.and_then(|view| view.search_query())
|
|
.map(str::to_string)
|
|
} else {
|
|
None
|
|
};
|
|
self.view_stack.pop();
|
|
self.apply_standard_popup_hint(&mut params);
|
|
let mut view = list_selection_view::ListSelectionView::new(
|
|
params,
|
|
self.app_event_tx.clone(),
|
|
self.keymap.list.clone(),
|
|
);
|
|
if let Some(search_query) = search_query {
|
|
view.set_search_query(search_query);
|
|
}
|
|
self.push_view(Box::new(view));
|
|
true
|
|
}
|
|
|
|
/// Replace the newest matching selection view without disturbing views stacked above it.
|
|
/// Preserve pending parent cleanup when an already-open child is accepted.
|
|
pub(crate) fn replace_selection_view_if_present(
|
|
&mut self,
|
|
view_id: &'static str,
|
|
mut params: list_selection_view::SelectionViewParams,
|
|
) -> bool {
|
|
let Some(index) = self
|
|
.view_stack
|
|
.iter()
|
|
.rposition(|view| view.view_id() == Some(view_id))
|
|
else {
|
|
return false;
|
|
};
|
|
|
|
let replaces_active_view = index + 1 == self.view_stack.len();
|
|
self.apply_standard_popup_hint(&mut params);
|
|
let mut view = list_selection_view::ListSelectionView::new(
|
|
params,
|
|
self.app_event_tx.clone(),
|
|
self.keymap.list.clone(),
|
|
);
|
|
view.dismiss_after_child_accept = self.view_stack[index].dismiss_after_child_accept();
|
|
self.view_stack[index] = Box::new(view);
|
|
if replaces_active_view {
|
|
self.key_chord_reset_requested = true;
|
|
self.schedule_active_view_frame();
|
|
}
|
|
self.request_redraw();
|
|
true
|
|
}
|
|
|
|
pub(crate) fn replace_view_if_present(
|
|
&mut self,
|
|
view_id: &'static str,
|
|
view: Box<dyn BottomPaneView>,
|
|
) {
|
|
if let Some(index) = self
|
|
.view_stack
|
|
.iter()
|
|
.rposition(|existing| existing.view_id() == Some(view_id))
|
|
{
|
|
self.view_stack[index] = view;
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn list_keymap(&self) -> crate::keymap::ListKeymap {
|
|
self.keymap.list.clone()
|
|
}
|
|
|
|
/// Replace one or more active views whose IDs are in `view_ids` with a
|
|
/// generic list selection view.
|
|
pub(crate) fn replace_active_views_with_selection_view(
|
|
&mut self,
|
|
view_ids: &[&'static str],
|
|
mut params: list_selection_view::SelectionViewParams,
|
|
) -> bool {
|
|
let is_match = self
|
|
.view_stack
|
|
.last()
|
|
.and_then(|view| view.view_id())
|
|
.is_some_and(|view_id| view_ids.contains(&view_id));
|
|
if !is_match {
|
|
return false;
|
|
}
|
|
|
|
while self
|
|
.view_stack
|
|
.last()
|
|
.and_then(|view| view.view_id())
|
|
.is_some_and(|view_id| view_ids.contains(&view_id))
|
|
{
|
|
self.view_stack.pop();
|
|
}
|
|
self.apply_standard_popup_hint(&mut params);
|
|
let view = list_selection_view::ListSelectionView::new(
|
|
params,
|
|
self.app_event_tx.clone(),
|
|
self.keymap.list.clone(),
|
|
);
|
|
self.push_view(Box::new(view));
|
|
true
|
|
}
|
|
|
|
pub(crate) fn selected_index_for_active_view(&self, view_id: &'static str) -> Option<usize> {
|
|
self.view_stack
|
|
.last()
|
|
.filter(|view| view.view_id() == Some(view_id))
|
|
.and_then(|view| view.selected_index())
|
|
}
|
|
|
|
pub(crate) fn selected_index_for_present_view(&self, view_id: &'static str) -> Option<usize> {
|
|
self.view_stack
|
|
.iter()
|
|
.rfind(|view| view.view_id() == Some(view_id))
|
|
.and_then(|view| view.selected_index())
|
|
}
|
|
|
|
pub(crate) fn active_tab_id_for_active_view(&self, view_id: &'static str) -> Option<&str> {
|
|
self.view_stack
|
|
.last()
|
|
.filter(|view| view.view_id() == Some(view_id))
|
|
.and_then(|view| view.active_tab_id())
|
|
}
|
|
|
|
/// Forward a suggestion to its matching prompt, even beneath another view.
|
|
pub(crate) fn apply_text_suggestion(
|
|
&mut self,
|
|
request_id: uuid::Uuid,
|
|
suggestion: Option<&str>,
|
|
) -> bool {
|
|
let changed = self
|
|
.view_stack
|
|
.iter_mut()
|
|
.rev()
|
|
.any(|view| view.apply_text_suggestion(request_id, suggestion));
|
|
|
|
if changed {
|
|
self.request_redraw();
|
|
}
|
|
|
|
changed
|
|
}
|
|
|
|
pub(crate) fn dismiss_active_view_if_id(&mut self, view_id: &'static str) -> bool {
|
|
let is_match = self
|
|
.view_stack
|
|
.last()
|
|
.is_some_and(|view| view.view_id() == Some(view_id));
|
|
if !is_match {
|
|
return false;
|
|
}
|
|
|
|
self.key_chord_reset_requested = true;
|
|
self.view_stack.pop();
|
|
self.request_redraw();
|
|
true
|
|
}
|
|
|
|
/// Dismiss the newest matching view without disturbing views stacked above it.
|
|
pub(crate) fn dismiss_view_by_id(&mut self, view_id: &'static str) -> bool {
|
|
let Some(index) = self
|
|
.view_stack
|
|
.iter()
|
|
.rposition(|view| view.view_id() == Some(view_id))
|
|
else {
|
|
return false;
|
|
};
|
|
|
|
let removed_active_view = index + 1 == self.view_stack.len();
|
|
self.view_stack.remove(index);
|
|
if removed_active_view {
|
|
self.key_chord_reset_requested = true;
|
|
self.schedule_active_view_frame();
|
|
}
|
|
self.request_redraw();
|
|
true
|
|
}
|
|
|
|
/// Update the pending-input preview shown above the composer.
|
|
pub(crate) fn set_pending_input_preview(
|
|
&mut self,
|
|
queued: Vec<String>,
|
|
pending_steers: Vec<String>,
|
|
rejected_steers: Vec<String>,
|
|
) {
|
|
self.pending_input_preview.pending_steers = pending_steers;
|
|
self.pending_input_preview.rejected_steers = rejected_steers;
|
|
self.pending_input_preview.queued_messages = queued;
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Update the inactive-thread approval list shown above the composer.
|
|
pub(crate) fn set_pending_thread_approvals(&mut self, threads: Vec<String>) {
|
|
if self.pending_thread_approvals.set_threads(threads) {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn pending_thread_approvals(&self) -> &[String] {
|
|
self.pending_thread_approvals.threads()
|
|
}
|
|
|
|
/// Update the unified-exec process set and refresh whichever summary surface is active.
|
|
///
|
|
/// The summary may be displayed inline in the status row or as a dedicated
|
|
/// footer row depending on whether a status indicator is currently visible.
|
|
pub(crate) fn set_unified_exec_processes(&mut self, processes: Vec<String>) {
|
|
if self.unified_exec_footer.set_processes(processes) {
|
|
self.sync_status_inline_message();
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
/// Update hook activity after the lifecycle reveal delay, even outside a turn.
|
|
pub(crate) fn set_hook_status_message(&mut self, message: Option<String>) {
|
|
if self.hook_status_message == message {
|
|
return;
|
|
}
|
|
|
|
self.hook_status_message = message;
|
|
if self.hook_status_message.is_some() && self.status.is_none() && self.is_task_running() {
|
|
self.ensure_status_indicator();
|
|
} else {
|
|
self.sync_status_inline_message();
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
/// Copy background activity and hook text into the active status row, if any.
|
|
///
|
|
/// This keeps status-line inline text synchronized without forcing the
|
|
/// standalone unified-exec footer row to be visible.
|
|
fn sync_status_inline_message(&mut self) {
|
|
if let Some(status) = self.status.as_mut() {
|
|
status.update_inline_message(self.unified_exec_footer.summary_text());
|
|
status.update_hook_status_message(self.hook_status_message.clone());
|
|
}
|
|
}
|
|
|
|
pub(crate) fn composer_is_empty(&self) -> bool {
|
|
self.composer.is_empty()
|
|
}
|
|
|
|
pub(crate) fn composer_is_vim_enabled(&self) -> bool {
|
|
self.composer.is_vim_enabled()
|
|
}
|
|
|
|
pub(crate) fn composer_should_handle_vim_insert_escape(&self, key_event: KeyEvent) -> bool {
|
|
self.composer.should_handle_vim_insert_escape(key_event)
|
|
}
|
|
|
|
pub(crate) fn is_task_running(&self) -> bool {
|
|
self.is_task_running
|
|
}
|
|
|
|
pub(crate) fn should_interrupt_running_task(&self, key_event: KeyEvent) -> bool {
|
|
let is_agent_command = self
|
|
.composer_text()
|
|
.lines()
|
|
.next()
|
|
.and_then(parse_slash_name)
|
|
.is_some_and(|(name, _, _)| matches!(name, "agents" | "subagents"));
|
|
|
|
self.keymap.chat.interrupt_turn.is_pressed(key_event)
|
|
&& !(self.shortcut_overlay_visible()
|
|
&& key_hint::plain(KeyCode::Esc).is_press(key_event))
|
|
&& self.is_task_running
|
|
&& !(is_agent_command && key_event.code == KeyCode::Esc)
|
|
&& self.no_modal_or_popup_active()
|
|
&& !self.composer_should_handle_vim_insert_escape(key_event)
|
|
}
|
|
|
|
pub(crate) fn terminal_title_requires_action(&self) -> bool {
|
|
self.questions
|
|
.as_ref()
|
|
.is_some_and(|q| q.unanswered_count() > 0)
|
|
|| self
|
|
.active_view()
|
|
.is_some_and(bottom_pane_view::BottomPaneView::terminal_title_requires_action)
|
|
}
|
|
|
|
pub(crate) fn has_centered_view(&self) -> bool {
|
|
self.active_view()
|
|
.is_some_and(|view| view.presentation() == ViewPresentation::Centered)
|
|
}
|
|
|
|
pub(crate) fn has_active_view(&self) -> bool {
|
|
self.warnings_view.is_some() || self.has_active_modal()
|
|
}
|
|
|
|
/// Warnings own input without replacing the composer with an interactive modal.
|
|
pub(crate) fn has_active_modal(&self) -> bool {
|
|
!self.view_stack.is_empty()
|
|
}
|
|
|
|
pub(crate) fn active_view_accepts_input_when_disconnected(&self) -> bool {
|
|
self.active_view()
|
|
.is_some_and(BottomPaneView::accepts_input_when_disconnected)
|
|
}
|
|
|
|
pub(crate) fn active_view_will_interrupt_turn_on_key_event(&self, key_event: KeyEvent) -> bool {
|
|
self.is_task_running
|
|
&& self
|
|
.active_view()
|
|
.is_some_and(|view| view.will_interrupt_turn_on_key_event(key_event))
|
|
}
|
|
|
|
pub(crate) fn active_view_id(&self) -> Option<&'static str> {
|
|
self.view_stack.last().and_then(|view| view.view_id())
|
|
}
|
|
|
|
/// 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.shortcut_overlay_visible()
|
|
&& self.can_launch_external_editor()
|
|
&& !self.inline_banner_accepts_dismissal()
|
|
}
|
|
|
|
pub(crate) fn shortcut_overlay_visible(&self) -> bool {
|
|
self.no_modal_or_popup_active() && self.composer.shortcut_overlay_visible()
|
|
}
|
|
|
|
/// Return true when no popups or modal views are active, regardless of task state.
|
|
pub(crate) fn can_launch_external_editor(&self) -> bool {
|
|
!self.has_active_view()
|
|
&& !self.composer.popup_active()
|
|
&& !self.questions.as_ref().is_some_and(|q| q.expanded)
|
|
}
|
|
|
|
/// Returns true when the bottom pane has no active modal view and no active composer popup.
|
|
///
|
|
/// This is the UI-level definition of "no modal/popup is active" for key routing decisions.
|
|
/// It intentionally does not include task state, since some actions are safe while a task is
|
|
/// running and some are not.
|
|
pub(crate) fn no_modal_or_popup_active(&self) -> bool {
|
|
self.can_launch_external_editor()
|
|
}
|
|
|
|
pub(crate) fn clear_composer_selection(&mut self) {
|
|
self.composer.clear_mouse_selection();
|
|
}
|
|
|
|
pub(crate) fn end_composer_drag(&mut self) {
|
|
self.composer.end_mouse_drag();
|
|
}
|
|
|
|
pub(crate) fn finish_composer_copy(
|
|
&mut self,
|
|
completion: &(u64, crate::clipboard_copy::worker::CopyResult),
|
|
visible: bool,
|
|
) -> Option<usize> {
|
|
let current = visible && !self.has_active_view();
|
|
self.composer.finish_copy(completion, current)
|
|
}
|
|
|
|
pub(crate) fn copy_composer_selection(
|
|
&mut self,
|
|
event: &crate::tui::TuiEvent,
|
|
copy: impl FnOnce(&str) -> Result<crate::clipboard_copy::CopyStatus, String>,
|
|
) -> Option<(usize, Result<crate::clipboard_copy::CopyStatus, String>)> {
|
|
if self.has_active_view() || self.questions.as_ref().is_some_and(|q| q.expanded) {
|
|
return None;
|
|
}
|
|
self.composer.copy_selection(event, copy)
|
|
}
|
|
|
|
pub(crate) fn can_paste_on_right_click(&self) -> bool {
|
|
self.no_modal_or_popup_active() && self.composer.can_paste_on_right_click()
|
|
}
|
|
|
|
pub(crate) fn prepare_composer_mouse(&mut self, event: crossterm::event::MouseEvent) -> bool {
|
|
if event.kind != crossterm::event::MouseEventKind::Moved {
|
|
self.view_transition_key_guard = None;
|
|
}
|
|
if self.has_active_view() || self.questions.as_ref().is_some_and(|q| q.expanded) {
|
|
self.composer.end_mouse_drag();
|
|
return false;
|
|
}
|
|
self.composer.prepare_mouse(event)
|
|
}
|
|
|
|
pub(crate) fn handle_composer_mouse(&mut self, event: crossterm::event::MouseEvent) -> bool {
|
|
self.composer.handle_mouse(event)
|
|
}
|
|
|
|
pub(crate) fn show_view(&mut self, view: Box<dyn BottomPaneView>) {
|
|
self.push_view(view);
|
|
}
|
|
|
|
pub(crate) fn suppress_current_view_key_until_release(
|
|
&mut self,
|
|
key: KeyBinding,
|
|
activated_at: Instant,
|
|
) {
|
|
self.view_transition_key_guard =
|
|
Some(crate::activation_key_guard::ActivationKeyGuard::new_at(
|
|
key,
|
|
activated_at,
|
|
self.enhanced_keys_supported,
|
|
));
|
|
}
|
|
|
|
pub(crate) fn consume_view_transition_key_event(&mut self, key_event: KeyEvent) -> bool {
|
|
self.consume_view_transition_key(KeyBinding::from_event(key_event), key_event.kind)
|
|
}
|
|
|
|
fn consume_view_transition_key(&mut self, key: KeyBinding, kind: KeyEventKind) -> bool {
|
|
let Some(guard) = self.view_transition_key_guard.as_mut() else {
|
|
return false;
|
|
};
|
|
let consumed = guard.consume(key, kind);
|
|
if !guard.is_active() {
|
|
self.view_transition_key_guard = None;
|
|
}
|
|
consumed
|
|
}
|
|
|
|
/// Show a text prompt with the composer's current editing preferences.
|
|
pub(crate) fn show_text_prompt(&mut self, mut view: custom_prompt_view::CustomPromptView) {
|
|
view.set_keymap_bindings(&self.keymap);
|
|
if self.composer_is_vim_enabled() {
|
|
view.enable_vim_in_insert_mode();
|
|
}
|
|
self.push_view(Box::new(view));
|
|
}
|
|
|
|
/// Called when the agent requests user approval.
|
|
pub fn push_approval_request(&mut self, request: ApprovalRequest, features: &Features) {
|
|
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
|
|
};
|
|
|
|
let now = Instant::now();
|
|
if !self.delayed_approval_requests.is_empty()
|
|
|| self.approval_prompt_delay_remaining(now).is_some()
|
|
{
|
|
self.delayed_approval_requests
|
|
.push_back(DelayedApprovalRequest {
|
|
request,
|
|
features: features.clone(),
|
|
});
|
|
self.maybe_show_delayed_approval_requests_at(now);
|
|
} else {
|
|
// No recent composer activity, so show the approval modal immediately.
|
|
let modal = ApprovalOverlay::new(
|
|
request,
|
|
self.app_event_tx.clone(),
|
|
features.clone(),
|
|
self.keymap.approval.clone(),
|
|
self.keymap.list.clone(),
|
|
);
|
|
self.pause_status_timer_for_modal();
|
|
self.push_view(Box::new(modal));
|
|
}
|
|
}
|
|
|
|
/// Called when the agent requests user input.
|
|
pub fn push_user_input_request(&mut self, request: ToolRequestUserInputParams) {
|
|
let request = if let Some(view) = self.view_stack.last_mut() {
|
|
match view.try_consume_user_input_request(request) {
|
|
Some(request) => request,
|
|
None => {
|
|
self.request_redraw();
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
request
|
|
};
|
|
|
|
let modal = RequestUserInputOverlay::new_with_keymap(
|
|
request,
|
|
self.app_event_tx.clone(),
|
|
self.has_input_focus,
|
|
self.enhanced_keys_supported,
|
|
self.disable_paste_burst,
|
|
self.keymap.clone(),
|
|
);
|
|
self.pause_status_timer_for_modal();
|
|
self.set_composer_input_enabled(
|
|
/*enabled*/ false,
|
|
Some("Answer the questions to continue.".to_string()),
|
|
);
|
|
self.push_view(Box::new(modal));
|
|
}
|
|
|
|
pub(crate) fn push_mcp_server_elicitation_request(
|
|
&mut self,
|
|
request: McpServerElicitationFormRequest,
|
|
) {
|
|
let request = if let Some(view) = self.view_stack.last_mut() {
|
|
match view.try_consume_mcp_server_elicitation_request(request) {
|
|
Some(request) => request,
|
|
None => {
|
|
self.request_redraw();
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
request
|
|
};
|
|
|
|
if let Some(tool_suggestion) = request.tool_suggestion()
|
|
&& let Some(install_url) = tool_suggestion.install_url.clone()
|
|
{
|
|
let Some(install_url) = app_link_view::validate_external_url(
|
|
&install_url,
|
|
/*require_chatgpt_host*/ false,
|
|
) else {
|
|
self.app_event_tx.resolve_elicitation(
|
|
request.thread_id(),
|
|
request.server_name().to_string(),
|
|
request.request_id().clone(),
|
|
codex_app_server_protocol::McpServerElicitationAction::Decline,
|
|
/*content*/ None,
|
|
/*meta*/ None,
|
|
);
|
|
return;
|
|
};
|
|
let suggestion_type = match tool_suggestion.suggest_type {
|
|
mcp_server_elicitation::ToolSuggestionType::Install => {
|
|
AppLinkSuggestionType::Install
|
|
}
|
|
mcp_server_elicitation::ToolSuggestionType::Enable => AppLinkSuggestionType::Enable,
|
|
};
|
|
let is_installed = matches!(
|
|
tool_suggestion.suggest_type,
|
|
mcp_server_elicitation::ToolSuggestionType::Enable
|
|
);
|
|
let view = AppLinkView::new_with_keymap(
|
|
AppLinkViewParams {
|
|
app_id: tool_suggestion.tool_id.clone(),
|
|
title: tool_suggestion.tool_name.clone(),
|
|
description: None,
|
|
instructions: match suggestion_type {
|
|
AppLinkSuggestionType::Install => {
|
|
"Install this app in your browser, then return here.".to_string()
|
|
}
|
|
AppLinkSuggestionType::Enable => {
|
|
"Enable this app to use it for the current request.".to_string()
|
|
}
|
|
AppLinkSuggestionType::Auth => unreachable!(
|
|
"auth uses URL mode elicitation, not tool suggestion forms"
|
|
),
|
|
AppLinkSuggestionType::ExternalAction => unreachable!(
|
|
"external actions use URL mode elicitation, not tool suggestion forms"
|
|
),
|
|
},
|
|
url: install_url.into(),
|
|
is_installed,
|
|
is_enabled: false,
|
|
suggest_reason: Some(tool_suggestion.suggest_reason.clone()),
|
|
suggestion_type: Some(suggestion_type),
|
|
elicitation_target: Some(AppLinkElicitationTarget {
|
|
thread_id: request.thread_id(),
|
|
server_name: request.server_name().to_string(),
|
|
request_id: request.request_id().clone(),
|
|
}),
|
|
},
|
|
self.app_event_tx.clone(),
|
|
self.keymap.list.clone(),
|
|
);
|
|
self.pause_status_timer_for_modal();
|
|
self.set_composer_input_enabled(
|
|
/*enabled*/ false,
|
|
Some("Respond to the tool suggestion to continue.".to_string()),
|
|
);
|
|
self.push_view(Box::new(view));
|
|
return;
|
|
}
|
|
|
|
let modal = McpServerElicitationOverlay::new_with_keymap(
|
|
request,
|
|
self.app_event_tx.clone(),
|
|
self.has_input_focus,
|
|
self.enhanced_keys_supported,
|
|
self.disable_paste_burst,
|
|
self.keymap.clone(),
|
|
);
|
|
self.pause_status_timer_for_modal();
|
|
self.set_composer_input_enabled(
|
|
/*enabled*/ false,
|
|
Some("Respond to the MCP server request to continue.".to_string()),
|
|
);
|
|
self.push_view(Box::new(modal));
|
|
}
|
|
|
|
pub(crate) fn dismiss_app_server_request(
|
|
&mut self,
|
|
request: &ResolvedAppServerRequest,
|
|
) -> bool {
|
|
let delayed_len = self.delayed_approval_requests.len();
|
|
self.delayed_approval_requests
|
|
.retain(|delayed| !delayed.request.matches_resolved_request(request));
|
|
let delayed_changed = self.delayed_approval_requests.len() != delayed_len;
|
|
|
|
if self.view_stack.is_empty() {
|
|
if delayed_changed {
|
|
self.request_redraw();
|
|
}
|
|
return delayed_changed;
|
|
}
|
|
|
|
let mut changed = delayed_changed;
|
|
let mut completed_indices = Vec::new();
|
|
for index in (0..self.view_stack.len()).rev() {
|
|
let view = &mut self.view_stack[index];
|
|
if !view.dismiss_app_server_request(request) {
|
|
continue;
|
|
}
|
|
changed = true;
|
|
if view.is_complete() {
|
|
completed_indices.push(index);
|
|
}
|
|
}
|
|
if !changed {
|
|
return false;
|
|
}
|
|
for index in completed_indices {
|
|
self.view_stack.remove(index);
|
|
}
|
|
self.on_view_stack_depth_decreased();
|
|
self.request_redraw();
|
|
true
|
|
}
|
|
|
|
fn on_active_view_complete(&mut self) {
|
|
self.resume_status_timer_after_modal();
|
|
self.set_composer_input_enabled(/*enabled*/ true, /*placeholder*/ None);
|
|
}
|
|
|
|
fn pause_status_timer_for_modal(&mut self) {
|
|
self.status_timer.pause_at(Instant::now());
|
|
}
|
|
|
|
fn resume_status_timer_after_modal(&mut self) {
|
|
self.status_timer.resume_at(Instant::now());
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// 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,
|
|
thread_id: ThreadId,
|
|
log_id: u64,
|
|
entry_count: usize,
|
|
) {
|
|
self.thread_id = Some(thread_id);
|
|
self.composer
|
|
.set_history_metadata(thread_id, log_id, entry_count);
|
|
}
|
|
|
|
pub(crate) fn flush_paste_burst_if_due(&mut self) -> bool {
|
|
// Every editor can retain buffered input after losing focus. Flush all
|
|
// of them, matching the buffers that can defer drawing below.
|
|
let mut flushed = self.composer.flush_paste_burst_if_due();
|
|
if let Some(view) = self.view_stack.last_mut() {
|
|
flushed |= view.flush_paste_burst_if_due();
|
|
}
|
|
if let Some(questions) = &mut self.questions {
|
|
flushed |= questions.flush_paste_burst_if_due();
|
|
}
|
|
flushed
|
|
}
|
|
|
|
pub(crate) fn is_in_paste_burst(&self) -> bool {
|
|
self.view_stack
|
|
.last()
|
|
.is_some_and(|view| view.is_in_paste_burst())
|
|
|| self
|
|
.questions
|
|
.as_deref()
|
|
.is_some_and(bottom_pane_view::BottomPaneView::is_in_paste_burst)
|
|
|| self.composer.is_in_paste_burst()
|
|
}
|
|
|
|
pub(crate) fn on_history_lookup_response(&mut self, response: HistoryLookupResponse) {
|
|
let mut updated = false;
|
|
for composer in std::iter::once(&mut self.composer)
|
|
.chain(self.questions.iter_mut().map(|q| &mut q.composer))
|
|
{
|
|
updated |= match response.clone() {
|
|
HistoryLookupResponse::Entry {
|
|
offset,
|
|
log_id,
|
|
entry,
|
|
} => composer.on_history_entry_response(log_id, offset, entry),
|
|
HistoryLookupResponse::Batch {
|
|
cursor,
|
|
log_id,
|
|
entries,
|
|
next_older_cursor,
|
|
} => composer.on_history_batch_response(log_id, cursor, entries, next_older_cursor),
|
|
HistoryLookupResponse::BatchError { cursor, log_id } => {
|
|
composer.on_history_batch_error(log_id, cursor)
|
|
}
|
|
};
|
|
}
|
|
if updated {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn record_replayed_user_message_history(&mut self, entry: HistoryEntry) {
|
|
self.composer.record_replayed_user_message_history(entry);
|
|
}
|
|
|
|
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) {
|
|
if !self.has_active_view() {
|
|
self.composer.attach_image(path);
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn take_recent_submission_images(&mut self) -> Vec<PathBuf> {
|
|
self.composer.take_recent_submission_images()
|
|
}
|
|
|
|
pub(crate) fn take_recent_submission_images_with_placeholders(
|
|
&mut self,
|
|
) -> Vec<LocalImageAttachment> {
|
|
self.composer
|
|
.take_recent_submission_images_with_placeholders()
|
|
}
|
|
|
|
pub(crate) fn prepare_inline_args_submission(
|
|
&mut self,
|
|
record_history: bool,
|
|
) -> Option<(String, Vec<TextElement>)> {
|
|
self.composer.prepare_inline_args_submission(record_history)
|
|
}
|
|
|
|
fn as_renderable(&'_ self) -> RenderableItem<'_> {
|
|
self.as_renderable_with_options(ComposerRenderOptions::default())
|
|
}
|
|
|
|
pub(crate) fn as_renderable_with_options<'a>(
|
|
&'a self,
|
|
options: ComposerRenderOptions<'a>,
|
|
) -> RenderableItem<'a> {
|
|
self.renderable_for_views(options, &self.view_stack)
|
|
}
|
|
|
|
pub(crate) fn centered_dialog(&self) -> Option<CenteredView<'_>> {
|
|
self.active_view()
|
|
.filter(|view| {
|
|
!self.warnings_active() && view.presentation() == ViewPresentation::Centered
|
|
})
|
|
.map(CenteredView)
|
|
}
|
|
|
|
pub(crate) fn backdrop_with_options<'a>(
|
|
&'a self,
|
|
options: ComposerRenderOptions<'a>,
|
|
) -> RenderableItem<'a> {
|
|
let views = if self.centered_dialog().is_some() {
|
|
&self.view_stack[..self.view_stack.len() - 1]
|
|
} else {
|
|
&self.view_stack
|
|
};
|
|
self.renderable_for_views(options, views)
|
|
}
|
|
|
|
fn renderable_for_views<'a>(
|
|
&'a self,
|
|
mut options: ComposerRenderOptions<'a>,
|
|
views: &'a [Box<dyn BottomPaneView>],
|
|
) -> RenderableItem<'a> {
|
|
if self.warnings_active()
|
|
&& let Some(warnings) = &self.warnings_view
|
|
{
|
|
return RenderableItem::Borrowed(warnings);
|
|
}
|
|
if (self.is_task_running || !self.view_stack.is_empty())
|
|
&& let Some(banner) = &self.inline_banner
|
|
{
|
|
banner.visible.set(false);
|
|
}
|
|
if let Some(view) = views.last() {
|
|
if view.presentation() == ViewPresentation::Centered {
|
|
RenderableItem::Owned(Box::new(view_stack::ViewStack(views)))
|
|
} else {
|
|
RenderableItem::Borrowed(view.as_ref())
|
|
}
|
|
} else {
|
|
let mut flex = FlexRenderable::new();
|
|
if let Some(banner) = self
|
|
.inline_banner
|
|
.as_ref()
|
|
.filter(|_| !self.is_task_running)
|
|
{
|
|
flex.push(/*flex*/ 0, RenderableItem::Borrowed(banner));
|
|
}
|
|
if let Some(status) = self.status_widget() {
|
|
flex.push(
|
|
/*flex*/ 0,
|
|
RenderableItem::Owned(Box::new(status.with_timer(&self.status_timer))),
|
|
);
|
|
}
|
|
if self.status.is_none()
|
|
&& let Some(message) = &self.hook_status_message
|
|
{
|
|
flex.push(
|
|
/*flex*/ 0,
|
|
RenderableItem::Owned(Box::new(hook_status::HookStatus {
|
|
message,
|
|
animations_enabled: self.animations_enabled && self.effects.shimmer,
|
|
})),
|
|
);
|
|
}
|
|
// Avoid double-surfacing the same summary and avoid adding an extra
|
|
// row while the status line is already visible.
|
|
if self.status_widget().is_none() && !self.unified_exec_footer.is_empty() {
|
|
flex.push(
|
|
/*flex*/ 0,
|
|
RenderableItem::Borrowed(&self.unified_exec_footer),
|
|
);
|
|
}
|
|
let has_pending_thread_approvals = !self.pending_thread_approvals.is_empty();
|
|
let has_questions = self
|
|
.questions
|
|
.as_ref()
|
|
.is_some_and(|q| q.unanswered_count() > 0);
|
|
let has_pending_input = has_questions
|
|
|| !self.pending_input_preview.queued_messages.is_empty()
|
|
|| !self.pending_input_preview.pending_steers.is_empty()
|
|
|| !self.pending_input_preview.rejected_steers.is_empty();
|
|
let has_status_or_footer = self.status_widget().is_some()
|
|
|| self.hook_status_message.is_some()
|
|
|| !self.unified_exec_footer.is_empty();
|
|
let has_inline_previews = has_pending_thread_approvals || has_pending_input;
|
|
if !has_inline_previews
|
|
&& self.status_widget().is_some()
|
|
&& let Some(tip) = options.working_tip
|
|
{
|
|
flex.push(/*flex*/ 1, RenderableItem::Borrowed(tip));
|
|
}
|
|
if has_inline_previews && has_status_or_footer {
|
|
flex.push(/*flex*/ 0, RenderableItem::Owned("".into()));
|
|
}
|
|
flex.push(
|
|
/*flex*/ 1,
|
|
RenderableItem::Borrowed(&self.pending_thread_approvals),
|
|
);
|
|
if has_pending_thread_approvals && has_pending_input {
|
|
flex.push(/*flex*/ 0, RenderableItem::Owned("".into()));
|
|
}
|
|
flex.push(
|
|
/*flex*/ 1,
|
|
if has_questions {
|
|
RenderableItem::Owned(Box::new(
|
|
pending_input_preview::PendingInputPreviewContent(
|
|
&self.pending_input_preview,
|
|
),
|
|
))
|
|
} else {
|
|
RenderableItem::Borrowed(&self.pending_input_preview)
|
|
},
|
|
);
|
|
let question_editor = self.questions.as_ref().filter(|q| q.expanded);
|
|
// An empty shared gap already separates activity from the composer.
|
|
if !has_inline_previews
|
|
&& has_status_or_footer
|
|
&& options.composer_gap.is_none_or(|gap| gap.needs_separator)
|
|
&& question_editor.is_none_or(|q| q.unanswered_count() > 1)
|
|
{
|
|
flex.push(/*flex*/ 0, RenderableItem::Owned("".into()));
|
|
}
|
|
let question_summary = self.question_summary(Instant::now());
|
|
// History overlays must not clear the status and previews above this composer.
|
|
if options.command_popup_placement == CommandPopupPlacement::Overlay
|
|
&& (has_status_or_footer
|
|
|| has_inline_previews
|
|
|| self.inline_banner.is_some()
|
|
|| question_summary.is_some())
|
|
{
|
|
options.command_popup_placement = CommandPopupPlacement::AboveComposer;
|
|
}
|
|
if let Some(summary) = question_summary {
|
|
flex.push(
|
|
/*flex*/ 0,
|
|
RenderableItem::Owned(Box::new(Paragraph::new(summary))),
|
|
);
|
|
}
|
|
let mut flex2 = FlexRenderable::new();
|
|
// Clip spacing and hints before activity and previews when the composer is tall.
|
|
let above_composer = if let Some(gap) = options.composer_gap {
|
|
let mut column = FlexRenderable::new();
|
|
if has_status_or_footer {
|
|
column.push(/*flex*/ 1, RenderableItem::Owned("".into()));
|
|
}
|
|
column.push(/*flex*/ 0, RenderableItem::Owned(flex.into()));
|
|
column.push(/*flex*/ 1, RenderableItem::Borrowed(gap));
|
|
column.into()
|
|
} else {
|
|
flex.into()
|
|
};
|
|
flex2.push(/*flex*/ 1, RenderableItem::Owned(above_composer));
|
|
let composer: RenderableItem<'_> = if let Some(questions) = question_editor {
|
|
RenderableItem::Borrowed(questions.as_ref())
|
|
} else if options.max_height.is_none()
|
|
&& options.textarea_right_reserve == 0
|
|
&& options.warning_count == 0
|
|
&& options.footer.is_none()
|
|
&& !options.separate_status_line
|
|
&& options.command_popup_placement == CommandPopupPlacement::AboveComposer
|
|
{
|
|
RenderableItem::Borrowed(&self.composer)
|
|
} else {
|
|
RenderableItem::Owned(Box::new(ChatComposerPresentation {
|
|
composer: &self.composer,
|
|
options: self.composer.resolve_render_options(options),
|
|
}))
|
|
};
|
|
flex2.push(/*flex*/ 0, composer);
|
|
RenderableItem::Owned(Box::new(flex2))
|
|
}
|
|
}
|
|
|
|
pub(crate) fn show_footer_flash(&mut self, line: Line<'static>, duration: Duration) {
|
|
if self.warnings_active()
|
|
&& let Some(view) = &mut self.warnings_view
|
|
{
|
|
view.flash = Some((line.clone(), Instant::now() + duration));
|
|
}
|
|
self.composer.show_footer_flash(line, duration);
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_status_line(&mut self, status_line: Option<Line<'static>>) {
|
|
if self.composer.set_status_line(status_line) {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_luna_reserve_active(&mut self, active: bool) {
|
|
if self.composer.set_luna_reserve_active(active) {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_status_line_hyperlink(&mut self, url: Option<String>) {
|
|
if self.composer.set_status_line_hyperlink(url) {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_status_line_enabled(&mut self, enabled: bool) {
|
|
if self.composer.set_status_line_enabled(enabled) {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
/// Updates the contextual footer label and requests a redraw only when it changed.
|
|
///
|
|
/// This keeps the footer plumbing cheap during thread transitions where `App` may recompute
|
|
/// the label several times while the visible thread settles.
|
|
pub(crate) fn set_active_agent_label(&mut self, active_agent_label: Option<String>) {
|
|
if self.composer.set_active_agent_label(active_agent_label) {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_side_conversation_context_label(&mut self, label: Option<String>) {
|
|
if self.composer.set_side_conversation_context_label(label) {
|
|
self.request_redraw();
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ChatComposerPresentation<'a> {
|
|
composer: &'a chat_composer::ChatComposer,
|
|
options: ComposerRenderOptions<'a>,
|
|
}
|
|
|
|
impl Renderable for ChatComposerPresentation<'_> {
|
|
fn render(&self, area: Rect, buf: &mut Buffer) {
|
|
self.composer
|
|
.render_with_options(area, buf, /*mask_char*/ None, self.options);
|
|
}
|
|
|
|
fn desired_height(&self, width: u16) -> u16 {
|
|
self.composer
|
|
.desired_height_with_options(width, self.options)
|
|
.min(self.options.max_height.unwrap_or(u16::MAX))
|
|
}
|
|
|
|
fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
|
|
self.composer.cursor_pos_with_options(area, self.options)
|
|
}
|
|
|
|
fn cursor_style(&self, area: Rect) -> crossterm::cursor::SetCursorStyle {
|
|
if self
|
|
.options
|
|
.footer
|
|
.is_some_and(|footer| footer.is_interactive)
|
|
{
|
|
crossterm::cursor::SetCursorStyle::SteadyBar
|
|
} else {
|
|
self.composer.cursor_style(area)
|
|
}
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
fn cursor_style(&self, area: Rect) -> crossterm::cursor::SetCursorStyle {
|
|
self.as_renderable().cursor_style(area)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#[path = "actionable_banner_tests.rs"]
|
|
mod actionable_banner_tests;
|
|
#[path = "picker_hint_tests.rs"]
|
|
mod picker_hint_tests;
|
|
|
|
use super::*;
|
|
use crate::app::app_server_requests::ResolvedAppServerRequest;
|
|
use crate::app_command::AppCommand as Op;
|
|
use crate::app_event::AppEvent;
|
|
use crate::status_indicator_widget::STATUS_DETAILS_DEFAULT_MAX_LINES;
|
|
use crate::status_indicator_widget::StatusDetailsCapitalization;
|
|
use crate::test_support::PathBufExt;
|
|
use crate::test_support::test_path_buf;
|
|
use codex_app_server_protocol::CommandExecutionApprovalDecision;
|
|
use crossterm::event::KeyCode;
|
|
use crossterm::event::KeyEvent;
|
|
use crossterm::event::KeyEventKind;
|
|
use crossterm::event::KeyModifiers;
|
|
use insta::assert_snapshot;
|
|
use pretty_assertions::assert_eq;
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
use std::cell::Cell;
|
|
use std::rc::Rc;
|
|
use std::time::Instant;
|
|
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: &impl Renderable, area: Rect) -> String {
|
|
let mut buf = Buffer::empty(area);
|
|
pane.render(area, &mut buf);
|
|
snapshot_buffer(&buf)
|
|
}
|
|
|
|
pub(super) fn test_pane(app_event_tx: AppEventSender) -> BottomPane {
|
|
test_pane_with_disable_paste_burst(app_event_tx, /*disable_paste_burst*/ false)
|
|
}
|
|
|
|
fn test_pane_with_disable_paste_burst(
|
|
app_event_tx: AppEventSender,
|
|
disable_paste_burst: bool,
|
|
) -> BottomPane {
|
|
BottomPane::new(BottomPaneParams {
|
|
app_event_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,
|
|
animations_enabled: true,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
})
|
|
}
|
|
|
|
fn exec_request() -> ApprovalRequest {
|
|
ApprovalRequest::Exec(ExecApprovalRequest {
|
|
kind: Default::default(),
|
|
thread_id: codex_protocol::ThreadId::new(),
|
|
thread_label: None,
|
|
id: "1".to_string(),
|
|
environment_id: None,
|
|
command: vec!["echo".into(), "ok".into()],
|
|
reason: None,
|
|
available_decisions: vec![
|
|
CommandExecutionApprovalDecision::Accept,
|
|
CommandExecutionApprovalDecision::Cancel,
|
|
],
|
|
network_approval_context: None,
|
|
additional_permissions: None,
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn flush_buffered_typing_in_background_and_covering_editors() {
|
|
let (tx, _rx) = unbounded_channel();
|
|
let tx = AppEventSender::new(tx);
|
|
let mut pane = test_pane(tx.clone());
|
|
for ch in "main draft".chars() {
|
|
pane.handle_key_event(KeyEvent::from(KeyCode::Char(ch)));
|
|
}
|
|
assert!(pane.composer.is_in_paste_burst());
|
|
let request = ToolRequestUserInputParams {
|
|
thread_id: "thread".into(),
|
|
turn_id: "turn".into(),
|
|
item_id: "call".into(),
|
|
is_blocking: true,
|
|
auto_resolution_ms: None,
|
|
questions: vec![codex_app_server_protocol::ToolRequestUserInputQuestion {
|
|
id: "question".into(),
|
|
header: String::new(),
|
|
question: "Which way?".into(),
|
|
is_other: false,
|
|
is_secret: false,
|
|
options: None,
|
|
}],
|
|
};
|
|
let mut covering = RequestUserInputOverlay::new_with_keymap(
|
|
request,
|
|
tx,
|
|
/*has_input_focus*/ true,
|
|
/*enhanced_keys_supported*/ false,
|
|
/*disable_paste_burst*/ false,
|
|
RuntimeKeymap::defaults(),
|
|
);
|
|
for ch in "modal".chars() {
|
|
covering.handle_key_event(KeyEvent::from(KeyCode::Char(ch)));
|
|
}
|
|
assert!(covering.is_in_paste_burst());
|
|
pane.push_view(Box::new(covering));
|
|
std::thread::sleep(paste_burst::PasteBurst::recommended_active_flush_delay());
|
|
assert!(pane.flush_paste_burst_if_due());
|
|
assert!(!pane.is_in_paste_burst());
|
|
assert_eq!(pane.composer_text(), "main draft");
|
|
}
|
|
|
|
#[test]
|
|
fn inline_banner_snapshot() {
|
|
let (tx, _rx) = unbounded_channel();
|
|
let mut pane = test_pane(AppEventSender::new(tx));
|
|
pane.set_inline_banner(Some(ActionableBanner {
|
|
title: "Choose how to continue working".to_string(),
|
|
description: "A long description wraps to fit the available terminal width.\n"
|
|
.repeat(/*n*/ 8),
|
|
actions: vec![
|
|
SelectionItem {
|
|
name: "Open usage settings".to_string(),
|
|
..Default::default()
|
|
},
|
|
SelectionItem {
|
|
name: "Notify owner".to_string(),
|
|
..Default::default()
|
|
},
|
|
],
|
|
..Default::default()
|
|
}));
|
|
let width = 44;
|
|
let area = Rect::new(
|
|
/*x*/ 0,
|
|
/*y*/ 0,
|
|
width,
|
|
pane.desired_height(width),
|
|
);
|
|
assert_snapshot!(
|
|
"inline_banner_wrapped_and_truncated",
|
|
render_snapshot(&pane, area)
|
|
);
|
|
assert!(!pane.is_normal_backtrack_mode());
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
assert!(pane.is_normal_backtrack_mode());
|
|
}
|
|
|
|
#[test]
|
|
fn escape_closes_shortcut_help_before_inline_banner() {
|
|
let (tx, _rx) = unbounded_channel();
|
|
let mut pane = test_pane(AppEventSender::new(tx));
|
|
pane.set_inline_banner(Some(ActionableBanner {
|
|
title: "Continue working".into(),
|
|
description: "Keep this notice while dismissing shortcut help".into(),
|
|
..Default::default()
|
|
}));
|
|
let width = 80;
|
|
let area = Rect::new(
|
|
/*x*/ 0,
|
|
/*y*/ 0,
|
|
width,
|
|
pane.desired_height(width),
|
|
);
|
|
let _ = render_snapshot(&pane, area);
|
|
assert_eq!(pane.inline_banner_lifecycle(), (true, false));
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::NONE));
|
|
assert!(pane.shortcut_overlay_visible());
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
assert!(!pane.shortcut_overlay_visible());
|
|
assert_eq!(pane.inline_banner_lifecycle(), (true, false));
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
assert_eq!(pane.inline_banner_lifecycle(), (true, true));
|
|
}
|
|
|
|
#[test]
|
|
fn backend_banner_snapshots_and_numbered_actions() {
|
|
for (kind, action, label) in [
|
|
("personal_limit", "view_usage", "View usage"),
|
|
("workspace_member_credits", "notify_owner", "Notify owner"),
|
|
] {
|
|
let banner = crate::backend_banners::BackendBanner::parse(&serde_json::json!({
|
|
"banner_type": kind,
|
|
"presentation": "dismissible",
|
|
"title": "Usage limit\u{7} reached",
|
|
"description": "Your included usage is depleted.\nChoose an action to continue.",
|
|
"ctas": [
|
|
{"action": "unsupported", "label": "Hidden action"},
|
|
{"action": "view_usage", "label": "Open usage settings"},
|
|
{"action": action, "label": label},
|
|
{"action": "view_usage", "label": "Extra action"}
|
|
]
|
|
}))
|
|
.expect("valid optional banner");
|
|
let (tx, mut rx) = unbounded_channel();
|
|
let mut pane = test_pane(AppEventSender::new(tx));
|
|
pane.set_inline_banner(Some(
|
|
banner.actionable_banner(crate::clock_format::ClockFormat::TwentyFourHour),
|
|
));
|
|
let width = 44;
|
|
let area = Rect::new(
|
|
/*x*/ 0,
|
|
/*y*/ 0,
|
|
width,
|
|
pane.desired_height(width),
|
|
);
|
|
assert_snapshot!(
|
|
format!("backend_banner_{kind}"),
|
|
render_snapshot(&pane, area)
|
|
);
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::NONE));
|
|
let selected = match rx.try_recv().expect("numbered CTA dispatch") {
|
|
AppEvent::OpenUrlInBrowser { url } => url,
|
|
AppEvent::SendAddCreditsNudgeEmail { credit_type } => format!("{credit_type:?}"),
|
|
other => panic!("unexpected banner action: {other:?}"),
|
|
};
|
|
assert_eq!(
|
|
selected,
|
|
if action == "view_usage" {
|
|
"https://chatgpt.com/settings/usage"
|
|
} else {
|
|
"Credits"
|
|
}
|
|
);
|
|
assert!(pane.inline_banner.is_some());
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct DismissibleView {
|
|
id: Option<&'static str>,
|
|
dismiss_exec_id: Option<&'static str>,
|
|
complete: bool,
|
|
}
|
|
|
|
impl Renderable for DismissibleView {
|
|
fn render(&self, _area: Rect, _buf: &mut Buffer) {}
|
|
|
|
fn desired_height(&self, _width: u16) -> u16 {
|
|
0
|
|
}
|
|
}
|
|
|
|
impl BottomPaneView for DismissibleView {
|
|
fn is_complete(&self) -> bool {
|
|
self.complete
|
|
}
|
|
|
|
fn view_id(&self) -> Option<&'static str> {
|
|
self.id
|
|
}
|
|
|
|
fn dismiss_app_server_request(&mut self, request: &ResolvedAppServerRequest) -> bool {
|
|
let ResolvedAppServerRequest::ExecApproval { id, .. } = request else {
|
|
return false;
|
|
};
|
|
if self.dismiss_exec_id != Some(id.as_str()) {
|
|
return false;
|
|
}
|
|
|
|
self.complete = true;
|
|
true
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn view_transition_key_guard_survives_an_intervening_modal() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let mut pane = test_pane(AppEventSender::new(tx_raw));
|
|
let activation_key = crate::key_hint::plain(KeyCode::Enter);
|
|
pane.suppress_current_view_key_until_release(activation_key, Instant::now());
|
|
pane.push_view(Box::new(DismissibleView::default()));
|
|
|
|
assert!(pane.consume_view_transition_key(activation_key, KeyEventKind::Repeat));
|
|
assert!(pane.consume_view_transition_key(activation_key, KeyEventKind::Release));
|
|
assert!(!pane.consume_view_transition_key(activation_key, KeyEventKind::Press));
|
|
}
|
|
|
|
#[test]
|
|
fn transition_events_reach_a_view_covered_by_a_modal() {
|
|
#[derive(Default)]
|
|
struct CoveredEvents {
|
|
press_seen: Cell<bool>,
|
|
release_seen: Cell<bool>,
|
|
interrupted: Cell<bool>,
|
|
}
|
|
|
|
struct TrackingView(Rc<CoveredEvents>);
|
|
|
|
impl Renderable for TrackingView {
|
|
fn render(&self, _area: Rect, _buf: &mut Buffer) {}
|
|
|
|
fn desired_height(&self, _width: u16) -> u16 {
|
|
0
|
|
}
|
|
}
|
|
|
|
impl BottomPaneView for TrackingView {
|
|
fn observe_key_event_while_covered(
|
|
&mut self,
|
|
_key_event: KeyEvent,
|
|
_activation_key: KeyBinding,
|
|
) {
|
|
self.0.press_seen.set(true);
|
|
}
|
|
|
|
fn handle_key_release(&mut self, _key_event: KeyEvent) {
|
|
self.0.release_seen.set(true);
|
|
}
|
|
|
|
fn interrupt_config_editor_transition(&mut self) {
|
|
self.0.interrupted.set(true);
|
|
}
|
|
}
|
|
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let mut pane = test_pane(AppEventSender::new(tx_raw));
|
|
let events = Rc::new(CoveredEvents::default());
|
|
pane.push_view(Box::new(TrackingView(events.clone())));
|
|
pane.push_view(Box::new(DismissibleView::default()));
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
pane.handle_key_event(KeyEvent::new_with_kind(
|
|
KeyCode::Enter,
|
|
KeyModifiers::NONE,
|
|
KeyEventKind::Release,
|
|
));
|
|
pane.handle_paste("pasted".to_string());
|
|
|
|
assert!(events.press_seen.get());
|
|
assert!(events.release_seen.get());
|
|
assert!(events.interrupted.get());
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct CompletingView {
|
|
id: Option<&'static str>,
|
|
complete: bool,
|
|
}
|
|
|
|
impl Renderable for CompletingView {
|
|
fn render(&self, _area: Rect, _buf: &mut Buffer) {}
|
|
|
|
fn desired_height(&self, _width: u16) -> u16 {
|
|
0
|
|
}
|
|
}
|
|
|
|
impl BottomPaneView for CompletingView {
|
|
fn handle_key_event(&mut self, key_event: KeyEvent) {
|
|
if key_event.code == KeyCode::Enter {
|
|
self.complete = true;
|
|
}
|
|
}
|
|
|
|
fn is_complete(&self) -> bool {
|
|
self.complete
|
|
}
|
|
|
|
fn view_id(&self) -> Option<&'static str> {
|
|
self.id
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn ctrl_c_on_modal_consumes_without_showing_quit_hint() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
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: true,
|
|
animations_enabled: true,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
pane.push_approval_request(exec_request(), &features);
|
|
assert_eq!(CancellationEvent::Handled, pane.on_ctrl_c());
|
|
assert!(!pane.quit_shortcut_hint_visible());
|
|
assert_eq!(CancellationEvent::NotHandled, pane.on_ctrl_c());
|
|
}
|
|
|
|
#[test]
|
|
fn ctrl_c_cancels_history_search_without_clearing_draft_or_showing_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: true,
|
|
animations_enabled: true,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
pane.insert_str("draft");
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));
|
|
assert!(pane.composer.popup_active());
|
|
|
|
assert_eq!(CancellationEvent::Handled, pane.on_ctrl_c());
|
|
assert_eq!(pane.composer_text(), "draft");
|
|
assert!(!pane.composer.popup_active());
|
|
assert!(!pane.quit_shortcut_hint_visible());
|
|
pane.composer.set_vim_enabled(/*enabled*/ true);
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('/'), KeyModifiers::NONE));
|
|
assert_eq!(CancellationEvent::Handled, pane.on_ctrl_c());
|
|
assert_eq!(pane.composer_text(), "draft");
|
|
assert!(!pane.composer.popup_active());
|
|
}
|
|
|
|
// 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 features = Features::with_defaults();
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
// Create an approval modal (active view).
|
|
pane.push_approval_request(exec_request(), &features);
|
|
|
|
// 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 approval_request_shows_immediately_without_recent_typing() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
let mut pane = test_pane(tx);
|
|
|
|
pane.push_approval_request(exec_request(), &features);
|
|
|
|
assert_eq!(pane.view_stack.len(), 1);
|
|
assert!(pane.delayed_approval_requests.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn approval_request_is_delayed_after_recent_typing() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
for source in [
|
|
"composer",
|
|
"warning open",
|
|
"warning navigation",
|
|
"warning paste",
|
|
] {
|
|
let mut pane = test_pane(tx.clone());
|
|
match source {
|
|
"warning open" => pane.show_warnings(
|
|
Vec::new(),
|
|
Default::default(),
|
|
/*daemon_restart_hint_at*/ None,
|
|
),
|
|
"warning navigation" => {
|
|
pane.show_warnings(
|
|
Vec::new(),
|
|
Default::default(),
|
|
/*daemon_restart_hint_at*/ None,
|
|
);
|
|
pane.last_composer_activity_at = None;
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
|
|
}
|
|
"warning paste" => {
|
|
pane.show_warnings(
|
|
Vec::new(),
|
|
Default::default(),
|
|
/*daemon_restart_hint_at*/ None,
|
|
);
|
|
pane.last_composer_activity_at = None;
|
|
pane.handle_paste("query".into());
|
|
}
|
|
_ => pane.last_composer_activity_at = Some(Instant::now()),
|
|
}
|
|
let now = pane
|
|
.last_composer_activity_at
|
|
.expect("typing activity recorded");
|
|
|
|
pane.push_approval_request(exec_request(), &features);
|
|
|
|
assert!(pane.view_stack.is_empty());
|
|
assert_eq!(pane.delayed_approval_requests.len(), 1);
|
|
if source == "warning navigation" {
|
|
pane.handle_key_event(KeyCode::Enter.into());
|
|
assert!(pane.warnings_active());
|
|
}
|
|
let now = pane.last_composer_activity_at.unwrap_or(now);
|
|
|
|
pane.pre_draw_tick_at(
|
|
now + APPROVAL_PROMPT_TYPING_IDLE_DELAY - Duration::from_millis(/*millis*/ 1),
|
|
);
|
|
assert!(pane.view_stack.is_empty());
|
|
assert_eq!(pane.delayed_approval_requests.len(), 1);
|
|
|
|
pane.pre_draw_tick_at(now + APPROVAL_PROMPT_TYPING_IDLE_DELAY);
|
|
assert_eq!(pane.view_stack.len(), 1);
|
|
assert!(pane.delayed_approval_requests.is_empty());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn continued_typing_resets_delayed_approval_idle_deadline() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
let mut pane = test_pane(tx);
|
|
let first_activity = Instant::now();
|
|
pane.last_composer_activity_at = Some(first_activity);
|
|
pane.push_approval_request(exec_request(), &features);
|
|
|
|
let continued_activity = first_activity + Duration::from_millis(/*millis*/ 750);
|
|
pane.record_composer_activity_at(continued_activity);
|
|
|
|
pane.pre_draw_tick_at(first_activity + APPROVAL_PROMPT_TYPING_IDLE_DELAY);
|
|
assert!(pane.view_stack.is_empty());
|
|
assert_eq!(pane.delayed_approval_requests.len(), 1);
|
|
|
|
pane.pre_draw_tick_at(continued_activity + APPROVAL_PROMPT_TYPING_IDLE_DELAY);
|
|
assert_eq!(pane.view_stack.len(), 1);
|
|
assert!(pane.delayed_approval_requests.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn typed_approval_shortcuts_during_delay_stay_in_composer() {
|
|
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
let mut pane = test_pane_with_disable_paste_burst(tx, /*disable_paste_burst*/ true);
|
|
pane.last_composer_activity_at = Some(Instant::now());
|
|
pane.push_approval_request(exec_request(), &features);
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE));
|
|
|
|
assert_eq!(pane.composer_text(), "ya");
|
|
assert!(pane.view_stack.is_empty());
|
|
assert_eq!(pane.delayed_approval_requests.len(), 1);
|
|
pane.handle_restricted_key(
|
|
KeyEvent::new(KeyCode::Null, KeyModifiers::NONE),
|
|
RestrictedInputMode::Disconnected,
|
|
);
|
|
pane.pre_draw_tick_at(Instant::now() + APPROVAL_PROMPT_TYPING_IDLE_DELAY);
|
|
pane.handle_paste(" kept".into());
|
|
assert_eq!(pane.composer_text(), "ya kept");
|
|
assert!(pane.view_stack.is_empty());
|
|
while let Ok(event) = rx.try_recv() {
|
|
assert!(
|
|
!matches!(event, AppEvent::SubmitThreadOp { .. }),
|
|
"delayed approval shortcut should not submit an approval: {event:?}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn delayed_approval_shortcut_works_after_idle_deadline() {
|
|
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
let mut pane = test_pane(tx);
|
|
let now = Instant::now();
|
|
pane.last_composer_activity_at = Some(now);
|
|
pane.push_approval_request(exec_request(), &features);
|
|
|
|
pane.pre_draw_tick_at(now + APPROVAL_PROMPT_TYPING_IDLE_DELAY);
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
|
|
|
|
let mut approval_decision = None;
|
|
while let Ok(event) = rx.try_recv() {
|
|
if let AppEvent::SubmitThreadOp {
|
|
op: Op::ExecApproval { decision, .. },
|
|
..
|
|
} = event
|
|
{
|
|
approval_decision = Some(decision);
|
|
}
|
|
}
|
|
assert_eq!(
|
|
approval_decision,
|
|
Some(CommandExecutionApprovalDecision::Accept)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn dismiss_app_server_request_prunes_delayed_approval() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
let mut pane = test_pane(tx);
|
|
let now = Instant::now();
|
|
pane.last_composer_activity_at = Some(now);
|
|
let request = exec_request();
|
|
let thread_id = request.thread_id();
|
|
pane.push_approval_request(request, &features);
|
|
|
|
assert!(
|
|
pane.dismiss_app_server_request(&ResolvedAppServerRequest::ExecApproval {
|
|
thread_id: thread_id.to_string(),
|
|
id: "1".to_string(),
|
|
})
|
|
);
|
|
assert!(pane.delayed_approval_requests.is_empty());
|
|
|
|
pane.pre_draw_tick_at(now + APPROVAL_PROMPT_TYPING_IDLE_DELAY);
|
|
assert!(pane.view_stack.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn dismiss_app_server_request_removes_matching_buried_view() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = test_pane(tx);
|
|
|
|
pane.push_view(Box::new(DismissibleView {
|
|
id: Some("buried"),
|
|
dismiss_exec_id: Some("request-1"),
|
|
complete: false,
|
|
}));
|
|
pane.push_view(Box::new(DismissibleView {
|
|
id: Some("top"),
|
|
dismiss_exec_id: None,
|
|
complete: false,
|
|
}));
|
|
|
|
assert!(
|
|
pane.dismiss_app_server_request(&ResolvedAppServerRequest::ExecApproval {
|
|
thread_id: "thread-1".to_string(),
|
|
id: "request-1".to_string(),
|
|
})
|
|
);
|
|
assert_eq!(pane.view_stack.len(), 1);
|
|
assert_eq!(
|
|
pane.view_stack.last().and_then(|view| view.view_id()),
|
|
Some("top")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn apply_text_suggestion_updates_matching_prompt_beneath_an_overlay() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = test_pane(tx);
|
|
let request_id = uuid::Uuid::new_v4();
|
|
let prompt = custom_prompt_view::CustomPromptView::new(
|
|
"Rename thread".to_string(),
|
|
"Type a name".to_string(),
|
|
/*initial_text*/ String::new(),
|
|
/*context_label*/ None,
|
|
Box::new(|_| {}),
|
|
)
|
|
.with_text_suggestion(request_id, "Loading".to_string(), "Ready".to_string());
|
|
pane.show_text_prompt(prompt);
|
|
pane.push_view(Box::new(CompletingView {
|
|
id: Some("overlay"),
|
|
complete: false,
|
|
}));
|
|
|
|
assert!(pane.apply_text_suggestion(request_id, Some("Fix login timeout")));
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
let rendered = render_snapshot(
|
|
&pane,
|
|
Rect::new(
|
|
/*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 8,
|
|
),
|
|
);
|
|
|
|
assert!(rendered.contains("Fix login timeout"));
|
|
assert!(rendered.contains("Ready"));
|
|
assert!(!rendered.contains("Loading"));
|
|
}
|
|
|
|
#[test]
|
|
fn dismiss_app_server_request_returns_false_when_no_view_matches() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = test_pane(tx);
|
|
|
|
pane.push_view(Box::new(DismissibleView {
|
|
id: Some("first"),
|
|
dismiss_exec_id: Some("other-request"),
|
|
complete: false,
|
|
}));
|
|
pane.push_view(Box::new(DismissibleView {
|
|
id: Some("second"),
|
|
dismiss_exec_id: None,
|
|
complete: false,
|
|
}));
|
|
|
|
assert!(
|
|
!pane.dismiss_app_server_request(&ResolvedAppServerRequest::ExecApproval {
|
|
thread_id: "thread-1".to_string(),
|
|
id: "request-1".to_string(),
|
|
})
|
|
);
|
|
assert_eq!(pane.view_stack.len(), 2);
|
|
assert_eq!(
|
|
pane.view_stack.last().and_then(|view| view.view_id()),
|
|
Some("second")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completing_top_view_preserves_underlying_view() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = test_pane(tx);
|
|
|
|
pane.push_view(Box::new(DismissibleView {
|
|
id: Some("underlying"),
|
|
dismiss_exec_id: None,
|
|
complete: false,
|
|
}));
|
|
pane.push_view(Box::new(CompletingView {
|
|
id: Some("top"),
|
|
complete: false,
|
|
}));
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
|
|
assert_eq!(pane.view_stack.len(), 1);
|
|
assert_eq!(
|
|
pane.view_stack.last().and_then(|view| view.view_id()),
|
|
Some("underlying")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn composer_shown_after_denied_while_task_running() {
|
|
let (tx_raw, _rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let features = Features::with_defaults();
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
// Start a running task so the status indicator is active above the composer.
|
|
pane.set_task_running(/*running*/ true);
|
|
|
|
// Push an approval modal (e.g., command approval) which should hide the status view.
|
|
pane.push_approval_request(exec_request(), &features);
|
|
|
|
// 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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
// Begin a task: show initial status.
|
|
pane.set_task_running(/*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");
|
|
|
|
pane.reset_status_timer(Duration::from_secs(/*secs*/ 42));
|
|
pane.hide_status_indicator();
|
|
pane.pause_status_timer_for_modal();
|
|
let paused = pane.status_timer.elapsed_at(Instant::now());
|
|
pane.ensure_status_indicator();
|
|
assert_snapshot!(
|
|
"status_timer_survives_hidden_row",
|
|
render_snapshot(&pane, area)
|
|
);
|
|
assert_eq!(
|
|
pane.status_timer
|
|
.elapsed_at(Instant::now() + Duration::from_secs(/*secs*/ 10)),
|
|
paused
|
|
);
|
|
pane.resume_status_timer_after_modal();
|
|
assert!(
|
|
pane.status_timer
|
|
.elapsed_at(Instant::now() + Duration::from_secs(/*secs*/ 10))
|
|
>= paused + Duration::from_secs(/*secs*/ 10)
|
|
);
|
|
pane.set_task_running(/*running*/ false);
|
|
pane.set_task_running(/*running*/ true);
|
|
assert!(pane.status_timer.elapsed_at(Instant::now()) < paused);
|
|
}
|
|
|
|
#[test]
|
|
fn turn_start_keeps_an_outstanding_approval_paused() {
|
|
let (tx, _rx) = unbounded_channel::<AppEvent>();
|
|
let mut pane = test_pane(AppEventSender::new(tx));
|
|
// MCP startup can already own the running row when an agent turn starts.
|
|
pane.set_task_running(/*running*/ true);
|
|
pane.push_approval_request(exec_request(), &Features::default());
|
|
pane.hide_status_indicator();
|
|
pane.set_task_running(/*running*/ true);
|
|
pane.reset_status_timer(Duration::ZERO);
|
|
pane.ensure_status_indicator();
|
|
let later = Instant::now() + Duration::from_secs(/*secs*/ 120);
|
|
assert_eq!(pane.status_timer.elapsed_at(later), Duration::ZERO);
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
assert!(pane.no_modal_or_popup_active());
|
|
assert!(
|
|
pane.status_timer
|
|
.elapsed_at(Instant::now() + Duration::from_secs(/*secs*/ 10))
|
|
>= Duration::from_secs(/*secs*/ 10)
|
|
);
|
|
}
|
|
|
|
#[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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
// Activate spinner (status view replaces composer) with no live ring.
|
|
pane.set_task_running(/*running*/ true);
|
|
|
|
// Use height == desired_height; expect spacer + status + composer rows without trailing padding.
|
|
let height = pane.desired_height(/*width*/ 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 status_only_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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
|
|
let width = 48;
|
|
let height = pane.desired_height(width);
|
|
let area = Rect::new(0, 0, width, height);
|
|
assert_snapshot!("status_only_snapshot", render_snapshot(&pane, area));
|
|
}
|
|
|
|
#[test]
|
|
fn unified_exec_summary_does_not_increase_height_when_status_visible() {
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
let width = 120;
|
|
let before = pane.desired_height(width);
|
|
|
|
pane.set_unified_exec_processes(vec!["sleep 5".to_string()]);
|
|
let after = pane.desired_height(width);
|
|
|
|
assert_eq!(after, before);
|
|
|
|
let area = Rect::new(0, 0, width, after);
|
|
let rendered = render_snapshot(&pane, area);
|
|
assert!(rendered.contains("background terminal running · /ps to view"));
|
|
}
|
|
|
|
#[test]
|
|
fn status_with_details_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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
pane.update_status(
|
|
"Working".to_string(),
|
|
Some("First detail line\nSecond detail line".to_string()),
|
|
StatusDetailsCapitalization::CapitalizeFirst,
|
|
STATUS_DETAILS_DEFAULT_MAX_LINES,
|
|
);
|
|
pane.set_pending_input_preview(
|
|
vec!["Queued follow-up question".to_string()],
|
|
Vec::new(),
|
|
Vec::new(),
|
|
);
|
|
|
|
let width = 48;
|
|
let height = pane.desired_height(width);
|
|
let area = Rect::new(0, 0, width, height);
|
|
assert_snapshot!(
|
|
"status_with_details_and_queued_messages_snapshot",
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
pane.set_pending_input_preview(
|
|
vec!["Queued follow-up question".to_string()],
|
|
Vec::new(),
|
|
Vec::new(),
|
|
);
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
pane.set_pending_input_preview(
|
|
vec!["Queued follow-up question".to_string()],
|
|
Vec::new(),
|
|
Vec::new(),
|
|
);
|
|
|
|
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)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn remote_images_render_above_composer_text() {
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_remote_image_urls(vec![
|
|
"https://example.com/one.png".to_string(),
|
|
"data:image/png;base64,aGVsbG8=".to_string(),
|
|
]);
|
|
|
|
assert_eq!(pane.composer_text(), "");
|
|
let width = 48;
|
|
let height = pane.desired_height(width);
|
|
let area = Rect::new(0, 0, width, height);
|
|
let snapshot = render_snapshot(&pane, area);
|
|
assert!(snapshot.contains("[Image #1]"));
|
|
assert!(snapshot.contains("[Image #2]"));
|
|
}
|
|
|
|
#[test]
|
|
fn drain_pending_submission_state_clears_remote_image_urls() {
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_remote_image_urls(vec!["https://example.com/one.png".to_string()]);
|
|
assert_eq!(pane.remote_image_urls().len(), 1);
|
|
|
|
pane.drain_pending_submission_state();
|
|
|
|
assert!(pane.remote_image_urls().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn esc_with_skill_popup_does_not_interrupt_task() {
|
|
let (tx_raw, mut 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,
|
|
effects: Default::default(),
|
|
skills: Some(vec![SkillMetadata {
|
|
name: "test-skill".to_string(),
|
|
description: "test skill".to_string(),
|
|
short_description: None,
|
|
interface: None,
|
|
dependencies: None,
|
|
path: test_path_buf("/tmp/test-skill/SKILL.md").abs().into(),
|
|
scope: crate::test_support::skill_scope_user(),
|
|
enabled: true,
|
|
plugin_id: None,
|
|
}]),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
|
|
// Repro: a running task + skill popup + Esc should dismiss the popup, not interrupt.
|
|
pane.insert_str("$");
|
|
assert!(
|
|
pane.composer.popup_active(),
|
|
"expected skill popup after typing `$`"
|
|
);
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
|
|
while let Ok(ev) = rx.try_recv() {
|
|
assert!(
|
|
!matches!(ev, AppEvent::CodexOp(Op::Interrupt)),
|
|
"expected Esc to not send Op::Interrupt when dismissing skill popup"
|
|
);
|
|
}
|
|
assert!(
|
|
!pane.composer.popup_active(),
|
|
"expected Esc to dismiss skill popup"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn esc_dismisses_slash_command_popup_without_interrupting_task() {
|
|
let (tx_raw, mut 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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
|
|
// Repro: a running task + slash-command popup + Esc should dismiss the popup without
|
|
// interrupting the task.
|
|
pane.insert_str("/rev");
|
|
assert!(
|
|
pane.composer.popup_active(),
|
|
"expected command popup after typing `/rev`"
|
|
);
|
|
|
|
// Owned transcript mode must reserve the popup's rows while task status is visible.
|
|
let overlay = pane.as_renderable_with_options(ComposerRenderOptions {
|
|
command_popup_placement: CommandPopupPlacement::Overlay,
|
|
..Default::default()
|
|
});
|
|
let inline = pane.as_renderable();
|
|
let area = Rect::new(
|
|
/*x*/ 0,
|
|
/*y*/ 0,
|
|
/*width*/ 60,
|
|
inline.desired_height(/*width*/ 60),
|
|
);
|
|
let mut expected = Buffer::empty(area);
|
|
let mut actual = Buffer::empty(area);
|
|
inline.render(area, &mut expected);
|
|
overlay.render(area, &mut actual);
|
|
assert_eq!(overlay.desired_height(/*width*/ 60), area.height);
|
|
assert_eq!(actual, expected);
|
|
assert_eq!(overlay.cursor_pos(area), inline.cursor_pos(area));
|
|
drop((overlay, inline));
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
|
|
while let Ok(ev) = rx.try_recv() {
|
|
assert!(
|
|
!matches!(ev, AppEvent::CodexOp(Op::Interrupt)),
|
|
"expected Esc to not send Op::Interrupt while command popup is active"
|
|
);
|
|
}
|
|
assert!(!pane.composer.popup_active());
|
|
assert_eq!(pane.composer_text(), "/rev");
|
|
|
|
let width = 60;
|
|
let area = Rect::new(0, 0, width, pane.desired_height(width));
|
|
assert_snapshot!(
|
|
"slash_command_popup_dismissed",
|
|
render_snapshot(&pane, area)
|
|
);
|
|
|
|
pane.insert_str("i");
|
|
assert!(pane.composer.popup_active());
|
|
}
|
|
|
|
#[test]
|
|
fn esc_with_agent_command_without_popup_does_not_interrupt_task() {
|
|
let (tx_raw, mut 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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
|
|
// Repro: `/subagents ` hides the popup (cursor past command name). Esc should
|
|
// keep editing command text instead of interrupting the running task.
|
|
pane.insert_str("/subagents ");
|
|
assert!(
|
|
!pane.composer.popup_active(),
|
|
"expected command popup to be hidden after entering `/subagents `"
|
|
);
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
|
|
while let Ok(ev) = rx.try_recv() {
|
|
assert!(
|
|
!matches!(ev, AppEvent::CodexOp(Op::Interrupt)),
|
|
"expected Esc to not send Op::Interrupt while typing `/subagents`"
|
|
);
|
|
}
|
|
assert_eq!(pane.composer_text(), "/subagents ");
|
|
}
|
|
|
|
#[test]
|
|
fn esc_release_after_dismissing_agent_picker_does_not_interrupt_task() {
|
|
let (tx_raw, mut 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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
pane.show_selection_view(SelectionViewParams {
|
|
title: Some("Agents".to_string()),
|
|
items: vec![SelectionItem {
|
|
name: "Main".to_string(),
|
|
..Default::default()
|
|
}],
|
|
..Default::default()
|
|
});
|
|
|
|
pane.handle_key_event(KeyEvent::new_with_kind(
|
|
KeyCode::Esc,
|
|
KeyModifiers::NONE,
|
|
KeyEventKind::Press,
|
|
));
|
|
pane.handle_key_event(KeyEvent::new_with_kind(
|
|
KeyCode::Esc,
|
|
KeyModifiers::NONE,
|
|
KeyEventKind::Release,
|
|
));
|
|
|
|
while let Ok(ev) = rx.try_recv() {
|
|
assert!(
|
|
!matches!(ev, AppEvent::CodexOp(Op::Interrupt)),
|
|
"expected Esc release after dismissing agent picker to not interrupt"
|
|
);
|
|
}
|
|
assert!(
|
|
pane.no_modal_or_popup_active(),
|
|
"expected Esc press to dismiss the agent picker"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn esc_interrupts_running_task_when_no_popup() {
|
|
let (tx_raw, mut 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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_task_running(/*running*/ true);
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
|
|
assert!(
|
|
matches!(rx.try_recv(), Ok(AppEvent::CodexOp(Op::Interrupt))),
|
|
"expected Esc to send Op::Interrupt while a task is running"
|
|
);
|
|
|
|
pane.hide_status_indicator();
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
assert!(matches!(
|
|
rx.try_recv(),
|
|
Ok(AppEvent::CodexOp(Op::Interrupt))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn remapped_interrupt_turn_uses_configured_key_including_agent_drafts() {
|
|
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = test_pane(tx);
|
|
let mut keymap = RuntimeKeymap::defaults();
|
|
keymap.chat.interrupt_turn = vec![crate::key_hint::plain(KeyCode::F(12))];
|
|
pane.set_keymap_bindings(&keymap);
|
|
pane.set_task_running(/*running*/ true);
|
|
pane.insert_str("/subagents ");
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
assert!(
|
|
rx.try_recv().is_err(),
|
|
"expected Esc to remain local after remapping interruption"
|
|
);
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::F(12), KeyModifiers::NONE));
|
|
assert!(
|
|
matches!(rx.try_recv(), Ok(AppEvent::CodexOp(Op::Interrupt))),
|
|
"expected configured key to interrupt while `/subagents` is being edited"
|
|
);
|
|
|
|
pane.hide_status_indicator();
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::F(12), KeyModifiers::NONE));
|
|
assert!(matches!(
|
|
rx.try_recv(),
|
|
Ok(AppEvent::CodexOp(Op::Interrupt))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn selection_view_esc_respects_remapped_list_cancel() {
|
|
let (tx_raw, mut rx) = unbounded_channel::<AppEvent>();
|
|
let tx = AppEventSender::new(tx_raw);
|
|
let mut pane = test_pane(tx);
|
|
let mut keymap = RuntimeKeymap::defaults();
|
|
keymap.list.cancel = vec![crate::key_hint::plain(KeyCode::Char('q'))];
|
|
pane.set_keymap_bindings(&keymap);
|
|
pane.show_selection_view(SelectionViewParams {
|
|
title: Some("Agents".to_string()),
|
|
items: vec![SelectionItem {
|
|
name: "Main".to_string(),
|
|
..Default::default()
|
|
}],
|
|
on_cancel: Some(Box::new(|tx: &_| {
|
|
tx.send(AppEvent::OpenApprovalsPopup);
|
|
})),
|
|
..Default::default()
|
|
});
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
|
|
assert!(pane.active_view().is_some());
|
|
assert!(rx.try_recv().is_err());
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE));
|
|
|
|
assert!(pane.no_modal_or_popup_active());
|
|
assert!(matches!(rx.try_recv(), Ok(AppEvent::OpenApprovalsPopup)));
|
|
}
|
|
|
|
#[test]
|
|
fn esc_routes_to_handle_key_event_when_requested() {
|
|
#[derive(Default)]
|
|
struct EscRoutingView {
|
|
on_ctrl_c_calls: Rc<Cell<usize>>,
|
|
handle_calls: Rc<Cell<usize>>,
|
|
}
|
|
|
|
impl Renderable for EscRoutingView {
|
|
fn render(&self, _area: Rect, _buf: &mut Buffer) {}
|
|
|
|
fn desired_height(&self, _width: u16) -> u16 {
|
|
0
|
|
}
|
|
}
|
|
|
|
impl BottomPaneView for EscRoutingView {
|
|
fn handle_key_event(&mut self, _key_event: KeyEvent) {
|
|
self.handle_calls
|
|
.set(self.handle_calls.get().saturating_add(1));
|
|
}
|
|
|
|
fn on_ctrl_c(&mut self) -> CancellationEvent {
|
|
self.on_ctrl_c_calls
|
|
.set(self.on_ctrl_c_calls.get().saturating_add(1));
|
|
CancellationEvent::Handled
|
|
}
|
|
|
|
fn prefer_esc_to_handle_key_event(&self) -> bool {
|
|
true
|
|
}
|
|
}
|
|
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
let on_ctrl_c_calls = Rc::new(Cell::new(0));
|
|
let handle_calls = Rc::new(Cell::new(0));
|
|
pane.push_view(Box::new(EscRoutingView {
|
|
on_ctrl_c_calls: Rc::clone(&on_ctrl_c_calls),
|
|
handle_calls: Rc::clone(&handle_calls),
|
|
}));
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
|
|
|
assert_eq!(on_ctrl_c_calls.get(), 0);
|
|
assert_eq!(handle_calls.get(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn release_events_are_ignored_for_active_view() {
|
|
#[derive(Default)]
|
|
struct CountingView {
|
|
handle_calls: Rc<Cell<usize>>,
|
|
}
|
|
|
|
impl Renderable for CountingView {
|
|
fn render(&self, _area: Rect, _buf: &mut Buffer) {}
|
|
|
|
fn desired_height(&self, _width: u16) -> u16 {
|
|
0
|
|
}
|
|
}
|
|
|
|
impl BottomPaneView for CountingView {
|
|
fn handle_key_event(&mut self, _key_event: KeyEvent) {
|
|
self.handle_calls
|
|
.set(self.handle_calls.get().saturating_add(1));
|
|
}
|
|
}
|
|
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
let handle_calls = Rc::new(Cell::new(0));
|
|
pane.push_view(Box::new(CountingView {
|
|
handle_calls: Rc::clone(&handle_calls),
|
|
}));
|
|
|
|
pane.handle_key_event(KeyEvent::new_with_kind(
|
|
KeyCode::Down,
|
|
KeyModifiers::NONE,
|
|
KeyEventKind::Press,
|
|
));
|
|
pane.handle_key_event(KeyEvent::new_with_kind(
|
|
KeyCode::Down,
|
|
KeyModifiers::NONE,
|
|
KeyEventKind::Release,
|
|
));
|
|
|
|
assert_eq!(handle_calls.get(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn paste_completion_clears_stacked_views_and_restores_composer_input() {
|
|
#[derive(Default)]
|
|
struct BlockingView {
|
|
handle_calls: Rc<Cell<usize>>,
|
|
}
|
|
|
|
impl Renderable for BlockingView {
|
|
fn render(&self, _area: Rect, _buf: &mut Buffer) {}
|
|
|
|
fn desired_height(&self, _width: u16) -> u16 {
|
|
0
|
|
}
|
|
}
|
|
|
|
impl BottomPaneView for BlockingView {
|
|
fn handle_key_event(&mut self, _key_event: KeyEvent) {
|
|
self.handle_calls
|
|
.set(self.handle_calls.get().saturating_add(1));
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct PasteCompletesView {
|
|
complete: bool,
|
|
}
|
|
|
|
impl Renderable for PasteCompletesView {
|
|
fn render(&self, _area: Rect, _buf: &mut Buffer) {}
|
|
|
|
fn desired_height(&self, _width: u16) -> u16 {
|
|
0
|
|
}
|
|
}
|
|
|
|
impl BottomPaneView for PasteCompletesView {
|
|
fn handle_paste(&mut self, _pasted: String) -> bool {
|
|
self.complete = true;
|
|
true
|
|
}
|
|
|
|
fn is_complete(&self) -> bool {
|
|
self.complete
|
|
}
|
|
}
|
|
|
|
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,
|
|
effects: Default::default(),
|
|
skills: Some(Vec::new()),
|
|
});
|
|
|
|
pane.set_composer_input_enabled(/*enabled*/ false, /*placeholder*/ None);
|
|
|
|
let lower_view_handle_calls = Rc::new(Cell::new(0));
|
|
pane.push_view(Box::new(BlockingView {
|
|
handle_calls: Rc::clone(&lower_view_handle_calls),
|
|
}));
|
|
pane.push_view(Box::new(PasteCompletesView::default()));
|
|
|
|
pane.handle_paste("hello".to_string());
|
|
|
|
assert!(
|
|
pane.view_stack.is_empty(),
|
|
"paste completion should tear down the active modal flow"
|
|
);
|
|
|
|
pane.handle_key_event(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
|
|
|
|
let area = Rect::new(0, 0, 40, pane.desired_height(/*width*/ 40).max(2));
|
|
assert!(pane.cursor_pos(area).is_some());
|
|
assert_eq!(lower_view_handle_calls.get(), 0);
|
|
}
|
|
}
|