Lightweight coding agent that runs in your terminal
Rust
Add TUI request bookkeeping for user verification (#43708)
riley-oai95327467c3af
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 51536cad3f..768128b335 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -257,6 +257,10 @@ mod thread_session_state;mod thread_settings;mod thread_title;mod transcript_export;+#[cfg_attr(not(test), allow(dead_code))]+mod user_verification_errors;+#[allow(dead_code)] // Connected by the following verification UI integration.+mod user_verification_requests;mod working_directory;use self::agent_navigation::AgentNavigationDirection;diff --git a/codex-rs/tui/src/app/app_server_requests.rs b/codex-rs/tui/src/app/app_server_requests.rsindex 64ebda4f88..4530e7a5b8 100644--- a/codex-rs/tui/src/app/app_server_requests.rs+++ b/codex-rs/tui/src/app/app_server_requests.rs@@ -77,6 +77,7 @@ pub(super) struct PendingAppServerRequests {permissions_approvals: HashMap<(String, String), AppServerRequestId>,user_inputs: HashMap<String, VecDeque<PendingUserInputRequest>>,mcp_requests: HashMap<McpRequestKey, AppServerRequestId>,+ pub(super) user_verification: super::user_verification_requests::UserVerificationRequests,}impl PendingAppServerRequests {@@ -92,6 +93,7 @@ impl PendingAppServerRequests {self.permissions_approvals.clear();self.user_inputs.clear();self.mcp_requests.clear();+ self.user_verification.clear();}pub(super) fn note_server_request(@@ -153,6 +155,7 @@ impl PendingAppServerRequests {None}ServerRequest::McpServerElicitationRequest { request_id, params } => {+ self.user_verification.note_request(request_id, params);self.mcp_requests.insert(McpRequestKey {server_name: params.server_name.clone(),@@ -202,7 +205,43 @@ impl PendingAppServerRequests {T: Into<AppCommand>,{let thread_id = Self::canonical_thread_id(thread_id);- let op: AppCommand = op.into();+ let op: AppCommand = match op.into() {+ AppCommand::ResolveUserVerification {+ server_name,+ request_id,+ response,+ } => {+ let (decision, content) = match response {+ crate::app_command::UserVerificationResponse::Accept { proof } => (+ codex_app_server_protocol::McpServerElicitationAction::Accept,+ Some(+ serde_json::to_value(proof)+ .map_err(|_| "Invalid verification proof".to_string())?,+ ),+ ),+ crate::app_command::UserVerificationResponse::Cancel => (+ codex_app_server_protocol::McpServerElicitationAction::Cancel,+ None,+ ),+ };+ AppCommand::ResolveElicitation {+ server_name,+ request_id,+ decision,+ content,+ meta: None,+ }+ }+ op => op,+ };+ if let AppCommand::ResolveElicitation {+ server_name,+ request_id,+ ..+ } = &op+ {+ self.user_verification.remove(server_name, request_id);+ }let resolution = match &op {AppCommand::ExecApproval { id, decision, .. } => self.exec_approvals@@ -345,6 +384,8 @@ impl PendingAppServerRequests {.find_map(|(key, value)| (value == request_id).then(|| key.clone())){self.mcp_requests.remove(&key);+ self.user_verification+ .remove(&key.server_name, &key.request_id);return Some(ResolvedAppServerRequest::McpElicitation {server_name: key.server_name,request_id: key.request_id,diff --git a/codex-rs/tui/src/app/pending_interactive_replay.rs b/codex-rs/tui/src/app/pending_interactive_replay.rsindex 0f23191a0d..366591569b 100644--- a/codex-rs/tui/src/app/pending_interactive_replay.rs+++ b/codex-rs/tui/src/app/pending_interactive_replay.rs@@ -80,6 +80,7 @@ impl PendingInteractiveReplayState {AppCommand::ExecApproval { .. }| AppCommand::PatchApproval { .. }| AppCommand::ResolveElicitation { .. }+ | AppCommand::ResolveUserVerification { .. }| AppCommand::RequestPermissionsResponse { .. }| AppCommand::UserInputAnswer { .. })@@ -116,6 +117,11 @@ impl PendingInteractiveReplayState {server_name,request_id,..+ }+ | AppCommand::ResolveUserVerification {+ server_name,+ request_id,+ ..} => {self.elicitation_requests.remove(&ElicitationRequestKey::new(@@ -901,23 +907,40 @@ mod tests {#[test]fn thread_event_snapshot_drops_resolved_elicitation_after_outbound_resolution() {- let mut store = ThreadEventStore::new(/*capacity*/ 8);let request_id = AppServerRequestId::String("request-1".to_string());- store.push_request(elicitation_request("server-1", "request-1", "turn-1"));-- store.note_outbound_op(&Op::ResolveElicitation {- server_name: "server-1".to_string(),- request_id,- decision: McpServerElicitationAction::Accept,- content: None,- meta: None,- });-- let snapshot = store.snapshot();- assert!(- snapshot.events.is_empty(),- "resolved elicitation prompt should not replay on thread switch"- );+ for response in [+ Op::ResolveElicitation {+ server_name: "server-1".to_string(),+ request_id: request_id.clone(),+ decision: McpServerElicitationAction::Accept,+ content: None,+ meta: None,+ },+ Op::ResolveUserVerification {+ server_name: "server-1".to_string(),+ request_id,+ response: crate::app_command::UserVerificationResponse::Cancel,+ },+ ] {+ let mut store = ThreadEventStore::new(/*capacity*/ 8);+ let mut request = elicitation_request("server-1", "request-1", "turn-1");+ if matches!(&response, Op::ResolveUserVerification { .. })+ && let ServerRequest::McpServerElicitationRequest { params, .. } = &mut request+ {+ params.request = McpServerElicitationRequest::UserVerification {+ title: "Verify".to_string(),+ description: "Approve deployment".to_string(),+ challenge: "AQID".to_string(),+ };+ }+ store.push_request(request);+ assert_eq!(store.snapshot().events.len(), 1);+ store.note_outbound_op(&response);+ assert!(+ store.snapshot().events.is_empty(),+ "resolved elicitation prompt should not replay on thread switch"+ );+ }}#[test]diff --git a/codex-rs/tui/src/app/user_verification_errors.rs b/codex-rs/tui/src/app/user_verification_errors.rsnew file mode 100644index 0000000000..19a1aee827--- /dev/null+++ b/codex-rs/tui/src/app/user_verification_errors.rs@@ -0,0 +1,55 @@+//! Safe user-facing messages for typed local verification failures.++use codex_app_server_client::TypedRequestError;+use codex_app_server_protocol::UserVerificationCancellationReason;+use codex_app_server_protocol::UserVerificationErrorDetails;+use codex_app_server_protocol::UserVerificationFailureReason;+use codex_app_server_protocol::UserVerificationInvalidRequestReason;+use codex_app_server_protocol::UserVerificationUnavailableReason;++pub(super) fn verification_error_message(error: &TypedRequestError) -> &'static str {+ let TypedRequestError::Server { source, .. } = error else {+ return "Could not complete user verification with the local Codex binary.";+ };+ let details = source+ .data+ .clone()+ .and_then(|data| serde_json::from_value::<UserVerificationErrorDetails>(data).ok());+ match details {+ Some(UserVerificationErrorDetails::InvalidRequest {+ reason: UserVerificationInvalidRequestReason::InvalidParams,+ }) => "The local Codex binary could not verify this request.",+ Some(UserVerificationErrorDetails::Unavailable {+ reason: UserVerificationUnavailableReason::CredentialMissing,+ }) => "No user-verification credential is available in the local Codex binary.",+ Some(UserVerificationErrorDetails::Unavailable {+ reason: UserVerificationUnavailableReason::BiometricsUnavailable,+ }) => "Biometric verification is currently unavailable on this device.",+ Some(UserVerificationErrorDetails::Unavailable {+ reason: UserVerificationUnavailableReason::ProviderUnavailable,+ }) => "User verification is unavailable for this request.",+ Some(UserVerificationErrorDetails::Cancelled {+ reason: UserVerificationCancellationReason::UserCancelled,+ }) => "User verification was cancelled.",+ Some(UserVerificationErrorDetails::Cancelled {+ reason: UserVerificationCancellationReason::Interrupted,+ }) => "User verification was interrupted.",+ Some(UserVerificationErrorDetails::Failed {+ reason: UserVerificationFailureReason::AuthenticationFailed,+ }) => "Biometric verification did not succeed. The request was cancelled.",+ Some(UserVerificationErrorDetails::Failed {+ reason: UserVerificationFailureReason::Timeout,+ }) => "User verification timed out. The request was cancelled.",+ Some(UserVerificationErrorDetails::Failed {+ reason: UserVerificationFailureReason::ProviderError,+ })+ | Some(UserVerificationErrorDetails::Failed {+ reason: UserVerificationFailureReason::ServiceError,+ })+ | None => "The local Codex binary could not complete user verification.",+ }+}++#[cfg(test)]+#[path = "user_verification_errors_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app/user_verification_errors_tests.rs b/codex-rs/tui/src/app/user_verification_errors_tests.rsnew file mode 100644index 0000000000..89393f1cba--- /dev/null+++ b/codex-rs/tui/src/app/user_verification_errors_tests.rs@@ -0,0 +1,57 @@+use super::*;+use codex_app_server_protocol::JSONRPCErrorError;+use pretty_assertions::assert_eq;++#[test]+fn user_verification_errors_use_typed_reasons_without_raw_provider_diagnostics() {+ let error = TypedRequestError::Server {+ method: "userVerification/verify".to_string(),+ source: JSONRPCErrorError {+ code: -32603,+ message: "private native provider diagnostics".to_string(),+ data: Some(serde_json::json!({ "type": "unavailable", "reason": "credentialMissing" })),+ },+ };+ assert_eq!(+ verification_error_message(&error),+ "No user-verification credential is available in the local Codex binary."+ );+ let malformed = TypedRequestError::Server {+ method: "userVerification/verify".to_string(),+ source: JSONRPCErrorError {+ code: -32603,+ message: "private native provider diagnostics".to_string(),+ data: Some(+ serde_json::json!({ "type": "unavailable", "reason": "secret native failure" }),+ ),+ },+ };+ assert_eq!(+ verification_error_message(&malformed),+ "The local Codex binary could not complete user verification."+ );+}++#[test]+fn unavailable_reasons_use_device_and_session_neutral_copy() {+ for (reason, expected) in [+ (+ "biometricsUnavailable",+ "Biometric verification is currently unavailable on this device.",+ ),+ (+ "providerUnavailable",+ "User verification is unavailable for this request.",+ ),+ ] {+ let error = TypedRequestError::Server {+ method: "userVerification/verify".to_string(),+ source: JSONRPCErrorError {+ code: -32603,+ message: "private native provider diagnostics".to_string(),+ data: Some(serde_json::json!({ "type": "unavailable", "reason": reason })),+ },+ };+ assert_eq!(verification_error_message(&error), expected);+ }+}diff --git a/codex-rs/tui/src/app/user_verification_requests.rs b/codex-rs/tui/src/app/user_verification_requests.rsnew file mode 100644index 0000000000..667d945054--- /dev/null+++ b/codex-rs/tui/src/app/user_verification_requests.rs@@ -0,0 +1,106 @@+//! Keeps the approved request bytes separate from the view and rejects late signing results.++use std::collections::HashMap;++use codex_app_server_protocol::McpServerElicitationRequest;+use codex_app_server_protocol::McpServerElicitationRequestParams;+use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::UserVerificationVerifyParams;+use tokio_util::sync::CancellationToken;+use uuid::Uuid;++#[derive(Debug, Default)]+pub(super) struct UserVerificationRequests {+ pending: HashMap<(String, RequestId), PendingVerification>,+}++#[derive(Debug)]+struct PendingVerification {+ params: UserVerificationVerifyParams,+ attempt: Option<Uuid>,+ cancelled: CancellationToken,+}++pub(super) struct UserVerificationAttempt {+ pub(super) id: Uuid,+ pub(super) params: UserVerificationVerifyParams,+ pub(super) cancelled: CancellationToken,+}++impl Drop for PendingVerification {+ fn drop(&mut self) {+ self.cancelled.cancel();+ }+}++impl UserVerificationRequests {+ pub(super) fn note_request(+ &mut self,+ request_id: &RequestId,+ params: &McpServerElicitationRequestParams,+ ) {+ if let McpServerElicitationRequest::UserVerification {+ title,+ description,+ challenge,+ } = ¶ms.request+ {+ self.pending.insert(+ (params.server_name.clone(), request_id.clone()),+ PendingVerification {+ params: UserVerificationVerifyParams {+ title: title.clone(),+ description: description.clone(),+ challenge: challenge.clone(),+ },+ attempt: None,+ cancelled: CancellationToken::new(),+ },+ );+ }+ }++ pub(super) fn begin(+ &mut self,+ server_name: &str,+ request_id: &RequestId,+ ) -> Option<UserVerificationAttempt> {+ let pending = self+ .pending+ .get_mut(&(server_name.to_string(), request_id.clone()))?;+ if pending.attempt.is_some() {+ return None;+ }+ let attempt = Uuid::new_v4();+ pending.attempt = Some(attempt);+ Some(UserVerificationAttempt {+ id: attempt,+ params: pending.params.clone(),+ cancelled: pending.cancelled.clone(),+ })+ }++ pub(super) fn is_pending(+ &self,+ server_name: &str,+ request_id: &RequestId,+ attempt: Uuid,+ ) -> bool {+ self.pending+ .get(&(server_name.to_string(), request_id.clone()))+ .is_some_and(|pending| pending.attempt == Some(attempt))+ }++ pub(super) fn remove(&mut self, server_name: &str, request_id: &RequestId) {+ self.pending+ .remove(&(server_name.to_string(), request_id.clone()));+ }++ pub(super) fn clear(&mut self) {+ self.pending.clear();+ }+}++#[cfg(test)]+#[path = "user_verification_requests_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app/user_verification_requests_tests.rs b/codex-rs/tui/src/app/user_verification_requests_tests.rsnew file mode 100644index 0000000000..b23a4285a9--- /dev/null+++ b/codex-rs/tui/src/app/user_verification_requests_tests.rs@@ -0,0 +1,168 @@+use crate::app::app_server_requests::AppServerRequestResolution;+use crate::app::app_server_requests::PendingAppServerRequests;+use crate::app::app_server_requests::ResolvedAppServerRequest;+use crate::app_command::AppCommand;+use crate::app_command::UserVerificationResponse;+use codex_app_server_protocol::McpServerElicitationRequest;+use codex_app_server_protocol::McpServerElicitationRequestParams;+use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::ServerRequest;+use codex_app_server_protocol::UserVerificationProof;+use codex_protocol::ThreadId;+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(),+ },+ },+ }+}++#[test]+fn user_verification_cancellation_invalidates_the_inflight_result() {+ let mut pending = PendingAppServerRequests::default();+ let request = verification_request();+ pending.note_server_request(&request);+ let attempt = pending+ .user_verification+ .begin("deployments", request.id())+ .expect("pending request");+ assert!(+ pending+ .user_verification+ .begin("deployments", request.id())+ .is_none()+ );+ assert!(+ pending+ .user_verification+ .is_pending("deployments", request.id(), attempt.id)+ );+ let resolution = pending+ .take_resolution(+ "unused",+ AppCommand::resolve_user_verification(+ "deployments".to_string(),+ request.id().clone(),+ UserVerificationResponse::Cancel,+ ),+ )+ .expect("cancel response");+ assert_eq!(+ resolution,+ Some(AppServerRequestResolution {+ request_id: request.id().clone(),+ result: serde_json::json!({ "action": "cancel", "content": null, "_meta": null }),+ })+ );+ assert!(+ !pending+ .user_verification+ .is_pending("deployments", request.id(), attempt.id)+ );+ assert!(attempt.cancelled.is_cancelled());+}++#[test]+fn user_verification_reconnect_cannot_accept_a_previous_connections_proof() {+ let mut pending = PendingAppServerRequests::default();+ let request = verification_request();+ pending.note_server_request(&request);+ let previous = pending+ .user_verification+ .begin("deployments", request.id())+ .expect("first request");+ pending.clear();+ assert!(previous.cancelled.is_cancelled());+ pending.note_server_request(&request);+ let current = pending+ .user_verification+ .begin("deployments", request.id())+ .expect("new request");+ assert!(+ !pending+ .user_verification+ .is_pending("deployments", request.id(), previous.id)+ );+ assert!(+ pending+ .user_verification+ .is_pending("deployments", request.id(), current.id)+ );+}++#[test]+fn user_verification_server_resolution_invalidates_the_inflight_result() {+ let mut pending = PendingAppServerRequests::default();+ let request = verification_request();+ pending.note_server_request(&request);+ let attempt = pending+ .user_verification+ .begin("deployments", request.id())+ .expect("pending request");+ assert_eq!(+ pending.resolve_notification("unused", request.id()),+ Some(ResolvedAppServerRequest::McpElicitation {+ server_name: "deployments".to_string(),+ request_id: request.id().clone()+ })+ );+ assert!(+ !pending+ .user_verification+ .is_pending("deployments", request.id(), attempt.id)+ );+ assert!(attempt.cancelled.is_cancelled());+}++#[test]+fn user_verification_proof_is_sent_to_the_server_but_not_session_recording() {+ let request = verification_request();+ let proof = UserVerificationProof {+ credential_id: "private-credential".to_string(),+ signature: "private-signature".to_string(),+ };+ let op = AppCommand::resolve_user_verification(+ "deployments".to_string(),+ request.id().clone(),+ UserVerificationResponse::Accept {+ proof: proof.clone(),+ },+ );+ assert_eq!(+ serde_json::to_value(&op).expect("recording payload"),+ serde_json::json!({+ "ResolveUserVerification": {+ "server_name": "deployments",+ "request_id": 7,+ "response": { "Accept": {} },+ },+ })+ );+ let mut pending = PendingAppServerRequests::default();+ pending.note_server_request(&request);+ let resolution = pending+ .take_resolution("unused", op)+ .expect("response should serialize")+ .expect("pending request");+ assert_eq!(+ resolution,+ AppServerRequestResolution {+ request_id: request.id().clone(),+ result: serde_json::json!({+ "action": "accept",+ "content": proof,+ "_meta": null,+ }),+ }+ );+}diff --git a/codex-rs/tui/src/app_command.rs b/codex-rs/tui/src/app_command.rsindex 82bc948942..500c2d5d8c 100644--- a/codex-rs/tui/src/app_command.rs+++ b/codex-rs/tui/src/app_command.rs@@ -9,6 +9,7 @@ use codex_app_server_protocol::RequestId as AppServerRequestId;use codex_app_server_protocol::ReviewTarget;use codex_app_server_protocol::ToolRequestUserInputResponse;use codex_app_server_protocol::UserInput;+use codex_app_server_protocol::UserVerificationProof;use codex_config::types::ApprovalsReviewer;use codex_protocol::ThreadId;use codex_protocol::approvals::GuardianAssessmentEvent;@@ -161,6 +162,12 @@ pub(crate) enum AppCommand {content: Option<Value>,meta: Option<Value>,},+ #[allow(dead_code)] // Connected by the following verification UI integration.+ ResolveUserVerification {+ server_name: String,+ request_id: AppServerRequestId,+ response: UserVerificationResponse,+ },UserInputAnswer {id: String,response: ToolRequestUserInputResponse,@@ -186,6 +193,18 @@ pub(crate) enum AppCommand {},}+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]+#[allow(dead_code)] // Connected by the following verification UI integration.+pub(crate) enum UserVerificationResponse {+ Accept {+ // AppCommand serialization is used by session recording, not the RPC wire response.+ // The controller serializes the assertion only into McpServerElicitationRequestResponse.+ #[serde(skip_serializing)]+ proof: UserVerificationProof,+ },+ Cancel,+}+impl AppCommand {pub(crate) fn interrupt() -> Self {Self::Interrupt@@ -294,6 +313,19 @@ impl AppCommand {}}+ #[allow(dead_code)] // Connected by the following verification UI integration.+ pub(crate) fn resolve_user_verification(+ server_name: String,+ request_id: AppServerRequestId,+ response: UserVerificationResponse,+ ) -> Self {+ Self::ResolveUserVerification {+ server_name,+ request_id,+ response,+ }+ }+pub(crate) fn user_input_answer(id: String, response: ToolRequestUserInputResponse) -> Self {Self::UserInputAnswer { id, response }}