Lightweight coding agent that runs in your terminal
Rust
Enable user verification for the bundled TUI on supported devices (#43715)
riley-oaid6489472f3c1
diff --git a/codex-rs/app-server/src/user_verification.rs b/codex-rs/app-server/src/user_verification.rsindex 3f8112b899..2345ffe5c4 100644--- a/codex-rs/app-server/src/user_verification.rs+++ b/codex-rs/app-server/src/user_verification.rs@@ -48,8 +48,7 @@ impl Service {auth_manager,provider: Arc::new(native::platform_provider),platform_supported: native::platform_supported(),- // Host activation follows the bundled TUI integration.- device_supported: || false,+ device_supported: native::device_supported,worker: Arc::new(Semaphore::new(/*permits*/ 1)),}}@@ -257,3 +256,11 @@ mod rpc_tests;#[cfg(test)]#[path = "user_verification_test_support.rs"]mod test_support;++#[cfg(test)]+#[path = "user_verification_activation_tests.rs"]+mod activation_tests;++#[cfg(test)]+#[path = "user_verification_connection_tests.rs"]+mod connection_tests;diff --git a/codex-rs/app-server/src/user_verification_activation_tests.rs b/codex-rs/app-server/src/user_verification_activation_tests.rsnew file mode 100644index 0000000000..969d4df3f0--- /dev/null+++ b/codex-rs/app-server/src/user_verification_activation_tests.rs@@ -0,0 +1,99 @@+//! Verifies that host initialization owns capability projection and response eligibility.++use super::test_support::Harness;+use crate::outgoing_message::ConnectionId;+use crate::outgoing_message::OutgoingMessage;+use crate::transport::ConnectionOrigin;+use anyhow::Result;+use codex_app_server_protocol as rpc;+use codex_protocol::mcp::OPENAI_ELICITATION_EXTENSION_ID;+use pretty_assertions::assert_eq;+use serde_json::json;++#[tokio::test]+async fn user_verification_initialize_owns_advertisement_and_eligibility() -> Result<()> {+ for (origin, name, opt_in, supported, expected) in [+ (ConnectionOrigin::InProcess, "codex-tui", true, true, true),+ (ConnectionOrigin::WebSocket, "codex-tui", true, true, false),+ (+ ConnectionOrigin::RemoteControl,+ "codex-tui",+ true,+ true,+ false,+ ),+ (ConnectionOrigin::Stdio, "codex-tui", true, true, false),+ (ConnectionOrigin::InProcess, "other-ui", true, true, false),+ (ConnectionOrigin::InProcess, "codex-tui", false, true, false),+ (ConnectionOrigin::InProcess, "codex-tui", true, false, false),+ ] {+ let probe: fn() -> bool = if supported { || true } else { || false };+ let mut h = Harness::new(origin, probe).await?;+ h.initialize(name, opt_in).await;+ let projected = h+ .session+ .client_mcp_extensions()+ .iter()+ .any(|(id, settings)| {+ id == OPENAI_ELICITATION_EXTENSION_ID && settings.get("userVerification").is_some()+ });+ assert_eq!(+ projected, expected,+ "{origin:?}/{name}/{opt_in}/{supported}"+ );+ let thread_id = codex_protocol::ThreadId::new();+ let (id, response) = h+ .outgoing+ .send_request_to_connections(+ Some(&[ConnectionId(1)]),+ rpc::ServerRequestPayload::McpServerElicitationRequest(+ rpc::McpServerElicitationRequestParams {+ thread_id: thread_id.to_string(),+ turn_id: None,+ server_name: "codex_apps".into(),+ request: rpc::McpServerElicitationRequest::UserVerification {+ challenge: "AQ".into(),+ title: "Approve".into(),+ description: String::new(),+ },+ },+ ),+ Some(thread_id),+ )+ .await;+ if expected {+ assert!(matches!(h.response().await, OutgoingMessage::Request(_)));+ let proof =+ json!({"action":"accept", "content":{"credentialId":"AQ", "signature":"Ag"}});+ h.processor+ .process_response(+ ConnectionId(2),+ rpc::JSONRPCResponse {+ id: id.clone(),+ result: proof.clone(),+ },+ )+ .await;+ let mut response = std::pin::pin!(response);+ assert!(matches!(+ futures::poll!(&mut response),+ std::task::Poll::Pending+ ));+ h.processor+ .process_response(+ ConnectionId(1),+ rpc::JSONRPCResponse {+ id,+ result: proof.clone(),+ },+ )+ .await;+ assert_eq!(response.await?, Ok(proof));+ } else {+ assert!(response.await.is_err());+ assert!(h.messages.try_recv().is_err());+ }+ h.shutdown().await;+ }+ Ok(())+}diff --git a/codex-rs/app-server/src/user_verification_auth.rs b/codex-rs/app-server/src/user_verification_auth.rsindex 9a27d26a3d..bf3a094702 100644--- a/codex-rs/app-server/src/user_verification_auth.rs+++ b/codex-rs/app-server/src/user_verification_auth.rs@@ -12,7 +12,6 @@ pub(super) struct Identity {impl OutgoingMessageSender {/// Trusted host activation enables a UI integration after its signing path is available.- #[allow(dead_code)] // Called by the subsequent host activation change.pub(crate) async fn enable_user_verification_connection(&self, connection_id: ConnectionId) {self.verification_connections.lock()diff --git a/codex-rs/app-server/src/user_verification_connection_tests.rs b/codex-rs/app-server/src/user_verification_connection_tests.rsnew file mode 100644index 0000000000..08a42a43e9--- /dev/null+++ b/codex-rs/app-server/src/user_verification_connection_tests.rs@@ -0,0 +1,180 @@+//! Exercises ownership through real initialized JSON-RPC sessions and disconnect processing.++use super::test_support::Harness;+use super::test_support::write_auth;+use crate::message_processor::ConnectionSessionState;+use crate::outgoing_message::ConnectionId;+use crate::outgoing_message::OutgoingEnvelope;+use crate::outgoing_message::OutgoingMessage;+use crate::transport::AppServerTransport;+use crate::transport::ConnectionOrigin;+use anyhow::Result;+use codex_app_server_protocol as rpc;+use codex_protocol::ThreadId;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::sync::Arc;+use tokio::sync::oneshot;+use tokio::time::Duration;+use tokio::time::timeout;++fn request() -> rpc::ServerRequestPayload {+ rpc::ServerRequestPayload::McpServerElicitationRequest(rpc::McpServerElicitationRequestParams {+ thread_id: ThreadId::new().to_string(),+ turn_id: None,+ server_name: "codex_apps".into(),+ request: rpc::McpServerElicitationRequest::UserVerification {+ title: "Approve".into(),+ description: String::new(),+ challenge: "AQ".into(),+ },+ })+}++async fn initialize_second(h: &mut Harness) -> Result<Arc<ConnectionSessionState>> {+ let session = Arc::new(ConnectionSessionState::new(ConnectionOrigin::InProcess));+ h.processor+ .process_request(+ ConnectionId(2),+ rpc::JSONRPCRequest {+ id: rpc::RequestId::Integer(0),+ method: "initialize".into(),+ params: Some(json!({"clientInfo":{"name":"codex-tui","version":"1"},"capabilities":{"experimentalApi":true}})),+ trace: None,+ },+ &AppServerTransport::Stdio,+ Arc::clone(&session),+ )+ .await;+ let message = timeout(Duration::from_secs(/*secs*/ 5), h.messages.recv()).await?;+ assert!(matches!(+ message,+ Some(OutgoingEnvelope::ToConnection {+ connection_id: ConnectionId(2),+ message: OutgoingMessage::Response(_),+ ..+ })+ ));+ Ok(session)+}++#[tokio::test]+async fn user_verification_disconnect_releases_ownership_before_rpc_drain() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::InProcess, || true).await?;+ h.initialize("codex-tui", /*opt_in*/ true).await;+ let second = initialize_second(&mut h).await?;+ let connections = [ConnectionId(1), ConnectionId(2)];+ let (id, pending) = h+ .outgoing+ .send_request_to_connections(Some(&connections), request(), /*thread_id*/ None)+ .await;+ assert!(matches!(h.response().await, OutgoingMessage::Request(_)));+ let proof = json!({"action":"accept","content":{"credentialId":"AQ","signature":"Ag"}});+ h.processor+ .process_response(+ ConnectionId(2),+ rpc::JSONRPCResponse {+ id: id.clone(),+ result: proof.clone(),+ },+ )+ .await;+ let mut pending = std::pin::pin!(pending);+ assert!(matches!(+ futures::poll!(&mut pending),+ std::task::Poll::Pending+ ));++ // Keep an unrelated initialized handler active so production disconnect must wait at the gate.+ let gate = Arc::clone(&h.session.rpc_gate);+ let (entered, waiting) = oneshot::channel();+ let (release, blocked) = oneshot::channel();+ let running = tokio::spawn(async move {+ gate.run(async move {+ entered.send(()).expect("handler entry");+ blocked.await.expect("release handler");+ })+ .await;+ });+ waiting.await?;+ let processor = Arc::clone(&h.processor);+ let session = Arc::clone(&h.session);+ let mut disconnect = std::pin::pin!(processor.connection_closed(ConnectionId(1), &session));+ assert!(matches!(+ futures::poll!(&mut disconnect),+ std::task::Poll::Pending+ ));+ assert!(+ timeout(Duration::from_secs(/*secs*/ 5), pending)+ .await?+ .is_err()+ );++ // The live initialized UI must now own the request, although the disconnected RPC is draining.+ let (id, response) = h+ .outgoing+ .send_request_to_connections(Some(&connections), request(), /*thread_id*/ None)+ .await;+ let message = timeout(Duration::from_secs(/*secs*/ 5), h.messages.recv()).await?;+ assert!(matches!(+ message,+ Some(OutgoingEnvelope::ToConnection {+ connection_id: ConnectionId(2),+ message: OutgoingMessage::Request(_),+ ..+ })+ ));+ h.processor+ .process_response(+ ConnectionId(1),+ rpc::JSONRPCResponse {+ id: id.clone(),+ result: proof.clone(),+ },+ )+ .await;+ let mut response = std::pin::pin!(response);+ assert!(matches!(+ futures::poll!(&mut response),+ std::task::Poll::Pending+ ));+ h.processor+ .process_response(+ ConnectionId(2),+ rpc::JSONRPCResponse {+ id,+ result: proof.clone(),+ },+ )+ .await;+ assert_eq!(response.await?, Ok(proof));+ release.send(()).expect("release draining handler");+ running.await?;+ disconnect.await;+ h.processor+ .connection_closed(ConnectionId(2), &second)+ .await;+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_dispatcher_auth_watcher_cancels_pending_ownership() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::InProcess, || true).await?;+ h.initialize("codex-tui", /*opt_in*/ true).await;+ let (_, pending) = h+ .outgoing+ .send_request_to_connections(Some(&[ConnectionId(1)]), request(), /*thread_id*/ None)+ .await;+ assert!(matches!(h.response().await, OutgoingMessage::Request(_)));+ write_auth(h.home.path(), "second")?;+ h.auth.reload().await;+ // No response triggers a revision recheck: MessageProcessor's installed watcher must cancel it.+ assert!(+ timeout(Duration::from_secs(/*secs*/ 5), pending)+ .await?+ .is_err()+ );+ h.shutdown().await;+ Ok(())+}