mirror of
https://github.com/openai/codex.git
synced 2026-11-21 22:50:37 +00:00
Dock the Agent Command Center beside the conversation (#62986)
## Why Opening the Agent Command Center in a modal interrupts the conversation view. Docking it keeps the transcript and draft visible while browsing tasks when the terminal has room for both panes. ## What changed With `features.tui_workspace` enabled in owned transcript mode, the Command Center opens to the left of the conversation on wide terminals. On narrow terminals, the focused pane fills the screen. Opening a task returns focus to the conversation and keeps the dock open. Other transcript modes continue to use the modal Command Center. ## Testing Add coverage for draft and reading-position preservation, wide and narrow layouts, queued results arriving after a focus change, and selecting a new session when its task appears in the dock. GitOrigin-RevId: d07c9cad3bb8685167b5995e550c406948d7a6e3
This commit is contained in:
+36
-17
@@ -28,6 +28,7 @@ use crate::app_server_session::app_server_rate_limit_snapshots;
|
||||
use crate::bottom_pane::AppLinkViewParams;
|
||||
use crate::bottom_pane::ApplyPatchApprovalRequest;
|
||||
use crate::bottom_pane::ApprovalRequest;
|
||||
use crate::bottom_pane::BottomPaneView;
|
||||
use crate::bottom_pane::ExecApprovalRequest;
|
||||
use crate::bottom_pane::FeedbackAudience;
|
||||
use crate::bottom_pane::McpElicitationApprovalRequest;
|
||||
@@ -230,6 +231,7 @@ mod composer_hints;
|
||||
mod config_panel;
|
||||
mod config_persistence;
|
||||
mod connector_mentions;
|
||||
mod conversation_workspace;
|
||||
mod daemon_menu;
|
||||
mod daybreak;
|
||||
mod empty_state_policy;
|
||||
@@ -1001,6 +1003,36 @@ impl App {
|
||||
{
|
||||
return Ok(AppRunControl::Continue);
|
||||
}
|
||||
if self.workspace_center_owns_input() {
|
||||
match &event {
|
||||
TuiEvent::Key(key) => {
|
||||
self.handle_workspace_key(tui, *key);
|
||||
if !self.agents_overview.workspace.is_open() {
|
||||
self.cancel_cloud_inventory_refresh(app_server).await;
|
||||
if self.reconnect.presentation == reconnect::ReconnectPresentation::Overview
|
||||
{
|
||||
self.reconnect.presentation =
|
||||
reconnect::ReconnectPresentation::Conversation;
|
||||
}
|
||||
}
|
||||
return Ok(AppRunControl::Continue);
|
||||
}
|
||||
TuiEvent::Paste(text) if !composer_paste => {
|
||||
self.cancel_pending_key_chord();
|
||||
if let Some(view) = &mut self.agents_overview.workspace.view {
|
||||
view.handle_paste(text.clone());
|
||||
}
|
||||
tui.frame_requester().schedule_frame();
|
||||
return Ok(AppRunControl::Continue);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if let TuiEvent::Mouse(mouse) = &event
|
||||
&& self.handle_workspace_mouse(tui, *mouse)
|
||||
{
|
||||
return Ok(AppRunControl::Continue);
|
||||
}
|
||||
if matches!(&event, TuiEvent::Key(_))
|
||||
&& self.handle_composer_copy_event(tui, &event, |tui, text| {
|
||||
tui.copy_transcript_selection(text, crate::clipboard_copy::CopyFormat::PlainText)
|
||||
@@ -1153,7 +1185,7 @@ impl App {
|
||||
if let Some(current) = side_pane::layout(self, tui, size.into())
|
||||
&& current.passive_thread == painted.passive_thread
|
||||
&& let Some(peer) = self.current_displayed_thread_id()
|
||||
&& painted.passive.union(painted.focused) == Rect::from(size)
|
||||
&& painted.passive.union(painted.focused) == self.workspace_chat_area(size.into())
|
||||
{
|
||||
let painted_area = painted.passive;
|
||||
if let Some(link) = self.transcript_link_at(*press) {
|
||||
@@ -1203,20 +1235,10 @@ impl App {
|
||||
return Ok(AppRunControl::Continue);
|
||||
}
|
||||
self.cancel_primed_browsing_for_event(&event);
|
||||
let voice_toggle = |app: &Self, key: KeyEvent| {
|
||||
key.kind == KeyEventKind::Press
|
||||
&& app
|
||||
.active_keymap_contexts()
|
||||
.contains_action(crate::keymap::KeymapActionId {
|
||||
context: crate::keymap::KeymapContext::Chat,
|
||||
action: "toggle_voice",
|
||||
})
|
||||
&& app.keymap.chat.toggle_voice.is_pressed(key)
|
||||
};
|
||||
// Transcript interactions consume otherwise-unhandled keys; let enabled voice controls
|
||||
// reach App.
|
||||
if !matches!(&event, TuiEvent::Key(key)
|
||||
if voice_toggle(self, *key)
|
||||
if self.voice_toggle_pressed(*key)
|
||||
&& (!self.transcript_view.owns_interaction_key(*key)
|
||||
|| self.transcript_view.is_select_mode()))
|
||||
&& !composer_paste
|
||||
@@ -1247,12 +1269,8 @@ impl App {
|
||||
}
|
||||
}
|
||||
if let TuiEvent::Key(key_event) = &event
|
||||
&& voice_toggle(self, *key_event)
|
||||
&& self.handle_voice_toggle_key(tui, *key_event)
|
||||
{
|
||||
self.cancel_transcript_browsing(tui);
|
||||
if !self.chat_widget.handle_startup_submission_key(*key_event) {
|
||||
self.control_voice(crate::app_event::VoiceControl::Toggle);
|
||||
}
|
||||
return Ok(AppRunControl::Continue);
|
||||
}
|
||||
if let TuiEvent::Key(key_event) = &event
|
||||
@@ -1439,6 +1457,7 @@ impl App {
|
||||
let visible = self.current_displayed_thread_id().filter(|&id| {
|
||||
tui.is_terminal_focused()
|
||||
&& !self.conversation_frame.panel_covers_transcript()
|
||||
&& !self.conversation_area(screen_size.into()).is_empty()
|
||||
&& matches!(self.overlay, None | Some(Overlay::Transcript(_)))
|
||||
&& self.chat_widget.no_modal_or_popup_active()
|
||||
&& self.initial_history_replay_buffer.is_none()
|
||||
|
||||
@@ -177,12 +177,17 @@ impl Renderable for AgentsOverviewView {
|
||||
);
|
||||
tabs.width = tabs.width.saturating_sub(hint_width + 2);
|
||||
}
|
||||
render_filled_tab_bar(
|
||||
let targets = render_filled_tab_bar(
|
||||
&labels.iter().map(String::as_str).collect::<Vec<_>>(),
|
||||
state.status_filter,
|
||||
tabs,
|
||||
buf,
|
||||
);
|
||||
if self.dock_focused == Some(false)
|
||||
&& let Some((_, tab)) = targets.iter().find(|(id, _)| *id == state.status_filter)
|
||||
{
|
||||
buf.set_style(*tab, crate::style::quiet_workspace_style());
|
||||
}
|
||||
line(
|
||||
"─"
|
||||
.repeat(usize::from(area.width.saturating_sub(/*rhs*/ 4)))
|
||||
|
||||
@@ -67,6 +67,11 @@ impl AgentsOverviewView {
|
||||
);
|
||||
return;
|
||||
}
|
||||
let selected_style = if self.dock_focused == Some(false) {
|
||||
crate::style::quiet_workspace_style()
|
||||
} else {
|
||||
selection_style()
|
||||
};
|
||||
let entries = self.center_rows(&indices, state.grouping);
|
||||
let selected = entries
|
||||
.iter()
|
||||
@@ -112,7 +117,7 @@ impl AgentsOverviewView {
|
||||
let rect = row(viewport, offset as u16, /*height*/ 1);
|
||||
let selected = self.selected == usize::MAX;
|
||||
let style = if selected {
|
||||
selection_style()
|
||||
selected_style
|
||||
} else {
|
||||
Style::default()
|
||||
};
|
||||
@@ -196,7 +201,7 @@ impl AgentsOverviewView {
|
||||
continue;
|
||||
}
|
||||
let style = if index == self.selected {
|
||||
selection_style()
|
||||
selected_style
|
||||
} else {
|
||||
Style::default()
|
||||
};
|
||||
|
||||
@@ -1007,3 +1007,231 @@ async fn live_center_show_more_navigation_search_and_loading() {
|
||||
);
|
||||
insta::assert_snapshot!(screen(&view, /*width*/ 80, /*height*/ 12).lines().nth(6).unwrap(), @" › Show more matches");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn workspace_navigation_preserves_the_draft_and_reading_position() -> Result<()> {
|
||||
use crate::app::owned_transcript::tests::attach_thread;
|
||||
use crate::app::owned_transcript::tests::buffer_text;
|
||||
|
||||
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
|
||||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||||
app.local_settings.tui.animations = false;
|
||||
let wide = Size::new(/*width*/ 90, /*height*/ 14);
|
||||
let mut tui = crate::tui::test_support::make_test_tui_with_size(wide)?;
|
||||
tui.set_owned_screen(/*owned*/ true)?;
|
||||
app.config.features.enable(Feature::TuiWorkspace)?;
|
||||
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
|
||||
let id = ThreadId::from_u128(/*value*/ 12);
|
||||
attach_thread(&mut app, id);
|
||||
let mut title = "Investigate retry";
|
||||
let mut task = overview_thread(
|
||||
id,
|
||||
/*parent_thread_id*/ None,
|
||||
title,
|
||||
ThreadStatus::Idle,
|
||||
);
|
||||
task.git_info = Some(codex_app_server_protocol::GitInfo {
|
||||
branch: Some("retry-fix".into()),
|
||||
sha: None,
|
||||
origin_url: None,
|
||||
});
|
||||
task.updated_at = 4_000_000_000;
|
||||
app.agents_overview.threads.insert(id, Some(task));
|
||||
app.agents_overview
|
||||
.pins_by_backend
|
||||
.insert(server.backend_id(), Some(vec![id]));
|
||||
let rows = (0..40)
|
||||
.map(|i| format!("Response row {i}").into())
|
||||
.collect();
|
||||
app.transcript_cells
|
||||
.push(Arc::new(history_cell::PlainHistoryCell::new(rows)));
|
||||
let paste = TuiEvent::Paste("Keep this draft".into());
|
||||
app.handle_tui_event(&mut tui, &mut server, paste).await?;
|
||||
|
||||
app.render_chat_widget_frame(&mut tui, wide)?;
|
||||
app.transcript_view
|
||||
.scroll(&app.transcript_cells, /*rows*/ -10);
|
||||
app.render_chat_widget_frame(&mut tui, wide)?;
|
||||
let before = buffer_text(tui.terminal.previous_buffer());
|
||||
let first = before.lines().next().unwrap().trim();
|
||||
assert!(first.starts_with("Response row"));
|
||||
assert_eq!(
|
||||
app.chat_widget.composer_text_with_pending(),
|
||||
"Keep this draft"
|
||||
);
|
||||
|
||||
let narrow = Size::new(50, 14);
|
||||
let mut screens = Vec::new();
|
||||
let mut wide_styles = Vec::new();
|
||||
for (label, size, center_focused) in [
|
||||
("Wide Command Center", wide, true),
|
||||
("Wide conversation", wide, false),
|
||||
("Narrow conversation", narrow, false),
|
||||
("Narrow Command Center", narrow, true),
|
||||
("Restored dock", wide, true),
|
||||
] {
|
||||
tui.terminal.resize(size)?;
|
||||
if center_focused && !app.workspace_center_owns_input() {
|
||||
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::OpenAgentsOverview)).await?;
|
||||
} else if !center_focused && app.workspace_center_owns_input() {
|
||||
let click = crossterm::event::MouseEvent {
|
||||
kind: crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Left),
|
||||
column: wide.width - 1,
|
||||
row: 0,
|
||||
modifiers: KeyModifiers::NONE,
|
||||
};
|
||||
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Mouse(click))
|
||||
.await?;
|
||||
}
|
||||
if size == wide && !center_focused {
|
||||
title = "Investigate retry again";
|
||||
let renamed = ServerNotification::ThreadNameUpdated(ThreadNameUpdatedNotification {
|
||||
thread_id: id.to_string(),
|
||||
thread_name: Some(title.into()),
|
||||
});
|
||||
app.handle_app_server_event(
|
||||
&server,
|
||||
AppServerEvent::ServerNotification(Box::new(renamed)),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
tui.screen_size_for_event(&TuiEvent::Resize(size))?;
|
||||
crate::terminal_palette::with_test_default_colors(
|
||||
crate::terminal_probe::DefaultColors {
|
||||
fg: (230, 230, 230),
|
||||
bg: (20, 20, 20),
|
||||
},
|
||||
|| app.render_chat_widget_frame(&mut tui, size),
|
||||
)?;
|
||||
let buffer = tui.terminal.previous_buffer();
|
||||
let screen = buffer_text(buffer);
|
||||
assert_eq!(app.workspace_center_owns_input(), center_focused, "{label}");
|
||||
if size == wide && wide_styles.len() < 2 {
|
||||
wide_styles.push([title, "All 1", "Keep this draft"].map(|text| {
|
||||
let (row, prefix) = screen
|
||||
.lines()
|
||||
.enumerate()
|
||||
.find_map(|(row, line)| Some((row, line.split_once(text)?.0)))
|
||||
.expect("visible task, filter and draft");
|
||||
buffer[(prefix.chars().count() as u16, row as u16)].style()
|
||||
}));
|
||||
}
|
||||
if matches!(label, "Wide Command Center" | "Narrow Command Center") {
|
||||
let screen = normalize_agent_center_snapshot(screen);
|
||||
screens.push(format!("{label}\n{screen}"));
|
||||
}
|
||||
}
|
||||
let [center, conversation] = wide_styles.as_slice() else {
|
||||
panic!("expected both wide focus states");
|
||||
};
|
||||
for (center_style, conversation_style) in center.iter().zip(conversation) {
|
||||
assert_ne!(center_style, conversation_style);
|
||||
}
|
||||
assert_ne!(center[2].fg, conversation[2].fg);
|
||||
assert_ne!(center[2].bg, conversation[2].bg);
|
||||
|
||||
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Tab.into()))
|
||||
.await?;
|
||||
app.render_chat_widget_frame(&mut tui, wide)?;
|
||||
assert!(buffer_text(tui.terminal.previous_buffer()).contains("No matching tasks"));
|
||||
insta::assert_snapshot!("workspace_responsive_focus", screens.join("\n\n"));
|
||||
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Paste("ignored".into()))
|
||||
.await?;
|
||||
for key in [KeyCode::BackTab, KeyCode::Enter] {
|
||||
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key.into()))
|
||||
.await?;
|
||||
}
|
||||
let selected = std::iter::from_fn(|| events.try_recv().ok())
|
||||
.find(|event| {
|
||||
matches!(event, AppEvent::SelectAgentsOverviewThread { thread_id } if *thread_id == id)
|
||||
})
|
||||
.expect("Enter selects the displayed task");
|
||||
Box::pin(app.handle_event(&mut tui, &mut server, selected)).await?;
|
||||
let bottom = app.render_chat_widget_frame(&mut tui, wide)?;
|
||||
let screen = buffer_text(tui.terminal.previous_buffer());
|
||||
assert!(screen.contains(title));
|
||||
assert!(screen.lines().next().unwrap().ends_with(first));
|
||||
assert!(bottom.contains(tui.terminal.last_known_cursor_pos));
|
||||
assert_eq!(
|
||||
app.chat_widget.composer_text_with_pending(),
|
||||
"Keep this draft"
|
||||
);
|
||||
|
||||
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::OpenAgentsOverview)).await?;
|
||||
app.sidebar_mut().show(
|
||||
crate::app::sidebar::SidebarContent::Chooser,
|
||||
crate::app::sidebar::PaneFocus::Sidebar,
|
||||
);
|
||||
let three_panes = Size::new(185, 18);
|
||||
let combined = crate::app::test_support::side_frame(&mut app, &mut tui, three_panes)?;
|
||||
let center = app.conversation_frame.command_center.unwrap();
|
||||
let side = app.conversation_frame.panel_area().unwrap();
|
||||
let middle = app.conversation_area(Rect::new(0, 0, 185, 18));
|
||||
assert!(center.right() <= middle.x && middle.right() <= side.x && !middle.is_empty());
|
||||
let labels = ["Agent command center", "Keep this draft", "Open in sidebar"].map(|label| {
|
||||
combined
|
||||
.lines()
|
||||
.find_map(|line| line.find(label))
|
||||
.map(|_| label)
|
||||
});
|
||||
insta::assert_snapshot!(format!("{labels:?}"),@"[Some(\"Agent command center\"), Some(\"Keep this draft\"), Some(\"Open in sidebar\")]");
|
||||
let divider = app
|
||||
.conversation_frame
|
||||
.divider_area()
|
||||
.expect("right divider");
|
||||
let mouse = |kind, column| {
|
||||
TuiEvent::Mouse(crossterm::event::MouseEvent {
|
||||
kind,
|
||||
column,
|
||||
row: divider.y,
|
||||
modifiers: KeyModifiers::NONE,
|
||||
})
|
||||
};
|
||||
use crossterm::event::MouseButton::Left;
|
||||
use crossterm::event::MouseEventKind::Down;
|
||||
use crossterm::event::MouseEventKind::Drag;
|
||||
tui.screen_size_for_event(&TuiEvent::Resize(three_panes))?;
|
||||
app.handle_tui_event(&mut tui, &mut server, mouse(Down(Left), divider.x))
|
||||
.await?;
|
||||
app.handle_tui_event(&mut tui, &mut server, mouse(Drag(Left), divider.x - 6))
|
||||
.await?;
|
||||
crate::app::test_support::side_frame(&mut app, &mut tui, three_panes)?;
|
||||
let preview = app
|
||||
.conversation_frame
|
||||
.divider_area()
|
||||
.expect("right divider");
|
||||
assert_eq!(preview.x, divider.x - 6);
|
||||
|
||||
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Enter.into()))
|
||||
.await?;
|
||||
let selected = std::iter::from_fn(|| events.try_recv().ok())
|
||||
.find(|event| {
|
||||
matches!(event, AppEvent::SelectAgentsOverviewThread { thread_id } if *thread_id == id)
|
||||
})
|
||||
.expect("Enter selects the displayed task with the chooser open");
|
||||
Box::pin(app.handle_event(&mut tui, &mut server, selected)).await?;
|
||||
assert_eq!(
|
||||
app.panel_focus(),
|
||||
Some(crate::app::sidebar::PaneFocus::Main)
|
||||
);
|
||||
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Paste("!".into()))
|
||||
.await?;
|
||||
assert!(app.chat_widget.composer_text_with_pending().contains('!'));
|
||||
app.handle_tui_event(
|
||||
&mut tui,
|
||||
&mut server,
|
||||
TuiEvent::Key(KeyCode::Backspace.into()),
|
||||
)
|
||||
.await?;
|
||||
|
||||
app.open_agents_overview(&server);
|
||||
app.sidebar_mut().hide();
|
||||
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))
|
||||
.await?;
|
||||
tui.screen_size_for_event(&TuiEvent::Resize(wide))?;
|
||||
app.render_chat_widget_frame(&mut tui, wide)?;
|
||||
assert_eq!(buffer_text(tui.terminal.previous_buffer()), before);
|
||||
|
||||
server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -41,6 +41,7 @@ pub(crate) const AGENTS_OVERVIEW_VIEW_ID: &str = "agents-overview";
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct AgentsOverviewState {
|
||||
pub(super) workspace: super::conversation_workspace::Workspace,
|
||||
/// Missing metadata records a local resume until the next metadata refresh.
|
||||
pub(super) threads: HashMap<ThreadId, Option<Thread>>,
|
||||
/// Identifies the query that populated the cached search results.
|
||||
@@ -137,18 +138,43 @@ impl Drop for AgentsOverviewState {
|
||||
}
|
||||
|
||||
impl App {
|
||||
/// Read the selected row from its host, even while a dialog has focus.
|
||||
pub(super) fn overview_selected_index(&self) -> Option<usize> {
|
||||
let workspace = &self.agents_overview.workspace;
|
||||
if workspace.is_open() {
|
||||
return workspace.selected_index();
|
||||
}
|
||||
self.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
}
|
||||
|
||||
pub(super) fn overview_selected_thread_id(&self) -> Option<ThreadId> {
|
||||
let index = self.overview_selected_index()?;
|
||||
self.agents_overview.visible_thread_ids.get(index).copied()
|
||||
}
|
||||
|
||||
pub(super) fn agents_overview_has_focus(&self) -> bool {
|
||||
self.workspace_center_owns_input()
|
||||
|| self.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID)
|
||||
}
|
||||
|
||||
pub(super) fn open_agents_overview(&mut self, app_server: &AppServerSession) {
|
||||
let threads = self
|
||||
.agents_overview
|
||||
.threads
|
||||
.values()
|
||||
.flatten()
|
||||
.cloned()
|
||||
.collect();
|
||||
let selected_thread_id = self.agents_overview.selection_after_removal.take();
|
||||
let dock = self.local_settings.workspace_enabled(&self.config);
|
||||
let overview = &mut self.agents_overview;
|
||||
let threads = overview.threads.values().flatten().cloned().collect();
|
||||
let selected_thread_id = overview.selection_after_removal.take().or_else(|| {
|
||||
let index = overview.workspace.selected_index()?;
|
||||
overview.visible_thread_ids.get(index).copied()
|
||||
});
|
||||
let view = self.agents_overview_view(threads, selected_thread_id);
|
||||
self.agents_overview.visible_thread_ids = view.thread_ids();
|
||||
self.chat_widget.show_bottom_pane_view(Box::new(view));
|
||||
if dock {
|
||||
self.agents_overview.workspace.replace_view(view);
|
||||
self.agents_overview.workspace.focus_center();
|
||||
self.chat_widget.request_redraw();
|
||||
} else {
|
||||
self.chat_widget.show_bottom_pane_view(Box::new(view));
|
||||
}
|
||||
if self.reconnect.offline {
|
||||
self.reconnect.presentation = reconnect::ReconnectPresentation::Overview;
|
||||
let mut state = self
|
||||
@@ -379,10 +405,7 @@ impl App {
|
||||
if self.agents_overview.active_refresh.is_some() || self.reconnect.offline {
|
||||
return;
|
||||
}
|
||||
let visible = self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some();
|
||||
let visible = self.overview_selected_index().is_some();
|
||||
if let Some((backend_id, handle)) = self
|
||||
.agents_overview
|
||||
.pending_refresh_backends
|
||||
@@ -485,10 +508,7 @@ impl App {
|
||||
}
|
||||
|
||||
pub(super) fn repaint_agents_overview(&mut self) {
|
||||
let Some(selected) = self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
else {
|
||||
let Some(selected) = self.overview_selected_index() else {
|
||||
return;
|
||||
};
|
||||
let previous_thread_id = self
|
||||
@@ -535,10 +555,7 @@ impl App {
|
||||
.selected_index()
|
||||
.and_then(|index| self.agents_overview.visible_thread_ids.get(index).copied());
|
||||
if (previous_thread_id.is_none() || previous_thread_id != next_thread_id)
|
||||
&& self
|
||||
.chat_widget
|
||||
.selected_index_for_active_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some()
|
||||
&& self.agents_overview_has_focus()
|
||||
{
|
||||
self.cancel_pending_key_chord();
|
||||
}
|
||||
@@ -557,8 +574,13 @@ impl App {
|
||||
state.rename_target = None;
|
||||
state.input.set_text_clearing_elements("");
|
||||
}
|
||||
self.chat_widget
|
||||
.replace_bottom_pane_view_if_present(AGENTS_OVERVIEW_VIEW_ID, Box::new(view));
|
||||
if self.agents_overview.workspace.is_open() {
|
||||
self.agents_overview.workspace.replace_view(view);
|
||||
self.chat_widget.request_redraw();
|
||||
} else {
|
||||
self.chat_widget
|
||||
.replace_bottom_pane_view_if_present(AGENTS_OVERVIEW_VIEW_ID, Box::new(view));
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn agents_overview_view(
|
||||
@@ -744,6 +766,14 @@ impl App {
|
||||
.await
|
||||
}
|
||||
|
||||
fn redraw_during_task_attach(&mut self, tui: &mut tui::Tui) -> Result<()> {
|
||||
if self.agents_overview.workspace.is_open() {
|
||||
self.refresh_owned_transcript(tui)
|
||||
} else {
|
||||
loading::draw(tui).map_err(Into::into)
|
||||
}
|
||||
}
|
||||
|
||||
async fn attach_agents_overview_thread(
|
||||
&mut self,
|
||||
tui: &mut tui::Tui,
|
||||
@@ -761,7 +791,9 @@ impl App {
|
||||
{
|
||||
self.cancel_cloud_inventory_refresh(app_server).await;
|
||||
// Keep the displayed read-only snapshot frozen; R explicitly retries attachment.
|
||||
if let Ok(mut state) = self.agents_overview.view_state.lock() {
|
||||
if !self.agents_overview.workspace.is_open()
|
||||
&& let Ok(mut state) = self.agents_overview.view_state.lock()
|
||||
{
|
||||
state.completion = Some(crate::bottom_pane::ViewCompletion::Accepted);
|
||||
}
|
||||
self.chat_widget.pre_draw_tick();
|
||||
@@ -770,7 +802,7 @@ impl App {
|
||||
if self.reject_pending_permission_root_switch() {
|
||||
return Ok(AppRunControl::Continue);
|
||||
}
|
||||
if startup_draft.is_none() {
|
||||
if startup_draft.is_none() && !self.agents_overview.workspace.is_open() {
|
||||
loading::draw(tui)?;
|
||||
}
|
||||
let mut restored_blank_session = false;
|
||||
@@ -922,9 +954,9 @@ impl App {
|
||||
Err(control) => return Ok(control),
|
||||
}
|
||||
}
|
||||
// Folder selection and trust prompts can replace or clear the loading frame.
|
||||
// Folder selection and trust prompts can replace or clear the current frame.
|
||||
if startup_draft.is_none() {
|
||||
loading::draw(tui)?;
|
||||
self.redraw_during_task_attach(tui)?;
|
||||
}
|
||||
let baseline_approval = resume_config.permissions.approval_policy.value();
|
||||
let baseline_reviewer = resume_config.approvals_reviewer;
|
||||
@@ -1123,10 +1155,6 @@ impl App {
|
||||
if !is_new_session && !restored_blank_session {
|
||||
self.agents_overview.blank_sessions.remove(&root_thread_id);
|
||||
}
|
||||
// Replacing the widget clears the terminal before the remaining server requests.
|
||||
if startup_draft.is_none() {
|
||||
loading::draw(tui)?;
|
||||
}
|
||||
if let Some(error) = provider_error {
|
||||
self.chat_widget
|
||||
.show_provider_error(error, /*rejected_message_id*/ None);
|
||||
@@ -1145,6 +1173,10 @@ impl App {
|
||||
self.chat_widget
|
||||
.add_info_message(notice.to_string(), /*hint*/ None);
|
||||
}
|
||||
// Widget replacement clears the terminal. Paint the destination before further waits.
|
||||
if startup_draft.is_none() {
|
||||
self.redraw_during_task_attach(tui)?;
|
||||
}
|
||||
let mut destination_config = self.chat_widget.config_ref().clone();
|
||||
if self.app_server_target.uses_remote_workspace() {
|
||||
destination_config.cwd.clone_from(&self.config.cwd);
|
||||
|
||||
@@ -8,6 +8,7 @@ use crate::app_event::AgentsOverviewAction;
|
||||
use crate::app_event::AppEvent;
|
||||
use crate::app_server_session::AppServerSession;
|
||||
use crate::backend_id::BackendId;
|
||||
use crate::bottom_pane::BottomPaneView;
|
||||
use crate::bottom_pane::SelectionItem;
|
||||
use crate::bottom_pane::SelectionViewParams;
|
||||
use crate::chatwidget::ChatWidget;
|
||||
@@ -71,18 +72,31 @@ async fn run_lifecycle_modal<T>(
|
||||
if matches!(&event, tui::TuiEvent::Paste(_) | tui::TuiEvent::FocusLost) {
|
||||
app.cancel_pending_key_chord();
|
||||
}
|
||||
let dashboard_active = app.chat_widget
|
||||
let dock_owns_input = app.workspace_center_owns_input();
|
||||
let dashboard_active = dock_owns_input || app.chat_widget
|
||||
.selected_index_for_active_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some();
|
||||
match event {
|
||||
tui::TuiEvent::Key(key) if dashboard_active => {
|
||||
if let Some(key) = app.route_key_chord_event(tui, key) {
|
||||
app.chat_widget.handle_key_event_with_activation_key(key, app.routed_key_activation);
|
||||
if dock_owns_input {
|
||||
if let Some(view) = &mut app.agents_overview.workspace.view {
|
||||
view.handle_key_event(key);
|
||||
}
|
||||
} else {
|
||||
app.chat_widget.handle_key_event_with_activation_key(key, app.routed_key_activation);
|
||||
}
|
||||
}
|
||||
tui.frame_requester().schedule_frame();
|
||||
}
|
||||
tui::TuiEvent::Paste(text) if dashboard_active => {
|
||||
app.chat_widget.handle_paste(text);
|
||||
if dock_owns_input {
|
||||
if let Some(view) = &mut app.agents_overview.workspace.view {
|
||||
view.handle_paste(text);
|
||||
}
|
||||
} else {
|
||||
app.chat_widget.handle_paste(text);
|
||||
}
|
||||
tui.frame_requester().schedule_frame();
|
||||
}
|
||||
tui::TuiEvent::Key(_) | tui::TuiEvent::Paste(_) | tui::TuiEvent::FocusLost | tui::TuiEvent::Mouse(_) => {}
|
||||
@@ -399,14 +413,10 @@ impl App {
|
||||
self.cancel_agents_overview_refresh(app_server.backend_id());
|
||||
}
|
||||
if detach_primary {
|
||||
self.agents_overview.selection_after_removal =
|
||||
self.agents_overview.selection_after_removal.or_else(|| {
|
||||
self.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.and_then(|index| {
|
||||
self.agents_overview.visible_thread_ids.get(index).copied()
|
||||
})
|
||||
});
|
||||
self.agents_overview.selection_after_removal = self
|
||||
.agents_overview
|
||||
.selection_after_removal
|
||||
.or_else(|| self.overview_selected_thread_id());
|
||||
self.reset_for_thread_switch(tui)?;
|
||||
self.pending_thread_switch_resets += 1;
|
||||
self.app_event_tx
|
||||
|
||||
@@ -17,6 +17,7 @@ use pretty_assertions::assert_eq;
|
||||
#[tokio::test]
|
||||
async fn pin_action_updates_shared_section_state() -> Result<()> {
|
||||
let mut app = make_test_app().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
app.app_event_tx = AppEventSender::new(tx);
|
||||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||||
@@ -364,6 +365,7 @@ async fn archiving_selects_the_next_displayed_task() -> Result<()> {
|
||||
for filtered in [false, true] {
|
||||
let (mut app, mut rx, _op_rx) =
|
||||
crate::app::tests::make_test_app_with_channels().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
let mut app_server =
|
||||
crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
@@ -1009,6 +1011,7 @@ async fn lifecycle_removes_background_and_current_tasks_without_losing_the_dashb
|
||||
};
|
||||
let (mut app, mut rx, _op_rx) =
|
||||
Box::pin(crate::app::tests::make_test_app_with_channels()).await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
let (release, gate) = tokio::sync::oneshot::channel();
|
||||
let (server, _completions) = start_streaming_sse_server(vec![vec![
|
||||
StreamingSseChunk {
|
||||
|
||||
@@ -136,7 +136,13 @@ async fn overview_return_to_current_chat_cancels_the_cloud_list_and_allows_reope
|
||||
next_cloud_page(commands, /*cursor*/ None).await
|
||||
};
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
crate::app::test_support::enable_side_retention(&mut app)?;
|
||||
tui.set_owned_screen(/*owned*/ true)?;
|
||||
for key in [KeyCode::Esc, KeyCode::Enter] {
|
||||
if key == KeyCode::Enter {
|
||||
// Escape closes the dock. Selection closes the original modal.
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
}
|
||||
app.open_agents_overview(&cloud);
|
||||
let held_list = tokio::time::timeout(timeout, next_list(&mut commands)).await?;
|
||||
Box::pin(app.handle_tui_event(&mut tui, &mut cloud, TuiEvent::Key(key.into()))).await?;
|
||||
@@ -157,7 +163,7 @@ async fn overview_return_to_current_chat_cancels_the_cloud_list_and_allows_reope
|
||||
.await??;
|
||||
}
|
||||
assert!(held_list.response.is_closed());
|
||||
assert!(!app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
|
||||
assert!(app.overview_selected_index().is_none());
|
||||
}
|
||||
|
||||
// The previous archive was observed, but its unarchive notification was missed.
|
||||
|
||||
@@ -30,11 +30,7 @@ impl App {
|
||||
title: Option<&'static str>,
|
||||
message: String,
|
||||
) {
|
||||
if self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some()
|
||||
{
|
||||
if self.overview_selected_index().is_some() {
|
||||
let items = vec![SelectionItem {
|
||||
name: "Return to command center".to_string(),
|
||||
dismiss_on_select: true,
|
||||
|
||||
@@ -245,6 +245,9 @@ impl App {
|
||||
"Could not open the new session.",
|
||||
);
|
||||
}
|
||||
} else if self.agents_overview.workspace.is_open() {
|
||||
self.focus_workspace_composer(tui);
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
Ok(control)
|
||||
}
|
||||
|
||||
@@ -2,19 +2,16 @@
|
||||
//! Choose against the displayed order before mutation; pending successors survive
|
||||
//! batched removals and duplicate completion notifications until the next repaint.
|
||||
|
||||
use super::AGENTS_OVERVIEW_VIEW_ID;
|
||||
use super::App;
|
||||
use codex_protocol::ThreadId;
|
||||
use std::collections::HashSet;
|
||||
|
||||
impl App {
|
||||
pub(in crate::app) fn prepare_agents_overview_removal(&mut self, removed: &HashSet<ThreadId>) {
|
||||
let selected = self.agents_overview.selection_after_removal.or_else(|| {
|
||||
let index = self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)?;
|
||||
self.agents_overview.visible_thread_ids.get(index).copied()
|
||||
});
|
||||
let selected = self
|
||||
.agents_overview
|
||||
.selection_after_removal
|
||||
.or_else(|| self.overview_selected_thread_id());
|
||||
let Some(selected) = selected.filter(|id| removed.contains(id)) else {
|
||||
return;
|
||||
};
|
||||
|
||||
@@ -366,8 +366,10 @@ async fn late_overview_page_only_refills_its_own_backend() {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn queued_overview_page_survives_a_focus_change() {
|
||||
async fn queued_overview_page_survives_a_focus_change() -> Result<()> {
|
||||
let mut app = make_test_app().await;
|
||||
app.config.features.enable(Feature::TuiWorkspace)?;
|
||||
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
|
||||
let owner = BackendId::new();
|
||||
let other = BackendId::new();
|
||||
let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1);
|
||||
@@ -409,9 +411,15 @@ async fn queued_overview_page_survives_a_focus_change() {
|
||||
assert!(app.agents_overview.active_refresh.is_none());
|
||||
|
||||
app.app_server_backend_id = Some(owner);
|
||||
app.open_agents_overview(&session);
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
app.focus_workspace_composer(&mut tui);
|
||||
app.drain_agents_overview_refresh_queue();
|
||||
let (page, page_owner) = app.agents_overview.active_refresh.unwrap();
|
||||
assert_eq!(page_owner, owner);
|
||||
assert_eq!(
|
||||
app.agents_overview.pending_refresh_backends.front(),
|
||||
Some(&owner)
|
||||
);
|
||||
assert!(app.agents_overview.refresh_show_more);
|
||||
assert!(!app.agents_overview.active_refresh_recent);
|
||||
assert!(app.agents_overview.refresh_recent_backends.contains(&owner));
|
||||
@@ -440,6 +448,7 @@ async fn queued_overview_page_survives_a_focus_change() {
|
||||
assert_eq!(app.agents_overview.active_refresh, Some((recent, owner)));
|
||||
assert!(app.agents_overview.cloud_inventory_dirty.contains(&owner));
|
||||
app.cancel_agents_overview_refresh(owner);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
@@ -474,6 +483,7 @@ async fn cloud_inventory_polls_when_visible_and_detached() {
|
||||
#[tokio::test]
|
||||
async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> {
|
||||
let mut app = make_test_app().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
let (mut displayed, mut commands, _events) =
|
||||
overview_session_stub(BackendId::new(), ThreadParamsMode::Cloud);
|
||||
let remote_owner = BackendId::new();
|
||||
@@ -1063,6 +1073,7 @@ async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Re
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Result<()> {
|
||||
let mut app = make_test_app().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
trust_fixture_folders(&mut app);
|
||||
let mut ids = Vec::new();
|
||||
for day in 1..=12 {
|
||||
@@ -1221,6 +1232,7 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res
|
||||
|
||||
// A fresh TUI/server has no in-memory additions; read-only resumes did not promote history.
|
||||
let mut restarted = make_test_app().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut restarted);
|
||||
restarted.app_server_target = app.app_server_target.clone();
|
||||
let app_server = Box::pin(crate::start_embedded_app_server_for_picker(&config)).await?;
|
||||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
@@ -2316,11 +2328,96 @@ async fn root_switch_preserves_vim_line_yank() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn new_session_selects_its_task_when_the_open_dock_receives_the_row() -> Result<()> {
|
||||
let mut app = Box::pin(make_test_app()).await;
|
||||
trust_fixture_folders(&mut app);
|
||||
app.local_settings.tui.animations = false;
|
||||
std::fs::write(
|
||||
&app.local_settings.user_config_path,
|
||||
"[features]\ntui_workspace = true\n[tui]\nanimations = false\n",
|
||||
)?;
|
||||
app.config.features.enable(Feature::TuiWorkspace)?;
|
||||
let mut tui = crate::tui::test_support::make_test_tui_with_size(Size::new(
|
||||
/*width*/ 100, /*height*/ 24,
|
||||
))?;
|
||||
tui.set_owned_screen(/*owned*/ true)?;
|
||||
app.local_settings.transcript_mode = tui.transcript_mode();
|
||||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||||
let previous = Box::pin(server.start_thread(&app.config)).await?;
|
||||
let previous_id = previous.session.thread_id;
|
||||
app.enqueue_primary_thread_session(previous.session, previous.turns)
|
||||
.await?;
|
||||
let previous_row = overview_thread(
|
||||
previous_id,
|
||||
/*parent_thread_id*/ None,
|
||||
"Previous task",
|
||||
ThreadStatus::Idle,
|
||||
);
|
||||
app.agents_overview
|
||||
.threads
|
||||
.insert(previous_id, Some(previous_row));
|
||||
app.open_agents_overview(&server);
|
||||
app.focus_workspace_composer(&mut tui);
|
||||
assert_eq!(app.overview_selected_thread_id(), Some(previous_id));
|
||||
|
||||
tui.pause_events();
|
||||
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::NewSession { name: None })).await?;
|
||||
let new_id = app.current_displayed_thread_id().expect("new conversation");
|
||||
assert_ne!(new_id, previous_id);
|
||||
app.repaint_agents_overview();
|
||||
let thread = server.thread_read(new_id, /*include_turns*/ false).await?;
|
||||
let started = ServerNotification::ThreadStarted(ThreadStartedNotification { thread });
|
||||
Box::pin(app.handle_app_server_event(
|
||||
&server,
|
||||
AppServerEvent::ServerNotification(Box::new(started)),
|
||||
))
|
||||
.await;
|
||||
assert_eq!(app.overview_selected_thread_id(), Some(new_id));
|
||||
assert!(!app.workspace_center_owns_input());
|
||||
|
||||
app.render_chat_widget_frame(&mut tui, Size::new(/*width*/ 100, /*height*/ 24))?;
|
||||
let screen = crate::app::owned_transcript::tests::buffer_text(tui.terminal.previous_buffer());
|
||||
let selected_title = screen
|
||||
.lines()
|
||||
.filter_map(|line| line.split_once('│'))
|
||||
.map(|(dock, _)| dock.trim())
|
||||
.find(|line| line.starts_with('›'))
|
||||
.expect("selected task in dock");
|
||||
insta::assert_snapshot!(selected_title, @"› ○ Untitled task");
|
||||
|
||||
app.open_agents_overview(&server);
|
||||
app.handle_workspace_key(&mut tui, KeyCode::Down.into());
|
||||
assert_eq!(app.overview_selected_thread_id(), Some(previous_id));
|
||||
app.focus_workspace_composer(&mut tui);
|
||||
app.repaint_agents_overview();
|
||||
assert_eq!(app.overview_selected_thread_id(), Some(previous_id));
|
||||
|
||||
app.open_agents_overview(&server);
|
||||
Box::pin(app.new_agents_overview_session(&mut tui, &mut server, /*cwd*/ None)).await?;
|
||||
assert_ne!(app.current_displayed_thread_id(), Some(new_id));
|
||||
assert!(app.agents_overview.workspace.is_open());
|
||||
assert!(!app.workspace_center_owns_input());
|
||||
|
||||
// Read receipts follow the visible conversation, including while the wide dock has focus.
|
||||
app.open_agents_overview(&server);
|
||||
let displayed = app.current_displayed_thread_id().expect("new dock task");
|
||||
for (width, visible) in [(100, Some(displayed)), (50, None)] {
|
||||
let size = Size::new(width, /*height*/ 24);
|
||||
tui.terminal.resize(size)?;
|
||||
Box::pin(app.handle_tui_event(&mut tui, &mut server, TuiEvent::Resize(size))).await?;
|
||||
assert_eq!(server.focused_conversation, visible);
|
||||
}
|
||||
server.shutdown().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn root_switch_loads_local_preferences_from_disk() -> Result<()> {
|
||||
// Keep the large setup and root-switch futures off the test thread's stack.
|
||||
let mut app = Box::pin(make_test_app()).await;
|
||||
trust_fixture_folders(&mut app);
|
||||
app.local_settings.tui.animations = false;
|
||||
let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(
|
||||
app.chat_widget.config_ref(),
|
||||
))
|
||||
@@ -2341,15 +2438,28 @@ async fn root_switch_loads_local_preferences_from_disk() -> Result<()> {
|
||||
)?;
|
||||
std::fs::write(
|
||||
app.local_settings.user_config_path.as_path(),
|
||||
"[tui]\ntheme = \"dracula\"\nresume_cwd = \"session\"\n[history]\npersistence = \"none\"\n",
|
||||
"[features]\ntui_workspace = true\n[tui]\nanimations = false\ntheme = \"dracula\"\nresume_cwd = \"session\"\n[history]\npersistence = \"none\"\n",
|
||||
)?;
|
||||
let config = Box::pin(app.rebuild_config_for_cwd(app.config.cwd.to_path_buf())).await?;
|
||||
let expected = crate::local_settings::LocalSettings::from(&config);
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
|
||||
Box::pin(app.select_agents_overview_thread(&mut tui, &mut app_server, target_thread_id))
|
||||
.await?;
|
||||
let mut tui = crate::tui::test_support::make_test_tui_with_size(Size::new(
|
||||
/*width*/ 100, /*height*/ 24,
|
||||
))?;
|
||||
tui.set_owned_screen(/*owned*/ true)?;
|
||||
let expected = crate::local_settings::LocalSettings::for_tui(&config, &tui);
|
||||
app.config.features.enable(Feature::TuiWorkspace)?;
|
||||
app.local_settings.transcript_mode = tui.transcript_mode();
|
||||
app.open_agents_overview(&app_server);
|
||||
|
||||
Box::pin(app.handle_event(
|
||||
&mut tui,
|
||||
&mut app_server,
|
||||
AppEvent::SelectAgentsOverviewThread {
|
||||
thread_id: target_thread_id,
|
||||
},
|
||||
))
|
||||
.await?;
|
||||
assert!(app.agents_overview.workspace.is_open());
|
||||
assert!(!app.workspace_center_owns_input());
|
||||
assert_eq!(app.current_displayed_thread_id(), Some(target_thread_id));
|
||||
assert_eq!(app.local_settings, expected);
|
||||
assert_eq!(app.chat_widget.local_settings, expected);
|
||||
@@ -3425,6 +3535,7 @@ async fn command_center_handles_resume_failure_and_success() -> Result<()> {
|
||||
#[tokio::test]
|
||||
async fn command_center_attach_conflict_opens_read_only_and_retries() -> Result<()> {
|
||||
let mut app = Box::pin(make_test_app()).await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
trust_fixture_folders(&mut app);
|
||||
std::fs::write(
|
||||
app.config.codex_home.join("config.toml"),
|
||||
@@ -3860,6 +3971,12 @@ async fn overview_fork_keeps_idle_source_input_queued() -> Result<()> {
|
||||
ready = Some(event);
|
||||
}
|
||||
}
|
||||
if cached_primary {
|
||||
tui.set_owned_screen(/*owned*/ true)?;
|
||||
app.local_settings.transcript_mode = tui.transcript_mode();
|
||||
app.config.features.enable(Feature::TuiWorkspace)?;
|
||||
app.open_agents_overview(&server);
|
||||
}
|
||||
// Failed reattachment can leave the source displayed as a saved replay.
|
||||
app.app_server_target = AppServerTarget::LocalDaemon {
|
||||
allow_embedded_fallback: true,
|
||||
@@ -3878,9 +3995,12 @@ async fn overview_fork_keeps_idle_source_input_queued() -> Result<()> {
|
||||
assert_eq!(app.current_displayed_thread_id(), Some(source));
|
||||
assert_eq!(server.next_request_id(), RequestId::Integer(request + 1));
|
||||
assert!(!app.chat_widget.fork_in_progress);
|
||||
assert_eq!(app.workspace_center_owns_input(), cached_primary);
|
||||
app.app_server_target = AppServerTarget::Embedded;
|
||||
Box::pin(app.handle_event(&mut tui, &mut server, ready.expect("fork continuation")))
|
||||
.await?;
|
||||
assert_eq!(app.agents_overview.workspace.is_open(), cached_primary);
|
||||
assert!(!app.workspace_center_owns_input());
|
||||
assert_ne!(app.current_displayed_thread_id(), Some(source));
|
||||
assert_eq!(app.agents_overview.input_states[&source], retained);
|
||||
assert!(app.chat_widget.queued_user_message_texts().is_empty());
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
//! Discovery merges into retained membership without evicting rows.
|
||||
|
||||
use super::App;
|
||||
use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;
|
||||
use super::agents_overview_details::preview_agent_message;
|
||||
use super::agents_overview_discovery::AgentsOverviewDiscovery;
|
||||
use super::agents_overview_discovery::is_overview_root;
|
||||
@@ -281,11 +280,7 @@ impl App {
|
||||
&mut self,
|
||||
app_server: &AppServerSession,
|
||||
) {
|
||||
if self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_none()
|
||||
{
|
||||
if self.overview_selected_index().is_none() {
|
||||
return;
|
||||
}
|
||||
self.agents_overview.pin_refresh_requested = true;
|
||||
@@ -317,16 +312,13 @@ impl App {
|
||||
{
|
||||
return;
|
||||
}
|
||||
let visible = self.overview_selected_index().is_some();
|
||||
let overview = &mut self.agents_overview;
|
||||
let initialized = overview.initialized.contains(&backend_id);
|
||||
let source_has_more = overview
|
||||
.discovery
|
||||
.get(&backend_id)
|
||||
.is_none_or(AgentsOverviewDiscovery::has_more);
|
||||
let visible = self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some();
|
||||
if !visible && initialized {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
//! pending billing results and disabled capability state.
|
||||
|
||||
use super::App;
|
||||
use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;
|
||||
use super::background_requests::THREAD_USAGE_FETCH_TIMEOUT;
|
||||
use super::background_requests::fetch_thread_usage;
|
||||
use crate::app_event::AppEvent;
|
||||
@@ -62,12 +61,7 @@ impl App {
|
||||
{
|
||||
return;
|
||||
}
|
||||
let Some(thread_id) = self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.and_then(|index| self.agents_overview.visible_thread_ids.get(index))
|
||||
.copied()
|
||||
else {
|
||||
let Some(thread_id) = self.overview_selected_thread_id() else {
|
||||
return;
|
||||
};
|
||||
let owner = app_server.backend_id();
|
||||
|
||||
@@ -227,6 +227,8 @@ impl AgentsOverviewViewState {
|
||||
}
|
||||
|
||||
pub(super) struct AgentsOverviewView {
|
||||
/// Some when shown beside the conversation. The value records keyboard focus.
|
||||
pub(super) dock_focused: Option<bool>,
|
||||
use_theme_colors: bool,
|
||||
pub(super) rows: Vec<AgentsOverviewRow>,
|
||||
project_groups: Vec<AgentsOverviewProjectGroup>,
|
||||
@@ -305,6 +307,7 @@ impl AgentsOverviewView {
|
||||
}
|
||||
}
|
||||
let mut view = Self {
|
||||
dock_focused: None,
|
||||
editor_keymap: keymap.clone(),
|
||||
use_theme_colors,
|
||||
rows,
|
||||
@@ -330,6 +333,29 @@ impl AgentsOverviewView {
|
||||
view
|
||||
}
|
||||
|
||||
pub(super) fn owns_nested_input(&self) -> bool {
|
||||
let state = self.state();
|
||||
state.editing_metadata() || state.help || state.removal.is_some() || state.creating_worktree
|
||||
}
|
||||
|
||||
/// Follow a newly displayed task once its row arrives. Ordinary refreshes keep the browse position.
|
||||
pub(super) fn follow_changed_conversation(&mut self, previous: &Self) {
|
||||
let Some((index, current)) = self.rows.iter().enumerate().find(|(_, row)| row.is_current)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
if !previous
|
||||
.rows
|
||||
.iter()
|
||||
.any(|row| row.is_current && row.thread_id == current.thread_id)
|
||||
&& !self.owns_nested_input()
|
||||
&& self.visible_indices().contains(&index)
|
||||
{
|
||||
self.selected = index;
|
||||
self.state().show_more_selected = false;
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn thread_ids(&self) -> Vec<ThreadId> {
|
||||
self.rows.iter().map(|row| row.thread_id).collect()
|
||||
}
|
||||
|
||||
@@ -0,0 +1,228 @@
|
||||
//! The docked Command Center requires the owned transcript renderer.
|
||||
//! Its view stays in the workspace when focus moves to the conversation.
|
||||
|
||||
use super::App;
|
||||
use super::agents_overview_view::AgentsOverviewView;
|
||||
use super::sidebar::PaneFocus;
|
||||
use crate::app_event::AppEvent;
|
||||
use crate::app_event::ExitMode;
|
||||
use crate::bottom_pane::BottomPaneView;
|
||||
use crate::bottom_pane::CancellationEvent;
|
||||
use crate::key_hint::KeyBindingListExt;
|
||||
use crate::render::renderable::Renderable;
|
||||
use crate::tui::Tui;
|
||||
|
||||
use crossterm::event::KeyCode;
|
||||
use crossterm::event::KeyEvent;
|
||||
use crossterm::event::KeyModifiers;
|
||||
use crossterm::event::MouseEvent;
|
||||
use crossterm::event::MouseEventKind;
|
||||
use ratatui::layout::Constraint;
|
||||
use ratatui::layout::Layout;
|
||||
use ratatui::layout::Rect;
|
||||
|
||||
use ratatui::style::Style;
|
||||
|
||||
const CENTER_WIDTH: u16 = 36;
|
||||
// One column for the divider and one for padding before the conversation.
|
||||
const GUTTER_WIDTH: u16 = 2;
|
||||
const MIN_CHAT_WIDTH: u16 = 48;
|
||||
const MIN_SPLIT_WIDTH: u16 = CENTER_WIDTH + GUTTER_WIDTH + MIN_CHAT_WIDTH;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum Pane {
|
||||
Center,
|
||||
Conversation,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Workspace {
|
||||
pub(super) view: Option<AgentsOverviewView>,
|
||||
/// None while the dock is closed.
|
||||
focus: Option<Pane>,
|
||||
}
|
||||
|
||||
impl Workspace {
|
||||
pub(super) fn is_open(&self) -> bool {
|
||||
self.focus.is_some()
|
||||
}
|
||||
|
||||
pub(super) fn focus_center(&mut self) {
|
||||
self.focus = Some(Pane::Center);
|
||||
}
|
||||
|
||||
pub(super) fn replace_view(&mut self, mut view: AgentsOverviewView) {
|
||||
if self.focus == Some(Pane::Conversation)
|
||||
&& let Some(previous) = &self.view
|
||||
{
|
||||
view.follow_changed_conversation(previous);
|
||||
}
|
||||
self.view = Some(view);
|
||||
}
|
||||
|
||||
pub(super) fn selected_index(&self) -> Option<usize> {
|
||||
self.view.as_ref()?.selected_index()
|
||||
}
|
||||
}
|
||||
|
||||
impl App {
|
||||
pub(super) fn workspace_center_owns_input(&self) -> bool {
|
||||
self.agents_overview.workspace.focus == Some(Pane::Center)
|
||||
&& self.overlay.is_none()
|
||||
&& !self.chat_widget.has_active_view()
|
||||
}
|
||||
|
||||
pub(super) fn workspace_chat_area(&self, viewport: Rect) -> Rect {
|
||||
if self.agents_overview.workspace.is_open() {
|
||||
self.workspace_areas(viewport).1.unwrap_or_default()
|
||||
} else {
|
||||
viewport
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn workspace_areas(&self, viewport: Rect) -> (Option<Rect>, Option<Rect>) {
|
||||
if viewport.width >= MIN_SPLIT_WIDTH {
|
||||
let [center, _, conversation] = Layout::horizontal([
|
||||
Constraint::Length(CENTER_WIDTH),
|
||||
Constraint::Length(GUTTER_WIDTH),
|
||||
Constraint::Min(MIN_CHAT_WIDTH),
|
||||
])
|
||||
.areas(viewport);
|
||||
(Some(center), Some(conversation))
|
||||
} else if self.workspace_center_owns_input() {
|
||||
(Some(viewport), None)
|
||||
} else {
|
||||
(None, Some(viewport))
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn focus_workspace_composer(&mut self, tui: &mut Tui) {
|
||||
if self.agents_overview.workspace.is_open() {
|
||||
self.agents_overview.workspace.focus = Some(Pane::Conversation);
|
||||
}
|
||||
if self.panel_focus() == Some(PaneFocus::Sidebar) {
|
||||
let pane = self.sidebar_mut();
|
||||
if let Some(content) = pane.visible_content() {
|
||||
pane.show(content, PaneFocus::Main);
|
||||
}
|
||||
}
|
||||
self.cancel_transcript_browsing(tui);
|
||||
self.transcript_view.end_select_mode();
|
||||
self.transcript_view.end_selection(&self.transcript_cells);
|
||||
self.transcript_view.cancel_search();
|
||||
self.transcript_view.clear_activity_focus();
|
||||
self.cancel_pending_key_chord();
|
||||
}
|
||||
|
||||
pub(super) fn handle_workspace_key(&mut self, tui: &mut Tui, mut key: KeyEvent) {
|
||||
if self.should_recover_vim_insert_escape(tui, key)
|
||||
&& let Some(view) = &mut self.agents_overview.workspace.view
|
||||
{
|
||||
view.handle_key_event(KeyCode::Esc.into());
|
||||
key.modifiers.remove(KeyModifiers::ALT);
|
||||
}
|
||||
let Some(key) = self.route_key_chord_event(tui, key) else {
|
||||
return;
|
||||
};
|
||||
if self.handle_voice_toggle_key(tui, key) {
|
||||
return;
|
||||
}
|
||||
let Some(view) = &mut self.agents_overview.workspace.view else {
|
||||
return;
|
||||
};
|
||||
if !view.owns_nested_input() && self.keymap.app.select_transcript.is_pressed(key) {
|
||||
self.focus_workspace_composer(tui);
|
||||
self.transcript_view
|
||||
.begin_select_mode(&self.transcript_cells);
|
||||
} else {
|
||||
if crate::key_hint::ctrl(KeyCode::Char('c')).is_press(key) {
|
||||
if view.on_ctrl_c() == CancellationEvent::NotHandled {
|
||||
self.app_event_tx
|
||||
.send(AppEvent::Exit(ExitMode::ShutdownFirst));
|
||||
}
|
||||
} else {
|
||||
view.handle_key_event(key);
|
||||
}
|
||||
if view.is_complete() {
|
||||
self.agents_overview.workspace.focus = None;
|
||||
self.focus_workspace_composer(tui);
|
||||
self.conversation_frame = Default::default();
|
||||
}
|
||||
}
|
||||
tui.frame_requester().schedule_frame();
|
||||
}
|
||||
|
||||
pub(super) fn handle_workspace_mouse(&mut self, tui: &mut Tui, mouse: MouseEvent) -> bool {
|
||||
if !self.agents_overview.workspace.is_open()
|
||||
|| self.overlay.is_some()
|
||||
|| self.chat_widget.has_active_view()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
let viewport: Rect = tui.terminal.last_known_screen_size.into();
|
||||
let (center, conversation) = self.workspace_areas(viewport);
|
||||
let center_was_focused = self.agents_overview.workspace.focus == Some(Pane::Center);
|
||||
// The press chose the owner. Let its selection finish even outside its pane.
|
||||
if matches!(mouse.kind, MouseEventKind::Drag(_) | MouseEventKind::Up(_)) {
|
||||
return center_was_focused;
|
||||
}
|
||||
|
||||
let point = (mouse.column, mouse.row).into();
|
||||
let pressed = matches!(mouse.kind, MouseEventKind::Down(_));
|
||||
if center.is_some_and(|rect| rect.contains(point)) {
|
||||
if pressed {
|
||||
self.agents_overview.workspace.focus_center();
|
||||
self.cancel_pending_key_chord();
|
||||
tui.frame_requester().schedule_frame();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if conversation.is_some_and(|rect| rect.contains(point)) {
|
||||
if center_was_focused && pressed {
|
||||
if !self
|
||||
.agents_overview
|
||||
.workspace
|
||||
.view
|
||||
.as_ref()
|
||||
.is_some_and(|view| view.can_return_to_chat)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
self.focus_workspace_composer(tui);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
pub(super) fn paint_command_center(
|
||||
&mut self,
|
||||
frame: &mut crate::custom_terminal::Frame<'_>,
|
||||
center: Rect,
|
||||
conversation: Option<Rect>,
|
||||
) {
|
||||
let center_focused = self.workspace_center_owns_input();
|
||||
frame
|
||||
.image_placements
|
||||
.retain(|image| !center.intersects(image.area));
|
||||
if center_focused {
|
||||
frame.cursor_position = None;
|
||||
}
|
||||
let area = center;
|
||||
if let Some(view) = &mut self.agents_overview.workspace.view {
|
||||
view.dock_focused = conversation.map(|_| center_focused);
|
||||
view.render(area, frame.buffer);
|
||||
if center_focused {
|
||||
frame.cursor_position = view.cursor_pos(area).map(Into::into);
|
||||
frame.set_cursor_style(view.cursor_style(area));
|
||||
}
|
||||
}
|
||||
if conversation.is_some() {
|
||||
for y in center.y..center.bottom() {
|
||||
frame.buffer[(center.right(), y)]
|
||||
.set_symbol("│")
|
||||
.set_style(Style::default().dim());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -856,6 +856,10 @@ impl App {
|
||||
}
|
||||
// Keep local input without replacing the fork's running state.
|
||||
self.chat_widget.restore_reconnected_input(retained_input, &[]);
|
||||
if from_agents_overview && self.agents_overview.workspace.is_open() {
|
||||
self.focus_workspace_composer(tui);
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
if let Some(err) = name_error {
|
||||
self.chat_widget.add_error_message(err);
|
||||
}
|
||||
@@ -1341,7 +1345,7 @@ impl App {
|
||||
&& (self.agents_overview.threads.iter().any(|(id, thread)| {
|
||||
(mode == ExitMode::Immediate
|
||||
|| Some(*id) != self.current_displayed_thread_id()
|
||||
|| self.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID))
|
||||
|| self.agents_overview_has_focus())
|
||||
&& matches!(thread.as_ref().map(|t| &t.status), Some(ThreadStatus::Active { .. }))
|
||||
}) || self.running_side_thread_id().await.is_some()) =>
|
||||
{
|
||||
@@ -3471,9 +3475,15 @@ impl App {
|
||||
{
|
||||
AppRunControl::Continue
|
||||
if self.primary_thread_id.is_none()
|
||||
&& self.chat_widget.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID).is_none() => {
|
||||
&& self.overview_selected_index().is_none() => {
|
||||
self.open_agents_overview(app_server);
|
||||
}
|
||||
AppRunControl::Continue
|
||||
if self.agents_overview.workspace.is_open()
|
||||
&& self.current_displayed_thread_id() == Some(thread_id) => {
|
||||
self.focus_workspace_composer(tui);
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
AppRunControl::Continue => {}
|
||||
AppRunControl::Exit(reason) => return Ok(AppRunControl::Exit(reason)),
|
||||
}
|
||||
|
||||
@@ -22,12 +22,9 @@ impl App {
|
||||
if self.focused_sidebar_chooser(tui) {
|
||||
return false;
|
||||
}
|
||||
let rename_active = self
|
||||
.chat_widget
|
||||
.selected_index_for_active_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some();
|
||||
let overview_owns_input = self.agents_overview_has_focus();
|
||||
let escape = KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE);
|
||||
let insert_escape = if rename_active {
|
||||
let insert_escape = if overview_owns_input {
|
||||
let state = self
|
||||
.agents_overview
|
||||
.view_state
|
||||
@@ -50,11 +47,11 @@ impl App {
|
||||
&& (key_event.modifiers == KeyModifiers::ALT
|
||||
|| key_event.modifiers == (KeyModifiers::ALT | KeyModifiers::SHIFT))
|
||||
// ChatWidget's fixed image-paste shortcut is not in the configurable keymap.
|
||||
&& !(!rename_active
|
||||
&& !(!overview_owns_input
|
||||
&& key_event.kind == KeyEventKind::Press
|
||||
&& matches!(key_event.code, KeyCode::Char('v' | 'V')))
|
||||
// Empty-draft agent navigation also has fixed legacy-terminal fallbacks.
|
||||
&& !(!rename_active
|
||||
&& !(!overview_owns_input
|
||||
&& self.chat_widget.composer_text_with_pending().is_empty()
|
||||
&& (previous_agent_shortcut_matches(key_event, /*allow_word_motion_fallback*/ true)
|
||||
|| next_agent_shortcut_matches(key_event, /*allow_word_motion_fallback*/ true)))
|
||||
@@ -97,7 +94,10 @@ impl App {
|
||||
if let Some(overlay) = &mut self.overlay {
|
||||
overlay.set_keymap_bindings(&self.keymap);
|
||||
}
|
||||
if self.overlay.is_none() && self.chat_widget.handle_quick_dial_menu(key_event) {
|
||||
if self.overlay.is_none()
|
||||
&& !self.workspace_center_owns_input()
|
||||
&& self.chat_widget.handle_quick_dial_menu(key_event)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let contexts = self.key_chord_contexts(tui);
|
||||
@@ -127,6 +127,7 @@ impl App {
|
||||
},
|
||||
)))
|
||||
&& !select_mode_chord
|
||||
&& !self.workspace_center_owns_input()
|
||||
{
|
||||
let close = tui.is_owned_screen()
|
||||
&& self.overlay.is_none()
|
||||
@@ -285,6 +286,12 @@ impl App {
|
||||
}
|
||||
|
||||
pub(super) fn active_keymap_contexts(&self) -> crate::keymap::KeymapContextSet {
|
||||
if self.workspace_center_owns_input()
|
||||
&& let Some(view) = &self.agents_overview.workspace.view
|
||||
{
|
||||
use crate::bottom_pane::BottomPaneView;
|
||||
return view.keymap_contexts().with_voice_toggle(&self.keymap);
|
||||
}
|
||||
use crate::keymap::KeymapContext;
|
||||
use crate::keymap::KeymapContextSet;
|
||||
|
||||
@@ -350,6 +357,28 @@ impl App {
|
||||
contexts.with_voice_toggle(&self.keymap)
|
||||
}
|
||||
|
||||
pub(super) fn voice_toggle_pressed(&self, key: KeyEvent) -> bool {
|
||||
key.kind == KeyEventKind::Press
|
||||
&& self
|
||||
.active_keymap_contexts()
|
||||
.contains_action(crate::keymap::KeymapActionId {
|
||||
context: crate::keymap::KeymapContext::Chat,
|
||||
action: "toggle_voice",
|
||||
})
|
||||
&& self.keymap.chat.toggle_voice.is_pressed(key)
|
||||
}
|
||||
|
||||
pub(super) fn handle_voice_toggle_key(&mut self, tui: &mut tui::Tui, key: KeyEvent) -> bool {
|
||||
if !self.voice_toggle_pressed(key) {
|
||||
return false;
|
||||
}
|
||||
self.cancel_transcript_browsing(tui);
|
||||
if !self.chat_widget.handle_startup_submission_key(key) {
|
||||
self.control_voice(crate::app_event::VoiceControl::Toggle);
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
pub(super) async fn launch_external_editor(&mut self, tui: &mut tui::Tui) {
|
||||
self.chat_widget
|
||||
.empty_state_animation
|
||||
|
||||
@@ -39,6 +39,7 @@ use ratatui::widgets::Widget;
|
||||
#[derive(Default)]
|
||||
pub(super) struct ConversationFrame {
|
||||
inset: Option<Rect>,
|
||||
pub(super) command_center: Option<Rect>,
|
||||
pub(super) sidebar: Option<sidebar::SidebarLayout>,
|
||||
pub(super) chat_strip: Option<Rect>,
|
||||
pub(super) sidebar_input: Option<sidebar::SidebarInputState>,
|
||||
@@ -51,7 +52,10 @@ pub(super) struct ConversationFrame {
|
||||
|
||||
impl ConversationFrame {
|
||||
pub(super) fn has_caller_inset(&self) -> bool {
|
||||
self.inset.is_some() && self.sidebar.is_none() && self.chat_strip.is_none()
|
||||
self.inset.is_some()
|
||||
&& self.command_center.is_none()
|
||||
&& self.sidebar.is_none()
|
||||
&& self.chat_strip.is_none()
|
||||
}
|
||||
|
||||
pub(super) fn side_pane(&self) -> Option<&side_pane::SidePaneLayout> {
|
||||
@@ -251,7 +255,9 @@ impl App {
|
||||
) -> Result<Rect> {
|
||||
self.transcript_view.image_protocol = self.prepare_frame_images(tui);
|
||||
let frames = tui.frame_requester();
|
||||
if self.conversation_frame.sidebar.is_some() || self.conversation_frame.chat_strip.is_some()
|
||||
if self.conversation_frame.command_center.is_some()
|
||||
|| self.conversation_frame.sidebar.is_some()
|
||||
|| self.conversation_frame.chat_strip.is_some()
|
||||
{
|
||||
// Recompute our own inset on every frame, including the first narrow frame.
|
||||
self.conversation_frame = ConversationFrame::default();
|
||||
@@ -268,7 +274,16 @@ impl App {
|
||||
{
|
||||
pane.sync_agent_rows(&self.agent_navigation);
|
||||
}
|
||||
let layout = sidebar::paint_layout(self, tui, screen_size.into());
|
||||
let viewport: Rect = screen_size.into();
|
||||
let (center, available) =
|
||||
if caller_inset.is_none() && self.agents_overview.workspace.is_open() {
|
||||
self.workspace_areas(viewport)
|
||||
} else {
|
||||
(None, Some(viewport))
|
||||
};
|
||||
self.conversation_frame.command_center = center;
|
||||
let content = available.unwrap_or_default();
|
||||
let layout = available.and_then(|area| sidebar::paint_layout(self, tui, area));
|
||||
let displayed = self.current_displayed_thread_id();
|
||||
let chat = match displayed.and_then(|id| self.side_pair_key(id)) {
|
||||
Some(child) if Some(child) == displayed => TabState::Active,
|
||||
@@ -286,13 +301,16 @@ impl App {
|
||||
&& caller_inset.is_none()
|
||||
&& self.side_retention_enabled(tui) =>
|
||||
{
|
||||
let [strip, body] = side_pane::tab_and_body(screen_size.into());
|
||||
let [strip, body] = side_pane::tab_and_body(content);
|
||||
(Some(body), Some(strip))
|
||||
}
|
||||
None => (None, None),
|
||||
};
|
||||
let mut prepared =
|
||||
self.prepare_conversation(screen_size.into(), caller_inset.or(live), &frames);
|
||||
let mut prepared = self.prepare_conversation(
|
||||
viewport,
|
||||
caller_inset.or(live).or(center.map(|_| content)),
|
||||
&frames,
|
||||
);
|
||||
self.conversation_frame.sidebar = layout;
|
||||
self.conversation_frame.chat_strip = strip;
|
||||
self.conversation_frame.sidebar_input =
|
||||
@@ -300,7 +318,7 @@ impl App {
|
||||
let divider = self.conversation_frame.divider_area();
|
||||
if self.divider_drag.is_some_and(|drag| {
|
||||
divider.is_none()
|
||||
|| !drag.matches(screen_size.into(), self)
|
||||
|| !drag.matches(content, self)
|
||||
|| !self.conversation_focus_available(tui)
|
||||
}) {
|
||||
self.divider_drag = None;
|
||||
@@ -631,6 +649,9 @@ impl App {
|
||||
if let Some(area) = self.hover_target_area(hover_mouse, frame.buffer) {
|
||||
super::link_hover::paint_hover_foreground(area, frame.buffer);
|
||||
}
|
||||
if let Some(center) = center {
|
||||
self.paint_command_center(frame, center, available);
|
||||
}
|
||||
self.paint_centered_dialog(frame);
|
||||
})?;
|
||||
// A shortcut HUD is painted after the conversation and can move over a stationary pointer.
|
||||
@@ -744,6 +765,14 @@ impl App {
|
||||
} else {
|
||||
self.prompt_navigation_footer(area.width.saturating_sub(/*rhs*/ 2))
|
||||
};
|
||||
let unfocused = self.workspace_center_owns_input()
|
||||
|| matches!(
|
||||
self.conversation_frame.sidebar,
|
||||
Some(sidebar::SidebarLayout::Panel {
|
||||
focus: PaneFocus::Sidebar,
|
||||
..
|
||||
})
|
||||
);
|
||||
let chat_widget = &self.chat_widget;
|
||||
let view = &mut self.transcript_view;
|
||||
let active_key = chat_widget.active_cell_transcript_key();
|
||||
@@ -753,13 +782,6 @@ impl App {
|
||||
// which can change the footer hint and the composer's measured height.
|
||||
let footer = view.footer_with_navigation(footer_width, motion, latest_navigation);
|
||||
let max_composer_height = side_pane::composer_height_limit(area.height);
|
||||
let unfocused = matches!(
|
||||
self.conversation_frame.sidebar,
|
||||
Some(sidebar::SidebarLayout::Panel {
|
||||
focus: PaneFocus::Sidebar,
|
||||
..
|
||||
})
|
||||
);
|
||||
let options = |interacting| ComposerRenderOptions {
|
||||
unfocused,
|
||||
max_height: Some(max_composer_height),
|
||||
|
||||
@@ -86,6 +86,7 @@ async fn external_writer_escape_returns_to_command_center_without_editing() -> R
|
||||
(false, false, true),
|
||||
] {
|
||||
let mut app = crate::app::test_support::make_test_app().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
attach_thread(&mut app, ThreadId::new());
|
||||
app.transcript_cells = vec![user_cell("First prompt"), user_cell("Second prompt")];
|
||||
app.app_server_target = AppServerTarget::Remote {
|
||||
@@ -670,11 +671,16 @@ async fn owned_details_keep_the_composer_cursor_and_screen() -> Result<()> {
|
||||
let frames = tui.frame_requester();
|
||||
let mut painted = Default::default();
|
||||
tui.draw(outer.height, |frame| {
|
||||
for cell in &mut frame.buffer.content {
|
||||
cell.set_char('·');
|
||||
// Paint the side margins before the conversation and the rows below it afterward.
|
||||
let viewport = frame.area();
|
||||
for pos in viewport.positions().filter(|pos| pos.y < area.bottom()) {
|
||||
frame.buffer[pos].set_char('·');
|
||||
}
|
||||
let prepared = app.prepare_conversation(frame.area(), Some(area), &frames);
|
||||
let prepared = app.prepare_conversation(viewport, Some(area), &frames);
|
||||
painted = app.paint_conversation(frame, &prepared);
|
||||
for pos in viewport.positions().filter(|pos| pos.y >= area.bottom()) {
|
||||
frame.buffer[pos].set_char('·');
|
||||
}
|
||||
frame
|
||||
.image_placements
|
||||
.push(crate::transcript_image::ImagePlacement {
|
||||
@@ -804,6 +810,18 @@ async fn owned_details_keep_the_composer_cursor_and_screen() -> Result<()> {
|
||||
),
|
||||
(false, true, "preserved draft".to_string()),
|
||||
);
|
||||
// A replacement conversation starts at full width and drops the previous pane's image.
|
||||
let init = app.chatwidget_init_for_forked_or_resumed_thread(
|
||||
&mut tui,
|
||||
app.config.clone(),
|
||||
/*initial_user_message*/ None,
|
||||
);
|
||||
app.replace_chat_widget(ChatWidget::new_with_app_event(init));
|
||||
assert_eq!(
|
||||
app.render_owned_transcript(&mut tui, outer)?.width,
|
||||
outer.width
|
||||
);
|
||||
assert!(presented(&tui).is_empty());
|
||||
tui.set_owned_screen(/*owned*/ false)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -319,14 +319,8 @@ impl App {
|
||||
.selected_index_for_active_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some()
|
||||
|| (self.current_displayed_thread_id().is_none()
|
||||
&& self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some())
|
||||
&& self.overview_selected_index().is_some())
|
||||
{
|
||||
if let Ok(mut state) = self.agents_overview.view_state.lock() {
|
||||
state.connection_notice = Some("Reconnecting — agent list is stale");
|
||||
}
|
||||
ReconnectPresentation::Overview
|
||||
} else {
|
||||
if !self
|
||||
@@ -340,6 +334,12 @@ impl App {
|
||||
}
|
||||
ReconnectPresentation::Conversation
|
||||
};
|
||||
if (self.agents_overview.workspace.is_open()
|
||||
|| self.reconnect.presentation == ReconnectPresentation::Overview)
|
||||
&& let Ok(mut state) = self.agents_overview.view_state.lock()
|
||||
{
|
||||
state.connection_notice = Some("Reconnecting — agent list is stale");
|
||||
}
|
||||
if preserve_startup_input {
|
||||
// Draining admission never reopens. Wait for this connection to close before
|
||||
// reconnecting, then give the ordinary startup path one more attempt.
|
||||
@@ -409,10 +409,7 @@ impl App {
|
||||
archived_thread,
|
||||
} = connected;
|
||||
session.model_provider_override = self.harness_overrides.model_provider.clone();
|
||||
let selected = self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID)
|
||||
.and_then(|index| self.agents_overview.visible_thread_ids.get(index).copied());
|
||||
let selected = self.overview_selected_thread_id();
|
||||
let displayed = self.reconnect_thread_id();
|
||||
let mut input = self.chat_widget.capture_thread_input_state();
|
||||
if let Some(input) = input.as_mut() {
|
||||
@@ -644,7 +641,9 @@ impl App {
|
||||
// A hidden overview performs this discovery when it is next opened.
|
||||
self.reset_agents_overview_discovery(app_server.backend_id());
|
||||
self.backend_registry.connect(app_server);
|
||||
if self.reconnect.presentation == ReconnectPresentation::Overview {
|
||||
if self.agents_overview.workspace.is_open() {
|
||||
self.repaint_agents_overview();
|
||||
} else if self.reconnect.presentation == ReconnectPresentation::Overview {
|
||||
let threads = self
|
||||
.agents_overview
|
||||
.threads
|
||||
@@ -675,7 +674,9 @@ impl App {
|
||||
self.app_event_tx
|
||||
.send(AppEvent::RefreshConfigReasoningSummary);
|
||||
}
|
||||
if self.reconnect.presentation == ReconnectPresentation::Overview {
|
||||
if self.agents_overview.workspace.is_open()
|
||||
|| self.reconnect.presentation == ReconnectPresentation::Overview
|
||||
{
|
||||
self.refresh_agents_overview_threads(app_server);
|
||||
}
|
||||
self.chat_widget.forget_inherited_quota_provider();
|
||||
|
||||
@@ -282,11 +282,7 @@ impl App {
|
||||
if options.cancel == Some(crate::onboarding::TrustCancelAction::CurrentTask) {
|
||||
return Err(AppRunControl::Continue);
|
||||
}
|
||||
if self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_none()
|
||||
{
|
||||
if self.overview_selected_index().is_none() {
|
||||
self.open_agents_overview(app_server);
|
||||
}
|
||||
return Err(AppRunControl::Continue);
|
||||
|
||||
@@ -610,6 +610,7 @@ impl App {
|
||||
mut chat_widget: ChatWidget,
|
||||
thread_provider: Option<&str>,
|
||||
) {
|
||||
self.conversation_frame = Default::default();
|
||||
self.statusline_picker = None;
|
||||
chat_widget.inherit_view_transition_key_guard(&mut self.chat_widget);
|
||||
chat_widget.fork_in_progress = self.chat_widget.fork_in_progress;
|
||||
@@ -1026,6 +1027,7 @@ impl App {
|
||||
.unwrap_or_default();
|
||||
self.apply_session_account(&mut init, account);
|
||||
}
|
||||
let presented = preserve_screen.then(|| std::mem::take(&mut self.conversation_frame));
|
||||
self.replace_chat_widget_for_provider(
|
||||
ChatWidget::new_with_app_event(init),
|
||||
snapshot
|
||||
@@ -1033,6 +1035,9 @@ impl App {
|
||||
.as_ref()
|
||||
.map(|session| session.model_provider_id.as_str()),
|
||||
);
|
||||
if let Some(frame) = presented {
|
||||
self.conversation_frame = frame;
|
||||
}
|
||||
self.chat_widget
|
||||
.set_task_mentions_enabled(app_server.task_tools_available(thread_id));
|
||||
self.chat_widget
|
||||
@@ -1962,6 +1967,9 @@ impl App {
|
||||
self.agents_overview
|
||||
.hidden_threads
|
||||
.remove(&target_session.thread_id);
|
||||
if self.agents_overview.workspace.is_open() {
|
||||
self.focus_workspace_composer(tui);
|
||||
}
|
||||
self.repaint_agents_overview();
|
||||
tui.frame_requester().schedule_frame();
|
||||
return Ok(AppRunControl::Continue);
|
||||
@@ -2191,6 +2199,10 @@ impl App {
|
||||
self.chat_widget
|
||||
.add_info_message(notice.to_string(), /*hint*/ None);
|
||||
}
|
||||
if self.agents_overview.workspace.is_open() {
|
||||
self.focus_workspace_composer(tui);
|
||||
self.repaint_agents_overview();
|
||||
}
|
||||
self.backfill_loaded_subagent_threads(app_server).await;
|
||||
if matches!(
|
||||
self.runtime_approval_policy_override,
|
||||
|
||||
@@ -109,11 +109,9 @@ impl App {
|
||||
{
|
||||
return Ok(AppRunControl::Exit(reason));
|
||||
}
|
||||
if self.active_thread_id == Some(thread_id)
|
||||
&& self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some()
|
||||
if !self.agents_overview.workspace.is_open()
|
||||
&& self.active_thread_id == Some(thread_id)
|
||||
&& self.overview_selected_index().is_some()
|
||||
{
|
||||
if let Ok(mut state) = self.agents_overview.view_state.lock() {
|
||||
state.completion = Some(crate::bottom_pane::ViewCompletion::Accepted);
|
||||
@@ -137,11 +135,7 @@ impl App {
|
||||
}
|
||||
|
||||
pub(super) fn add_session_picker_error(&mut self, message: String) {
|
||||
if self
|
||||
.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some()
|
||||
{
|
||||
if self.overview_selected_index().is_some() {
|
||||
self.chat_widget.show_selection_view(SelectionViewParams {
|
||||
title: Some("Unable to resume session".to_string()),
|
||||
subtitle: Some(message.clone()),
|
||||
|
||||
@@ -108,6 +108,7 @@ fn visible_split(app: &App, tui: &Tui, area: Rect) -> Option<SidebarLayout> {
|
||||
}
|
||||
|
||||
pub(super) fn split_layout(app: &App, tui: &Tui, area: Rect) -> Option<SidebarLayout> {
|
||||
let area = app.workspace_chat_area(area);
|
||||
let content = app.sidebar()?.visible_content()?;
|
||||
if area.width < 100
|
||||
|| app.conversation_frame.has_caller_inset()
|
||||
@@ -250,6 +251,7 @@ impl App {
|
||||
if key.kind == KeyEventKind::Release {
|
||||
return true;
|
||||
}
|
||||
let screen = self.workspace_chat_area(screen);
|
||||
let current = screen.right() - divider.right();
|
||||
let step = match (key.code, key.modifiers) {
|
||||
(KeyCode::Left | KeyCode::Char('h'), KeyModifiers::NONE) => 1,
|
||||
@@ -301,6 +303,7 @@ impl App {
|
||||
100 - focused_percent
|
||||
};
|
||||
// The sidebar gets the spare column when an equal split is odd.
|
||||
let screen = self.workspace_chat_area(screen);
|
||||
let available = u32::from(screen.width - GAP);
|
||||
let preferred = (available * u32::from(side_percent)).div_ceil(100);
|
||||
let width = sidebar_width(preferred as i32, screen.width);
|
||||
@@ -335,7 +338,7 @@ impl App {
|
||||
visible_split(self, tui, screen).and_then(|layout| layout.divider_area())
|
||||
{
|
||||
let current = screen.right() - divider.right();
|
||||
let total = screen.width;
|
||||
let total = self.workspace_chat_area(screen).width;
|
||||
let step = (i32::from(total) * percent.abs() + 50) / 100;
|
||||
let next = sidebar_width(i32::from(current) + step * percent.signum(), total);
|
||||
if next != current {
|
||||
@@ -402,6 +405,7 @@ impl App {
|
||||
let Some(target) = self.sidebar_resize_target() else {
|
||||
return Ok(false);
|
||||
};
|
||||
let screen = self.workspace_chat_area(screen);
|
||||
let width = screen.right() - divider.right();
|
||||
self.divider_drag = Some(DividerDrag {
|
||||
target,
|
||||
@@ -420,10 +424,13 @@ impl App {
|
||||
return Ok(false);
|
||||
};
|
||||
let screen = tui.terminal.last_known_screen_size.into();
|
||||
if drag.matches(screen, self) && visible_split(self, tui, screen).is_some() {
|
||||
if drag.matches(self.workspace_chat_area(screen), self)
|
||||
&& visible_split(self, tui, screen).is_some()
|
||||
{
|
||||
let width = i32::from(drag.initial_width) + i32::from(drag.press)
|
||||
- i32::from(mouse.column);
|
||||
let width = sidebar_width(width, screen.width);
|
||||
let total = drag.screen.width;
|
||||
let width = sidebar_width(width, total);
|
||||
let changed = drag.width != width;
|
||||
drag.width = width;
|
||||
if mouse.kind == Drag(Left) {
|
||||
@@ -434,7 +441,7 @@ impl App {
|
||||
} else if let Some(percent) = drag.percent()
|
||||
&& self.save_sidebar_width(percent).await
|
||||
{
|
||||
self.exact_sidebar_width = Some((screen.width, width));
|
||||
self.exact_sidebar_width = Some((total, width));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
---
|
||||
source: tui/src/app/agent_center_tests.rs
|
||||
expression: "screens.join(\"\\n\\n\")"
|
||||
---
|
||||
Wide Command Center
|
||||
Agent command center Group: Pr… │ Response row 22
|
||||
All 1 Needs you 0 › │ Response row 23
|
||||
──────────────────────────────── │ Response row 24
|
||||
Tasks │ Response row 25
|
||||
Pinned 1 │ Response row 26
|
||||
› ○ Investigate retry │ Response row 27
|
||||
│ Response row 28
|
||||
│ Response row 29
|
||||
│ ↓ Back to bottom · esc
|
||||
│
|
||||
│ › Keep this draft
|
||||
│
|
||||
│ gpt-test default · /tmp/project
|
||||
? help esc back ↑/↓ move ent… │
|
||||
|
||||
Narrow Command Center
|
||||
Agent command center Group: Project g
|
||||
All 1 Needs you 0 Working 0 Ready 1 ›
|
||||
──────────────────────────────────────────────
|
||||
Tasks
|
||||
Pinned 1
|
||||
› ○ Investigate retry again
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
? help esc back ↑/↓ move enter open n new
|
||||
@@ -15,6 +15,16 @@ use codex_models_manager::test_support::get_model_offline_for_tests;
|
||||
pub(crate) use super::cloud_switch_wait::ClipboardHandoff;
|
||||
pub(crate) use super::cloud_switch_wait::wait_for_cloud_switch;
|
||||
|
||||
/// Opt in to testing the original Command Center modal through the chat widget.
|
||||
pub(super) fn use_modal_agents_overview(app: &mut App) {
|
||||
app.config
|
||||
.features
|
||||
.disable(Feature::TuiWorkspace)
|
||||
.expect("disable TUI workspace for the modal fixture");
|
||||
app.cli_kv_overrides
|
||||
.push(("features.tui_workspace".to_owned(), false.into()));
|
||||
}
|
||||
|
||||
pub(super) fn enable_side_retention(app: &mut App) -> Result<()> {
|
||||
app.config.features.enable(Feature::TuiWorkspace)?;
|
||||
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
|
||||
|
||||
@@ -41,7 +41,7 @@ async fn agents_navigation_opens_the_command_center_on_every_target() -> Result<
|
||||
let event = events.try_recv()?;
|
||||
assert_matches!(event, AppEvent::OpenAgentsOverview);
|
||||
app.handle_event(&mut tui, &mut app_server, event).await?;
|
||||
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
|
||||
assert!(app.agents_overview_has_focus());
|
||||
app_server.shutdown().await?;
|
||||
}
|
||||
Ok(())
|
||||
@@ -50,6 +50,7 @@ async fn agents_navigation_opens_the_command_center_on_every_target() -> Result<
|
||||
#[tokio::test]
|
||||
async fn externally_archived_thread_keeps_advertised_agents_navigation() -> Result<()> {
|
||||
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
let mut app_server = start_config_write_test_app_server(&app).await?;
|
||||
app.app_server_target = AppServerTarget::LocalDaemon {
|
||||
@@ -167,7 +168,7 @@ async fn provider_error_opens_command_center_with_left() -> Result<()> {
|
||||
TuiEvent::Key(KeyCode::Left.into()),
|
||||
)
|
||||
.await?;
|
||||
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
|
||||
assert!(app.agents_overview_has_focus());
|
||||
assert_eq!(
|
||||
app.chat_widget.composer_text_with_pending(),
|
||||
"Retained draft"
|
||||
|
||||
@@ -165,11 +165,7 @@ async fn external_writer_view_opens_agents_with_left() -> Result<()> {
|
||||
)
|
||||
.await?;
|
||||
|
||||
assert!(
|
||||
app.chat_widget
|
||||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||||
.is_some()
|
||||
);
|
||||
assert!(app.agents_overview_has_focus());
|
||||
assert_eq!(
|
||||
app.chat_widget.composer_text_with_pending(),
|
||||
"Retained draft"
|
||||
|
||||
@@ -28,6 +28,7 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv
|
||||
(Some(ThreadId::new()), true, true),
|
||||
] {
|
||||
let (mut app, mut events, _) = make_test_app_with_channels().await;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
app.keymap.app.open_agents = vec![crate::key_hint::alt(KeyCode::Char('a'))];
|
||||
let child = ThreadId::new();
|
||||
let child_recap = recap::RecapProgress {
|
||||
|
||||
@@ -1283,11 +1283,16 @@ async fn resumed_backend_handoff_detaches_through_the_source_connection() -> Res
|
||||
cwd: Some(resumed.session.cwd.to_path_buf()),
|
||||
history_mode: None,
|
||||
};
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
tui.set_owned_screen(/*owned*/ true)?;
|
||||
app.local_settings.transcript_mode = tui.transcript_mode();
|
||||
app.config.features.enable(Feature::TuiWorkspace)?;
|
||||
app.open_agents_overview(&source);
|
||||
assert!(app.workspace_center_owns_input());
|
||||
let mut backends = BackendSessions::from_initial(source, vec![destination]);
|
||||
backends
|
||||
.settings
|
||||
.insert(destination_id, app.backend_settings());
|
||||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||||
let mut stale_input = app.chat_widget.capture_thread_input_state().unwrap();
|
||||
stale_input.provider_error = Some(
|
||||
codex_app_server_protocol::ModelProviderError::ModelProviderNotConfigured {
|
||||
@@ -1304,6 +1309,8 @@ async fn resumed_backend_handoff_detaches_through_the_source_connection() -> Res
|
||||
app.resume_backend_session(&mut tui, &mut backends, target)
|
||||
.await?;
|
||||
|
||||
assert!(app.agents_overview.workspace.is_open());
|
||||
assert!(!app.workspace_center_owns_input());
|
||||
assert_eq!(backends.displayed_owner(), destination_id);
|
||||
assert_eq!(app.chat_widget.thread_id(), Some(resumed_id));
|
||||
assert!(!app.chat_widget.has_provider_error());
|
||||
|
||||
@@ -2360,7 +2360,7 @@ async fn delete_current_thread_navigates_only_after_success() -> Result<()> {
|
||||
app.chat_widget.composer_text_with_pending(),
|
||||
"Retained on failure"
|
||||
);
|
||||
assert!(!app.chat_widget.has_active_view());
|
||||
assert!(!app.agents_overview_has_focus());
|
||||
|
||||
let resumed = server
|
||||
.resume_thread(
|
||||
@@ -2413,7 +2413,7 @@ async fn delete_current_thread_navigates_only_after_success() -> Result<()> {
|
||||
);
|
||||
assert_eq!(app.active_thread_id, Some(thread_id));
|
||||
assert!(app.side_threads.contains_key(&side_id));
|
||||
assert!(!app.chat_widget.has_active_view());
|
||||
assert!(!app.agents_overview_has_focus());
|
||||
assert_eq!(recorded_params(&requests, "thread/delete").len(), 1);
|
||||
let (tx, mut events) = tokio::sync::mpsc::unbounded_channel();
|
||||
app.app_event_tx = AppEventSender::new(tx);
|
||||
@@ -2454,7 +2454,7 @@ async fn delete_current_thread_navigates_only_after_success() -> Result<()> {
|
||||
(None, None, None)
|
||||
);
|
||||
assert!(app.chat_widget.composer_is_empty());
|
||||
assert!(app.chat_widget.has_active_view());
|
||||
assert!(app.agents_overview_has_focus());
|
||||
assert_eq!(
|
||||
recorded_params(&requests, "thread/delete"),
|
||||
vec![
|
||||
@@ -2626,7 +2626,7 @@ async fn embedded_archive_completes_after_opening_command_center() -> Result<()>
|
||||
let (_tx, mut events) = tokio::sync::mpsc::unbounded_channel();
|
||||
app.active_thread_id = Some(thread_id);
|
||||
Box::pin(app.archive_current_thread(&mut tui, &mut server)).await?;
|
||||
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
|
||||
assert!(app.agents_overview_has_focus());
|
||||
assert_matches!(
|
||||
app.saved_openings.next_event(&mut events).await,
|
||||
Some(AppEvent::ArchiveFinished { thread_id: id, result: Ok(()), .. }) if id == thread_id
|
||||
@@ -2694,7 +2694,7 @@ async fn archive_opens_command_center_before_the_server_replies() -> Result<()>
|
||||
.expect("the confirmation must not wait for the archive RPC")?,
|
||||
AppRunControl::Continue
|
||||
);
|
||||
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
|
||||
assert!(app.agents_overview_has_focus());
|
||||
assert_eq!(app.current_displayed_thread_id(), None);
|
||||
assert_eq!(app.agents_overview.visible_thread_ids, [other_id]);
|
||||
assert_eq!(
|
||||
@@ -2990,13 +2990,7 @@ async fn archive_current_thread_returns_to_agents() -> Result<()> {
|
||||
recorded_params(&requests, "thread/archive"),
|
||||
vec![serde_json::json!({"threadId": thread_id.to_string()})]
|
||||
);
|
||||
assert!(
|
||||
app.chat_widget
|
||||
.selected_index_for_present_view(
|
||||
crate::app::agents_overview::AGENTS_OVERVIEW_VIEW_ID
|
||||
)
|
||||
.is_some()
|
||||
);
|
||||
assert!(app.agents_overview_has_focus());
|
||||
server.shutdown().await?;
|
||||
proxy.await??;
|
||||
}
|
||||
@@ -6844,6 +6838,7 @@ async fn external_writer_escape_preserves_snapshot_and_explicit_quits() -> Resul
|
||||
AppServerTarget::Remote { endpoint },
|
||||
] {
|
||||
let (mut app, _codex_home) = make_history_test_app().await?;
|
||||
crate::app::test_support::use_modal_agents_overview(&mut app);
|
||||
let thread_id =
|
||||
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "owned elsewhere")?;
|
||||
let (mut server, requests, proxy) = start_recording_app_server(
|
||||
|
||||
Reference in New Issue
Block a user