mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
## Why A remote app server can report a working directory in a different path convention from the client. Decoding a Windows drive path as a client-native absolute path can make a Unix client reject the thread response. ## What changed Keep thread `cwd` values as server-native strings in summaries, settings, and start, resume, and fork responses. Preserve the JSON and generated SDK types. In the TUI, store the session directory as a `PathUri` using the server's path convention when available. Use that directory to match diff and skill results and to display the project name in the terminal title. ## Testing Add regression coverage for foreign-path response round trips, diff results matched against a remote session directory, and terminal titles derived from a Windows path. Verify that the server rejects a working directory that cannot be encoded as UTF-8. GitOrigin-RevId: 600f0b531939db4cd4ec884de166224082995e00
1410 lines
56 KiB
Rust
1410 lines
56 KiB
Rust
use super::*;
|
||
use crate::app::agents_overview_discovery::list_pinned_threads;
|
||
use crate::app::tests::test_thread_session;
|
||
use crate::app_event::AgentsOverviewAction;
|
||
use codex_app_server_protocol::ClientRequest;
|
||
use codex_app_server_protocol::RequestId;
|
||
use codex_app_server_protocol::ThreadLoadedListParams;
|
||
use codex_app_server_protocol::ThreadStatusChangedNotification;
|
||
use codex_app_server_protocol::TurnStartParams;
|
||
use codex_app_server_protocol::TurnStartResponse;
|
||
use codex_model_provider_info::ModelProviderInfo;
|
||
use core_test_support::responses;
|
||
use core_test_support::streaming_sse::StreamingSseChunk;
|
||
use core_test_support::streaming_sse::start_streaming_sse_server;
|
||
use pretty_assertions::assert_eq;
|
||
|
||
#[tokio::test]
|
||
async fn pin_action_updates_shared_section_state() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let started = app_server.start_thread(&app.config).await?;
|
||
let thread_id = started.session.thread_id;
|
||
attach_thread(&mut app, thread_id);
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
app.backend_registry.connect(&app_server);
|
||
app.open_agents_overview(&app_server);
|
||
finish_overview_refresh(&mut app, &app_server, &mut rx).await;
|
||
|
||
let status_changed = |status| {
|
||
ServerNotification::ThreadStatusChanged(ThreadStatusChangedNotification {
|
||
thread_id: thread_id.to_string(),
|
||
status,
|
||
})
|
||
};
|
||
for pinned in [true, false] {
|
||
app.refresh_agents_overview_threads(&app_server);
|
||
app.track_agents_overview_notification(&status_changed(ThreadStatus::Active {
|
||
active_flags: Vec::new(),
|
||
}));
|
||
assert!(
|
||
app.agents_overview
|
||
.refresh_notifications
|
||
.contains_key(&thread_id)
|
||
);
|
||
Box::pin(app.handle_event(
|
||
&mut tui,
|
||
&mut app_server,
|
||
AppEvent::ToggleAgentsOverviewPin { thread_id, pinned },
|
||
))
|
||
.await?;
|
||
let (pending, _) = app
|
||
.agents_overview
|
||
.pending_pin_change
|
||
.expect("pin request started");
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
assert!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.is_none()
|
||
);
|
||
let completed = tokio::time::timeout(std::time::Duration::from_secs(15), async {
|
||
loop {
|
||
let event = rx.recv().await.expect("pin request completes");
|
||
if let AppEvent::AgentsOverviewPinToggled { request_id, .. } = &event
|
||
&& *request_id == pending
|
||
{
|
||
return event;
|
||
}
|
||
}
|
||
})
|
||
.await?;
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, completed)).await?;
|
||
assert_eq!(app.agents_overview.pending_pin_change, None);
|
||
assert_eq!(app.agents_overview.active_refresh, None);
|
||
app.track_agents_overview_notification(&status_changed(ThreadStatus::Idle));
|
||
app.open_agents_overview(&app_server);
|
||
finish_overview_refresh(&mut app, &app_server, &mut rx).await;
|
||
assert_eq!(
|
||
app.agents_overview.threads[&thread_id]
|
||
.as_ref()
|
||
.unwrap()
|
||
.status,
|
||
ThreadStatus::Idle
|
||
);
|
||
let threads = list_pinned_threads(&app_server.request_handle())
|
||
.await
|
||
.map_err(color_eyre::eyre::Report::msg)?
|
||
.expect("embedded app server supports shared thread sections");
|
||
assert_eq!(
|
||
threads
|
||
.iter()
|
||
.any(|(thread, _)| thread.id == started.session.thread_id.to_string()),
|
||
pinned
|
||
);
|
||
}
|
||
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn cloud_archive_preserves_attached_child_and_other_tasks() -> Result<()> {
|
||
use codex_app_server_client::AppServerClient;
|
||
use codex_app_server_client::CloudClient;
|
||
use codex_app_server_client::CloudOperation;
|
||
use serde_json::json;
|
||
|
||
let mut app = make_test_app().await;
|
||
app.app_server_target = AppServerTarget::Cloud;
|
||
let parent = ThreadId::new();
|
||
let child = ThreadId::new();
|
||
let other = ThreadId::new();
|
||
let threads = HashMap::from([
|
||
(
|
||
parent,
|
||
Some(overview_thread(
|
||
parent,
|
||
/*parent_thread_id*/ None,
|
||
"Cloud parent",
|
||
ThreadStatus::Idle,
|
||
)),
|
||
),
|
||
(
|
||
child,
|
||
Some(overview_thread(
|
||
child,
|
||
Some(parent),
|
||
"Cloud child",
|
||
ThreadStatus::Active {
|
||
active_flags: Vec::new(),
|
||
},
|
||
)),
|
||
),
|
||
(
|
||
other,
|
||
Some(overview_thread(
|
||
other,
|
||
/*parent_thread_id*/ None,
|
||
"Other task",
|
||
ThreadStatus::Idle,
|
||
)),
|
||
),
|
||
]);
|
||
app.agents_overview.threads = threads.clone();
|
||
app.primary_thread_id = Some(child);
|
||
app.active_thread_id = Some(child);
|
||
app.chat_widget
|
||
.handle_thread_session(test_thread_session(child, app.config.cwd.to_path_buf()));
|
||
app.chat_widget
|
||
.apply_external_edit("Keep child draft".into());
|
||
let draft = app.chat_widget.capture_thread_input_state();
|
||
crate::chatwidget::activate_voice_for_thread(&mut app.chat_widget, child);
|
||
|
||
app.confirm_agents_overview_action(parent, AgentsOverviewAction::Archive);
|
||
insta::assert_snapshot!(render_bottom_popup(&app.chat_widget, /*width*/ 80), @"
|
||
Archive “Cloud parent”?
|
||
› Ke This stops any running work in this task and archives it. Child
|
||
agents stay unchanged. Its history can be restored from the resume
|
||
gp picker.
|
||
|
||
|
||
› 1. Cancel
|
||
2. Archive task
|
||
|
||
enter select · esc back
|
||
");
|
||
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
||
|
||
let (client, mut commands, _events) = CloudClient::channel(/*capacity*/ 1);
|
||
let mut session = AppServerSession::new(
|
||
crate::backend_id::BackendId::new(),
|
||
AppServerClient::Cloud(client),
|
||
crate::app_server_session::ThreadParamsMode::Cloud,
|
||
);
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
tui.pause_events();
|
||
let (result, ()) = tokio::join!(
|
||
Box::pin(app.run_agents_overview_action(
|
||
&mut tui,
|
||
&mut session,
|
||
parent,
|
||
AgentsOverviewAction::Archive
|
||
)),
|
||
async {
|
||
let command = commands.recv().await.expect("archive request");
|
||
let CloudOperation::Request(request) = command.operation else {
|
||
panic!("expected archive request");
|
||
};
|
||
assert!(
|
||
matches!(*request, ClientRequest::ThreadArchive { params, .. } if params.thread_id == parent.to_string())
|
||
);
|
||
command.response.send(Ok(Ok(json!({})))).unwrap();
|
||
},
|
||
);
|
||
result?;
|
||
let mut expected = threads;
|
||
expected.remove(&parent);
|
||
assert_eq!(app.agents_overview.threads, expected);
|
||
assert_eq!(
|
||
(
|
||
app.primary_thread_id,
|
||
app.current_displayed_thread_id(),
|
||
app.chat_widget.thread_id()
|
||
),
|
||
(Some(child), Some(child), Some(child))
|
||
);
|
||
assert_eq!(app.chat_widget.capture_thread_input_state(), draft);
|
||
assert_eq!(app.voice_owner_thread_id(), Some(child));
|
||
if let Some(refresh) = app.agents_overview.refresh_task.take() {
|
||
refresh.abort();
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn pin_completion_cancels_the_originating_backends_stale_refresh() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let backend_id = BackendId::new();
|
||
let thread_id = ThreadId::new();
|
||
app.backend_registry.observe(backend_id, thread_id);
|
||
app.agents_overview
|
||
.pins_by_backend
|
||
.insert(backend_id, Some(Vec::new()));
|
||
let pin_request = Uuid::new_v4();
|
||
app.agents_overview.pending_pin_change = Some((pin_request, backend_id));
|
||
let stale_refresh = Uuid::new_v4();
|
||
app.agents_overview.active_refresh = Some((stale_refresh, backend_id));
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
|
||
Box::pin(app.handle_event(
|
||
&mut tui,
|
||
&mut app_server,
|
||
AppEvent::AgentsOverviewPinToggled {
|
||
backend_id,
|
||
request_id: pin_request,
|
||
thread_id,
|
||
pinned: true,
|
||
result: Ok(()),
|
||
},
|
||
))
|
||
.await?;
|
||
|
||
assert_eq!(app.agents_overview.active_refresh, None);
|
||
assert_eq!(
|
||
app.agents_overview.pins_by_backend[&backend_id],
|
||
Some(vec![thread_id])
|
||
);
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn archive_confirmation_number_keys_act_immediately() {
|
||
for key in ['1', '2'] {
|
||
let (mut app, mut rx, _op_rx) = crate::app::tests::make_test_app_with_channels().await;
|
||
let id = ThreadId::new();
|
||
app.agents_overview.threads.insert(
|
||
id,
|
||
Some(overview_thread(
|
||
id,
|
||
/*parent_thread_id*/ None,
|
||
"Current task",
|
||
ThreadStatus::Idle,
|
||
)),
|
||
);
|
||
app.confirm_agents_overview_action(id, AgentsOverviewAction::Archive);
|
||
|
||
app.chat_widget.handle_key_event(KeyCode::Char(key).into());
|
||
|
||
assert!(!app.chat_widget.has_active_view());
|
||
let actions = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.filter_map(|event| match event {
|
||
AppEvent::RunAgentsOverviewAction { thread_id, action } => {
|
||
Some((thread_id, action))
|
||
}
|
||
_ => None,
|
||
})
|
||
.collect::<Vec<_>>();
|
||
assert_eq!(
|
||
actions,
|
||
if key == '2' {
|
||
vec![(id, AgentsOverviewAction::Archive)]
|
||
} else {
|
||
Vec::new()
|
||
}
|
||
);
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn lifecycle_shortcuts_target_filtered_task_in_any_state() {
|
||
let mut app = make_test_app().await;
|
||
let mut keymap = TuiKeymap::default();
|
||
keymap.agents.archive = Some(KeybindingsSpec::One(KeybindingSpec("f5".into())));
|
||
keymap.agents.delete = Some(KeybindingsSpec::One(KeybindingSpec("f6".into())));
|
||
keymap.agents.hide = Some(KeybindingsSpec::One(KeybindingSpec("f7".into())));
|
||
keymap.agents.fork = Some(KeybindingsSpec::One(KeybindingSpec("f8".into())));
|
||
app.keymap = RuntimeKeymap::from_config(&keymap).unwrap();
|
||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||
app.app_event_tx = AppEventSender::new(tx);
|
||
for status in [
|
||
ThreadStatus::Idle,
|
||
ThreadStatus::NotLoaded,
|
||
ThreadStatus::Active {
|
||
active_flags: Vec::new(),
|
||
},
|
||
] {
|
||
let target = ThreadId::new();
|
||
let mut view = app.agents_overview_view(
|
||
vec![
|
||
overview_thread(
|
||
ThreadId::new(),
|
||
/*parent_thread_id*/ None,
|
||
"Other",
|
||
ThreadStatus::Idle,
|
||
),
|
||
overview_thread(target, /*parent_thread_id*/ None, "Target", status),
|
||
],
|
||
Some(target),
|
||
);
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
view.handle_key_event(KeyEvent::new(KeyCode::Char('/'), KeyModifiers::NONE));
|
||
view.handle_paste("Target".into());
|
||
assert!(matches!(
|
||
rx.try_recv(),
|
||
Ok(AppEvent::SearchAgentsOverview(..))
|
||
));
|
||
for (key, expected) in [
|
||
(5, AgentsOverviewAction::Archive),
|
||
(6, AgentsOverviewAction::Delete),
|
||
] {
|
||
view.handle_key_event(KeyCode::F(key).into());
|
||
let event = rx.try_recv();
|
||
assert!(
|
||
matches!(event, Ok(AppEvent::ConfirmAgentsOverviewAction { thread_id, action }) if thread_id == target && action == expected),
|
||
"unexpected event: {event:?}"
|
||
);
|
||
}
|
||
view.handle_key_event(KeyCode::F(8).into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::ForkAgentsOverviewThread { thread_id }) if thread_id == target)
|
||
);
|
||
view.handle_key_event(KeyCode::F(7).into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::HideAgentsOverviewThread { thread_id }) if thread_id == target)
|
||
);
|
||
assert!(rx.try_recv().is_err());
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn archiving_selects_the_next_displayed_task() -> Result<()> {
|
||
for action in [AgentsOverviewAction::Archive, AgentsOverviewAction::Delete] {
|
||
let mut selections = Vec::new();
|
||
for grouping in [
|
||
AgentsOverviewGrouping::Project,
|
||
AgentsOverviewGrouping::Status,
|
||
AgentsOverviewGrouping::Model,
|
||
] {
|
||
for filtered in [false, true] {
|
||
let (mut app, mut rx, _op_rx) =
|
||
crate::app::tests::make_test_app_with_channels().await;
|
||
let mut app_server =
|
||
crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
tui.pause_events();
|
||
app.app_server_target = AppServerTarget::LocalDaemon {
|
||
allow_embedded_fallback: true,
|
||
endpoint: crate::RemoteAppServerEndpoint::UnixSocket {
|
||
socket_path: test_path_buf("/tmp/unused.sock").abs(),
|
||
},
|
||
};
|
||
let mut keymap = TuiKeymap::default();
|
||
match action {
|
||
AgentsOverviewAction::Archive => {
|
||
keymap.agents.archive =
|
||
Some(KeybindingsSpec::One(KeybindingSpec("f5".into())))
|
||
}
|
||
AgentsOverviewAction::Delete => {
|
||
keymap.agents.delete =
|
||
Some(KeybindingsSpec::One(KeybindingSpec("f5".into())))
|
||
}
|
||
}
|
||
app.keymap = RuntimeKeymap::from_config(&keymap).unwrap();
|
||
let mut threads = Vec::new();
|
||
let mut ids = Vec::new();
|
||
for index in 1..=4 {
|
||
let title = format!("{} {index}", if index == 2 { "Other" } else { "Task" });
|
||
let id = ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
&app.config.codex_home,
|
||
&format!("2025-01-0{index}T12-00-00"),
|
||
&format!("2025-01-0{index}T12:00:00Z"),
|
||
&title,
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("materialize task"),
|
||
)?;
|
||
let mut thread = overview_thread(
|
||
id,
|
||
/*parent_thread_id*/ None,
|
||
&title,
|
||
ThreadStatus::Idle,
|
||
);
|
||
thread.cwd = test_path_buf(&format!("/tmp/project-{index}")).abs().into();
|
||
thread.model = Some(format!("model-{index}"));
|
||
thread.updated_at = index as i64;
|
||
app.agents_overview.threads.insert(id, Some(thread.clone()));
|
||
threads.push(thread);
|
||
ids.push(id);
|
||
}
|
||
// Task 1 exercises rebuilding the dashboard after archiving the attached task.
|
||
let resumed = app_server
|
||
.resume_thread(
|
||
&app.local_settings,
|
||
app.config.clone(),
|
||
ids[0],
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
)
|
||
.await?;
|
||
app.enqueue_primary_thread_session(resumed.session, resumed.turns)
|
||
.await?;
|
||
app.agents_overview.view_state.lock().unwrap().grouping = grouping;
|
||
let mut view = app.agents_overview_view(threads, Some(ids[2]));
|
||
if filtered {
|
||
view.handle_key_event(KeyCode::Char('/').into());
|
||
view.handle_paste("Task".into());
|
||
view.handle_key_event(KeyCode::Down.into());
|
||
}
|
||
let expected = match (grouping, filtered) {
|
||
(AgentsOverviewGrouping::Status, false) => vec![3, 2, 1, 4],
|
||
(AgentsOverviewGrouping::Status, true) => vec![3, 1, 4],
|
||
(
|
||
AgentsOverviewGrouping::Project
|
||
| AgentsOverviewGrouping::Directory
|
||
| AgentsOverviewGrouping::Model,
|
||
false,
|
||
) => {
|
||
vec![3, 4, 2, 1]
|
||
}
|
||
(
|
||
AgentsOverviewGrouping::Project
|
||
| AgentsOverviewGrouping::Directory
|
||
| AgentsOverviewGrouping::Model,
|
||
true,
|
||
) => {
|
||
vec![3, 4, 1]
|
||
}
|
||
};
|
||
assert_eq!(
|
||
view.selection_after_removal(&HashSet::from([ids[2], ids[expected[1] - 1]])),
|
||
Some(ids[expected[2] - 1])
|
||
);
|
||
app.agents_overview.visible_thread_ids = view.thread_ids();
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
for index in expected {
|
||
let selected = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.unwrap();
|
||
assert_eq!(
|
||
app.agents_overview.visible_thread_ids.get(selected),
|
||
Some(&ids[index - 1])
|
||
);
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 100);
|
||
let selected_row = rendered
|
||
.lines()
|
||
.find(|line| line.trim_start().starts_with('›'))
|
||
.expect("selected task");
|
||
let selected_row = selected_row.split('│').next().unwrap().trim();
|
||
if !filtered && grouping == AgentsOverviewGrouping::Status {
|
||
selections.push(selected_row.to_owned());
|
||
}
|
||
if !filtered {
|
||
app.chat_widget.handle_key_event(KeyCode::Char('r').into());
|
||
}
|
||
app.chat_widget.handle_key_event(KeyCode::F(5).into());
|
||
let confirmation = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::ConfirmAgentsOverviewAction { .. }))
|
||
.expect("archive shortcut while editing");
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, confirmation)).await?;
|
||
app.chat_widget.handle_key_event(KeyCode::Char('2').into());
|
||
if action == AgentsOverviewAction::Delete {
|
||
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
||
}
|
||
let confirmed = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::RunAgentsOverviewAction { .. }))
|
||
.expect("confirmed archive");
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, confirmed)).await?;
|
||
// Later repaints retain the selected successor.
|
||
app.repaint_agents_overview();
|
||
}
|
||
let selected = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.unwrap();
|
||
assert_eq!(app.agents_overview.visible_thread_ids.get(selected), None);
|
||
assert_eq!(app.agents_overview.selection_after_removal, None);
|
||
app_server.shutdown().await?;
|
||
}
|
||
}
|
||
if matches!(action, AgentsOverviewAction::Archive) {
|
||
insta::assert_snapshot!(
|
||
"archiving_selects_the_next_displayed_task",
|
||
selections.join("\n")
|
||
);
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn archiving_keeps_another_backends_page_in_flight() -> Result<()> {
|
||
let mut app = make_test_app().await;
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
app.backend_registry.connect(&app_server);
|
||
let rollout_id = app_test_support::create_fake_rollout(
|
||
&app.config.codex_home,
|
||
"2025-01-01T12-00-00",
|
||
"2025-01-01T12:00:00Z",
|
||
"Local task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.map_err(color_eyre::eyre::Report::msg)?;
|
||
let thread_id = ThreadId::from_string(&rollout_id)?;
|
||
app.backend_registry
|
||
.observe(app_server.backend_id(), thread_id);
|
||
let foreign = crate::backend_id::BackendId::new();
|
||
let foreign_thread = ThreadId::new();
|
||
app.backend_registry.observe(foreign, foreign_thread);
|
||
let foreign_request = Uuid::new_v4();
|
||
app.agents_overview.active_refresh = Some((foreign_request, foreign));
|
||
app.agents_overview.refresh_show_more = true;
|
||
for id in [thread_id, foreign_thread] {
|
||
app.track_agents_overview_notification(&ServerNotification::ThreadStarted(
|
||
codex_app_server_protocol::ThreadStartedNotification {
|
||
thread: overview_thread(
|
||
id,
|
||
/*parent_thread_id*/ None,
|
||
"Task",
|
||
ThreadStatus::Idle,
|
||
),
|
||
},
|
||
));
|
||
}
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
tui.pause_events();
|
||
|
||
Box::pin(app.run_agents_overview_action(
|
||
&mut tui,
|
||
&mut app_server,
|
||
thread_id,
|
||
AgentsOverviewAction::Archive,
|
||
))
|
||
.await?;
|
||
|
||
let overview = &app.agents_overview;
|
||
assert!(overview.removed_threads.contains(&thread_id));
|
||
assert_eq!(overview.active_refresh, Some((foreign_request, foreign)));
|
||
assert!(overview.refresh_show_more);
|
||
assert!(!overview.refresh_notifications.contains_key(&thread_id));
|
||
assert!(overview.refresh_notifications.contains_key(&foreign_thread));
|
||
assert!(
|
||
overview
|
||
.pending_refresh_backends
|
||
.contains(&app_server.backend_id())
|
||
);
|
||
app.apply_agents_overview_thread_refresh(
|
||
&app_server,
|
||
foreign_request,
|
||
Ok(crate::app_event::AgentsOverviewThreadRefresh {
|
||
cleared_unread: Vec::new(),
|
||
threads: HashMap::new(),
|
||
last_messages: HashMap::new(),
|
||
recent_seed_complete: true,
|
||
discovery: None,
|
||
pinned_thread_ids: None,
|
||
}),
|
||
);
|
||
assert!(app.agents_overview.removed_threads.contains(&thread_id));
|
||
assert!(!app.agents_overview.threads.contains_key(&thread_id));
|
||
assert!(app.agents_overview.threads.contains_key(&foreign_thread));
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn external_removals_preserve_adjacent_selection() {
|
||
for grouping in [
|
||
AgentsOverviewGrouping::Project,
|
||
AgentsOverviewGrouping::Directory,
|
||
AgentsOverviewGrouping::Status,
|
||
AgentsOverviewGrouping::Model,
|
||
] {
|
||
for filtered in [false, true] {
|
||
let mut app = make_test_app().await;
|
||
let ids = [1, 2, 3, 4].map(ThreadId::from_u128);
|
||
let threads = ids
|
||
.iter()
|
||
.enumerate()
|
||
.map(|(index, id)| {
|
||
let mut thread = overview_thread(
|
||
*id,
|
||
/*parent_thread_id*/ None,
|
||
if index == 1 { "Other" } else { "Task" },
|
||
ThreadStatus::Idle,
|
||
);
|
||
thread.cwd = test_path_buf(&format!("/tmp/project-{index}")).abs().into();
|
||
thread.model = Some(format!("model-{index}"));
|
||
thread.updated_at = index as i64;
|
||
thread
|
||
})
|
||
.collect::<Vec<_>>();
|
||
app.agents_overview.threads = ids
|
||
.into_iter()
|
||
.zip(threads.iter().cloned().map(Some))
|
||
.collect();
|
||
app.agents_overview.view_state.lock().unwrap().grouping = grouping;
|
||
let mut view = app.agents_overview_view(threads, Some(ids[2]));
|
||
if filtered {
|
||
view.handle_key_event(KeyCode::Char('/').into());
|
||
view.handle_paste("Task".into());
|
||
view.handle_key_event(KeyCode::Down.into());
|
||
}
|
||
app.agents_overview.visible_thread_ids = view.thread_ids();
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
// Removing another task must retain selection even when its index changes.
|
||
let other = ServerNotification::ThreadDeleted(ThreadDeletedNotification {
|
||
thread_id: ids[1].to_string(),
|
||
});
|
||
app.track_agents_overview_notification(&other);
|
||
app.repaint_agents_overview();
|
||
let selected = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.unwrap();
|
||
assert_eq!(
|
||
app.agents_overview.visible_thread_ids.get(selected),
|
||
Some(&ids[2])
|
||
);
|
||
let expected = match grouping {
|
||
AgentsOverviewGrouping::Status => [ids[0], ids[3]],
|
||
AgentsOverviewGrouping::Project
|
||
| AgentsOverviewGrouping::Directory
|
||
| AgentsOverviewGrouping::Model => [ids[3], ids[0]],
|
||
};
|
||
let archive = ServerNotification::ThreadArchived(ThreadArchivedNotification {
|
||
thread_id: ids[2].to_string(),
|
||
});
|
||
app.track_agents_overview_notification(&archive);
|
||
app.track_agents_overview_notification(&archive);
|
||
assert_eq!(
|
||
app.agents_overview.selection_after_removal,
|
||
Some(expected[0])
|
||
);
|
||
// A notification burst can remove the pending successor before repaint.
|
||
let delete = ServerNotification::ThreadDeleted(ThreadDeletedNotification {
|
||
thread_id: expected[0].to_string(),
|
||
});
|
||
app.track_agents_overview_notification(&delete);
|
||
app.track_agents_overview_notification(&archive);
|
||
app.repaint_agents_overview();
|
||
app.repaint_agents_overview();
|
||
let selected = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.unwrap();
|
||
assert_eq!(
|
||
app.agents_overview.visible_thread_ids.get(selected),
|
||
Some(&expected[1])
|
||
);
|
||
app.track_agents_overview_notification(&ServerNotification::ThreadDeleted(
|
||
ThreadDeletedNotification {
|
||
thread_id: expected[1].to_string(),
|
||
},
|
||
));
|
||
app.repaint_agents_overview();
|
||
let selected = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.unwrap();
|
||
assert_eq!(app.agents_overview.visible_thread_ids.get(selected), None);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hiding_tasks_keeps_selection_adjacent_in_display_order() -> Result<()> {
|
||
let (mut app, mut rx, _op_rx) = crate::app::tests::make_test_app_with_channels().await;
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let threads = (1..=4)
|
||
.map(|index| {
|
||
let mut thread = overview_thread(
|
||
ThreadId::from_u128(index),
|
||
/*parent_thread_id*/ None,
|
||
if index == 2 { "Other" } else { "Task" },
|
||
ThreadStatus::Idle,
|
||
);
|
||
thread.name = Some(format!("{} {index}", thread.preview));
|
||
thread.cwd = test_path_buf(&format!("/tmp/project-{index}")).abs().into();
|
||
thread.model = Some(format!("model-{index}"));
|
||
thread.updated_at = index as i64;
|
||
thread
|
||
})
|
||
.collect::<Vec<_>>();
|
||
app.primary_thread_id = Some(ThreadId::from_u128(/*value*/ 1));
|
||
app.agents_overview.threads = threads
|
||
.iter()
|
||
.map(|thread| {
|
||
(
|
||
ThreadId::from_string(&thread.id).unwrap(),
|
||
Some(thread.clone()),
|
||
)
|
||
})
|
||
.collect();
|
||
let age = regex_lite::Regex::new(r"\d+d ago$").unwrap();
|
||
let mut selections = Vec::new();
|
||
for grouping in [
|
||
AgentsOverviewGrouping::Project,
|
||
AgentsOverviewGrouping::Directory,
|
||
AgentsOverviewGrouping::Status,
|
||
AgentsOverviewGrouping::Model,
|
||
] {
|
||
for filtered in [false, true] {
|
||
app.agents_overview.hidden_threads.clear();
|
||
app.agents_overview.view_state.lock().unwrap().grouping = grouping;
|
||
let mut keymap = TuiKeymap::default();
|
||
let hide_key = if filtered {
|
||
KeyCode::F(7)
|
||
} else {
|
||
KeyCode::Char('h')
|
||
};
|
||
if filtered {
|
||
keymap.agents.hide = Some(KeybindingsSpec::One(KeybindingSpec("f7".into())));
|
||
}
|
||
app.keymap = RuntimeKeymap::from_config(&keymap).unwrap();
|
||
let mut view =
|
||
app.agents_overview_view(threads.clone(), Some(ThreadId::from_u128(/*value*/ 3)));
|
||
// Clear retained search without dismissing the command center.
|
||
view.on_ctrl_c();
|
||
if filtered {
|
||
view.handle_key_event(KeyCode::Char('/').into());
|
||
view.handle_paste("Task".into());
|
||
// Search selects the first match; move back to Task 3.
|
||
view.handle_key_event(KeyCode::Down.into());
|
||
}
|
||
app.agents_overview.visible_thread_ids = view.thread_ids();
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
let expected = match (grouping, filtered) {
|
||
// Status displays tasks newest first: 4, 3, 2, 1.
|
||
(AgentsOverviewGrouping::Status, false) => vec![3, 2, 1, 4],
|
||
(AgentsOverviewGrouping::Status, true) => vec![3, 1, 4],
|
||
(
|
||
AgentsOverviewGrouping::Project
|
||
| AgentsOverviewGrouping::Directory
|
||
| AgentsOverviewGrouping::Model,
|
||
false,
|
||
) => {
|
||
vec![3, 4, 2, 1]
|
||
}
|
||
(
|
||
AgentsOverviewGrouping::Project
|
||
| AgentsOverviewGrouping::Directory
|
||
| AgentsOverviewGrouping::Model,
|
||
true,
|
||
) => {
|
||
vec![3, 4, 1]
|
||
}
|
||
};
|
||
for index in expected {
|
||
let selected = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.unwrap();
|
||
assert_eq!(
|
||
app.agents_overview.visible_thread_ids[selected],
|
||
ThreadId::from_u128(index),
|
||
"{grouping:?}, filtered={filtered}"
|
||
);
|
||
let rendered = render_bottom_popup(&app.chat_widget, /*width*/ 100);
|
||
let selected_row = rendered
|
||
.lines()
|
||
.find(|line| line.trim_start().starts_with('›'))
|
||
.expect("selected task row");
|
||
let selected_row = selected_row.split('│').next().unwrap().trim();
|
||
selections.push(format!(
|
||
"{grouping:?}, filtered={filtered}: {}",
|
||
age.replace(selected_row, "[age]")
|
||
));
|
||
app.chat_widget.handle_key_event(hide_key.into());
|
||
let hide = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::HideAgentsOverviewThread { .. }))
|
||
.expect("hide action emits an event");
|
||
assert!(matches!(
|
||
&hide,
|
||
AppEvent::HideAgentsOverviewThread { thread_id }
|
||
if *thread_id == ThreadId::from_u128(index)
|
||
));
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, hide)).await?;
|
||
}
|
||
let selected = app
|
||
.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.unwrap();
|
||
assert_eq!(app.agents_overview.visible_thread_ids.get(selected), None);
|
||
app.chat_widget.handle_key_event(hide_key.into());
|
||
assert!(
|
||
!std::iter::from_fn(|| rx.try_recv().ok())
|
||
.any(|event| matches!(event, AppEvent::HideAgentsOverviewThread { .. }))
|
||
);
|
||
}
|
||
}
|
||
insta::assert_snapshot!(selections.join("\n"));
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hiding_rename_target_does_not_transfer_draft_to_neighbor() -> Result<()> {
|
||
let (mut app, mut rx, _op_rx) = crate::app::tests::make_test_app_with_channels().await;
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let mut keymap = TuiKeymap::default();
|
||
keymap.agents.hide = Some(KeybindingsSpec::One(KeybindingSpec("f7".into())));
|
||
app.keymap = RuntimeKeymap::from_config(&keymap).unwrap();
|
||
let threads = ["Rename target", "Neighbor"]
|
||
.into_iter()
|
||
.map(|name| {
|
||
overview_thread(
|
||
ThreadId::new(),
|
||
/*parent_thread_id*/ None,
|
||
name,
|
||
ThreadStatus::Idle,
|
||
)
|
||
})
|
||
.collect::<Vec<_>>();
|
||
let target = ThreadId::from_string(&threads[0].id)?;
|
||
app.agents_overview.threads = threads
|
||
.iter()
|
||
.map(|thread| {
|
||
(
|
||
ThreadId::from_string(&thread.id).unwrap(),
|
||
Some(thread.clone()),
|
||
)
|
||
})
|
||
.collect();
|
||
let mut view = app.agents_overview_view(threads, Some(target));
|
||
view.handle_key_event(KeyCode::Char('r').into());
|
||
view.handle_paste("Unsubmitted title".into());
|
||
app.agents_overview.visible_thread_ids = view.thread_ids();
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
app.chat_widget.handle_key_event(KeyCode::F(7).into());
|
||
let hide = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::HideAgentsOverviewThread { .. }))
|
||
.expect("hide shortcut emits an event");
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, hide)).await?;
|
||
{
|
||
let state = app.agents_overview.view_state.lock().unwrap();
|
||
assert_eq!(
|
||
(state.rename_target.is_some(), state.input.text()),
|
||
(false, "")
|
||
);
|
||
}
|
||
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
||
assert!(
|
||
!std::iter::from_fn(|| rx.try_recv().ok())
|
||
.any(|event| matches!(event, AppEvent::RenameAgentsOverviewThread { .. }))
|
||
);
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn hidden_task_stays_hidden_through_activity_and_seed_until_explicit_resume() -> Result<()> {
|
||
let (mut app, mut rx, _op_rx) = crate::app::tests::make_test_app_with_channels().await;
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let backend_id = app_server.backend_id();
|
||
let started = app_server.start_thread(&app.config).await?;
|
||
let id = started.session.thread_id;
|
||
app.enqueue_primary_thread_session(started.session, started.turns)
|
||
.await?;
|
||
let thread = overview_thread(
|
||
id,
|
||
/*parent_thread_id*/ None,
|
||
"Hidden task",
|
||
ThreadStatus::Idle,
|
||
);
|
||
app.agents_overview.threads.insert(id, Some(thread.clone()));
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
let view = app.agents_overview_view(vec![thread.clone()], Some(id));
|
||
app.chat_widget.show_bottom_pane_view(Box::new(view));
|
||
app.chat_widget
|
||
.handle_key_event(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::NONE));
|
||
let hide = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::HideAgentsOverviewThread { .. }))
|
||
.expect("shortcut requests hiding the task");
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, hide)).await?;
|
||
app.track_agents_overview_notification(&ServerNotification::ThreadStarted(
|
||
ThreadStartedNotification {
|
||
thread: thread.clone(),
|
||
},
|
||
));
|
||
app.track_agents_overview_notification(&ServerNotification::ThreadStatusChanged(
|
||
codex_app_server_protocol::ThreadStatusChangedNotification {
|
||
thread_id: id.to_string(),
|
||
status: ThreadStatus::Active {
|
||
active_flags: Vec::new(),
|
||
},
|
||
},
|
||
));
|
||
app.track_agents_overview_notification(&ServerNotification::ThreadClosed(
|
||
ThreadClosedNotification {
|
||
thread_id: id.to_string(),
|
||
},
|
||
));
|
||
let request_id = Uuid::new_v4();
|
||
app.agents_overview.initialized.clear();
|
||
app.agents_overview.active_refresh = Some((request_id, app_server.backend_id()));
|
||
app.apply_agents_overview_thread_refresh(
|
||
&app_server,
|
||
request_id,
|
||
Ok(AgentsOverviewThreadRefresh {
|
||
cleared_unread: Vec::new(),
|
||
threads: HashMap::from([(id, Some((thread.clone(), false, None)))]),
|
||
last_messages: HashMap::new(),
|
||
recent_seed_complete: true,
|
||
discovery: None,
|
||
pinned_thread_ids: None,
|
||
}),
|
||
);
|
||
assert_eq!(
|
||
app.agents_overview_view(vec![thread.clone()], /*selected_thread_id*/ None)
|
||
.thread_ids(),
|
||
Vec::<ThreadId>::new()
|
||
);
|
||
assert_eq!(app.primary_thread_id, Some(id));
|
||
app.resume_target_session(
|
||
&mut tui,
|
||
&mut app_server,
|
||
SessionTarget {
|
||
backend_id,
|
||
thread_id: id,
|
||
path: None,
|
||
cwd: None,
|
||
history_mode: None,
|
||
},
|
||
)
|
||
.await?;
|
||
assert_eq!(
|
||
app.agents_overview_view(vec![thread], /*selected_thread_id*/ None)
|
||
.thread_ids(),
|
||
vec![id]
|
||
);
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn rejected_delete_preserves_a_live_attachment_and_draft() -> Result<()> {
|
||
let (mut app, _rx, _op_rx) = crate::app::tests::make_test_app_with_channels().await;
|
||
app.config.ephemeral = true;
|
||
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
||
let started = app_server.start_thread(&app.config).await?;
|
||
let id = started.session.thread_id;
|
||
app.enqueue_primary_thread_session(started.session, started.turns)
|
||
.await?;
|
||
app.chat_widget
|
||
.apply_external_edit("Keep this draft".into());
|
||
let draft = app.chat_widget.capture_thread_input_state();
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
tui.pause_events();
|
||
// Ephemeral tasks provide a deterministic rejection before server teardown.
|
||
Box::pin(app.run_agents_overview_action(
|
||
&mut tui,
|
||
&mut app_server,
|
||
id,
|
||
AgentsOverviewAction::Delete,
|
||
))
|
||
.await?;
|
||
assert_eq!(
|
||
(app.primary_thread_id, app.chat_widget.thread_id()),
|
||
(Some(id), Some(id))
|
||
);
|
||
assert_eq!(app.chat_widget.capture_thread_input_state(), draft);
|
||
assert!(render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("Could not delete task"));
|
||
app_server.shutdown().await?;
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn lifecycle_removes_background_and_current_tasks_without_losing_the_dashboard() -> Result<()>
|
||
{
|
||
for (action, snapshot, attach_child) in [
|
||
(AgentsOverviewAction::Archive, "archive_task", false),
|
||
(AgentsOverviewAction::Delete, "delete_task", false),
|
||
(AgentsOverviewAction::Archive, "archive_task", true),
|
||
(AgentsOverviewAction::Delete, "delete_task", true),
|
||
] {
|
||
let key = match action {
|
||
AgentsOverviewAction::Archive => KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE),
|
||
AgentsOverviewAction::Delete => KeyCode::Backspace.into(),
|
||
};
|
||
let (mut app, mut rx, _op_rx) =
|
||
Box::pin(crate::app::tests::make_test_app_with_channels()).await;
|
||
let (release, gate) = tokio::sync::oneshot::channel();
|
||
let (server, _completions) = start_streaming_sse_server(vec![vec![
|
||
StreamingSseChunk {
|
||
gate: None,
|
||
body: responses::sse(vec![responses::ev_response_created("running")]),
|
||
},
|
||
StreamingSseChunk {
|
||
gate: Some(gate),
|
||
body: responses::sse(vec![responses::ev_completed("running")]),
|
||
},
|
||
]])
|
||
.await;
|
||
app.config.model = Some("gpt-5.2".into());
|
||
app.config.model_provider_id = "lifecycle-test".into();
|
||
app.config.model_provider = ModelProviderInfo {
|
||
name: "Lifecycle test".into(),
|
||
base_url: Some(format!("{}/v1", server.uri())),
|
||
request_max_retries: Some(0),
|
||
stream_max_retries: Some(0),
|
||
..ModelProviderInfo::default()
|
||
};
|
||
app_test_support::MockResponsesConfig::new(server.uri())
|
||
.with_model("gpt-5.2")
|
||
.with_model_provider("lifecycle-test")
|
||
.with_provider_name("Lifecycle test")
|
||
.write(app.config.codex_home.as_path())?;
|
||
let mut app_server =
|
||
Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
||
let id = ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
&app.config.codex_home,
|
||
"2025-01-05T12-00-00",
|
||
"2025-01-05T12:00:00Z",
|
||
"Current task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("materialize session"),
|
||
)?;
|
||
let primary = if attach_child {
|
||
let child = ThreadId::from_string(
|
||
&app_test_support::create_fake_parented_rollout_with_source(
|
||
&app.config.codex_home,
|
||
"2025-01-05T12-01-00",
|
||
"2025-01-05T12:01:00Z",
|
||
"Current child",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
codex_protocol::protocol::SessionSource::SubAgent(
|
||
SubAgentSource::ThreadSpawn {
|
||
parent_thread_id: id,
|
||
depth: 1,
|
||
agent_path: None,
|
||
agent_nickname: None,
|
||
agent_role: None,
|
||
},
|
||
),
|
||
codex_protocol::SessionId::from(id),
|
||
id,
|
||
)
|
||
.expect("materialize child session"),
|
||
)?;
|
||
let state_db = codex_state::StateRuntime::init(
|
||
codex_state::SqliteConfig::new_for_testing(app.config.codex_home.clone()),
|
||
app.config.model_provider_id.clone(),
|
||
)
|
||
.await
|
||
.expect("initialize spawn state");
|
||
state_db
|
||
.upsert_thread_spawn_edge(
|
||
id,
|
||
child,
|
||
codex_state::DirectionalThreadSpawnEdgeStatus::Open,
|
||
)
|
||
.await
|
||
.expect("persist spawn edge");
|
||
app.agents_overview.threads.insert(
|
||
child,
|
||
Some(overview_thread(
|
||
child,
|
||
Some(id),
|
||
"Current child",
|
||
ThreadStatus::Idle,
|
||
)),
|
||
);
|
||
child
|
||
} else {
|
||
id
|
||
};
|
||
let resumed = Box::pin(app_server.resume_thread(
|
||
&app.local_settings,
|
||
app.config.clone(),
|
||
primary,
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
))
|
||
.await?;
|
||
app.enqueue_primary_thread_session(resumed.session, resumed.turns)
|
||
.await?;
|
||
app.agents_overview.threads.insert(
|
||
id,
|
||
Some(overview_thread(
|
||
id,
|
||
/*parent_thread_id*/ None,
|
||
"Current task",
|
||
ThreadStatus::Idle,
|
||
)),
|
||
);
|
||
app.app_server_target = AppServerTarget::LocalDaemon {
|
||
allow_embedded_fallback: true,
|
||
endpoint: crate::RemoteAppServerEndpoint::UnixSocket {
|
||
socket_path: test_path_buf("/tmp/unused.sock").abs(),
|
||
},
|
||
};
|
||
let mut tui = crate::tui::test_support::make_test_tui()?;
|
||
tui.pause_events();
|
||
app.backend_registry.connect(&app_server);
|
||
app.open_agents_overview(&app_server);
|
||
if action == AgentsOverviewAction::Archive {
|
||
let rollout = app_server
|
||
.thread_read(id, /*include_turns*/ false)
|
||
.await?
|
||
.path
|
||
.expect("saved root history");
|
||
let blocked_archive = app
|
||
.config
|
||
.codex_home
|
||
.join("archived_sessions")
|
||
.join(rollout.file_name().unwrap());
|
||
std::fs::create_dir_all(&blocked_archive)?;
|
||
Box::pin(app.run_agents_overview_action(&mut tui, &mut app_server, id, action)).await?;
|
||
assert_eq!(
|
||
(app.primary_thread_id, app.chat_widget.thread_id()),
|
||
(None, None)
|
||
);
|
||
assert_eq!(app.agents_overview.visible_thread_ids, vec![id]);
|
||
assert_eq!(
|
||
app_server
|
||
.thread_read(primary, /*include_turns*/ false)
|
||
.await?
|
||
.status,
|
||
ThreadStatus::NotLoaded
|
||
);
|
||
let error = render_bottom_popup(&app.chat_widget, /*width*/ 40);
|
||
assert!(error.contains("Could not archive task"));
|
||
assert!(error.contains("Work may have stopped."));
|
||
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
||
assert!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.is_some()
|
||
);
|
||
std::fs::remove_dir(&blocked_archive)?;
|
||
let resumed = Box::pin(app_server.resume_thread(
|
||
&app.local_settings,
|
||
app.config.clone(),
|
||
primary,
|
||
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
||
))
|
||
.await?;
|
||
app.enqueue_primary_thread_session(resumed.session, resumed.turns)
|
||
.await?;
|
||
app.open_agents_overview(&app_server);
|
||
}
|
||
let background = ThreadId::from_string(
|
||
&app_test_support::create_fake_rollout(
|
||
&app.config.codex_home,
|
||
"2025-01-05T13-00-00",
|
||
"2025-01-05T13:00:00Z",
|
||
"Background task",
|
||
Some(&app.config.model_provider_id),
|
||
/*git_info*/ None,
|
||
)
|
||
.expect("materialize background session"),
|
||
)?;
|
||
let child = ThreadId::new();
|
||
let grandchild = ThreadId::new();
|
||
for (target, parent) in [
|
||
(background, None),
|
||
(child, Some(background)),
|
||
(grandchild, Some(child)),
|
||
] {
|
||
app.agents_overview.threads.insert(
|
||
target,
|
||
Some(overview_thread(
|
||
target,
|
||
parent,
|
||
"Background task",
|
||
ThreadStatus::NotLoaded,
|
||
)),
|
||
);
|
||
}
|
||
// Cached details and approval state are invalidated as a group after success.
|
||
let request_id = Uuid::new_v4();
|
||
app.agents_overview.active_refresh = Some((request_id, app_server.backend_id()));
|
||
let stale_threads = app.agents_overview.threads.clone();
|
||
Box::pin(app.run_agents_overview_action(&mut tui, &mut app_server, background, action))
|
||
.await?;
|
||
app.apply_agents_overview_thread_refresh(
|
||
&app_server,
|
||
request_id,
|
||
Ok(AgentsOverviewThreadRefresh {
|
||
cleared_unread: Vec::new(),
|
||
threads: stale_threads
|
||
.into_iter()
|
||
.map(|(id, thread)| (id, thread.map(|thread| (thread, false, None))))
|
||
.collect(),
|
||
last_messages: HashMap::new(),
|
||
recent_seed_complete: true,
|
||
discovery: None,
|
||
pinned_thread_ids: None,
|
||
}),
|
||
);
|
||
assert_eq!(
|
||
(app.primary_thread_id, app.chat_widget.thread_id()),
|
||
(Some(primary), Some(primary))
|
||
);
|
||
assert_eq!(app.agents_overview.visible_thread_ids, vec![id]);
|
||
assert_eq!(
|
||
app.agents_overview
|
||
.threads
|
||
.keys()
|
||
.copied()
|
||
.collect::<std::collections::HashSet<_>>(),
|
||
std::collections::HashSet::from([id, primary])
|
||
);
|
||
Box::pin(app.run_agents_overview_action(
|
||
&mut tui,
|
||
&mut app_server,
|
||
ThreadId::from_string("00000000-0000-0000-0000-000000000001")?,
|
||
action,
|
||
))
|
||
.await?;
|
||
assert_eq!(
|
||
(app.primary_thread_id, app.chat_widget.thread_id()),
|
||
(Some(primary), Some(primary))
|
||
);
|
||
insta::assert_snapshot!(
|
||
format!("{snapshot}_failure"),
|
||
render_bottom_popup(&app.chat_widget, /*width*/ 80)
|
||
);
|
||
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
||
app_server
|
||
.request_handle()
|
||
.request_typed::<TurnStartResponse>(ClientRequest::TurnStart {
|
||
request_id: RequestId::String(Uuid::new_v4().to_string()),
|
||
params: TurnStartParams {
|
||
thread_id: primary.to_string(),
|
||
input: vec![codex_app_server_protocol::UserInput::Text {
|
||
text: "Keep working".into(),
|
||
text_elements: Vec::new(),
|
||
}],
|
||
..Default::default()
|
||
},
|
||
})
|
||
.await?;
|
||
tokio::time::timeout(
|
||
std::time::Duration::from_secs(/*secs*/ 5),
|
||
server.wait_for_request_count(/*count*/ 1),
|
||
)
|
||
.await?;
|
||
assert!(matches!(
|
||
app_server
|
||
.thread_read(primary, /*include_turns*/ false)
|
||
.await?
|
||
.status,
|
||
ThreadStatus::Active { .. }
|
||
));
|
||
app.chat_widget.handle_key_event(key);
|
||
let confirmation = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::ConfirmAgentsOverviewAction { .. }))
|
||
.expect("shortcut requests confirmation");
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, confirmation)).await?;
|
||
insta::assert_snapshot!(
|
||
format!("{snapshot}_confirmation"),
|
||
normalize_agent_center_snapshot(render_bottom_popup(
|
||
&app.chat_widget,
|
||
/*width*/ 80
|
||
))
|
||
);
|
||
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
||
assert!(
|
||
!std::iter::from_fn(|| rx.try_recv().ok())
|
||
.any(|event| matches!(event, AppEvent::RunAgentsOverviewAction { .. }))
|
||
);
|
||
app.chat_widget.handle_key_event(key);
|
||
let confirmation = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::ConfirmAgentsOverviewAction { .. }))
|
||
.expect("shortcut requests confirmation again");
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, confirmation)).await?;
|
||
app.chat_widget.handle_key_event(KeyCode::Down.into());
|
||
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
||
let confirmed = std::iter::from_fn(|| rx.try_recv().ok())
|
||
.find(|event| matches!(event, AppEvent::RunAgentsOverviewAction { .. }))
|
||
.expect("confirmation requests lifecycle action");
|
||
if attach_child {
|
||
// Removal must not depend on the overview having the primary or its ancestors cached.
|
||
app.agents_overview.threads.remove(&primary);
|
||
}
|
||
crate::chatwidget::activate_voice_for_thread(&mut app.chat_widget, primary);
|
||
// Canceling pagination must allow automatic refill to finish after removing the last task.
|
||
app.agents_overview
|
||
.initialized
|
||
.insert(app_server.backend_id());
|
||
app.agents_overview.view_state.lock().unwrap().loading = true;
|
||
// An invalidated refresh can already be queued when the lifecycle action
|
||
// aborts its task. It must not satisfy the wait for the replacement refresh.
|
||
app.app_event_tx
|
||
.send(AppEvent::AgentsOverviewThreadsLoaded {
|
||
request_id,
|
||
result: Ok(AgentsOverviewThreadRefresh {
|
||
cleared_unread: Vec::new(),
|
||
threads: HashMap::new(),
|
||
last_messages: HashMap::new(),
|
||
recent_seed_complete: true,
|
||
discovery: None,
|
||
pinned_thread_ids: None,
|
||
}),
|
||
});
|
||
Box::pin(app.handle_event(&mut tui, &mut app_server, confirmed)).await?;
|
||
if app.agents_overview.active_refresh.is_some() {
|
||
finish_overview_refresh(&mut app, &app_server, &mut rx).await;
|
||
}
|
||
assert!(!app.agents_overview.view_state.lock().unwrap().loading);
|
||
assert_eq!(app.voice_owner_thread_id(), None);
|
||
assert_eq!(
|
||
(
|
||
app.primary_thread_id,
|
||
app.current_displayed_thread_id(),
|
||
app.chat_widget.thread_id()
|
||
),
|
||
(None, None, None)
|
||
);
|
||
assert_eq!(
|
||
app.agents_overview.visible_thread_ids,
|
||
Vec::<ThreadId>::new()
|
||
);
|
||
assert_eq!(
|
||
app_server
|
||
.thread_loaded_list(ThreadLoadedListParams::default())
|
||
.await?
|
||
.data,
|
||
Vec::<String>::new()
|
||
);
|
||
assert!(
|
||
app.chat_widget
|
||
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
||
.is_some()
|
||
);
|
||
match action {
|
||
AgentsOverviewAction::Archive => {
|
||
app_server.thread_unarchive(id).await?;
|
||
}
|
||
AgentsOverviewAction::Delete => {
|
||
assert!(
|
||
app_server
|
||
.thread_read(id, /*include_turns*/ false)
|
||
.await
|
||
.is_err()
|
||
);
|
||
}
|
||
}
|
||
app_server.shutdown().await?;
|
||
drop(release);
|
||
server.shutdown().await;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn fork_shortcut_respects_metadata_editing() {
|
||
let (app, mut rx, _) = crate::app::tests::make_test_app_with_channels().await;
|
||
let target = ThreadId::new();
|
||
let mut view = app.agents_overview_view(
|
||
vec![overview_thread(
|
||
target,
|
||
/*parent_thread_id*/ None,
|
||
"Target",
|
||
ThreadStatus::Idle,
|
||
)],
|
||
Some(target),
|
||
);
|
||
for editor in ['r', '/'] {
|
||
view.handle_key_event(KeyCode::Char(editor).into());
|
||
view.handle_key_event(KeyCode::Char('f').into());
|
||
if editor == '/' {
|
||
assert!(matches!(
|
||
rx.try_recv(),
|
||
Ok(AppEvent::SearchAgentsOverview(..))
|
||
));
|
||
}
|
||
assert!(rx.try_recv().is_err());
|
||
view.handle_key_event(KeyCode::Esc.into());
|
||
}
|
||
view.handle_key_event(KeyCode::Char('f').into());
|
||
assert!(
|
||
matches!(rx.try_recv(), Ok(AppEvent::ForkAgentsOverviewThread { thread_id }) if thread_id == target)
|
||
);
|
||
}
|