use crate::app_backtrack::BacktrackState; use crate::app_event::AppEvent; use crate::app_event_sender::AppEventSender; use crate::bottom_pane::ApprovalRequest; use crate::chatwidget::ChatWidget; use crate::clipboard_copy; use crate::custom_terminal::Frame; use crate::diff_render::DiffSummary; use crate::exec_command::strip_bash_lc_and_escape; use crate::file_search::FileSearchManager; use crate::history_cell::HistoryCell; use crate::history_cell::UserHistoryCell; use crate::model_migration::ModelMigrationOutcome; use crate::model_migration::migration_copy_for_models; use crate::model_migration::run_model_migration_prompt; use crate::pager_overlay::Overlay; use crate::render::highlight::highlight_bash_to_lines; use crate::render::renderable::Renderable; use crate::resume_picker::ResumeSelection; use crate::tui; use crate::tui::TuiEvent; use crate::tui::scrolling::TranscriptLineMeta; use crate::tui::scrolling::TranscriptScroll; use crate::update_action::UpdateAction; use crate::wrapping::RtOptions; use crate::wrapping::word_wrap_line; use crate::wrapping::word_wrap_lines_borrowed; use codex_ansi_escape::ansi_escape_line; use codex_core::AuthManager; use codex_core::ConversationManager; use codex_core::config::Config; use codex_core::config::edit::ConfigEditsBuilder; #[cfg(target_os = "windows")] use codex_core::features::Feature; use codex_core::openai_models::model_presets::HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG; use codex_core::openai_models::model_presets::HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG; use codex_core::openai_models::models_manager::ModelsManager; use codex_core::protocol::EventMsg; use codex_core::protocol::FinalOutput; use codex_core::protocol::ListSkillsResponseEvent; use codex_core::protocol::Op; use codex_core::protocol::SessionSource; use codex_core::protocol::SkillErrorInfo; use codex_core::protocol::TokenUsage; use codex_protocol::ConversationId; use codex_protocol::openai_models::ModelPreset; use codex_protocol::openai_models::ModelUpgrade; use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig; use color_eyre::eyre::Result; use color_eyre::eyre::WrapErr; use crossterm::event::KeyCode; use crossterm::event::KeyEvent; use crossterm::event::KeyEventKind; use crossterm::event::MouseButton; use ratatui::buffer::Buffer; use ratatui::layout::Rect; use ratatui::style::Stylize; use ratatui::text::Line; use ratatui::widgets::Clear; use ratatui::widgets::Paragraph; use ratatui::widgets::WidgetRef; use ratatui::widgets::Wrap; use std::collections::BTreeMap; use std::path::Path; use std::path::PathBuf; use std::sync::Arc; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering; use std::thread; use std::time::Duration; use tokio::select; use tokio::sync::mpsc::unbounded_channel; use unicode_width::UnicodeWidthStr; #[cfg(not(debug_assertions))] use crate::history_cell::UpdateAvailableHistoryCell; #[derive(Debug, Clone)] pub struct AppExitInfo { pub token_usage: TokenUsage, pub conversation_id: Option, pub update_action: Option, /// ANSI-styled transcript lines to print after the TUI exits. /// /// These lines are rendered against the same width as the final TUI /// viewport and include styling (colors, bold, etc.) so that scrollback /// preserves the visual structure of the on-screen transcript. pub session_lines: Vec, } impl From for codex_tui::AppExitInfo { fn from(info: AppExitInfo) -> Self { codex_tui::AppExitInfo { token_usage: info.token_usage, conversation_id: info.conversation_id, update_action: info.update_action.map(Into::into), } } } fn session_summary( token_usage: TokenUsage, conversation_id: Option, ) -> Option { if token_usage.is_zero() { return None; } let usage_line = FinalOutput::from(token_usage).to_string(); let resume_command = conversation_id.map(|conversation_id| format!("codex resume {conversation_id}")); Some(SessionSummary { usage_line, resume_command, }) } fn errors_for_cwd(cwd: &Path, response: &ListSkillsResponseEvent) -> Vec { response .skills .iter() .find(|entry| entry.cwd.as_path() == cwd) .map(|entry| entry.errors.clone()) .unwrap_or_default() } fn emit_skill_load_warnings(app_event_tx: &AppEventSender, errors: &[SkillErrorInfo]) { if errors.is_empty() { return; } let error_count = errors.len(); app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( crate::history_cell::new_warning_event(format!( "Skipped loading {error_count} skill(s) due to invalid SKILL.md files." )), ))); for error in errors { let path = error.path.display(); let message = error.message.as_str(); app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( crate::history_cell::new_warning_event(format!("{path}: {message}")), ))); } } #[derive(Debug, Clone, PartialEq, Eq)] struct SessionSummary { usage_line: String, resume_command: Option, } fn should_show_model_migration_prompt( current_model: &str, target_model: &str, seen_migrations: &BTreeMap, available_models: &[ModelPreset], ) -> bool { if target_model == current_model { return false; } if let Some(seen_target) = seen_migrations.get(current_model) && seen_target == target_model { return false; } if available_models .iter() .any(|preset| preset.model == current_model && preset.upgrade.is_some()) { return true; } if available_models .iter() .any(|preset| preset.upgrade.as_ref().map(|u| u.id.as_str()) == Some(target_model)) { return true; } false } fn migration_prompt_hidden(config: &Config, migration_config_key: &str) -> bool { match migration_config_key { HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG => config .notices .hide_gpt_5_1_codex_max_migration_prompt .unwrap_or(false), HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG => { config.notices.hide_gpt5_1_migration_prompt.unwrap_or(false) } _ => false, } } async fn handle_model_migration_prompt_if_needed( tui: &mut tui::Tui, config: &mut Config, model: &str, app_event_tx: &AppEventSender, models_manager: Arc, ) -> Option { let available_models = models_manager.list_models(config).await; let upgrade = available_models .iter() .find(|preset| preset.model == model) .and_then(|preset| preset.upgrade.as_ref()); if let Some(ModelUpgrade { id: target_model, reasoning_effort_mapping, migration_config_key, .. }) = upgrade { if migration_prompt_hidden(config, migration_config_key.as_str()) { return None; } let target_model = target_model.to_string(); if !should_show_model_migration_prompt( model, &target_model, &config.notices.model_migrations, &available_models, ) { return None; } let current_preset = available_models.iter().find(|preset| preset.model == model); let target_preset = available_models .iter() .find(|preset| preset.model == target_model); let target_display_name = target_preset .map(|preset| preset.display_name.clone()) .unwrap_or_else(|| target_model.clone()); let heading_label = if target_display_name == model { target_model.clone() } else { target_display_name.clone() }; let target_description = target_preset.and_then(|preset| { if preset.description.is_empty() { None } else { Some(preset.description.clone()) } }); let can_opt_out = current_preset.is_some(); let prompt_copy = migration_copy_for_models( model, &target_model, heading_label, target_description, can_opt_out, ); match run_model_migration_prompt(tui, prompt_copy).await { ModelMigrationOutcome::Accepted => { app_event_tx.send(AppEvent::PersistModelMigrationPromptAcknowledged { from_model: model.to_string(), to_model: target_model.clone(), }); config.model = Some(target_model.clone()); let mapped_effort = if let Some(reasoning_effort_mapping) = reasoning_effort_mapping && let Some(reasoning_effort) = config.model_reasoning_effort { reasoning_effort_mapping .get(&reasoning_effort) .cloned() .or(config.model_reasoning_effort) } else { config.model_reasoning_effort }; config.model_reasoning_effort = mapped_effort; app_event_tx.send(AppEvent::UpdateModel(target_model.clone())); app_event_tx.send(AppEvent::UpdateReasoningEffort(mapped_effort)); app_event_tx.send(AppEvent::PersistModelSelection { model: target_model.clone(), effort: mapped_effort, }); } ModelMigrationOutcome::Rejected => { app_event_tx.send(AppEvent::PersistModelMigrationPromptAcknowledged { from_model: model.to_string(), to_model: target_model.clone(), }); } ModelMigrationOutcome::Exit => { return Some(AppExitInfo { token_usage: TokenUsage::default(), conversation_id: None, update_action: None, session_lines: Vec::new(), }); } } } None } pub(crate) struct App { pub(crate) server: Arc, pub(crate) app_event_tx: AppEventSender, pub(crate) chat_widget: ChatWidget, pub(crate) auth_manager: Arc, /// Config is stored here so we can recreate ChatWidgets as needed. pub(crate) config: Config, pub(crate) current_model: String, pub(crate) active_profile: Option, pub(crate) file_search: FileSearchManager, pub(crate) transcript_cells: Vec>, #[allow(dead_code)] transcript_scroll: TranscriptScroll, transcript_selection: TranscriptSelection, transcript_view_top: usize, transcript_total_lines: usize, // Pager overlay state (Transcript or Static like Diff) pub(crate) overlay: Option, pub(crate) deferred_history_lines: Vec>, has_emitted_history_lines: bool, pub(crate) enhanced_keys_supported: bool, /// Controls the animation thread that sends CommitTick events. pub(crate) commit_anim_running: Arc, // Esc-backtracking state grouped pub(crate) backtrack: crate::app_backtrack::BacktrackState, pub(crate) feedback: codex_feedback::CodexFeedback, /// Set when the user confirms an update; propagated on exit. pub(crate) pending_update_action: Option, /// Ignore the next ShutdownComplete event when we're intentionally /// stopping a conversation (e.g., before starting a new one). suppress_shutdown_complete: bool, // One-shot suppression of the next world-writable scan after user confirmation. skip_world_writable_scan_once: bool, } /// Content-relative selection within the inline transcript viewport. /// /// Selection endpoints are expressed in terms of flattened, wrapped transcript /// line indices and columns, so the highlight tracks logical conversation /// content even when the viewport scrolls or the terminal is resized. #[derive(Debug, Clone, Copy, Default)] struct TranscriptSelection { anchor: Option, head: Option, } /// A single endpoint of a transcript selection. /// /// `line_index` is an index into the flattened wrapped transcript lines, and /// `column` is a zero-based column offset within that visual line, counted from /// the first content column to the right of the transcript gutter. #[derive(Debug, Clone, Copy, PartialEq, Eq)] struct TranscriptSelectionPoint { line_index: usize, column: u16, } impl App { async fn shutdown_current_conversation(&mut self) { if let Some(conversation_id) = self.chat_widget.conversation_id() { self.suppress_shutdown_complete = true; self.chat_widget.submit_op(Op::Shutdown); self.server.remove_conversation(&conversation_id).await; } } #[allow(clippy::too_many_arguments)] pub async fn run( tui: &mut tui::Tui, auth_manager: Arc, mut config: Config, active_profile: Option, initial_prompt: Option, initial_images: Vec, resume_selection: ResumeSelection, feedback: codex_feedback::CodexFeedback, is_first_run: bool, ) -> Result { use tokio_stream::StreamExt; let (app_event_tx, mut app_event_rx) = unbounded_channel(); let app_event_tx = AppEventSender::new(app_event_tx); let conversation_manager = Arc::new(ConversationManager::new( auth_manager.clone(), SessionSource::Cli, )); let mut model = conversation_manager .get_models_manager() .get_model(&config.model, &config) .await; let exit_info = handle_model_migration_prompt_if_needed( tui, &mut config, model.as_str(), &app_event_tx, conversation_manager.get_models_manager(), ) .await; if let Some(exit_info) = exit_info { return Ok(exit_info); } if let Some(updated_model) = config.model.clone() { model = updated_model; } let enhanced_keys_supported = tui.enhanced_keys_supported(); let model_family = conversation_manager .get_models_manager() .construct_model_family(model.as_str(), &config) .await; let mut chat_widget = match resume_selection { ResumeSelection::StartFresh | ResumeSelection::Exit => { let init = crate::chatwidget::ChatWidgetInit { config: config.clone(), frame_requester: tui.frame_requester(), app_event_tx: app_event_tx.clone(), initial_prompt: initial_prompt.clone(), initial_images: initial_images.clone(), enhanced_keys_supported, auth_manager: auth_manager.clone(), models_manager: conversation_manager.get_models_manager(), feedback: feedback.clone(), is_first_run, model_family: model_family.clone(), }; ChatWidget::new(init, conversation_manager.clone()) } ResumeSelection::Resume(path) => { let resumed = conversation_manager .resume_conversation_from_rollout( config.clone(), path.clone(), auth_manager.clone(), ) .await .wrap_err_with(|| { format!("Failed to resume session from {}", path.display()) })?; let init = crate::chatwidget::ChatWidgetInit { config: config.clone(), frame_requester: tui.frame_requester(), app_event_tx: app_event_tx.clone(), initial_prompt: initial_prompt.clone(), initial_images: initial_images.clone(), enhanced_keys_supported, auth_manager: auth_manager.clone(), models_manager: conversation_manager.get_models_manager(), feedback: feedback.clone(), is_first_run, model_family: model_family.clone(), }; ChatWidget::new_from_existing( init, resumed.conversation, resumed.session_configured, ) } }; chat_widget.maybe_prompt_windows_sandbox_enable(); let file_search = FileSearchManager::new(config.cwd.clone(), app_event_tx.clone()); #[cfg(not(debug_assertions))] let upgrade_version = crate::updates::get_upgrade_version(&config); let mut app = Self { server: conversation_manager.clone(), app_event_tx, chat_widget, auth_manager: auth_manager.clone(), config, current_model: model.clone(), active_profile, file_search, enhanced_keys_supported, transcript_cells: Vec::new(), transcript_scroll: TranscriptScroll::default(), transcript_selection: TranscriptSelection::default(), transcript_view_top: 0, transcript_total_lines: 0, overlay: None, deferred_history_lines: Vec::new(), has_emitted_history_lines: false, commit_anim_running: Arc::new(AtomicBool::new(false)), backtrack: BacktrackState::default(), feedback: feedback.clone(), pending_update_action: None, suppress_shutdown_complete: false, skip_world_writable_scan_once: false, }; // On startup, if Agent mode (workspace-write) or ReadOnly is active, warn about world-writable dirs on Windows. #[cfg(target_os = "windows")] { let should_check = codex_core::get_platform_sandbox().is_some() && matches!( app.config.sandbox_policy, codex_core::protocol::SandboxPolicy::WorkspaceWrite { .. } | codex_core::protocol::SandboxPolicy::ReadOnly ) && !app .config .notices .hide_world_writable_warning .unwrap_or(false); if should_check { let cwd = app.config.cwd.clone(); let env_map: std::collections::HashMap = std::env::vars().collect(); let tx = app.app_event_tx.clone(); let logs_base_dir = app.config.codex_home.clone(); let sandbox_policy = app.config.sandbox_policy.clone(); Self::spawn_world_writable_scan(cwd, env_map, logs_base_dir, sandbox_policy, tx); } } #[cfg(not(debug_assertions))] if let Some(latest_version) = upgrade_version { app.handle_event( tui, AppEvent::InsertHistoryCell(Box::new(UpdateAvailableHistoryCell::new( latest_version, crate::update_action::get_update_action(), ))), ) .await?; } let tui_events = tui.event_stream(); tokio::pin!(tui_events); tui.frame_requester().schedule_frame(); while select! { Some(event) = app_event_rx.recv() => { app.handle_event(tui, event).await? } Some(event) = tui_events.next() => { app.handle_tui_event(tui, event).await? } } {} let width = tui.terminal.last_known_screen_size.width; let session_lines = if width == 0 { Vec::new() } else { let (lines, line_meta) = Self::build_transcript_lines(&app.transcript_cells, width); let is_user_cell: Vec = app .transcript_cells .iter() .map(|cell| cell.as_any().is::()) .collect(); Self::render_lines_to_ansi(&lines, &line_meta, &is_user_cell, width) }; tui.terminal.clear()?; Ok(AppExitInfo { token_usage: app.token_usage(), conversation_id: app.chat_widget.conversation_id(), update_action: app.pending_update_action, session_lines, }) } pub(crate) async fn handle_tui_event( &mut self, tui: &mut tui::Tui, event: TuiEvent, ) -> Result { if self.overlay.is_some() { let _ = self.handle_backtrack_overlay_event(tui, event).await?; } else { match event { TuiEvent::Key(key_event) => { self.handle_key_event(tui, key_event).await; } TuiEvent::Mouse(mouse_event) => { self.handle_mouse_event(tui, mouse_event); } TuiEvent::Paste(pasted) => { // Many terminals convert newlines to \r when pasting (e.g., iTerm2), // but tui-textarea expects \n. Normalize CR to LF. // [tui-textarea]: https://github.com/rhysd/tui-textarea/blob/4d18622eeac13b309e0ff6a55a46ac6706da68cf/src/textarea.rs#L782-L783 // [iTerm2]: https://github.com/gnachman/iTerm2/blob/5d0c0d9f68523cbd0494dad5422998964a2ecd8d/sources/iTermPasteHelper.m#L206-L216 let pasted = pasted.replace("\r", "\n"); self.chat_widget.handle_paste(pasted); } TuiEvent::Draw => { self.chat_widget.maybe_post_pending_notification(tui); if self .chat_widget .handle_paste_burst_tick(tui.frame_requester()) { return Ok(true); } let cells = self.transcript_cells.clone(); tui.draw(tui.terminal.size()?.height, |frame| { let chat_height = self.chat_widget.desired_height(frame.area().width); let chat_top = self.render_transcript_cells(frame, &cells, chat_height); let chat_area = Rect { x: frame.area().x, y: chat_top, width: frame.area().width, height: chat_height.min( frame .area() .height .saturating_sub(chat_top.saturating_sub(frame.area().y)), ), }; self.chat_widget.render(chat_area, frame.buffer); let chat_bottom = chat_area.y.saturating_add(chat_area.height); if chat_bottom < frame.area().bottom() { Clear.render_ref( Rect { x: frame.area().x, y: chat_bottom, width: frame.area().width, height: frame.area().bottom().saturating_sub(chat_bottom), }, frame.buffer, ); } if let Some((x, y)) = self.chat_widget.cursor_pos(chat_area) { frame.set_cursor_position((x, y)); } })?; let transcript_scrolled = !matches!(self.transcript_scroll, TranscriptScroll::ToBottom); let selection_active = matches!( (self.transcript_selection.anchor, self.transcript_selection.head), (Some(a), Some(b)) if a != b ); let scroll_position = if self.transcript_total_lines == 0 { None } else { Some(( self.transcript_view_top.saturating_add(1), self.transcript_total_lines, )) }; self.chat_widget.set_transcript_ui_state( transcript_scrolled, selection_active, scroll_position, ); } } } Ok(true) } pub(crate) fn render_transcript_cells( &mut self, frame: &mut Frame, cells: &[Arc], chat_height: u16, ) -> u16 { let area = frame.area(); if area.width == 0 || area.height == 0 { self.transcript_scroll = TranscriptScroll::default(); self.transcript_view_top = 0; self.transcript_total_lines = 0; return area.bottom().saturating_sub(chat_height); } let chat_height = chat_height.min(area.height); let max_transcript_height = area.height.saturating_sub(chat_height); if max_transcript_height == 0 { self.transcript_scroll = TranscriptScroll::default(); self.transcript_view_top = 0; self.transcript_total_lines = 0; return area.y; } let transcript_area = Rect { x: area.x, y: area.y, width: area.width, height: max_transcript_height, }; let (lines, line_meta) = Self::build_transcript_lines(cells, transcript_area.width); if lines.is_empty() { Clear.render_ref(transcript_area, frame.buffer); self.transcript_scroll = TranscriptScroll::default(); self.transcript_view_top = 0; self.transcript_total_lines = 0; return area.y; } let wrapped = word_wrap_lines_borrowed(&lines, transcript_area.width.max(1) as usize); if wrapped.is_empty() { self.transcript_scroll = TranscriptScroll::default(); self.transcript_view_top = 0; self.transcript_total_lines = 0; return area.y; } let is_user_cell: Vec = cells .iter() .map(|c| c.as_any().is::()) .collect(); let base_opts: RtOptions<'_> = RtOptions::new(transcript_area.width.max(1) as usize); let mut wrapped_is_user_row: Vec = Vec::with_capacity(wrapped.len()); let mut first = true; for (idx, line) in lines.iter().enumerate() { let opts = if first { base_opts.clone() } else { base_opts .clone() .initial_indent(base_opts.subsequent_indent.clone()) }; let seg_count = word_wrap_line(line, opts).len(); let is_user_row = line_meta .get(idx) .and_then(TranscriptLineMeta::cell_index) .map(|cell_index| is_user_cell.get(cell_index).copied().unwrap_or(false)) .unwrap_or(false); wrapped_is_user_row.extend(std::iter::repeat_n(is_user_row, seg_count)); first = false; } let total_lines = wrapped.len(); self.transcript_total_lines = total_lines; let max_visible = std::cmp::min(max_transcript_height as usize, total_lines); let max_start = total_lines.saturating_sub(max_visible); let (scroll_state, top_offset) = self.transcript_scroll.resolve_top(&line_meta, max_start); self.transcript_scroll = scroll_state; self.transcript_view_top = top_offset; let transcript_visible_height = max_visible as u16; let chat_top = if total_lines <= max_transcript_height as usize { let gap = if transcript_visible_height == 0 { 0 } else { 1 }; area.y .saturating_add(transcript_visible_height) .saturating_add(gap) } else { area.bottom().saturating_sub(chat_height) }; let clear_height = chat_top.saturating_sub(area.y); if clear_height > 0 { Clear.render_ref( Rect { x: area.x, y: area.y, width: area.width, height: clear_height, }, frame.buffer, ); } let transcript_area = Rect { x: area.x, y: area.y, width: area.width, height: transcript_visible_height, }; for (row_index, line_index) in (top_offset..total_lines).enumerate() { if row_index >= max_visible { break; } let y = transcript_area.y + row_index as u16; let row_area = Rect { x: transcript_area.x, y, width: transcript_area.width, height: 1, }; if wrapped_is_user_row .get(line_index) .copied() .unwrap_or(false) { let base_style = crate::style::user_message_style(); for x in row_area.x..row_area.right() { let cell = &mut frame.buffer[(x, y)]; let style = cell.style().patch(base_style); cell.set_style(style); } } wrapped[line_index].render_ref(row_area, frame.buffer); } self.apply_transcript_selection(transcript_area, frame.buffer); chat_top } /// Handle mouse interaction in the main transcript view. /// /// - Mouse wheel movement scrolls the conversation history by small, fixed increments, /// independent of the terminal's own scrollback. /// - Mouse clicks and drags adjust a text selection defined in terms of /// flattened transcript lines and columns, so the selection is anchored /// to the underlying content rather than absolute screen rows. /// - When the user drags to extend a selection while the view is following the bottom /// and a task is actively running (e.g., streaming a response), the scroll mode is /// first converted into an anchored position so that ongoing updates no longer move /// the viewport under the selection. A simple click without a drag does not change /// scroll behavior. fn handle_mouse_event( &mut self, tui: &mut tui::Tui, mouse_event: crossterm::event::MouseEvent, ) { use crossterm::event::MouseEventKind; if self.overlay.is_some() { return; } let size = tui.terminal.last_known_screen_size; let width = size.width; let height = size.height; if width == 0 || height == 0 { return; } let chat_height = self.chat_widget.desired_height(width); if chat_height >= height { return; } // Only handle events over the transcript area above the composer. let transcript_height = height.saturating_sub(chat_height); if transcript_height == 0 { return; } let transcript_area = Rect { x: 0, y: 0, width, height: transcript_height, }; let base_x = transcript_area.x.saturating_add(2); let max_x = transcript_area.right().saturating_sub(1); let mut clamped_x = mouse_event.column; let mut clamped_y = mouse_event.row; if clamped_y < transcript_area.y || clamped_y >= transcript_area.bottom() { clamped_y = transcript_area.y; } if clamped_x < base_x { clamped_x = base_x; } if clamped_x > max_x { clamped_x = max_x; } let streaming = self.chat_widget.is_task_running(); match mouse_event.kind { MouseEventKind::ScrollUp => { self.scroll_transcript( tui, -3, transcript_area.height as usize, transcript_area.width, ); } MouseEventKind::ScrollDown => { self.scroll_transcript( tui, 3, transcript_area.height as usize, transcript_area.width, ); } MouseEventKind::Down(MouseButton::Left) => { if let Some(point) = self.transcript_point_from_coordinates( transcript_area, base_x, clamped_x, clamped_y, ) { self.transcript_selection.anchor = Some(point); self.transcript_selection.head = Some(point); } } MouseEventKind::Drag(MouseButton::Left) => { if let Some(anchor) = self.transcript_selection.anchor && let Some(point) = self.transcript_point_from_coordinates( transcript_area, base_x, clamped_x, clamped_y, ) { if streaming && matches!(self.transcript_scroll, TranscriptScroll::ToBottom) && point != anchor { self.lock_transcript_scroll_to_current_view( transcript_area.height as usize, transcript_area.width, ); } self.transcript_selection.head = Some(point); } } MouseEventKind::Up(MouseButton::Left) => { if self.transcript_selection.anchor == self.transcript_selection.head { self.transcript_selection = TranscriptSelection::default(); } } _ => {} } } /// Scroll the transcript by a fixed number of visual lines. /// /// This is the shared implementation behind mouse wheel movement and PgUp/PgDn keys in /// the main view. Scroll state is expressed in terms of transcript cells and their /// internal line indices, so scrolling refers to logical conversation content and /// remains stable even as wrapping or streaming causes visual reflows. fn scroll_transcript( &mut self, tui: &mut tui::Tui, delta_lines: i32, visible_lines: usize, width: u16, ) { if visible_lines == 0 { return; } let (_, line_meta) = Self::build_transcript_lines(&self.transcript_cells, width); self.transcript_scroll = self.transcript_scroll .scrolled_by(delta_lines, &line_meta, visible_lines); tui.frame_requester().schedule_frame(); } /// Convert a `ToBottom` (auto-follow) scroll state into a fixed anchor at the current view. /// /// When the user begins a mouse selection while new output is streaming in, the view /// should stop auto-following the latest line so the selection stays on the intended /// content. This helper inspects the flattened transcript at the given width, derives /// a concrete position corresponding to the current top row, and switches into a scroll /// mode that keeps that position stable until the user scrolls again. fn lock_transcript_scroll_to_current_view(&mut self, visible_lines: usize, width: u16) { if self.transcript_cells.is_empty() || visible_lines == 0 || width == 0 { return; } let (lines, line_meta) = Self::build_transcript_lines(&self.transcript_cells, width); if lines.is_empty() || line_meta.is_empty() { return; } let total_lines = lines.len(); let max_visible = std::cmp::min(visible_lines, total_lines); if max_visible == 0 { return; } let max_start = total_lines.saturating_sub(max_visible); let top_offset = match self.transcript_scroll { TranscriptScroll::ToBottom => max_start, TranscriptScroll::Scrolled { .. } => { // Already anchored; nothing to lock. return; } }; if let Some(scroll_state) = TranscriptScroll::anchor_for(&line_meta, top_offset) { self.transcript_scroll = scroll_state; } } /// Build the flattened transcript lines for rendering, scrolling, and exit transcripts. /// /// Returns both the visible `Line` buffer and a parallel metadata vector /// that maps each line back to its originating `(cell_index, line_in_cell)` /// pair (see `TranscriptLineMeta::CellLine`), or `TranscriptLineMeta::Spacer` for /// synthetic spacer rows inserted between cells. This allows the scroll state /// to anchor to a specific history cell even as new content arrives or the /// viewport size changes, and gives exit transcript renderers enough structure /// to style user rows differently from agent rows. fn build_transcript_lines( cells: &[Arc], width: u16, ) -> (Vec>, Vec) { let mut lines: Vec> = Vec::new(); let mut line_meta: Vec = Vec::new(); let mut has_emitted_lines = false; for (cell_index, cell) in cells.iter().enumerate() { let cell_lines = cell.display_lines(width); if cell_lines.is_empty() { continue; } if !cell.is_stream_continuation() { if has_emitted_lines { lines.push(Line::from("")); line_meta.push(TranscriptLineMeta::Spacer); } else { has_emitted_lines = true; } } for (line_in_cell, line) in cell_lines.into_iter().enumerate() { line_meta.push(TranscriptLineMeta::CellLine { cell_index, line_in_cell, }); lines.push(line); } } (lines, line_meta) } /// Render flattened transcript lines into ANSI strings suitable for /// printing after the TUI exits. /// /// This helper mirrors the original TUI viewport behavior: /// - Merges line-level style into each span so the ANSI output matches /// the on-screen styling (e.g., blockquotes, lists). /// - For user-authored rows, pads the background style out to the full /// terminal width so prompts appear as solid blocks in scrollback. /// - Streams spans through the shared vt100 writer so downstream tests /// and tools see consistent escape sequences. fn render_lines_to_ansi( lines: &[Line<'static>], line_meta: &[TranscriptLineMeta], is_user_cell: &[bool], width: u16, ) -> Vec { lines .iter() .enumerate() .map(|(idx, line)| { let is_user_row = line_meta .get(idx) .and_then(TranscriptLineMeta::cell_index) .map(|cell_index| is_user_cell.get(cell_index).copied().unwrap_or(false)) .unwrap_or(false); let mut merged_spans: Vec> = line .spans .iter() .map(|span| ratatui::text::Span { style: span.style.patch(line.style), content: span.content.clone(), }) .collect(); if is_user_row && width > 0 { let text: String = merged_spans .iter() .map(|span| span.content.as_ref()) .collect(); let text_width = UnicodeWidthStr::width(text.as_str()); let total_width = usize::from(width); if text_width < total_width { let pad_len = total_width.saturating_sub(text_width); if pad_len > 0 { let pad_style = crate::style::user_message_style(); merged_spans.push(ratatui::text::Span { style: pad_style, content: " ".repeat(pad_len).into(), }); } } } let mut buf: Vec = Vec::new(); let _ = crate::insert_history::write_spans(&mut buf, merged_spans.iter()); String::from_utf8(buf).unwrap_or_default() }) .collect() } /// Apply the current transcript selection to the given buffer. /// /// The selection is defined in terms of flattened wrapped transcript line /// indices and columns. This method maps those content-relative endpoints /// into the currently visible viewport based on `transcript_view_top` and /// `transcript_total_lines`, so the highlight moves with the content as the /// user scrolls. fn apply_transcript_selection(&self, area: Rect, buf: &mut Buffer) { let (anchor, head) = match ( self.transcript_selection.anchor, self.transcript_selection.head, ) { (Some(a), Some(h)) => (a, h), _ => return, }; if self.transcript_total_lines == 0 { return; } let base_x = area.x.saturating_add(2); let max_x = area.right().saturating_sub(1); let mut start = anchor; let mut end = head; if (end.line_index < start.line_index) || (end.line_index == start.line_index && end.column < start.column) { std::mem::swap(&mut start, &mut end); } let visible_start = self.transcript_view_top; let visible_end = self .transcript_view_top .saturating_add(area.height as usize) .min(self.transcript_total_lines); for (row_index, line_index) in (visible_start..visible_end).enumerate() { if line_index < start.line_index || line_index > end.line_index { continue; } let y = area.y + row_index as u16; let mut first_text_x = None; let mut last_text_x = None; for x in base_x..=max_x { let cell = &buf[(x, y)]; if cell.symbol() != " " { if first_text_x.is_none() { first_text_x = Some(x); } last_text_x = Some(x); } } let (text_start, text_end) = match (first_text_x, last_text_x) { // Treat indentation spaces as part of the selectable region by // starting from the first content column to the right of the // transcript gutter, but still clamp to the last non-space // glyph so trailing padding is not included. (Some(_), Some(e)) => (base_x, e), _ => continue, }; let line_start_col = if line_index == start.line_index { start.column } else { 0 }; let line_end_col = if line_index == end.line_index { end.column } else { max_x.saturating_sub(base_x) }; let row_sel_start = base_x.saturating_add(line_start_col); let row_sel_end = base_x.saturating_add(line_end_col).min(max_x); if row_sel_start > row_sel_end { continue; } let from_x = row_sel_start.max(text_start); let to_x = row_sel_end.min(text_end); if from_x > to_x { continue; } for x in from_x..=to_x { let cell = &mut buf[(x, y)]; let style = cell.style(); cell.set_style(style.add_modifier(ratatui::style::Modifier::REVERSED)); } } } /// Copy the currently selected transcript region to the system clipboard. /// /// The selection is defined in terms of flattened wrapped transcript line /// indices and columns, and this method reconstructs the same wrapped /// transcript used for on-screen rendering so the copied text closely /// matches the highlighted region. fn copy_transcript_selection(&mut self, tui: &tui::Tui) { let (anchor, head) = match ( self.transcript_selection.anchor, self.transcript_selection.head, ) { (Some(a), Some(h)) if a != h => (a, h), _ => return, }; let size = tui.terminal.last_known_screen_size; let width = size.width; let height = size.height; if width == 0 || height == 0 { return; } let chat_height = self.chat_widget.desired_height(width); if chat_height >= height { return; } let transcript_height = height.saturating_sub(chat_height); if transcript_height == 0 { return; } let transcript_area = Rect { x: 0, y: 0, width, height: transcript_height, }; let cells = self.transcript_cells.clone(); let (lines, _) = Self::build_transcript_lines(&cells, transcript_area.width); if lines.is_empty() { return; } let wrapped = crate::wrapping::word_wrap_lines_borrowed( &lines, transcript_area.width.max(1) as usize, ); let total_lines = wrapped.len(); if total_lines == 0 { return; } let max_visible = transcript_area.height as usize; let visible_start = self .transcript_view_top .min(total_lines.saturating_sub(max_visible)); let visible_end = std::cmp::min(visible_start + max_visible, total_lines); let mut buf = Buffer::empty(transcript_area); Clear.render_ref(transcript_area, &mut buf); for (row_index, line_index) in (visible_start..visible_end).enumerate() { let row_area = Rect { x: transcript_area.x, y: transcript_area.y + row_index as u16, width: transcript_area.width, height: 1, }; wrapped[line_index].render_ref(row_area, &mut buf); } let base_x = transcript_area.x.saturating_add(2); let max_x = transcript_area.right().saturating_sub(1); let mut start = anchor; let mut end = head; if (end.line_index < start.line_index) || (end.line_index == start.line_index && end.column < start.column) { std::mem::swap(&mut start, &mut end); } let mut lines_out: Vec = Vec::new(); for (row_index, line_index) in (visible_start..visible_end).enumerate() { if line_index < start.line_index || line_index > end.line_index { continue; } let y = transcript_area.y + row_index as u16; let line_start_col = if line_index == start.line_index { start.column } else { 0 }; let line_end_col = if line_index == end.line_index { end.column } else { max_x.saturating_sub(base_x) }; let row_sel_start = base_x.saturating_add(line_start_col); let row_sel_end = base_x.saturating_add(line_end_col).min(max_x); if row_sel_start > row_sel_end { continue; } let mut first_text_x = None; let mut last_text_x = None; for x in base_x..=max_x { let cell = &buf[(x, y)]; if cell.symbol() != " " { if first_text_x.is_none() { first_text_x = Some(x); } last_text_x = Some(x); } } let (text_start, text_end) = match (first_text_x, last_text_x) { // Treat indentation spaces as part of the copyable region by // starting from the first content column to the right of the // transcript gutter, but still clamp to the last non-space // glyph so trailing padding is not included. (Some(_), Some(e)) => (base_x, e), _ => { lines_out.push(String::new()); continue; } }; let from_x = row_sel_start.max(text_start); let to_x = row_sel_end.min(text_end); if from_x > to_x { continue; } let mut line_text = String::new(); for x in from_x..=to_x { let cell = &buf[(x, y)]; let symbol = cell.symbol(); if !symbol.is_empty() { line_text.push_str(symbol); } } lines_out.push(line_text); } if lines_out.is_empty() { return; } let text = lines_out.join("\n"); if let Err(err) = clipboard_copy::copy_text(text) { tracing::error!(error = %err, "failed to copy selection to clipboard"); } } /// Map a mouse position in the transcript area to a content-relative /// selection point, if there is transcript content to select. fn transcript_point_from_coordinates( &self, transcript_area: Rect, base_x: u16, x: u16, y: u16, ) -> Option { if self.transcript_total_lines == 0 { return None; } let mut row_index = y.saturating_sub(transcript_area.y); if row_index >= transcript_area.height { if transcript_area.height == 0 { return None; } row_index = transcript_area.height.saturating_sub(1); } let max_line = self.transcript_total_lines.saturating_sub(1); let line_index = self .transcript_view_top .saturating_add(usize::from(row_index)) .min(max_line); let column = x.saturating_sub(base_x); Some(TranscriptSelectionPoint { line_index, column }) } async fn handle_event(&mut self, tui: &mut tui::Tui, event: AppEvent) -> Result { let model_family = self .server .get_models_manager() .construct_model_family(self.current_model.as_str(), &self.config) .await; match event { AppEvent::NewSession => { let summary = session_summary( self.chat_widget.token_usage(), self.chat_widget.conversation_id(), ); self.shutdown_current_conversation().await; let init = crate::chatwidget::ChatWidgetInit { config: self.config.clone(), frame_requester: tui.frame_requester(), app_event_tx: self.app_event_tx.clone(), initial_prompt: None, initial_images: Vec::new(), enhanced_keys_supported: self.enhanced_keys_supported, auth_manager: self.auth_manager.clone(), models_manager: self.server.get_models_manager(), feedback: self.feedback.clone(), is_first_run: false, model_family: model_family.clone(), }; self.chat_widget = ChatWidget::new(init, self.server.clone()); self.current_model = model_family.get_model_slug().to_string(); if let Some(summary) = summary { let mut lines: Vec> = vec![summary.usage_line.clone().into()]; if let Some(command) = summary.resume_command { let spans = vec!["To continue this session, run ".into(), command.cyan()]; lines.push(spans.into()); } self.chat_widget.add_plain_history_lines(lines); } tui.frame_requester().schedule_frame(); } AppEvent::OpenResumePicker => { match crate::resume_picker::run_resume_picker( tui, &self.config.codex_home, &self.config.model_provider_id, false, ) .await? { ResumeSelection::Resume(path) => { let summary = session_summary( self.chat_widget.token_usage(), self.chat_widget.conversation_id(), ); match self .server .resume_conversation_from_rollout( self.config.clone(), path.clone(), self.auth_manager.clone(), ) .await { Ok(resumed) => { self.shutdown_current_conversation().await; let init = crate::chatwidget::ChatWidgetInit { config: self.config.clone(), frame_requester: tui.frame_requester(), app_event_tx: self.app_event_tx.clone(), initial_prompt: None, initial_images: Vec::new(), enhanced_keys_supported: self.enhanced_keys_supported, auth_manager: self.auth_manager.clone(), models_manager: self.server.get_models_manager(), feedback: self.feedback.clone(), is_first_run: false, model_family: model_family.clone(), }; self.chat_widget = ChatWidget::new_from_existing( init, resumed.conversation, resumed.session_configured, ); self.current_model = model_family.get_model_slug().to_string(); if let Some(summary) = summary { let mut lines: Vec> = vec![summary.usage_line.clone().into()]; if let Some(command) = summary.resume_command { let spans = vec![ "To continue this session, run ".into(), command.cyan(), ]; lines.push(spans.into()); } self.chat_widget.add_plain_history_lines(lines); } } Err(err) => { self.chat_widget.add_error_message(format!( "Failed to resume session from {}: {err}", path.display() )); } } } ResumeSelection::Exit | ResumeSelection::StartFresh => {} } // Leaving alt-screen may blank the inline viewport; force a redraw either way. tui.frame_requester().schedule_frame(); } AppEvent::InsertHistoryCell(cell) => { let cell: Arc = cell.into(); if let Some(Overlay::Transcript(transcript)) = &mut self.overlay { transcript.insert_cell(cell.clone()); tui.frame_requester().schedule_frame(); } self.transcript_cells.push(cell.clone()); let mut display = cell.display_lines(tui.terminal.last_known_screen_size.width); if !display.is_empty() { // Only insert a separating blank line for new cells that are not // part of an ongoing stream. Streaming continuations should not // accrue extra blank lines between chunks. if !cell.is_stream_continuation() { if self.has_emitted_history_lines { display.insert(0, Line::from("")); } else { self.has_emitted_history_lines = true; } } if self.overlay.is_some() { self.deferred_history_lines.extend(display); } } } AppEvent::StartCommitAnimation => { if self .commit_anim_running .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) .is_ok() { let tx = self.app_event_tx.clone(); let running = self.commit_anim_running.clone(); thread::spawn(move || { while running.load(Ordering::Relaxed) { thread::sleep(Duration::from_millis(50)); tx.send(AppEvent::CommitTick); } }); } } AppEvent::StopCommitAnimation => { self.commit_anim_running.store(false, Ordering::Release); } AppEvent::CommitTick => { self.chat_widget.on_commit_tick(); } AppEvent::CodexEvent(event) => { if self.suppress_shutdown_complete && matches!(event.msg, EventMsg::ShutdownComplete) { self.suppress_shutdown_complete = false; return Ok(true); } if let EventMsg::ListSkillsResponse(response) = &event.msg { let cwd = self.chat_widget.config_ref().cwd.clone(); let errors = errors_for_cwd(&cwd, response); emit_skill_load_warnings(&self.app_event_tx, &errors); } self.chat_widget.handle_codex_event(event); } AppEvent::ConversationHistory(ev) => { self.on_conversation_history_for_backtrack(tui, ev).await?; } AppEvent::ExitRequest => { return Ok(false); } AppEvent::CodexOp(op) => self.chat_widget.submit_op(op), AppEvent::DiffResult(text) => { // Clear the in-progress state in the bottom pane self.chat_widget.on_diff_complete(); // Enter alternate screen using TUI helper and build pager lines let _ = tui.enter_alt_screen(); let pager_lines: Vec> = if text.trim().is_empty() { vec!["No changes detected.".italic().into()] } else { text.lines().map(ansi_escape_line).collect() }; self.overlay = Some(Overlay::new_static_with_lines( pager_lines, "D I F F".to_string(), )); tui.frame_requester().schedule_frame(); } AppEvent::StartFileSearch(query) => { if !query.is_empty() { self.file_search.on_user_query(query); } } AppEvent::FileSearchResult { query, matches } => { self.chat_widget.apply_file_search_result(query, matches); } AppEvent::RateLimitSnapshotFetched(snapshot) => { self.chat_widget.on_rate_limit_snapshot(Some(snapshot)); } AppEvent::UpdateReasoningEffort(effort) => { self.on_update_reasoning_effort(effort); } AppEvent::UpdateModel(model) => { let model_family = self .server .get_models_manager() .construct_model_family(&model, &self.config) .await; self.chat_widget.set_model(&model, model_family); self.current_model = model; } AppEvent::OpenReasoningPopup { model } => { self.chat_widget.open_reasoning_popup(model); } AppEvent::OpenAllModelsPopup { models } => { self.chat_widget.open_all_models_popup(models); } AppEvent::OpenFullAccessConfirmation { preset } => { self.chat_widget.open_full_access_confirmation(preset); } AppEvent::OpenWorldWritableWarningConfirmation { preset, sample_paths, extra_count, failed_scan, } => { self.chat_widget.open_world_writable_warning_confirmation( preset, sample_paths, extra_count, failed_scan, ); } AppEvent::OpenFeedbackNote { category, include_logs, } => { self.chat_widget.open_feedback_note(category, include_logs); } AppEvent::OpenFeedbackConsent { category } => { self.chat_widget.open_feedback_consent(category); } AppEvent::OpenWindowsSandboxEnablePrompt { preset } => { self.chat_widget.open_windows_sandbox_enable_prompt(preset); } AppEvent::EnableWindowsSandboxForAgentMode { preset } => { #[cfg(target_os = "windows")] { let profile = self.active_profile.as_deref(); let feature_key = Feature::WindowsSandbox.key(); match ConfigEditsBuilder::new(&self.config.codex_home) .with_profile(profile) .set_feature_enabled(feature_key, true) .apply() .await { Ok(()) => { self.config.set_windows_sandbox_globally(true); self.chat_widget.clear_forced_auto_mode_downgrade(); if let Some((sample_paths, extra_count, failed_scan)) = self.chat_widget.world_writable_warning_details() { self.app_event_tx.send( AppEvent::OpenWorldWritableWarningConfirmation { preset: Some(preset.clone()), sample_paths, extra_count, failed_scan, }, ); } else { self.app_event_tx.send(AppEvent::CodexOp( Op::OverrideTurnContext { cwd: None, approval_policy: Some(preset.approval), sandbox_policy: Some(preset.sandbox.clone()), model: None, effort: None, summary: None, }, )); self.app_event_tx .send(AppEvent::UpdateAskForApprovalPolicy(preset.approval)); self.app_event_tx .send(AppEvent::UpdateSandboxPolicy(preset.sandbox.clone())); self.chat_widget.add_info_message( "Enabled experimental Windows sandbox.".to_string(), None, ); } } Err(err) => { tracing::error!( error = %err, "failed to enable Windows sandbox feature" ); self.chat_widget.add_error_message(format!( "Failed to enable the Windows sandbox feature: {err}" )); } } } #[cfg(not(target_os = "windows"))] { let _ = preset; } } AppEvent::PersistModelSelection { model, effort } => { let profile = self.active_profile.as_deref(); match ConfigEditsBuilder::new(&self.config.codex_home) .with_profile(profile) .set_model(Some(model.as_str()), effort) .apply() .await { Ok(()) => { let mut message = format!("Model changed to {model}"); if let Some(label) = Self::reasoning_label_for(&model, effort) { message.push(' '); message.push_str(label); } if let Some(profile) = profile { message.push_str(" for "); message.push_str(profile); message.push_str(" profile"); } self.chat_widget.add_info_message(message, None); } Err(err) => { tracing::error!( error = %err, "failed to persist model selection" ); if let Some(profile) = profile { self.chat_widget.add_error_message(format!( "Failed to save model for profile `{profile}`: {err}" )); } else { self.chat_widget .add_error_message(format!("Failed to save default model: {err}")); } } } } AppEvent::UpdateAskForApprovalPolicy(policy) => { self.chat_widget.set_approval_policy(policy); } AppEvent::UpdateSandboxPolicy(policy) => { #[cfg(target_os = "windows")] let policy_is_workspace_write_or_ro = matches!( policy, codex_core::protocol::SandboxPolicy::WorkspaceWrite { .. } | codex_core::protocol::SandboxPolicy::ReadOnly ); self.config.sandbox_policy = policy.clone(); #[cfg(target_os = "windows")] if !matches!(policy, codex_core::protocol::SandboxPolicy::ReadOnly) || codex_core::get_platform_sandbox().is_some() { self.config.forced_auto_mode_downgraded_on_windows = false; } self.chat_widget.set_sandbox_policy(policy); // If sandbox policy becomes workspace-write or read-only, run the Windows world-writable scan. #[cfg(target_os = "windows")] { // One-shot suppression if the user just confirmed continue. if self.skip_world_writable_scan_once { self.skip_world_writable_scan_once = false; return Ok(true); } let should_check = codex_core::get_platform_sandbox().is_some() && policy_is_workspace_write_or_ro && !self.chat_widget.world_writable_warning_hidden(); if should_check { let cwd = self.config.cwd.clone(); let env_map: std::collections::HashMap = std::env::vars().collect(); let tx = self.app_event_tx.clone(); let logs_base_dir = self.config.codex_home.clone(); let sandbox_policy = self.config.sandbox_policy.clone(); Self::spawn_world_writable_scan( cwd, env_map, logs_base_dir, sandbox_policy, tx, ); } } } AppEvent::SkipNextWorldWritableScan => { self.skip_world_writable_scan_once = true; } AppEvent::UpdateFullAccessWarningAcknowledged(ack) => { self.chat_widget.set_full_access_warning_acknowledged(ack); } AppEvent::UpdateWorldWritableWarningAcknowledged(ack) => { self.chat_widget .set_world_writable_warning_acknowledged(ack); } AppEvent::UpdateRateLimitSwitchPromptHidden(hidden) => { self.chat_widget.set_rate_limit_switch_prompt_hidden(hidden); } AppEvent::PersistFullAccessWarningAcknowledged => { if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) .set_hide_full_access_warning(true) .apply() .await { tracing::error!( error = %err, "failed to persist full access warning acknowledgement" ); self.chat_widget.add_error_message(format!( "Failed to save full access confirmation preference: {err}" )); } } AppEvent::PersistWorldWritableWarningAcknowledged => { if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) .set_hide_world_writable_warning(true) .apply() .await { tracing::error!( error = %err, "failed to persist world-writable warning acknowledgement" ); self.chat_widget.add_error_message(format!( "Failed to save Agent mode warning preference: {err}" )); } } AppEvent::PersistRateLimitSwitchPromptHidden => { if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) .set_hide_rate_limit_model_nudge(true) .apply() .await { tracing::error!( error = %err, "failed to persist rate limit switch prompt preference" ); self.chat_widget.add_error_message(format!( "Failed to save rate limit reminder preference: {err}" )); } } AppEvent::PersistModelMigrationPromptAcknowledged { from_model, to_model, } => { if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) .record_model_migration_seen(from_model.as_str(), to_model.as_str()) .apply() .await { tracing::error!( error = %err, "failed to persist model migration prompt acknowledgement" ); self.chat_widget.add_error_message(format!( "Failed to save model migration prompt preference: {err}" )); } } AppEvent::OpenApprovalsPopup => { self.chat_widget.open_approvals_popup(); } AppEvent::OpenReviewBranchPicker(cwd) => { self.chat_widget.show_review_branch_picker(&cwd).await; } AppEvent::OpenReviewCommitPicker(cwd) => { self.chat_widget.show_review_commit_picker(&cwd).await; } AppEvent::OpenReviewCustomPrompt => { self.chat_widget.show_review_custom_prompt(); } AppEvent::FullScreenApprovalRequest(request) => match request { ApprovalRequest::ApplyPatch { cwd, changes, .. } => { let _ = tui.enter_alt_screen(); let diff_summary = DiffSummary::new(changes, cwd); self.overlay = Some(Overlay::new_static_with_renderables( vec![diff_summary.into()], "P A T C H".to_string(), )); } ApprovalRequest::Exec { command, .. } => { let _ = tui.enter_alt_screen(); let full_cmd = strip_bash_lc_and_escape(&command); let full_cmd_lines = highlight_bash_to_lines(&full_cmd); self.overlay = Some(Overlay::new_static_with_lines( full_cmd_lines, "E X E C".to_string(), )); } ApprovalRequest::McpElicitation { server_name, message, .. } => { let _ = tui.enter_alt_screen(); let paragraph = Paragraph::new(vec![ Line::from(vec!["Server: ".into(), server_name.bold()]), Line::from(""), Line::from(message), ]) .wrap(Wrap { trim: false }); self.overlay = Some(Overlay::new_static_with_renderables( vec![Box::new(paragraph)], "E L I C I T A T I O N".to_string(), )); } }, } Ok(true) } fn reasoning_label(reasoning_effort: Option) -> &'static str { match reasoning_effort { Some(ReasoningEffortConfig::Minimal) => "minimal", Some(ReasoningEffortConfig::Low) => "low", Some(ReasoningEffortConfig::Medium) => "medium", Some(ReasoningEffortConfig::High) => "high", Some(ReasoningEffortConfig::XHigh) => "xhigh", None | Some(ReasoningEffortConfig::None) => "default", } } fn reasoning_label_for( model: &str, reasoning_effort: Option, ) -> Option<&'static str> { (!model.starts_with("codex-auto-")).then(|| Self::reasoning_label(reasoning_effort)) } pub(crate) fn token_usage(&self) -> codex_core::protocol::TokenUsage { self.chat_widget.token_usage() } fn on_update_reasoning_effort(&mut self, effort: Option) { self.chat_widget.set_reasoning_effort(effort); self.config.model_reasoning_effort = effort; } async fn handle_key_event(&mut self, tui: &mut tui::Tui, key_event: KeyEvent) { match key_event { KeyEvent { code: KeyCode::Char('t'), modifiers: crossterm::event::KeyModifiers::CONTROL, kind: KeyEventKind::Press, .. } => { // Enter alternate screen and set viewport to full size. let _ = tui.enter_alt_screen(); self.overlay = Some(Overlay::new_transcript(self.transcript_cells.clone())); tui.frame_requester().schedule_frame(); } // Esc primes/advances backtracking only in normal (not working) mode // with the composer focused and empty. In any other state, forward // Esc so the active UI (e.g. status indicator, modals, popups) // handles it. KeyEvent { code: KeyCode::Esc, kind: KeyEventKind::Press | KeyEventKind::Repeat, .. } => { if self.chat_widget.is_normal_backtrack_mode() && self.chat_widget.composer_is_empty() { self.handle_backtrack_esc_key(tui); } else { self.chat_widget.handle_key_event(key_event); } } KeyEvent { code: KeyCode::Char('y'), modifiers: crossterm::event::KeyModifiers::CONTROL, kind: KeyEventKind::Press | KeyEventKind::Repeat, .. } => { self.copy_transcript_selection(tui); } KeyEvent { code: KeyCode::PageUp, kind: KeyEventKind::Press | KeyEventKind::Repeat, .. } => { let size = tui.terminal.last_known_screen_size; let width = size.width; let height = size.height; if width > 0 && height > 0 { let chat_height = self.chat_widget.desired_height(width); if chat_height < height { let transcript_height = height.saturating_sub(chat_height); if transcript_height > 0 { let delta = -i32::from(transcript_height); self.scroll_transcript( tui, delta, usize::from(transcript_height), width, ); } } } } KeyEvent { code: KeyCode::PageDown, kind: KeyEventKind::Press | KeyEventKind::Repeat, .. } => { let size = tui.terminal.last_known_screen_size; let width = size.width; let height = size.height; if width > 0 && height > 0 { let chat_height = self.chat_widget.desired_height(width); if chat_height < height { let transcript_height = height.saturating_sub(chat_height); if transcript_height > 0 { let delta = i32::from(transcript_height); self.scroll_transcript( tui, delta, usize::from(transcript_height), width, ); } } } } KeyEvent { code: KeyCode::Home, kind: KeyEventKind::Press | KeyEventKind::Repeat, .. } => { if !self.transcript_cells.is_empty() { self.transcript_scroll = TranscriptScroll::Scrolled { cell_index: 0, line_in_cell: 0, }; tui.frame_requester().schedule_frame(); } } KeyEvent { code: KeyCode::End, kind: KeyEventKind::Press | KeyEventKind::Repeat, .. } => { self.transcript_scroll = TranscriptScroll::ToBottom; tui.frame_requester().schedule_frame(); } // Enter confirms backtrack when primed + count > 0. Otherwise pass to widget. KeyEvent { code: KeyCode::Enter, kind: KeyEventKind::Press, .. } if self.backtrack.primed && self.backtrack.nth_user_message != usize::MAX && self.chat_widget.composer_is_empty() => { // Delegate to helper for clarity; preserves behavior. self.confirm_backtrack_from_main(); } KeyEvent { kind: KeyEventKind::Press | KeyEventKind::Repeat, .. } => { // Any non-Esc key press should cancel a primed backtrack. // This avoids stale "Esc-primed" state after the user starts typing // (even if they later backspace to empty). if key_event.code != KeyCode::Esc && self.backtrack.primed { self.reset_backtrack_state(); } self.chat_widget.handle_key_event(key_event); } _ => { // Ignore Release key events. } }; } #[cfg(target_os = "windows")] fn spawn_world_writable_scan( cwd: PathBuf, env_map: std::collections::HashMap, logs_base_dir: PathBuf, sandbox_policy: codex_core::protocol::SandboxPolicy, tx: AppEventSender, ) { tokio::task::spawn_blocking(move || { let result = codex_windows_sandbox::apply_world_writable_scan_and_denies( &logs_base_dir, &cwd, &env_map, &sandbox_policy, Some(logs_base_dir.as_path()), ); if result.is_err() { // Scan failed: warn without examples. tx.send(AppEvent::OpenWorldWritableWarningConfirmation { preset: None, sample_paths: Vec::new(), extra_count: 0usize, failed_scan: true, }); } }); } } #[cfg(test)] mod tests { use super::*; use crate::app_backtrack::BacktrackState; use crate::app_backtrack::user_count; use crate::chatwidget::tests::make_chatwidget_manual_with_sender; use crate::file_search::FileSearchManager; use crate::history_cell::AgentMessageCell; use crate::history_cell::HistoryCell; use crate::history_cell::UserHistoryCell; use crate::history_cell::new_session_info; use codex_core::AuthManager; use codex_core::CodexAuth; use codex_core::ConversationManager; use codex_core::protocol::AskForApproval; use codex_core::protocol::Event; use codex_core::protocol::EventMsg; use codex_core::protocol::SandboxPolicy; use codex_core::protocol::SessionConfiguredEvent; use codex_protocol::ConversationId; use pretty_assertions::assert_eq; use ratatui::prelude::Line; use std::path::PathBuf; use std::sync::Arc; use std::sync::atomic::AtomicBool; async fn make_test_app() -> App { let (chat_widget, app_event_tx, _rx, _op_rx) = make_chatwidget_manual_with_sender().await; let config = chat_widget.config_ref().clone(); let current_model = chat_widget.get_model_family().get_model_slug().to_string(); let server = Arc::new(ConversationManager::with_models_provider( CodexAuth::from_api_key("Test API Key"), config.model_provider.clone(), )); let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key")); let file_search = FileSearchManager::new(config.cwd.clone(), app_event_tx.clone()); App { server, app_event_tx, chat_widget, auth_manager, config, current_model, active_profile: None, file_search, transcript_cells: Vec::new(), transcript_scroll: TranscriptScroll::default(), transcript_selection: TranscriptSelection::default(), transcript_view_top: 0, transcript_total_lines: 0, overlay: None, deferred_history_lines: Vec::new(), has_emitted_history_lines: false, enhanced_keys_supported: false, commit_anim_running: Arc::new(AtomicBool::new(false)), backtrack: BacktrackState::default(), feedback: codex_feedback::CodexFeedback::new(), pending_update_action: None, suppress_shutdown_complete: false, skip_world_writable_scan_once: false, } } async fn make_test_app_with_channels() -> ( App, tokio::sync::mpsc::UnboundedReceiver, tokio::sync::mpsc::UnboundedReceiver, ) { let (chat_widget, app_event_tx, rx, op_rx) = make_chatwidget_manual_with_sender().await; let config = chat_widget.config_ref().clone(); let current_model = chat_widget.get_model_family().get_model_slug().to_string(); let server = Arc::new(ConversationManager::with_models_provider( CodexAuth::from_api_key("Test API Key"), config.model_provider.clone(), )); let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key")); let file_search = FileSearchManager::new(config.cwd.clone(), app_event_tx.clone()); ( App { server, app_event_tx, chat_widget, auth_manager, config, current_model, active_profile: None, file_search, transcript_cells: Vec::new(), transcript_scroll: TranscriptScroll::default(), transcript_selection: TranscriptSelection::default(), transcript_view_top: 0, transcript_total_lines: 0, overlay: None, deferred_history_lines: Vec::new(), has_emitted_history_lines: false, enhanced_keys_supported: false, commit_anim_running: Arc::new(AtomicBool::new(false)), backtrack: BacktrackState::default(), feedback: codex_feedback::CodexFeedback::new(), pending_update_action: None, suppress_shutdown_complete: false, skip_world_writable_scan_once: false, }, rx, op_rx, ) } fn all_model_presets() -> Vec { codex_core::openai_models::model_presets::all_model_presets().clone() } #[tokio::test] async fn model_migration_prompt_only_shows_for_deprecated_models() { let seen = BTreeMap::new(); assert!(should_show_model_migration_prompt( "gpt-5", "gpt-5.1", &seen, &all_model_presets() )); assert!(should_show_model_migration_prompt( "gpt-5-codex", "gpt-5.1-codex", &seen, &all_model_presets() )); assert!(should_show_model_migration_prompt( "gpt-5-codex-mini", "gpt-5.1-codex-mini", &seen, &all_model_presets() )); assert!(should_show_model_migration_prompt( "gpt-5.1-codex", "gpt-5.1-codex-max", &seen, &all_model_presets() )); assert!(!should_show_model_migration_prompt( "gpt-5.1-codex", "gpt-5.1-codex", &seen, &all_model_presets() )); } #[tokio::test] async fn model_migration_prompt_respects_hide_flag_and_self_target() { let mut seen = BTreeMap::new(); seen.insert("gpt-5".to_string(), "gpt-5.1".to_string()); assert!(!should_show_model_migration_prompt( "gpt-5", "gpt-5.1", &seen, &all_model_presets() )); assert!(!should_show_model_migration_prompt( "gpt-5.1", "gpt-5.1", &seen, &all_model_presets() )); } #[tokio::test] async fn update_reasoning_effort_updates_config() { let mut app = make_test_app().await; app.config.model_reasoning_effort = Some(ReasoningEffortConfig::Medium); app.chat_widget .set_reasoning_effort(Some(ReasoningEffortConfig::Medium)); app.on_update_reasoning_effort(Some(ReasoningEffortConfig::High)); assert_eq!( app.config.model_reasoning_effort, Some(ReasoningEffortConfig::High) ); assert_eq!( app.chat_widget.config_ref().model_reasoning_effort, Some(ReasoningEffortConfig::High) ); } #[tokio::test] async fn backtrack_selection_with_duplicate_history_targets_unique_turn() { let mut app = make_test_app().await; let user_cell = |text: &str| -> Arc { Arc::new(UserHistoryCell { message: text.to_string(), }) as Arc }; let agent_cell = |text: &str| -> Arc { Arc::new(AgentMessageCell::new( vec![Line::from(text.to_string())], true, )) as Arc }; let make_header = |is_first| { let event = SessionConfiguredEvent { session_id: ConversationId::new(), model: "gpt-test".to_string(), model_provider_id: "test-provider".to_string(), approval_policy: AskForApproval::Never, sandbox_policy: SandboxPolicy::ReadOnly, cwd: PathBuf::from("/home/user/project"), reasoning_effort: None, history_log_id: 0, history_entry_count: 0, initial_messages: None, rollout_path: PathBuf::new(), }; Arc::new(new_session_info( app.chat_widget.config_ref(), app.current_model.as_str(), event, is_first, )) as Arc }; // Simulate the transcript after trimming for a fork, replaying history, and // appending the edited turn. The session header separates the retained history // from the forked conversation's replayed turns. app.transcript_cells = vec![ make_header(true), user_cell("first question"), agent_cell("answer first"), user_cell("follow-up"), agent_cell("answer follow-up"), make_header(false), user_cell("first question"), agent_cell("answer first"), user_cell("follow-up (edited)"), agent_cell("answer edited"), ]; assert_eq!(user_count(&app.transcript_cells), 2); app.backtrack.base_id = Some(ConversationId::new()); app.backtrack.primed = true; app.backtrack.nth_user_message = user_count(&app.transcript_cells).saturating_sub(1); app.confirm_backtrack_from_main(); let (_, nth, prefill) = app.backtrack.pending.clone().expect("pending backtrack"); assert_eq!(nth, 1); assert_eq!(prefill, "follow-up (edited)"); } #[tokio::test] async fn transcript_selection_moves_with_scroll() { use ratatui::buffer::Buffer; use ratatui::layout::Rect; let mut app = make_test_app().await; app.transcript_total_lines = 3; let area = Rect { x: 0, y: 0, width: 10, height: 2, }; // Anchor selection to logical line 1, columns 2..4. app.transcript_selection = TranscriptSelection { anchor: Some(TranscriptSelectionPoint { line_index: 1, column: 2, }), head: Some(TranscriptSelectionPoint { line_index: 1, column: 4, }), }; // First render: top of view is line 0, so line 1 maps to the second row. app.transcript_view_top = 0; let mut buf = Buffer::empty(area); for x in 2..area.width { buf[(x, 0)].set_symbol("A"); buf[(x, 1)].set_symbol("B"); } app.apply_transcript_selection(area, &mut buf); // No selection should be applied to the first row when the view is anchored at the top. for x in 0..area.width { let cell = &buf[(x, 0)]; assert!(cell.style().add_modifier.is_empty()); } // After scrolling down by one line, the same logical line should now be // rendered on the first row, and the highlight should move with it. app.transcript_view_top = 1; let mut buf_scrolled = Buffer::empty(area); for x in 2..area.width { buf_scrolled[(x, 0)].set_symbol("B"); buf_scrolled[(x, 1)].set_symbol("C"); } app.apply_transcript_selection(area, &mut buf_scrolled); // After scrolling, the selection should now be applied on the first row rather than the // second. for x in 0..area.width { let cell = &buf_scrolled[(x, 1)]; assert!(cell.style().add_modifier.is_empty()); } } #[tokio::test] async fn new_session_requests_shutdown_for_previous_conversation() { let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; let conversation_id = ConversationId::new(); let event = SessionConfiguredEvent { session_id: conversation_id, model: "gpt-test".to_string(), model_provider_id: "test-provider".to_string(), approval_policy: AskForApproval::Never, sandbox_policy: SandboxPolicy::ReadOnly, cwd: PathBuf::from("/home/user/project"), reasoning_effort: None, history_log_id: 0, history_entry_count: 0, initial_messages: None, rollout_path: PathBuf::new(), }; app.chat_widget.handle_codex_event(Event { id: String::new(), msg: EventMsg::SessionConfigured(event), }); while app_event_rx.try_recv().is_ok() {} while op_rx.try_recv().is_ok() {} app.shutdown_current_conversation().await; match op_rx.try_recv() { Ok(Op::Shutdown) => {} Ok(other) => panic!("expected Op::Shutdown, got {other:?}"), Err(_) => panic!("expected shutdown op to be sent"), } } #[tokio::test] async fn session_summary_skip_zero_usage() { assert!(session_summary(TokenUsage::default(), None).is_none()); } #[tokio::test] async fn render_lines_to_ansi_pads_user_rows_to_full_width() { let line: Line<'static> = Line::from("hi"); let lines = vec![line]; let line_meta = vec![TranscriptLineMeta::CellLine { cell_index: 0, line_in_cell: 0, }]; let is_user_cell = vec![true]; let width: u16 = 10; let rendered = App::render_lines_to_ansi(&lines, &line_meta, &is_user_cell, width); assert_eq!(rendered.len(), 1); assert!(rendered[0].contains("hi")); } #[tokio::test] async fn session_summary_includes_resume_hint() { let usage = TokenUsage { input_tokens: 10, output_tokens: 2, total_tokens: 12, ..Default::default() }; let conversation = ConversationId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap(); let summary = session_summary(usage, Some(conversation)).expect("summary"); assert_eq!( summary.usage_line, "Token usage: total=12 input=10 output=2" ); assert_eq!( summary.resume_command, Some("codex resume 123e4567-e89b-12d3-a456-426614174000".to_string()) ); } }