Lightweight coding agent that runs in your terminal
Rust
Wire app-server user verification RPCs to the native provider (#43568)
riley-oaica6fb194b695
diff --git a/codex-rs/app-server-client/src/lib.rs b/codex-rs/app-server-client/src/lib.rsindex 11b1b3dfb0..c5840e4d4c 100644--- a/codex-rs/app-server-client/src/lib.rs+++ b/codex-rs/app-server-client/src/lib.rs@@ -348,8 +348,20 @@ impl InProcessAppServerClient {// this loop can keep draining runtime events// while the request is blocked on client input.tokio::spawn(async move {- let result = request_sender.request(*request).await;- let _ = response_tx.send(result);+ // Device ceremonies belong to the waiting UI. Preserve+ // its cancellation through this buffering task.+ let cancellable = matches!(*request,+ ClientRequest::UserVerificationStatus { .. }+ | ClientRequest::UserVerificationEnroll { .. }+ | ClientRequest::UserVerificationDelete { .. }+ | ClientRequest::UserVerificationVerify { .. });+ let mut response_tx = response_tx;+ tokio::select! {+ _ = response_tx.closed(), if cancellable => {}+ result = request_sender.request(*request) => {+ let _ = response_tx.send(result);+ }+ }});}Some(ClientCommand::Notify {diff --git a/codex-rs/app-server/src/connection_rpc_gate.rs b/codex-rs/app-server/src/connection_rpc_gate.rsindex fb2aedd352..dc1dc5307b 100644--- a/codex-rs/app-server/src/connection_rpc_gate.rs+++ b/codex-rs/app-server/src/connection_rpc_gate.rs@@ -38,6 +38,10 @@ impl ConnectionRpcGate {drop(token);}+ pub(crate) fn is_closed(&self) -> bool {+ self.tasks.is_closed()+ }+pub(crate) async fn close(&self) {let mut accepting = self.accepting.lock().await;*accepting = false;diff --git a/codex-rs/app-server/src/in_process.rs b/codex-rs/app-server/src/in_process.rsindex bc012ce7c9..65a7d4e1db 100644--- a/codex-rs/app-server/src/in_process.rs+++ b/codex-rs/app-server/src/in_process.rs@@ -188,6 +188,7 @@ enum InProcessClientMessage {Request {request: Box<ClientRequest>,response_tx: oneshot::Sender<PendingClientRequestResponse>,+ cancellation: tokio_util::sync::CancellationToken,},Notification {notification: ClientNotification,@@ -206,7 +207,7 @@ enum InProcessClientMessage {}enum ProcessorCommand {- Request(Box<ClientRequest>),+ Request(Box<ClientRequest>, tokio_util::sync::CancellationToken),Notification(ClientNotification),}@@ -218,9 +219,12 @@ pub struct InProcessClientSender {impl InProcessClientSender {pub async fn request(&self, request: ClientRequest) -> IoResult<PendingClientRequestResponse> {let (response_tx, response_rx) = oneshot::channel();+ let cancellation = tokio_util::sync::CancellationToken::new();+ let _cancel_on_drop = cancellation.clone().drop_guard();self.try_send_client_message(InProcessClientMessage::Request {request: Box::new(request),response_tx,+ cancellation,})?;response_rx.await.map_err(|err| {IoError::new(@@ -482,6 +486,9 @@ async fn start_uninitialized(args: InProcessStartArgs) -> IoResult<InProcessCliestate_db: args.state_db,config_warnings: args.config_warnings,session_source: args.session_source,+ user_verification: Arc::new(crate::user_verification::Service::new(Arc::clone(+ &auth_manager,+ ))),auth_manager,installation_id,code_mode_session_provider: None,@@ -490,14 +497,16 @@ async fn start_uninitialized(args: InProcessStartArgs) -> IoResult<InProcessClieplugin_startup_tasks: Some(PluginStartupConfig::Current),}));let mut thread_created_rx = processor.thread_created_receiver();- let session = Arc::new(ConnectionSessionState::new());+ let session = Arc::new(ConnectionSessionState::new(+ crate::transport::ConnectionOrigin::InProcess,+ ));let mut listen_for_threads = true;loop {tokio::select! {command = processor_rx.recv() => {match command {- Some(ProcessorCommand::Request(request)) => {+ Some(ProcessorCommand::Request(request, cancellation)) => {let was_initialized = session.initialized();processor.process_client_request(@@ -505,6 +514,7 @@ async fn start_uninitialized(args: InProcessStartArgs) -> IoResult<InProcessClie*request,Arc::clone(&session),&outbound_initialized,+ cancellation,).await;let opted_out_notification_methods_snapshot =@@ -576,7 +586,7 @@ async fn start_uninitialized(args: InProcessStartArgs) -> IoResult<InProcessClietokio::select! {message = client_rx.recv() => {match message {- Some(InProcessClientMessage::Request { request, response_tx }) => {+ Some(InProcessClientMessage::Request { request, response_tx, cancellation }) => {let request = *request;let request_id = request.id().clone();match pending_request_responses.entry(request_id.clone()) {@@ -591,7 +601,7 @@ async fn start_uninitialized(args: InProcessStartArgs) -> IoResult<InProcessClie}}- match processor_tx.try_send(ProcessorCommand::Request(Box::new(request))) {+ match processor_tx.try_send(ProcessorCommand::Request(Box::new(request), cancellation)) {Ok(()) => {}Err(mpsc::error::TrySendError::Full(_)) => {if let Some(response_tx) =diff --git a/codex-rs/app-server/src/lib.rs b/codex-rs/app-server/src/lib.rsindex c4ec80c9bf..7bb96f6ad0 100644--- a/codex-rs/app-server/src/lib.rs+++ b/codex-rs/app-server/src/lib.rs@@ -938,6 +938,9 @@ pub async fn run_main_with_transport_options(state_db: state_db.clone(),config_warnings,session_source,+ user_verification: Arc::new(crate::user_verification::Service::new(Arc::clone(+ &auth_manager,+ ))),auth_manager,installation_id,code_mode_session_provider,diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rsindex da84311484..3557370eee 100644--- a/codex-rs/app-server/src/message_processor.rs+++ b/codex-rs/app-server/src/message_processor.rs@@ -135,6 +135,7 @@ fn reject_removed_permission_profile(request: &JSONRPCRequest) -> Result<(), JSO}pub(crate) struct MessageProcessor {+ user_verification: Arc<crate::user_verification::Service>,outgoing: Arc<OutgoingMessageSender>,models_refresh_worker: ModelsRefreshWorker,turn_cost_worker: Option<TurnCostWorker>,@@ -168,6 +169,7 @@ pub(crate) struct MessageProcessor {#[derive(Debug)]pub(crate) struct ConnectionSessionState {pub(crate) rpc_gate: Arc<ConnectionRpcGate>,+ pub(crate) origin: crate::transport::ConnectionOrigin,pub(crate) mcp_event_streams: McpEventStreams,initialized: OnceLock<InitializedConnectionSessionState>,}@@ -182,15 +184,10 @@ pub(crate) struct InitializedConnectionSessionState {pub(crate) client_mcp_extensions: ClientMcpExtensions,}-impl Default for ConnectionSessionState {- fn default() -> Self {- Self::new()- }-}-impl ConnectionSessionState {- pub(crate) fn new() -> Self {+ pub(crate) fn new(origin: crate::transport::ConnectionOrigin) -> Self {Self {+ origin,rpc_gate: Arc::new(ConnectionRpcGate::new()),mcp_event_streams: McpEventStreams::default(),initialized: OnceLock::new(),@@ -256,6 +253,7 @@ pub(crate) struct MessageProcessorArgs {pub(crate) config_warnings: Vec<ConfigWarningNotification>,pub(crate) session_source: SessionSource,pub(crate) auth_manager: Arc<AuthManager>,+ pub(crate) user_verification: Arc<crate::user_verification::Service>,pub(crate) installation_id: String,pub(crate) code_mode_session_provider: Option<Arc<dyn CodeModeSessionProvider>>,pub(crate) rpc_transport: AppServerRpcTransport,@@ -281,6 +279,7 @@ impl MessageProcessor {config_warnings,session_source,auth_manager,+ user_verification,installation_id,code_mode_session_provider,rpc_transport,@@ -448,6 +447,7 @@ impl MessageProcessor {Arc::clone(&config),config_warnings.clone(),rpc_transport,+ Arc::clone(&user_verification),);let marketplace_processor = MarketplaceRequestProcessor::new(Arc::clone(&config),@@ -569,6 +569,7 @@ impl MessageProcessor {);Self {+ user_verification,outgoing,models_refresh_worker,turn_cost_worker,@@ -671,6 +672,7 @@ impl MessageProcessor {request: ClientRequest,session: Arc<ConnectionSessionState>,outbound_initialized: &AtomicBool,+ cancellation: tokio_util::sync::CancellationToken,) {let request_id = ConnectionRequestId {connection_id,@@ -678,8 +680,9 @@ impl MessageProcessor {};let request_span =crate::app_server_tracing::typed_request_span(&request, connection_id, &session);- let request_context =+ let mut request_context =RequestContext::new(request_id.clone(), request_span, /*parent_trace*/ None);+ request_context.cancellation = cancellation;tracing::trace!(?connection_id,request_id = ?request_id.request_id,@@ -992,11 +995,43 @@ impl MessageProcessor {ClientRequest::Initialize { .. } => {panic!("Initialize should be handled before initialized request dispatch");}- ClientRequest::UserVerificationStatus { .. }+ request @ (ClientRequest::UserVerificationStatus { .. }| ClientRequest::UserVerificationEnroll { .. }| ClientRequest::UserVerificationDelete { .. }- | ClientRequest::UserVerificationVerify { .. } => {- Err(crate::user_verification::unavailable())+ | ClientRequest::UserVerificationVerify { .. }) => {+ return Box::pin(async {+ // Keep verification temporaries out of unrelated RPCs' stack frames.+ let operation = match request {+ ClientRequest::UserVerificationStatus { .. } => {+ crate::user_verification::Operation::Status+ }+ ClientRequest::UserVerificationEnroll { .. } => {+ crate::user_verification::Operation::Enroll+ }+ ClientRequest::UserVerificationDelete { .. } => {+ crate::user_verification::Operation::Delete+ }+ ClientRequest::UserVerificationVerify { params, .. } => {+ crate::user_verification::Operation::Verify(params)+ }+ _ => unreachable!("matched a user-verification request"),+ };+ let response = self+ .user_verification+ .handle(+ operation,+ Arc::clone(&session.rpc_gate),+ request_context.cancellation.clone(),+ session.origin,+ )+ .await?;+ let (payload, check) = response.into_parts();+ self.outgoing+ .send_response_as_checked(request_id.clone(), payload, check)+ .await;+ Ok(())+ })+ .await;}ClientRequest::ServerDiagnostics { .. } => Ok(Some(read_server_diagnostics().into())),ClientRequest::ConfigRead { params, .. } => selfdiff --git a/codex-rs/app-server/src/message_processor_tracing_tests.rs b/codex-rs/app-server/src/message_processor_tracing_tests.rsindex 82c1ad0127..260092a4e7 100644--- a/codex-rs/app-server/src/message_processor_tracing_tests.rs+++ b/codex-rs/app-server/src/message_processor_tracing_tests.rs@@ -129,7 +129,9 @@ impl TracingHarness {_codex_home: codex_home,processor,outgoing_rx,- session: Arc::new(ConnectionSessionState::new()),+ session: Arc::new(ConnectionSessionState::new(+ crate::transport::ConnectionOrigin::Stdio,+ )),tracing,};@@ -265,6 +267,9 @@ async fn build_test_processor(state_db: None,config_warnings: Vec::new(),session_source: SessionSource::VSCode,+ user_verification: Arc::new(crate::user_verification::Service::new(Arc::clone(+ &auth_manager,+ ))),auth_manager,installation_id: "11111111-1111-4111-8111-111111111111".to_string(),code_mode_session_provider: None,diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rsindex e6e0ae87a4..5c20dad5d7 100644--- a/codex-rs/app-server/src/outgoing_message.rs+++ b/codex-rs/app-server/src/outgoing_message.rs@@ -61,6 +61,7 @@ pub(crate) struct ConnectionRequestId {#[derive(Clone)]pub(crate) struct RequestContext {request_id: ConnectionRequestId,+ pub(crate) cancellation: tokio_util::sync::CancellationToken,span: Span,parent_trace: Option<W3cTraceContext>,_diagnostics_guard: Arc<GaugeGuard>,@@ -74,6 +75,7 @@ impl RequestContext {) -> Self {Self {request_id,+ cancellation: tokio_util::sync::CancellationToken::new(),span,parent_trace,_diagnostics_guard: Arc::new(IN_FLIGHT_REQUESTS.track()),@@ -638,6 +640,42 @@ impl OutgoingMessageSender {.await;}+ /// Revalidates a sensitive result after reserving queue capacity, with no+ /// suspension between the identity check and handing off the response.+ pub(crate) async fn send_response_as_checked(+ &self,+ request_id: ConnectionRequestId,+ response: ClientResponsePayload,+ check: impl FnOnce() -> std::result::Result<(), JSONRPCErrorError>,+ ) {+ let _context = self.take_request_context(&request_id).await;+ let Ok(permit) = self.sender.reserve().await else {+ return;+ };+ let message = match check() {+ Ok(()) => {+ self.analytics_events_client.track_response(+ request_id.connection_id.0,+ request_id.request_id.clone(),+ &response,+ );+ OutgoingMessage::Response(OutgoingResponse {+ id: request_id.request_id,+ result: Box::new(response),+ })+ }+ Err(error) => OutgoingMessage::Error(OutgoingError {+ id: request_id.request_id,+ error,+ }),+ };+ permit.send(OutgoingEnvelope::ToConnection {+ connection_id: request_id.connection_id,+ message,+ write_complete_tx: None,+ });+ }+async fn send_response_as_inner(&self,request_id: ConnectionRequestId,diff --git a/codex-rs/app-server/src/request_processors/initialize_processor.rs b/codex-rs/app-server/src/request_processors/initialize_processor.rsindex 442b71f335..d6c77f12eb 100644--- a/codex-rs/app-server/src/request_processors/initialize_processor.rs+++ b/codex-rs/app-server/src/request_processors/initialize_processor.rs@@ -8,6 +8,8 @@ use codex_login::default_client::USER_AGENT_SUFFIX;use codex_login::default_client::get_codex_user_agent;use codex_login::default_client::set_default_client_residency_requirement;use codex_login::default_client::set_default_originator;+use codex_protocol::mcp::ClientMcpExtensions;+use codex_protocol::mcp::OPENAI_ELICITATION_EXTENSION_ID;use super::*;use crate::message_processor::ConnectionSessionState;@@ -22,6 +24,7 @@ pub(crate) struct InitializeRequestProcessor {config: Arc<Config>,config_warnings: Arc<Vec<ConfigWarningNotification>>,rpc_transport: AppServerRpcTransport,+ user_verification: Arc<crate::user_verification::Service>,}impl InitializeRequestProcessor {@@ -31,6 +34,7 @@ impl InitializeRequestProcessor {config: Arc<Config>,config_warnings: Vec<ConfigWarningNotification>,rpc_transport: AppServerRpcTransport,+ user_verification: Arc<crate::user_verification::Service>,) -> Self {Self {outgoing,@@ -38,6 +42,7 @@ impl InitializeRequestProcessor {config,config_warnings: Arc::new(config_warnings),rpc_transport,+ user_verification,}}@@ -71,7 +76,7 @@ impl InitializeRequestProcessor {let experimental_api_enabled = capabilities.experimental_api;let request_attestation = capabilities.request_attestation;let extensions = capabilities.extensions.as_ref();- let client_mcp_extensions = codex_mcp::client_mcp_extensions(+ let mut client_mcp_extensions = codex_mcp::client_mcp_extensions(extensions,capabilities.mcp_server_openai_form_elicitation,);@@ -90,6 +95,31 @@ impl InitializeRequestProcessor {"Invalid clientInfo.name: '{name}'. Must be a valid HTTP header value.")));}+ // The bundled TUI shares this build and implements the typed verification UI.+ // Independently deployed UIs need their own rollout before receiving this mode.+ let user_verification_enabled = experimental_api_enabled+ && matches!(+ session.origin,+ crate::transport::ConnectionOrigin::InProcess+ )+ && name == "codex-tui"+ && tokio::task::spawn_blocking(self.user_verification.device_supported)+ .await+ .unwrap_or(false);+ if user_verification_enabled {+ let mut extensions = client_mcp_extensions+ .iter()+ .map(|(id, value)| (id.to_string(), value.clone()))+ .collect::<std::collections::HashMap<_, _>>();+ let settings = extensions+ .entry(OPENAI_ELICITATION_EXTENSION_ID.to_string())+ .or_insert_with(|| serde_json::json!({}));+ if !settings.is_object() {+ *settings = serde_json::json!({});+ }+ settings["userVerification"] = serde_json::json!({});+ client_mcp_extensions = ClientMcpExtensions::new(extensions);+ }let originator = name.clone();let user_agent_suffix = format!("{name}; {version}");let mutates_global_identity = !NON_ORIGINATING_CLIENT_NAMES.contains(&name.as_str());@@ -107,6 +137,11 @@ impl InitializeRequestProcessor {{return Err(invalid_request("Already initialized"));}+ if user_verification_enabled {+ self.outgoing+ .enable_user_verification_connection(connection_id)+ .await;+ }if mutates_global_identity {// Only real client initialization may mutate process-global client metadata.diff --git a/codex-rs/app-server/src/transport.rs b/codex-rs/app-server/src/transport.rsindex 3203065331..e94df28833 100644--- a/codex-rs/app-server/src/transport.rs+++ b/codex-rs/app-server/src/transport.rs@@ -57,7 +57,7 @@ impl ConnectionState {outbound_initialized,outbound_experimental_api_enabled,outbound_opted_out_notification_methods,- session: Arc::new(ConnectionSessionState::new()),+ session: Arc::new(ConnectionSessionState::new(origin)),}}}diff --git a/codex-rs/app-server/src/user_verification.rs b/codex-rs/app-server/src/user_verification.rsindex 6cc5f9b36d..3f8112b899 100644--- a/codex-rs/app-server/src/user_verification.rs+++ b/codex-rs/app-server/src/user_verification.rs@@ -1,7 +1,259 @@-//! Local verification value conversion; provider dispatch follows in the next change.+//! Dispatches local verification onto one bounded native worker per service.+//! Request guards remain active through response delivery; registration is a later integration.++use crate::connection_rpc_gate::ConnectionRpcGate;+use crate::transport::ConnectionOrigin;+use codex_app_server_protocol as rpc;+use codex_login::AuthManager;+use codex_user_verification as native;+use std::sync::Arc;+use std::time::Duration;+use tokio::sync::Semaphore;+use tokio::sync::oneshot;+use tokio_util::sync::CancellationToken;-#[allow(dead_code)]#[path = "user_verification_adapter.rs"]mod adapter;+use adapter::error;+use adapter::native_error;pub(crate) use adapter::unavailable;+use adapter::unavailable_reason;+use adapter::validate;++pub(crate) enum Operation {+ Status,+ Enroll,+ Delete,+ Verify(rpc::UserVerificationVerifyParams),+}++/// Shared local provider dependencies and a bounded native worker slot.+/// The slot stays with the worker until it exits, including after RPC cancellation.+pub(crate) struct Service {+ auth_manager: Arc<AuthManager>,+ provider: Arc<+ dyn Fn(native::UserVerificationKeyNamespace) -> Arc<dyn native::UserVerificationProvider>+ + Send+ + Sync,+ >,+ platform_supported: bool,+ pub(crate) device_supported: fn() -> bool,+ worker: Arc<Semaphore>,+}++impl Service {+ pub(crate) fn new(auth_manager: Arc<AuthManager>) -> Self {+ Self {+ auth_manager,+ provider: Arc::new(native::platform_provider),+ platform_supported: native::platform_supported(),+ // Host activation follows the bundled TUI integration.+ device_supported: || false,+ worker: Arc::new(Semaphore::new(/*permits*/ 1)),+ }+ }++ pub(crate) async fn handle(+ &self,+ operation: Operation,+ connection: Arc<ConnectionRpcGate>,+ cancellation: CancellationToken,+ origin: ConnectionOrigin,+ ) -> Result<GuardedResponse, rpc::JSONRPCErrorError> {+ // A network peer must sign on its own device. Stdio belongs to the local+ // parent process; in-process calls belong to the embedded application.+ if matches!(+ origin,+ ConnectionOrigin::WebSocket | ConnectionOrigin::RemoteControl+ ) && !matches!(operation, Operation::Status)+ {+ return Err(unavailable());+ }+ let operation = match operation {+ Operation::Verify(params) => NativeOperation::Verify(validate(params)?),+ Operation::Status => NativeOperation::Status,+ Operation::Enroll => NativeOperation::Enroll,+ Operation::Delete => NativeOperation::Delete,+ };+ let auth_manager = Arc::clone(&self.auth_manager);+ let auth_changes = auth_manager.auth_change_receiver();+ let auth_revision = *auth_changes.borrow();+ let Some(identity) = identity(&auth_manager).filter(|_| self.platform_supported) else {+ return match operation {+ NativeOperation::Status => Ok(GuardedResponse {+ payload: rpc::UserVerificationStatusResponse {+ credential_id: None,+ unavailable_reason: Some(+ rpc::UserVerificationUnavailableReason::ProviderUnavailable,+ ),+ unavailable_message: Some(+ "User verification is not available in this build or account.".into(),+ ),+ }+ .into(),+ guard: CancelOnDrop(native::UserVerificationRequestGuard::default()),+ }),+ NativeOperation::Enroll | NativeOperation::Delete | NativeOperation::Verify(_) => {+ Err(unavailable())+ }+ };+ };+ let provider = (self.provider)(native::UserVerificationKeyNamespace::new(&identity));+ let guard = native::UserVerificationRequestGuard::with_activity_check(move || {+ !connection.is_closed()+ && !cancellation.is_cancelled()+ && *auth_changes.borrow() == auth_revision+ && self::identity(&auth_manager).as_ref() == Some(&identity)+ });+ run(operation, provider, guard, Arc::clone(&self.worker)).await+ }+}++pub(crate) struct GuardedResponse {+ pub(crate) payload: rpc::ClientResponsePayload,+ guard: CancelOnDrop,+}++impl GuardedResponse {+ pub(crate) fn into_parts(+ self,+ ) -> (+ rpc::ClientResponsePayload,+ impl FnOnce() -> Result<(), rpc::JSONRPCErrorError>,+ ) {+ (self.payload, move || {+ self.guard.0.check().map_err(native_error)+ })+ }+}++fn identity(auth_manager: &AuthManager) -> Option<String> {+ auth_manager.auth_cached()?.get_chatgpt_account_user_id()+}++enum NativeOperation {+ Status,+ Enroll,+ Delete,+ Verify(native::UserVerificationRequest),+}++/// Cancels blocking work when its RPC future is dropped or times out.+struct CancelOnDrop(native::UserVerificationRequestGuard);+impl Drop for CancelOnDrop {+ fn drop(&mut self) {+ self.0.cancel();+ }+}++async fn run(+ operation: NativeOperation,+ provider: Arc<dyn native::UserVerificationProvider>,+ guard: native::UserVerificationRequestGuard,+ worker: Arc<Semaphore>,+) -> Result<GuardedResponse, rpc::JSONRPCErrorError> {+ let cancel = CancelOnDrop(guard.clone());+ let permit = worker.try_acquire_owned().map_err(|_| {+ error(+ rpc::UserVerificationErrorDetails::Failed {+ reason: rpc::UserVerificationFailureReason::ProviderError,+ },+ "Another user verification operation is still running.",+ )+ })?;+ let (result_tx, work) = oneshot::channel();+ // Native APIs may block even after cancellation. They must not occupy Tokio's+ // blocking pool (which runtime shutdown joins), or create unbounded workers.+ std::thread::Builder::new()+ .name("user-verification".into())+ .spawn(move || {+ let result = (|| {+ guard.check().map_err(native_error)?;+ let result: rpc::ClientResponsePayload = match operation {+ NativeOperation::Status => {+ let status = provider.status(&guard).map_err(native_error)?;+ rpc::UserVerificationStatusResponse {+ credential_id: status.credential.map(|key| key.credential_id),+ unavailable_reason: status.unavailable_reason.map(unavailable_reason),+ unavailable_message: status.unavailable_message,+ }+ .into()+ }+ NativeOperation::Enroll => {+ let key = provider.ensure_key(&guard).map_err(native_error)?;+ // TODO: start enrollment, sign proof of possession, then finish registration.+ // This implementation establishes the local key only.+ rpc::UserVerificationEnrollResponse {+ credential_id: key.credential.credential_id,+ }+ .into()+ }+ NativeOperation::Delete => {+ // TODO: retain credential references and revoke server registrations when+ // backend enrollment is connected. Current enroll only creates local keys.+ provider.delete(&guard).map_err(native_error)?;+ rpc::UserVerificationDeleteResponse {}.into()+ }+ NativeOperation::Verify(request) => {+ let proof = provider.verify(&request, &guard).map_err(native_error)?;+ rpc::UserVerificationVerifyResponse {+ proof: rpc::UserVerificationProof {+ credential_id: proof.credential_id,+ signature: proof.signature,+ },+ }+ .into()+ }+ };+ guard.check().map_err(native_error)?;+ Ok(result)+ })();+ drop(permit);+ let _ = result_tx.send(result);+ })+ .map_err(|_| {+ error(+ rpc::UserVerificationErrorDetails::Failed {+ reason: rpc::UserVerificationFailureReason::ProviderError,+ },+ "User verification could not start.",+ )+ })?;+ let result = match tokio::time::timeout(Duration::from_secs(/*secs*/ 120), work).await {+ Ok(Ok(result)) => result,+ Ok(Err(_)) => Err(error(+ rpc::UserVerificationErrorDetails::Failed {+ reason: rpc::UserVerificationFailureReason::ProviderError,+ },+ "User verification could not complete.",+ )),+ Err(_) => Err(error(+ rpc::UserVerificationErrorDetails::Failed {+ reason: rpc::UserVerificationFailureReason::Timeout,+ },+ "User verification timed out.",+ )),+ };+ // The UI may disconnect or change accounts after the blocking worker completes+ // but before this task receives its result.+ if result.is_ok() {+ cancel.0.check().map_err(native_error)?;+ }+ result.map(|payload| GuardedResponse {+ payload,+ guard: cancel,+ })+}++#[cfg(test)]+#[path = "user_verification_tests.rs"]+mod tests;++#[cfg(test)]+#[path = "user_verification_rpc_tests.rs"]+mod rpc_tests;++#[cfg(test)]+#[path = "user_verification_test_support.rs"]+mod test_support;diff --git a/codex-rs/app-server/src/user_verification_rpc_tests.rs b/codex-rs/app-server/src/user_verification_rpc_tests.rsnew file mode 100644index 0000000000..591d77ae50--- /dev/null+++ b/codex-rs/app-server/src/user_verification_rpc_tests.rs@@ -0,0 +1,188 @@+//! Exercises cancellation and local-device security through the client JSON-RPC dispatcher.++use super::test_support::Harness;+use super::test_support::write_auth;+use super::*;+use crate::outgoing_message::ConnectionId;+use crate::outgoing_message::OutgoingMessage;+use anyhow::Result;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::sync::atomic::Ordering;+use tokio::time::timeout;++#[tokio::test]+async fn user_verification_rpc_auth_revision_discards_native_proof() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ h.initialize("test-local-ui", /*opt_in*/ true).await;+ h.start_verify().await?;+ write_auth(h.home.path(), "second")?;+ h.auth.reload().await;+ h.provider.released.store(/*val*/ true, Ordering::Release);+ let OutgoingMessage::Error(error) = h.response().await else {+ panic!("auth change must reject proof")+ };+ assert_eq!(+ error.error.data,+ Some(json!({"type": "cancelled", "reason": "interrupted"}))+ );+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_rpc_disconnect_cancels_worker_and_releases_slot() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ h.initialize("test-local-ui", /*opt_in*/ true).await;+ h.start_verify().await?;+ timeout(+ Duration::from_secs(/*secs*/ 5),+ h.processor.connection_closed(ConnectionId(1), &h.session),+ )+ .await?;+ assert!(matches!(h.response().await, OutgoingMessage::Error(_)));+ assert_eq!(h.service.worker.available_permits(), 1);+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_rpc_network_peers_cannot_use_server_keys() -> Result<()> {+ for origin in [ConnectionOrigin::WebSocket, ConnectionOrigin::RemoteControl] {+ let mut h = Harness::new(origin, || true).await?;+ h.initialize("codex-tui", /*opt_in*/ true).await;+ for method in [+ "userVerification/enroll",+ "userVerification/delete",+ "userVerification/verify",+ ] {+ let params = if method.ends_with("verify") {+ json!({"challenge":"AQ", "title":"Approve", "description":""})+ } else {+ json!({})+ };+ h.send(/*id*/ 1, method, params).await;+ let OutgoingMessage::Error(error) = h.response().await else {+ panic!("remote native operation must fail")+ };+ assert_eq!(+ error.error.data,+ Some(json!({"type":"unavailable", "reason":"providerUnavailable"}))+ );+ }+ assert_eq!(h.provider.calls.load(Ordering::SeqCst), 0);+ h.shutdown().await;+ }+ Ok(())+}++#[tokio::test]+async fn user_verification_rpc_dropped_caller_cancels_native_work() -> Result<()> {+ let h = Harness::new(ConnectionOrigin::InProcess, || true).await?;+ let (entered, waiting) = oneshot::channel();+ *h.provider.entered.lock().unwrap() = Some(entered);+ let future = h.service.handle(+ Operation::Verify(rpc::UserVerificationVerifyParams {+ challenge: "AQ".into(),+ title: "Approve".into(),+ description: String::new(),+ }),+ Arc::clone(&h.session.rpc_gate),+ CancellationToken::new(),+ ConnectionOrigin::InProcess,+ );+ {+ let future = std::pin::pin!(future);+ tokio::select! { result = future => panic!("native operation should block: {}", result.is_ok()), entered = waiting => entered? }+ }+ let permit = timeout(Duration::from_secs(/*secs*/ 5), h.service.worker.acquire()).await??;+ drop(permit);+ assert_eq!(h.provider.calls.load(Ordering::SeqCst), 1);+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_rechecks_auth_after_response_queue_wait() -> Result<()> {+ let mut h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ h.provider.released.store(/*val*/ true, Ordering::Release);+ let response = h+ .service+ .handle(+ Operation::Verify(rpc::UserVerificationVerifyParams {+ challenge: "AQ".into(),+ title: "Approve".into(),+ description: String::new(),+ }),+ Arc::clone(&h.session.rpc_gate),+ CancellationToken::new(),+ ConnectionOrigin::Stdio,+ )+ .await+ .map_err(|error| anyhow::anyhow!("{error:?}"))?;+ for id in 0..16 {+ h.outgoing+ .send_response(+ crate::outgoing_message::ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: rpc::RequestId::Integer(id),+ },+ rpc::UserVerificationDeleteResponse {},+ )+ .await;+ }+ let outgoing = Arc::clone(&h.outgoing);+ let (payload, check) = response.into_parts();+ let sending = outgoing.send_response_as_checked(+ crate::outgoing_message::ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: rpc::RequestId::Integer(16),+ },+ payload,+ check,+ );+ let mut sending = std::pin::pin!(sending);+ assert!(matches!(+ futures::poll!(&mut sending),+ std::task::Poll::Pending+ ));+ write_auth(h.home.path(), "second")?;+ h.auth.reload().await;+ h.response().await;+ sending.await;+ for _ in 1..16 {+ h.response().await;+ }+ let OutgoingMessage::Error(error) = h.response().await else {+ panic!("queued response must recheck auth")+ };+ assert_eq!(+ error.error.data,+ Some(json!({"type":"cancelled", "reason":"interrupted"}))+ );+ h.shutdown().await;+ Ok(())+}++#[tokio::test]+async fn user_verification_rejects_concurrent_native_workers() -> Result<()> {+ let h = Harness::new(ConnectionOrigin::Stdio, || true).await?;+ let permit = h.service.worker.clone().acquire_owned().await?;+ let result = h+ .service+ .handle(+ Operation::Status,+ Arc::clone(&h.session.rpc_gate),+ CancellationToken::new(),+ ConnectionOrigin::Stdio,+ )+ .await;+ assert_eq!(+ result.err().unwrap().message,+ "Another user verification operation is still running."+ );+ assert_eq!(h.provider.calls.load(Ordering::SeqCst), 0);+ drop(permit);+ h.shutdown().await;+ Ok(())+}diff --git a/codex-rs/app-server/src/user_verification_test_support.rs b/codex-rs/app-server/src/user_verification_test_support.rsnew file mode 100644index 0000000000..413be31d79--- /dev/null+++ b/codex-rs/app-server/src/user_verification_test_support.rs@@ -0,0 +1,270 @@+//! Dispatcher harness with a controllable native provider for lifecycle tests.+//! Public stdio and WebSocket framing are exercised in the integration suite.++use super::*;+use crate::config_manager::ConfigManager;+use crate::message_processor::ConnectionSessionState;+use crate::message_processor::MessageProcessor;+use crate::message_processor::MessageProcessorArgs;+use crate::outgoing_message::ConnectionId;+use crate::outgoing_message::OutgoingEnvelope;+use crate::outgoing_message::OutgoingMessage;+use crate::outgoing_message::OutgoingMessageSender;+use crate::transport::AppServerTransport;+use anyhow::Result;+use app_test_support::ChatGptAuthFixture;+use app_test_support::write_chatgpt_auth;+use base64::Engine as _;+use base64::engine::general_purpose::URL_SAFE_NO_PAD;+use codex_analytics::AnalyticsEventsClient;+use codex_analytics::AppServerRpcTransport;+use codex_arg0::Arg0DispatchPaths;+use codex_config::CloudConfigBundleLoader;+use codex_config::LoaderOverrides;+use codex_config::types::AuthCredentialsStoreMode;+use codex_core::config::ConfigBuilder;+use codex_exec_server::EnvironmentManager;+use codex_feedback::CodexFeedback;+use codex_protocol::protocol::SessionSource;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::sync::Mutex;+use std::sync::atomic::AtomicBool;+use std::sync::atomic::AtomicUsize;+use std::sync::atomic::Ordering;+use tokio::sync::mpsc;+use tokio::time::timeout;++#[derive(Default)]+pub(super) struct BlockingProvider {+ pub(super) entered: Mutex<Option<oneshot::Sender<()>>>,+ pub(super) released: AtomicBool,+ pub(super) calls: AtomicUsize,+}++impl native::UserVerificationProvider for BlockingProvider {+ fn status(+ &self,+ guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationStatus, native::UserVerificationError> {+ guard.check()?;+ Ok(native::UserVerificationStatus {+ credential: None,+ unavailable_reason: Some(native::UserVerificationUnavailableReason::CredentialMissing),+ unavailable_message: None,+ })+ }+ fn ensure_key(+ &self,+ _guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationKeyCreation, native::UserVerificationError> {+ unreachable!("this test must not create keys")+ }+ fn delete(+ &self,+ _guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationKeyDeletion, native::UserVerificationError> {+ unreachable!("this test must not delete keys")+ }+ fn verify(+ &self,+ _request: &native::UserVerificationRequest,+ guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationProof, native::UserVerificationError> {+ self.calls.fetch_add(/*val*/ 1, Ordering::SeqCst);+ if let Some(entered) = self.entered.lock().unwrap().take() {+ let _ = entered.send(());+ }+ let deadline = std::time::Instant::now() + Duration::from_secs(/*secs*/ 10);+ while !self.released.load(Ordering::Acquire) {+ guard.check()?;+ assert!(+ std::time::Instant::now() < deadline,+ "test failed to release native worker"+ );+ std::thread::sleep(Duration::from_millis(/*millis*/ 5));+ }+ Ok(native::UserVerificationProof {+ credential_id: "credential".into(),+ signature: "signature".into(),+ })+ }+}++pub(super) struct Harness {+ pub(super) processor: Arc<MessageProcessor>,+ pub(super) session: Arc<ConnectionSessionState>,+ pub(super) auth: Arc<AuthManager>,+ pub(super) service: Arc<Service>,+ pub(super) provider: Arc<BlockingProvider>,+ pub(super) outgoing: Arc<OutgoingMessageSender>,+ pub(super) messages: mpsc::Receiver<OutgoingEnvelope>,+ pub(super) home: tempfile::TempDir,+ transport: AppServerTransport,+}++impl Harness {+ pub(super) async fn new(origin: ConnectionOrigin, supported: fn() -> bool) -> Result<Self> {+ let home = tempfile::tempdir()?;+ write_auth(home.path(), "first")?;+ let config = Arc::new(+ ConfigBuilder::default()+ .codex_home(home.path().into())+ .build()+ .await?,+ );+ let auth = AuthManager::shared_from_config(+ config.as_ref(),+ /*enable_codex_api_key_env*/ false,+ )+ .await?;+ let provider = Arc::new(BlockingProvider::default());+ let factory_provider = Arc::clone(&provider);+ let service = Arc::new(Service {+ auth_manager: Arc::clone(&auth),+ provider: Arc::new(move |_| factory_provider.clone()),+ platform_supported: true,+ device_supported: supported,+ worker: Arc::new(Semaphore::new(/*permits*/ 1)),+ });+ let config_manager = ConfigManager::new(+ home.path().into(),+ Vec::new(),+ LoaderOverrides::default(),+ /*strict_config*/ false,+ CloudConfigBundleLoader::default(),+ Arg0DispatchPaths::default(),+ Arc::new(codex_config::NoopThreadConfigLoader),+ );+ let (sender, messages) = mpsc::channel(/*buffer*/ 16);+ let outgoing = Arc::new(OutgoingMessageSender::new(+ sender,+ AnalyticsEventsClient::disabled(),+ ));+ let processor = Arc::new(MessageProcessor::new(MessageProcessorArgs {+ outgoing: Arc::clone(&outgoing),+ analytics_events_client: AnalyticsEventsClient::disabled(),+ arg0_paths: Arg0DispatchPaths::default(),+ config,+ config_manager,+ environment_manager: Arc::new(EnvironmentManager::default_for_tests()),+ feedback: CodexFeedback::new(),+ log_db: None,+ state_db: None,+ config_warnings: Vec::new(),+ session_source: SessionSource::Cli,+ auth_manager: Arc::clone(&auth),+ user_verification: Arc::clone(&service),+ installation_id: "11111111-1111-4111-8111-111111111111".into(),+ code_mode_session_provider: None,+ rpc_transport: match origin {+ ConnectionOrigin::InProcess => AppServerRpcTransport::InProcess,+ ConnectionOrigin::Stdio | ConnectionOrigin::RemoteControl => {+ AppServerRpcTransport::Stdio+ }+ ConnectionOrigin::WebSocket => AppServerRpcTransport::Websocket,+ },+ remote_control_handle: None,+ plugin_startup_tasks: None,+ }));+ Ok(Self {+ processor,+ session: Arc::new(ConnectionSessionState::new(origin)),+ auth,+ service,+ provider,+ outgoing,+ messages,+ home,+ transport: match origin {+ ConnectionOrigin::WebSocket => AppServerTransport::WebSocket {+ bind_address: "127.0.0.1:0".parse()?,+ },+ // Remote control can share a process whose primary listener is stdio.+ // Keeping that case tests that authorization uses the connection's origin.+ ConnectionOrigin::Stdio+ | ConnectionOrigin::InProcess+ | ConnectionOrigin::RemoteControl => AppServerTransport::Stdio,+ },+ })+ }++ pub(super) async fn send(&self, id: i64, method: &str, params: serde_json::Value) {+ self.processor+ .process_request(+ ConnectionId(1),+ rpc::JSONRPCRequest {+ id: rpc::RequestId::Integer(id),+ method: method.into(),+ params: Some(params),+ trace: None,+ },+ &self.transport,+ Arc::clone(&self.session),+ )+ .await;+ }++ pub(super) async fn response(&mut self) -> OutgoingMessage {+ let envelope = timeout(Duration::from_secs(/*secs*/ 10), self.messages.recv())+ .await+ .expect("response deadline")+ .expect("response channel");+ let OutgoingEnvelope::ToConnection {+ connection_id,+ message,+ ..+ } = envelope+ else {+ panic!("unexpected broadcast")+ };+ assert_eq!(connection_id, ConnectionId(1));+ message+ }++ pub(super) async fn initialize(&mut self, name: &str, opt_in: bool) {+ self.send(/*id*/ 0, "initialize", json!({"clientInfo": {"name": name, "version": "1"}, "capabilities": {"experimentalApi": opt_in}})).await;+ assert!(matches!(+ self.response().await,+ OutgoingMessage::Response(_)+ ));+ }++ pub(super) async fn start_verify(&self) -> Result<()> {+ let (entered, waiting) = oneshot::channel();+ *self.provider.entered.lock().unwrap() = Some(entered);+ self.send(+ /*id*/ 1,+ "userVerification/verify",+ json!({"challenge": "AQID", "title": "Approve", "description": "Action"}),+ )+ .await;+ timeout(Duration::from_secs(/*secs*/ 10), waiting).await??;+ Ok(())+ }++ pub(super) async fn shutdown(self) {+ self.provider+ .released+ .store(/*val*/ true, Ordering::Release);+ self.processor+ .connection_closed(ConnectionId(1), &self.session)+ .await;+ self.processor.clear_runtime_references();+ self.processor.clear_all_thread_listeners().await;+ self.processor.drain_background_tasks().await;+ self.processor.shutdown_threads().await;+ }+}++pub(super) fn write_auth(home: &std::path::Path, token: &str) -> Result<()> {+ let payload = URL_SAFE_NO_PAD.encode(serde_json::to_vec(&json!({"jti": token, "https://api.openai.com/auth": {"chatgpt_account_id": "account-1", "chatgpt_account_user_id": "membership-1"}}))?);+ write_chatgpt_auth(+ home,+ ChatGptAuthFixture::new(format!("header.{payload}.signature"))+ .chatgpt_user_id("user-1")+ .account_id("account-1")+ .chatgpt_account_id("account-1"),+ AuthCredentialsStoreMode::File,+ )+}diff --git a/codex-rs/app-server/src/user_verification_tests.rs b/codex-rs/app-server/src/user_verification_tests.rsnew file mode 100644index 0000000000..65970c750d--- /dev/null+++ b/codex-rs/app-server/src/user_verification_tests.rs@@ -0,0 +1,192 @@+//! Verifies local key lifecycle, signing, and cancellation without transport concerns.++use super::*;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::sync::Mutex;+use std::sync::atomic::AtomicBool;+use std::sync::atomic::Ordering;++#[derive(Default)]+struct Provider {+ key: Mutex<Option<native::UserVerificationKeyInfo>>,+ signed: Mutex<Vec<Vec<u8>>>,+ deactivate_on_sign: Option<Arc<AtomicBool>>,+}++impl native::UserVerificationProvider for Provider {+ fn status(+ &self,+ _guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationStatus, native::UserVerificationError> {+ let credential = self.key.lock().unwrap().clone();+ Ok(native::UserVerificationStatus {+ unavailable_reason: credential+ .is_none()+ .then_some(native::UserVerificationUnavailableReason::CredentialMissing),+ unavailable_message: credential.is_none().then(|| "No key".into()),+ credential,+ })+ }+ fn ensure_key(+ &self,+ guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationKeyCreation, native::UserVerificationError> {+ guard.check()?;+ let mut key = self.key.lock().unwrap();+ let created = key.is_none();+ let credential = key+ .get_or_insert_with(|| native::UserVerificationKeyInfo {+ credential_id: "credential".into(),+ algorithm: "ecdsaP256Sha256X962".into(),+ public_key: "public-key".into(),+ })+ .clone();+ Ok(native::UserVerificationKeyCreation {+ created,+ credential,+ })+ }+ fn delete(+ &self,+ guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationKeyDeletion, native::UserVerificationError> {+ guard.check()?;+ Ok(native::UserVerificationKeyDeletion {+ deleted_credential_id: self.key.lock().unwrap().take().map(|key| key.credential_id),+ })+ }+ fn verify(+ &self,+ request: &native::UserVerificationRequest,+ guard: &native::UserVerificationRequestGuard,+ ) -> Result<native::UserVerificationProof, native::UserVerificationError> {+ guard.check()?;+ self.signed.lock().unwrap().push(request.challenge.clone());+ if let Some(active) = &self.deactivate_on_sign {+ active.store(/*val*/ false, Ordering::Release);+ }+ Ok(native::UserVerificationProof {+ credential_id: "credential".into(),+ signature: "signature".into(),+ })+ }+}++#[tokio::test]+async fn local_enrollment_reuses_key_and_status_and_delete_have_no_signing_effects() {+ let provider = Arc::new(Provider::default());+ for _ in 0..2 {+ let response = run(+ NativeOperation::Enroll,+ provider.clone(),+ native::UserVerificationRequestGuard::default(),+ Arc::new(Semaphore::new(/*permits*/ 1)),+ )+ .await+ .unwrap();+ assert_eq!(+ serde_json::to_value(response.payload).unwrap(),+ json!({"credentialId": "credential"})+ );+ }+ let response = run(+ NativeOperation::Status,+ provider.clone(),+ native::UserVerificationRequestGuard::default(),+ Arc::new(Semaphore::new(/*permits*/ 1)),+ )+ .await+ .unwrap();+ assert_eq!(+ serde_json::to_value(response.payload).unwrap(),+ json!({"credentialId": "credential", "unavailableReason": null, "unavailableMessage": null})+ );+ for _ in 0..2 {+ let response = run(+ NativeOperation::Delete,+ provider.clone(),+ native::UserVerificationRequestGuard::default(),+ Arc::new(Semaphore::new(/*permits*/ 1)),+ )+ .await+ .unwrap();+ assert_eq!(serde_json::to_value(response.payload).unwrap(), json!({}));+ }+ assert_eq!(*provider.key.lock().unwrap(), None);+ assert!(provider.signed.lock().unwrap().is_empty());+}++#[tokio::test]+async fn signing_uses_decoded_bytes_without_a_pending_elicitation() {+ let provider = Arc::new(Provider::default());+ let request = validate(rpc::UserVerificationVerifyParams {+ challenge: "AQID".into(),+ title: "Approve".into(),+ description: "Action".into(),+ })+ .unwrap();+ let response = run(+ NativeOperation::Verify(request),+ provider.clone(),+ native::UserVerificationRequestGuard::default(),+ Arc::new(Semaphore::new(/*permits*/ 1)),+ )+ .await+ .unwrap();+ assert_eq!(+ serde_json::to_value(response.payload).unwrap(),+ json!({"proof": {"credentialId": "credential", "signature": "signature"}})+ );+ assert_eq!(*provider.signed.lock().unwrap(), vec![vec![1, 2, 3]]);+}++#[tokio::test]+async fn identity_change_during_native_prompt_discards_proof() {+ let active = Arc::new(AtomicBool::new(/*v*/ true));+ let provider = Arc::new(Provider {+ deactivate_on_sign: Some(active.clone()),+ ..Default::default()+ });+ let guard = native::UserVerificationRequestGuard::with_activity_check(move || {+ active.load(Ordering::Acquire)+ });+ let response = run(+ NativeOperation::Verify(native::UserVerificationRequest {+ challenge: vec![1],+ title: "Approve".into(),+ description: String::new(),+ }),+ provider,+ guard,+ Arc::new(Semaphore::new(/*permits*/ 1)),+ )+ .await+ .err()+ .unwrap();+ assert_eq!(+ response.data,+ Some(json!({"type": "cancelled", "reason": "interrupted"}))+ );+}++#[tokio::test]+async fn cancelled_operation_cannot_create_a_key() {+ let provider = Arc::new(Provider::default());+ let guard = native::UserVerificationRequestGuard::default();+ guard.cancel();+ let response = run(+ NativeOperation::Enroll,+ provider.clone(),+ guard,+ Arc::new(Semaphore::new(/*permits*/ 1)),+ )+ .await+ .err()+ .unwrap();+ assert_eq!(+ response.data,+ Some(json!({"type": "cancelled", "reason": "interrupted"}))+ );+ assert_eq!(*provider.key.lock().unwrap(), None);+}diff --git a/codex-rs/app-server/tests/suite/v2/user_verification.rs b/codex-rs/app-server/tests/suite/v2/user_verification.rsindex 1da2477f05..20a54a7fd8 100644--- a/codex-rs/app-server/tests/suite/v2/user_verification.rs+++ b/codex-rs/app-server/tests/suite/v2/user_verification.rs@@ -1,3 +1,8 @@+use super::connection_handling_websocket::connect_websocket;+use super::connection_handling_websocket::read_error_for_id;+use super::connection_handling_websocket::read_response_for_id;+use super::connection_handling_websocket::send_request;+use super::connection_handling_websocket::spawn_websocket_server;use anyhow::Result;use app_test_support::DEFAULT_CLIENT_NAME;use app_test_support::TestAppServer;@@ -50,6 +55,26 @@ async fn user_verification_methods_require_experimental_opt_in() -> Result<()> {Ok(())}+#[tokio::test]+async fn user_verification_status_without_account_returns_local_readiness() -> Result<()> {+ let mut app_server = TestAppServer::builder().build_initialized().await?;+ let id = app_server+ .send_raw_request("userVerification/status", Some(json!({})))+ .await?;+ let response = app_server+ .read_stream_until_response_message(RequestId::Integer(id))+ .await?;+ assert_eq!(+ response.result,+ json!({+ "credentialId": null,+ "unavailableReason": "providerUnavailable",+ "unavailableMessage": "User verification is not available in this build or account."+ })+ );+ Ok(())+}+#[tokio::test]async fn user_verification_without_provider_returns_typed_unavailability() -> Result<()> {let mut app_server = TestAppServer::builder().build_initialized().await?;@@ -74,3 +99,96 @@ async fn user_verification_without_provider_returns_typed_unavailability() -> Re);Ok(())}++#[tokio::test]+async fn user_verification_stdio_requires_initialization_then_validates_challenges() -> Result<()> {+ let mut app_server = TestAppServer::builder().build().await?;+ let params = json!({"challenge": "!", "title": "Approve", "description": ""});+ let id = app_server+ .send_raw_request("userVerification/verify", Some(params.clone()))+ .await?;+ let response = app_server+ .read_stream_until_error_message(RequestId::Integer(id))+ .await?;+ assert_eq!(+ response.error,+ JSONRPCErrorError {+ code: -32600,+ message: "Not initialized".into(),+ data: None,+ }+ );+ app_server.initialize().await?;+ let id = app_server+ .send_raw_request("userVerification/verify", Some(params))+ .await?;+ let response = app_server+ .read_stream_until_error_message(RequestId::Integer(id))+ .await?;+ assert_eq!(+ response.error,+ JSONRPCErrorError {+ code: -32602,+ message: "Invalid verification challenge or display text.".into(),+ data: Some(json!({"type": "invalidRequest", "reason": "invalidParams"})),+ }+ );+ Ok(())+}++#[tokio::test]+async fn user_verification_websocket_blocks_native_operations_before_validation() -> Result<()> {+ // TestAppServer speaks stdio; use the existing transport fixture for real WebSocket frames.+ let home = tempfile::tempdir()?;+ let (mut process, address) = spawn_websocket_server(home.path()).await?;+ let mut websocket = connect_websocket(address).await?;+ send_request(+ &mut websocket,+ "initialize",+ /*id*/ 0,+ Some(json!({+ "clientInfo": {"name": "codex-tui", "version": "1"},+ "capabilities": {"experimentalApi": true},+ })),+ )+ .await?;+ read_response_for_id(&mut websocket, /*id*/ 0).await?;+ send_request(+ &mut websocket,+ "userVerification/status",+ /*id*/ 1,+ Some(json!({})),+ )+ .await?;+ assert_eq!(+ read_response_for_id(&mut websocket, /*id*/ 1).await?.result,+ json!({+ "credentialId": null,+ "unavailableReason": "providerUnavailable",+ "unavailableMessage": "User verification is not available in this build or account."+ })+ );++ // This challenge produces invalidRequest over stdio. A network peer must be+ // rejected before validation, regardless of account or biometric hardware.+ for (method, params) in [+ ("userVerification/enroll", json!({})),+ ("userVerification/delete", json!({})),+ (+ "userVerification/verify",+ json!({"challenge": "!", "title": "Approve", "description": ""}),+ ),+ ] {+ send_request(&mut websocket, method, /*id*/ 2, Some(params)).await?;+ assert_eq!(+ read_error_for_id(&mut websocket, /*id*/ 2).await?.error,+ JSONRPCErrorError {+ code: -32603,+ message: "User verification is not available in this build or account.".into(),+ data: Some(json!({"type": "unavailable", "reason": "providerUnavailable"})),+ }+ );+ }+ process.kill().await?;+ Ok(())+}