fix(tui): handle legacy exec approvals compatibly

Treat legacy `ExecCommandApproval` requests as a compatibility path
regardless of transport so older request shapes continue to surface in the
existing exec approval UI instead of failing on session type.

Restore `active_thread_rx` before reinserting retained thread events and
use non-blocking refill logic so resolved-approval cleanup cannot deadlock
while the receiver is detached.

Author: fcoury

codex-rs/tui_app_server/src/app.rs

@@ -1660,13 +1660,35 @@ impl App {
             return;
         }
 
-        for event in retained_events {
-            if sender.send(event).await.is_err() {
-                self.clear_active_thread().await;
-                return;
+        self.active_thread_rx = Some(rx);
+
+        if retained_events.is_empty() {
+            return;
+        }
+
+        let mut pending_events = retained_events.into_iter();
+        while let Some(event) = pending_events.next() {
+            match sender.try_send(event) {
+                Ok(()) => {}
+                Err(TrySendError::Full(event)) => {
+                    let remaining_events: Vec<_> =
+                        std::iter::once(event).chain(pending_events).collect();
+                    tokio::spawn(async move {
+                        for event in remaining_events {
+                            if let Err(err) = sender.send(event).await {
+                                tracing::warn!("thread {thread_id} event channel closed: {err}");
+                                break;
+                            }
+                        }
+                    });
+                    return;
+                }
+                Err(TrySendError::Closed(_)) => {
+                    self.clear_active_thread().await;
+                    return;
+                }
             }
         }
-        self.active_thread_rx = Some(rx);
     }
 
     async fn active_turn_id_for_thread(&self, thread_id: ThreadId) -> Option<String> {

codex-rs/tui_app_server/src/app/app_server_adapter.rs

@@ -165,7 +165,7 @@ impl App {
         request: ServerRequest,
     ) {
         if self
-            .try_handle_legacy_remote_exec_approval_request(app_server_client, &request)
+            .try_handle_legacy_exec_approval_request(app_server_client, &request)
             .await
         {
             return;
@@ -211,14 +211,12 @@ impl App {
         }
     }
 
-    async fn try_handle_legacy_remote_exec_approval_request(
+    async fn try_handle_legacy_exec_approval_request(
         &mut self,
         app_server_client: &AppServerSession,
         request: &ServerRequest,
     ) -> bool {
-        if !app_server_client.is_remote()
-            || !matches!(request, ServerRequest::ExecCommandApproval { .. })
-        {
+        if !matches!(request, ServerRequest::ExecCommandApproval { .. }) {
             return false;
         }