Lightweight coding agent that runs in your terminal
Rust
Prompt to unarchive sessions before resuming or forking (#39640)
Jeremy Rosed944ce83a230
diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rsindex 0c5fff959e..03a81f9b7e 100644--- a/codex-rs/cli/src/main.rs+++ b/codex-rs/cli/src/main.rs@@ -2795,6 +2795,7 @@ fn merge_interactive_cli_flags(interactive: &mut TuiCli, subcommand_cli: TuiCli)strict_config,approval_policy,web_search,+ no_alt_screen,prompt,mut config_overrides,..@@ -2814,6 +2815,7 @@ fn merge_interactive_cli_flags(interactive: &mut TuiCli, subcommand_cli: TuiCli)if web_search {interactive.web_search = true;}+ interactive.no_alt_screen |= no_alt_screen;if strict_config {interactive.strict_config = true;}@@ -3772,6 +3774,18 @@ mod tests {assert_eq!(interactive.resume_session_id, None);}+ #[test]+ fn resume_and_fork_preserve_no_alt_screen() {+ for (command, finalize) in [+ ("resume", finalize_resume_from_args as fn(&[&str]) -> TuiCli),+ ("fork", finalize_fork_from_args as fn(&[&str]) -> TuiCli),+ ] {+ assert!(finalize(&["codex", command, "--no-alt-screen"]).no_alt_screen);+ assert!(finalize(&["codex", "--no-alt-screen", command]).no_alt_screen);+ assert!(!finalize(&["codex", command]).no_alt_screen);+ }+ }+#[test]fn resume_picker_logic_none_and_not_last() {let interactive = finalize_resume_from_args(["codex", "resume"].as_ref());diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 8b17591059..70d147de53 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -682,31 +682,6 @@ fn active_turn_steer_race(error: &TypedRequestError) -> Option<ActiveTurnSteerRaSome(ActiveTurnSteerRace::ExpectedTurnMismatch { actual_turn_id })}-fn session_start_error(- action: &str,- target_session: &SessionTarget,- err: color_eyre::eyre::Report,-) -> color_eyre::eyre::Report {- if let Some(message) = archived_session_guidance(&err) {- return color_eyre::eyre::eyre!("{message}");- }-- let target_label = target_session.display_label();- color_eyre::eyre::eyre!("Failed to {action} session from {target_label}: {err}")-}--fn archived_session_guidance(err: &color_eyre::eyre::Report) -> Option<String> {- let err = err.to_string();- let message = &err[err.find("session ")?..];- if !message.contains(" is archived. Run `codex unarchive ") {- return None;- }- let message = message- .split_once(" (code ")- .map_or(message, |(message, _)| message);- Some(message.to_string())-}-fn active_turn_interrupt_race(error: &TypedRequestError) -> Option<String> {let TypedRequestError::Server { method, source } = error else {return None;diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rsindex 010c7c6374..ee9b713a76 100644--- a/codex-rs/tui/src/app/startup.rs+++ b/codex-rs/tui/src/app/startup.rs@@ -4,6 +4,10 @@//! remains isolated from protected interactive requests until the initialized composer owns it.use super::*;+use crate::session_start::SessionStartAction;+use crate::session_start::cancel_session_start;+use crate::session_start::complete_session_start;+use crate::unarchive_prompt::run_unarchive_prompt;async fn resolve_runtime_model_provider_base_url(provider: &ModelProviderInfo) -> Option<String> {let provider = create_model_provider(provider.clone(), /*auth_manager*/ None);@@ -304,10 +308,25 @@ impl App {).await{- Ok(resumed) => resumed- .map_err(|err| session_start_error("resume", &target_session, err))?,+ Ok(resumed) => resumed,Err(err) => return shutdown_on_startup_error(app_server, err).await,};+ let action = SessionStartAction::Resume(model_settings);+ let Some(resumed) = complete_session_start(+ &mut app_server,+ &config,+ &target_session,+ action,+ resumed,+ async || {+ startup_draft.flush_pending_events(tui).await?;+ run_unarchive_prompt(tui, target_session.thread_id, action).await+ },+ )+ .await?+ else {+ return Ok(cancel_session_start(app_server).await);+ };let init = crate::chatwidget::ChatWidgetInit {config: config.clone(),frame_requester: tui.frame_requester(),@@ -350,11 +369,25 @@ impl App {).await{- Ok(forked) => {- forked.map_err(|err| session_start_error("fork", &target_session, err))?- }+ Ok(forked) => forked,Err(err) => return shutdown_on_startup_error(app_server, err).await,};+ let action = SessionStartAction::Fork;+ let Some(forked) = complete_session_start(+ &mut app_server,+ &config,+ &target_session,+ action,+ forked,+ async || {+ startup_draft.flush_pending_events(tui).await?;+ run_unarchive_prompt(tui, target_session.thread_id, action).await+ },+ )+ .await?+ else {+ return Ok(cancel_session_start(app_server).await);+ };let init = crate::chatwidget::ChatWidgetInit {config: config.clone(),frame_requester: tui.frame_requester(),diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex a653a002d0..7b043346f0 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -6272,33 +6272,6 @@ fn active_turn_not_steerable_turn_error_extracts_structured_server_error() {);}-#[test]-fn session_start_error_surfaces_archived_guidance_without_rollout_path() {- let thread_id =- ThreadId::from_string("019e72f4-e09a-70f2-b2c2-a153a57b8cc0").expect("thread id");- let target_session = SessionTarget {- path: Some(std::path::PathBuf::from(- "/Users/me/.codex/archived_sessions/rollout.jsonl",- )),- thread_id,- history_mode: None,- };- let expected = format!(- "session {thread_id} is archived. Run `codex unarchive {thread_id}` to unarchive it first."- );-- for action in ["resume", "fork"] {- let err = color_eyre::eyre::eyre!(- "thread/{action} failed during TUI bootstrap: thread/{action} failed: {expected} (code -32600)"- );-- assert_eq!(- session_start_error(action, &target_session, err).to_string(),- expected- );- }-}-#[test]fn active_turn_steer_race_detects_missing_active_turn() {let error = TypedRequestError::Server {diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rsindex 0e00413658..490c06984e 100644--- a/codex-rs/tui/src/lib.rs+++ b/codex-rs/tui/src/lib.rs@@ -170,6 +170,7 @@ mod session_archive_commands;mod session_log;mod session_queue_commands;mod session_resume;+mod session_start;mod session_state;mod skills_helpers;mod slash_command;@@ -195,6 +196,7 @@ mod tooltips;mod transcript_reflow;mod tui;mod ui_consts;+mod unarchive_prompt;pub(crate) mod update_action;pub use update_action::UpdateAction;#[cfg(not(debug_assertions))]diff --git a/codex-rs/tui/src/session_start.rs b/codex-rs/tui/src/session_start.rsnew file mode 100644index 0000000000..5bae25a7c9--- /dev/null+++ b/codex-rs/tui/src/session_start.rs@@ -0,0 +1,127 @@+//! Interactive recovery when starting an archived session.++use crate::app::AppExitInfo;+use crate::app::ExitReason;+use crate::app_server_session::AppServerSession;+use crate::app_server_session::AppServerStartedThread;+use crate::app_server_session::ResumeModelSettings;+use crate::legacy_core::config::Config;+use crate::resume_picker::SessionTarget;+use crate::unarchive_prompt::UnarchiveChoice;+use color_eyre::Result;+use color_eyre::eyre::WrapErr;++#[derive(Clone, Copy)]+pub(crate) enum SessionStartAction {+ Resume(ResumeModelSettings),+ Fork,+}++impl SessionStartAction {+ pub(crate) fn verb(self) -> &'static str {+ match self {+ Self::Resume(_) => "resume",+ Self::Fork => "fork",+ }+ }++ async fn start(+ self,+ app_server: &mut AppServerSession,+ config: &Config,+ target: &SessionTarget,+ ) -> Result<AppServerStartedThread> {+ match self {+ Self::Resume(settings) => {+ app_server+ .resume_thread(config.clone(), target.thread_id, settings)+ .await+ }+ Self::Fork => {+ app_server+ .fork_thread(config.clone(), target.thread_id)+ .await+ }+ }+ }+}++pub(crate) async fn complete_session_start(+ app_server: &mut AppServerSession,+ config: &Config,+ target: &SessionTarget,+ action: SessionStartAction,+ initial_result: Result<AppServerStartedThread>,+ confirm: impl AsyncFnOnce() -> Result<UnarchiveChoice>,+) -> Result<Option<AppServerStartedThread>> {+ match initial_result {+ Ok(started) => return Ok(Some(started)),+ Err(err) => {+ // Match the requested ID as well as the server's archive guidance: an unrelated+ // startup failure must never cause us to unarchive a session.+ let archived_prefix = format!("session {} is archived. ", target.thread_id);+ if !archived_session_guidance(&err)+ .is_some_and(|message| message.starts_with(&archived_prefix))+ {+ return Err(session_start_error(action.verb(), target, err));+ }+ }+ }++ if confirm().await? == UnarchiveChoice::Cancel {+ return Ok(None);+ }++ app_server+ .thread_unarchive(target.thread_id)+ .await+ .wrap_err_with(|| format!("Failed to unarchive session {}", target.thread_id))?;+ // Retry by ID, not by the old rollout path, which unarchiving may have moved.+ action+ .start(app_server, config, target)+ .await+ .map(Some)+ .map_err(|err| session_start_error(action.verb(), target, err))+}++pub(crate) async fn cancel_session_start(app_server: AppServerSession) -> AppExitInfo {+ if let Err(err) = app_server.shutdown().await {+ tracing::warn!("app-server shutdown failed: {err}");+ }+ AppExitInfo {+ token_usage: Default::default(),+ thread_id: None,+ resume_hint: None,+ update_action: None,+ exit_reason: ExitReason::UserRequested,+ }+}++fn session_start_error(+ action: &str,+ target_session: &SessionTarget,+ err: color_eyre::Report,+) -> color_eyre::Report {+ if let Some(message) = archived_session_guidance(&err) {+ return color_eyre::eyre::eyre!("{message}");+ }++ let target_label = target_session.display_label();+ color_eyre::eyre::eyre!("Failed to {action} session from {target_label}: {err}")+}++fn archived_session_guidance(err: &color_eyre::Report) -> Option<String> {+ let err = err.to_string();+ let message = &err[err.find("session ")?..];+ if !message.contains(" is archived. Run `codex unarchive ") {+ return None;+ }+ let message = message+ .split_once(" (code ")+ .map_or(message, |(message, _)| message);+ Some(message.to_string())+}++#[cfg(test)]+#[path = "session_start_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/session_start_tests.rs b/codex-rs/tui/src/session_start_tests.rsnew file mode 100644index 0000000000..0694175b34--- /dev/null+++ b/codex-rs/tui/src/session_start_tests.rs@@ -0,0 +1,150 @@+use super::*;+use crate::legacy_core::config::ConfigBuilder;+use app_test_support::create_fake_rollout;+use app_test_support::rollout_path;+use codex_config::LoaderOverrides;+use codex_protocol::ThreadId;+use pretty_assertions::assert_eq;+use std::cell::Cell;+use tempfile::TempDir;++async fn start_session(+ app_server: &mut AppServerSession,+ config: &Config,+ target: &SessionTarget,+ action: SessionStartAction,+ confirm: impl AsyncFnOnce() -> Result<UnarchiveChoice>,+) -> Result<Option<AppServerStartedThread>> {+ let initial_result = action.start(app_server, config, target).await;+ complete_session_start(app_server, config, target, action, initial_result, confirm).await+}++#[tokio::test]+async fn archived_session_requires_confirmation_before_resume_or_fork() -> Result<()> {+ for action in [+ SessionStartAction::Resume(ResumeModelSettings::RestoreFromThread),+ SessionStartAction::Fork,+ ] {+ let codex_home = TempDir::new()?;+ let config = ConfigBuilder::default()+ .codex_home(codex_home.path().to_path_buf())+ .loader_overrides(LoaderOverrides::without_managed_config_for_tests())+ .build()+ .await?;+ let timestamp = "2025-01-05T12-00-00";+ let id = create_fake_rollout(+ codex_home.path(),+ timestamp,+ "2025-01-05T12:00:00Z",+ "Archived saved user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create source rollout");+ let active_path = rollout_path(codex_home.path(), timestamp, &id);+ let archived_dir = codex_home.path().join("archived_sessions");+ std::fs::create_dir_all(&archived_dir)?;+ let archived_path = archived_dir.join(active_path.file_name().unwrap());+ std::fs::rename(&active_path, &archived_path)?;+ let target = SessionTarget {+ path: Some(archived_path.clone()),+ thread_id: ThreadId::from_string(&id)?,+ history_mode: None,+ };+ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ let prompts = Cell::new(0);++ let cancelled = start_session(&mut app_server, &config, &target, action, async || {+ prompts.set(prompts.get() + 1);+ Ok(UnarchiveChoice::Cancel)+ })+ .await?;+ assert!(cancelled.is_none());+ assert_eq!(+ (prompts.get(), archived_path.exists(), active_path.exists()),+ (1, true, false)+ );++ let started = start_session(&mut app_server, &config, &target, action, async || {+ prompts.set(prompts.get() + 1);+ Ok(UnarchiveChoice::Unarchive)+ })+ .await?+ .expect("confirmed session should start");+ assert_eq!(+ (prompts.get(), archived_path.exists(), active_path.exists()),+ (2, false, true)+ );+ match action {+ SessionStartAction::Resume(_) => {+ assert_eq!(started.session.thread_id, target.thread_id)+ }+ SessionStartAction::Fork => {+ assert_ne!(started.session.thread_id, target.thread_id);+ assert_eq!(+ app_server+ .thread_read(started.session.thread_id, /*include_turns*/ false)+ .await?+ .forked_from_id,+ Some(id)+ );+ }+ }++ let resumed = start_session(+ &mut app_server,+ &config,+ &target,+ SessionStartAction::Resume(ResumeModelSettings::RestoreFromThread),+ async || panic!("active sessions must not prompt"),+ )+ .await?+ .expect("active session should start");+ assert_eq!(resumed.session.thread_id, target.thread_id);++ let missing = SessionTarget {+ path: None,+ thread_id: ThreadId::new(),+ history_mode: None,+ };+ let error = start_session(&mut app_server, &config, &missing, action, async || {+ panic!("unrelated failures must not prompt")+ })+ .await+ .expect_err("missing session should fail");+ assert!(+ error+ .to_string()+ .starts_with(&format!("Failed to {} session", action.verb()))+ );+ app_server.shutdown().await?;+ }+ Ok(())+}++#[test]+fn session_start_error_surfaces_archived_guidance_without_rollout_path() {+ let thread_id =+ ThreadId::from_string("019e72f4-e09a-70f2-b2c2-a153a57b8cc0").expect("thread id");+ let target_session = SessionTarget {+ path: Some(std::path::PathBuf::from(+ "/Users/me/.codex/archived_sessions/rollout.jsonl",+ )),+ thread_id,+ history_mode: None,+ };+ let expected = format!(+ "session {thread_id} is archived. Run `codex unarchive {thread_id}` to unarchive it first."+ );++ for action in ["resume", "fork"] {+ let err = color_eyre::eyre::eyre!(+ "thread/{action} failed during TUI bootstrap: thread/{action} failed: {expected} (code -32600)"+ );++ assert_eq!(+ session_start_error(action, &target_session, err).to_string(),+ expected+ );+ }+}diff --git a/codex-rs/tui/src/snapshots/codex_tui__unarchive_prompt__tests__inline_prompt.snap b/codex-rs/tui/src/snapshots/codex_tui__unarchive_prompt__tests__inline_prompt.snapnew file mode 100644index 0000000000..af0428bf1f--- /dev/null+++ b/codex-rs/tui/src/snapshots/codex_tui__unarchive_prompt__tests__inline_prompt.snap@@ -0,0 +1,15 @@+---+source: tui/src/unarchive_prompt_tests.rs+assertion_line: 108+expression: render_inline(80)+---+$ codex fork saved-session+++This conversation is archived+019e72f4-e09a-70f2-b2c2-a153a57b8cc0++› 1. Unarchive and fork+ 2. Cancel++Press enter to continue or esc to canceldiff --git a/codex-rs/tui/src/snapshots/codex_tui__unarchive_prompt__tests__narrow_inline_prompt.snap b/codex-rs/tui/src/snapshots/codex_tui__unarchive_prompt__tests__narrow_inline_prompt.snapnew file mode 100644index 0000000000..52c5669921--- /dev/null+++ b/codex-rs/tui/src/snapshots/codex_tui__unarchive_prompt__tests__narrow_inline_prompt.snap@@ -0,0 +1,18 @@+---+source: tui/src/unarchive_prompt_tests.rs+assertion_line: 113+expression: render_inline(28)+---+$ codex fork saved-session+++This conversation is+archived+019e72f4-e09a-70f2-b2c2-a153+a57b8cc0++› 1. Unarchive and fork+ 2. Cancel++Press enter to continue or+esc to canceldiff --git a/codex-rs/tui/src/unarchive_prompt.rs b/codex-rs/tui/src/unarchive_prompt.rsnew file mode 100644index 0000000000..b44d08d707--- /dev/null+++ b/codex-rs/tui/src/unarchive_prompt.rs@@ -0,0 +1,198 @@+use crate::key_hint;+use crate::render::renderable::ColumnRenderable;+use crate::render::renderable::Renderable;+use crate::selection_list::selection_option_row;+use crate::session_start::SessionStartAction;+use crate::tui::Tui;+use crate::tui::TuiEvent;+use codex_protocol::ThreadId;+use color_eyre::Result;+use crossterm::event::KeyCode;+use crossterm::event::KeyEvent;+use crossterm::event::KeyEventKind;+use crossterm::event::KeyModifiers;+use ratatui::buffer::Buffer;+use ratatui::layout::Rect;+use ratatui::style::Stylize as _;+use ratatui::text::Line;+use ratatui::widgets::Clear;+use ratatui::widgets::Paragraph;+use ratatui::widgets::Widget;+use ratatui::widgets::WidgetRef;+use ratatui::widgets::Wrap;+use tokio_stream::StreamExt;++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) enum UnarchiveChoice {+ Unarchive,+ Cancel,+}++pub(crate) async fn run_unarchive_prompt(+ tui: &mut Tui,+ thread_id: ThreadId,+ action: SessionStartAction,+) -> Result<UnarchiveChoice> {+ let mut guard = PromptScreenGuard::enter(tui)?;+ let mut screen = UnarchivePrompt::new(thread_id, action);+ guard.draw(&screen)?;+ guard+ .tui+ .discard_pending_input_before_interactive_screen()?;+ let events = guard.tui.event_stream();+ tokio::pin!(events);+ loop {+ guard.draw(&screen)?;+ let Some(event) = events.next().await else {+ return Ok(UnarchiveChoice::Cancel);+ };+ guard.tui.screen_size_for_event(&event)?;+ match event {+ TuiEvent::Key(key) => {+ if let Some(choice) = screen.handle_key(key) {+ return Ok(choice);+ }+ }+ TuiEvent::Paste(_) | TuiEvent::Draw | TuiEvent::Resize(_) | TuiEvent::Resume => {}+ }+ }+}++/// Keep startup prompts out of normal scrollback when an alternate screen is available.+/// Inline mode owns only its content-height viewport, including when the terminal is resized.+struct PromptScreenGuard<'a> {+ tui: &'a mut Tui,+ entered_alt_screen: bool,+}++impl<'a> PromptScreenGuard<'a> {+ fn enter(tui: &'a mut Tui) -> Result<Self> {+ let was_alternate = tui.is_alt_screen_active();+ if !was_alternate {+ tui.enter_alt_screen()?;+ }+ let entered_alt_screen = !was_alternate && tui.is_alt_screen_active();+ Ok(Self {+ tui,+ entered_alt_screen,+ })+ }++ fn draw(&mut self, screen: &UnarchivePrompt) -> Result<()> {+ let height = if self.tui.is_alt_screen_active() {+ u16::MAX+ } else {+ screen+ .content()+ .desired_height(self.tui.terminal.size()?.width)+ };+ self.tui.draw(height, |frame| {+ frame.render_widget_ref(screen, frame.area());+ })?;+ Ok(())+ }+}++impl Drop for PromptScreenGuard<'_> {+ fn drop(&mut self) {+ let result = if self.entered_alt_screen {+ self.tui.leave_alt_screen()+ } else if !self.tui.is_alt_screen_active() {+ let result = self.tui.terminal.clear();+ let mut area = self.tui.terminal.viewport_area;+ area.height = 0;+ self.tui.terminal.set_viewport_area(area);+ result+ } else {+ Ok(())+ };+ if let Err(err) = result {+ tracing::warn!("failed to restore terminal after unarchive prompt: {err}");+ }+ }+}++struct UnarchivePrompt {+ thread_id: ThreadId,+ action: SessionStartAction,+ highlighted: UnarchiveChoice,+}++impl UnarchivePrompt {+ fn new(thread_id: ThreadId, action: SessionStartAction) -> Self {+ Self {+ thread_id,+ action,+ highlighted: UnarchiveChoice::Unarchive,+ }+ }++ fn handle_key(&mut self, key: KeyEvent) -> Option<UnarchiveChoice> {+ if key.kind == KeyEventKind::Release {+ return None;+ }+ if key.modifiers.contains(KeyModifiers::CONTROL)+ && matches!(key.code, KeyCode::Char('c') | KeyCode::Char('d'))+ {+ return Some(UnarchiveChoice::Cancel);+ }+ match key.code {+ KeyCode::Up | KeyCode::Down | KeyCode::Char('k' | 'j') => {+ self.highlighted = match self.highlighted {+ UnarchiveChoice::Unarchive => UnarchiveChoice::Cancel,+ UnarchiveChoice::Cancel => UnarchiveChoice::Unarchive,+ };+ None+ }+ KeyCode::Char('1' | 'y' | 'Y') => Some(UnarchiveChoice::Unarchive),+ KeyCode::Esc | KeyCode::Char('2' | 'n' | 'N') => Some(UnarchiveChoice::Cancel),+ KeyCode::Enter => Some(self.highlighted),+ _ => None,+ }+ }++ fn content(&self) -> ColumnRenderable<'static> {+ let mut column = ColumnRenderable::new();+ column.push("");+ column.push(+ Paragraph::new("This conversation is archived".bold()).wrap(Wrap { trim: false }),+ );+ column.push(+ Paragraph::new(Line::from(self.thread_id.to_string()).dim()).wrap(Wrap { trim: false }),+ );+ column.push("");+ column.push(selection_option_row(+ /*index*/ 0,+ format!("Unarchive and {}", self.action.verb()),+ self.highlighted == UnarchiveChoice::Unarchive,+ ));+ column.push(selection_option_row(+ /*index*/ 1,+ "Cancel".to_string(),+ self.highlighted == UnarchiveChoice::Cancel,+ ));+ column.push("");+ column.push(+ Paragraph::new(Line::from(vec![+ "Press ".dim(),+ key_hint::plain(KeyCode::Enter).into(),+ " to continue or ".dim(),+ key_hint::plain(KeyCode::Esc).into(),+ " to cancel".dim(),+ ]))+ .wrap(Wrap { trim: false }),+ );+ column+ }+}++impl WidgetRef for &UnarchivePrompt {+ fn render_ref(&self, area: Rect, buf: &mut Buffer) {+ Clear.render(area, buf);+ self.content().render(area, buf);+ }+}++#[cfg(test)]+#[path = "unarchive_prompt_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/unarchive_prompt_tests.rs b/codex-rs/tui/src/unarchive_prompt_tests.rsnew file mode 100644index 0000000000..bf3bbb1cfb--- /dev/null+++ b/codex-rs/tui/src/unarchive_prompt_tests.rs@@ -0,0 +1,174 @@+use super::*;+use crate::app_server_session::ResumeModelSettings;+use crate::test_backend::VT100Backend;+use pretty_assertions::assert_eq;+use ratatui::Terminal;+use ratatui::widgets::FrameExt as _;++fn prompt(action: SessionStartAction) -> UnarchivePrompt {+ UnarchivePrompt::new(+ ThreadId::from_string("019e72f4-e09a-70f2-b2c2-a153a57b8cc0").unwrap(),+ action,+ )+}++fn render(screen: &UnarchivePrompt) -> String {+ let mut terminal = Terminal::new(VT100Backend::new(/*width*/ 80, /*height*/ 10)).unwrap();+ terminal+ .draw(|frame| frame.render_widget_ref(screen, frame.area()))+ .unwrap();+ terminal+ .backend()+ .to_string()+ .lines()+ .map(str::trim_end)+ .collect::<Vec<_>>()+ .join("\n")+ .trim()+ .to_string()+}++#[test]+fn resume_prompt_snapshot() {+ let screen = prompt(SessionStartAction::Resume(+ ResumeModelSettings::RestoreFromThread,+ ));+ insta::assert_snapshot!(render(&screen), @"+ This conversation is archived+ 019e72f4-e09a-70f2-b2c2-a153a57b8cc0++ › 1. Unarchive and resume+ 2. Cancel++ Press enter to continue or esc to cancel+ ");+}++#[test]+fn fork_prompt_cancel_snapshot() {+ let mut screen = prompt(SessionStartAction::Fork);+ assert_eq!(+ screen.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE)),+ None+ );+ insta::assert_snapshot!(render(&screen), @"+ This conversation is archived+ 019e72f4-e09a-70f2-b2c2-a153a57b8cc0++ 1. Unarchive and fork+ › 2. Cancel++ Press enter to continue or esc to cancel+ ");+ assert_eq!(+ screen.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),+ Some(UnarchiveChoice::Cancel)+ );+}++#[test]+fn confirmation_requires_an_accept_key() {+ let mut screen = prompt(SessionStartAction::Fork);+ for key in [+ KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),+ KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),+ KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),+ KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL),+ ] {+ assert_eq!(screen.handle_key(key), Some(UnarchiveChoice::Cancel));+ }+ assert_eq!(+ screen.handle_key(KeyEvent::new_with_kind(+ KeyCode::Enter,+ KeyModifiers::NONE,+ KeyEventKind::Release+ )),+ None+ );+ assert_eq!(+ screen.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),+ Some(UnarchiveChoice::Unarchive)+ );+}++fn render_inline(width: u16) -> String {+ let screen = prompt(SessionStartAction::Fork);+ let height = screen.content().desired_height(width);+ let mut terminal = Terminal::new(VT100Backend::new(width, height + 2)).unwrap();+ terminal+ .draw(|frame| {+ frame.render_widget(+ Paragraph::new("$ codex fork saved-session"),+ Rect::new(/*x*/ 0, /*y*/ 0, width, /*height*/ 1),+ );+ frame.render_widget_ref(&screen, Rect::new(/*x*/ 0, /*y*/ 2, width, height));+ })+ .unwrap();+ terminal+ .backend()+ .to_string()+ .lines()+ .map(str::trim_end)+ .collect::<Vec<_>>()+ .join("\n")+ .trim_end()+ .to_string()+}++#[test]+fn inline_prompt_preserves_shell_context_snapshot() {+ insta::assert_snapshot!("inline_prompt", render_inline(/*width*/ 80));+}++#[test]+fn narrow_inline_prompt_wraps_snapshot() {+ insta::assert_snapshot!("narrow_inline_prompt", render_inline(/*width*/ 28));+}++#[tokio::test]+async fn inline_prompt_only_claims_content_height() -> Result<()> {+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_alt_screen_enabled(/*enabled*/ false);+ let original = Rect::new(+ /*x*/ 0, /*y*/ 3, /*width*/ 80, /*height*/ 0,+ );+ tui.terminal.set_viewport_area(original);+ let screen = prompt(SessionStartAction::Fork);+ {+ let mut guard = PromptScreenGuard::enter(&mut tui)?;+ guard.draw(&screen)?;+ assert!(!guard.tui.is_alt_screen_active());+ assert_eq!(+ guard.tui.terminal.viewport_area,+ Rect {+ height: screen.content().desired_height(/*width*/ 80),+ ..original+ }+ );+ }+ assert_eq!(tui.terminal.viewport_area, original);+ Ok(())+}++#[tokio::test]+async fn alternate_prompt_restores_original_viewport() -> Result<()> {+ let mut tui = crate::tui::test_support::make_test_tui()?;+ let original = Rect::new(+ /*x*/ 0, /*y*/ 3, /*width*/ 80, /*height*/ 0,+ );+ tui.terminal.set_viewport_area(original);+ {+ let mut guard = PromptScreenGuard::enter(&mut tui)?;+ guard.draw(&prompt(SessionStartAction::Fork))?;+ assert!(guard.tui.is_alt_screen_active());+ assert_eq!(+ guard.tui.terminal.viewport_area,+ Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 24+ )+ );+ }+ assert!(!tui.is_alt_screen_active());+ assert_eq!(tui.terminal.viewport_area, original);+ Ok(())+}