diff --git a/codex-rs/config/src/tui_keymap.rs b/codex-rs/config/src/tui_keymap.rs index b3a4258533..e1e4cc4524 100644 --- a/codex-rs/config/src/tui_keymap.rs +++ b/codex-rs/config/src/tui_keymap.rs @@ -137,6 +137,8 @@ pub struct TuiGlobalKeymap { pub leader: Option, /// Change where a new conversation runs. pub change_host: Option, + /// Choose a saved environment for a new Cloud conversation. + pub choose_cloud_environment: Option, /// Focus the main conversation composer. pub focus_main_composer: Option, /// Focus the side conversation, or hide it when already focused. diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index 9f781a41ef..0347fb96d7 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -5556,6 +5556,7 @@ }, "global": { "change_host": null, + "choose_cloud_environment": null, "clear_terminal": null, "close_sidebar_tab": null, "copy": null, @@ -6406,6 +6407,14 @@ ], "description": "Change where a new conversation runs." }, + "choose_cloud_environment": { + "allOf": [ + { + "$ref": "#/definitions/KeybindingsSpec" + } + ], + "description": "Choose a saved environment for a new Cloud conversation." + }, "clear_terminal": { "allOf": [ { @@ -6777,6 +6786,7 @@ ], "default": { "change_host": null, + "choose_cloud_environment": null, "clear_terminal": null, "close_sidebar_tab": null, "copy": null, diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index 63bb1674df..f5b81aba77 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -222,6 +222,7 @@ mod backend_registry; pub(crate) mod backend_selection; pub(crate) mod backend_sessions; mod background_requests; +mod cloud_environments; mod cloud_switch_wait; #[cfg(test)] pub(crate) use cloud_switch_wait::wait_for_cloud_switch; diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rs index e607289c99..869273050b 100644 --- a/codex-rs/tui/src/app/agents_overview.rs +++ b/codex-rs/tui/src/app/agents_overview.rs @@ -86,6 +86,9 @@ pub(super) struct AgentsOverviewState { pub(super) requested_permission_profiles: HashMap, /// Keep new tasks subscribed and reusable until a first turn makes them resumable. pub(super) blank_sessions: HashMap, + /// A host switch carries this choice with the draft, but only its original backend can use it. + pub(super) draft_cloud_environments: + HashMap, pub(super) input_states: HashMap, pub(super) new_session_draft: Option>, pub(super) dispatched_requests: HashMap>, diff --git a/codex-rs/tui/src/app/agents_overview_threads.rs b/codex-rs/tui/src/app/agents_overview_threads.rs index a6b98bd0a4..b3902d3c97 100644 --- a/codex-rs/tui/src/app/agents_overview_threads.rs +++ b/codex-rs/tui/src/app/agents_overview_threads.rs @@ -112,6 +112,9 @@ impl App { | ServerNotification::ThreadDeleted(_) ) { self.agents_overview.blank_sessions.remove(&thread_id); + self.agents_overview + .draft_cloud_environments + .remove(&thread_id); } self.track_agents_overview_activity(thread_id, notification); let thread = self diff --git a/codex-rs/tui/src/app/backend_selection.rs b/codex-rs/tui/src/app/backend_selection.rs index bacaec27bf..4fc9fcfdca 100644 --- a/codex-rs/tui/src/app/backend_selection.rs +++ b/codex-rs/tui/src/app/backend_selection.rs @@ -15,6 +15,7 @@ use futures::TryFutureExt; pub(super) enum NewBackendSession { Fresh { name: Option }, CarryDraft, + ChangeCloudEnvironment(Option), } /// Host inputs for the new-thread preference. A cloud thread's cwd and credentials @@ -171,16 +172,21 @@ impl App { } let displayed_thread = self.current_displayed_thread_id(); let outgoing_slot = backends.displayed; + let switching_backend = owner != backends.displayed_owner(); if let Some(thread_id) = displayed_thread && self.active_turn_id_for_thread(thread_id).await.is_some() { return Err("Wait for the current turn to finish before switching.".into()); } - let mut settings = backends - .settings - .get(&owner) - .cloned() - .ok_or("Connection settings are unavailable.")?; + let mut settings = if !switching_backend { + self.backend_settings() + } else { + backends + .settings + .get(&owner) + .cloned() + .ok_or("Connection settings are unavailable.")? + }; if settings.target == AppServerTarget::Cloud && self.chat_widget.thread_id().is_some() { self.remember_attached_host_project(backends.session_at(outgoing_slot)); } @@ -196,19 +202,28 @@ impl App { }; let user_config_path = self.local_settings.user_config_path.clone(); let responsive_cloud_switch = settings.target == AppServerTarget::Cloud - && matches!(session, NewBackendSession::CarryDraft); - let (name, mut draft) = match session { + && !matches!(session, NewBackendSession::Fresh { .. }); + let replacing_cloud_draft = matches!(session, NewBackendSession::ChangeCloudEnvironment(_)); + let (name, mut draft, saved_environment) = match session { NewBackendSession::Fresh { name } => { *fresh_draft = Some(StartupDraftPump::for_new_session( tui, &settings.local_settings, settings.config.cwd.as_path(), )); - (name, None) + (name, None, None) } NewBackendSession::CarryDraft => ( self.chat_widget.thread_name(), (!responsive_cloud_switch).then(|| self.chat_widget.composer_draft_snapshot()), + displayed_thread + .and_then(|id| self.agents_overview.draft_cloud_environments.get(&id)) + .cloned(), + ), + NewBackendSession::ChangeCloudEnvironment(environment) => ( + self.chat_widget.thread_name(), + None, + environment.map(|env| (owner, env)), ), }; let destination = backends.session_at_mut(slot); @@ -294,14 +309,20 @@ impl App { draft.apply_settings(&local_settings, config.cwd.as_path()); } let host_project_cwd = self.backend_preference_context.local_cwd.clone(); + let cloud_start = match &saved_environment { + Some((backend, env)) if *backend == owner => { + crate::app_server_session::CloudThreadStart::Saved(env.id.clone()) + } + _ => crate::app_server_session::CloudThreadStart::Project(host_project_cwd.as_deref()), + }; let start = destination - .start_thread_with_session_start_source( + .start_thread_with_environment( &local_settings, &config, /*session_start_source*/ None, /*remote_cwd_override*/ None, /*selected_profile*/ None, - host_project_cwd.as_deref(), + cloud_start, ) .map_err(|error| format!("Failed to start the new conversation: {error}")); let Some(started) = if responsive_cloud_switch { @@ -325,8 +346,8 @@ impl App { if responsive_cloud_switch { draft = Some(self.chat_widget.composer_draft_snapshot()); } - // Clear before switching so a terminal error leaves the outgoing conversation usable. - if let Err(error) = tui.clear_for_thread_switch() { + // A same-backend Cloud start already replaced the attachment. Clear on its first draw. + if switching_backend && let Err(error) = tui.clear_for_thread_switch() { if responsive_cloud_switch { let events = tui.event_stream(); if finish_failed_cloud_switch(self, tui, events) @@ -340,15 +361,17 @@ impl App { } let destination_thread = started.session.thread_id; let outgoing_has_queue = self.chat_widget.has_queued_follow_up_messages(); - self.switch_backend_context( - backends, - slot, - started.session.thread_id, - settings.target, - config.cwd.to_path_buf(), - bootstrap, - ) - .await; + if switching_backend { + self.switch_backend_context( + backends, + slot, + started.session.thread_id, + settings.target, + config.cwd.to_path_buf(), + bootstrap, + ) + .await; + } let destination = backends.session_at_mut(slot); self.adopt_fresh_session( tui, @@ -358,12 +381,32 @@ impl App { config, local_settings, }, - ThreadAttachPresentation::FreshAfterClear, + if switching_backend { + ThreadAttachPresentation::FreshAfterClear + } else { + ThreadAttachPresentation::FreshWithDraft + }, /*initial_user_message*/ None, name, ) .await; - backends.switch_displayed(slot, &mut self.agents_overview.input_states); + if replacing_cloud_draft + && let Some(source) = displayed_thread + && self.current_displayed_thread_id() == Some(destination_thread) + { + destination.move_staged_cloud_settings(source, destination_thread); + self.chat_widget.sync_service_tier_commands(); + } + if let Some(environment) = saved_environment + && self.current_displayed_thread_id() == Some(destination_thread) + { + self.agents_overview + .draft_cloud_environments + .insert(destination_thread, environment); + } + if switching_backend { + backends.switch_displayed(slot, &mut self.agents_overview.input_states); + } if !backends.session_at_mut(slot).uses_remote_workspace() && self.current_displayed_thread_id() == Some(destination_thread) { @@ -381,7 +424,10 @@ impl App { } else { self.chat_widget.restore_startup_draft(draft); } + // Another Cloud client may have started a turn on the source while we + // opened this environment. Keep that thread and its local input accessible. if let Some(thread_id) = displayed_thread + && !replacing_cloud_draft && !outgoing_has_queue && self.current_displayed_thread_id() == Some(destination_thread) && self @@ -390,7 +436,12 @@ impl App { .remove(&thread_id) .is_some() { - backends.parked_inputs_mut(outgoing_slot).remove(&thread_id); + let input_states = if switching_backend { + backends.parked_inputs_mut(outgoing_slot) + } else { + &mut self.agents_overview.input_states + }; + input_states.remove(&thread_id); self.remove_agents_overview_thread(thread_id); if let Err(error) = backends .session_at_mut(outgoing_slot) diff --git a/codex-rs/tui/src/app/cloud_environments.rs b/codex-rs/tui/src/app/cloud_environments.rs new file mode 100644 index 0000000000..606f82c878 --- /dev/null +++ b/codex-rs/tui/src/app/cloud_environments.rs @@ -0,0 +1,74 @@ +//! Shows saved Cloud environments before starting a conversation on the Cloud backend. + +use crate::app_event::AppEvent; +use crate::bottom_pane::SelectionItem; +use crate::bottom_pane::SelectionViewParams; +use codex_app_server_client::SavedEnvironment; +use codex_protocol::ThreadId; + +pub(super) const LOADING_VIEW_ID: &str = "cloud_environment_loading"; + +pub(super) fn loading_view() -> SelectionViewParams { + SelectionViewParams { + view_id: Some(LOADING_VIEW_ID), + title: Some("Cloud environment".into()), + subtitle: Some("Loading saved environments…".into()), + ..SelectionViewParams::picker() + } +} + +pub(super) fn cloud_environment_picker( + result: Result, String>, + source: ThreadId, +) -> SelectionViewParams { + let (environments, subtitle) = match result { + Ok(environments) => (environments, None), + Err(error) => ( + Vec::new(), + Some(format!("{error}. You can still use Default.")), + ), + }; + let choices = std::iter::once(( + "Default".to_string(), + "Use the default environment with the current GitHub project, if available", + None, + )) + .chain(environments.into_iter().map(|environment| { + ( + environment.name.clone(), + if environment.workspace_shared { + "Workspace environment" + } else { + "Personal environment" + }, + Some(environment), + ) + })); + let items = choices + .map(|(name, description, saved_environment)| SelectionItem { + search_value: Some(name.clone()), + name, + description: Some(description.to_string()), + actions: vec![Box::new(move |tx| { + tx.send(AppEvent::StartCloudConversation { + source, + saved_environment: saved_environment.clone(), + }); + })], + dismiss_on_select: true, + ..Default::default() + }) + .collect(); + SelectionViewParams { + title: Some("Cloud environment".into()), + subtitle, + items, + is_searchable: true, + search_placeholder: Some("Search environments".to_string()), + ..SelectionViewParams::picker() + } +} + +#[cfg(test)] +#[path = "cloud_environments_tests.rs"] +mod tests; diff --git a/codex-rs/tui/src/app/cloud_environments_tests.rs b/codex-rs/tui/src/app/cloud_environments_tests.rs new file mode 100644 index 0000000000..b8e57d6dc9 --- /dev/null +++ b/codex-rs/tui/src/app/cloud_environments_tests.rs @@ -0,0 +1,61 @@ +#![cfg(test)] + +use super::*; +use crate::app::tests::make_test_app_with_channels; +use crate::chatwidget::tests::render_bottom_popup; +use crossterm::event::KeyCode; +use pretty_assertions::assert_eq; + +#[tokio::test] +async fn cloud_environment_picker_shows_default_and_saved_choice() { + let (mut app, mut events, _) = make_test_app_with_channels().await; + let source = ThreadId::new(); + let saved = SavedEnvironment { + id: "ws~asenvcfg_saved".into(), + name: "Team Rust".into(), + workspace_shared: true, + }; + app.chat_widget + .show_selection_view(cloud_environment_picker(Ok(vec![saved.clone()]), source)); + + let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 110); + let rows = ["Cloud environment", "Default", "Team Rust"].map(|label| { + let line = rendered.lines().find(|line| line.contains(label)).unwrap(); + line[line.find(label).unwrap()..] + .split_whitespace() + .collect::>() + .join(" ") + }); + insta::assert_snapshot!(rows.join("\n"), @" + Cloud environment + Default Use the default environment with the current GitHub project, if available + Team Rust Workspace environment + "); + + for key in "rust".chars().map(KeyCode::Char) { + app.chat_widget.handle_key_event(key.into()); + } + app.chat_widget.handle_key_event(KeyCode::Enter.into()); + let selection = std::iter::from_fn(|| events.try_recv().ok()).find_map(|event| match event { + AppEvent::StartCloudConversation { + source, + saved_environment, + } => Some((source, saved_environment)), + _ => None, + }); + assert_eq!(selection, Some((source, Some(saved)))); +} + +#[tokio::test] +async fn dismissing_cloud_environment_loading_keeps_the_draft() { + let (mut app, _, _) = make_test_app_with_channels().await; + app.chat_widget.apply_external_edit("draft".into()); + app.chat_widget.show_selection_view(loading_view()); + app.chat_widget.handle_key_event(KeyCode::Esc.into()); + let view = cloud_environment_picker(Ok(Vec::new()), ThreadId::new()); + assert!( + !app.chat_widget + .replace_selection_view_if_present(LOADING_VIEW_ID, view) + ); + assert_eq!(app.chat_widget.composer_text_with_pending(), "draft"); +} diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index f1ce22b57b..358afac939 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -655,7 +655,10 @@ impl App { Err(err) => return Err(err), } } - AppEvent::ResumeBackendSession(_) | AppEvent::CycleNewConversationBackend => { + AppEvent::ResumeBackendSession(_) + | AppEvent::CycleNewConversationBackend + | AppEvent::ChooseCloudEnvironment + | AppEvent::StartCloudConversation { .. } => { unreachable!("backend selection is handled by the session manager") } AppEvent::ArchiveCurrentThread => { diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs index 9f12b333b5..696d820842 100644 --- a/codex-rs/tui/src/app/session_lifecycle.rs +++ b/codex-rs/tui/src/app/session_lifecycle.rs @@ -1046,6 +1046,12 @@ impl App { }); self.thread_event_channels .retain(|id, _| Some(*id) == voice_owner || self.side_threads.contains_key(id)); + let displayed = self.current_displayed_thread_id(); + self.agents_overview + .draft_cloud_environments + .retain(|id, _| { + displayed == Some(*id) || self.agents_overview.blank_sessions.contains_key(id) + }); // A retained side can still display its parent even after the parent channel is detached. self.side_companions.retain(|id, _| { self.side_threads.contains_key(id) diff --git a/codex-rs/tui/src/app/side.rs b/codex-rs/tui/src/app/side.rs index 2b9a9deaaf..fa9de003ad 100644 --- a/codex-rs/tui/src/app/side.rs +++ b/codex-rs/tui/src/app/side.rs @@ -602,6 +602,9 @@ impl App { }); self.abort_thread_event_listener(thread_id); self.thread_event_channels.remove(&thread_id); + self.agents_overview + .draft_cloud_environments + .remove(&thread_id); self.pending_server_profiles.remove(&thread_id); self.agents_overview.activity.remove(&thread_id); self.sidebars.remove(&Some(thread_id)); diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs index 8a9ac4e784..b15a20a822 100644 --- a/codex-rs/tui/src/app/startup.rs +++ b/codex-rs/tui/src/app/startup.rs @@ -1308,6 +1308,9 @@ See the Codex keymap documentation for supported actions and examples." let mut settled_size_tags = crate::terminal_size_telemetry::tags(last_screen_size); let mut pending_resize: Option<(ratatui::layout::Size, Instant)> = None; let mut reconnect = None; + let mut cloud_environment_picker: Option< + futures::future::LocalBoxFuture<'static, crate::bottom_pane::SelectionViewParams>, + > = None; let mut waiting_for_initial_session_configured = wait_for_initial_session_configured; let mut waiting_for_initial_session_header = true; @@ -1368,7 +1371,25 @@ See the Codex keymap documentation for supported actions and examples." .flatten(); let current_label = next_backend.and_then(|_| backends.displayed_name(&app.app_server_target)); - app.chat_widget.set_new_backend_control(current_label); + let cloud_draft = draft.filter(|_| { + app.app_server_target == AppServerTarget::Cloud + && backends.is_listening(displayed_owner) + }); + let environment_name = cloud_draft.map(|id| { + app.agents_overview + .draft_cloud_environments + .get(&id) + .filter(|(owner, _)| *owner == displayed_owner) + .map(|(_, env)| { + crate::terminal_title::sanitize_terminal_title( + &env.name, + crate::terminal_title::TitleEncoding::Unicode, + ) + }) + .unwrap_or_else(|| "Default".into()) + }); + app.chat_widget + .set_new_backend_control(current_label, environment_name); if !backends.is_listening(displayed_owner) && !app.pending_startup_thread_start && !app.reconnect.offline @@ -1523,6 +1544,13 @@ See the Codex keymap documentation for supported actions and examples." } AppRunControl::Continue } + Some(view) = futures::future::OptionFuture::from(cloud_environment_picker.as_mut()) => { + cloud_environment_picker = None; + app.chat_widget.replace_selection_view_if_present( + super::cloud_environments::LOADING_VIEW_ID, view, + ); + AppRunControl::Continue + } Some(event) = app.saved_openings.next_event(&mut app_event_rx) => { if let AppEvent::ArchiveFinished { backend_id, thread_id, result: Ok(()) } = &event && *backend_id != displayed_owner @@ -1531,6 +1559,25 @@ See the Codex keymap documentation for supported actions and examples." backends.parked_inputs_mut(slot).remove(thread_id); } let switch_backend = match &event { + AppEvent::ChooseCloudEnvironment => { + if let Some(source) = cloud_draft + && app.chat_widget.no_modal_or_popup_active() + && let AppServerRequestHandle::Cloud(handle) = backends.session_at(displayed_session).request_handle() + { + app.chat_widget.show_selection_view(super::cloud_environments::loading_view()); + cloud_environment_picker = Some(Box::pin(async move { + let environments = handle.list_saved_environments().await.map_err(|error| error.to_string()); + super::cloud_environments::cloud_environment_picker(environments, source) + })); + } + continue; + } + AppEvent::StartCloudConversation { source, saved_environment } + if cloud_draft == Some(*source) => + { + Some((displayed_owner, NewBackendSession::ChangeCloudEnvironment(saved_environment.clone()))) + } + AppEvent::StartCloudConversation { .. } => continue, AppEvent::ChooseNewSessionCheckout { name } | AppEvent::NewSession { name } if multi_backend => app.other_new_session_backend(&backends).await .map(|owner| (owner, NewBackendSession::Fresh { name: name.clone() })), diff --git a/codex-rs/tui/src/app/tests/key_chords.rs b/codex-rs/tui/src/app/tests/key_chords.rs index af4af807cd..4e5d322e08 100644 --- a/codex-rs/tui/src/app/tests/key_chords.rs +++ b/codex-rs/tui/src/app/tests/key_chords.rs @@ -79,10 +79,37 @@ async fn empty_thread_backend_chord_preserves_draft_until_first_submission() -> let mut tui = crate::tui::test_support::make_test_tui()?; app.chat_widget .apply_external_edit("first draft".to_string()); - app.chat_widget - .set_new_backend_control(Some("Cloud".to_string())); - let screen = render_bottom_popup(&app.chat_widget, /*width*/ 80); - insta::assert_snapshot!(screen.lines().find(|line| line.trim_start().starts_with("Cloud")).unwrap().trim(), @"Cloud ⌃x b to cycle"); + let host_lines = [ + ("Default", 80), + ("Team Rust", 80), + ("Team Rust — shared development environment", 45), + ] + .map(|(environment, width)| { + app.chat_widget + .set_new_backend_control(Some("Cloud".into()), Some(environment.into())); + render_bottom_popup(&app.chat_widget, width) + .lines() + .map(str::trim) + .find(|line| line.starts_with("Cloud")) + .unwrap() + .to_owned() + }); + insta::assert_snapshot!(host_lines.join("\n"), @" + Cloud ⌃x b cycle - Default ⌃x e change + Cloud ⌃x b cycle - Team Rust ⌃x e change + Cloud ⌃x b cycle - Team Rust… ⌃x e change + "); + + assert_eq!(app.route_key_chord_event(&mut tui, ctrl('x')), None); + let key = app + .route_key_chord_event(&mut tui, KeyCode::Char('e').into()) + .expect("environment chord dispatch"); + app.chat_widget.handle_key_event(key); + assert!( + std::iter::from_fn(|| events.try_recv().ok()) + .any(|event| matches!(event, AppEvent::ChooseCloudEnvironment)) + ); + assert_eq!(app.chat_widget.composer_text_with_pending(), "first draft"); // Cursor movement remains available while the backend selector is visible. let key = app.route_key_chord_event(&mut tui, ctrl('b')).unwrap(); diff --git a/codex-rs/tui/src/app/tests/model_defaults_tests.rs b/codex-rs/tui/src/app/tests/model_defaults_tests.rs index 37a2a8332d..4a68439c40 100644 --- a/codex-rs/tui/src/app/tests/model_defaults_tests.rs +++ b/codex-rs/tui/src/app/tests/model_defaults_tests.rs @@ -745,3 +745,242 @@ async fn model_default_saves_report_server_outcomes_and_target_server_profile() } Ok(()) } + +#[tokio::test] +async fn changing_cloud_environment_carries_staged_settings_to_first_turn() -> Result<()> { + use crate::app::backend_selection::NewBackendSession; + use crate::app::backend_sessions::BackendSessions; + use codex_app_server_protocol::ClientRequest; + + let (mut app, mut events, mut ops) = make_test_app_with_channels().await; + let mut tui = crate::tui::test_support::make_test_tui()?; + tui.pause_events(); + let mut embedded = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?; + let blank = embedded.start_thread(&app.config).await?; + let source = blank.session.thread_id; + let (client, mut commands, _server_events) = + codex_app_server_client::CloudClient::channel(/*capacity*/ 8); + let owner = crate::backend_id::BackendId::new(); + let mut cloud = AppServerSession::new( + owner, + AppServerClient::Cloud(client), + crate::ThreadParamsMode::Cloud, + ); + app.app_server_target = crate::AppServerTarget::Cloud; + app.bind_backend_workspace(&cloud, app.config.cwd.to_path_buf()); + app.agents_overview + .blank_sessions + .insert(source, blank.clone()); + app.enqueue_primary_thread_session(blank.session, blank.turns) + .await?; + app.chat_widget + .apply_external_edit("keep this draft".into()); + let mut model = app.model_catalog.models[0].clone(); + model.model = "model-selected-before-switch".into(); + cloud + .stage_cloud_model_selection(source, &model, Some(ReasoningEffortConfig::High)) + .expect("stage model"); + cloud + .toggle_cloud_service_tier(source, /*current*/ None, "fast".into()) + .expect("stage speed"); + + // Use the embedded server for ordinary bootstrap requests. Observe the native admission + // after the environment start to verify that pending choices moved to the new thread ID. + let proxy = embedded.request_handle(); + let worker = tokio::spawn(async move { + let mut starts = Vec::new(); + while let Some(command) = commands.recv().await { + let request = match command.operation { + CloudOperation::Request(request) => { + if matches!(&*request, ClientRequest::ThreadStart { .. }) { + starts.push(None); + } + *request + } + CloudOperation::StartThreadWithEnvironment { + request_id, + params, + environment: codex_app_server_client::EnvironmentSelection::Saved(id), + } => { + starts.push(Some(id)); + ClientRequest::ThreadStart { + request_id, + params: *params, + } + } + CloudOperation::SubmitUserMessage(params) => { + let turn = test_turn("first-turn", TurnStatus::InProgress, Vec::new()); + let receipt = + serde_json::to_value(CloudUserMessageReceipt::Started(turn)).unwrap(); + command.response.send(Ok(Ok(receipt))).unwrap(); + return (starts, params); + } + _ => panic!("unexpected native operation before the first turn"), + }; + let _ = command.response.send(proxy.request(request).await); + } + panic!("no native submission"); + }); + + let mut backends = BackendSessions::from_initial(cloud, vec![]); + // Start Default without a project so the caller's Git checkout cannot affect routing. + app.backend_preference_context.local_cwd = None; + let default_switch = Box::pin(app.start_new_session_on_other_backend( + &mut tui, + &mut backends, + owner, + NewBackendSession::ChangeCloudEnvironment(None), + )); + tokio::time::timeout(std::time::Duration::from_secs(30), default_switch) + .await? + .expect("switch to Default"); + let saved = codex_app_server_client::SavedEnvironment { + id: "asenvcfg_saved".into(), + name: "Saved".into(), + workspace_shared: false, + }; + let switch = Box::pin(app.start_new_session_on_other_backend( + &mut tui, + &mut backends, + owner, + NewBackendSession::ChangeCloudEnvironment(Some(saved)), + )); + tokio::time::timeout(std::time::Duration::from_secs(30), switch) + .await? + .expect("switch environment"); + let destination = app.chat_widget.thread_id().expect("new Cloud draft"); + assert_ne!(source, destination); + assert!(!app.agents_overview.removed_threads.contains(&source)); + assert_eq!( + app.chat_widget.composer_text_with_pending(), + "keep this draft" + ); + app.chat_widget.handle_key_event(KeyCode::Enter.into()); + let op = std::iter::from_fn(|| events.try_recv().ok()) + .find_map(|event| match event { + AppEvent::CodexOp(op @ Op::UserTurn { .. }) + | AppEvent::SubmitThreadOp { + op: op @ Op::UserTurn { .. }, + .. + } => Some(op), + _ => None, + }) + .unwrap_or_else(|| next_user_turn_op(&mut ops)); + let submit = Box::pin(super::super::user_turn_submission::try_submit_user_turn( + &mut app, + backends.session_at_mut(backends.displayed), + destination, + &op, + )); + assert!(tokio::time::timeout(std::time::Duration::from_secs(5), submit).await??); + let (starts, params) = + tokio::time::timeout(std::time::Duration::from_secs(5), worker).await??; + assert_eq!(starts, vec![None, Some("asenvcfg_saved".to_string())]); + assert_eq!( + ( + params.thread_id, + params.model, + params.effort, + params.service_tier + ), + ( + destination.to_string(), + Some(model.model), + Some(ReasoningEffortConfig::High), + Some(Some("fast".into())) + ) + ); + embedded.shutdown().await?; + Ok(()) +} + +#[tokio::test] +async fn cycling_cloud_draft_through_local_reuses_its_saved_environment() -> Result<()> { + use crate::app::backend_selection::NewBackendSession; + use crate::app::backend_sessions::BackendSessions; + use codex_app_server_client::EnvironmentSelection; + use codex_app_server_protocol::ClientRequest; + + let (mut app, _events, _ops) = make_test_app_with_channels().await; + let mut tui = crate::tui::test_support::make_test_tui()?; + tui.pause_events(); + let mut local = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?; + let local_owner = local.backend_id(); + let local_settings = app.backend_settings(); + let blank = local.start_thread(&app.config).await?; + let proxy = local.request_handle(); + + let (client, mut commands, _server_events) = + codex_app_server_client::CloudClient::channel(/*capacity*/ 8); + let cloud_owner = crate::backend_id::BackendId::new(); + let cloud = AppServerSession::new( + cloud_owner, + AppServerClient::Cloud(client), + crate::ThreadParamsMode::Cloud, + ); + app.app_server_target = crate::AppServerTarget::Cloud; + app.bind_backend_workspace(&cloud, app.config.cwd.to_path_buf()); + app.enqueue_primary_thread_session(blank.session, blank.turns) + .await?; + app.chat_widget.apply_external_edit("carry me".into()); + + let mut backends = BackendSessions::from_initial(cloud, vec![local]); + backends.settings.insert(local_owner, local_settings); + let saved = codex_app_server_client::SavedEnvironment { + id: "asenvcfg_rust".into(), + name: "Rust".into(), + workspace_shared: false, + }; + let (started_tx, mut started_rx) = tokio::sync::mpsc::unbounded_channel(); + let worker = tokio::spawn(async move { + while let Some(command) = commands.recv().await { + let request = match command.operation { + CloudOperation::Request(request) => { + if matches!(&*request, ClientRequest::ThreadStart { .. }) { + started_tx.send(None).unwrap(); + } + *request + } + CloudOperation::StartThreadWithEnvironment { + request_id, + environment: EnvironmentSelection::Saved(id), + params, + } => { + started_tx.send(Some(id)).unwrap(); + ClientRequest::ThreadStart { + request_id, + params: *params, + } + } + CloudOperation::Shutdown => { + command + .response + .send(Ok(Ok(serde_json::Value::Null))) + .unwrap(); + return; + } + _ => panic!("unexpected Cloud operation for this draft"), + }; + let _ = command.response.send(proxy.request(request).await); + } + }); + for (owner, selection) in [ + ( + cloud_owner, + NewBackendSession::ChangeCloudEnvironment(Some(saved.clone())), + ), + (local_owner, NewBackendSession::CarryDraft), + (cloud_owner, NewBackendSession::CarryDraft), + ] { + Box::pin(app.start_new_session_on_other_backend(&mut tui, &mut backends, owner, selection)) + .await + .expect("carry draft"); + assert_eq!(app.chat_widget.composer_text_with_pending(), "carry me"); + if owner == cloud_owner { + assert_eq!(started_rx.try_recv()?, Some(saved.id.clone())); + } + } + backends.shutdown().await?; + worker.await?; + Ok(()) +} diff --git a/codex-rs/tui/src/app/tests/new_session_tests.rs b/codex-rs/tui/src/app/tests/new_session_tests.rs index 516143f258..ad1fcea6a4 100644 --- a/codex-rs/tui/src/app/tests/new_session_tests.rs +++ b/codex-rs/tui/src/app/tests/new_session_tests.rs @@ -1184,6 +1184,19 @@ async fn check_retained_draft_handoff( if retained_blank { app.agents_overview.blank_sessions.insert(thread_id, blank); } + if !saved_history { + app.agents_overview.draft_cloud_environments.insert( + thread_id, + ( + destination_id, + codex_app_server_client::SavedEnvironment { + id: "asenvcfg_rust".into(), + name: "Saved Rust".into(), + workspace_shared: false, + }, + ), + ); + } app.chat_widget .restore_user_message_to_composer("draft for the retained task".into()); let parked_policy = (!saved_history && history_capabilities == HistoryCapabilities::Current) @@ -1304,6 +1317,16 @@ async fn check_retained_draft_handoff( .contains(&destination_id) ); assert_eq!(app.chat_widget.thread_id(), Some(thread_id)); + if !saved_history { + let draft = app.backend_draft().expect("restored blank draft"); + assert_eq!( + app.agents_overview + .draft_cloud_environments + .get(&draft) + .map(|(_, env)| env.name.as_str()), + Some("Saved Rust"), + ); + } if saved_history || parked_policy.is_some() { assert_eq!( app.chat_widget.effective_collaboration_mode(), @@ -1637,7 +1660,7 @@ async fn cloud_switch_wait_keeps_draft_editable_without_submitting_to_local() -> let session = test_thread_session(ThreadId::new(), app.config.cwd.to_path_buf()); app.chat_widget.handle_thread_session(session); app.chat_widget - .set_new_backend_control(Some("Cloud".into())); + .set_new_backend_control(Some("Cloud".into()), /*cloud_environment_name*/ None); app.chat_widget .apply_external_edit("/review first draft".into()); app.keymap @@ -1903,7 +1926,7 @@ async fn cloud_switch_wait_displays_pending_submission_hint() -> Result<()> { let session = test_thread_session(ThreadId::new(), app.config.cwd.to_path_buf()); app.chat_widget.handle_thread_session(session); app.chat_widget - .set_new_backend_control(Some("Cloud".into())); + .set_new_backend_control(Some("Cloud".into()), /*cloud_environment_name*/ None); let mut tui = crate::tui::test_support::make_test_tui()?; { let wait = wait_for_cloud_switch( diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs index 3cf30b0530..140a2d6bd5 100644 --- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs +++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs @@ -327,6 +327,7 @@ async fn cloud_resume_picker_reconciles_admitted_steers() -> Result<()> { use codex_protocol::models::MessagePhase; let (mut app, mut events, mut ops) = make_test_app_with_channels().await; + app.local_settings.tui.show_tooltips = false; let [original, other, failed] = std::array::from_fn(|_| ThreadId::new()); app.app_server_target = AppServerTarget::Cloud; app.enqueue_primary_thread_session( diff --git a/codex-rs/tui/src/app/workspace_hud.rs b/codex-rs/tui/src/app/workspace_hud.rs index 6f1304553d..ccc2bb0b0b 100644 --- a/codex-rs/tui/src/app/workspace_hud.rs +++ b/codex-rs/tui/src/app/workspace_hud.rs @@ -63,6 +63,7 @@ impl App { (1, "Pane right") } "hide_pane" | "focus_pane_left" | "focus_pane_right" => continue, + "choose_cloud_environment" => (2, "Choose environment"), "open_presets" => (2, "Presets ›"), "find_transcript" => (2, "Find text"), "select_transcript" => (2, "Select transcript"), diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index 8a9e20297b..883e95c471 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -701,6 +701,15 @@ pub(crate) enum AppEvent { /// Move an empty conversation to the next connected backend. CycleNewConversationBackend, + /// Show the saved environments for the empty Cloud draft. + ChooseCloudEnvironment, + + /// Move the empty Cloud draft to the selected environment. + StartCloudConversation { + source: ThreadId, + saved_environment: Option, + }, + /// Continue a provider-locked conversation in a fresh chat using its saved history. ContinueProviderChat { thread_id: ThreadId, diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs index 52d8f172d7..b3993428f4 100644 --- a/codex-rs/tui/src/app_server_session.rs +++ b/codex-rs/tui/src/app_server_session.rs @@ -614,10 +614,6 @@ pub(crate) struct UnsupportedLegacyPermissionProfile; /// The environment choice for a new Cloud thread. pub(crate) enum CloudThreadStart<'a> { Project(Option<&'a std::path::Path>), - #[cfg_attr( - not(test), - expect(dead_code, reason = "saved starts are wired by the Cloud picker") - )] Saved(String), } diff --git a/codex-rs/tui/src/app_server_session/user_message_submission.rs b/codex-rs/tui/src/app_server_session/user_message_submission.rs index 0f60909a5e..82c17f938d 100644 --- a/codex-rs/tui/src/app_server_session/user_message_submission.rs +++ b/codex-rs/tui/src/app_server_session/user_message_submission.rs @@ -135,6 +135,13 @@ impl AppServerSession { .then(|| self.cloud_turn_settings.clone()) } + pub(crate) fn move_staged_cloud_settings(&self, from: ThreadId, to: ThreadId) { + let mut pending = self.cloud_turn_settings.lock(); + if let Some(settings) = pending.remove(&from) { + pending.insert(to, settings); + } + } + fn cloud_model_catalog_is_current(&self) -> bool { matches!(&self.request_handle, AppServerRequestHandle::Cloud(handle) if handle.model_catalog_is_current() diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index 06397ae417..1b99b807e6 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -722,6 +722,7 @@ pub(crate) struct ChatWidget { /// Main chat-surface bindings resolved from `tui.keymap.chat`. chat_keymap: ChatKeymap, new_backend_label: Option, + cloud_environment_name: Option, /// Whether the preset submenu owns the next key. quick_dial_menu: bool, /// Ignore a held key after it dismisses the preset submenu. diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rs index 53408357ec..9582de9a9a 100644 --- a/codex-rs/tui/src/chatwidget/constructor.rs +++ b/codex-rs/tui/src/chatwidget/constructor.rs @@ -268,6 +268,7 @@ impl ChatWidget { pending_notification: None, quit_shortcut_expires_at: None, new_backend_label: None, + cloud_environment_name: None, quick_dial_menu: false, quick_dial_menu_key_guard: None, quit_shortcut_key: None, diff --git a/codex-rs/tui/src/chatwidget/interaction.rs b/codex-rs/tui/src/chatwidget/interaction.rs index feda07664d..2308fa0d63 100644 --- a/codex-rs/tui/src/chatwidget/interaction.rs +++ b/codex-rs/tui/src/chatwidget/interaction.rs @@ -83,12 +83,16 @@ impl ChatWidget { } pub(crate) fn keymap_contexts(&self) -> crate::keymap::KeymapContextSet { - let contexts = self.bottom_pane.keymap_contexts(); - if self.visible_new_backend_control().is_some() { - contexts.with_backend_cycling() - } else { - contexts + let mut contexts = self.bottom_pane.keymap_contexts(); + if let Some((cycle, choose_environment)) = self.visible_new_backend_control() { + if cycle.is_some() { + contexts = contexts.with_backend_cycling(); + } + if choose_environment.is_some() { + contexts = contexts.with_cloud_environment_selection(); + } } + contexts } pub(crate) fn take_key_chord_reset(&mut self) -> bool { @@ -122,9 +126,15 @@ impl ChatWidget { self.handle_key_event_with_activation_key(key_event, /*activation_key*/ None) } - pub(crate) fn set_new_backend_control(&mut self, label: Option) { - if self.new_backend_label != label { + pub(crate) fn set_new_backend_control( + &mut self, + label: Option, + cloud_environment_name: Option, + ) { + if self.new_backend_label != label || self.cloud_environment_name != cloud_environment_name + { self.new_backend_label = label; + self.cloud_environment_name = cloud_environment_name; self.request_redraw(); } } @@ -138,9 +148,11 @@ impl ChatWidget { && self.initial_user_message.is_none() } - pub(super) fn visible_new_backend_control(&self) -> Option<&str> { - let label = self.new_backend_label.as_deref()?; - (self.can_choose_new_backend() + pub(super) fn visible_new_backend_control(&self) -> Option<(Option<&str>, Option<&str>)> { + let cycle = self.new_backend_label.as_deref(); + let environment = self.cloud_environment_name.as_deref(); + ((cycle.is_some() || environment.is_some()) + && self.can_choose_new_backend() && self.bottom_pane.no_modal_or_popup_active() && !self.fork_in_progress && !self.shortcut_overlay_visible() @@ -148,7 +160,7 @@ impl ChatWidget { && self.safety_recourse.is_none() && !self.has_provider_error() && matches!(self.external_editor_state, ExternalEditorState::Closed)) - .then_some(label) + .then_some((cycle, environment)) } pub(crate) fn handle_key_event_with_activation_key( @@ -194,12 +206,18 @@ impl ChatWidget { } let keymap = self.bottom_pane.keymap(); - if keymap.app.change_host.is_pressed(key_event) - && self.visible_new_backend_control().is_some() - { - self.app_event_tx - .send(AppEvent::CycleNewConversationBackend); - return KeyEventAction::None; + if let Some((cycle, choose_environment)) = self.visible_new_backend_control() { + if cycle.is_some() && keymap.app.change_host.is_pressed(key_event) { + self.app_event_tx + .send(AppEvent::CycleNewConversationBackend); + return KeyEventAction::None; + } + if choose_environment.is_some() + && keymap.app.choose_cloud_environment.is_pressed(key_event) + { + self.app_event_tx.send(AppEvent::ChooseCloudEnvironment); + return KeyEventAction::None; + } } if self.shortcut_overlay_visible() && key_hint::plain(KeyCode::Esc).is_press(key_event) { diff --git a/codex-rs/tui/src/chatwidget/rendering.rs b/codex-rs/tui/src/chatwidget/rendering.rs index 9611f6aeed..1de4bea05d 100644 --- a/codex-rs/tui/src/chatwidget/rendering.rs +++ b/codex-rs/tui/src/chatwidget/rendering.rs @@ -5,6 +5,8 @@ use super::transcript::ActiveCellLayoutCache; use super::transcript::ActiveCellLayoutCacheKey; use super::*; use crate::keymap::KeymapContext; +use crate::line_truncation::span_width; +use crate::line_truncation::truncate_line_with_ellipsis_if_overflow; use crate::render::RectExt; use crate::terminal_hyperlinks::HyperlinkParagraph; use crate::wrapping::RtOptions; @@ -14,6 +16,27 @@ use ratatui::text::Span; use ratatui::widgets::Block; use std::cell::Cell; +struct NewBackendControl<'a>(Line<'a>, Option<(usize, String)>); + +impl Renderable for NewBackendControl<'_> { + fn render(&self, area: Rect, buf: &mut Buffer) { + let mut line = self.0.clone(); + if let Some((index, environment)) = &self.1 { + let reserved: usize = line.iter().map(span_width).sum(); + let environment = truncate_line_with_ellipsis_if_overflow( + Line::from(environment.clone()), + usize::from(area.width).saturating_sub(reserved), + ); + line.spans.splice(*index..*index, environment.spans); + } + Widget::render(line, area, buf); + } + + fn desired_height(&self, _width: u16) -> u16 { + 1 + } +} + struct ReadOnlyThreadNotice { reason: ReadOnlyThread, agents_navigation_key_available: bool, @@ -298,13 +321,25 @@ impl ChatWidget { let bottom_pane = self.bottom_pane.backdrop_with_options(options); let above_composer = if self.quick_dial_menu && !options.floating_shortcuts { RenderableItem::Owned(Box::new(self.quick_dial_hud())) - } else if let Some(backend) = self.visible_new_backend_control() { - let mut spans = vec![" ".into(), backend.into()]; + } else if let Some((cycle, environment)) = self.visible_new_backend_control() { + let mut spans = vec![" ".into(), cycle.unwrap_or("Cloud").into()]; let keymap = self.bottom_pane.keymap(); - if let Some(key) = keymap.primary_hint(KeymapContext::Global, "change_host") { - spans.extend([" ".into(), key.into(), " to cycle".dim()]); + if cycle.is_some() + && let Some(key) = keymap.primary_hint(KeymapContext::Global, "change_host") + { + spans.extend([" ".into(), key.into(), " cycle".dim()]); } - RenderableItem::Owned(Box::new(Paragraph::new(Line::from(spans)))) + let environment = environment.map(|name| { + spans.push(" - ".dim()); + let index = spans.len(); + if let Some(key) = + keymap.primary_hint(KeymapContext::Global, "choose_cloud_environment") + { + spans.extend([" ".into(), key.into(), " change".dim()]); + } + (index, name.to_owned()) + }); + RenderableItem::Owned(Box::new(NewBackendControl(Line::from(spans), environment))) } else { return bottom_pane; }; diff --git a/codex-rs/tui/src/keymap.rs b/codex-rs/tui/src/keymap.rs index c377c79924..72929a28ae 100644 --- a/codex-rs/tui/src/keymap.rs +++ b/codex-rs/tui/src/keymap.rs @@ -105,6 +105,7 @@ pub(crate) struct RuntimeKeymap { pub(crate) struct AppKeymap { /// Change where a new conversation runs. pub(crate) change_host: Vec, + pub(crate) choose_cloud_environment: Vec, pub(crate) focus_main_composer: Vec, pub(crate) focus_sidebar_content: Vec, pub(crate) focus_sidebar_tabs: Vec, @@ -775,6 +776,11 @@ impl RuntimeKeymap { &defaults.app.change_host, "tui.keymap.global.change_host", )?, + choose_cloud_environment: resolve_bindings( + keymap.global.choose_cloud_environment.as_ref(), + &defaults.app.choose_cloud_environment, + "tui.keymap.global.choose_cloud_environment", + )?, focus_main_composer: resolve_bindings( keymap.global.focus_main_composer.as_ref(), &[], @@ -1882,6 +1888,7 @@ impl RuntimeKeymap { Self { app: AppKeymap { change_host: Vec::new(), + choose_cloud_environment: Vec::new(), focus_main_composer: Vec::new(), focus_sidebar_content: Vec::new(), focus_sidebar_tabs: Vec::new(), @@ -2228,6 +2235,10 @@ impl RuntimeKeymap { fn validate_conflicts(&self) -> Result<(), String> { for (action, bindings) in [ ("global.change_host", &self.app.change_host), + ( + "global.choose_cloud_environment", + &self.app.choose_cloud_environment, + ), ("chat.open_presets", &self.chat.open_presets), ("chat.toggle_voice", &self.chat.toggle_voice), ("composer.undo", &self.composer.undo), @@ -2257,6 +2268,10 @@ impl RuntimeKeymap { #[cfg(unix)] for (action, bindings) in [ ("global.change_host", &self.app.change_host), + ( + "global.choose_cloud_environment", + &self.app.choose_cloud_environment, + ), ("global.open_agents", &self.app.open_agents), ("global.focus_main_composer", &self.app.focus_main_composer), ( @@ -2310,6 +2325,10 @@ impl RuntimeKeymap { let divider_right = self.app.move_divider_right.as_slice(); let main_bindings = [ ("change_host", self.app.change_host.as_slice()), + ( + "choose_cloud_environment", + self.app.choose_cloud_environment.as_slice(), + ), ( "focus_main_composer", self.app.focus_main_composer.as_slice(), diff --git a/codex-rs/tui/src/keymap/bindings.rs b/codex-rs/tui/src/keymap/bindings.rs index 2d2293c286..97639e3111 100644 --- a/codex-rs/tui/src/keymap/bindings.rs +++ b/codex-rs/tui/src/keymap/bindings.rs @@ -321,6 +321,7 @@ macro_rules! define_runtime_action_bindings { define_runtime_action_bindings! { "global" => Global, app, global [ change_host, + choose_cloud_environment, open_agents, open_transcript, find_transcript, diff --git a/codex-rs/tui/src/keymap/chords.rs b/codex-rs/tui/src/keymap/chords.rs index 6f050de236..55651f34d3 100644 --- a/codex-rs/tui/src/keymap/chords.rs +++ b/codex-rs/tui/src/keymap/chords.rs @@ -45,28 +45,29 @@ const LIST_RESERVED_BINDINGS: &[(&str, KeyBinding)] = &[ /// Compact set of keymap contexts that share one active input path. #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] -pub(crate) struct KeymapContextSet(u32); +pub(crate) struct KeymapContextSet(u64); -const ACTIVITY_FOCUS: u32 = 1 << 13; -const TRANSCRIPT_CLOSE: u32 = 1 << 15; -const WARNINGS_FOCUS: u32 = 1 << 16; -const VOICE_TOGGLE: u32 = 1 << 17; -const RAW_KEY_CAPTURE: u32 = 1 << 18; -const VOICE_TOGGLE_BLOCKED: u32 = 1 << 19; -const TRANSCRIPT_ACTIONS: u32 = 1 << 20; -const BACKEND_CYCLING: u32 = 1 << 21; -const SIDE_PANE: u32 = 1 << 22; -const MAIN_COMPOSER_FOCUS: u32 = 1 << 23; -const PANE_DIRECTION: u32 = 1 << 24; -const OPEN_PANE: u32 = 1 << 25; -const FOCUSED_SIDE_PANE: u32 = 1 << 26; -const SIDEBAR_CHOOSER: u32 = 1 << 27; -const SIDEBAR_RESIZE: u32 = 1 << 28; -const FOCUSED_SIDEBAR: u32 = 1 << 29; -const TRANSCRIPT_SELECT: u32 = 1 << 30; -const COMPOSER_EDIT_ONLY: u32 = 1 << 31; +const ACTIVITY_FOCUS: u64 = 1 << 13; +const TRANSCRIPT_CLOSE: u64 = 1 << 15; +const WARNINGS_FOCUS: u64 = 1 << 16; +const VOICE_TOGGLE: u64 = 1 << 17; +const RAW_KEY_CAPTURE: u64 = 1 << 18; +const VOICE_TOGGLE_BLOCKED: u64 = 1 << 19; +const TRANSCRIPT_ACTIONS: u64 = 1 << 20; +const BACKEND_CYCLING: u64 = 1 << 21; +const SIDE_PANE: u64 = 1 << 22; +const MAIN_COMPOSER_FOCUS: u64 = 1 << 23; +const PANE_DIRECTION: u64 = 1 << 24; +const OPEN_PANE: u64 = 1 << 25; +const FOCUSED_SIDE_PANE: u64 = 1 << 26; +const SIDEBAR_CHOOSER: u64 = 1 << 27; +const SIDEBAR_RESIZE: u64 = 1 << 28; +const FOCUSED_SIDEBAR: u64 = 1 << 29; +const TRANSCRIPT_SELECT: u64 = 1 << 30; +const COMPOSER_EDIT_ONLY: u64 = 1 << 31; +const CLOUD_ENVIRONMENT_SELECTION: u64 = 1 << 32; -const TRANSCRIPT_BROWSING: u32 = 1 << 14; +const TRANSCRIPT_BROWSING: u64 = 1 << 14; impl KeymapContextSet { pub(crate) const fn composer_edit_only() -> Self { @@ -92,6 +93,10 @@ impl KeymapContextSet { Self(self.0 | BACKEND_CYCLING) } + pub(crate) const fn with_cloud_environment_selection(self) -> Self { + Self(self.0 | CLOUD_ENVIRONMENT_SELECTION) + } + /// Add only the detail-close action to an owned composer path. pub(crate) const fn with_transcript_close(self) -> Self { Self(self.0 | context_bit(KeymapContext::Pager) | TRANSCRIPT_CLOSE) @@ -230,8 +235,12 @@ impl KeymapContextSet { if action.context == KeymapContext::Pager && action.action == "mark_markdown" { return self.0 & TRANSCRIPT_SELECT != 0; } - if action.context == KeymapContext::Global && action.action == "change_host" { - return self.0 & BACKEND_CYCLING != 0; + if action.context == KeymapContext::Global { + match action.action { + "change_host" => return self.0 & BACKEND_CYCLING != 0, + "choose_cloud_environment" => return self.0 & CLOUD_ENVIRONMENT_SELECTION != 0, + _ => {} + } } if action.is_side_pane() { let required = match action.action { @@ -291,7 +300,7 @@ impl KeymapContextSet { } } -const fn context_bit(context: KeymapContext) -> u32 { +const fn context_bit(context: KeymapContext) -> u64 { 1 << match context { KeymapContext::Global => 0, KeymapContext::Chat => 1, diff --git a/codex-rs/tui/src/keymap/chords/leader_defaults.rs b/codex-rs/tui/src/keymap/chords/leader_defaults.rs index f3d10e72d1..5595077319 100644 --- a/codex-rs/tui/src/keymap/chords/leader_defaults.rs +++ b/codex-rs/tui/src/keymap/chords/leader_defaults.rs @@ -57,6 +57,7 @@ pub(in crate::keymap) fn register( (Global, "sidebar_down", KeyCode::Down, "down"), (Global, "sidebar_down", Char('j'), "j"), (Pager, "mark_markdown", Char('v'), "v"), + (Global, "choose_cloud_environment", Char('e'), "e"), ] { if remaining == 0 { break; diff --git a/codex-rs/tui/src/keymap/chords_tests.rs b/codex-rs/tui/src/keymap/chords_tests.rs index 556af0089d..55a7b1270d 100644 --- a/codex-rs/tui/src/keymap/chords_tests.rs +++ b/codex-rs/tui/src/keymap/chords_tests.rs @@ -636,6 +636,20 @@ fn warning_context_keeps_local_chords_ahead_of_copy_and_hides_unreachable_hints( assert!(!runtime.app.copy.is_pressed(event)); } +#[test] +fn cloud_picker_preserves_composer_undo_and_stays_hidden_in_edit_only_popups() { + let picker = keymap_action_id("global", "choose_cloud_environment").unwrap(); + let undo = keymap_action_id("composer", "undo").unwrap(); + let editor = KeymapContextSet::new(KeymapContext::Editor).with(KeymapContext::Composer); + + assert!( + editor + .with_cloud_environment_selection() + .contains_action(undo) + ); + assert!(!KeymapContextSet::composer_edit_only().contains_action(picker)); +} + #[test] fn composer_undo_defaults_yield_without_shadowing_vim_redo() { let mut config = TuiKeymap::default();