Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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<ActiveTurnSteerRa
Some(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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.snap
new file mode 100644
index 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 cancel
diff --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.snap
new file mode 100644
index 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 cancel
diff --git a/codex-rs/tui/src/unarchive_prompt.rs b/codex-rs/tui/src/unarchive_prompt.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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(())
+}