Lightweight coding agent that runs in your terminal
Rust
Restore archived sessions from the resume picker (#37371)
joshyin-oai0bdce9f424eb
diff --git a/codex-rs/tui/src/resume_picker.rs b/codex-rs/tui/src/resume_picker.rsindex b4bfaa99c9..86eef4b1b0 100644--- a/codex-rs/tui/src/resume_picker.rs+++ b/codex-rs/tui/src/resume_picker.rs@@ -49,6 +49,8 @@ use codex_app_server_protocol::ThreadItem;use codex_app_server_protocol::ThreadListCwdFilter;use codex_app_server_protocol::ThreadListParams;use codex_app_server_protocol::ThreadSortKey;+use codex_app_server_protocol::ThreadUnarchiveParams;+use codex_app_server_protocol::ThreadUnarchiveResponse;use codex_config::types::SessionPickerViewMode;use codex_protocol::ThreadId;use codex_utils_path as path_utils;@@ -164,6 +166,7 @@ struct PageLoadRequest {search_token: Option<usize>,mode: PageLoadMode,cwd_filter: Option<PathBuf>,+ status: SessionStatus,provider_filter: ProviderFilter,sort_key: ThreadSortKey,}@@ -180,6 +183,9 @@ enum PickerLoadRequest {Archive {thread_id: ThreadId,},+ Unarchive {+ thread_id: ThreadId,+ },}#[derive(Clone)]@@ -212,23 +218,33 @@ impl SessionFilterMode {}}+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+enum SessionStatus {+ Active,+ Archived,+}+#[derive(Clone, Copy, Debug, PartialEq, Eq)]enum ToolbarControl {Filter,+ Status,Sort,}impl ToolbarControl {- fn previous(self) -> Self {+ fn previous(self, action: SessionPickerAction) -> Self {match self {Self::Filter => Self::Sort,+ Self::Status => Self::Filter,+ Self::Sort if matches!(action, SessionPickerAction::Resume) => Self::Status,Self::Sort => Self::Filter,}}- fn next(self) -> Self {+ fn next(self, action: SessionPickerAction) -> Self {match self {- Self::Filter => Self::Sort,+ Self::Filter if matches!(action, SessionPickerAction::Resume) => Self::Status,+ Self::Filter | Self::Status => Self::Sort,Self::Sort => Self::Filter,}}@@ -286,6 +302,10 @@ enum BackgroundEvent {thread_id: ThreadId,result: std::io::Result<()>,},+ Unarchive {+ thread_id: ThreadId,+ result: std::io::Result<SessionTarget>,+ },}#[derive(Clone)]@@ -324,8 +344,8 @@ struct SessionPickerRunOptions {/// lazy transcript previews, and pagination.////// Sessions render as compact multi-line records with stable metadata first and-/// the conversation preview last. Users can focus Sort/Filter toolbar controls-/// with Tab, change the focused control with the arrow keys, and expand the+/// the conversation preview last. Users can focus the toolbar controls with+/// Tab, change the focused control with the arrow keys, and expand the/// selected session with Ctrl+E to load recent transcript context on demand.////// Sessions are loaded on-demand via cursor-based pagination. The backend@@ -558,7 +578,9 @@ async fn run_session_picker_with_loader(}}Some(event) = background_events.next() => {- state.handle_background_event(event).await?;+ if let Some(selection) = state.handle_background_event(event).await? {+ return Ok(selection);+ }}else => break,}@@ -631,16 +653,16 @@ fn spawn_app_server_page_loader(match request {PickerLoadRequest::Page(request) => {let cursor = request.cursor.map(|PageCursor::AppServer(cursor)| cursor);- let page = load_app_server_page(- &mut app_server,+ let params = thread_list_params(cursor,request.cwd_filter.as_deref(),+ request.status,request.provider_filter,request.sort_key,include_non_interactive,matches!(request.mode, PageLoadMode::StateDbOnly),- )- .await;+ );+ let page = load_app_server_page(&mut app_server, params).await;let _ = bg_tx.send(BackgroundEvent::Page {request_token: request.request_token,search_token: request.search_token,@@ -688,6 +710,25 @@ fn spawn_app_server_page_loader(.map_err(std::io::Error::other);let _ = bg_tx.send(BackgroundEvent::Archive { thread_id, result });}+ PickerLoadRequest::Unarchive { thread_id } => {+ let result = archive_request_handle+ .request_typed::<ThreadUnarchiveResponse>(ClientRequest::ThreadUnarchive {+ request_id: RequestId::String(format!(+ "resume-picker-unarchive-{}",+ Uuid::new_v4()+ )),+ params: ThreadUnarchiveParams {+ thread_id: thread_id.to_string(),+ },+ })+ .await+ .map(|response| SessionTarget {+ path: response.thread.path,+ thread_id,+ })+ .map_err(std::io::Error::other);+ let _ = bg_tx.send(BackgroundEvent::Unarchive { thread_id, result });+ }}}if let Err(err) = app_server.shutdown().await {@@ -748,6 +789,7 @@ struct PickerState {view_width: Option<u16>,provider_filter: ProviderFilter,filter_mode: SessionFilterMode,+ status: SessionStatus,filter_cwd: Option<PathBuf>,local_filter_cwd: Option<PathBuf>,toolbar_focus: ToolbarControl,@@ -810,22 +852,10 @@ enum LoadTrigger {async fn load_app_server_page(app_server: &mut AppServerSession,- cursor: Option<String>,- cwd_filter: Option<&Path>,- provider_filter: ProviderFilter,- sort_key: ThreadSortKey,- include_non_interactive: bool,- use_state_db_only: bool,+ params: ThreadListParams,) -> std::io::Result<PickerPage> {let response = app_server- .thread_list(thread_list_params(- cursor,- cwd_filter,- provider_filter,- sort_key,- include_non_interactive,- use_state_db_only,- ))+ .thread_list(params).await.map_err(std::io::Error::other)?;let num_scanned_files = response.data.len();@@ -1086,6 +1116,7 @@ impl PickerState {view_width: None,provider_filter,filter_mode: SessionFilterMode::from_show_all(show_all, filter_cwd.as_deref()),+ status: SessionStatus::Active,local_filter_cwd: filter_cwd.clone(),filter_cwd,toolbar_focus: ToolbarControl::Filter,@@ -1313,7 +1344,7 @@ impl PickerState {self.toggle_density().await;}_ if self.list_keymap.accept.is_pressed(key)- && matches!(self.archive_state, archive::ArchiveState::Pending { .. }) => {}+ && !matches!(self.archive_state, archive::ArchiveState::Idle) => {}_ if self.list_keymap.accept.is_pressed(key) => {if let Some(row) = self.filtered_rows.get(self.selected) {let path = row.path.clone();@@ -1328,6 +1359,10 @@ impl PickerState {},};if let Some(thread_id) = thread_id {+ if self.status == SessionStatus::Archived {+ self.request_unarchive(thread_id);+ return Ok(None);+ }return Ok(Some(self.action.selection(path, thread_id)));}self.inline_error = Some(match path {@@ -1489,12 +1524,16 @@ impl PickerState {search_token,mode,cwd_filter: self.active_cwd_filter(),+ status: self.status,provider_filter: self.provider_filter.clone(),sort_key: self.sort_key,}));}- async fn handle_background_event(&mut self, event: BackgroundEvent) -> Result<()> {+ async fn handle_background_event(+ &mut self,+ event: BackgroundEvent,+ ) -> Result<Option<SessionSelection>> {match event {BackgroundEvent::Page {request_token,@@ -1502,7 +1541,7 @@ impl PickerState {page,} => {let Some(pending) = self.pagination.finish_load(request_token) else {- return Ok(());+ return Ok(None);};let page_has_rows = matches!(&page, Ok(page) if !page.rows.is_empty());// Fall back only when the initial DB listing is unusable. Once SQLite returns@@ -1525,10 +1564,11 @@ impl PickerState {search_token,mode: PageLoadMode::StoreDefault,cwd_filter: self.active_cwd_filter(),+ status: self.status,provider_filter: self.provider_filter.clone(),sort_key: self.sort_key,}));- return Ok(());+ return Ok(None);}let page = page.map_err(color_eyre::Report::from)?;self.ingest_page(page);@@ -1575,8 +1615,11 @@ impl PickerState {BackgroundEvent::Archive { thread_id, result } => {self.handle_archive_result(thread_id, result);}+ BackgroundEvent::Unarchive { thread_id, result } => {+ return Ok(self.handle_unarchive_result(thread_id, result));+ }}- Ok(())+ Ok(None)}fn reset_pagination(&mut self) {@@ -1811,6 +1854,7 @@ impl PickerState {search_token,mode,cwd_filter: self.active_cwd_filter(),+ status: self.status,provider_filter: self.provider_filter.clone(),sort_key: self.sort_key,}));@@ -1857,6 +1901,14 @@ impl PickerState {self.start_initial_load();}+ fn toggle_status(&mut self) {+ self.status = match self.status {+ SessionStatus::Active => SessionStatus::Archived,+ SessionStatus::Archived => SessionStatus::Active,+ };+ self.start_initial_load();+ }+fn active_cwd_filter(&self) -> Option<PathBuf> {match self.filter_mode {SessionFilterMode::Cwd => self.filter_cwd.clone(),@@ -1865,17 +1917,18 @@ impl PickerState {}fn focus_previous_toolbar_control(&mut self) {- self.toolbar_focus = self.toolbar_focus.previous();+ self.toolbar_focus = self.toolbar_focus.previous(self.action);}fn focus_next_toolbar_control(&mut self) {- self.toolbar_focus = self.toolbar_focus.next();+ self.toolbar_focus = self.toolbar_focus.next(self.action);}fn change_focused_toolbar_value(&mut self) {match self.toolbar_focus {ToolbarControl::Sort => self.toggle_sort_key(),ToolbarControl::Filter => self.toggle_filter_mode(),+ ToolbarControl::Status => self.toggle_status(),}}@@ -2035,6 +2088,7 @@ fn row_from_app_server_thread(thread: Thread) -> Option<Row> {fn thread_list_params(cursor: Option<String>,cwd_filter: Option<&Path>,+ status: SessionStatus,provider_filter: ProviderFilter,sort_key: ThreadSortKey,include_non_interactive: bool,@@ -2050,7 +2104,7 @@ fn thread_list_params(ProviderFilter::MatchDefault(default_provider) => Some(vec![default_provider]),},source_kinds: Some(crate::resume_source_kinds(include_non_interactive)),- archived: Some(false),+ archived: Some(status == SessionStatus::Archived),section_id: None,parent_thread_id: None,ancestor_thread_id: None,@@ -2135,11 +2189,11 @@ fn search_line(state: &PickerState, width: u16) -> Line<'_> {} else {format!("Search: {}", state.query).into()};+ let search_width = UnicodeWidthStr::width(search.content.as_ref());let mut toolbar = toolbar_line(state, /*compact*/ false);- if toolbar.width() as u16 > width.saturating_sub(2) {+ if search_width.saturating_add(toolbar.width()) > usize::from(width.saturating_sub(2)) {toolbar = toolbar_line(state, /*compact*/ true);}- let search_width = UnicodeWidthStr::width(search.content.as_ref());let toolbar_width = toolbar.width();let spacer_width = width.saturating_sub((search_width + toolbar_width) as u16)@@ -2165,8 +2219,40 @@ fn search_line(state: &PickerState, width: u16) -> Line<'_> {fn toolbar_line(state: &PickerState, compact: bool) -> Line<'static> {let mut spans = Vec::new();+ let separator = if compact && matches!(state.action, SessionPickerAction::Resume) {+ " "+ } else {+ " "+ };spans.extend(filter_control_spans(state, compact));- spans.push(" ".dim());+ spans.push(separator.dim());+ if matches!(state.action, SessionPickerAction::Resume) {+ let status_focused = state.toolbar_focus == ToolbarControl::Status;+ if compact {+ let active_status = match state.status {+ SessionStatus::Active => "Active",+ SessionStatus::Archived => "Archived",+ };+ spans.push(toolbar_value(+ active_status,+ /*active*/ true,+ status_focused,+ ));+ } else {+ spans.push("Status: ".dim());+ spans.push(toolbar_value(+ "Active",+ state.status == SessionStatus::Active,+ status_focused,+ ));+ spans.push(toolbar_value(+ "Archived",+ state.status == SessionStatus::Archived,+ status_focused,+ ));+ }+ spans.push(separator.dim());+ }spans.extend(sort_control_spans(state, compact));spans.into()}@@ -2389,7 +2475,11 @@ fn footer_hint_lines(state: &PickerState, width: u16) -> Vec<Line<'static>> {return vec![line, Line::default()];}- let action_label = state.action.action_label();+ let action_label = if state.status == SessionStatus::Archived {+ "restore"+ } else {+ state.action.action_label()+ };let (esc_label, esc_compact_label) = if state.query.is_empty() {match state.launch_context {SessionPickerLaunchContext::Startup => ("start new", "new"),@@ -3609,6 +3699,7 @@ mod tests {let params = thread_list_params(Some(String::from("cursor-1")),cwd_filter.as_deref(),+ SessionStatus::Active,ProviderFilter::MatchDefault(String::from("openai")),ThreadSortKey::UpdatedAt,/*include_non_interactive*/ false,@@ -3987,6 +4078,7 @@ mod tests {let params = thread_list_params(Some(String::from("cursor-1")),Some(Path::new("repo/on/server")),+ SessionStatus::Active,ProviderFilter::Any,ThreadSortKey::UpdatedAt,/*include_non_interactive*/ false,@@ -4010,6 +4102,7 @@ mod tests {let params = thread_list_params(Some(String::from("cursor-1")),/*cwd_filter*/ None,+ SessionStatus::Active,ProviderFilter::Any,ThreadSortKey::UpdatedAt,/*include_non_interactive*/ true,@@ -5180,6 +5273,7 @@ session_picker_view = "dense"let line = search_line(&state, /*width*/ 40).to_string();assert!(line.contains("Filter:[Cwd]"));+ assert!(line.contains("[Active]"));assert!(line.contains("Sort:[Updated]"));assert!(line.find("Filter:[Cwd]") < line.find("Sort:[Updated]"));}@@ -5853,6 +5947,10 @@ session_picker_view = "dense"assert_eq!(guard[0].sort_key, ThreadSortKey::UpdatedAt);}+ state+ .handle_key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE))+ .await+ .unwrap();state.handle_key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)).await@@ -5936,7 +6034,7 @@ session_picker_view = "dense"}#[tokio::test]- async fn filter_stays_all_when_no_cwd_candidate_exists() {+ async fn status_changes_when_directory_filter_is_unavailable() {let recorded_requests: Arc<Mutex<Vec<PageLoadRequest>>> = Arc::new(Mutex::new(Vec::new()));let request_sink = recorded_requests.clone();let loader = page_only_loader(move |req: PageLoadRequest| {@@ -5965,10 +6063,21 @@ session_picker_view = "dense".handle_key(KeyEvent::new(KeyCode::Right, KeyModifiers::NONE)).await.unwrap();+ state+ .handle_key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE))+ .await+ .unwrap();+ state+ .handle_key(KeyEvent::new(KeyCode::Right, KeyModifiers::NONE))+ .await+ .unwrap();let guard = recorded_requests.lock().unwrap();- assert_eq!(guard.len(), 1);+ assert_eq!(guard.len(), 2);+ assert_eq!(guard[0].status, SessionStatus::Active);assert_eq!(guard[0].cwd_filter, None);+ assert_eq!(guard[1].status, SessionStatus::Archived);+ assert_eq!(guard[1].cwd_filter, None);}#[tokio::test]diff --git a/codex-rs/tui/src/resume_picker/archive.rs b/codex-rs/tui/src/resume_picker/archive.rsindex a44d5c164b..41f0659290 100644--- a/codex-rs/tui/src/resume_picker/archive.rs+++ b/codex-rs/tui/src/resume_picker/archive.rs@@ -10,6 +10,9 @@ use super::Row;use super::SearchState;use super::SessionPickerAction;use super::SessionPickerLaunchContext;+use super::SessionSelection;+use super::SessionStatus;+use super::SessionTarget;use crate::keymap::KeymapContext;#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]@@ -19,11 +22,16 @@ pub(super) enum ArchiveState {Pending {thread_id: ThreadId,},+ Restoring {+ thread_id: ThreadId,+ },}impl PickerState {pub(super) fn archive_shortcut_available(&self) -> bool {- if !matches!(self.action, SessionPickerAction::Resume) {+ if !matches!(self.action, SessionPickerAction::Resume)+ || self.status == SessionStatus::Archived+ {return false;}@@ -127,6 +135,36 @@ impl PickerState {self.load_more_if_needed(LoadTrigger::Search { token });}}++ pub(super) fn request_unarchive(&mut self, thread_id: ThreadId) {+ if !matches!(self.archive_state, ArchiveState::Idle) {+ return;+ }++ self.archive_state = ArchiveState::Restoring { thread_id };+ self.request_frame();+ (self.picker_loader)(PickerLoadRequest::Unarchive { thread_id });+ }++ pub(super) fn handle_unarchive_result(+ &mut self,+ thread_id: ThreadId,+ result: std::io::Result<SessionTarget>,+ ) -> Option<SessionSelection> {+ if self.archive_state != (ArchiveState::Restoring { thread_id }) {+ return None;+ }+ self.archive_state = ArchiveState::Idle;++ match result {+ Ok(target) => Some(SessionSelection::Resume(target)),+ Err(error) => {+ self.inline_error = Some(format!("Failed to restore archived session: {error}"));+ self.request_frame();+ None+ }+ }+ }}#[cfg(test)]diff --git a/codex-rs/tui/src/resume_picker/archive_tests.rs b/codex-rs/tui/src/resume_picker/archive_tests.rsindex c379115e5d..51f0d61c11 100644--- a/codex-rs/tui/src/resume_picker/archive_tests.rs+++ b/codex-rs/tui/src/resume_picker/archive_tests.rs@@ -5,16 +5,21 @@ use super::super::ProviderFilter;use super::super::Row;use super::super::SessionPickerAction;use super::super::SessionPickerLaunchContext;+use super::super::SessionSelection;+use super::super::SessionStatus;+use super::super::SessionTarget;use super::ArchiveState;use crate::key_hint::KeyBinding;use crate::tui::FrameRequester;use codex_app_server_client::TypedRequestError;use codex_app_server_protocol::JSONRPCErrorError;+use codex_app_server_protocol::ThreadSortKey;use codex_protocol::ThreadId;use crossterm::event::KeyCode;use crossterm::event::KeyEvent;use crossterm::event::KeyModifiers;use pretty_assertions::assert_eq;+use std::path::PathBuf;use std::sync::Arc;use std::sync::Mutex;@@ -22,7 +27,9 @@ fn archive_picker_state() -> (PickerState, Arc<Mutex<Vec<ThreadId>>>) {let requests = Arc::new(Mutex::new(Vec::new()));let request_sink = Arc::clone(&requests);let picker_loader: PickerLoader = Arc::new(move |request| {- if let PickerLoadRequest::Archive { thread_id } = request {+ if let PickerLoadRequest::Archive { thread_id }+ | PickerLoadRequest::Unarchive { thread_id } = request+ {request_sink.lock().expect("archive request sink")@@ -155,3 +162,133 @@ fn archive_footer_shows_shortcut_for_resume_sessions() {ctrl+o dense view ctrl+t transcript ctrl+e expand ↑/↓ browse");}++#[test]+fn archived_status_preserves_directory_filter_and_hides_archive_shortcut() {+ let requested_filters = Arc::new(Mutex::new(Vec::new()));+ let request_sink = Arc::clone(&requested_filters);+ let picker_loader: PickerLoader = Arc::new(move |request| {+ if let PickerLoadRequest::Page(request) = request {+ request_sink+ .lock()+ .expect("page request sink")+ .push((request.status, request.cwd_filter));+ }+ });+ let mut state = PickerState::new(+ FrameRequester::test_dummy(),+ picker_loader,+ ProviderFilter::Any,+ /*show_all*/ false,+ Some(PathBuf::from("/tmp/project")),+ SessionPickerAction::Resume,+ );++ state.toggle_status();++ assert_eq!(state.status, SessionStatus::Archived);+ let params = super::super::thread_list_params(+ /*cursor*/ None,+ Some(std::path::Path::new("/tmp/project")),+ SessionStatus::Archived,+ ProviderFilter::Any,+ ThreadSortKey::UpdatedAt,+ /*include_non_interactive*/ false,+ /*use_state_db_only*/ false,+ );+ assert_eq!(params.archived, Some(true));++ set_selected_session(&mut state, ThreadId::new());+ assert!(!state.archive_shortcut_available());+ let footer = super::super::footer_hint_lines(&state, /*width*/ 220)+ .into_iter()+ .map(|line| line.to_string())+ .collect::<Vec<_>>()+ .join("\n");+ insta::assert_snapshot!(footer, @r"+ enter restore esc start new ctrl+c quit tab focus sort/filter ←/→ change option+ ctrl+o dense view ctrl+t transcript ctrl+e expand ↑/↓ browse+ ");+ insta::assert_snapshot!(+ super::super::toolbar_line(&state, /*compact*/ true).to_string(),+ @"Filter:[Cwd] [Archived] Sort:[Updated]"+ );++ state.toggle_filter_mode();++ assert_eq!(+ *requested_filters.lock().unwrap(),+ vec![+ (SessionStatus::Archived, Some(PathBuf::from("/tmp/project")),),+ (SessionStatus::Archived, None),+ ]+ );+}++#[tokio::test]+async fn archived_session_restore_resumes_after_completion() {+ let (mut state, requests) = archive_picker_state();+ let thread_id = ThreadId::new();+ state.status = SessionStatus::Archived;+ set_selected_session(&mut state, thread_id);++ assert!(+ state+ .handle_key(KeyEvent::from(KeyCode::Enter))+ .await+ .unwrap()+ .is_none()+ );+ assert_eq!(state.archive_state, ArchiveState::Restoring { thread_id });+ assert_eq!(*requests.lock().unwrap(), vec![thread_id]);++ assert!(+ state+ .handle_key(KeyEvent::from(KeyCode::Enter))+ .await+ .unwrap()+ .is_none()+ );+ assert_eq!(*requests.lock().unwrap(), vec![thread_id]);++ let selection = state.handle_unarchive_result(+ thread_id,+ Ok(SessionTarget {+ path: None,+ thread_id,+ }),+ );++ assert!(matches!(+ selection,+ Some(SessionSelection::Resume(SessionTarget {+ path: None,+ thread_id: resumed_thread_id,+ })) if resumed_thread_id == thread_id+ ));+ assert_eq!(state.archive_state, ArchiveState::Idle);+}++#[test]+fn archived_session_restore_failure_preserves_session_and_allows_retry() {+ let (mut state, requests) = archive_picker_state();+ let thread_id = ThreadId::new();+ state.status = SessionStatus::Archived;+ set_selected_session(&mut state, thread_id);+ state.request_unarchive(thread_id);++ let selection =+ state.handle_unarchive_result(thread_id, Err(std::io::Error::other("restore denied")));++ assert!(selection.is_none());+ assert_eq!(state.archive_state, ArchiveState::Idle);+ assert_eq!(+ state.inline_error.as_deref(),+ Some("Failed to restore archived session: restore denied")+ );+ assert_eq!(state.filtered_rows.len(), 1);++ state.request_unarchive(thread_id);++ assert_eq!(*requests.lock().unwrap(), vec![thread_id, thread_id]);+}diff --git a/codex-rs/tui/src/snapshots/codex_tui__resume_picker__tests__resume_picker_search_line_sort_filter_tabs.snap b/codex-rs/tui/src/snapshots/codex_tui__resume_picker__tests__resume_picker_search_line_sort_filter_tabs.snapindex f48b6543cd..7d9be2926d 100644--- a/codex-rs/tui/src/snapshots/codex_tui__resume_picker__tests__resume_picker_search_line_sort_filter_tabs.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__resume_picker__tests__resume_picker_search_line_sort_filter_tabs.snap@@ -2,4 +2,4 @@source: tui/src/resume_picker.rsexpression: terminal.backend().to_string()----Type to search Filter: [Cwd] All Sort: [Updated] Created+Type to search Filter: [Cwd] All Status: [Active] Archived Sort: [Updated] Created