mirror of
https://github.com/openai/codex.git
synced 2026-04-28 02:11:08 +03:00
97c54634f7
Add an in-viewport find experience for the TUI2 transcript (the scrollable region above the composer), without introducing a persistent search bar or scroll indicator. UX: - Ctrl-F opens a 1-row "/ " prompt above the composer and updates highlights live as you type - Ctrl-G jumps to the next match without closing the prompt, and keeps working after the prompt closes while the query is still active - Esc closes the prompt but keeps the active query/highlights; Esc again clears the search - Enter closes the prompt and jumps to the selected match Implementation: - Add a dedicated transcript_find module to own query/edit state, smart-case matching over flattened transcript lines, stable jump anchoring (cell + line-in-cell), and per-line highlight rendering - Keep app.rs integration additive via small delegation calls from the key handler and render loop - Plumb find visibility to the footer so shortcuts show Ctrl-G next match only while the find prompt is visible Docs/tests: - Add tui2/docs/transcript_find.md documenting current behavior vs the ideal/perfect end state and explicitly calling out deferred work - Stabilize VT100-based rendering tests by forcing color output and emitting crossterm fg/bg colors directly in insert-history output
2729 lines
106 KiB
Rust
2729 lines
106 KiB
Rust
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::transcript_copy_ui::TranscriptCopyUi;
|
|
use crate::transcript_find::TranscriptFind;
|
|
use crate::transcript_multi_click::TranscriptMultiClick;
|
|
use crate::transcript_selection::TRANSCRIPT_GUTTER_COLS;
|
|
use crate::transcript_selection::TranscriptSelection;
|
|
use crate::transcript_selection::TranscriptSelectionPoint;
|
|
use crate::tui;
|
|
use crate::tui::TuiEvent;
|
|
use crate::tui::scrolling::MouseScrollState;
|
|
use crate::tui::scrolling::ScrollConfig;
|
|
use crate::tui::scrolling::ScrollConfigOverrides;
|
|
use crate::tui::scrolling::ScrollDirection;
|
|
use crate::tui::scrolling::ScrollUpdate;
|
|
use crate::tui::scrolling::TranscriptLineMeta;
|
|
use crate::tui::scrolling::TranscriptScroll;
|
|
use crate::update_action::UpdateAction;
|
|
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::models_manager::manager::ModelsManager;
|
|
use codex_core::models_manager::model_presets::HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG;
|
|
use codex_core::models_manager::model_presets::HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG;
|
|
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_core::terminal::terminal_info;
|
|
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;
|
|
|
|
#[cfg(not(debug_assertions))]
|
|
use crate::history_cell::UpdateAvailableHistoryCell;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct AppExitInfo {
|
|
pub token_usage: TokenUsage,
|
|
pub conversation_id: Option<ConversationId>,
|
|
pub update_action: Option<UpdateAction>,
|
|
/// 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<String>,
|
|
}
|
|
|
|
impl From<AppExitInfo> 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<ConversationId>,
|
|
) -> Option<SessionSummary> {
|
|
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<SkillErrorInfo> {
|
|
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<String>,
|
|
}
|
|
|
|
fn should_show_model_migration_prompt(
|
|
current_model: &str,
|
|
target_model: &str,
|
|
seen_migrations: &BTreeMap<String, String>,
|
|
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<ModelsManager>,
|
|
) -> Option<AppExitInfo> {
|
|
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<ConversationManager>,
|
|
pub(crate) app_event_tx: AppEventSender,
|
|
pub(crate) chat_widget: ChatWidget,
|
|
pub(crate) auth_manager: Arc<AuthManager>,
|
|
/// 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<String>,
|
|
|
|
pub(crate) file_search: FileSearchManager,
|
|
|
|
pub(crate) transcript_cells: Vec<Arc<dyn HistoryCell>>,
|
|
|
|
#[allow(dead_code)]
|
|
transcript_scroll: TranscriptScroll,
|
|
transcript_selection: TranscriptSelection,
|
|
transcript_multi_click: TranscriptMultiClick,
|
|
transcript_view_top: usize,
|
|
transcript_total_lines: usize,
|
|
transcript_copy_ui: TranscriptCopyUi,
|
|
transcript_find: TranscriptFind,
|
|
|
|
// Pager overlay state (Transcript or Static like Diff)
|
|
pub(crate) overlay: Option<Overlay>,
|
|
pub(crate) deferred_history_lines: Vec<Line<'static>>,
|
|
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<AtomicBool>,
|
|
|
|
scroll_config: ScrollConfig,
|
|
scroll_state: MouseScrollState,
|
|
|
|
// 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<UpdateAction>,
|
|
|
|
/// 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,
|
|
}
|
|
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<AuthManager>,
|
|
mut config: Config,
|
|
active_profile: Option<String>,
|
|
initial_prompt: Option<String>,
|
|
initial_images: Vec<PathBuf>,
|
|
resume_selection: ResumeSelection,
|
|
feedback: codex_feedback::CodexFeedback,
|
|
is_first_run: bool,
|
|
) -> Result<AppExitInfo> {
|
|
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 scroll_config = ScrollConfig::from_terminal(
|
|
&terminal_info(),
|
|
ScrollConfigOverrides {
|
|
events_per_tick: config.tui_scroll_events_per_tick,
|
|
wheel_lines_per_tick: config.tui_scroll_wheel_lines,
|
|
trackpad_lines_per_tick: config.tui_scroll_trackpad_lines,
|
|
trackpad_accel_events: config.tui_scroll_trackpad_accel_events,
|
|
trackpad_accel_max: config.tui_scroll_trackpad_accel_max,
|
|
mode: Some(config.tui_scroll_mode),
|
|
wheel_tick_detect_max_ms: config.tui_scroll_wheel_tick_detect_max_ms,
|
|
wheel_like_max_duration_ms: config.tui_scroll_wheel_like_max_duration_ms,
|
|
invert_direction: config.tui_scroll_invert,
|
|
},
|
|
);
|
|
|
|
let copy_selection_shortcut = crate::transcript_copy_ui::detect_copy_selection_shortcut();
|
|
|
|
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_multi_click: TranscriptMultiClick::default(),
|
|
transcript_view_top: 0,
|
|
transcript_total_lines: 0,
|
|
transcript_copy_ui: TranscriptCopyUi::new_with_shortcut(copy_selection_shortcut),
|
|
transcript_find: TranscriptFind::default(),
|
|
overlay: None,
|
|
deferred_history_lines: Vec::new(),
|
|
has_emitted_history_lines: false,
|
|
commit_anim_running: Arc::new(AtomicBool::new(false)),
|
|
scroll_config,
|
|
scroll_state: MouseScrollState::default(),
|
|
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.get(),
|
|
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<String, String> = 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.get().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 transcript =
|
|
crate::transcript_render::build_transcript_lines(&app.transcript_cells, width);
|
|
let (lines, line_meta) = (transcript.lines, transcript.meta);
|
|
let is_user_cell: Vec<bool> = app
|
|
.transcript_cells
|
|
.iter()
|
|
.map(|cell| cell.as_any().is::<UserHistoryCell>())
|
|
.collect();
|
|
crate::transcript_render::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<bool> {
|
|
if matches!(&event, TuiEvent::Draw) {
|
|
self.handle_scroll_tick(tui);
|
|
}
|
|
|
|
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.transcript_find.cursor_position(frame.area(), chat_top)
|
|
{
|
|
frame.set_cursor_position((x, y));
|
|
} else 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,
|
|
self.copy_selection_key(),
|
|
self.transcript_find.is_visible(),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
Ok(true)
|
|
}
|
|
|
|
pub(crate) fn render_transcript_cells(
|
|
&mut self,
|
|
frame: &mut Frame,
|
|
cells: &[Arc<dyn HistoryCell>],
|
|
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 transcript =
|
|
crate::transcript_render::build_wrapped_transcript_lines(cells, transcript_area.width);
|
|
let (lines, line_meta) = (transcript.lines, transcript.meta);
|
|
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;
|
|
}
|
|
|
|
if let Some((cell_index, line_in_cell)) = self.transcript_find.on_render(
|
|
&lines,
|
|
&line_meta,
|
|
transcript_area.width,
|
|
self.transcript_view_top,
|
|
) {
|
|
self.transcript_scroll = TranscriptScroll::Scrolled {
|
|
cell_index,
|
|
line_in_cell,
|
|
};
|
|
}
|
|
let is_user_cell: Vec<bool> = cells
|
|
.iter()
|
|
.map(|c| c.as_any().is::<UserHistoryCell>())
|
|
.collect();
|
|
|
|
let total_lines = lines.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,
|
|
};
|
|
|
|
let is_user_row = line_meta
|
|
.get(line_index)
|
|
.and_then(TranscriptLineMeta::cell_index)
|
|
.map(|cell_index| is_user_cell.get(cell_index).copied().unwrap_or(false))
|
|
.unwrap_or(false);
|
|
if is_user_row {
|
|
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);
|
|
}
|
|
}
|
|
|
|
let line = self
|
|
.transcript_find
|
|
.render_line(line_index, &lines[line_index]);
|
|
line.render_ref(row_area, frame.buffer);
|
|
}
|
|
|
|
self.apply_transcript_selection(transcript_area, frame.buffer);
|
|
if let (Some(anchor), Some(head)) = (
|
|
self.transcript_selection.anchor,
|
|
self.transcript_selection.head,
|
|
) && anchor != head
|
|
{
|
|
self.transcript_copy_ui.render_copy_pill(
|
|
transcript_area,
|
|
frame.buffer,
|
|
(anchor.line_index, anchor.column),
|
|
(head.line_index, head.column),
|
|
self.transcript_view_top,
|
|
self.transcript_total_lines,
|
|
);
|
|
} else {
|
|
self.transcript_copy_ui.clear_affordance();
|
|
}
|
|
|
|
if let Some(prompt_line) = self.transcript_find.render_prompt_line()
|
|
&& chat_top > area.y
|
|
{
|
|
let prompt_area = Rect {
|
|
x: area.x,
|
|
y: chat_top.saturating_sub(1),
|
|
width: area.width,
|
|
height: 1,
|
|
};
|
|
Clear.render_ref(prompt_area, frame.buffer);
|
|
Paragraph::new(prompt_line).render_ref(prompt_area, frame.buffer);
|
|
}
|
|
chat_top
|
|
}
|
|
|
|
/// Handle mouse interaction in the main transcript view.
|
|
///
|
|
/// - Mouse wheel movement scrolls the conversation history using stream-based
|
|
/// normalization (events-per-line factor, discrete vs. continuous streams),
|
|
/// independent of the terminal's own scrollback.
|
|
/// - Mouse 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.
|
|
/// - Mouse events outside the transcript area (e.g. over the composer/footer) must not
|
|
/// start or mutate transcript selection state. A left-click outside the transcript
|
|
/// clears any existing transcript selection so the user can dismiss the highlight.
|
|
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(TRANSCRIPT_GUTTER_COLS);
|
|
let max_x = transcript_area.right().saturating_sub(1);
|
|
|
|
// Treat the transcript as the only interactive region for transcript selection.
|
|
//
|
|
// This prevents clicks in the composer/footer from starting or extending a transcript
|
|
// selection, while still allowing a left-click outside the transcript to clear an
|
|
// existing highlight.
|
|
if mouse_event.row < transcript_area.y || mouse_event.row >= transcript_area.bottom() {
|
|
if matches!(
|
|
mouse_event.kind,
|
|
MouseEventKind::Down(MouseButton::Left) | MouseEventKind::Up(MouseButton::Left)
|
|
) && (self.transcript_selection.anchor.is_some()
|
|
|| self.transcript_selection.head.is_some())
|
|
{
|
|
self.transcript_selection = TranscriptSelection::default();
|
|
// Mouse events do not inherently trigger a redraw; schedule one so the cleared
|
|
// highlight is reflected immediately.
|
|
tui.frame_requester().schedule_frame();
|
|
}
|
|
return;
|
|
}
|
|
|
|
let mut clamped_x = mouse_event.column;
|
|
let clamped_y = mouse_event.row;
|
|
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();
|
|
|
|
if matches!(mouse_event.kind, MouseEventKind::Down(MouseButton::Left))
|
|
&& self
|
|
.transcript_copy_ui
|
|
.hit_test(mouse_event.column, mouse_event.row)
|
|
{
|
|
self.copy_transcript_selection(tui);
|
|
return;
|
|
}
|
|
|
|
match mouse_event.kind {
|
|
MouseEventKind::ScrollUp => {
|
|
let scroll_update = self.mouse_scroll_update(ScrollDirection::Up);
|
|
self.apply_scroll_update(
|
|
tui,
|
|
scroll_update,
|
|
transcript_area.height as usize,
|
|
transcript_area.width,
|
|
true,
|
|
);
|
|
}
|
|
MouseEventKind::ScrollDown => {
|
|
let scroll_update = self.mouse_scroll_update(ScrollDirection::Down);
|
|
self.apply_scroll_update(
|
|
tui,
|
|
scroll_update,
|
|
transcript_area.height as usize,
|
|
transcript_area.width,
|
|
true,
|
|
);
|
|
}
|
|
MouseEventKind::ScrollLeft | MouseEventKind::ScrollRight => {}
|
|
MouseEventKind::Down(MouseButton::Left) => {
|
|
self.transcript_copy_ui.set_dragging(true);
|
|
let point = self.transcript_point_from_coordinates(
|
|
transcript_area,
|
|
base_x,
|
|
clamped_x,
|
|
clamped_y,
|
|
);
|
|
if self.transcript_multi_click.on_mouse_down(
|
|
&mut self.transcript_selection,
|
|
&self.transcript_cells,
|
|
transcript_area.width,
|
|
point,
|
|
) {
|
|
tui.frame_requester().schedule_frame();
|
|
}
|
|
}
|
|
MouseEventKind::Drag(MouseButton::Left) => {
|
|
let point = self.transcript_point_from_coordinates(
|
|
transcript_area,
|
|
base_x,
|
|
clamped_x,
|
|
clamped_y,
|
|
);
|
|
let outcome = crate::transcript_selection::on_mouse_drag(
|
|
&mut self.transcript_selection,
|
|
&self.transcript_scroll,
|
|
point,
|
|
streaming,
|
|
);
|
|
self.transcript_multi_click
|
|
.on_mouse_drag(&self.transcript_selection, point);
|
|
if outcome.lock_scroll {
|
|
self.lock_transcript_scroll_to_current_view(
|
|
transcript_area.height as usize,
|
|
transcript_area.width,
|
|
);
|
|
}
|
|
if outcome.changed {
|
|
tui.frame_requester().schedule_frame();
|
|
}
|
|
}
|
|
MouseEventKind::Up(MouseButton::Left) => {
|
|
self.transcript_copy_ui.set_dragging(false);
|
|
let selection_changed =
|
|
crate::transcript_selection::on_mouse_up(&mut self.transcript_selection);
|
|
let has_active_selection = self.transcript_selection.anchor.is_some()
|
|
&& self.transcript_selection.head.is_some();
|
|
if selection_changed || has_active_selection {
|
|
tui.frame_requester().schedule_frame();
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
/// Convert a single mouse scroll event (direction-only) into a normalized scroll update.
|
|
///
|
|
/// This delegates to [`MouseScrollState::on_scroll_event`] using the current [`ScrollConfig`].
|
|
/// The returned [`ScrollUpdate`] is intentionally split into:
|
|
///
|
|
/// - `lines`: a *delta* in visual lines to apply immediately to the transcript viewport.
|
|
/// - Sign convention matches [`ScrollDirection`] (`Up` is negative; `Down` is positive).
|
|
/// - May be 0 in trackpad-like mode while sub-line fractions are still accumulating.
|
|
/// - `next_tick_in`: an optional delay after which we should trigger a follow-up tick.
|
|
/// This is required because stream closure is defined by a *time gap* rather than an
|
|
/// explicit "gesture end" event. See [`App::apply_scroll_update`] and
|
|
/// [`App::handle_scroll_tick`].
|
|
///
|
|
/// In TUI2, that follow-up tick is driven via `TuiEvent::Draw`: we schedule a frame, and on
|
|
/// the next draw we call [`MouseScrollState::on_tick`] to close idle streams and flush any
|
|
/// newly-reached whole lines. This prevents perceived "stop lag" where accumulated scroll only
|
|
/// applies once the next user input arrives.
|
|
fn mouse_scroll_update(&mut self, direction: ScrollDirection) -> ScrollUpdate {
|
|
self.scroll_state
|
|
.on_scroll_event(direction, self.scroll_config)
|
|
}
|
|
|
|
/// Apply a [`ScrollUpdate`] to the transcript viewport and schedule any needed follow-up tick.
|
|
///
|
|
/// `update.lines` is applied immediately via [`App::scroll_transcript`].
|
|
///
|
|
/// If `update.next_tick_in` is `Some`, we schedule a future frame so `TuiEvent::Draw` can call
|
|
/// [`App::handle_scroll_tick`] and close the stream after it goes idle and/or cadence-flush
|
|
/// pending whole lines.
|
|
///
|
|
/// `schedule_frame` is forwarded to [`App::scroll_transcript`] and controls whether scrolling
|
|
/// should request an additional draw. Pass `false` when applying scroll during a
|
|
/// `TuiEvent::Draw` tick to avoid redundant frames.
|
|
fn apply_scroll_update(
|
|
&mut self,
|
|
tui: &mut tui::Tui,
|
|
update: ScrollUpdate,
|
|
visible_lines: usize,
|
|
width: u16,
|
|
schedule_frame: bool,
|
|
) {
|
|
if update.lines != 0 {
|
|
self.scroll_transcript(tui, update.lines, visible_lines, width, schedule_frame);
|
|
}
|
|
if let Some(delay) = update.next_tick_in {
|
|
tui.frame_requester().schedule_frame_in(delay);
|
|
}
|
|
}
|
|
|
|
/// Drive stream closure and cadence-based flushing for mouse scrolling.
|
|
///
|
|
/// This is called on every `TuiEvent::Draw` before rendering. If a scroll stream is active, it
|
|
/// may:
|
|
///
|
|
/// - Close the stream once it has been idle for longer than the stream-gap threshold.
|
|
/// - Flush whole-line deltas on the redraw cadence for trackpad-like streams, even if no new
|
|
/// events arrive.
|
|
///
|
|
/// The resulting update is applied with `schedule_frame = false` because we are already in a
|
|
/// draw tick.
|
|
fn handle_scroll_tick(&mut self, tui: &mut tui::Tui) {
|
|
let Some((visible_lines, width)) = self.transcript_scroll_dimensions(tui) else {
|
|
return;
|
|
};
|
|
let update = self.scroll_state.on_tick();
|
|
self.apply_scroll_update(tui, update, visible_lines, width, false);
|
|
}
|
|
|
|
/// Compute the transcript viewport dimensions used for scrolling.
|
|
///
|
|
/// Mouse scrolling is applied in terms of "visible transcript lines": the terminal height
|
|
/// minus the chat composer height. We compute this from the last known terminal size to avoid
|
|
/// querying the terminal during non-draw events.
|
|
///
|
|
/// Returns `(visible_lines, width)` or `None` when the terminal is not yet sized or the chat
|
|
/// area consumes the full height.
|
|
fn transcript_scroll_dimensions(&self, tui: &tui::Tui) -> Option<(usize, u16)> {
|
|
let size = tui.terminal.last_known_screen_size;
|
|
let width = size.width;
|
|
let height = size.height;
|
|
if width == 0 || height == 0 {
|
|
return None;
|
|
}
|
|
|
|
let chat_height = self.chat_widget.desired_height(width);
|
|
if chat_height >= height {
|
|
return None;
|
|
}
|
|
|
|
let transcript_height = height.saturating_sub(chat_height);
|
|
if transcript_height == 0 {
|
|
return None;
|
|
}
|
|
|
|
Some((transcript_height as usize, width))
|
|
}
|
|
|
|
/// Scroll the transcript by a 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.
|
|
///
|
|
/// `schedule_frame` controls whether to request an extra draw; pass `false` when applying
|
|
/// scroll during a `TuiEvent::Draw` tick to avoid redundant frames.
|
|
fn scroll_transcript(
|
|
&mut self,
|
|
tui: &mut tui::Tui,
|
|
delta_lines: i32,
|
|
visible_lines: usize,
|
|
width: u16,
|
|
schedule_frame: bool,
|
|
) {
|
|
if visible_lines == 0 {
|
|
return;
|
|
}
|
|
|
|
let transcript =
|
|
crate::transcript_render::build_wrapped_transcript_lines(&self.transcript_cells, width);
|
|
let line_meta = transcript.meta;
|
|
self.transcript_scroll =
|
|
self.transcript_scroll
|
|
.scrolled_by(delta_lines, &line_meta, visible_lines);
|
|
|
|
if schedule_frame {
|
|
// Delay redraws slightly so scroll bursts coalesce into a single frame.
|
|
tui.frame_requester()
|
|
.schedule_frame_in(Duration::from_millis(16));
|
|
}
|
|
}
|
|
|
|
/// 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 transcript =
|
|
crate::transcript_render::build_wrapped_transcript_lines(&self.transcript_cells, width);
|
|
let (lines, line_meta) = (transcript.lines, transcript.meta);
|
|
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;
|
|
}
|
|
}
|
|
|
|
/// 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(TRANSCRIPT_GUTTER_COLS);
|
|
let max_x = area.right().saturating_sub(1);
|
|
|
|
let (start, end) = crate::transcript_selection::ordered_endpoints(anchor, head);
|
|
|
|
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.
|
|
///
|
|
/// Important: copy operates on the selection's full content-relative range,
|
|
/// not just the current viewport. A selection can extend outside the visible
|
|
/// region (for example, by scrolling after selecting, or by selecting while
|
|
/// autoscrolling), and we still want the clipboard payload to reflect the
|
|
/// entire selected transcript.
|
|
fn copy_transcript_selection(&mut self, tui: &tui::Tui) {
|
|
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 Some(text) = crate::transcript_copy::selection_to_copy_text_for_cells(
|
|
&self.transcript_cells,
|
|
self.transcript_selection,
|
|
width,
|
|
) else {
|
|
return;
|
|
};
|
|
if let Err(err) = clipboard_copy::copy_text(text) {
|
|
tracing::error!(error = %err, "failed to copy selection to clipboard");
|
|
}
|
|
}
|
|
|
|
fn copy_selection_key(&self) -> crate::key_hint::KeyBinding {
|
|
self.transcript_copy_ui.key_binding()
|
|
}
|
|
|
|
/// 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<TranscriptSelectionPoint> {
|
|
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<bool> {
|
|
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();
|
|
self.transcript_find.clear();
|
|
if let Some(summary) = summary {
|
|
let mut lines: Vec<Line<'static>> = 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<Line<'static>> =
|
|
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<dyn HistoryCell> = 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());
|
|
self.transcript_find.note_lines_changed();
|
|
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<ratatui::text::Line<'static>> = 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
|
|
);
|
|
|
|
if let Err(err) = self.config.sandbox_policy.set(policy.clone()) {
|
|
tracing::warn!(%err, "failed to set sandbox policy on app config");
|
|
self.chat_widget
|
|
.add_error_message(format!("Failed to set sandbox policy: {err}"));
|
|
return Ok(true);
|
|
}
|
|
#[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;
|
|
}
|
|
if let Err(err) = self.chat_widget.set_sandbox_policy(policy) {
|
|
tracing::warn!(%err, "failed to set sandbox policy on chat config");
|
|
self.chat_widget
|
|
.add_error_message(format!("Failed to set sandbox policy: {err}"));
|
|
return Ok(true);
|
|
}
|
|
|
|
// 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<String, String> =
|
|
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.get().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<ReasoningEffortConfig>) -> &'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<ReasoningEffortConfig>,
|
|
) -> 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<ReasoningEffortConfig>) {
|
|
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) {
|
|
if self.transcript_find.handle_key_event(&key_event) {
|
|
tui.frame_requester().schedule_frame();
|
|
return;
|
|
}
|
|
|
|
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(ch),
|
|
modifiers,
|
|
kind: KeyEventKind::Press | KeyEventKind::Repeat,
|
|
..
|
|
} if self.transcript_copy_ui.is_copy_key(ch, modifiers) => {
|
|
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,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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,
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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<String, String>,
|
|
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 crate::transcript_copy_ui::CopySelectionShortcut;
|
|
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_multi_click: TranscriptMultiClick::default(),
|
|
transcript_view_top: 0,
|
|
transcript_total_lines: 0,
|
|
transcript_copy_ui: TranscriptCopyUi::new_with_shortcut(
|
|
CopySelectionShortcut::CtrlShiftC,
|
|
),
|
|
transcript_find: TranscriptFind::default(),
|
|
overlay: None,
|
|
deferred_history_lines: Vec::new(),
|
|
has_emitted_history_lines: false,
|
|
enhanced_keys_supported: false,
|
|
commit_anim_running: Arc::new(AtomicBool::new(false)),
|
|
scroll_config: ScrollConfig::default(),
|
|
scroll_state: MouseScrollState::default(),
|
|
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<AppEvent>,
|
|
tokio::sync::mpsc::UnboundedReceiver<Op>,
|
|
) {
|
|
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_multi_click: TranscriptMultiClick::default(),
|
|
transcript_view_top: 0,
|
|
transcript_total_lines: 0,
|
|
transcript_copy_ui: TranscriptCopyUi::new_with_shortcut(
|
|
CopySelectionShortcut::CtrlShiftC,
|
|
),
|
|
transcript_find: TranscriptFind::default(),
|
|
overlay: None,
|
|
deferred_history_lines: Vec::new(),
|
|
has_emitted_history_lines: false,
|
|
enhanced_keys_supported: false,
|
|
commit_anim_running: Arc::new(AtomicBool::new(false)),
|
|
scroll_config: ScrollConfig::default(),
|
|
scroll_state: MouseScrollState::default(),
|
|
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<ModelPreset> {
|
|
codex_core::models_manager::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 transcript_selection_copy_includes_offscreen_lines() {
|
|
let mut app = make_test_app().await;
|
|
app.transcript_cells = vec![Arc::new(AgentMessageCell::new(
|
|
vec![
|
|
Line::from("one"),
|
|
Line::from("two"),
|
|
Line::from("three"),
|
|
Line::from("four"),
|
|
],
|
|
true,
|
|
))];
|
|
|
|
app.transcript_view_top = 2;
|
|
app.transcript_selection.anchor = Some(TranscriptSelectionPoint {
|
|
line_index: 0,
|
|
column: 0,
|
|
});
|
|
app.transcript_selection.head = Some(TranscriptSelectionPoint {
|
|
line_index: 3,
|
|
column: u16::MAX,
|
|
});
|
|
|
|
let text = crate::transcript_copy::selection_to_copy_text_for_cells(
|
|
&app.transcript_cells,
|
|
app.transcript_selection,
|
|
40,
|
|
)
|
|
.expect("expected text");
|
|
assert_eq!(text, "one\ntwo\nthree\nfour");
|
|
}
|
|
|
|
#[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<dyn HistoryCell> {
|
|
Arc::new(UserHistoryCell {
|
|
message: text.to_string(),
|
|
}) as Arc<dyn HistoryCell>
|
|
};
|
|
let agent_cell = |text: &str| -> Arc<dyn HistoryCell> {
|
|
Arc::new(AgentMessageCell::new(
|
|
vec![Line::from(text.to_string())],
|
|
true,
|
|
)) as Arc<dyn HistoryCell>
|
|
};
|
|
|
|
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<dyn HistoryCell>
|
|
};
|
|
|
|
// 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 transcript_selection_renders_copy_affordance() {
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
|
|
let mut app = make_test_app().await;
|
|
app.transcript_total_lines = 3;
|
|
app.transcript_view_top = 0;
|
|
|
|
let area = Rect {
|
|
x: 0,
|
|
y: 0,
|
|
width: 60,
|
|
height: 3,
|
|
};
|
|
|
|
app.transcript_selection = TranscriptSelection {
|
|
anchor: Some(TranscriptSelectionPoint {
|
|
line_index: 1,
|
|
column: 2,
|
|
}),
|
|
head: Some(TranscriptSelectionPoint {
|
|
line_index: 1,
|
|
column: 6,
|
|
}),
|
|
};
|
|
|
|
let mut buf = Buffer::empty(area);
|
|
for y in 0..area.height {
|
|
for x in 2..area.width.saturating_sub(1) {
|
|
buf[(x, y)].set_symbol("X");
|
|
}
|
|
}
|
|
|
|
app.apply_transcript_selection(area, &mut buf);
|
|
let anchor = app.transcript_selection.anchor.expect("anchor");
|
|
let head = app.transcript_selection.head.expect("head");
|
|
app.transcript_copy_ui.render_copy_pill(
|
|
area,
|
|
&mut buf,
|
|
(anchor.line_index, anchor.column),
|
|
(head.line_index, head.column),
|
|
app.transcript_view_top,
|
|
app.transcript_total_lines,
|
|
);
|
|
|
|
let mut s = String::new();
|
|
for y in area.y..area.bottom() {
|
|
for x in area.x..area.right() {
|
|
s.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
|
|
}
|
|
s.push('\n');
|
|
}
|
|
|
|
assert!(s.contains("copy"));
|
|
assert!(s.contains("ctrl + shift + c"));
|
|
assert!(app.transcript_copy_ui.hit_test(10, 2));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn transcript_selection_renders_ctrl_y_copy_affordance_in_vscode_mode() {
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
|
|
let mut app = make_test_app().await;
|
|
app.transcript_copy_ui = TranscriptCopyUi::new_with_shortcut(CopySelectionShortcut::CtrlY);
|
|
app.transcript_total_lines = 3;
|
|
app.transcript_view_top = 0;
|
|
|
|
let area = Rect {
|
|
x: 0,
|
|
y: 0,
|
|
width: 60,
|
|
height: 3,
|
|
};
|
|
|
|
app.transcript_selection = TranscriptSelection {
|
|
anchor: Some(TranscriptSelectionPoint {
|
|
line_index: 1,
|
|
column: 2,
|
|
}),
|
|
head: Some(TranscriptSelectionPoint {
|
|
line_index: 1,
|
|
column: 6,
|
|
}),
|
|
};
|
|
|
|
let mut buf = Buffer::empty(area);
|
|
for y in 0..area.height {
|
|
for x in 2..area.width.saturating_sub(1) {
|
|
buf[(x, y)].set_symbol("X");
|
|
}
|
|
}
|
|
|
|
app.apply_transcript_selection(area, &mut buf);
|
|
let anchor = app.transcript_selection.anchor.expect("anchor");
|
|
let head = app.transcript_selection.head.expect("head");
|
|
app.transcript_copy_ui.render_copy_pill(
|
|
area,
|
|
&mut buf,
|
|
(anchor.line_index, anchor.column),
|
|
(head.line_index, head.column),
|
|
app.transcript_view_top,
|
|
app.transcript_total_lines,
|
|
);
|
|
|
|
let mut s = String::new();
|
|
for y in area.y..area.bottom() {
|
|
for x in area.x..area.right() {
|
|
s.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
|
|
}
|
|
s.push('\n');
|
|
}
|
|
|
|
assert!(s.contains("copy"));
|
|
assert!(s.contains("ctrl + y"));
|
|
assert!(!s.contains("ctrl + shift + c"));
|
|
assert!(app.transcript_copy_ui.hit_test(10, 2));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn transcript_selection_hides_copy_affordance_while_dragging() {
|
|
use ratatui::buffer::Buffer;
|
|
use ratatui::layout::Rect;
|
|
|
|
let mut app = make_test_app().await;
|
|
app.transcript_total_lines = 3;
|
|
app.transcript_view_top = 0;
|
|
app.transcript_copy_ui.set_dragging(true);
|
|
|
|
let area = Rect {
|
|
x: 0,
|
|
y: 0,
|
|
width: 60,
|
|
height: 3,
|
|
};
|
|
|
|
app.transcript_selection = TranscriptSelection {
|
|
anchor: Some(TranscriptSelectionPoint {
|
|
line_index: 1,
|
|
column: 2,
|
|
}),
|
|
head: Some(TranscriptSelectionPoint {
|
|
line_index: 1,
|
|
column: 6,
|
|
}),
|
|
};
|
|
|
|
let mut buf = Buffer::empty(area);
|
|
for y in 0..area.height {
|
|
for x in 2..area.width.saturating_sub(1) {
|
|
buf[(x, y)].set_symbol("X");
|
|
}
|
|
}
|
|
|
|
let anchor = app.transcript_selection.anchor.expect("anchor");
|
|
let head = app.transcript_selection.head.expect("head");
|
|
app.transcript_copy_ui.render_copy_pill(
|
|
area,
|
|
&mut buf,
|
|
(anchor.line_index, anchor.column),
|
|
(head.line_index, head.column),
|
|
app.transcript_view_top,
|
|
app.transcript_total_lines,
|
|
);
|
|
|
|
let mut s = String::new();
|
|
for y in area.y..area.bottom() {
|
|
for x in area.x..area.right() {
|
|
s.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
|
|
}
|
|
s.push('\n');
|
|
}
|
|
|
|
assert!(!s.contains("copy"));
|
|
assert!(!app.transcript_copy_ui.hit_test(10, 2));
|
|
}
|
|
|
|
#[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 = crate::transcript_render::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())
|
|
);
|
|
}
|
|
}
|