Enable MCP user verification in the TUI (#43712)

## Why

The TUI automatically canceled MCP user verification requests, preventing users from completing verification and approving them.

## What changed

- Show verification prompts for active and inactive threads, with actions to verify and approve or cancel.
- Run approved verification through the local app-server's `userVerification/verify` RPC and return the proof to the original request. Cancel on failure and show a warning in the requesting thread; remote workspaces remain unsupported.
- Deduplicate prompts, preserve foreground streaming when another thread requests verification, and surface queued prompts when returning from a side conversation.
- Cancel verification when its thread is discarded and ignore stale results after cancellation.

## Testing

Add RPC, routing, and snapshot tests covering successful verification, unsupported binaries and remote workspaces, cancellation and late proofs, prompt replay, side conversation switching, and foreground stream preservation.

GitOrigin-RevId: 2ae12f47c443e17de25f4ec033f6078ac28b1e03
This commit is contained in:
riley-oai authored and copyberry committed 2026-09-08 05:39:17 +00:00
1 parent 95327467c3
commit c7f81afc19
23 files changed
+1060 -29

No files matched your search

+5 -2
View File
@@ -257,9 +257,8 @@ mod thread_session_state;
mod thread_settings; mod thread_settings;
mod thread_title; mod thread_title;
mod transcript_export; mod transcript_export;
#[cfg_attr(not(test), allow(dead_code))] mod user_verification;
mod user_verification_errors; mod user_verification_errors;
#[allow(dead_code)] // Connected by the following verification UI integration.
mod user_verification_requests; mod user_verification_requests;
mod working_directory; mod working_directory;
@@ -282,6 +281,10 @@ enum ThreadInteractiveRequest {
AppLink(AppLinkViewParams), AppLink(AppLinkViewParams),
Approval(ApprovalRequest), Approval(ApprovalRequest),
McpServerElicitation(McpServerElicitationFormRequest), McpServerElicitation(McpServerElicitationFormRequest),
UserVerification {
thread_id: ThreadId,
request: crate::bottom_pane::user_verification::UserVerificationRequest,
},
} }
/// Extracts `receiver_thread_ids` from collab agent tool-call notifications. /// Extracts `receiver_thread_ids` from collab agent tool-call notifications.
@@ -96,6 +96,15 @@ impl PendingAppServerRequests {
self.user_verification.clear(); self.user_verification.clear();
} }
pub(super) fn cancel_thread_verification(&mut self, thread_id: &str) {
for (server_name, request_id) in self.user_verification.cancel_thread(thread_id) {
self.mcp_requests.remove(&McpRequestKey {
server_name,
request_id,
});
}
}
pub(super) fn note_server_request( pub(super) fn note_server_request(
&mut self, &mut self,
request: &ServerRequest, request: &ServerRequest,
+7
View File
@@ -67,6 +67,13 @@ impl App {
} }
match event { match event {
AppEvent::UserVerificationApproved { thread_id, server_name, request_id } => {
Box::pin(self.start_user_verification(app_server, thread_id, server_name, request_id)).await?;
}
AppEvent::UserVerificationFinished { thread_id, server_name, request_id, attempt_id, result } => {
// Keep this RPC future out of the event loop's stack frame.
Box::pin(self.finish_user_verification(app_server, thread_id, server_name, request_id, attempt_id, result)).await?;
}
AppEvent::ReviewMisalignment(review) => { AppEvent::ReviewMisalignment(review) => {
self.open_misalignment_review(tui, review); self.open_misalignment_review(tui, review);
} }
+13 -2
View File
@@ -408,7 +408,14 @@ impl App {
}; };
self.select_agent_thread(tui, app_server, target_thread_id) self.select_agent_thread(tui, app_server, target_thread_id)
.await .await?;
if self.active_thread_id == Some(target_thread_id)
&& self.active_side_parent_thread_id().is_none()
{
self.surface_pending_inactive_thread_interactive_requests()
.await?;
}
Ok(())
} }
pub(super) async fn discard_side_thread( pub(super) async fn discard_side_thread(
@@ -438,6 +445,9 @@ impl App {
app_server: &mut AppServerSession, app_server: &mut AppServerSession,
thread_id: ThreadId, thread_id: ThreadId,
) { ) {
self.abandoned_side_threads.insert(thread_id);
self.pending_app_server_requests
.cancel_thread_verification(&thread_id.to_string());
let turn_id = self let turn_id = self
.active_turn_id_for_thread(thread_id) .active_turn_id_for_thread(thread_id)
.await .await
@@ -447,7 +457,6 @@ impl App {
let retry_interrupt_request_id = app_server.next_request_id(); let retry_interrupt_request_id = app_server.next_request_id();
let unsubscribe_request_id = app_server.next_request_id(); let unsubscribe_request_id = app_server.next_request_id();
self.abandoned_side_threads.insert(thread_id);
self.discard_thread_local_state(thread_id).await; self.discard_thread_local_state(thread_id).await;
tokio::spawn(async move { tokio::spawn(async move {
@@ -497,6 +506,8 @@ impl App {
} }
pub(super) async fn discard_thread_local_state(&mut self, thread_id: ThreadId) { pub(super) async fn discard_thread_local_state(&mut self, thread_id: ThreadId) {
self.pending_app_server_requests
.cancel_thread_verification(&thread_id.to_string());
let app_event_tx = self.app_event_tx.clone(); let app_event_tx = self.app_event_tx.clone();
self.dynamic_tool_tasks self.dynamic_tool_tasks
.retain(|request_id, (source, task)| { .retain(|request_id, (source, task)| {
@@ -0,0 +1,6 @@
---
source: tui/src/app/user_verification_tests.rs
assertion_line: 275
expression: rendered
---
⚠ The local Codex binary could not complete user verification.
@@ -0,0 +1,6 @@
---
source: tui/src/app/user_verification_tests.rs
assertion_line: 273
expression: rendered
---
⚠ User verification is unavailable for remote workspaces.
+2
View File
@@ -65,6 +65,8 @@ mod thread_usage;
mod transcript_composer; mod transcript_composer;
#[path = "tests/turn_submission.rs"] #[path = "tests/turn_submission.rs"]
mod turn_submission; mod turn_submission;
#[path = "tests/user_verification_routes_tests.rs"]
mod user_verification_routes;
use super::*; use super::*;
use crate::app_backtrack::BacktrackSelection; use crate::app_backtrack::BacktrackSelection;
@@ -0,0 +1,6 @@
---
source: tui/src/app/tests/user_verification_routes.rs
assertion_line: 194
expression: "app.render_transcript_lines_for_reflow(80).lines.iter().map(rendered_line_text).collect::<Vec<_>>().join(\"\\n\")"
---
• The foreground answer continues.
@@ -0,0 +1,17 @@
---
source: tui/src/app/tests/user_verification_routes.rs
assertion_line: 67
expression: "render_bottom_popup(&app.chat_widget, 80)"
---
Approve deployment?
Thread: Verifier [worker]
Server: deployments
Verify the production deployment.
› 1. Verify and approve (y)
2. Cancel this request (c)
Press enter to confirm or esc to cancel
@@ -0,0 +1,16 @@
---
source: tui/src/app/tests/user_verification_routes.rs
expression: "render_bottom_popup(&app.chat_widget, 80)"
---
Approve deployment?
Thread: Verifier [worker]
Server: deployments
Verify the production deployment.
› 1. Verify and approve (y)
2. Cancel this request (c)
Press enter to confirm or esc to cancel
@@ -0,0 +1,335 @@
use super::*;
use pretty_assertions::assert_eq;
fn user_verification_server_request(thread_id: ThreadId, request_id: i64) -> ServerRequest {
ServerRequest::McpServerElicitationRequest {
request_id: AppServerRequestId::Integer(request_id),
params: McpServerElicitationRequestParams {
thread_id: thread_id.to_string(),
turn_id: Some("turn-verification".to_string()),
server_name: "deployments".to_string(),
request: McpServerElicitationRequest::UserVerification {
title: "Approve deployment?".to_string(),
description: "Verify the production deployment.".to_string(),
challenge: "AQID".to_string(),
},
},
}
}
async fn next_submitted_thread_op(
app_event_rx: &mut tokio::sync::mpsc::UnboundedReceiver<AppEvent>,
) -> (ThreadId, Op) {
time::timeout(std::time::Duration::from_secs(/*secs*/ 1), async {
loop {
match app_event_rx.recv().await {
Some(AppEvent::SubmitThreadOp { thread_id, op }) => break (thread_id, op),
Some(_) => {}
None => panic!("app event channel closed before submitting an operation"),
}
}
})
.await
.expect("user-verification operation should be submitted promptly")
}
#[tokio::test]
async fn inactive_thread_user_verification_replays_queued_request_once() -> Result<()> {
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
let primary_thread_id = ThreadId::new();
let side_thread_id = ThreadId::new();
let thread_id = ThreadId::new();
let request = user_verification_server_request(thread_id, /*request_id*/ 11);
app.primary_thread_id = Some(primary_thread_id);
app.active_thread_id = Some(side_thread_id);
app.side_threads
.insert(side_thread_id, SideThreadState::new(primary_thread_id));
app.agent_navigation.upsert(
thread_id,
Some("Verifier".to_string()),
Some("worker".to_string()),
/*is_closed*/ false,
);
app.enqueue_thread_request(thread_id, request.clone())
.await?;
assert!(!app.chat_widget.has_active_view());
assert_eq!(
app.pending_inactive_thread_requests().await,
vec![(thread_id, request)]
);
app.side_threads.remove(&side_thread_id);
app.active_thread_id = Some(primary_thread_id);
app.surface_pending_inactive_thread_interactive_requests()
.await?;
app.surface_pending_inactive_thread_interactive_requests()
.await?;
insta::assert_snapshot!(
"inactive_thread_user_verification_prompt",
render_bottom_popup(&app.chat_widget, /*width*/ 80)
);
app.chat_widget
.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert_eq!(
next_submitted_thread_op(&mut app_event_rx).await,
(
thread_id,
Op::ResolveUserVerification {
server_name: "deployments".to_string(),
request_id: AppServerRequestId::Integer(11),
response: crate::app_command::UserVerificationResponse::Cancel,
}
)
);
assert!(!app.chat_widget.has_active_view());
assert!(
!std::iter::from_fn(|| app_event_rx.try_recv().ok())
.any(|event| matches!(event, AppEvent::SubmitThreadOp { .. }))
);
Ok(())
}
#[tokio::test]
async fn side_toggle_surfaces_pending_verification_from_an_inactive_thread() -> Result<()> {
Box::pin(async {
let (mut app, _events, _ops) = make_test_app_with_channels().await;
let mut app_server =
crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;
let primary = app_server.start_thread(&app.config).await?;
let primary_thread_id = primary.session.thread_id;
app.enqueue_primary_thread_session(primary.session, primary.turns)
.await?;
let side_thread_id = ThreadId::new();
app.side_threads
.insert(side_thread_id, SideThreadState::new(primary_thread_id));
app.thread_event_channels.insert(
side_thread_id,
ThreadEventChannel::new_with_session(
/*capacity*/ 4,
test_thread_session(side_thread_id, test_path_buf("/tmp/side")),
Vec::new(),
),
);
let mut tui = crate::tui::test_support::make_test_tui()?;
app.select_agent_thread(&mut tui, &mut app_server, side_thread_id)
.await?;
assert_eq!(app.active_thread_id, Some(side_thread_id));
let agent_thread_id = ThreadId::new();
app.agent_navigation.upsert(
agent_thread_id,
Some("Verifier".to_string()),
Some("worker".to_string()),
/*is_closed*/ false,
);
app.enqueue_thread_request(
agent_thread_id,
user_verification_server_request(agent_thread_id, /*request_id*/ 17),
)
.await?;
assert!(!app.chat_widget.has_active_view());
app.toggle_side_conversation(&mut tui, &mut app_server)
.await?;
assert_eq!(app.active_thread_id, Some(primary_thread_id));
insta::assert_snapshot!(
"side_toggle_surfaces_pending_user_verification",
render_bottom_popup(&app.chat_widget, /*width*/ 80)
);
app_server.shutdown().await?;
Ok(())
})
.await
}
#[tokio::test]
async fn discarding_side_cancels_verification_and_ignores_late_proof() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let mut app_server =
crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?;
let primary_thread_id = ThreadId::new();
let side_thread_id = ThreadId::new();
let request = user_verification_server_request(side_thread_id, /*request_id*/ 19);
app.active_thread_id = Some(primary_thread_id);
app.side_threads
.insert(side_thread_id, SideThreadState::new(primary_thread_id));
app.thread_event_channels
.insert(side_thread_id, ThreadEventChannel::new(/*capacity*/ 4));
app.pending_app_server_requests
.note_server_request(&request);
let attempt = app
.pending_app_server_requests
.user_verification
.begin("deployments", request.id())
.expect("pending side-thread verification");
app.discard_side_thread_in_background(&mut app_server, side_thread_id)
.await;
assert!(attempt.cancelled.is_cancelled());
assert!(
!app.pending_app_server_requests
.contains_server_request(&request)
);
app.finish_user_verification(
&mut app_server,
side_thread_id,
"deployments".to_string(),
request.id().clone(),
attempt.id,
Ok(codex_app_server_protocol::UserVerificationProof {
credential_id: "discarded-credential".to_string(),
signature: "discarded-signature".to_string(),
}),
)
.await?;
assert!(
!std::iter::from_fn(|| events.try_recv().ok())
.any(|event| matches!(event, AppEvent::SubmitThreadOp { .. }))
);
app_server.shutdown().await?;
Ok(())
}
#[tokio::test]
async fn inactive_thread_user_verification_preserves_foreground_stream() -> Result<()> {
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
let foreground_thread_id = ThreadId::new();
let thread_id = ThreadId::new();
app.primary_thread_id = Some(foreground_thread_id);
app.active_thread_id = Some(foreground_thread_id);
app.chat_widget.handle_thread_session(test_thread_session(
foreground_thread_id,
test_path_buf("/tmp/project"),
));
while app_event_rx.try_recv().is_ok() {}
app.chat_widget.handle_server_notification(
agent_message_delta_notification(
foreground_thread_id,
"turn-foreground",
"message-foreground",
"The foreground answer",
),
/*replay_kind*/ None,
);
assert!(app.chat_widget.has_active_agent_stream());
app.enqueue_thread_request(
thread_id,
user_verification_server_request(thread_id, /*request_id*/ 13),
)
.await?;
assert!(app.chat_widget.has_active_view());
assert!(app.chat_widget.has_active_agent_stream());
app.chat_widget
.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
app.chat_widget.handle_server_notification(
agent_message_delta_notification(
foreground_thread_id,
"turn-foreground",
"message-foreground",
" continues.",
),
/*replay_kind*/ None,
);
app.chat_widget.handle_server_notification(
ServerNotification::ItemCompleted(codex_app_server_protocol::ItemCompletedNotification {
thread_id: foreground_thread_id.to_string(),
turn_id: "turn-foreground".to_string(),
completed_at_ms: 0,
item: ThreadItem::AgentMessage {
id: "message-foreground".to_string(),
text: "The foreground answer continues.".to_string(),
phase: None,
memory_citation: None,
delivery: None,
questions: None,
},
}),
/*replay_kind*/ None,
);
let mut approved = Vec::new();
let mut completed_messages = Vec::new();
let mut tui = crate::tui::test_support::make_test_tui()?;
while let Ok(event) = app_event_rx.try_recv() {
match event {
AppEvent::UserVerificationApproved {
thread_id,
server_name,
request_id,
} => approved.push((thread_id, server_name, request_id)),
AppEvent::InsertHistoryCell(cell) => app.insert_history_cell(&mut tui, cell),
AppEvent::ConsolidateAgentMessage {
source,
cwd,
inline_visualization_context,
scrollback_reflow,
deferred_history_cell,
} => {
completed_messages.push(source.clone());
app.handle_consolidate_agent_message(
&mut tui,
source,
cwd,
inline_visualization_context,
scrollback_reflow,
deferred_history_cell,
)?;
app.chat_widget.note_stream_consolidation_completed();
}
_ => {}
}
}
assert_eq!(
approved,
vec![(
thread_id,
"deployments".to_string(),
AppServerRequestId::Integer(13)
)]
);
assert_eq!(completed_messages, vec!["The foreground answer continues."]);
assert!(!app.chat_widget.has_active_agent_stream());
insta::assert_snapshot!(
"inactive_thread_user_verification_foreground_history",
app.render_transcript_lines_for_reflow(/*width*/ 80)
.lines
.iter()
.map(rendered_line_text)
.collect::<Vec<_>>()
.join("\n")
);
Ok(())
}
#[tokio::test]
async fn active_thread_user_verification_cancels_through_original_request() {
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
let thread_id = ThreadId::new();
let request = user_verification_server_request(thread_id, /*request_id*/ 12);
let ServerRequest::McpServerElicitationRequest { request_id, params } = request else {
panic!("elicitation request")
};
app.chat_widget
.handle_elicitation_request_now(request_id, params);
app.chat_widget
.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
let (submitted_thread_id, op) = next_submitted_thread_op(&mut app_event_rx).await;
assert_eq!(submitted_thread_id, thread_id);
assert_eq!(
op,
Op::ResolveUserVerification {
server_name: "deployments".to_string(),
request_id: AppServerRequestId::Integer(12),
response: crate::app_command::UserVerificationResponse::Cancel,
}
);
}
+17 -11
View File
@@ -331,14 +331,18 @@ impl App {
message: message.clone(), message: message.clone(),
}), }),
)), )),
codex_app_server_protocol::McpServerElicitationRequest::UserVerification { .. } => { codex_app_server_protocol::McpServerElicitationRequest::UserVerification {
self.app_event_tx.resolve_elicitation( title, description, ..
thread_id, params.server_name.clone(), request_id.clone(), } => Some(ThreadInteractiveRequest::UserVerification {
codex_app_server_protocol::McpServerElicitationAction::Cancel, thread_id,
/*content*/ None, /*meta*/ None, request: crate::bottom_pane::user_verification::UserVerificationRequest {
); thread_label,
None server_name: params.server_name.clone(),
} request_id: request_id.clone(),
title: title.clone(),
description: description.clone(),
},
}),
codex_app_server_protocol::McpServerElicitationRequest::OpenAiForm { codex_app_server_protocol::McpServerElicitationRequest::OpenAiForm {
.. ..
} }
@@ -397,6 +401,10 @@ impl App {
self.startup_pending_protected_request = true; self.startup_pending_protected_request = true;
} }
} }
ThreadInteractiveRequest::UserVerification { thread_id, request } => {
self.chat_widget
.push_user_verification_request(thread_id, request);
}
ThreadInteractiveRequest::McpServerElicitation(request) => { ThreadInteractiveRequest::McpServerElicitation(request) => {
self.chat_widget self.chat_widget
.push_mcp_server_elicitation_request(request); .push_mcp_server_elicitation_request(request);
@@ -1914,9 +1922,7 @@ impl App {
}; };
match &params.request { match &params.request {
codex_app_server_protocol::McpServerElicitationRequest::UserVerification { .. } => { codex_app_server_protocol::McpServerElicitationRequest::UserVerification { .. } => true,
false
}
codex_app_server_protocol::McpServerElicitationRequest::Form { .. } => true, codex_app_server_protocol::McpServerElicitationRequest::Form { .. } => true,
codex_app_server_protocol::McpServerElicitationRequest::OpenAiForm { .. } codex_app_server_protocol::McpServerElicitationRequest::OpenAiForm { .. }
| codex_app_server_protocol::McpServerElicitationRequest::OpenAiElicitationForm { | codex_app_server_protocol::McpServerElicitationRequest::OpenAiElicitationForm {
+139
View File
@@ -0,0 +1,139 @@
//! Coordinates approval through the local app-server, keeping proofs out of views.
//!
//! Attempt IDs are UI-local generations: cancellation, resolution, or reconnect removes the
//! pending generation, so a late RPC response cannot approve a newly surfaced request.
use codex_app_server_protocol::ClientRequest;
use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::ServerNotification;
use codex_app_server_protocol::UserVerificationProof;
use codex_app_server_protocol::UserVerificationVerifyResponse;
use codex_app_server_protocol::WarningNotification;
use codex_protocol::ThreadId;
use uuid::Uuid;
use super::App;
use super::app_server_requests::ResolvedAppServerRequest;
use super::user_verification_errors::verification_error_message;
use crate::app_command::AppCommand;
use crate::app_command::UserVerificationResponse;
use crate::app_event::AppEvent;
use crate::app_server_session::AppServerSession;
impl App {
pub(super) async fn start_user_verification(
&mut self,
app_server: &AppServerSession,
thread_id: ThreadId,
server_name: String,
request_id: RequestId,
) -> color_eyre::Result<()> {
if app_server.uses_remote_workspace() {
self.chat_widget.dismiss_app_server_request(
&ResolvedAppServerRequest::McpElicitation {
server_name: server_name.clone(),
request_id: request_id.clone(),
},
);
self.enqueue_thread_notification(
thread_id,
ServerNotification::Warning(WarningNotification {
thread_id: Some(thread_id.to_string()),
message: "User verification is unavailable for remote workspaces.".to_string(),
}),
)
.await?;
self.app_event_tx.resolve_user_verification(
thread_id,
server_name,
request_id,
UserVerificationResponse::Cancel,
);
return Ok(());
}
let Some(attempt) = self
.pending_app_server_requests
.user_verification
.begin(&server_name, &request_id)
else {
return Ok(());
};
let handle = app_server.request_handle();
let app_event_tx = self.app_event_tx.clone();
tokio::spawn(async move {
let attempt_id = attempt.id;
let verification = handle.request_typed::<UserVerificationVerifyResponse>(
ClientRequest::UserVerificationVerify {
request_id: RequestId::String(format!("user-verification-{attempt_id}")),
params: attempt.params,
},
);
let result = tokio::select! {
biased;
_ = attempt.cancelled.cancelled() => return,
result = verification => result,
}
.map(|response| response.proof)
.map_err(|error| verification_error_message(&error).to_string());
app_event_tx.send(AppEvent::UserVerificationFinished {
thread_id,
server_name,
request_id,
attempt_id,
result,
});
});
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(super) async fn finish_user_verification(
&mut self,
app_server: &mut AppServerSession,
thread_id: ThreadId,
server_name: String,
request_id: RequestId,
attempt_id: Uuid,
result: Result<UserVerificationProof, String>,
) -> color_eyre::Result<()> {
if self.abandoned_side_threads.contains(&thread_id)
|| !self
.pending_app_server_requests
.user_verification
.is_pending(&server_name, &request_id, attempt_id)
{
return Ok(());
}
let response = match result {
Ok(proof) => UserVerificationResponse::Accept { proof },
Err(message) => {
self.enqueue_thread_notification(
thread_id,
ServerNotification::Warning(WarningNotification {
thread_id: Some(thread_id.to_string()),
message,
}),
)
.await?;
// Another trusted device may be supported later. For now every incomplete
// verification cancels the original elicitation without a fallback provider.
UserVerificationResponse::Cancel
}
};
self.chat_widget
.dismiss_app_server_request(&ResolvedAppServerRequest::McpElicitation {
server_name: server_name.clone(),
request_id: request_id.clone(),
});
self.submit_thread_op(
app_server,
thread_id,
AppCommand::resolve_user_verification(server_name, request_id, response),
)
.await
}
}
#[cfg(test)]
#[path = "user_verification_tests.rs"]
mod tests;
@@ -16,6 +16,7 @@ pub(super) struct UserVerificationRequests {
#[derive(Debug)] #[derive(Debug)]
struct PendingVerification { struct PendingVerification {
thread_id: String,
params: UserVerificationVerifyParams, params: UserVerificationVerifyParams,
attempt: Option<Uuid>, attempt: Option<Uuid>,
cancelled: CancellationToken, cancelled: CancellationToken,
@@ -48,6 +49,7 @@ impl UserVerificationRequests {
self.pending.insert( self.pending.insert(
(params.server_name.clone(), request_id.clone()), (params.server_name.clone(), request_id.clone()),
PendingVerification { PendingVerification {
thread_id: params.thread_id.clone(),
params: UserVerificationVerifyParams { params: UserVerificationVerifyParams {
title: title.clone(), title: title.clone(),
description: description.clone(), description: description.clone(),
@@ -96,6 +98,19 @@ impl UserVerificationRequests {
.remove(&(server_name.to_string(), request_id.clone())); .remove(&(server_name.to_string(), request_id.clone()));
} }
pub(super) fn cancel_thread(&mut self, thread_id: &str) -> Vec<(String, RequestId)> {
let discarded_keys = self
.pending
.iter()
.filter(|(_, pending)| pending.thread_id == thread_id)
.map(|(key, _)| key.clone())
.collect::<Vec<_>>();
for (server_name, request_id) in &discarded_keys {
self.remove(server_name, request_id);
}
discarded_keys
}
pub(super) fn clear(&mut self) { pub(super) fn clear(&mut self) {
self.pending.clear(); self.pending.clear();
} }
@@ -72,6 +72,51 @@ fn user_verification_cancellation_invalidates_the_inflight_result() {
assert!(attempt.cancelled.is_cancelled()); assert!(attempt.cancelled.is_cancelled());
} }
#[test]
fn discarded_thread_cancels_only_its_verification_attempts() {
let mut pending = PendingAppServerRequests::default();
let request = verification_request();
let ServerRequest::McpServerElicitationRequest { params, .. } = &request else {
unreachable!()
};
let discarded_thread_id = params.thread_id.clone();
pending.note_server_request(&request);
let discarded_attempt = pending
.user_verification
.begin("deployments", request.id())
.expect("discarded thread attempt");
let mut other_request = verification_request();
let ServerRequest::McpServerElicitationRequest { request_id, params } = &mut other_request
else {
unreachable!()
};
*request_id = RequestId::Integer(8);
params.thread_id = ThreadId::new().to_string();
pending.note_server_request(&other_request);
let other_attempt = pending
.user_verification
.begin("deployments", other_request.id())
.expect("other thread attempt");
pending.cancel_thread_verification(&discarded_thread_id);
assert!(discarded_attempt.cancelled.is_cancelled());
assert!(!pending.contains_server_request(&request));
assert!(!pending.user_verification.is_pending(
"deployments",
request.id(),
discarded_attempt.id
));
assert!(!other_attempt.cancelled.is_cancelled());
assert!(pending.contains_server_request(&other_request));
assert!(pending.user_verification.is_pending(
"deployments",
other_request.id(),
other_attempt.id
));
}
#[test] #[test]
fn user_verification_reconnect_cannot_accept_a_previous_connections_proof() { fn user_verification_reconnect_cannot_accept_a_previous_connections_proof() {
let mut pending = PendingAppServerRequests::default(); let mut pending = PendingAppServerRequests::default();
@@ -0,0 +1,305 @@
//! Covers the controller's RPC boundary, cancellation generations, and proof redaction.
use super::*;
use codex_app_server_protocol::McpServerElicitationRequest;
use codex_app_server_protocol::McpServerElicitationRequestParams;
use codex_app_server_protocol::ServerRequest;
use futures::SinkExt;
use futures::StreamExt;
use pretty_assertions::assert_eq;
fn verification_request() -> ServerRequest {
ServerRequest::McpServerElicitationRequest {
request_id: RequestId::Integer(7),
params: McpServerElicitationRequestParams {
thread_id: ThreadId::new().to_string(),
turn_id: None,
server_name: "deployments".to_string(),
request: McpServerElicitationRequest::UserVerification {
title: "Approve deployment?".to_string(),
description: "Deploy the reviewed change.".to_string(),
challenge: "AQID".to_string(),
},
},
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum RpcScenario {
Success,
MethodNotFound,
CancelWhilePending,
RemoteWorkspace,
}
#[tokio::test]
async fn user_verification_controller_uses_the_local_binary_rpc_and_original_response()
-> color_eyre::Result<()> {
run_verification_rpc_scenario(RpcScenario::Success).await
}
#[tokio::test]
async fn user_verification_controller_cancels_for_an_older_binary() -> color_eyre::Result<()> {
run_verification_rpc_scenario(RpcScenario::MethodNotFound).await
}
#[tokio::test]
async fn user_verification_controller_suppresses_a_late_proof_after_cancellation()
-> color_eyre::Result<()> {
run_verification_rpc_scenario(RpcScenario::CancelWhilePending).await
}
#[tokio::test]
async fn user_verification_remote_workspace_dismisses_the_waiting_prompt() -> color_eyre::Result<()>
{
run_verification_rpc_scenario(RpcScenario::RemoteWorkspace).await
}
async fn run_verification_rpc_scenario(scenario: RpcScenario) -> color_eyre::Result<()> {
use codex_app_server_protocol::JSONRPCMessage;
use tokio_tungstenite::tungstenite::Message;
let (mut app, mut event_rx, _op_rx) = crate::app::tests::make_test_app_with_channels().await;
let mut tui = crate::tui::test_support::make_test_tui()?;
let foreground_thread_id = ThreadId::new();
app.active_thread_id = Some(foreground_thread_id);
app.primary_thread_id = Some(foreground_thread_id);
let request = verification_request();
let ServerRequest::McpServerElicitationRequest { request_id, params } = &request else {
unreachable!()
};
let thread_id = ThreadId::from_string(&params.thread_id)?;
app.pending_app_server_requests
.note_server_request(&request);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
let endpoint = crate::resolve_remote_addr(&format!("ws://{}", listener.local_addr()?))?;
let expected_params = serde_json::json!({ "title": "Approve deployment?", "description": "Deploy the reviewed change.", "challenge": "AQID" });
let proof =
serde_json::json!({ "credentialId": "issued-credential", "signature": "issued-signature" });
let (verify_started_tx, verify_started_rx) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await?;
let mut socket = tokio_tungstenite::accept_async(stream).await?;
let mut verify_started_tx = Some(verify_started_tx);
let mut pending_verification_id = None;
let mut response_received = false;
while let Some(frame) = socket.next().await {
let Message::Text(text) = frame? else {
continue;
};
match serde_json::from_str::<JSONRPCMessage>(&text)? {
JSONRPCMessage::Request(request) => {
let response = match request.method.as_str() {
"initialize" => {
serde_json::json!({ "id": request.id, "result": { "userAgent": "codex-tui-test", "codexHome": std::env::temp_dir(), "platformFamily": std::env::consts::FAMILY, "platformOs": std::env::consts::OS } })
}
"userVerification/verify" => {
assert_eq!(request.params, Some(expected_params.clone()));
let _ = verify_started_tx
.take()
.expect("one verification attempt")
.send(());
if scenario == RpcScenario::CancelWhilePending {
pending_verification_id = Some(request.id);
continue;
}
if scenario == RpcScenario::MethodNotFound {
serde_json::json!({ "id": request.id, "error": { "code": -32601, "message": "unknown method: private server diagnostic" } })
} else {
serde_json::json!({ "id": request.id, "result": { "proof": proof } })
}
}
"userVerification/status" => {
assert!(response_received);
socket.send(Message::Text(serde_json::json!({ "id": request.id, "result": { "unavailableReason": null, "unavailableMessage": null, "credentialId": null } }).to_string().into())).await?;
return Ok::<_, color_eyre::Report>(());
}
method => panic!("unexpected RPC: {method}"),
};
socket
.send(Message::Text(response.to_string().into()))
.await?;
}
JSONRPCMessage::Response(response) => {
assert!(
!response_received,
"a cancelled verification must never send a later acceptance"
);
response_received = true;
assert_eq!(response.id, RequestId::Integer(7));
let expected = if scenario == RpcScenario::Success {
serde_json::json!({ "action": "accept", "content": proof, "_meta": null })
} else {
serde_json::json!({ "action": "cancel", "content": null, "_meta": null })
};
assert_eq!(response.result, expected);
if let Some(id) = pending_verification_id.take() {
socket
.send(Message::Text(
serde_json::json!({ "id": id, "result": { "proof": proof } })
.to_string()
.into(),
))
.await?;
continue;
}
return Ok::<_, color_eyre::Report>(());
}
JSONRPCMessage::Notification(_) => {}
JSONRPCMessage::Error(error) => {
panic!("unexpected RPC error: {}", error.error.code)
}
}
}
color_eyre::eyre::bail!("connection closed before the elicitation response")
});
let client = crate::connect_remote_app_server(endpoint).await?;
let mode = if scenario == RpcScenario::RemoteWorkspace {
app.chat_widget
.handle_elicitation_request_now(request_id.clone(), params.clone());
app.chat_widget
.handle_key_event(crossterm::event::KeyEvent::new(
crossterm::event::KeyCode::Enter,
crossterm::event::KeyModifiers::NONE,
));
assert!(
crate::chatwidget::tests::helpers::render_bottom_popup(
&app.chat_widget,
/*width*/ 80
)
.contains("Waiting for verification")
);
crate::app_server_session::ThreadParamsMode::Remote
} else {
crate::app_server_session::ThreadParamsMode::Embedded
};
let mut session = AppServerSession::new(client, mode);
let approval = if scenario == RpcScenario::RemoteWorkspace {
event_rx.recv().await.expect("approval event")
} else {
AppEvent::UserVerificationApproved {
thread_id,
server_name: "deployments".to_string(),
request_id: request_id.clone(),
}
};
app.handle_event(&mut tui, &mut session, approval).await?;
if scenario == RpcScenario::RemoteWorkspace {
assert!(
!crate::chatwidget::tests::helpers::render_bottom_popup(
&app.chat_widget,
/*width*/ 80
)
.contains("Waiting for verification")
);
let AppEvent::SubmitThreadOp { thread_id, op } =
event_rx.recv().await.expect("cancel request")
else {
panic!("expected cancel response");
};
app.submit_thread_op(&mut session, thread_id, op).await?;
}
if scenario == RpcScenario::CancelWhilePending {
tokio::time::timeout(
std::time::Duration::from_secs(/*secs*/ 5),
verify_started_rx,
)
.await??;
app.submit_thread_op(
&mut session,
thread_id,
AppCommand::resolve_user_verification(
"deployments".to_string(),
request_id.clone(),
UserVerificationResponse::Cancel,
),
)
.await?;
}
if matches!(scenario, RpcScenario::Success | RpcScenario::MethodNotFound) {
let completion =
tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), event_rx.recv())
.await?
.expect("controller result");
assert!(matches!(
&completion,
AppEvent::UserVerificationFinished { .. }
));
app.handle_event(&mut tui, &mut session, completion).await?;
}
if scenario == RpcScenario::CancelWhilePending {
// Flush the client command queue after processing the late proof. The mock rejects any
// second elicitation response before acknowledging this harmless read.
session
.request_handle()
.request_typed::<codex_app_server_protocol::UserVerificationStatusResponse>(
ClientRequest::UserVerificationStatus {
request_id: RequestId::String("after-cancel".to_string()),
params: codex_app_server_protocol::UserVerificationStatusParams {},
},
)
.await?;
assert!(
event_rx.try_recv().is_err(),
"cancelled verification must drop its RPC future"
);
}
if matches!(
scenario,
RpcScenario::MethodNotFound | RpcScenario::RemoteWorkspace
) {
// A failure for the background request must not enter the foreground transcript.
assert!(event_rx.try_recv().is_err());
let snapshot = app.thread_event_channels[&thread_id]
.store
.lock()
.await
.snapshot();
assert_eq!(snapshot.events.len(), 1);
let crate::app::ThreadBufferedEvent::Notification(notification) = &snapshot.events[0]
else {
panic!("expected verification warning");
};
let message = if scenario == RpcScenario::RemoteWorkspace {
"User verification is unavailable for remote workspaces."
} else {
"The local Codex binary could not complete user verification."
};
let ServerNotification::Warning(warning) = notification.as_ref() else {
panic!("expected warning notification");
};
assert_eq!(
warning,
&WarningNotification {
thread_id: Some(thread_id.to_string()),
message: message.to_string(),
}
);
// Render the buffered warning as it appears when the requesting thread is displayed.
app.chat_widget
.handle_server_notification(*notification.clone(), /*replay_kind*/ None);
let AppEvent::InsertHistoryCell(cell) = event_rx.recv().await.expect("warning history")
else {
panic!("expected warning history cell");
};
let rendered = cell
.display_lines(/*width*/ 80)
.iter()
.map(|line| {
line.spans
.iter()
.map(|span| span.content.as_ref())
.collect::<String>()
})
.collect::<Vec<_>>()
.join("\n");
if scenario == RpcScenario::RemoteWorkspace {
insta::assert_snapshot!("remote_workspace_verification_warning", rendered);
} else {
insta::assert_snapshot!("older_binary_verification_warning", rendered);
}
}
tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), server).await???;
session.shutdown().await?;
Ok(())
}
-3
View File
@@ -162,7 +162,6 @@ pub(crate) enum AppCommand {
content: Option<Value>, content: Option<Value>,
meta: Option<Value>, meta: Option<Value>,
}, },
#[allow(dead_code)] // Connected by the following verification UI integration.
ResolveUserVerification { ResolveUserVerification {
server_name: String, server_name: String,
request_id: AppServerRequestId, request_id: AppServerRequestId,
@@ -194,7 +193,6 @@ pub(crate) enum AppCommand {
} }
#[derive(Debug, Clone, PartialEq, Eq, Serialize)] #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[allow(dead_code)] // Connected by the following verification UI integration.
pub(crate) enum UserVerificationResponse { pub(crate) enum UserVerificationResponse {
Accept { Accept {
// AppCommand serialization is used by session recording, not the RPC wire response. // AppCommand serialization is used by session recording, not the RPC wire response.
@@ -313,7 +311,6 @@ impl AppCommand {
} }
} }
#[allow(dead_code)] // Connected by the following verification UI integration.
pub(crate) fn resolve_user_verification( pub(crate) fn resolve_user_verification(
server_name: String, server_name: String,
request_id: AppServerRequestId, request_id: AppServerRequestId,
+15
View File
@@ -350,6 +350,21 @@ pub(crate) enum AppEvent {
prompt: UserMessage, prompt: UserMessage,
}, },
/// Sign the challenge associated with an approved elicitation.
UserVerificationApproved {
thread_id: ThreadId,
server_name: String,
request_id: AppServerRequestId,
},
/// Return a controller-owned verification result, never a native provider handle.
UserVerificationFinished {
thread_id: ThreadId,
server_name: String,
request_id: AppServerRequestId,
attempt_id: Uuid,
result: Result<codex_app_server_protocol::UserVerificationProof, String>,
},
/// Interrupt, fork, and retry a safety-buffered turn with the server-selected model. /// Interrupt, fork, and retry a safety-buffered turn with the server-selected model.
RetrySafetyBufferedTurn { RetrySafetyBufferedTurn {
thread_id: ThreadId, thread_id: ThreadId,
+14
View File
@@ -6,6 +6,7 @@
use std::path::PathBuf; use std::path::PathBuf;
use crate::app_command::AppCommand; use crate::app_command::AppCommand;
use crate::app_command::UserVerificationResponse;
use codex_app_server_protocol::CommandExecutionApprovalDecision; use codex_app_server_protocol::CommandExecutionApprovalDecision;
use codex_app_server_protocol::FileChangeApprovalDecision; use codex_app_server_protocol::FileChangeApprovalDecision;
use codex_app_server_protocol::McpServerElicitationAction; use codex_app_server_protocol::McpServerElicitationAction;
@@ -121,4 +122,17 @@ impl AppEventSender {
op: AppCommand::resolve_elicitation(server_name, request_id, decision, content, meta), op: AppCommand::resolve_elicitation(server_name, request_id, decision, content, meta),
}); });
} }
pub(crate) fn resolve_user_verification(
&self,
thread_id: ThreadId,
server_name: String,
request_id: AppServerRequestId,
response: UserVerificationResponse,
) {
self.send(AppEvent::SubmitThreadOp {
thread_id,
op: AppCommand::resolve_user_verification(server_name, request_id, response),
});
}
} }
@@ -144,6 +144,11 @@ pub(crate) trait BottomPaneView: Renderable {
Some(request) Some(request)
} }
/// Return true when this view already presents the matching app-server request.
fn matches_app_server_request(&self, _request: &ResolvedAppServerRequest) -> bool {
false
}
/// Dismiss a request that was resolved by another client. /// Dismiss a request that was resolved by another client.
/// ///
/// Returns `true` when the view changed state. /// Returns `true` when the view changed state.
-1
View File
@@ -77,7 +77,6 @@ mod status_line_setup;
mod status_line_style; mod status_line_style;
mod status_surface_preview; mod status_surface_preview;
mod title_setup; mod title_setup;
#[allow(dead_code)] // Connected by the following verification UI integration.
pub(crate) mod user_verification; pub(crate) mod user_verification;
mod voice_strip; mod voice_strip;
pub(crate) use action_required_title::ACTION_REQUIRED_PREVIEW_PREFIX; pub(crate) use action_required_title::ACTION_REQUIRED_PREVIEW_PREFIX;
@@ -199,10 +199,13 @@ impl BottomPaneView for UserVerificationView {
} }
} }
fn dismiss_app_server_request(&mut self, request: &ResolvedAppServerRequest) -> bool { fn matches_app_server_request(&self, request: &ResolvedAppServerRequest) -> bool {
if matches!(request, ResolvedAppServerRequest::McpElicitation { server_name, request_id } matches!(request, ResolvedAppServerRequest::McpElicitation { server_name, request_id }
if server_name == &self.request.server_name && request_id == &self.request.request_id) if server_name == &self.request.server_name && request_id == &self.request.request_id)
{ }
fn dismiss_app_server_request(&mut self, request: &ResolvedAppServerRequest) -> bool {
if self.matches_app_server_request(request) {
self.state = UserVerificationState::Complete(ViewCompletion::Accepted); self.state = UserVerificationState::Complete(ViewCompletion::Accepted);
true true
} else { } else {
@@ -300,3 +303,54 @@ fn waiting_view(request: &UserVerificationRequest, keymap: &ListKeymap) -> Box<d
#[cfg(test)] #[cfg(test)]
#[path = "user_verification_tests.rs"] #[path = "user_verification_tests.rs"]
mod tests; mod tests;
impl super::BottomPane {
pub(crate) fn push_user_verification_request(
&mut self,
thread_id: codex_protocol::ThreadId,
request: UserVerificationRequest,
) {
// App-server request IDs are shared across threads, unlike raw MCP request IDs.
let request_key = ResolvedAppServerRequest::McpElicitation {
server_name: request.server_name.clone(),
request_id: request.request_id.clone(),
};
if self
.view_stack
.iter()
.any(|view| view.matches_app_server_request(&request_key))
{
return;
}
let app_event_tx = self.app_event_tx.clone();
let server_name = request.server_name.clone();
let request_id = request.request_id.clone();
let view = UserVerificationView::new(
request,
self.app_event_tx.clone(),
self.keymap.approval.clone(),
self.keymap.list.clone(),
Box::new(move |decision| match decision {
UserVerificationDecision::Verify => {
app_event_tx.send(crate::app_event::AppEvent::UserVerificationApproved {
thread_id,
server_name: server_name.clone(),
request_id: request_id.clone(),
});
}
UserVerificationDecision::Cancel => app_event_tx.resolve_user_verification(
thread_id,
server_name.clone(),
request_id.clone(),
crate::app_command::UserVerificationResponse::Cancel,
),
}),
);
self.pause_status_timer_for_modal();
self.set_composer_input_enabled(
/*enabled*/ false,
Some("Complete user verification to continue.".to_string()),
);
self.push_view(Box::new(view));
}
}
+26 -7
View File
@@ -373,14 +373,18 @@ impl ChatWidget {
self.bottom_pane self.bottom_pane
.push_approval_request(request, &self.config.features); .push_approval_request(request, &self.config.features);
} }
McpServerElicitationRequest::UserVerification { .. } => { McpServerElicitationRequest::UserVerification {
self.app_event_tx.resolve_elicitation( title, description, ..
} => {
self.bottom_pane.push_user_verification_request(
thread_id, thread_id,
params.server_name, crate::bottom_pane::user_verification::UserVerificationRequest {
request_id, thread_label: None,
codex_app_server_protocol::McpServerElicitationAction::Cancel, server_name: params.server_name,
/*content*/ None, request_id,
/*meta*/ None, title,
description,
},
); );
} }
McpServerElicitationRequest::OpenAiForm { .. } McpServerElicitationRequest::OpenAiForm { .. }
@@ -414,6 +418,21 @@ impl ChatWidget {
self.request_redraw(); self.request_redraw();
} }
pub(crate) fn push_user_verification_request(
&mut self,
thread_id: ThreadId,
request: crate::bottom_pane::user_verification::UserVerificationRequest,
) {
// Inactive-thread prompts must leave the foreground stream and command activity intact.
self.bottom_pane
.push_user_verification_request(thread_id, request);
self.set_ambient_pet_notification(
crate::pets::PetNotificationKind::Waiting,
/*body*/ None,
);
self.request_redraw();
}
pub(crate) fn push_mcp_server_elicitation_request( pub(crate) fn push_mcp_server_elicitation_request(
&mut self, &mut self,
request: McpServerElicitationFormRequest, request: McpServerElicitationFormRequest,