mirror of
https://github.com/openai/codex.git
synced 2026-11-19 23:05:23 +00:00
## Why Resume and fork selection can change the working directory. Folder consent needs to cover the selected destination, and existing tasks in untrusted folders may retain settings and history loaded while trusted. ## What changed - Move startup consent after destination selection and reload local configuration when trust is saved. - Check both selected and saved folders for local daemon resumes, and reread the task after consent to catch working directory changes. - Resolve local trust using project markers, Git roots, and normalized paths, honoring explicit working directory decisions and canonical path precedence. - Offer restricted-folder consent without changing saved trust, with distinct wording for existing tasks that may retain configuration or hooks. Preserve remote checks scoped to explicit `--cd`. ## Testing Extend trust lookup coverage for parent/child decisions, repositories without project configuration, path aliases, and custom project markers. Update restricted-folder snapshots and add an existing-task snapshot. GitOrigin-RevId: caf8c70f1e953c4f7b4ddc89dd29bb1fd8ed62f1
2656 lines
104 KiB
Rust
2656 lines
104 KiB
Rust
use super::*;
|
||
|
||
#[tokio::test]
|
||
async fn older_server_notice_is_visible_in_agents_overview() {
|
||
let mut app = make_test_app().await;
|
||
app.update_server_version_overview_notice("0.153.0", Some("0.152.1"));
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 80);
|
||
insta::assert_snapshot!(rendered.lines().take(2).collect::<Vec<_>>().join("\n"));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn server_version_overview_notice_updates_and_clears() {
|
||
let mut app = make_test_app().await;
|
||
app.update_server_version_overview_notice("0.153.0", Some("0.152.1"));
|
||
app.update_server_version_overview_notice("0.153.0", Some("0.151.0"));
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 80);
|
||
insta::assert_snapshot!(rendered.lines().take(2).collect::<Vec<_>>().join("\n"), @" Service v0.151.0 < Codex CLI v0.153.0
|
||
0 need input 0 working 0 ready");
|
||
|
||
app.update_server_version_overview_notice("0.153.0", /*older_server*/ None);
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 80);
|
||
insta::assert_snapshot!(rendered.lines().take(2).collect::<Vec<_>>().join("\n"), @" Agent command center
|
||
0 need input 0 working 0 ready");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn older_server_notice_wraps_in_narrow_overview() {
|
||
let mut app = make_test_app().await;
|
||
app.update_server_version_overview_notice("0.153.0", Some("0.152.1"));
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
insta::assert_snapshot!(
|
||
"older_server_narrow_overview",
|
||
render_bottom_popup(&app.chat_widget, /*width*/ 12)
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn older_server_notice_falls_back_in_short_overview() {
|
||
let mut app = make_test_app().await;
|
||
app.update_server_version_overview_notice("0.153.0", Some("0.152.1"));
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
let area = ratatui::layout::Rect::new(
|
||
/*x*/ 0, /*y*/ 0, /*width*/ 24, /*height*/ 8,
|
||
);
|
||
let mut buffer = ratatui::buffer::Buffer::empty(area);
|
||
view.render(area, &mut buffer);
|
||
let header = buffer
|
||
.content()
|
||
.iter()
|
||
.take(usize::from(area.width))
|
||
.map(ratatui::buffer::Cell::symbol)
|
||
.collect::<String>();
|
||
insta::assert_snapshot!(header.trim_end(), @" Old srv");
|
||
}
|
||
use crate::app::agents_overview_view::AgentsOverviewFocus;
|
||
use crate::app::test_support::make_test_app;
|
||
use crate::app_event::AgentsOverviewThreadRefresh;
|
||
use crate::bottom_pane::BottomPaneView;
|
||
use crate::bottom_pane::CancellationEvent;
|
||
use crate::chatwidget::tests::helpers::render_bottom_popup;
|
||
use crate::render::renderable::Renderable;
|
||
use crate::test_support::PathBufExt;
|
||
use crate::test_support::test_path_buf;
|
||
use crate::test_support::test_path_display;
|
||
use codex_app_server_client::AppServerEvent;
|
||
use codex_app_server_protocol::CurrentTimeReadParams;
|
||
use codex_app_server_protocol::ReasoningSummaryTextDeltaNotification;
|
||
use codex_app_server_protocol::ServerRequest;
|
||
use codex_app_server_protocol::SessionSource;
|
||
use codex_app_server_protocol::ThreadActiveFlag;
|
||
use codex_app_server_protocol::ThreadArchivedNotification;
|
||
use codex_app_server_protocol::ThreadClosedNotification;
|
||
use codex_app_server_protocol::ThreadDeletedNotification;
|
||
use codex_app_server_protocol::ThreadNameUpdatedNotification;
|
||
use codex_app_server_protocol::ThreadSource;
|
||
use codex_app_server_protocol::ThreadStartedNotification;
|
||
use codex_app_server_protocol::ThreadStatus;
|
||
use codex_app_server_protocol::ThreadUnsubscribeParams;
|
||
use codex_app_server_protocol::ThreadUnsubscribeResponse;
|
||
use codex_app_server_protocol::ThreadUnsubscribeStatus;
|
||
use codex_app_server_protocol::ToolRequestUserInputParams;
|
||
use codex_app_server_protocol::ToolRequestUserInputQuestion;
|
||
use codex_config::types::KeybindingSpec;
|
||
use codex_config::types::KeybindingsSpec;
|
||
use codex_config::types::TuiKeymap;
|
||
use codex_protocol::models::PermissionProfile;
|
||
use codex_protocol::protocol::SubAgentSource;
|
||
use crossterm::cursor::SetCursorStyle;
|
||
use pretty_assertions::assert_eq;
|
||
use ratatui::Terminal;
|
||
use ratatui::backend::TestBackend;
|
||
use ratatui::layout::Rect;
|
||
|
||
static OVERVIEW_TIMESTAMP: std::sync::LazyLock<i64> =
|
||
std::sync::LazyLock::new(|| chrono::Utc::now().timestamp() - 120);
|
||
|
||
fn overview_draft(app: &App) -> (String, usize) {
|
||
let state = app.agents_overview.view_state.lock().unwrap();
|
||
let composer = state.composer.as_ref().unwrap();
|
||
(composer.current_text_with_pending(), composer.cursor())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_escape_returns_from_list_to_composer() {
|
||
for (vim, offline) in [(false, false), (true, false), (false, true), (true, true)] {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = true;
|
||
if vim {
|
||
app.chat_widget.toggle_vim_mode_and_notify();
|
||
}
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
let view = app.agents_overview_view(
|
||
vec![overview_thread(
|
||
ThreadId::new(),
|
||
/*parent_thread_id*/ None,
|
||
"Existing task",
|
||
ThreadStatus::Idle,
|
||
)],
|
||
/*selected_thread_id*/ None,
|
||
);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
app.chat_widget.handle_paste("task draft".into());
|
||
app.chat_widget.handle_key_event(KeyCode::Home.into());
|
||
let draft = overview_draft(&app);
|
||
if offline {
|
||
app.agents_overview
|
||
.view_state
|
||
.lock()
|
||
.unwrap()
|
||
.connection_notice = Some("Reconnecting");
|
||
}
|
||
if vim {
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
}
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
assert!(matches!(
|
||
app.agents_overview.view_state.lock().unwrap().focus,
|
||
AgentsOverviewFocus::List
|
||
));
|
||
app.chat_widget.handle_key_event(KeyCode::Down.into());
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
|
||
assert!(matches!(
|
||
app.agents_overview.view_state.lock().unwrap().focus,
|
||
AgentsOverviewFocus::Composer
|
||
));
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID),
|
||
Some(0)
|
||
);
|
||
assert_eq!(overview_draft(&app), draft);
|
||
assert!(rx.try_recv().is_err());
|
||
if !vim && !offline {
|
||
insta::assert_snapshot!(render_bottom_popup(&app.chat_widget, /*width*/ 80).lines().last().unwrap(), @" enter create task ctrl+j newline esc tasks");
|
||
}
|
||
app.chat_widget.handle_key_event(KeyCode::Char('!').into());
|
||
assert_eq!(overview_draft(&app).0, "!task draft");
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_right_opens_current_or_highlighted_task() {
|
||
let mut app = make_test_app().await;
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
let current = ThreadId::new();
|
||
let other = ThreadId::new();
|
||
app.primary_thread_id = Some(current);
|
||
let threads = vec![
|
||
overview_thread(
|
||
current,
|
||
/*parent_thread_id*/ None,
|
||
"Current",
|
||
ThreadStatus::Idle,
|
||
),
|
||
overview_thread(
|
||
other,
|
||
/*parent_thread_id*/ None,
|
||
"Other",
|
||
ThreadStatus::Idle,
|
||
),
|
||
];
|
||
|
||
let view = app.agents_overview_view(threads.clone(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
insta::assert_snapshot!(
|
||
"overview_empty_prompt_right_hint",
|
||
rendered.lines().last().unwrap()
|
||
);
|
||
app.chat_widget.handle_key_event(KeyCode::Right.into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::SelectAgentsOverviewThread { thread_id }) if thread_id == current)
|
||
);
|
||
assert!(!app.chat_widget.no_modal_or_popup_active());
|
||
|
||
let mut view = app.agents_overview_view(threads, /*selected_thread_id*/ None);
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_key_event(KeyCode::Down.into());
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
insta::assert_snapshot!(
|
||
"overview_right_open_hint",
|
||
rendered.lines().find(|line| line.contains("open")).unwrap()
|
||
);
|
||
app.chat_widget.handle_key_event(KeyCode::Right.into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::SelectAgentsOverviewThread { thread_id }) if thread_id == other)
|
||
);
|
||
assert!(!app.chat_widget.no_modal_or_popup_active());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_right_preserves_editors_and_offline_state() {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = true;
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
let thread_id = ThreadId::new();
|
||
let mut view = app.agents_overview_view(
|
||
vec![overview_thread(
|
||
thread_id,
|
||
/*parent_thread_id*/ None,
|
||
"Task",
|
||
ThreadStatus::Idle,
|
||
)],
|
||
Some(thread_id),
|
||
);
|
||
view.handle_paste("ab".into());
|
||
view.handle_key_event(KeyCode::Home.into());
|
||
view.handle_key_event(KeyCode::Right.into());
|
||
assert_eq!(overview_draft(&app), ("ab".into(), 1));
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));
|
||
view.handle_key_event(KeyCode::Right.into());
|
||
assert!(app.agents_overview.view_state.lock().unwrap().renaming);
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
app.agents_overview
|
||
.view_state
|
||
.lock()
|
||
.unwrap()
|
||
.connection_notice = Some("Offline");
|
||
view.handle_key_event(KeyCode::Right.into());
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL));
|
||
view.on_ctrl_c();
|
||
view.handle_key_event(KeyCode::Right.into());
|
||
assert!(!view.is_complete());
|
||
assert!(rx.try_recv().is_err());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_open_preserves_draft_and_uses_requested_focus() -> Result<()> {
|
||
for vim in [false, true] {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = true;
|
||
if vim {
|
||
app.chat_widget.toggle_vim_mode_and_notify();
|
||
}
|
||
let server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
app.app_server_target = AppServerTarget::LocalDaemon {
|
||
endpoint: crate::RemoteAppServerEndpoint::UnixSocket {
|
||
socket_path: test_path_buf("/tmp/unused.sock").abs(),
|
||
},
|
||
};
|
||
for (id, title) in [(1, "First task"), (2, "Second task")] {
|
||
let id = ThreadId::from_u128(id);
|
||
app.agents_overview.threads.insert(
|
||
id,
|
||
Some(overview_thread(
|
||
id,
|
||
/*parent_thread_id*/ None,
|
||
title,
|
||
ThreadStatus::Idle,
|
||
)),
|
||
);
|
||
}
|
||
app.open_agents_overview(&server, AgentsOverviewFocus::Composer);
|
||
assert!(matches!(
|
||
app.agents_overview.view_state.lock().unwrap().focus,
|
||
AgentsOverviewFocus::Composer
|
||
));
|
||
app.chat_widget.handle_paste("Unsent draft".into());
|
||
let draft = overview_draft(&app);
|
||
|
||
app.open_agents_overview(&server, AgentsOverviewFocus::List);
|
||
app.repaint_agents_overview();
|
||
let down = if vim {
|
||
KeyCode::Char('j')
|
||
} else {
|
||
KeyCode::Down
|
||
};
|
||
app.chat_widget.handle_key_event(down.into());
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID),
|
||
Some(1)
|
||
);
|
||
assert_eq!(overview_draft(&app), draft);
|
||
if !vim {
|
||
let project = test_path_display("/tmp/project");
|
||
let group = format!(
|
||
"/tmp/project 2{}",
|
||
" ".repeat(project.len().saturating_sub("/tmp/project".len()))
|
||
);
|
||
insta::assert_snapshot!(
|
||
"overview_reopened_with_list_focus",
|
||
render_bottom_popup(&app.chat_widget, /*width*/ 96)
|
||
.replace(&format!("{project} 2"), &group)
|
||
.replace(&project, "/tmp/project")
|
||
.replace("fwd del", "del")
|
||
);
|
||
}
|
||
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL));
|
||
app.repaint_agents_overview();
|
||
app.chat_widget.handle_key_event(KeyCode::Left.into());
|
||
assert_eq!(overview_draft(&app), (draft.0, draft.1 - 1));
|
||
|
||
app.agents_overview.threads.clear();
|
||
app.open_agents_overview(&server, AgentsOverviewFocus::List);
|
||
assert!(matches!(
|
||
app.agents_overview.view_state.lock().unwrap().focus,
|
||
AgentsOverviewFocus::List
|
||
));
|
||
app.agents_overview.initialized = true;
|
||
let pending = ThreadId::new();
|
||
app.agents_overview.threads.insert(pending, None);
|
||
app.repaint_agents_overview();
|
||
assert!(matches!(
|
||
app.agents_overview.view_state.lock().unwrap().focus,
|
||
AgentsOverviewFocus::List
|
||
));
|
||
app.agents_overview.threads.clear();
|
||
app.repaint_agents_overview();
|
||
app.chat_widget.handle_key_event(KeyCode::Char('x').into());
|
||
assert_eq!(overview_draft(&app), ("Unsent drafxt".into(), 12));
|
||
server.shutdown().await?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_composer_preserves_editing_and_routes_focus() {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = true;
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
let thread_id = ThreadId::new();
|
||
let threads = vec![overview_thread(
|
||
thread_id,
|
||
/*parent_thread_id*/ None,
|
||
"Existing task",
|
||
ThreadStatus::Idle,
|
||
)];
|
||
let mut view = app.agents_overview_view(threads.clone(), Some(thread_id));
|
||
view.handle_paste(" /first @file $skill\nthird \t".into());
|
||
view.handle_key_event(KeyCode::Home.into());
|
||
view.handle_paste("!second\n".into());
|
||
let expected = overview_draft(&app);
|
||
assert_eq!(
|
||
expected,
|
||
(" /first @file $skill\n!second\nthird \t".into(), 32)
|
||
);
|
||
view = app.agents_overview_view(threads.clone(), Some(thread_id));
|
||
assert_eq!(overview_draft(&app), expected);
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));
|
||
assert_eq!(view.on_ctrl_c(), CancellationEvent::Handled);
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));
|
||
view.handle_paste(" renamed".into());
|
||
view.handle_key_event(KeyCode::Enter.into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::RenameAgentsOverviewThread { name, .. }) if name == "Existing task renamed")
|
||
);
|
||
view = app.agents_overview_view(threads, Some(thread_id));
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL));
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_key_event(KeyCode::Tab.into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::DispatchAgentsOverviewTask { prompt, .. }) if prompt.text == expected.0)
|
||
);
|
||
view.handle_key_event(KeyCode::Up.into());
|
||
assert_eq!(overview_draft(&app).0, expected.0);
|
||
assert_eq!(view.on_ctrl_c(), CancellationEvent::Handled);
|
||
view.handle_paste(" \t\n".into());
|
||
view.handle_key_event(KeyCode::Enter.into());
|
||
assert!(rx.try_recv().is_err());
|
||
assert_eq!(view.on_ctrl_c(), CancellationEvent::Handled);
|
||
let mut server = crate::start_embedded_app_server_for_picker(&app.config)
|
||
.await
|
||
.unwrap();
|
||
app.cli_kv_overrides = vec![("model".into(), toml::Value::Integer(1))];
|
||
app.dispatch_agents_overview_task(&mut server, "retry me".into(), Some(app.config.cwd.clone()))
|
||
.await;
|
||
view.handle_paste(" later".into());
|
||
app.submit_agents_overview_prompt(&server, thread_id, "older failure".into(), Vec::new())
|
||
.await;
|
||
assert_eq!(overview_draft(&app).0, "retry me later");
|
||
server.shutdown().await.unwrap();
|
||
while rx.try_recv().is_ok() {}
|
||
view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
view.handle_paste(format!(
|
||
"x{}",
|
||
" ".repeat(codex_protocol::user_input::MAX_USER_INPUT_TEXT_CHARS)
|
||
));
|
||
view.handle_key_event(KeyCode::Enter.into());
|
||
assert!(matches!(rx.try_recv(), Ok(AppEvent::InsertHistoryCell(_))));
|
||
assert!(view.next_frame_delay().is_some());
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
insta::assert_snapshot!(render_bottom_popup(&app.chat_widget, /*width*/ 80).lines().last().unwrap(), @" Message too long; limit 1048576 characters");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_composer_preserves_pastes_and_editor_bindings() {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = true;
|
||
app.chat_widget.toggle_vim_mode_and_notify();
|
||
let mut keymap = TuiKeymap::default();
|
||
keymap.composer.submit = Some(KeybindingsSpec::One(KeybindingSpec("f8".to_string())));
|
||
keymap.editor.insert_newline = Some(KeybindingsSpec::One(KeybindingSpec("f7".to_string())));
|
||
app.keymap = RuntimeKeymap::from_config(&keymap).unwrap();
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
let mut view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
let pasted = "long paste ".repeat(/*n*/ 200);
|
||
view.handle_paste(pasted.clone());
|
||
view.handle_key_event(KeyCode::F(7).into());
|
||
view.handle_paste("last line".into());
|
||
view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
let area = Rect::new(
|
||
/*x*/ 0, /*y*/ 0, /*width*/ 60, /*height*/ 24,
|
||
);
|
||
let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
|
||
terminal
|
||
.draw(|frame| view.render(frame.area(), frame.buffer_mut()))
|
||
.unwrap();
|
||
insta::assert_snapshot!(terminal.backend().to_string().lines().last().unwrap(), @r#"" f8 create task f7 newline esc esc tasks ""#);
|
||
assert_eq!(view.cursor_style(area), SetCursorStyle::SteadyBar);
|
||
view.handle_key_event(KeyCode::Home.into());
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
assert_eq!(view.cursor_style(area), SetCursorStyle::DefaultUserShape);
|
||
view.handle_key_event(KeyCode::Char('d').into());
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
assert!(view.cursor_pos(area).is_some());
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
assert_eq!(view.cursor_pos(area), None);
|
||
view.handle_key_event(KeyCode::Char('x').into());
|
||
assert_eq!(view.cursor_pos(area), None);
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL));
|
||
assert_eq!(view.cursor_style(area), SetCursorStyle::SteadyBar);
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_paste("abc".into());
|
||
view.handle_key_event(KeyCode::Char('x').into());
|
||
view.handle_key_event(KeyCode::F(8).into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::DispatchAgentsOverviewTask { prompt, .. }) if prompt.text == format!("{pasted}\nabcxlast line"))
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_composer_flushes_pending_typing_after_refresh() {
|
||
for disable_paste_burst in [false, true] {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = false;
|
||
let mut view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
view.handle_key_event(KeyCode::Char('x').into());
|
||
app.config.disable_paste_burst = disable_paste_burst;
|
||
if !disable_paste_burst {
|
||
app.chat_widget.toggle_vim_mode_and_notify();
|
||
}
|
||
view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
assert_eq!(overview_draft(&app).0, "x");
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
if !disable_paste_burst {
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
}
|
||
assert_eq!(view.on_ctrl_c(), CancellationEvent::Handled);
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL));
|
||
view.handle_key_event(KeyCode::Up.into());
|
||
assert_eq!(overview_draft(&app).0, "x");
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn offline_overview_preserves_unbracketed_paste_newlines() {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = false;
|
||
let mut view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.agents_overview
|
||
.view_state
|
||
.lock()
|
||
.unwrap()
|
||
.connection_notice = Some("Reconnecting");
|
||
for ch in "a\nbc\nd".chars() {
|
||
view.handle_key_event(
|
||
if ch == '\n' {
|
||
KeyCode::Enter
|
||
} else {
|
||
KeyCode::Char(ch)
|
||
}
|
||
.into(),
|
||
);
|
||
}
|
||
view.handle_key_event(KeyCode::Tab.into());
|
||
assert_eq!(view.on_ctrl_c(), CancellationEvent::Handled);
|
||
view.handle_key_event(KeyCode::Up.into());
|
||
view.handle_key_event(KeyCode::Enter.into());
|
||
assert_eq!(overview_draft(&app).0, "a\nbc\nd");
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
insta::assert_snapshot!(render_bottom_popup(&app.chat_widget, /*width*/ 80).lines().last().unwrap(), @" ctrl+c clear input, then quit · actions paused until the list is refreshed");
|
||
}
|
||
|
||
fn overview_thread(
|
||
thread_id: ThreadId,
|
||
parent_thread_id: Option<ThreadId>,
|
||
name: &str,
|
||
status: ThreadStatus,
|
||
) -> Thread {
|
||
Thread {
|
||
originator: None,
|
||
environments: None,
|
||
id: thread_id.to_string(),
|
||
extra: None,
|
||
project_id: None,
|
||
daybreak_enabled: None,
|
||
session_id: parent_thread_id.unwrap_or(thread_id).to_string(),
|
||
forked_from_id: None,
|
||
parent_thread_id: None,
|
||
preview: name.to_string(),
|
||
ephemeral: false,
|
||
section: None,
|
||
section_entered_at: None,
|
||
history_mode: Default::default(),
|
||
model_provider: "openai".to_string(),
|
||
model: None,
|
||
reasoning_effort: None,
|
||
created_at: *OVERVIEW_TIMESTAMP,
|
||
updated_at: *OVERVIEW_TIMESTAMP,
|
||
recency_at: Some(*OVERVIEW_TIMESTAMP),
|
||
status,
|
||
path: None,
|
||
cwd: test_path_buf("/tmp/project").abs(),
|
||
cli_version: "0.0.0".to_string(),
|
||
source: parent_thread_id.map_or(SessionSource::Cli, |parent_thread_id| {
|
||
SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
|
||
parent_thread_id,
|
||
depth: 1,
|
||
agent_path: None,
|
||
agent_nickname: None,
|
||
agent_role: None,
|
||
})
|
||
}),
|
||
can_accept_direct_input: Some(parent_thread_id.is_none()),
|
||
thread_source: None,
|
||
agent_nickname: None,
|
||
agent_role: None,
|
||
git_info: None,
|
||
name: Some(name.to_string()),
|
||
turns: Vec::new(),
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let [retained, archived, deleted, created] = std::array::from_fn(|_| ThreadId::new());
|
||
let [
|
||
mut retained_thread,
|
||
archived_thread,
|
||
deleted_thread,
|
||
created_thread,
|
||
] = [
|
||
(retained, "Old name"),
|
||
(archived, "Archived"),
|
||
(deleted, "Deleted"),
|
||
(created, "Created in another client"),
|
||
]
|
||
.map(|(id, name)| {
|
||
overview_thread(id, /*parent_thread_id*/ None, name, ThreadStatus::Idle)
|
||
});
|
||
let request_id = Uuid::new_v4();
|
||
app.agents_overview.request_id = Some(request_id);
|
||
// The seed is still in flight and the command center has never been opened.
|
||
for notification in [
|
||
ServerNotification::ThreadStarted(ThreadStartedNotification {
|
||
thread: created_thread.clone(),
|
||
}),
|
||
ServerNotification::ThreadNameUpdated(ThreadNameUpdatedNotification {
|
||
thread_id: retained.to_string(),
|
||
thread_name: Some("New name".to_string()),
|
||
}),
|
||
ServerNotification::ThreadClosed(ThreadClosedNotification {
|
||
thread_id: retained.to_string(),
|
||
}),
|
||
ServerNotification::ThreadArchived(ThreadArchivedNotification {
|
||
thread_id: archived.to_string(),
|
||
}),
|
||
ServerNotification::ThreadDeleted(ThreadDeletedNotification {
|
||
thread_id: deleted.to_string(),
|
||
}),
|
||
] {
|
||
app.handle_app_server_event(
|
||
&app_server,
|
||
AppServerEvent::ServerNotification(Box::new(notification)),
|
||
)
|
||
.await;
|
||
}
|
||
app.apply_agents_overview_thread_refresh(
|
||
&app_server,
|
||
request_id,
|
||
Ok(AgentsOverviewThreadRefresh {
|
||
last_messages: HashMap::new(),
|
||
threads: HashMap::from([
|
||
(retained, Some(retained_thread.clone())),
|
||
(archived, Some(archived_thread)),
|
||
(deleted, Some(deleted_thread)),
|
||
]),
|
||
recent_seed_complete: true,
|
||
}),
|
||
);
|
||
retained_thread.name = Some("New name".to_string());
|
||
retained_thread.status = ThreadStatus::NotLoaded;
|
||
let expected = HashMap::from([
|
||
(retained, Some(retained_thread)),
|
||
(created, Some(created_thread)),
|
||
]);
|
||
assert_eq!(app.agents_overview.threads, expected);
|
||
|
||
let request_id = Uuid::new_v4();
|
||
app.agents_overview.request_id = Some(request_id);
|
||
app.apply_agents_overview_thread_refresh(
|
||
&app_server,
|
||
request_id,
|
||
Ok(AgentsOverviewThreadRefresh {
|
||
last_messages: HashMap::new(),
|
||
threads: HashMap::from([(retained, None)]),
|
||
recent_seed_complete: true,
|
||
}),
|
||
);
|
||
assert_eq!(app.agents_overview.threads, expected);
|
||
let request_id = Uuid::new_v4();
|
||
app.agents_overview.request_id = Some(request_id);
|
||
app.apply_agents_overview_thread_refresh(
|
||
&app_server,
|
||
request_id,
|
||
Err("temporarily unavailable".to_string()),
|
||
);
|
||
assert_eq!(app.agents_overview.threads, expected);
|
||
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let stale_messages = HashMap::from([(retained, "Removed answer".into())]);
|
||
for event in [
|
||
AppServerEvent::ServerNotification(Box::new(ServerNotification::ThreadReverted(
|
||
codex_app_server_protocol::ThreadRevertedNotification {
|
||
thread_id: retained.to_string(),
|
||
},
|
||
))),
|
||
AppServerEvent::Lagged { skipped: 1 },
|
||
] {
|
||
let old_request = Uuid::new_v4();
|
||
app.agents_overview.request_id = Some(old_request);
|
||
app.agents_overview.activity.entry(retained).or_default();
|
||
app.agents_overview.last_messages = stale_messages.clone();
|
||
app.handle_app_server_event(&app_server, event).await;
|
||
assert!(!app.agents_overview.activity.contains_key(&retained));
|
||
assert!(app.agents_overview.last_messages.is_empty());
|
||
// Fresh activity must survive an older read arriving after invalidation.
|
||
app.track_agents_overview_notification(&reasoning_delta(
|
||
retained,
|
||
"new-reasoning",
|
||
"**Checking the revised task**",
|
||
));
|
||
let current_request = app.agents_overview.request_id.unwrap();
|
||
for (request_id, last_messages) in [
|
||
(old_request, stale_messages.clone()),
|
||
(current_request, HashMap::new()),
|
||
] {
|
||
app.apply_agents_overview_thread_refresh(
|
||
&app_server,
|
||
request_id,
|
||
Ok(AgentsOverviewThreadRefresh {
|
||
threads: HashMap::new(),
|
||
last_messages,
|
||
recent_seed_complete: true,
|
||
}),
|
||
);
|
||
assert!(app.agents_overview.last_messages.is_empty());
|
||
}
|
||
assert!(app.agents_overview.activity.contains_key(&retained));
|
||
assert!(app.agents_overview.request_id.is_none());
|
||
}
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[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;
|
||
trust_fixture_folders(&mut app);
|
||
let mut ids = Vec::new();
|
||
for day in 1..=22 {
|
||
let source = match day {
|
||
3 => codex_protocol::protocol::SessionSource::Custom("atlas".to_string()),
|
||
4 => codex_protocol::protocol::SessionSource::Custom("chatgpt".to_string()),
|
||
5 => codex_protocol::protocol::SessionSource::Exec,
|
||
6 => codex_protocol::protocol::SessionSource::Mcp,
|
||
_ => codex_protocol::protocol::SessionSource::Cli,
|
||
};
|
||
ids.push(ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout_with_source(
|
||
&app.config.codex_home,
|
||
&format!("2025-01-{day:02}T12-00-00"),
|
||
&format!("2025-01-{day:02}T12:00:00Z"),
|
||
&format!("Task {day}"),
|
||
Some(if day == 10 {
|
||
"other-provider"
|
||
} else {
|
||
&app.config.model_provider_id
|
||
}),
|
||
/*git_info*/ None,
|
||
source,
|
||
)
|
||
.expect("materialize historical session"),
|
||
)?);
|
||
}
|
||
let message_path = app_test_support::rollout_path(
|
||
&app.config.codex_home,
|
||
"2025-01-21T12-00-00",
|
||
&ids[20].to_string(),
|
||
);
|
||
let mut history = std::fs::read_to_string(&message_path)?;
|
||
history.push_str(
|
||
&serde_json::json!({
|
||
"timestamp": "2025-01-21T12:00:01Z",
|
||
"type": "event_msg",
|
||
"payload": { "type": "agent_message", "message": "Found the regression in the parser." }
|
||
})
|
||
.to_string(),
|
||
);
|
||
history.push('\n');
|
||
std::fs::write(message_path, history)?;
|
||
let config = app.config.clone();
|
||
let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&config)).await?;
|
||
for thread_id in [ids[0], ids[21]] {
|
||
app_server
|
||
.resume_thread(
|
||
&app.local_settings,
|
||
config.clone(),
|
||
thread_id,
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
)
|
||
.await?;
|
||
}
|
||
// A newer rollout missing from the index must not trigger a startup filesystem scan.
|
||
app_test_support::create_fake_rollout_with_source(
|
||
&app.config.codex_home,
|
||
"2025-01-23T12-00-00",
|
||
"2025-01-23T12:00:00Z",
|
||
"Unindexed task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
codex_protocol::protocol::SessionSource::Cli,
|
||
)
|
||
.expect("materialize unindexed session");
|
||
app.app_server_target = AppServerTarget::LocalDaemon {
|
||
endpoint: crate::RemoteAppServerEndpoint::UnixSocket {
|
||
socket_path: test_path_buf("/tmp/unused.sock").abs(),
|
||
},
|
||
};
|
||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx);
|
||
app.refresh_agents_overview_threads(&app_server);
|
||
finish_overview_refresh(&mut app, &app_server, &mut event_rx).await;
|
||
let recent_ids: HashSet<_> = ids[2..].iter().copied().collect();
|
||
let mut expected = recent_ids.clone();
|
||
expected.insert(ids[0]);
|
||
let retained: HashSet<_> = app.agents_overview.threads.keys().copied().collect();
|
||
assert_eq!(retained, expected);
|
||
assert_eq!(
|
||
app.agents_overview.last_messages,
|
||
HashMap::from([(ids[20], "Found the regression in the parser.".to_string())])
|
||
);
|
||
let thread = app.agents_overview.threads[&ids[20]].as_ref().unwrap();
|
||
assert_eq!(thread.status, ThreadStatus::NotLoaded);
|
||
|
||
let created = app_server.start_thread(&config).await?.session.thread_id;
|
||
// Closing the view must not cancel a metadata refresh or forget unloaded entries.
|
||
app.primary_thread_id = Some(ids[0]);
|
||
app.open_agents_overview(&app_server, AgentsOverviewFocus::List);
|
||
let visible: HashSet<_> = app
|
||
.agents_overview
|
||
.visible_thread_ids
|
||
.iter()
|
||
.copied()
|
||
.collect();
|
||
assert_eq!(visible, expected);
|
||
app.agents_overview.view_state.lock().unwrap().completion =
|
||
Some(crate::bottom_pane::ViewCompletion::Accepted);
|
||
app.chat_widget.pre_draw_tick();
|
||
finish_overview_refresh(&mut app, &app_server, &mut event_rx).await;
|
||
let retained: HashSet<_> = app.agents_overview.threads.keys().copied().collect();
|
||
assert_eq!(retained, expected);
|
||
|
||
// A creation notification adds a session without attaching a local view.
|
||
tokio::time::timeout(Duration::from_secs(10), async {
|
||
loop {
|
||
let event = app_server.next_event().await.expect("server notification");
|
||
let is_created = matches!(&event, AppServerEvent::ServerNotification(notification)
|
||
if matches!(notification.as_ref(), ServerNotification::ThreadStarted(started) if started.thread.id == created.to_string()));
|
||
app.handle_app_server_event(&app_server, event).await;
|
||
if is_created { break; }
|
||
}
|
||
}).await.expect("creation notification received");
|
||
expected.insert(created);
|
||
let retained: HashSet<_> = app.agents_overview.threads.keys().copied().collect();
|
||
assert_eq!(retained, expected);
|
||
|
||
// Opening older history is a local addition, even without starting a turn.
|
||
let resumed = app_server
|
||
.resume_thread(
|
||
&app.local_settings,
|
||
config.clone(),
|
||
ids[1],
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
)
|
||
.await?;
|
||
app.enqueue_primary_thread_session(resumed.session, resumed.turns)
|
||
.await?;
|
||
app.open_agents_overview(&app_server, AgentsOverviewFocus::List);
|
||
finish_overview_refresh(&mut app, &app_server, &mut event_rx).await;
|
||
expected.insert(ids[1]);
|
||
let visible: HashSet<_> = app
|
||
.agents_overview
|
||
.visible_thread_ids
|
||
.iter()
|
||
.copied()
|
||
.collect();
|
||
assert_eq!(visible, expected);
|
||
|
||
// An unloaded row can be selected through the same flow as a loaded row.
|
||
std::fs::write(
|
||
app.config.codex_home.join("config.toml"),
|
||
"[tui]\nresume_cwd = \"session\"\n",
|
||
)?;
|
||
crate::legacy_core::config::set_project_trust_level(
|
||
app.config.codex_home.as_path(),
|
||
&test_path_buf("/"),
|
||
codex_protocol::config_types::TrustLevel::Trusted,
|
||
)
|
||
.map_err(std::io::Error::other)?;
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
Box::pin(app.select_agents_overview_thread(&mut tui, &mut app_server, ids[2])).await?;
|
||
assert_eq!(app.primary_thread_id, Some(ids[2]));
|
||
app_server.shutdown().await?;
|
||
|
||
// A fresh TUI/server has no in-memory additions; read-only resumes did not promote history.
|
||
let mut restarted = make_test_app().await;
|
||
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();
|
||
restarted.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx);
|
||
restarted.refresh_agents_overview_threads(&app_server);
|
||
finish_overview_refresh(&mut restarted, &app_server, &mut event_rx).await;
|
||
let retained: HashSet<_> = restarted.agents_overview.threads.keys().copied().collect();
|
||
assert_eq!(retained, recent_ids);
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
async fn finish_overview_refresh(
|
||
app: &mut App,
|
||
app_server: &AppServerSession,
|
||
events: &mut tokio::sync::mpsc::UnboundedReceiver<AppEvent>,
|
||
) {
|
||
tokio::time::timeout(Duration::from_secs(10), async {
|
||
loop {
|
||
if let AppEvent::AgentsOverviewThreadsLoaded { request_id, result } =
|
||
events.recv().await.expect("overview event")
|
||
{
|
||
assert!(result.is_ok(), "{result:?}");
|
||
app.apply_agents_overview_thread_refresh(app_server, request_id, result);
|
||
return;
|
||
}
|
||
}
|
||
})
|
||
.await
|
||
.expect("overview refresh completed");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hidden_system_thread_does_not_refresh_shared_overview() {
|
||
let mut app = make_test_app().await;
|
||
let app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref())
|
||
.await
|
||
.expect("embedded app server");
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
|
||
let request_id = uuid::Uuid::new_v4();
|
||
app.agents_overview.request_id = Some(request_id);
|
||
|
||
let parent_thread_id = ThreadId::new();
|
||
app.primary_thread_id = Some(parent_thread_id);
|
||
app.active_thread_id = Some(parent_thread_id);
|
||
app.ensure_thread_channel(parent_thread_id);
|
||
app.agents_overview
|
||
.dispatched_requests
|
||
.insert(parent_thread_id, Vec::new());
|
||
|
||
let hidden_thread_id = ThreadId::new();
|
||
let mut thread = overview_thread(
|
||
hidden_thread_id,
|
||
Some(parent_thread_id),
|
||
"Generate thread title",
|
||
ThreadStatus::Idle,
|
||
);
|
||
thread.ephemeral = true;
|
||
thread.thread_source = Some(ThreadSource::Feature("system".to_string()));
|
||
|
||
app.handle_app_server_event(
|
||
&app_server,
|
||
AppServerEvent::ServerNotification(Box::new(ServerNotification::ThreadStarted(
|
||
ThreadStartedNotification { thread },
|
||
))),
|
||
)
|
||
.await;
|
||
|
||
assert_eq!(
|
||
(
|
||
app.agents_overview.request_id,
|
||
app.agents_overview.refresh_pending,
|
||
),
|
||
(Some(request_id), false)
|
||
);
|
||
assert!(!app.thread_event_channels.contains_key(&hidden_thread_id));
|
||
assert!(
|
||
!app.agents_overview
|
||
.dispatched_requests
|
||
.contains_key(&hidden_thread_id)
|
||
);
|
||
|
||
let visible_thread_id = ThreadId::new();
|
||
let mut thread = overview_thread(
|
||
visible_thread_id,
|
||
Some(parent_thread_id),
|
||
"Persisted system thread",
|
||
ThreadStatus::Idle,
|
||
);
|
||
thread.thread_source = Some(ThreadSource::Feature("system".to_string()));
|
||
|
||
app.handle_app_server_event(
|
||
&app_server,
|
||
AppServerEvent::ServerNotification(Box::new(ServerNotification::ThreadStarted(
|
||
ThreadStartedNotification { thread },
|
||
))),
|
||
)
|
||
.await;
|
||
|
||
assert_eq!(
|
||
(
|
||
app.agents_overview.request_id,
|
||
app.agents_overview.refresh_pending,
|
||
),
|
||
(Some(request_id), true)
|
||
);
|
||
assert!(app.thread_event_channels.contains_key(&visible_thread_id));
|
||
assert!(
|
||
app.agents_overview
|
||
.dispatched_requests
|
||
.contains_key(&visible_thread_id)
|
||
);
|
||
|
||
app_server.shutdown().await.expect("shutdown app server");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn agents_overview_details_show_available_attention_without_expanding_rows() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let [root, child, unloaded] = std::array::from_fn(|_| ThreadId::new());
|
||
let waiting = ThreadStatus::Active {
|
||
active_flags: vec![
|
||
ThreadActiveFlag::WaitingOnApproval,
|
||
ThreadActiveFlag::WaitingOnUserInput,
|
||
],
|
||
};
|
||
// The child question takes priority over the generic waiting parent.
|
||
let mut threads = [
|
||
(root, None, "Repair authentication", waiting.clone()),
|
||
(child, Some(root), "Check dependencies", waiting),
|
||
(
|
||
unloaded,
|
||
None,
|
||
"Investigate parser",
|
||
ThreadStatus::NotLoaded,
|
||
),
|
||
]
|
||
.map(|(id, parent, title, status)| overview_thread(id, parent, title, status))
|
||
.to_vec();
|
||
threads[0].name = None;
|
||
threads[2].name = None;
|
||
threads[2].preview = "Investigate parser\nInclude edge cases\n".repeat(8);
|
||
app.agents_overview.threads = threads
|
||
.iter()
|
||
.cloned()
|
||
.map(|thread| (ThreadId::from_string(&thread.id).unwrap(), Some(thread)))
|
||
.collect();
|
||
app.agents_overview.last_messages.insert(
|
||
unloaded,
|
||
super::super::agents_overview_details::preview_text(
|
||
&"Found the regression\nin the parser. ".repeat(20),
|
||
),
|
||
);
|
||
app.agents_overview.dispatched_requests.insert(
|
||
child,
|
||
vec![ServerRequest::ToolRequestUserInput {
|
||
request_id: RequestId::Integer(42),
|
||
params: ToolRequestUserInputParams {
|
||
thread_id: child.to_string(),
|
||
turn_id: "turn".into(),
|
||
item_id: "question".into(),
|
||
questions: vec![ToolRequestUserInputQuestion {
|
||
id: "version".into(),
|
||
header: "Version".into(),
|
||
question: "Which dependency version should I use?".into(),
|
||
is_other: false,
|
||
is_secret: false,
|
||
options: None,
|
||
}],
|
||
is_blocking: true,
|
||
auto_resolution_ms: None,
|
||
},
|
||
}],
|
||
);
|
||
let view = app.agents_overview_view(threads.clone(), Some(root));
|
||
app.agents_overview.visible_thread_ids = view.thread_ids();
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let project = test_path_display("/tmp/project");
|
||
let normalized_group = format!(
|
||
"/tmp/project 2{}",
|
||
" ".repeat(project.len().saturating_sub("/tmp/project".len()))
|
||
);
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_attention", render_bottom_popup(&app.chat_widget, /*width*/ 96).replace(&format!("{project} 2"), &normalized_group).replace(&project, "/tmp/project"));
|
||
});
|
||
app.handle_app_server_event(
|
||
&app_server,
|
||
AppServerEvent::ServerNotification(Box::new(ServerNotification::ServerRequestResolved(
|
||
codex_app_server_protocol::ServerRequestResolvedNotification {
|
||
thread_id: child.to_string(),
|
||
request_id: RequestId::Integer(42),
|
||
},
|
||
))),
|
||
)
|
||
.await;
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
assert!(!rendered.contains("Which dependency version"));
|
||
assert!(rendered.contains("Waiting for approval."));
|
||
assert!(app.thread_event_channels.is_empty());
|
||
assert!(app.agents_overview.request_id.is_none());
|
||
|
||
let view = app.agents_overview_view(threads, Some(unloaded));
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_last_message", render_bottom_popup(&app.chat_widget, /*width*/ 96).replace(&format!("{project} 2"), &normalized_group).replace(&project, "/tmp/project"));
|
||
});
|
||
app.track_agents_overview_notification(&ServerNotification::ThreadReverted(
|
||
codex_app_server_protocol::ThreadRevertedNotification {
|
||
thread_id: unloaded.to_string(),
|
||
},
|
||
));
|
||
assert!(!render_bottom_popup(&app.chat_widget, /*width*/ 96).contains("Last message"));
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
fn reasoning_delta(thread_id: ThreadId, item_id: &str, delta: &str) -> ServerNotification {
|
||
ServerNotification::ReasoningSummaryTextDelta(ReasoningSummaryTextDeltaNotification {
|
||
thread_id: thread_id.to_string(),
|
||
turn_id: "turn".into(),
|
||
item_id: item_id.into(),
|
||
summary_index: 0,
|
||
delta: delta.into(),
|
||
})
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn agents_overview_reasoning_uses_existing_events_and_expires_with_attachment() {
|
||
let mut app = make_test_app().await;
|
||
let thread_id = ThreadId::new();
|
||
let mut thread = overview_thread(
|
||
thread_id,
|
||
/*parent_thread_id*/ None,
|
||
"Check startup performance",
|
||
ThreadStatus::Active {
|
||
active_flags: Vec::new(),
|
||
},
|
||
);
|
||
thread.preview.clear();
|
||
app.agents_overview
|
||
.threads
|
||
.insert(thread_id, Some(thread.clone()));
|
||
app.thread_event_channels
|
||
.insert(thread_id, ThreadEventChannel::new(/*capacity*/ 8));
|
||
let mut view = app.agents_overview_view(vec![thread.clone()], Some(thread_id));
|
||
view.handle_paste("Keep this draft".into());
|
||
app.agents_overview.visible_thread_ids = view.thread_ids();
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
for delta in ["**Checking", " cold-start regressions**\nFurther reasoning"] {
|
||
app.track_agents_overview_notification(&reasoning_delta(thread_id, "reasoning", delta));
|
||
}
|
||
let project = test_path_display("/tmp/project");
|
||
let normalized_group = format!(
|
||
"/tmp/project 1{}",
|
||
" ".repeat(project.len().saturating_sub("/tmp/project".len()))
|
||
);
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_live_activity", render_bottom_popup(&app.chat_widget, /*width*/ 96).replace(&format!("{project} 1"), &normalized_group).replace(&project, "/tmp/project"));
|
||
});
|
||
assert!(app.agents_overview.request_id.is_none());
|
||
|
||
// A working child can stream through a server attachment without a local channel.
|
||
let parent = overview_thread(
|
||
ThreadId::new(),
|
||
/*parent_thread_id*/ None,
|
||
"Parent",
|
||
thread.status.clone(),
|
||
);
|
||
let parent_id = ThreadId::from_string(&parent.id).unwrap();
|
||
app.agents_overview
|
||
.threads
|
||
.insert(parent_id, Some(parent.clone()));
|
||
app.track_agents_overview_notification(&ServerNotification::ItemCompleted(
|
||
codex_app_server_protocol::ItemCompletedNotification {
|
||
thread_id: parent.id.clone(),
|
||
turn_id: "previous-turn".into(),
|
||
completed_at_ms: 0,
|
||
item: ThreadItem::AgentMessage {
|
||
id: "answer".into(),
|
||
text: "Previous answer".into(),
|
||
phase: None,
|
||
memory_citation: None,
|
||
delivery: None,
|
||
questions: None,
|
||
},
|
||
},
|
||
));
|
||
let channel = app.thread_event_channels.remove(&thread_id).unwrap();
|
||
let details = app.agents_overview_details(
|
||
&parent,
|
||
&HashMap::from([(parent.id.clone(), vec![&thread])]),
|
||
);
|
||
assert!(
|
||
details
|
||
.iter()
|
||
.any(|line| line.to_string().contains("Checking cold-start regressions"))
|
||
);
|
||
app.thread_event_channels.insert(thread_id, channel);
|
||
|
||
// A new, oversized header clears the previous one and cannot grow the parsing buffer indefinitely.
|
||
for delta in [format!("**{}", "界".repeat(10_000)), "**".into()] {
|
||
app.track_agents_overview_notification(&reasoning_delta(thread_id, "oversized", &delta));
|
||
}
|
||
assert_eq!(
|
||
app.agents_overview_details(&thread, &HashMap::new()),
|
||
Vec::<Line>::new()
|
||
);
|
||
app.track_agents_overview_notification(&reasoning_delta(
|
||
thread_id,
|
||
"next",
|
||
"**Running tests**",
|
||
));
|
||
app.thread_event_channels
|
||
.get_mut(&thread_id)
|
||
.unwrap()
|
||
.mark_replay_only();
|
||
assert_eq!(
|
||
app.agents_overview_details(&thread, &HashMap::new()),
|
||
Vec::<Line>::new()
|
||
);
|
||
app.track_agents_overview_notification(&ServerNotification::ThreadClosed(
|
||
ThreadClosedNotification {
|
||
thread_id: thread_id.to_string(),
|
||
},
|
||
));
|
||
assert!(!app.agents_overview.activity.contains_key(&thread_id));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn worktrees_overview_grouping_requires_feature() {
|
||
let mut app = make_test_app().await;
|
||
let root = tempfile::tempdir().unwrap();
|
||
let primary = root.path().join("primary");
|
||
let linked = root.path().join("linked");
|
||
let linked_subdir = linked.join("subdir/child");
|
||
let nested = primary.join("subdir");
|
||
let nested_child = nested.join("child");
|
||
let admin = primary.join(".git/worktrees/linked");
|
||
std::fs::create_dir_all(&admin).unwrap();
|
||
std::fs::create_dir_all(&linked_subdir).unwrap();
|
||
std::fs::create_dir_all(nested.join(".git")).unwrap();
|
||
std::fs::create_dir_all(&nested_child).unwrap();
|
||
std::fs::write(primary.join(".git/HEAD"), "ref: refs/heads/main\n").unwrap();
|
||
std::fs::write(nested.join(".git/HEAD"), "ref: refs/heads/main\n").unwrap();
|
||
std::fs::write(admin.join("commondir"), "../..").unwrap();
|
||
std::fs::write(
|
||
admin.join("gitdir"),
|
||
linked.join(".git").display().to_string(),
|
||
)
|
||
.unwrap();
|
||
std::fs::write(linked.join(".git"), format!("gitdir: {}", admin.display())).unwrap();
|
||
let primary = dunce::canonicalize(primary).unwrap();
|
||
let threads = [primary.clone(), linked, linked_subdir, nested_child]
|
||
.into_iter()
|
||
.map(|cwd| {
|
||
let mut thread = overview_thread(
|
||
ThreadId::new(),
|
||
/*parent_thread_id*/ None,
|
||
"Task",
|
||
ThreadStatus::Idle,
|
||
);
|
||
thread.cwd = AbsolutePathBuf::from_absolute_path(cwd).unwrap();
|
||
thread
|
||
})
|
||
.collect::<Vec<_>>();
|
||
let grouped_heading = format!("{} 2", primary.join("").display());
|
||
let width = 160;
|
||
for enabled in [false, true] {
|
||
app.config
|
||
.features
|
||
.set_enabled(Feature::Worktrees, enabled)
|
||
.unwrap();
|
||
let view = app.agents_overview_view(threads.clone(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let popup = render_bottom_popup(&app.chat_widget, width);
|
||
assert_eq!(popup.contains(&grouped_heading), enabled, "{popup}");
|
||
if enabled {
|
||
let grouping = popup
|
||
.lines()
|
||
.map(|line| line.split('│').next().unwrap_or(line).trim_end())
|
||
.collect::<Vec<_>>()
|
||
.join("\n")
|
||
.replace(
|
||
&primary.join("").display().to_string(),
|
||
"/tmp/worktree-root/primary/",
|
||
)
|
||
.replace('\\', "/");
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_worktree_grouping", grouping);
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn shared_overview_shows_only_root_sessions() {
|
||
assert_eq!(
|
||
AgentsOverviewGroup::for_status(&ThreadStatus::SystemError),
|
||
AgentsOverviewGroup::NeedsYou
|
||
);
|
||
let mut app = make_test_app().await;
|
||
let first_root = ThreadId::from_string("00000000-0000-0000-0000-000000000101").unwrap();
|
||
let unloaded_root = ThreadId::from_string("00000000-0000-0000-0000-000000000102").unwrap();
|
||
let [child, second_root, side_thread] = std::array::from_fn(|_| ThreadId::new());
|
||
app.primary_thread_id = Some(first_root);
|
||
|
||
let mut threads = vec![
|
||
overview_thread(
|
||
first_root,
|
||
/*parent_thread_id*/ None,
|
||
"Build the dashboard",
|
||
ThreadStatus::Idle,
|
||
),
|
||
overview_thread(
|
||
child,
|
||
Some(first_root),
|
||
"Inspect keyboard shortcuts",
|
||
ThreadStatus::Active {
|
||
active_flags: vec![ThreadActiveFlag::WaitingOnApproval],
|
||
},
|
||
),
|
||
overview_thread(
|
||
second_root,
|
||
/*parent_thread_id*/ None,
|
||
"Repair authentication",
|
||
ThreadStatus::Active {
|
||
active_flags: Vec::new(),
|
||
},
|
||
),
|
||
overview_thread(
|
||
unloaded_root,
|
||
/*parent_thread_id*/ None,
|
||
"Review yesterday's changes",
|
||
ThreadStatus::NotLoaded,
|
||
),
|
||
];
|
||
let mut side = overview_thread(
|
||
side_thread,
|
||
/*parent_thread_id*/ None,
|
||
"Ephemeral side",
|
||
ThreadStatus::Idle,
|
||
);
|
||
side.ephemeral = true;
|
||
threads.push(side);
|
||
let view = app.agents_overview_view(threads, /*selected_thread_id*/ None);
|
||
|
||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||
let mut action_view = AgentsOverviewView::new(
|
||
view.rows.clone(),
|
||
Some(first_root),
|
||
/*worktrees_enabled*/ false,
|
||
crate::app_event_sender::AppEventSender::new(event_tx),
|
||
app.keymap.clone(),
|
||
Arc::clone(&app.agents_overview.view_state),
|
||
);
|
||
let state = &app.agents_overview.view_state;
|
||
assert!(!state.lock().unwrap().status_grouping);
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL));
|
||
assert!(state.lock().unwrap().status_grouping);
|
||
app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
assert!(state.lock().unwrap().status_grouping);
|
||
assert!(
|
||
action_view.handle_paste("Use \u{1b}[31mthe\u{1b}[0m current project\u{7}".to_string())
|
||
);
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::DispatchAgentsOverviewTask { prompt, cwd: None })
|
||
if prompt.text == "Use the current project"
|
||
));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL));
|
||
assert!(action_view.handle_paste("Fix the flaky tests after all retries complete".to_string()));
|
||
let area = ratatui::layout::Rect::new(
|
||
/*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 12,
|
||
);
|
||
let mut buffer = ratatui::buffer::Buffer::empty(area);
|
||
action_view.render(area, &mut buffer);
|
||
let prompt = buffer
|
||
.content()
|
||
.iter()
|
||
.map(ratatui::buffer::Cell::symbol)
|
||
.collect::<String>();
|
||
assert!(prompt.contains("complete"));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::DispatchAgentsOverviewTask { prompt, cwd: Some(cwd) })
|
||
if prompt.text == "Fix the flaky tests after all retries complete"
|
||
&& cwd == test_path_buf("/tmp/project").abs()
|
||
));
|
||
assert!(action_view.handle_paste(" ".to_string()));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::CONTROL));
|
||
assert!(action_view.handle_paste("Repair authentication".to_string()));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::SelectAgentsOverviewThread { thread_id }) if thread_id == second_root
|
||
));
|
||
assert!(action_view.handle_paste("Continue working".to_string()));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::DispatchAgentsOverviewTask { prompt, .. })
|
||
if prompt.text.trim() == "Continue working"
|
||
));
|
||
action_view.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL));
|
||
action_view.handle_paste("First line\nSecond line".into());
|
||
crate::chatwidget::tests::helpers::set_active_cell(
|
||
&mut app.chat_widget,
|
||
Box::new(crate::history_cell::PlainHistoryCell::new(vec![
|
||
Line::from("Previous session status"),
|
||
])),
|
||
);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let project = test_path_display("/tmp/project");
|
||
let normalized_project_group = format!(
|
||
"/tmp/project 3{}",
|
||
" ".repeat(project.len().saturating_sub("/tmp/project".len()))
|
||
);
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!(
|
||
"agents_overview",
|
||
render_bottom_popup(&app.chat_widget, /*width*/ 96)
|
||
.replace(&format!("{project} 3"), &normalized_project_group)
|
||
.replace(&project, "/tmp/project")
|
||
);
|
||
});
|
||
|
||
let threads = (0..20)
|
||
.map(|index| {
|
||
let thread_id = if index == 0 {
|
||
first_root
|
||
} else {
|
||
ThreadId::new()
|
||
};
|
||
let status = if index == 0 {
|
||
ThreadStatus::Active {
|
||
active_flags: vec![ThreadActiveFlag::WaitingOnApproval],
|
||
}
|
||
} else {
|
||
ThreadStatus::Idle
|
||
};
|
||
let mut candidate = overview_thread(
|
||
thread_id,
|
||
/*parent_thread_id*/ None,
|
||
&format!("Task {index}"),
|
||
status,
|
||
);
|
||
if index == 0 {
|
||
candidate.name = None;
|
||
candidate.preview = "Inspect unnamed task".to_string();
|
||
}
|
||
candidate.updated_at = index;
|
||
candidate.cwd = if index == 0 {
|
||
test_path_buf("/tmp/project-selected").abs()
|
||
} else {
|
||
test_path_buf(&format!("/tmp/project-{}", index % 3)).abs()
|
||
};
|
||
candidate
|
||
})
|
||
.collect();
|
||
app.agents_overview.view_state.lock().unwrap().completion =
|
||
Some(crate::bottom_pane::ViewCompletion::Accepted);
|
||
app.chat_widget.pre_draw_tick();
|
||
let view = app.agents_overview_view(threads, /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
assert!(
|
||
rendered
|
||
.lines()
|
||
.any(|line| line.contains("› ● Inspect unnamed task current")
|
||
&& line.contains("Needs input"))
|
||
);
|
||
|
||
app.transcript_cells.push(std::sync::Arc::new(
|
||
crate::history_cell::PlainHistoryCell::new(vec![ratatui::text::Line::from(
|
||
"Previous conversation",
|
||
)]),
|
||
));
|
||
let mut tui = crate::tui::test_support::make_test_tui().expect("test terminal");
|
||
let screen_size = tui.terminal.last_known_screen_size;
|
||
app.render_chat_widget_frame(&mut tui, screen_size)
|
||
.expect("render full-screen dashboard");
|
||
assert_eq!(tui.terminal.viewport_area.height, screen_size.height);
|
||
app.agents_overview.view_state.lock().unwrap().completion =
|
||
Some(crate::bottom_pane::ViewCompletion::Accepted);
|
||
app.chat_widget.pre_draw_tick();
|
||
app.render_chat_widget_frame(&mut tui, screen_size)
|
||
.expect("restore conversation after closing dashboard");
|
||
assert!(tui.terminal.viewport_area.height < screen_size.height);
|
||
assert!(app.last_rendered_history_tail.is_some());
|
||
}
|
||
|
||
#[cfg(any(unix, windows))]
|
||
#[tokio::test]
|
||
async fn embedded_sessions_offer_to_start_a_background_server_without_migrating() {
|
||
let mut app = make_test_app().await;
|
||
let app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref())
|
||
.await
|
||
.expect("embedded app server");
|
||
|
||
app.open_agents_overview(&app_server, AgentsOverviewFocus::List);
|
||
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!(
|
||
"agents_overview_embedded",
|
||
render_bottom_popup(&app.chat_widget, /*width*/ 96)
|
||
);
|
||
});
|
||
app_server.shutdown().await.expect("shutdown app server");
|
||
}
|
||
|
||
#[cfg(any(unix, windows))]
|
||
#[tokio::test]
|
||
async fn daemon_start_result_snapshots() -> Result<()> {
|
||
let (mut app, mut app_event_rx, _op_rx) =
|
||
crate::app::tests::make_test_app_with_channels().await;
|
||
let mut app_server =
|
||
crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
|
||
for (name, result) in [
|
||
("agents_daemon_started", Ok(())),
|
||
(
|
||
"agents_daemon_start_failed",
|
||
Err("The host does not allow detached processes".to_string()),
|
||
),
|
||
] {
|
||
app.handle_event(
|
||
&mut tui,
|
||
&mut app_server,
|
||
AppEvent::AgentsDaemonStarted { result },
|
||
)
|
||
.await?;
|
||
let cell = match app_event_rx.try_recv()? {
|
||
AppEvent::InsertHistoryCell(cell) => cell,
|
||
other => panic!("expected daemon result history, got {other:?}"),
|
||
};
|
||
let rendered = cell
|
||
.display_lines(/*width*/ 80)
|
||
.iter()
|
||
.map(ToString::to_string)
|
||
.collect::<Vec<_>>()
|
||
.join("\n");
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!(name, rendered);
|
||
});
|
||
}
|
||
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn filtered_dashboard_actions_use_configured_shortcuts() {
|
||
let mut app = make_test_app().await;
|
||
app.chat_widget.toggle_vim_mode_and_notify();
|
||
let mut keymap = TuiKeymap::default();
|
||
keymap.agents.search = Some(KeybindingsSpec::One(KeybindingSpec("f6".to_string())));
|
||
keymap.agents.stop = Some(KeybindingsSpec::One(KeybindingSpec("f10".to_string())));
|
||
keymap.agents.resume = Some(KeybindingsSpec::One(KeybindingSpec("f8".to_string())));
|
||
keymap.list.move_down = Some(KeybindingsSpec::One(KeybindingSpec("v".into())));
|
||
app.keymap = crate::keymap::RuntimeKeymap::from_config(&keymap).expect("runtime keymap");
|
||
let first = ThreadId::new();
|
||
let second = ThreadId::new();
|
||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||
let mut view = AgentsOverviewView::new(
|
||
app.agents_overview_view(
|
||
vec![
|
||
overview_thread(
|
||
first,
|
||
/*parent_thread_id*/ None,
|
||
"First task",
|
||
ThreadStatus::Idle,
|
||
),
|
||
overview_thread(
|
||
second,
|
||
/*parent_thread_id*/ None,
|
||
"Second task",
|
||
ThreadStatus::Active {
|
||
active_flags: Vec::new(),
|
||
},
|
||
),
|
||
],
|
||
Some(first),
|
||
)
|
||
.rows,
|
||
Some(first),
|
||
/*worktrees_enabled*/ false,
|
||
crate::app_event_sender::AppEventSender::new(event_tx),
|
||
app.keymap.clone(),
|
||
Arc::clone(&app.agents_overview.view_state),
|
||
);
|
||
|
||
view.handle_key_event(KeyEvent::new(KeyCode::F(10), KeyModifiers::NONE));
|
||
assert!(event_rx.try_recv().is_err());
|
||
assert!(view.handle_paste("Do not dispatch this draft".to_string()));
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
for (key, expected) in [('v', second), ('k', first), ('j', first)] {
|
||
view.handle_key_event(KeyCode::Char(key).into());
|
||
let selected = &view.rows[view.selected_index().unwrap()];
|
||
assert_eq!(selected.thread_id, expected);
|
||
}
|
||
assert_eq!(overview_draft(&app).0, "Do not dispatch this draft");
|
||
view.handle_key_event(KeyEvent::new(KeyCode::F(6), KeyModifiers::NONE));
|
||
assert!(view.handle_paste("Second task".to_string()));
|
||
view.handle_key_event(KeyEvent::new(KeyCode::F(8), KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::OpenResumePicker)
|
||
));
|
||
assert!(!view.is_complete());
|
||
view.handle_key_event(KeyEvent::new(KeyCode::F(10), KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::StopAgentsOverviewThread { thread_id }) if thread_id == second
|
||
));
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::SelectAgentsOverviewThread { thread_id }) if thread_id == second
|
||
));
|
||
assert!(event_rx.try_recv().is_err());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn failed_root_switch_keeps_background_requests_on_the_active_session() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let mut app_server =
|
||
crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;
|
||
app.primary_thread_id = Some(ThreadId::new());
|
||
app.ensure_thread_channel(ThreadId::new())
|
||
.store
|
||
.lock()
|
||
.await
|
||
.active_turn_id = Some("running-turn".to_string());
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
|
||
app.select_agents_overview_thread(&mut tui, &mut app_server, ThreadId::new())
|
||
.await?;
|
||
|
||
assert!(app.agents_overview.dispatched_requests.is_empty());
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn root_switch_preserves_vim_line_yank() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
std::fs::write(
|
||
app.local_settings.user_config_path.as_path(),
|
||
"[tui]\nresume_cwd = \"session\"\n",
|
||
)?;
|
||
let mut app_server =
|
||
crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;
|
||
let previous = app_server.start_thread(&app.config).await?;
|
||
app.enqueue_primary_thread_session(previous.session, previous.turns)
|
||
.await?;
|
||
let target_thread_id = ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
app.config.codex_home.as_path(),
|
||
"2025-01-05T12-00-00",
|
||
"2025-01-05T12:00:00Z",
|
||
"Target task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("materialize target rollout"),
|
||
)?;
|
||
app.chat_widget.toggle_vim_mode_and_notify();
|
||
app.chat_widget.insert_str("saved line");
|
||
for code in [KeyCode::Esc, KeyCode::Char('d'), KeyCode::Char('d')] {
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(code, KeyModifiers::NONE));
|
||
}
|
||
assert_eq!(app.chat_widget.composer_text_with_pending(), "");
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
|
||
app.select_agents_overview_thread(&mut tui, &mut app_server, target_thread_id)
|
||
.await?;
|
||
|
||
assert_eq!(app.current_displayed_thread_id(), Some(target_thread_id));
|
||
app.chat_widget.toggle_vim_mode_and_notify();
|
||
app.chat_widget.insert_str("new line");
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE));
|
||
assert_eq!(
|
||
app.chat_widget.composer_text_with_pending(),
|
||
"new line\nsaved line"
|
||
);
|
||
let composer_lines = render_bottom_popup(&app.chat_widget, /*width*/ 80)
|
||
.lines()
|
||
.take(2)
|
||
.collect::<Vec<_>>()
|
||
.join("\n");
|
||
insta::assert_snapshot!(composer_lines, @"› new line\n saved line");
|
||
app_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);
|
||
let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(
|
||
app.chat_widget.config_ref(),
|
||
))
|
||
.await?;
|
||
let previous = Box::pin(app_server.start_thread(&app.config)).await?;
|
||
app.enqueue_primary_thread_session(previous.session, previous.turns)
|
||
.await?;
|
||
let target_thread_id = ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
app.config.codex_home.as_path(),
|
||
"2025-01-05T12-00-00",
|
||
"2025-01-05T12:00:00Z",
|
||
"Target task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("materialize target rollout"),
|
||
)?;
|
||
std::fs::write(
|
||
app.local_settings.user_config_path.as_path(),
|
||
"[tui]\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?;
|
||
|
||
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);
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn root_switch_preserves_idle_root_with_running_subagent() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
trust_fixture_folders(&mut app);
|
||
let mut app_server =
|
||
crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;
|
||
let previous = app_server.start_thread(&app.config).await?;
|
||
let previous_root_id = previous.session.thread_id;
|
||
app.enqueue_primary_thread_session(previous.session, previous.turns)
|
||
.await?;
|
||
let target_thread_id = ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
app.config.codex_home.as_path(),
|
||
"2025-01-05T12-00-00",
|
||
"2025-01-05T12:00:00Z",
|
||
"Target task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("materialize target rollout"),
|
||
)?;
|
||
let target = app_server
|
||
.resume_thread(
|
||
&app.local_settings,
|
||
app.config.clone(),
|
||
target_thread_id,
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
)
|
||
.await?;
|
||
let child_id = ThreadId::new();
|
||
let idle_child_id = ThreadId::new();
|
||
app.ensure_thread_channel(idle_child_id);
|
||
app.upsert_agent_picker_thread(
|
||
child_id, /*agent_nickname*/ None, /*agent_role*/ None, /*is_closed*/ false,
|
||
);
|
||
app.agent_navigation.mark_running(child_id);
|
||
app.active_thread_id = Some(child_id);
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
|
||
app.select_agents_overview_thread(&mut tui, &mut app_server, target.session.thread_id)
|
||
.await?;
|
||
|
||
assert!(
|
||
app.agents_overview
|
||
.dispatched_requests
|
||
.contains_key(&idle_child_id)
|
||
);
|
||
app.handle_app_server_event(
|
||
&app_server,
|
||
AppServerEvent::ServerRequest(Box::new(ServerRequest::CurrentTimeRead {
|
||
request_id: RequestId::Integer(99),
|
||
params: CurrentTimeReadParams {
|
||
thread_id: idle_child_id.to_string(),
|
||
},
|
||
})),
|
||
)
|
||
.await;
|
||
assert!(app.agents_overview.dispatched_requests[&idle_child_id].is_empty());
|
||
let response: ThreadUnsubscribeResponse = app_server
|
||
.request_handle()
|
||
.request_typed(ClientRequest::ThreadUnsubscribe {
|
||
request_id: RequestId::String("verify-root-subscription".to_string()),
|
||
params: ThreadUnsubscribeParams {
|
||
thread_id: previous_root_id.to_string(),
|
||
},
|
||
})
|
||
.await?;
|
||
assert_eq!(response.status, ThreadUnsubscribeStatus::Unsubscribed);
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_selection_applies_user_permissions_only_to_unloaded_threads() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
trust_fixture_folders(&mut app);
|
||
std::fs::write(
|
||
app.config.codex_home.join("config.toml"),
|
||
"[tui]\nresume_cwd = \"session\"\n",
|
||
)?;
|
||
let mut server_config = app.config.clone();
|
||
server_config
|
||
.permissions
|
||
.set_permission_profile(PermissionProfile::workspace_write())?;
|
||
server_config
|
||
.permissions
|
||
.approval_policy
|
||
.set(codex_protocol::protocol::AskForApproval::Never)?;
|
||
let mut thread_ids = Vec::new();
|
||
for day in 1..=5 {
|
||
thread_ids.push(ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
&server_config.codex_home,
|
||
&format!("2025-01-{day:02}T12-00-00"),
|
||
&format!("2025-01-{day:02}T12:00:00Z"),
|
||
"Historical session",
|
||
Some(&server_config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("create historical session"),
|
||
)?);
|
||
}
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&server_config).await?;
|
||
let loaded = app_server
|
||
.resume_thread(
|
||
&crate::local_settings::LocalSettings::from(&server_config),
|
||
server_config.clone(),
|
||
thread_ids[0],
|
||
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
|
||
)
|
||
.await?
|
||
.session;
|
||
app.harness_overrides.sandbox_mode = Some(codex_protocol::config_types::SandboxMode::ReadOnly);
|
||
app.harness_overrides.approval_policy =
|
||
Some(codex_protocol::protocol::AskForApproval::UnlessTrusted);
|
||
app.config
|
||
.permissions
|
||
.set_permission_profile(PermissionProfile::read_only())?;
|
||
app.runtime_permission_profile_override =
|
||
Some(RuntimePermissionProfileOverride::from_config(&app.config));
|
||
app.runtime_approval_policy_override = Some(RuntimeApprovalPolicyOverride::Explicit(
|
||
AskForApproval::UnlessTrusted,
|
||
));
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
for (thread_id, expected_permissions, expected_approval) in [
|
||
(
|
||
loaded.thread_id,
|
||
loaded.permission_profile,
|
||
loaded.approval_policy,
|
||
),
|
||
(
|
||
thread_ids[1],
|
||
PermissionProfile::read_only(),
|
||
codex_app_server_protocol::AskForApproval::UnlessTrusted,
|
||
),
|
||
(
|
||
thread_ids[2],
|
||
PermissionProfile::read_only(),
|
||
codex_app_server_protocol::AskForApproval::UnlessTrusted,
|
||
),
|
||
(
|
||
thread_ids[3],
|
||
PermissionProfile::read_only(),
|
||
codex_app_server_protocol::AskForApproval::UnlessTrusted,
|
||
),
|
||
] {
|
||
if thread_id == thread_ids[2] {
|
||
// A session-only /permissions choice must survive subsequent cold resumes.
|
||
std::fs::write(
|
||
app.config.codex_home.join("config.toml"),
|
||
"approvals_reviewer = \"auto_review\"\n[tui]\nresume_cwd = \"session\"\n",
|
||
)?;
|
||
app.harness_overrides.sandbox_mode =
|
||
Some(codex_protocol::config_types::SandboxMode::WorkspaceWrite);
|
||
app.harness_overrides.approval_policy =
|
||
Some(codex_protocol::protocol::AskForApproval::Never);
|
||
app.runtime_permission_profile_override =
|
||
Some(RuntimePermissionProfileOverride::from_config(&app.config));
|
||
app.runtime_approval_policy_override = Some(RuntimeApprovalPolicyOverride::Explicit(
|
||
AskForApproval::UnlessTrusted,
|
||
));
|
||
}
|
||
app.select_agents_overview_thread(&mut tui, &mut app_server, thread_id)
|
||
.await?;
|
||
let observed = app_server
|
||
.resume_thread(
|
||
&app.local_settings,
|
||
app.config.clone(),
|
||
thread_id,
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
)
|
||
.await?
|
||
.session;
|
||
assert_eq!(
|
||
(
|
||
app.primary_thread_id,
|
||
observed.permission_profile,
|
||
observed.approval_policy,
|
||
observed.approvals_reviewer,
|
||
),
|
||
(
|
||
Some(thread_id),
|
||
expected_permissions,
|
||
expected_approval,
|
||
ApprovalsReviewer::User
|
||
),
|
||
);
|
||
}
|
||
let requirements = app.config.codex_home.join("requirements.toml");
|
||
std::fs::write(
|
||
&requirements,
|
||
"allowed_approvals_reviewers = [\"auto_review\"]\n",
|
||
)?;
|
||
app.loader_overrides.system_requirements_path = Some(requirements.to_path_buf());
|
||
app.select_agents_overview_thread(&mut tui, &mut app_server, thread_ids[4])
|
||
.await?;
|
||
assert_eq!(
|
||
(
|
||
app.primary_thread_id,
|
||
app_server
|
||
.thread_read(thread_ids[4], /*include_turns*/ false)
|
||
.await?
|
||
.status
|
||
),
|
||
(
|
||
Some(thread_ids[3]),
|
||
codex_app_server_protocol::ThreadStatus::NotLoaded
|
||
),
|
||
);
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn overview_cold_resume_honors_working_directory_selection() -> Result<()> {
|
||
for (mode, cli_cwd, runtime_cwd) in [
|
||
("current", false, false),
|
||
("session", true, false),
|
||
("session", true, true),
|
||
("session", false, false),
|
||
] {
|
||
let mut app = make_test_app().await;
|
||
trust_fixture_folders(&mut app);
|
||
let chosen = app.config.codex_home.join("chosen");
|
||
let overridden = app.config.codex_home.join("overridden");
|
||
std::fs::create_dir(&chosen)?;
|
||
std::fs::create_dir(&overridden)?;
|
||
std::fs::write(
|
||
app.config.codex_home.join("config.toml"),
|
||
format!("[tui]\nresume_cwd = \"{mode}\"\n"),
|
||
)?;
|
||
crate::legacy_core::config::set_project_trust_level(
|
||
app.config.codex_home.as_path(),
|
||
&chosen,
|
||
codex_protocol::config_types::TrustLevel::Trusted,
|
||
)
|
||
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
|
||
let thread_id = ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
&app.config.codex_home,
|
||
"2025-01-01T12-00-00",
|
||
"2025-01-01T12:00:00Z",
|
||
"Historical session",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("create historical session"),
|
||
)?;
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
app.launch_cwd = chosen.to_path_buf();
|
||
app.harness_overrides.cwd = cli_cwd.then(|| {
|
||
if runtime_cwd {
|
||
overridden.to_path_buf()
|
||
} else {
|
||
chosen.to_path_buf()
|
||
}
|
||
});
|
||
app.runtime_working_directory_override = runtime_cwd.then(|| chosen.to_path_buf());
|
||
let expected_cwd = if mode == "current" || cli_cwd || runtime_cwd {
|
||
chosen
|
||
} else {
|
||
test_path_buf("/").abs()
|
||
};
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
app.select_agents_overview_thread(&mut tui, &mut app_server, thread_id)
|
||
.await?;
|
||
let observed = app_server
|
||
.resume_thread(
|
||
&app.local_settings,
|
||
app.config.clone(),
|
||
thread_id,
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
)
|
||
.await?
|
||
.session;
|
||
assert_eq!(
|
||
(app.config.cwd.clone(), observed.cwd),
|
||
(expected_cwd.clone(), expected_cwd),
|
||
);
|
||
app_server.shutdown().await?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn restored_server_permission_profile_survives_cd_without_turn_override() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let destination = app.config.codex_home.join("destination");
|
||
std::fs::create_dir(&destination)?;
|
||
crate::legacy_core::config::set_project_trust_level(
|
||
app.config.codex_home.as_path(),
|
||
&destination,
|
||
codex_protocol::config_types::TrustLevel::Trusted,
|
||
)
|
||
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
|
||
let mut app_server =
|
||
crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;
|
||
let previous = app_server.start_thread(&app.config).await?;
|
||
app.enqueue_primary_thread_session(previous.session, previous.turns)
|
||
.await?;
|
||
let target = app_server.start_thread(&app.config).await?;
|
||
let target_thread_id = target.session.thread_id;
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
|
||
app.select_agents_overview_thread(&mut tui, &mut app_server, target_thread_id)
|
||
.await?;
|
||
app.config
|
||
.permissions
|
||
.set_permission_profile(PermissionProfile::read_only())?;
|
||
app.chat_widget.set_permission_profile_with_active_profile(
|
||
PermissionProfile::read_only(),
|
||
/*active_permission_profile*/ None,
|
||
)?;
|
||
app.runtime_permission_profile_override = Some(
|
||
RuntimePermissionProfileOverride::from_restored_config(app.chat_widget.config_ref()),
|
||
);
|
||
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.config_ref()
|
||
.permissions
|
||
.effective_permission_profile(),
|
||
PermissionProfile::read_only()
|
||
);
|
||
assert_eq!(
|
||
app.runtime_permission_profile_override
|
||
.as_ref()
|
||
.map(|profile| profile.turn_override),
|
||
Some(RuntimePermissionProfileTurnOverride::Preserve)
|
||
);
|
||
assert_eq!(
|
||
App::turn_permissions_override_from_config(
|
||
app.chat_widget.config_ref(),
|
||
/*active_permission_profile*/ None,
|
||
app.runtime_permission_profile_override
|
||
.as_ref()
|
||
.and_then(RuntimePermissionProfileOverride::turn_permission_profile),
|
||
),
|
||
TurnPermissionsOverride::Preserve
|
||
);
|
||
|
||
app.change_working_directory(&mut tui, &mut app_server, destination.clone())
|
||
.await;
|
||
|
||
assert_eq!(app.chat_widget.config_ref().cwd, destination);
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.config_ref()
|
||
.permissions
|
||
.effective_permission_profile(),
|
||
PermissionProfile::read_only()
|
||
);
|
||
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn cancelling_resume_picker_preserves_command_center_state() -> Result<()> {
|
||
for primary_thread_id in [None, Some(ThreadId::new())] {
|
||
let mut app = make_test_app().await;
|
||
app.config.disable_paste_burst = true;
|
||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx);
|
||
app.primary_thread_id = primary_thread_id;
|
||
let threads = ["First task", "Second task"].map(|name| {
|
||
overview_thread(
|
||
ThreadId::new(),
|
||
/*parent_thread_id*/ None,
|
||
name,
|
||
ThreadStatus::Idle,
|
||
)
|
||
});
|
||
let selected = ThreadId::from_string(&threads[1].id).unwrap();
|
||
let view = app.agents_overview_view(threads.into(), Some(selected));
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
for key in [
|
||
KeyCode::Esc.into(),
|
||
KeyEvent::new(KeyCode::Char('s'), KeyModifiers::CONTROL),
|
||
KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL),
|
||
KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE),
|
||
KeyCode::Esc.into(),
|
||
KeyEvent::new(KeyCode::Char('f'), KeyModifiers::CONTROL),
|
||
KeyEvent::new(KeyCode::Char('S'), KeyModifiers::NONE),
|
||
] {
|
||
app.chat_widget.handle_key_event(key);
|
||
}
|
||
let before = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
let selection = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID);
|
||
while event_rx.try_recv().is_ok() {}
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::CONTROL));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::OpenResumePicker)
|
||
));
|
||
assert!(event_rx.try_recv().is_err());
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
for selection in [SessionSelection::StartFresh, SessionSelection::Exit] {
|
||
assert!(matches!(
|
||
app.apply_resume_picker_selection(&mut tui, &mut server, selection)
|
||
.await?,
|
||
AppRunControl::Continue
|
||
));
|
||
app.chat_widget.pre_draw_tick();
|
||
assert_eq!(render_bottom_popup(&app.chat_widget, /*width*/ 96), before);
|
||
}
|
||
server.shutdown().await?;
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID),
|
||
selection
|
||
);
|
||
assert_eq!(overview_draft(&app).0, "d");
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn command_center_cursor_tracks_wrapped_footer() {
|
||
let app = make_test_app().await;
|
||
let mut view = app.agents_overview_view(
|
||
vec![overview_thread(
|
||
ThreadId::new(),
|
||
/*parent_thread_id*/ None,
|
||
"Task",
|
||
ThreadStatus::Idle,
|
||
)],
|
||
/*selected_thread_id*/ None,
|
||
);
|
||
for (key, label) in [('n', "› Describe"), ('f', "Search ›"), ('r', "Rename ›")] {
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char(key), KeyModifiers::CONTROL));
|
||
for width in [48, 96, 120] {
|
||
let area =
|
||
ratatui::layout::Rect::new(/*x*/ 0, /*y*/ 0, width, /*height*/ 24);
|
||
let mut buffer = ratatui::buffer::Buffer::empty(area);
|
||
view.render(area, &mut buffer);
|
||
let prompt_row = buffer
|
||
.content()
|
||
.chunks(usize::from(width))
|
||
.position(|row| {
|
||
row.iter()
|
||
.map(ratatui::buffer::Cell::symbol)
|
||
.collect::<String>()
|
||
.contains(label)
|
||
})
|
||
.expect("rendered prompt");
|
||
assert_eq!(
|
||
view.cursor_pos(area).map(|(_, y)| usize::from(y)),
|
||
Some(prompt_row)
|
||
);
|
||
assert!(area.contains(view.cursor_pos(area).unwrap().into()));
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn empty_command_center_can_open_resume_picker() {
|
||
let mut app = make_test_app().await;
|
||
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx);
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
while event_rx.try_recv().is_ok() {}
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::CONTROL));
|
||
assert!(matches!(
|
||
event_rx.try_recv(),
|
||
Ok(AppEvent::OpenResumePicker)
|
||
));
|
||
// Crossterm labels forward Delete as "fwd del" on macOS and "del" elsewhere.
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 48).replace("fwd del", "del");
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_empty_narrow", rendered);
|
||
});
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn resuming_active_session_closes_command_center() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let thread_id = ThreadId::new();
|
||
app.active_thread_id = Some(thread_id);
|
||
app.primary_thread_id = Some(thread_id);
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
assert!(matches!(
|
||
app.apply_resume_picker_selection(
|
||
&mut tui,
|
||
&mut server,
|
||
SessionSelection::Resume(SessionTarget {
|
||
path: None,
|
||
thread_id,
|
||
cwd: None,
|
||
history_mode: None,
|
||
})
|
||
)
|
||
.await?,
|
||
AppRunControl::Continue
|
||
));
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID),
|
||
None
|
||
);
|
||
server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn resume_failure_keeps_command_center_available() {
|
||
let mut app = make_test_app().await;
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let before = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
app.add_session_picker_error("The session is unavailable.".to_string());
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_resume_error", render_bottom_popup(&app.chat_widget, /*width*/ 96));
|
||
});
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
||
assert_eq!(render_bottom_popup(&app.chat_widget, /*width*/ 96), before);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn resume_picker_round_trip_preserves_each_threads_input() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
trust_fixture_folders(&mut app);
|
||
std::fs::write(
|
||
app.config.codex_home.join("config.toml"),
|
||
"[tui]\nresume_cwd = \"current\"\n",
|
||
)?;
|
||
let mut targets = Vec::new();
|
||
for (timestamp, name) in [
|
||
("2025-01-05T12-00-00", "First task"),
|
||
("2025-01-05T13-00-00", "Second task"),
|
||
] {
|
||
let id = app_test_support::create_fake_rollout(
|
||
app.config.codex_home.as_path(),
|
||
timestamp,
|
||
"2025-01-05T12:00:00Z",
|
||
name,
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("saved rollout");
|
||
targets.push(SessionTarget {
|
||
path: Some(app_test_support::rollout_path(
|
||
app.config.codex_home.as_path(),
|
||
timestamp,
|
||
&id,
|
||
)),
|
||
thread_id: ThreadId::from_string(&id)?,
|
||
cwd: None,
|
||
history_mode: None,
|
||
});
|
||
}
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
let mut expected_states = Vec::new();
|
||
for target in targets.iter().chain(&targets) {
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
app.apply_resume_picker_selection(
|
||
&mut tui,
|
||
&mut server,
|
||
SessionSelection::Resume(target.clone()),
|
||
)
|
||
.await?;
|
||
assert_eq!(app.chat_widget.thread_id(), Some(target.thread_id));
|
||
if expected_states.len() < targets.len() {
|
||
assert_eq!(app.chat_widget.composer_text_with_pending(), "");
|
||
assert!(app.chat_widget.queued_user_message_texts().is_empty());
|
||
app.chat_widget.handle_server_notification(
|
||
ServerNotification::TurnStarted(
|
||
codex_app_server_protocol::TurnStartedNotification {
|
||
thread_id: target.thread_id.to_string(),
|
||
turn: codex_app_server_protocol::Turn {
|
||
id: "turn-with-follow-up".to_string(),
|
||
items_view: codex_app_server_protocol::TurnItemsView::Full,
|
||
items: Vec::new(),
|
||
status: codex_app_server_protocol::TurnStatus::InProgress,
|
||
error: None,
|
||
started_at: None,
|
||
completed_at: None,
|
||
duration_ms: None,
|
||
},
|
||
},
|
||
),
|
||
/*replay_kind*/ None,
|
||
);
|
||
let follow_up = format!("Follow-up for {}", target.thread_id);
|
||
app.chat_widget.apply_external_edit(follow_up.clone());
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
|
||
assert_eq!(app.chat_widget.queued_user_message_texts(), vec![follow_up]);
|
||
app.chat_widget
|
||
.apply_external_edit(format!("Draft for {}", target.thread_id));
|
||
let mut input_state = app.chat_widget.capture_thread_input_state().unwrap();
|
||
// Recovered follow-ups stay paused until the user explicitly submits them.
|
||
input_state.recovered_queue = true;
|
||
app.chat_widget.restore_thread_input_state(
|
||
Some(input_state),
|
||
crate::chatwidget::ThreadInputStateRestoreMode {
|
||
preserve_in_flight_turn: false,
|
||
},
|
||
);
|
||
expected_states.push(app.chat_widget.capture_thread_input_state());
|
||
} else {
|
||
let index = targets
|
||
.iter()
|
||
.position(|t| t.thread_id == target.thread_id)
|
||
.unwrap();
|
||
assert_eq!(
|
||
app.chat_widget.capture_thread_input_state(),
|
||
expected_states[index]
|
||
);
|
||
}
|
||
}
|
||
server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn command_center_handles_resume_failure_and_success() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
trust_fixture_folders(&mut app);
|
||
std::fs::write(
|
||
app.config.codex_home.join("config.toml"),
|
||
"[tui]\nresume_cwd = \"current\"\n",
|
||
)?;
|
||
let timestamp = "2025-01-05T12-00-00";
|
||
let id = app_test_support::create_fake_rollout(
|
||
app.config.codex_home.as_path(),
|
||
timestamp,
|
||
"2025-01-05T12:00:00Z",
|
||
"Saved task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("saved rollout");
|
||
let thread_id = ThreadId::from_string(&id)?;
|
||
let path = app_test_support::rollout_path(app.config.codex_home.as_path(), timestamp, &id);
|
||
let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
assert!(matches!(
|
||
app.apply_resume_picker_selection(
|
||
&mut tui,
|
||
&mut server,
|
||
SessionSelection::Resume(SessionTarget {
|
||
path: None,
|
||
thread_id: ThreadId::new(),
|
||
cwd: None,
|
||
history_mode: None,
|
||
})
|
||
)
|
||
.await?,
|
||
AppRunControl::Continue
|
||
));
|
||
assert!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.is_some()
|
||
);
|
||
assert!(
|
||
render_bottom_popup(&app.chat_widget, /*width*/ 96).contains("Unable to resume session")
|
||
);
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
|
||
assert!(matches!(
|
||
app.apply_resume_picker_selection(
|
||
&mut tui,
|
||
&mut server,
|
||
SessionSelection::Resume(SessionTarget {
|
||
path: Some(path),
|
||
thread_id,
|
||
cwd: None,
|
||
history_mode: None,
|
||
})
|
||
)
|
||
.await?,
|
||
AppRunControl::Continue
|
||
));
|
||
assert_eq!(app.chat_widget.thread_id(), Some(thread_id));
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID),
|
||
None
|
||
);
|
||
server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn command_center_attach_conflict_preserves_selection_and_draft() -> Result<()> {
|
||
let mut app = Box::pin(make_test_app()).await;
|
||
trust_fixture_folders(&mut app);
|
||
std::fs::write(
|
||
app.config.codex_home.join("config.toml"),
|
||
"[tui]\nresume_cwd = \"current\"\n",
|
||
)?;
|
||
let mut owner = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
let started = Box::pin(owner.start_thread(&app.config)).await?;
|
||
let thread_id = started.session.thread_id;
|
||
// Materialize the lazy rollout so the second server can discover the locked task.
|
||
owner.thread_inject_items(thread_id, vec![serde_json::from_value(serde_json::json!({
|
||
"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "Saved task"}]
|
||
}))?]).await?;
|
||
let thread = owner
|
||
.thread_read(thread_id, /*include_turns*/ false)
|
||
.await?;
|
||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
let mut view = app.agents_overview_view(vec![thread], Some(thread_id));
|
||
view.handle_paste("Keep this draft".into());
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let before = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
let draft = overview_draft(&app);
|
||
let selection = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID);
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
|
||
app.chat_widget.handle_key_event(KeyCode::Right.into());
|
||
let event = rx.try_recv()?;
|
||
assert!(
|
||
matches!(event, AppEvent::SelectAgentsOverviewThread { thread_id: id } if id == thread_id)
|
||
);
|
||
Box::pin(app.handle_event(&mut tui, &mut server, event)).await?;
|
||
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_attach_conflict", render_bottom_popup(&app.chat_widget, /*width*/ 96));
|
||
});
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
assert_eq!(render_bottom_popup(&app.chat_widget, /*width*/ 96), before);
|
||
assert_eq!(overview_draft(&app), draft);
|
||
assert_eq!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID),
|
||
selection
|
||
);
|
||
owner.shutdown().await?;
|
||
// Once the owner releases the task, the same keyboard path closes the dashboard.
|
||
app.chat_widget.handle_key_event(KeyCode::Right.into());
|
||
Box::pin(app.handle_event(&mut tui, &mut server, rx.try_recv()?)).await?;
|
||
assert_eq!(app.chat_widget.thread_id(), Some(thread_id));
|
||
assert!(app.chat_widget.no_modal_or_popup_active());
|
||
|
||
// Opening the already displayed task also returns to its conversation.
|
||
let thread = server
|
||
.thread_read(thread_id, /*include_turns*/ false)
|
||
.await?;
|
||
let view = app.agents_overview_view(vec![thread], Some(thread_id));
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
while rx.try_recv().is_ok() {}
|
||
app.chat_widget.handle_key_event(KeyCode::Right.into());
|
||
Box::pin(app.handle_event(&mut tui, &mut server, rx.try_recv()?)).await?;
|
||
assert!(app.chat_widget.no_modal_or_popup_active());
|
||
server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn command_center_refresh_failure_is_inline_and_clears_on_success() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
let mut view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
view.handle_paste("Keep typing".into());
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let before = render_bottom_popup(&app.chat_widget, /*width*/ 48);
|
||
for result in [
|
||
Err("unavailable".into()),
|
||
Ok(AgentsOverviewThreadRefresh {
|
||
threads: HashMap::new(),
|
||
last_messages: HashMap::new(),
|
||
recent_seed_complete: false,
|
||
}),
|
||
] {
|
||
let request_id = Uuid::new_v4();
|
||
app.agents_overview.request_id = Some(request_id);
|
||
app.apply_agents_overview_thread_refresh(&server, request_id, result);
|
||
assert!(
|
||
app.agents_overview
|
||
.view_state
|
||
.lock()
|
||
.unwrap()
|
||
.refresh_failed
|
||
);
|
||
}
|
||
let notice = render_bottom_popup(&app.chat_widget, /*width*/ 32)
|
||
.lines()
|
||
.take(2)
|
||
.collect::<Vec<_>>()
|
||
.join("\n");
|
||
insta::assert_snapshot!(notice, @r"
|
||
Agent command center
|
||
Error loading tasks
|
||
");
|
||
let request_id = Uuid::new_v4();
|
||
app.agents_overview.request_id = Some(request_id);
|
||
app.apply_agents_overview_thread_refresh(
|
||
&server,
|
||
request_id,
|
||
Ok(AgentsOverviewThreadRefresh {
|
||
threads: HashMap::new(),
|
||
last_messages: HashMap::new(),
|
||
recent_seed_complete: true,
|
||
}),
|
||
);
|
||
assert_eq!(render_bottom_popup(&app.chat_widget, /*width*/ 48), before);
|
||
server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn command_center_failed_send_keeps_newer_draft_and_exposes_unsent_task() -> Result<()> {
|
||
let (mut app, mut rx, _op_rx) = crate::app::tests::make_test_app_with_channels().await;
|
||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
let mut view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
view.handle_paste("Newer draft".into());
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let before = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
let draft = overview_draft(&app);
|
||
let unsent = "Unsent draft that wraps across multiple lines in a narrow terminal.\nKeep this second line too.";
|
||
let thread_id = ThreadId::from_string("00000000-0000-0000-0000-000000000001")?;
|
||
app.submit_agents_overview_prompt(&server, thread_id, unsent.into(), Vec::new())
|
||
.await;
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
insta::with_settings!({snapshot_path => "../snapshots"}, {
|
||
insta::assert_snapshot!("agents_overview_unsent_task", rendered);
|
||
});
|
||
app.chat_widget.handle_key_event(KeyCode::Down.into());
|
||
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
||
let text = std::iter::from_fn(|| rx.try_recv().ok()).find_map(|event| match event {
|
||
AppEvent::ViewAgentsOverviewUnsentPrompt(text) => Some(text),
|
||
_ => None,
|
||
});
|
||
assert_eq!(text, Some(unsent.into()));
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
Box::pin(app.handle_event(
|
||
&mut tui,
|
||
&mut server,
|
||
AppEvent::ViewAgentsOverviewUnsentPrompt(text.unwrap()),
|
||
))
|
||
.await?;
|
||
let Some(Overlay::Static(mut overlay)) = app.overlay.take() else {
|
||
panic!("unsent task opens a static pager");
|
||
};
|
||
overlay.handle_event(&mut tui, TuiEvent::Key(KeyCode::Char('q').into()))?;
|
||
assert!(overlay.is_done());
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
assert_eq!(overview_draft(&app), draft);
|
||
assert_eq!(render_bottom_popup(&app.chat_widget, /*width*/ 96), before);
|
||
server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn command_center_action_failures_remain_visible() -> Result<()> {
|
||
let mut app = Box::pin(make_test_app()).await;
|
||
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let thread_id = ThreadId::new();
|
||
let mut view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);
|
||
view.handle_paste("Keep this draft".into());
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let draft = overview_draft(&app);
|
||
for (event, expected) in [
|
||
(
|
||
AppEvent::SelectAgentsOverviewThread { thread_id },
|
||
"is unavailable",
|
||
),
|
||
(
|
||
AppEvent::RenameAgentsOverviewThread {
|
||
thread_id,
|
||
name: "New name".into(),
|
||
},
|
||
"Failed to rename task",
|
||
),
|
||
(
|
||
AppEvent::StopAgentsOverviewThread { thread_id },
|
||
"Failed to stop background task",
|
||
),
|
||
(
|
||
AppEvent::AgentsOverviewError("Failed to paste image: clipboard unavailable".into()),
|
||
"Failed to paste image",
|
||
),
|
||
] {
|
||
Box::pin(app.handle_event(&mut tui, &mut server, event)).await?;
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
assert!(rendered.contains("Unable to complete action"), "{rendered}");
|
||
assert!(rendered.contains(expected), "{rendered}");
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
assert!(
|
||
render_bottom_popup(&app.chat_widget, /*width*/ 96).contains("Agent command center")
|
||
);
|
||
assert_eq!(overview_draft(&app), draft);
|
||
}
|
||
// The retained primary task can also fail in the nested agent-attachment path.
|
||
app.primary_thread_id = Some(thread_id);
|
||
Box::pin(app.handle_event(
|
||
&mut tui,
|
||
&mut server,
|
||
AppEvent::SelectAgentsOverviewThread { thread_id },
|
||
))
|
||
.await?;
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 96);
|
||
assert!(rendered.contains("Unable to complete action"), "{rendered}");
|
||
assert!(rendered.contains("is no longer available"), "{rendered}");
|
||
server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
#[path = "agents_overview_actions_tests.rs"]
|
||
mod actions;
|
||
|
||
fn trust_fixture_folders(app: &mut App) {
|
||
let projects = serde_json::json!({
|
||
test_path_buf("/").display().to_string(): {"trust_level": "trusted"},
|
||
app.config.cwd.display().to_string(): {"trust_level": "trusted"},
|
||
});
|
||
app.cli_kv_overrides.push((
|
||
"projects".into(),
|
||
toml::Value::try_from(projects).expect("trust fixture"),
|
||
));
|
||
}
|