Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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,
+ } = &params.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.rs
new file mode 100644
index 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.rs
index 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 }
}