Skip to main content

hyprstream_core/tui/
service.rs

1//! TuiService — ZMQ RPC service for the TUI multiplexer.
2//!
3//! Implements `RequestService` for the TUI display server. Manages sessions,
4//! windows, and panes via RPC. Frame publishing is handled separately
5//! by the frame loop task (not in the service struct).
6
7use std::collections::HashMap;
8use std::sync::atomic::{AtomicU32, Ordering};
9use std::sync::Arc;
10
11use anyhow::Result;
12use async_trait::async_trait;
13use capnp::message::Builder;
14use capnp::serialize;
15use ratatui::buffer::Cell;
16use tokio::sync::RwLock;
17use tokio_util::sync::CancellationToken;
18use tracing::{debug, info, warn};
19
20use hyprstream_rpc::moq_stream::{global_moq_origin, AnyStreamPublisher};
21use hyprstream_rpc::prelude::*;
22use hyprstream_rpc::streaming::{StreamChannel, StreamContext};
23use hyprstream_rpc::{Continuation, EnvelopeContext, RequestService};
24
25use super::diff;
26use super::state::{TuiEvent, TuiState};
27use super::vte_parser;
28use hyprstream_rpc_std::policy_client::PolicyClient;
29use hyprstream_rpc_std::tui_capnp;
30
31/// TUI service-to-service calls must carry the credential bound to the TUI
32/// signing key. A missing or blank attestation is a construction error, never
33/// a tokenless fallback that changes downstream admission semantics.
34pub(crate) fn required_service_token(signing_key: &SigningKey) -> Result<String> {
35    nonempty_service_token(crate::services::factories::service_token(signing_key))
36}
37
38fn nonempty_service_token(token: Option<String>) -> Result<String> {
39    token
40        .filter(|token| !token.trim().is_empty())
41        .ok_or_else(|| anyhow::anyhow!("TUI service credential is unavailable"))
42}
43
44pub(crate) fn production_model_client(
45    signing_key: SigningKey,
46) -> Result<hyprstream_rpc_std::model_client::ModelClient> {
47    let token = required_service_token(&signing_key)?;
48    hyprstream_rpc_std::model_client::ModelClient::from_provider(
49        &hyprstream_discovery::ProductionRpcClientProvider,
50        signing_key,
51        Some(token),
52    )
53}
54
55pub(crate) fn production_registry_client(
56    signing_key: SigningKey,
57) -> Result<hyprstream_rpc_std::registry_client::RegistryClient> {
58    let token = required_service_token(&signing_key)?;
59    hyprstream_rpc_std::registry_client::RegistryClient::from_provider(
60        &hyprstream_discovery::ProductionRpcClientProvider,
61        signing_key,
62        Some(token),
63    )
64}
65
66// ============================================================================
67// Display Mode
68// ============================================================================
69
70/// How a viewer wants frames encoded.
71#[derive(Debug, Clone, Copy, PartialEq, Eq)]
72pub enum DisplayMode {
73    Ansi,
74    Capnp,
75    Structured,
76}
77
78// ============================================================================
79// Viewer Management
80// ============================================================================
81
82/// A connected viewer's handle — tracks its publisher and health.
83///
84/// On the moq path `AnyStreamPublisher` wraps a `MoqStreamPublisher`.
85/// (`!Send`); viewer handles therefore live on the frame loop's local task
86/// (spawned via `spawn_local`).  On the moq path the publisher is `Send`, but
87/// `spawn_local` is kept for uniformity.
88struct ViewerHandle {
89    /// Viewer ID.
90    id: u32,
91    /// FD 1 (stdout): dedicated publisher for this viewer's frame stream.
92    publisher: AnyStreamPublisher,
93    /// FD 0 (stdin): publisher for relaying viewer input back to the CLI process.
94    /// Only populated when a session has a remote process that needs input relay.
95    stdin_publisher: Option<AnyStreamPublisher>,
96    /// How this viewer wants frames encoded.
97    display_mode: DisplayMode,
98    /// Consecutive frames that failed to send (HWM full).
99    consecutive_skips: u32,
100    /// Cancel token for this viewer.
101    cancel: CancellationToken,
102}
103
104// Viewer handles live on local tasks (not Send) — no type alias needed.
105
106/// Deferred viewer registration — sent from the RPC handler (Send) to the
107/// frame loop's local task (!Send) via a channel.
108pub(crate) struct PendingViewer {
109    id: u32,
110    #[allow(dead_code)]
111    session_id: u32,
112    display_mode: DisplayMode,
113    cancel: CancellationToken,
114    /// FD-indexed stream contexts: [0]=stdin (input relay), [1]=stdout (frames).
115    stream_ctxs: Vec<StreamContext>,
116}
117
118// We need PendingViewer to be Send so it can cross from the RPC thread
119// to the frame loop task. StreamContext is Send.
120// Safety: PendingViewer contains only Send types.
121
122/// Commands sent from RPC handlers to the frame loop.
123#[allow(dead_code)]
124pub(crate) enum FrameLoopCommand {
125    /// Register a new viewer.
126    RegisterViewer(PendingViewer),
127    /// Forward input bytes to the active pane.
128    SendInput { viewer_id: u32, data: Vec<u8> },
129    /// Evict a viewer by ID (disconnect).
130    EvictViewer { viewer_id: u32 },
131    /// Attach a process to a pane.
132    SpawnProcess {
133        pane_id: u32,
134        process: super::process::PaneProcess,
135    },
136    /// Notify the frame loop that a pane was resized.
137    Resize { pane_id: u32, cols: u16, rows: u16 },
138    /// Kill the process attached to a pane (called when window/pane is closed).
139    KillProcess { pane_id: u32 },
140    /// Mark a pane as private — frame loop forces a full redraw with [PRIVATE] placeholder.
141    MarkPanePrivate { pane_id: u32 },
142}
143
144/// Channel for sending commands to the frame loop.
145pub(crate) type CommandSender = tokio::sync::mpsc::UnboundedSender<FrameLoopCommand>;
146pub(crate) type CommandReceiver = tokio::sync::mpsc::UnboundedReceiver<FrameLoopCommand>;
147
148/// Registry of active sessions → their command channels + cancel tokens.
149/// This is Send+Sync because it only contains channel senders, not !Send sockets.
150type SessionRegistry = Arc<RwLock<HashMap<u32, (CommandSender, CancellationToken)>>>;
151
152/// Per-viewer stdin queues for the `pollStdin` RPC.
153///
154/// When a consumer viewer sends input (keyboard) and there is no local process
155/// attached, TuiService relays it to Capnp-mode producers via a ZMQ PUB stream.
156/// Simultaneously it enqueues the same data here so producers can poll via RPC
157/// instead of subscribing to the ZMQ stream — avoiding a second ZMQ context and
158/// the associated signaler assertion bugs.
159type StdinQueues = Arc<parking_lot::Mutex<HashMap<u32, std::collections::VecDeque<Vec<u8>>>>>;
160
161// ============================================================================
162// TuiService
163// ============================================================================
164
165/// The TUI multiplexer service.
166///
167/// Handles RPC requests for session/window/pane management.
168/// All mutable state is behind `Arc<RwLock<TuiState>>`, making this Send+Sync.
169/// Viewer/frame management is handled by separate local tasks (spawned via
170/// `spawn_local` in the continuation), keeping !Send types off the service struct.
171pub struct TuiService {
172    /// Shared TUI state (sessions, windows, panes).
173    state: Arc<RwLock<TuiState>>,
174    /// Next viewer ID counter (atomic for Send+Sync).
175    next_viewer_id: AtomicU32,
176    /// Transport config (required by RequestService).
177    transport: TransportConfig,
178    /// Signing key (required by RequestService).
179    signing_key: SigningKey,
180    /// Bound reach for streams served by this TUI instance.
181    reach_config: hyprstream_rpc::moq_stream::ProducerReachConfigHandle,
182    /// Optional relay-scoped MoQ origin for this TUI instance.
183    moq_origin: hyprstream_rpc::moq_stream::MoqStreamOriginHandle,
184    /// Per-session viewer registration channels + frame loop tokens.
185    sessions: SessionRegistry,
186    /// Per-viewer stdin queues (for pollStdin RPC).
187    stdin_queues: StdinQueues,
188    /// Optional policy client for authorization checks.
189    policy_client: Option<PolicyClient>,
190    /// Expected audience (resource URL) for JWT validation.
191    expected_audience: Option<String>,
192    /// JWT key source for verifying tokens (local and federated).
193    jwt_key_source: Option<std::sync::Arc<dyn hyprstream_rpc::auth::JwtKeySource>>,
194    /// Shared VFS namespace for ChatApps spawned via RPC.
195    vfs_ns: Option<std::sync::Arc<hyprstream_vfs::Namespace>>,
196    /// VFS subject identity for ChatApps spawned via RPC.
197    vfs_subject: Option<hyprstream_rpc::Subject>,
198    /// Lazily-spawned VFS proxy sender (shared across all ChatApps).
199    /// Initialized on first ChatApp spawn within the service's async context.
200    vfs_proxy_tx: std::sync::OnceLock<tokio::sync::mpsc::Sender<hyprstream_vfs::proxy::VfsRequest>>,
201    /// Configured Federate TUI client-class id for the W1.3 consumer gate.
202    /// `None` = the class is unconfigured: any credential carrying TUI
203    /// federate markers is denied (default-deny, the W1.1 invariant). Also
204    /// serves as the marker-independent class pin: a credential whose
205    /// (iss, client_id) names the configured class is gated even with every
206    /// TUI marker stripped.
207    federate_tui_client: Option<String>,
208}
209
210impl TuiService {
211    /// Create a new TUI service.
212    pub fn new(
213        state: Arc<RwLock<TuiState>>,
214        transport: TransportConfig,
215        signing_key: SigningKey,
216    ) -> Self {
217        Self {
218            state,
219            next_viewer_id: AtomicU32::new(1),
220            transport,
221            signing_key,
222            reach_config: Arc::new(parking_lot::RwLock::new(
223                hyprstream_rpc::moq_stream::ProducerReachConfig::default(),
224            )),
225            moq_origin: Arc::new(parking_lot::RwLock::new(None)),
226            sessions: Arc::new(RwLock::new(HashMap::new())),
227            stdin_queues: Arc::new(parking_lot::Mutex::new(HashMap::new())),
228            policy_client: None,
229            expected_audience: None,
230            jwt_key_source: None,
231            vfs_ns: None,
232            vfs_subject: None,
233            vfs_proxy_tx: std::sync::OnceLock::new(),
234            federate_tui_client: None,
235        }
236    }
237
238    /// Attach a PolicyClient for Casbin authorization.
239    pub fn with_policy_client(mut self, client: PolicyClient) -> Self {
240        self.policy_client = Some(client);
241        self
242    }
243
244    /// Set the expected audience (resource URL) for JWT validation.
245    pub fn with_expected_audience(mut self, audience: String) -> Self {
246        self.expected_audience = Some(audience);
247        self
248    }
249
250    /// Set the JWT key source for verifying tokens.
251    pub fn with_jwt_key_source(
252        mut self,
253        src: std::sync::Arc<dyn hyprstream_rpc::auth::JwtKeySource>,
254    ) -> Self {
255        self.jwt_key_source = Some(src);
256        self
257    }
258
259    /// Configure the Federate TUI client class this service consumes (W1.3).
260    /// `None` keeps the gate fail-closed for TUI-markered credentials.
261    pub fn with_federate_tui_client(mut self, client: Option<String>) -> Self {
262        self.federate_tui_client = client;
263        self
264    }
265
266    /// Whether a credential is TUI-CLASSIFIED at this service: it carries
267    /// any TUI federate marker, or its (iss, client_id) equals this
268    /// service's audience and the authority-owned class pin — the configured
269    /// TUI client id from this service's wiring OR the process-global
270    /// reservation installed from the deployment config at startup. The pin
271    /// mirrors the www reserved (iss, client_id) predicate, so a
272    /// class-shaped credential with every marker stripped still cannot fall
273    /// through to generic handling — including on a TuiService instance the
274    /// class was not wired into (the gate then denies: no configured class
275    /// to verify against).
276    fn is_federate_tui_classified(&self, claims: &hyprstream_rpc::auth::Claims) -> bool {
277        claims.has_federate_tui_profile_marker()
278            || (self.expected_audience.as_deref() == Some(claims.iss.as_str())
279                && claims.client_id.as_deref().is_some_and(|id| {
280                    Some(id) == self.federate_tui_client.as_deref()
281                        || Some(id) == hyprstream_rpc::auth::federate_tui_class_client()
282                }))
283    }
284
285    /// W1.3 consumer gate: admit a TUI-class federate credential for exactly
286    /// the operation class requested. The credential must verify against the
287    /// exact configured class — complete TUI marker set, no www markers,
288    /// `tui`-resource scopes only, holder-binding shape — and carry the
289    /// scope this operation needs. Fail-closed when the class is not
290    /// configured on this service. The holder's cnf.jwk binding to the
291    /// envelope signer was already enforced by the RPC layer (svc.rs R2).
292    #[cfg(feature = "postgres")]
293    fn admit_federate_tui(
294        &self,
295        claims: &hyprstream_rpc::auth::Claims,
296        required_scope: &str,
297    ) -> Result<()> {
298        let client = self.federate_tui_client.as_deref().ok_or_else(|| {
299            anyhow::anyhow!("Federate TUI client class is not configured on this service")
300        })?;
301        let audience = self.expected_audience.as_deref().ok_or_else(|| {
302            anyhow::anyhow!("no expected audience for Federate TUI credential verification")
303        })?;
304        let host = crate::services::oauth::federate_source::FederateHost::new(audience)
305            .map_err(|_| anyhow::anyhow!("service audience is not a Federate host"))?;
306        let facts = crate::services::oauth::federate_proof::verify_tui_credential_claims(
307            claims, &host, client,
308        )
309        .map_err(|_| anyhow::anyhow!("Federate TUI credential profile rejected"))?;
310        anyhow::ensure!(
311            facts.scopes.iter().any(|scope| scope == required_scope),
312            "Federate TUI credential lacks the scope this operation requires"
313        );
314        Ok(())
315    }
316
317    /// Attach a VFS namespace so ChatApps spawned via RPC have VFS access.
318    ///
319    /// The VFS proxy task is spawned lazily on the first ChatApp spawn,
320    /// on the service's own tokio runtime (inside the LocalSet).
321    pub fn with_vfs(
322        mut self,
323        ns: std::sync::Arc<hyprstream_vfs::Namespace>,
324        subject: hyprstream_rpc::Subject,
325    ) -> Self {
326        self.vfs_ns = Some(ns);
327        self.vfs_subject = Some(subject);
328        self
329    }
330
331    /// Test-only observation point for the W1.3 consumer dispatch fixture
332    /// (the fixture itself is postgres-gated, so this accessor is too).
333    #[cfg(all(test, feature = "postgres"))]
334    pub(crate) async fn test_session_count(&self) -> usize {
335        self.state.read().await.sessions.len()
336    }
337
338    /// Get the VFS proxy sender, spawning a dedicated proxy thread on first call.
339    fn vfs_proxy(&self) -> Option<&tokio::sync::mpsc::Sender<hyprstream_vfs::proxy::VfsRequest>> {
340        let (ns, subject) = match (&self.vfs_ns, &self.vfs_subject) {
341            (Some(ns), Some(subject)) => (ns, subject),
342            _ => return None,
343        };
344        Some(self.vfs_proxy_tx.get_or_init(|| {
345            super::vfs::spawn_dedicated_vfs_proxy(std::sync::Arc::clone(ns), subject.clone())
346        }))
347    }
348
349    /// Check authorization via PolicyClient.
350    ///
351    /// All callers are authorized via Casbin: system (node key) gets full access,
352    /// external callers require explicit policy grants.
353    async fn authorize(
354        &self,
355        ctx: &EnvelopeContext,
356        resource: &str,
357        operation: &str,
358    ) -> Result<()> {
359        let subject = ctx.subject().to_string();
360        let domain = ctx.domain()?;
361        let policy_client = self
362            .policy_client
363            .as_ref()
364            .ok_or_else(|| anyhow::anyhow!("Authorization denied: no policy client configured"))?;
365        let request = hyprstream_rpc_std::policy_client::PolicyCheck {
366            subject: subject.clone(),
367            domain,
368            resource: resource.to_owned(),
369            operation: operation.to_owned(),
370        };
371        let allowed = crate::services::policy::check_with_holder_evidence(
372            policy_client,
373            &request,
374            ctx.jwt_token(),
375            &ctx.subject(),
376            ctx.original_holder_evidence(),
377        )
378        .await
379        .unwrap_or_else(|e| {
380            warn!("TUI policy check failed for {}: {}", subject, e);
381            false
382        });
383        if !allowed {
384            anyhow::bail!(
385                "Unauthorized: {} cannot {} on {}",
386                subject,
387                operation,
388                resource
389            );
390        }
391        Ok(())
392    }
393
394    /// Handle a connect request.
395    ///
396    /// Creates a DH-derived stream context and sends the viewer registration
397    /// to the frame loop via a channel. The frame loop creates the !Send
398    /// publisher socket on its local task.
399    async fn handle_connect(
400        &self,
401        request_id: u64,
402        session_id: u32,
403        display_mode: DisplayMode,
404        cols: u16,
405        rows: u16,
406        ctx: &EnvelopeContext,
407    ) -> Result<(Vec<u8>, Option<Continuation>)> {
408        let mut state = self.state.write().await;
409
410        // Create or find session
411        let subject = ctx.subject().to_string();
412        let sid = if session_id == 0 {
413            if state.sessions.is_empty() {
414                let new_sid = state.create_session();
415                // Record the connecting client as session owner
416                if let Some(session) = state.session_mut(new_sid) {
417                    session.owner = subject.clone();
418                }
419                new_sid
420            } else {
421                state.sessions.last().map(|s| s.id).unwrap_or(1)
422            }
423        } else {
424            if state.session(session_id).is_none() {
425                return Ok((
426                    self.build_error_response(request_id, "session not found", "NOT_FOUND")?,
427                    None,
428                ));
429            }
430            session_id
431        };
432
433        // Track pane resize: if a pane was resized, notify its process via the
434        // frame loop after registration so attached ChatApp/shell gets the new size.
435        let mut resized_pane: Option<u32> = None;
436        if cols > 0 && rows > 0 {
437            state.default_cols = cols;
438            state.default_rows = rows;
439            // Resize active pane to viewer's size (tmux: last-attached wins)
440            if let Some(session) = state.session_mut(sid) {
441                if let Some(window) = session.active_window_mut() {
442                    if let Some(pane) = window.active_pane_mut() {
443                        let (cur_cols, cur_rows) = pane.size();
444                        if cur_cols != cols || cur_rows != rows {
445                            pane.resize(cols, rows);
446                            resized_pane = Some(pane.id);
447                        }
448                    }
449                }
450            }
451        }
452
453        let viewer_id = self.next_viewer_id.fetch_add(1, Ordering::Relaxed);
454
455        let session = match state.session(sid) {
456            Some(s) => s,
457            None => {
458                return Ok((
459                    self.build_error_response(request_id, "session not found", "NOT_FOUND")?,
460                    None,
461                ))
462            }
463        };
464        use crate::tui::state::PaneBackend;
465        let windows: Vec<_> = session
466            .windows
467            .iter()
468            .map(|w| {
469                (
470                    w.id,
471                    w.name.clone(),
472                    w.panes
473                        .iter()
474                        .map(|p| (p.id, p.size(), p.backend == PaneBackend::Private))
475                        .collect::<Vec<_>>(),
476                    w.active_pane_id,
477                )
478            })
479            .collect();
480
481        drop(state);
482
483        // Create FD-indexed stream contexts: [0]=stdin (input relay), [1]=stdout (frames).
484        // DH key exchange derives context from client's ephemeral pubkey.
485        // If no pubkey (local/test connections), generate random standalone contexts.
486        let reach_config = self.reach_config.read().clone();
487        let make_stream_ctx = |label: &str| -> Result<StreamContext> {
488            // #321: the TUI PTY/shell viewer receives only `(mac_key, topic)` out of
489            // band (see tui_handlers / shell_handlers) and never derives the DH
490            // `enc_key`, so transport AEAD is disabled for these same-host streams.
491            // The blocks remain HMAC-chain authenticated. (AEAD stays mandatory + ON
492            // for the DH-keyed mesh inference stream, whose consumer derives enc_key.)
493            match ctx.ephemeral_pubkey() {
494                Some(pubkey) => Ok(StreamContext::from_third_party_interop_dh(&pubkey)?
495                    .without_aead()
496                    .with_reach_config(reach_config.clone())),
497                None => {
498                    use rand::RngCore;
499                    let mut rng = rand::thread_rng();
500                    let mut topic_bytes = [0u8; 32];
501                    let mut mac_key = [0u8; 32];
502                    rng.fill_bytes(&mut topic_bytes);
503                    rng.fill_bytes(&mut mac_key);
504                    Ok(StreamContext::new(
505                        format!("tui-{}-{}", label, viewer_id),
506                        hex::encode(topic_bytes),
507                        mac_key,
508                        [0u8; 32],
509                    )
510                    .with_reach_config(reach_config.clone()))
511                }
512            }
513        };
514
515        let stdin_ctx = make_stream_ctx("stdin")?;
516        let stdout_ctx = make_stream_ctx("stdout")?;
517
518        // Build the moq broadcast paths when moq is active. The same-host UDS
519        // path is NOT advertised (#356): co-located viewers resolve it from LOCAL
520        // config, and cross-process viewers dial the networked reach instead.
521        let stdin_moq_path = global_moq_origin()
522            .map(|o| o.broadcast_path(stdin_ctx.topic()))
523            .unwrap_or_default();
524        let stdout_moq_path = global_moq_origin()
525            .map(|o| o.broadcast_path(stdout_ctx.topic()))
526            .unwrap_or_default();
527
528        // (topic, mac_key, broadcast_path)
529        let streams: [(&str, &[u8; 32], &str); 2] = [
530            (stdin_ctx.topic(), stdin_ctx.mac_key(), &stdin_moq_path),
531            (stdout_ctx.topic(), stdout_ctx.mac_key(), &stdout_moq_path),
532        ];
533
534        let response =
535            self.build_connect_response(request_id, viewer_id, sid, &windows, &streams)?;
536
537        let viewer_cancel = CancellationToken::new();
538        let pending = PendingViewer {
539            id: viewer_id,
540            session_id: sid,
541            display_mode,
542            cancel: viewer_cancel,
543            stream_ctxs: vec![stdin_ctx, stdout_ctx],
544        };
545
546        // Build continuation: send viewer registration to frame loop
547        let sessions_reg = Arc::clone(&self.sessions);
548        let tui_state = Arc::clone(&self.state);
549        let sk = self.signing_key.clone();
550        let stdin_queues = Arc::clone(&self.stdin_queues);
551        let reach_config = self.reach_config.clone();
552        let moq_origin = self.moq_origin.clone();
553        let continuation: Continuation = Box::pin(async move {
554            let mut reg = sessions_reg.write().await;
555            let (sender, _cancel) = reg.entry(sid).or_insert_with(|| {
556                let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<FrameLoopCommand>();
557                let cancel = CancellationToken::new();
558                // Spawn frame loop for this session
559                let s = Arc::clone(&tui_state);
560                let c = cancel.clone();
561                let sq = Arc::clone(&stdin_queues);
562                tokio::task::spawn_local(run_frame_loop(
563                    s,
564                    sid,
565                    rx,
566                    sk,
567                    c,
568                    sq,
569                    reach_config,
570                    moq_origin,
571                ));
572                info!(session_id = sid, "Frame loop spawned");
573                (tx, cancel)
574            });
575            if let Err(e) = sender.send(FrameLoopCommand::RegisterViewer(pending)) {
576                warn!(viewer_id, "Failed to register viewer: {}", e);
577            } else {
578                debug!(viewer_id, session_id = sid, "Viewer registration sent");
579            }
580            // If the pane was resized, notify the attached process so it redraws
581            // at the new terminal size (e.g. ChatApp spawned before viewer connected).
582            if let Some(pane_id) = resized_pane {
583                let _ = sender.send(FrameLoopCommand::Resize {
584                    pane_id,
585                    cols,
586                    rows,
587                });
588            }
589        });
590
591        Ok((response, Some(continuation)))
592    }
593
594    async fn handle_create_window(&self, request_id: u64) -> Result<Vec<u8>> {
595        use crate::tui::state::PaneBackend;
596        let mut state = self.state.write().await;
597        let session = state.sessions.last().map(|s| s.id);
598        if let Some(sid) = session {
599            if let Some(wid) = state.create_window(sid) {
600                let window = match state.session(sid).and_then(|s| s.window(wid)) {
601                    Some(w) => w,
602                    None => {
603                        return self.build_error_response(
604                            request_id,
605                            "window not found",
606                            "NOT_FOUND",
607                        )
608                    }
609                };
610                let panes: Vec<_> = window
611                    .panes
612                    .iter()
613                    .map(|p| {
614                        (
615                            p.id,
616                            p.size(),
617                            p.title.clone(),
618                            p.backend == PaneBackend::Private,
619                        )
620                    })
621                    .collect();
622                return self.build_window_response(request_id, window.id, &window.name, &panes);
623            }
624        }
625        self.build_error_response(request_id, "no active session", "NO_SESSION")
626    }
627
628    async fn handle_snapshot(&self, request_id: u64, session_id: u32) -> Result<Vec<u8>> {
629        let state = self.state.read().await;
630        let sid = if session_id == 0 {
631            state.sessions.last().map(|s| s.id).unwrap_or(0)
632        } else {
633            session_id
634        };
635
636        if let Some(session) = state.session(sid) {
637            let generation = state.generation();
638            let active_window_id = session.active_window_id;
639            let windows: Vec<_> = session
640                .windows
641                .iter()
642                .map(|w| {
643                    let panes: Vec<_> = w
644                        .panes
645                        .iter()
646                        .map(|p| (p.id, p.size(), p.title.clone()))
647                        .collect();
648                    (w.id, w.name.clone(), panes, w.active_pane_id)
649                })
650                .collect();
651
652            if let Some(window) = session.active_window() {
653                if let Some(pane) = window.active_pane() {
654                    let buf = pane.active_buffer();
655                    let frame_diff = diff::compute_diff(buf, None, generation, pane.cursor);
656                    return self.build_snapshot_response(
657                        request_id,
658                        sid,
659                        generation,
660                        active_window_id,
661                        &frame_diff,
662                        &windows,
663                    );
664                }
665            }
666        }
667
668        self.build_error_response(request_id, "session not found", "NOT_FOUND")
669    }
670
671    async fn handle_list_windows(&self, request_id: u64, session_id: u32) -> Result<Vec<u8>> {
672        let state = self.state.read().await;
673        let sid = if session_id == 0 {
674            state.sessions.last().map(|s| s.id).unwrap_or(0)
675        } else {
676            session_id
677        };
678
679        if let Some(session) = state.session(sid) {
680            use crate::tui::state::PaneBackend;
681            let windows: Vec<_> = session
682                .windows
683                .iter()
684                .map(|w| {
685                    let panes: Vec<_> = w
686                        .panes
687                        .iter()
688                        .map(|p| {
689                            (
690                                p.id,
691                                p.size(),
692                                p.title.clone(),
693                                p.backend == PaneBackend::Private,
694                            )
695                        })
696                        .collect();
697                    (w.id, w.name.clone(), panes, w.active_pane_id)
698                })
699                .collect();
700
701            let mut msg = Builder::new_default();
702            {
703                let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
704                resp.set_request_id(request_id);
705                let wl = resp.init_list_windows_result();
706                let mut win_list = wl.init_windows(windows.len() as u32);
707                for (i, (wid, name, panes, active_pane)) in windows.iter().enumerate() {
708                    let mut w = win_list.reborrow().get(i as u32);
709                    w.set_id(*wid);
710                    w.set_name(name);
711                    w.set_active_pane_id(*active_pane);
712                    let mut pane_list = w.init_panes(panes.len() as u32);
713                    for (j, (pid, (cols, rows), title, is_private)) in panes.iter().enumerate() {
714                        let mut p = pane_list.reborrow().get(j as u32);
715                        p.set_id(*pid);
716                        p.set_cols(*cols);
717                        p.set_rows(*rows);
718                        p.set_title(title);
719                        p.set_is_private(*is_private);
720                    }
721                }
722            }
723            let mut buf = Vec::new();
724            serialize::write_message(&mut buf, &msg)?;
725            Ok(buf)
726        } else {
727            self.build_error_response(request_id, "session not found", "NOT_FOUND")
728        }
729    }
730
731    async fn handle_disconnect(&self, request_id: u64, viewer_id: u32) -> Result<Vec<u8>> {
732        // Send eviction command to all session frame loops
733        let sessions = self.sessions.read().await;
734        for (sender, _) in sessions.values() {
735            let _ = sender.send(FrameLoopCommand::EvictViewer { viewer_id });
736        }
737        drop(sessions);
738
739        let mut msg = Builder::new_default();
740        {
741            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
742            resp.set_request_id(request_id);
743            resp.set_disconnect_result(());
744        }
745        let mut buf = Vec::new();
746        serialize::write_message(&mut buf, &msg)?;
747        Ok(buf)
748    }
749
750    async fn handle_send_input(
751        &self,
752        request_id: u64,
753        viewer_id: u32,
754        data: &[u8],
755    ) -> Result<Vec<u8>> {
756        // Send input to the frame loop for the viewer's session
757        let sessions = self.sessions.read().await;
758        for (sender, _) in sessions.values() {
759            let _ = sender.send(FrameLoopCommand::SendInput {
760                viewer_id,
761                data: data.to_vec(),
762            });
763        }
764        drop(sessions);
765
766        let mut msg = Builder::new_default();
767        {
768            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
769            resp.set_request_id(request_id);
770            resp.set_send_input_result(());
771        }
772        let mut buf = Vec::new();
773        serialize::write_message(&mut buf, &msg)?;
774        Ok(buf)
775    }
776
777    async fn handle_close_window(&self, request_id: u64, window_id: u32) -> Result<Vec<u8>> {
778        let (sid, pane_ids, ok) = {
779            let mut state = self.state.write().await;
780            let sid = state.sessions.last().map(|s| s.id).unwrap_or(0);
781            // Collect pane IDs before removing the window from state.
782            let pane_ids: Vec<u32> = state
783                .session(sid)
784                .and_then(|sess| sess.window(window_id))
785                .map(|w| w.panes.iter().map(|p| p.id).collect())
786                .unwrap_or_default();
787            let ok = state.close_window(sid, window_id);
788            (sid, pane_ids, ok)
789        };
790
791        if ok {
792            let reg = self.sessions.read().await;
793            if let Some((sender, _)) = reg.get(&sid) {
794                for pane_id in pane_ids {
795                    let _ = sender.send(FrameLoopCommand::KillProcess { pane_id });
796                }
797            }
798            let mut msg = Builder::new_default();
799            {
800                let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
801                resp.set_request_id(request_id);
802                resp.set_close_window_result(());
803            }
804            let mut buf = Vec::new();
805            serialize::write_message(&mut buf, &msg)?;
806            Ok(buf)
807        } else {
808            self.build_error_response(request_id, "window not found", "NOT_FOUND")
809        }
810    }
811
812    async fn handle_focus_window(&self, request_id: u64, window_id: u32) -> Result<Vec<u8>> {
813        let mut state = self.state.write().await;
814        let sid = state.sessions.last().map(|s| s.id).unwrap_or(0);
815        if state.focus_window(sid, window_id) {
816            let mut msg = Builder::new_default();
817            {
818                let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
819                resp.set_request_id(request_id);
820                resp.set_focus_window_result(());
821            }
822            let mut buf = Vec::new();
823            serialize::write_message(&mut buf, &msg)?;
824            Ok(buf)
825        } else {
826            self.build_error_response(request_id, "window not found", "NOT_FOUND")
827        }
828    }
829
830    async fn handle_split_pane(
831        &self,
832        request_id: u64,
833        horizontal: bool,
834        ratio: f32,
835    ) -> Result<Vec<u8>> {
836        let mut state = self.state.write().await;
837        let sid = state.sessions.last().map(|s| s.id).unwrap_or(0);
838        let ratio = if ratio <= 0.0 || ratio >= 1.0 {
839            0.5
840        } else {
841            ratio
842        };
843
844        if let Some((pane_id, cols, rows)) = state.split_pane(sid, horizontal, ratio) {
845            let mut msg = Builder::new_default();
846            {
847                let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
848                resp.set_request_id(request_id);
849                let mut pane_info = resp.init_split_pane_result();
850                pane_info.set_id(pane_id);
851                pane_info.set_cols(cols);
852                pane_info.set_rows(rows);
853                pane_info.set_title("");
854            }
855            let mut buf = Vec::new();
856            serialize::write_message(&mut buf, &msg)?;
857            Ok(buf)
858        } else {
859            self.build_error_response(request_id, "no active session or window", "NO_SESSION")
860        }
861    }
862
863    async fn handle_close_pane(&self, request_id: u64, pane_id: u32) -> Result<Vec<u8>> {
864        let mut state = self.state.write().await;
865        let sid = state.sessions.last().map(|s| s.id).unwrap_or(0);
866        if state.close_pane(sid, pane_id) {
867            let mut msg = Builder::new_default();
868            {
869                let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
870                resp.set_request_id(request_id);
871                resp.set_close_pane_result(());
872            }
873            let mut buf = Vec::new();
874            serialize::write_message(&mut buf, &msg)?;
875            Ok(buf)
876        } else {
877            self.build_error_response(
878                request_id,
879                "pane not found or is the last pane",
880                "NOT_FOUND",
881            )
882        }
883    }
884
885    async fn handle_focus_pane(&self, request_id: u64, pane_id: u32) -> Result<Vec<u8>> {
886        let mut state = self.state.write().await;
887        let sid = state.sessions.last().map(|s| s.id).unwrap_or(0);
888        if state.focus_pane(sid, pane_id) {
889            let mut msg = Builder::new_default();
890            {
891                let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
892                resp.set_request_id(request_id);
893                resp.set_focus_pane_result(());
894            }
895            let mut buf = Vec::new();
896            serialize::write_message(&mut buf, &msg)?;
897            Ok(buf)
898        } else {
899            self.build_error_response(request_id, "pane not found", "NOT_FOUND")
900        }
901    }
902
903    async fn handle_spawn_shell(
904        &self,
905        request_id: u64,
906        session_id: u32,
907        pane_id: u32,
908        cwd: &str,
909    ) -> Result<(Vec<u8>, Option<Continuation>)> {
910        // Resolve session ID and get pane dimensions
911        let (sid, cols, rows) = {
912            let state = self.state.read().await;
913            let sid = if session_id == 0 {
914                state.sessions.last().map(|s| s.id).unwrap_or(1)
915            } else {
916                session_id
917            };
918            let (cols, rows) = state
919                .session(sid)
920                .and_then(|s| {
921                    s.windows
922                        .iter()
923                        .flat_map(|w| w.panes.iter())
924                        .find(|p| p.id == pane_id)
925                })
926                .map(super::state::TuiPane::size)
927                .unwrap_or((80, 24));
928            (sid, cols, rows)
929        };
930
931        let cwd_path = if cwd.is_empty() {
932            None
933        } else {
934            Some(std::path::PathBuf::from(cwd))
935        };
936
937        let process = match super::process::spawn_pty_process(cwd_path, cols, rows) {
938            Ok(p) => p,
939            Err(e) => {
940                return Ok((
941                    self.build_error_response(
942                        request_id,
943                        &format!("Failed to spawn shell: {e}"),
944                        "SPAWN_FAILED",
945                    )?,
946                    None,
947                ));
948            }
949        };
950
951        // Rename the window to "Shell" so the titlebar shows something meaningful.
952        {
953            let mut state = self.state.write().await;
954            if let Some(sess) = state.session_mut(sid) {
955                for win in &mut sess.windows {
956                    if win.panes.iter().any(|p| p.id == pane_id) {
957                        win.name = "Shell".to_owned();
958                        break;
959                    }
960                }
961            }
962        }
963
964        // Send SpawnProcess command to the session's frame loop
965        let sessions_reg = Arc::clone(&self.sessions);
966        let continuation: Continuation = Box::pin(async move {
967            let reg = sessions_reg.read().await;
968            if let Some((sender, _)) = reg.get(&sid) {
969                let _ = sender.send(FrameLoopCommand::SpawnProcess { pane_id, process });
970            }
971        });
972
973        let mut msg = capnp::message::Builder::new_default();
974        {
975            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
976            resp.set_request_id(request_id);
977            let mut result = resp.init_spawn_shell_result();
978            result.set_success(true);
979            result.set_pid(0);
980        }
981        let mut buf = Vec::new();
982        serialize::write_message(&mut buf, &msg)?;
983        Ok((buf, Some(continuation)))
984    }
985
986    /// Drain all stdin bytes queued for `viewer_id` and return them concatenated.
987    ///
988    /// Called by Capnp-mode producers (`hyprstream tui shell`) instead of
989    /// subscribing to the ZMQ PUB stdin relay stream.  Avoids the second ZMQ
990    /// context and the libzmq signaler assertion that fires on some builds.
991    async fn handle_poll_stdin(&self, request_id: u64, viewer_id: u32) -> Result<Vec<u8>> {
992        let all_data: Vec<u8> = {
993            let mut queues = self.stdin_queues.lock();
994            if let Some(queue) = queues.get_mut(&viewer_id) {
995                let mut buf = Vec::new();
996                while let Some(chunk) = queue.pop_front() {
997                    buf.extend_from_slice(&chunk);
998                }
999                buf
1000            } else {
1001                Vec::new()
1002            }
1003        };
1004
1005        let mut msg = capnp::message::Builder::new_default();
1006        {
1007            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
1008            resp.set_request_id(request_id);
1009            resp.set_poll_stdin_result(&all_data);
1010        }
1011        let mut buf = Vec::new();
1012        serialize::write_message(&mut buf, &msg)?;
1013        Ok(buf)
1014    }
1015
1016    /// Spawn `ShellApp` as a `PaneProcess` inside TuiService.
1017    ///
1018    /// This is the server-side counterpart to `hyprstream tui shell`.  The
1019    /// client calls this RPC and then simply waits for SIGTERM — no
1020    /// fork-after-ZMQ ever occurs in the client process.
1021    async fn handle_spawn_chrome_shell(
1022        &self,
1023        request_id: u64,
1024        session_id: u32,
1025        registry_dir: &str,
1026        cols: u16,
1027        rows: u16,
1028        pane_id: u32,
1029    ) -> Result<(Vec<u8>, Option<Continuation>)> {
1030        let (sid, active_pane_id) = {
1031            let state = self.state.read().await;
1032            let sid = if session_id == 0 {
1033                state.sessions.last().map(|s| s.id).unwrap_or(1)
1034            } else {
1035                session_id
1036            };
1037            let active_pane_id = if pane_id != 0 {
1038                pane_id
1039            } else {
1040                use crate::tui::state::PaneBackend;
1041                state
1042                    .session(sid)
1043                    .and_then(|s| s.active_window())
1044                    .and_then(|w| {
1045                        // Prefer the active pane if it's not private; otherwise
1046                        // fall back to the first non-private pane in the window.
1047                        let ap = w.active_pane();
1048                        if ap
1049                            .map(|p| p.backend != PaneBackend::Private)
1050                            .unwrap_or(false)
1051                        {
1052                            ap.map(|p| p.id)
1053                        } else {
1054                            w.panes
1055                                .iter()
1056                                .find(|p| p.backend != PaneBackend::Private)
1057                                .map(|p| p.id)
1058                        }
1059                    })
1060                    .unwrap_or(1)
1061            };
1062            (sid, active_pane_id)
1063        };
1064
1065        let registry_models_dir = std::path::PathBuf::from(registry_dir);
1066
1067        let models = {
1068            let registry_client = production_registry_client(self.signing_key.clone())?;
1069            let model_client_for_status = production_model_client(self.signing_key.clone())?;
1070            let status_timeout = std::time::Duration::from_millis(500);
1071            let all_status_req = hyprstream_rpc_std::model_client::StatusRequest {
1072                model_ref: String::new(),
1073            };
1074            let (repos_result, status_result) = tokio::join!(
1075                registry_client.list(),
1076                tokio::time::timeout(
1077                    status_timeout,
1078                    model_client_for_status.status(&all_status_req)
1079                ),
1080            );
1081            let status_map: std::collections::HashMap<String, bool> = match status_result {
1082                Ok(Ok(entries)) => entries
1083                    .into_iter()
1084                    // Only mark as loaded when the model is fully ready.
1085                    // "loading" means GPU load is still in progress.
1086                    .map(|e| (e.model_ref, e.status == "loaded"))
1087                    .collect(),
1088                _ => std::collections::HashMap::new(),
1089            };
1090            match repos_result {
1091                Ok(repos) => repos
1092                    .into_iter()
1093                    .filter(|r| !r.name.is_empty())
1094                    .flat_map(|r| {
1095                        let name = r.name.clone();
1096                        let rmd = registry_models_dir.clone();
1097                        r.worktrees
1098                            .into_iter()
1099                            .map(|wt| {
1100                                let branch = if wt.branch_name.is_empty() {
1101                                    "main".to_owned()
1102                                } else {
1103                                    wt.branch_name
1104                                };
1105                                let model_ref = format!("{}:{}", name, branch);
1106                                let loaded = *status_map.get(&model_ref).unwrap_or(&false);
1107                                let path = rmd.join(&name).join("worktrees").join(&branch);
1108                                hyprstream_tui::shell_app::ModelEntry {
1109                                    model_ref,
1110                                    path,
1111                                    loaded,
1112                                    ahead: 0,
1113                                    behind: 0,
1114                                    is_dirty: false,
1115                                }
1116                            })
1117                            .collect::<Vec<_>>()
1118                    })
1119                    .collect::<Vec<_>>(),
1120                Err(_) => vec![],
1121            }
1122        };
1123
1124        let handle = tokio::runtime::Handle::current();
1125        let sk_load = self.signing_key.clone();
1126        let handle_load = handle.clone();
1127        let load_fn: Box<dyn Fn(&str, hyprstream_tui::shell_app::ModelStatusSender) + Send> =
1128            Box::new(
1129                move |model_ref: &str, tx: hyprstream_tui::shell_app::ModelStatusSender| {
1130                    let sk = sk_load.clone();
1131                    let mr = model_ref.to_owned();
1132                    let h = handle_load.clone();
1133                    // Submit load — returns "accepted" immediately (Continuation pattern).
1134                    h.block_on(async {
1135                        let client = match production_model_client(sk.clone()) {
1136                            Ok(c) => c,
1137                            Err(e) => {
1138                                tracing::warn!("Failed to create ModelClient: {e}");
1139                                return;
1140                            }
1141                        };
1142                        let _ = client
1143                            .load(&hyprstream_rpc_std::model_client::LoadModelRequest {
1144                                model_ref: mr.clone(),
1145                                max_context: None,
1146                                kv_quant: None,
1147                            })
1148                            .await;
1149                    });
1150                    // Poll status in a background thread so we don't block the ShellApp.
1151                    let sk_poll = sk.clone();
1152                    let mr_poll = mr.clone();
1153                    let h_poll = h.clone();
1154                    std::thread::spawn(move || {
1155                        for _ in 0..60u32 {
1156                            // max ~2 minutes (60 × 2 s)
1157                            std::thread::sleep(std::time::Duration::from_secs(2));
1158                            let loaded = h_poll.block_on(async {
1159                                let client = match production_model_client(sk_poll.clone()) {
1160                                    Ok(c) => c,
1161                                    Err(e) => {
1162                                        tracing::warn!("Failed to create ModelClient: {e}");
1163                                        return false;
1164                                    }
1165                                };
1166                                client
1167                                    .status(&hyprstream_rpc_std::model_client::StatusRequest {
1168                                        model_ref: mr_poll.clone(),
1169                                    })
1170                                    .await
1171                                    .is_ok_and(|es| es.iter().any(|e| e.status == "loaded"))
1172                            });
1173                            if loaded {
1174                                let _ = tx.send((mr_poll, true));
1175                                return;
1176                            }
1177                        }
1178                        // Timed out — clear the "Loading…" indicator.
1179                        let _ = tx.send((mr_poll, false));
1180                    });
1181                },
1182            );
1183        let sk_unload = self.signing_key.clone();
1184        let handle_unload = handle.clone();
1185        let unload_fn: Box<dyn Fn(&str) -> bool + Send> = Box::new(move |model_ref: &str| {
1186            let sk = sk_unload.clone();
1187            let mr = model_ref.to_owned();
1188            handle_unload.block_on(async move {
1189                let client = match production_model_client(sk.clone()) {
1190                    Ok(c) => c,
1191                    Err(e) => {
1192                        tracing::warn!("Failed to create ModelClient: {e}");
1193                        return false;
1194                    }
1195                };
1196                client
1197                    .unload(&hyprstream_rpc_std::model_client::UnloadModelRequest {
1198                        model_ref: mr.clone(),
1199                    })
1200                    .await
1201                    .is_ok()
1202            })
1203        });
1204
1205        let git_ops = {
1206            use hyprstream_rpc::streaming::StreamPayload;
1207            use hyprstream_rpc_std::registry_client::{
1208                CloneRequest, CreateWorktreeRequest, PushRequest, RegistryRpc, UpdateRequest,
1209            };
1210            use hyprstream_tui::shell_app::{
1211                GitOpProgress, GitOps, GitProgressSender, ModelEntry as ShellModelEntry,
1212            };
1213
1214            let sk_clone = self.signing_key.clone();
1215            let h_clone = handle.clone();
1216            let rmd_clone = registry_models_dir.clone();
1217            let clone_fn: hyprstream_tui::shell_app::CloneFn =
1218                Box::new(move |url, name, branch, tx: GitProgressSender| {
1219                    let sk = sk_clone.clone();
1220                    let h = h_clone.clone();
1221                    let rmd = rmd_clone.clone();
1222                    std::thread::spawn(move || {
1223                        h.block_on(async {
1224                            let registry = match production_registry_client(sk) {
1225                                Ok(c) => c,
1226                                Err(e) => {
1227                                    let _ = tx.send(GitOpProgress::Failed(format!(
1228                                        "Failed to create RegistryClient: {e}"
1229                                    )));
1230                                    return;
1231                                }
1232                            };
1233                            let model_name = name.unwrap_or_else(|| {
1234                                url.rsplit('/')
1235                                    .next()
1236                                    .unwrap_or("model")
1237                                    .trim_end_matches(".git")
1238                                    .to_owned()
1239                            });
1240                            let _ = tx.send(GitOpProgress::CloneProgress {
1241                                stage: "Connecting…".to_owned(),
1242                                pct: 0,
1243                            });
1244
1245                            let mut stream_handle = match RegistryRpc::clone_stream(
1246                                &registry,
1247                                &CloneRequest {
1248                                    url: url.clone(),
1249                                    name: model_name.clone(),
1250                                    shallow: false,
1251                                    depth: 0,
1252                                    branch: branch.unwrap_or_default(),
1253                                },
1254                            )
1255                            .await
1256                            {
1257                                Ok(h) => h,
1258                                Err(e) => {
1259                                    let _ = tx
1260                                        .send(GitOpProgress::Failed(format!("Clone failed: {e}")));
1261                                    return;
1262                                }
1263                            };
1264
1265                            loop {
1266                                match stream_handle.recv_next().await {
1267                                    Ok(Some(StreamPayload::Data(data))) => {
1268                                        if let Ok(text) = String::from_utf8(data) {
1269                                            let parts: Vec<&str> = text.split(':').collect();
1270                                            if parts.len() >= 3 {
1271                                                let stage = parts[0];
1272                                                let current: u64 = parts[1].parse().unwrap_or(0);
1273                                                let total: u64 = parts[2].parse().unwrap_or(0);
1274                                                let pct = (current * 70)
1275                                                    .checked_div(total)
1276                                                    .map(|v| v.min(70) as u8)
1277                                                    .unwrap_or(0);
1278                                                let label = match stage {
1279                                                    "fetch" => "Fetching objects",
1280                                                    "indexing" => "Indexing",
1281                                                    "smudge" => "Downloading model files",
1282                                                    "lfs" => "Downloading LFS files",
1283                                                    other => other,
1284                                                };
1285                                                let _ = tx.send(GitOpProgress::CloneProgress {
1286                                                    stage: label.to_owned(),
1287                                                    pct,
1288                                                });
1289                                            }
1290                                        }
1291                                    }
1292                                    Ok(Some(StreamPayload::Complete(_))) | Ok(None) => break,
1293                                    Ok(Some(StreamPayload::Error(message))) => {
1294                                        let _ = tx.send(GitOpProgress::Failed(format!(
1295                                            "Clone failed: {message}"
1296                                        )));
1297                                        return;
1298                                    }
1299                                    Ok(Some(StreamPayload::Tagged { .. })) => {}
1300                                    Err(e) => {
1301                                        let _ = tx.send(GitOpProgress::Failed(format!(
1302                                            "Clone stream error: {e}"
1303                                        )));
1304                                        return;
1305                                    }
1306                                }
1307                            }
1308
1309                            let _ = tx.send(GitOpProgress::CloneProgress {
1310                                stage: "Creating worktree…".to_owned(),
1311                                pct: 80,
1312                            });
1313
1314                            let tracked = match registry.get_by_name(&model_name).await {
1315                                Ok(t) => t,
1316                                Err(e) => {
1317                                    let _ = tx.send(GitOpProgress::Failed(format!(
1318                                        "Failed to get repo: {e}"
1319                                    )));
1320                                    return;
1321                                }
1322                            };
1323                            let repo_client = registry.repo(&tracked.id);
1324                            let wt_branch = if tracked.tracking_ref.is_empty() {
1325                                "main".to_owned()
1326                            } else {
1327                                tracked.tracking_ref.clone()
1328                            };
1329                            let _ = repo_client
1330                                .create_worktree(&CreateWorktreeRequest {
1331                                    branch: wt_branch.clone(),
1332                                })
1333                                .await;
1334
1335                            let model_ref = format!("{model_name}:{wt_branch}");
1336                            let path = rmd.join(&model_name).join("worktrees").join(&wt_branch);
1337                            let _ = tx.send(GitOpProgress::Done {
1338                                message: format!("Cloned {model_name} successfully"),
1339                                new_model: Some(ShellModelEntry {
1340                                    model_ref,
1341                                    path,
1342                                    loaded: false,
1343                                    ahead: 0,
1344                                    behind: 0,
1345                                    is_dirty: false,
1346                                }),
1347                            });
1348                        });
1349                    });
1350                });
1351
1352            let sk_pull = self.signing_key.clone();
1353            let h_pull = handle.clone();
1354            let pull_fn: hyprstream_tui::shell_app::PullFn =
1355                Box::new(move |model_ref, tx: GitProgressSender| {
1356                    let sk = sk_pull.clone();
1357                    let h = h_pull.clone();
1358                    std::thread::spawn(move || {
1359                        h.block_on(async {
1360                            let registry = match production_registry_client(sk) {
1361                                Ok(c) => c,
1362                                Err(e) => {
1363                                    let _ = tx.send(GitOpProgress::Failed(format!(
1364                                        "Failed to create RegistryClient: {e}"
1365                                    )));
1366                                    return;
1367                                }
1368                            };
1369                            let model_name = model_ref.split(':').next().unwrap_or(&model_ref);
1370                            let tracked = match registry.get_by_name(model_name).await {
1371                                Ok(t) => t,
1372                                Err(e) => {
1373                                    let _ =
1374                                        tx.send(GitOpProgress::Failed(format!("Not found: {e}")));
1375                                    return;
1376                                }
1377                            };
1378                            let repo_client = registry.repo(&tracked.id);
1379                            let _ = tx.send(GitOpProgress::Status("Fetching…".to_owned()));
1380                            match repo_client
1381                                .update(&UpdateRequest {
1382                                    refspec: String::new(),
1383                                })
1384                                .await
1385                            {
1386                                Ok(()) => {
1387                                    let _ = tx.send(GitOpProgress::Done {
1388                                        message: format!("Pulled {model_ref}"),
1389                                        new_model: None,
1390                                    });
1391                                }
1392                                Err(e) => {
1393                                    let _ =
1394                                        tx.send(GitOpProgress::Failed(format!("Pull failed: {e}")));
1395                                }
1396                            }
1397                        });
1398                    });
1399                });
1400
1401            let sk_push = self.signing_key.clone();
1402            let h_push = handle.clone();
1403            let push_fn: hyprstream_tui::shell_app::PushFn =
1404                Box::new(move |model_ref, tx: GitProgressSender| {
1405                    let sk = sk_push.clone();
1406                    let h = h_push.clone();
1407                    std::thread::spawn(move || {
1408                        h.block_on(async {
1409                            let registry = match production_registry_client(sk) {
1410                                Ok(c) => c,
1411                                Err(e) => {
1412                                    let _ = tx.send(GitOpProgress::Failed(format!(
1413                                        "Failed to create RegistryClient: {e}"
1414                                    )));
1415                                    return;
1416                                }
1417                            };
1418                            let model_name = model_ref.split(':').next().unwrap_or(&model_ref);
1419                            let branch = model_ref.split(':').nth(1).unwrap_or("main");
1420                            let tracked = match registry.get_by_name(model_name).await {
1421                                Ok(t) => t,
1422                                Err(e) => {
1423                                    let _ =
1424                                        tx.send(GitOpProgress::Failed(format!("Not found: {e}")));
1425                                    return;
1426                                }
1427                            };
1428                            let repo_client = registry.repo(&tracked.id);
1429                            let _ = tx.send(GitOpProgress::Status("Pushing…".to_owned()));
1430                            let refspec = format!("refs/heads/{branch}:refs/heads/{branch}");
1431                            match repo_client
1432                                .push(&PushRequest {
1433                                    remote: "origin".to_owned(),
1434                                    refspec,
1435                                    force: false,
1436                                })
1437                                .await
1438                            {
1439                                Ok(()) => {
1440                                    let _ = tx.send(GitOpProgress::Done {
1441                                        message: format!("Pushed {model_ref}"),
1442                                        new_model: None,
1443                                    });
1444                                }
1445                                Err(e) => {
1446                                    let _ =
1447                                        tx.send(GitOpProgress::Failed(format!("Push failed: {e}")));
1448                                }
1449                            }
1450                        });
1451                    });
1452                });
1453
1454            let sk_status = self.signing_key.clone();
1455            let h_status = handle.clone();
1456            let fetch_status_fn: hyprstream_tui::shell_app::FetchStatusFn =
1457                Box::new(move |model_refs, tx| {
1458                    let sk = sk_status.clone();
1459                    let h = h_status.clone();
1460                    std::thread::spawn(move || {
1461                        h.block_on(async {
1462                            let registry = match production_registry_client(sk) {
1463                                Ok(c) => c,
1464                                Err(e) => {
1465                                    tracing::warn!("Failed to create RegistryClient: {e}");
1466                                    return;
1467                                }
1468                            };
1469                            for mr in model_refs {
1470                                let model_name = mr.split(':').next().unwrap_or(&mr);
1471                                if let Ok(tracked) = registry.get_by_name(model_name).await {
1472                                    let repo_client = registry.repo(&tracked.id);
1473                                    if let Ok(status) = repo_client.status().await {
1474                                        let _ = tx.send((
1475                                            mr,
1476                                            status.ahead,
1477                                            status.behind,
1478                                            !status.is_clean,
1479                                        ));
1480                                    }
1481                                }
1482                            }
1483                        });
1484                    });
1485                });
1486
1487            let sk_refresh = self.signing_key.clone();
1488            let h_refresh = handle.clone();
1489            let rmd_refresh = registry_models_dir.clone();
1490            let refresh_fn: hyprstream_tui::shell_app::RefreshFn =
1491                Box::new(move |tx: GitProgressSender| {
1492                    let sk = sk_refresh.clone();
1493                    let h = h_refresh.clone();
1494                    let rmd = rmd_refresh.clone();
1495                    std::thread::spawn(move || {
1496                        h.block_on(async {
1497                            let registry_client = match production_registry_client(sk.clone()) {
1498                                Ok(c) => c,
1499                                Err(e) => {
1500                                    tracing::warn!("model-list refresh: RegistryClient: {e}");
1501                                    return;
1502                                }
1503                            };
1504                            let model_client = match production_model_client(sk) {
1505                                Ok(c) => c,
1506                                Err(e) => {
1507                                    tracing::warn!("model-list refresh: ModelClient: {e}");
1508                                    return;
1509                                }
1510                            };
1511                            let status_timeout = std::time::Duration::from_millis(500);
1512                            let all_status_req = hyprstream_rpc_std::model_client::StatusRequest {
1513                                model_ref: String::new(),
1514                            };
1515                            let (repos_result, status_result) = tokio::join!(
1516                                registry_client.list(),
1517                                tokio::time::timeout(
1518                                    status_timeout,
1519                                    model_client.status(&all_status_req)
1520                                ),
1521                            );
1522                            let status_map: std::collections::HashMap<String, bool> =
1523                                match status_result {
1524                                    Ok(Ok(entries)) => entries
1525                                        .into_iter()
1526                                        .map(|e| (e.model_ref, e.status == "loaded"))
1527                                        .collect(),
1528                                    _ => std::collections::HashMap::new(),
1529                                };
1530                            let models: Vec<hyprstream_tui::shell_app::ModelEntry> =
1531                                match repos_result {
1532                                    Ok(repos) => repos
1533                                        .into_iter()
1534                                        .filter(|r| !r.name.is_empty())
1535                                        .flat_map(|r| {
1536                                            let name = r.name.clone();
1537                                            let rmd = rmd.clone();
1538                                            r.worktrees
1539                                                .into_iter()
1540                                                .map(|wt| {
1541                                                    let branch = if wt.branch_name.is_empty() {
1542                                                        "main".to_owned()
1543                                                    } else {
1544                                                        wt.branch_name
1545                                                    };
1546                                                    let model_ref = format!("{name}:{branch}");
1547                                                    let loaded = *status_map
1548                                                        .get(&model_ref)
1549                                                        .unwrap_or(&false);
1550                                                    let path = rmd
1551                                                        .join(&name)
1552                                                        .join("worktrees")
1553                                                        .join(&branch);
1554                                                    hyprstream_tui::shell_app::ModelEntry {
1555                                                        model_ref,
1556                                                        path,
1557                                                        loaded,
1558                                                        ahead: 0,
1559                                                        behind: 0,
1560                                                        is_dirty: false,
1561                                                    }
1562                                                })
1563                                                .collect::<Vec<_>>()
1564                                        })
1565                                        .collect(),
1566                                    Err(_) => vec![],
1567                                };
1568                            let _ = tx.send(GitOpProgress::ModelList(models));
1569                        });
1570                    });
1571                });
1572
1573            GitOps {
1574                clone_fn,
1575                pull_fn,
1576                push_fn,
1577                fetch_status_fn,
1578                refresh_fn,
1579            }
1580        };
1581
1582        let app = hyprstream_tui::shell_app::ShellApp::new(
1583            models,
1584            cols,
1585            rows,
1586            load_fn,
1587            unload_fn,
1588            Some(git_ops),
1589            Some(registry_models_dir.clone()),
1590        );
1591        let config = waxterm::app::TerminalConfig::new().cols(cols).rows(rows);
1592        let process = super::process::spawn_app_process(app, config);
1593
1594        // Rename the window to "Shell" for a meaningful titlebar.
1595        {
1596            let mut state = self.state.write().await;
1597            if let Some(sess) = state.session_mut(sid) {
1598                for win in &mut sess.windows {
1599                    if win.panes.iter().any(|p| p.id == active_pane_id) {
1600                        win.name = "Shell".to_owned();
1601                        break;
1602                    }
1603                }
1604            }
1605        }
1606
1607        let sessions_reg = Arc::clone(&self.sessions);
1608        let continuation: Continuation = Box::pin(async move {
1609            let reg = sessions_reg.read().await;
1610            if let Some((sender, _)) = reg.get(&sid) {
1611                let _ = sender.send(FrameLoopCommand::SpawnProcess {
1612                    pane_id: active_pane_id,
1613                    process,
1614                });
1615            }
1616        });
1617
1618        let mut msg = capnp::message::Builder::new_default();
1619        {
1620            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
1621            resp.set_request_id(request_id);
1622            let mut result = resp.init_spawn_chrome_shell_result();
1623            result.set_success(true);
1624            result.set_pid(0);
1625        }
1626        let mut buf = Vec::new();
1627        serialize::write_message(&mut buf, &msg)?;
1628        Ok((buf, Some(continuation)))
1629    }
1630
1631    /// Spawn a [`ChatApp`] as a `PaneProcess` inside TuiService.
1632    ///
1633    /// Mirrors [`handle_spawn_chrome_shell`] — returns an "accepted" response
1634    /// immediately, then delivers the process to the frame loop via Continuation.
1635    async fn handle_spawn_chat_app(
1636        &self,
1637        request_id: u64,
1638        session_id: u32,
1639        model_ref: &str,
1640        cols: u16,
1641        rows: u16,
1642        pane_id: u32,
1643    ) -> Result<(Vec<u8>, Option<Continuation>)> {
1644        let (sid, active_pane_id, cols, rows) = {
1645            let state = self.state.read().await;
1646            let sid = if session_id == 0 {
1647                state.sessions.last().map(|s| s.id).unwrap_or(1)
1648            } else {
1649                session_id
1650            };
1651            let active_pane_id = if pane_id != 0 {
1652                pane_id
1653            } else {
1654                use crate::tui::state::PaneBackend;
1655                state
1656                    .session(sid)
1657                    .and_then(|s| s.active_window())
1658                    .and_then(|w| {
1659                        let ap = w.active_pane();
1660                        if ap
1661                            .map(|p| p.backend != PaneBackend::Private)
1662                            .unwrap_or(false)
1663                        {
1664                            ap.map(|p| p.id)
1665                        } else {
1666                            w.panes
1667                                .iter()
1668                                .find(|p| p.backend != PaneBackend::Private)
1669                                .map(|p| p.id)
1670                        }
1671                    })
1672                    .unwrap_or(1)
1673            };
1674            // Use the pane's actual dimensions from TuiState rather than the
1675            // RPC-supplied cols/rows, so the ChatApp matches the live pane size
1676            // regardless of when viewers connect and resize the pane.
1677            let pane_size = state
1678                .session(sid)
1679                .and_then(|s| {
1680                    s.windows
1681                        .iter()
1682                        .find(|w| w.panes.iter().any(|p| p.id == active_pane_id))
1683                })
1684                .and_then(|w| w.panes.iter().find(|p| p.id == active_pane_id))
1685                .map(super::state::TuiPane::size);
1686            let (cols, rows) = pane_size.unwrap_or((cols, rows));
1687            (sid, active_pane_id, cols, rows)
1688        };
1689
1690        let model_ref = model_ref.to_owned();
1691        let (tool_caller, tool_descriptions, openai_tools) =
1692            super::rpc_transport::make_tool_caller(&self.signing_key)?;
1693
1694        // Rename the window to "Chat: model_ref" so the titlebar is meaningful.
1695        {
1696            let mut state = self.state.write().await;
1697            if let Some(sess) = state.session_mut(sid) {
1698                for win in &mut sess.windows {
1699                    if win.panes.iter().any(|p| p.id == active_pane_id) {
1700                        win.name = format!("Chat: {}", model_ref);
1701                        break;
1702                    }
1703                }
1704            }
1705        }
1706
1707        let gen_config = std::sync::Arc::new(parking_lot::RwLock::new(
1708            hyprstream_tui::chat_app::ChatGenConfig::default(),
1709        ));
1710        let spawner = super::rpc_transport::make_chat_spawner(
1711            &self.signing_key,
1712            &model_ref,
1713            Some(openai_tools),
1714            std::sync::Arc::clone(&gen_config),
1715        );
1716
1717        let app = hyprstream_tui::chat_app::ChatApp::new(model_ref.clone(), cols, rows, spawner)
1718            .with_gen_config(gen_config)
1719            .with_tool_caller(
1720                tool_caller,
1721                tool_descriptions,
1722                crate::storage::ModelRef::parse(&model_ref)
1723                    .ok()
1724                    .and_then(|mr| {
1725                        let branch = match &mr.git_ref {
1726                            crate::storage::GitRef::Branch(name) => name.clone(),
1727                            _ => "main".to_owned(),
1728                        };
1729                        crate::storage::StoragePaths::new()
1730                            .ok()
1731                            .and_then(|sp| sp.worktree_path(mr.name(), &branch).ok())
1732                    })
1733                    .map(|path| {
1734                        let arch =
1735                            crate::runtime::model_config::ModelConfig::detect_architecture(&path);
1736                        match crate::api::tools::ToolCallFormat::from_architecture(&arch) {
1737                            crate::api::tools::ToolCallFormat::Qwen3Xml => {
1738                                hyprstream_tui::chat_app::ToolCallFormat::Qwen3Xml
1739                            }
1740                            crate::api::tools::ToolCallFormat::Qwen35XmlParam => {
1741                                hyprstream_tui::chat_app::ToolCallFormat::Qwen35XmlParam
1742                            }
1743                            crate::api::tools::ToolCallFormat::LlamaJson => {
1744                                hyprstream_tui::chat_app::ToolCallFormat::LlamaJson
1745                            }
1746                            crate::api::tools::ToolCallFormat::MistralJson => {
1747                                hyprstream_tui::chat_app::ToolCallFormat::MistralJson
1748                            }
1749                            crate::api::tools::ToolCallFormat::None => {
1750                                hyprstream_tui::chat_app::ToolCallFormat::None
1751                            }
1752                        }
1753                    })
1754                    .unwrap_or(hyprstream_tui::chat_app::ToolCallFormat::Qwen3Xml),
1755            )
1756            .with_server_spawned();
1757
1758        // Wire VFS namespace if available, using the shared proxy sender.
1759        let app = if let (Some(vfs_ns), Some(vfs_subject), Some(vfs_tx)) =
1760            (&self.vfs_ns, &self.vfs_subject, self.vfs_proxy())
1761        {
1762            app.with_vfs_proxy(vfs_ns.clone(), vfs_subject.clone(), vfs_tx.clone())
1763        } else {
1764            app
1765        };
1766
1767        let config = waxterm::app::TerminalConfig::new().cols(cols).rows(rows);
1768        let process = super::process::spawn_app_process(app, config);
1769
1770        let sessions_reg = Arc::clone(&self.sessions);
1771        let continuation: Continuation = Box::pin(async move {
1772            let reg = sessions_reg.read().await;
1773            if let Some((sender, _)) = reg.get(&sid) {
1774                let _ = sender.send(FrameLoopCommand::SpawnProcess {
1775                    pane_id: active_pane_id,
1776                    process,
1777                });
1778            }
1779        });
1780
1781        let mut msg = capnp::message::Builder::new_default();
1782        {
1783            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
1784            resp.set_request_id(request_id);
1785            let mut result = resp.init_spawn_chat_app_result();
1786            result.set_success(true);
1787            result.set_pid(0);
1788        }
1789        let mut buf = Vec::new();
1790        serialize::write_message(&mut buf, &msg)?;
1791        Ok((buf, Some(continuation)))
1792    }
1793
1794    async fn handle_resize(&self, request_id: u64, cols: u16, rows: u16) -> Result<Vec<u8>> {
1795        // Resize the active pane in the most recent session; capture pane_id + session_id.
1796        let (pane_id, session_id) = {
1797            let mut state = self.state.write().await;
1798            let mut found_pane_id = 0u32;
1799            let mut found_session_id = 0u32;
1800            if let Some(session) = state.sessions.last_mut() {
1801                found_session_id = session.id;
1802                if let Some(window) = session.active_window_mut() {
1803                    if let Some(pane) = window.active_pane_mut() {
1804                        pane.resize(cols, rows);
1805                        found_pane_id = pane.id;
1806                    }
1807                }
1808            }
1809            (found_pane_id, found_session_id)
1810        };
1811
1812        // Notify the frame loop so it forwards Resize to the attached process.
1813        if pane_id != 0 {
1814            let reg = self.sessions.read().await;
1815            if let Some((sender, _)) = reg.get(&session_id) {
1816                let _ = sender.send(FrameLoopCommand::Resize {
1817                    pane_id,
1818                    cols,
1819                    rows,
1820                });
1821            }
1822        }
1823
1824        let mut msg = Builder::new_default();
1825        {
1826            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
1827            resp.set_request_id(request_id);
1828            resp.set_resize_result(());
1829        }
1830        let mut buf = Vec::new();
1831        serialize::write_message(&mut buf, &msg)?;
1832        Ok(buf)
1833    }
1834
1835    /// Create a private pane — marks it `PaneBackend::Private` in `TuiState`,
1836    /// notifies the frame loop, and returns the assigned `pane_id`.
1837    async fn handle_create_private_pane(
1838        &self,
1839        request_id: u64,
1840        session_id: u32,
1841        window_id: u32,
1842        cols: u16,
1843        rows: u16,
1844        name: &str,
1845    ) -> Result<Vec<u8>> {
1846        use crate::tui::state::PaneBackend;
1847
1848        let (sid, pane_id) = {
1849            let mut state = self.state.write().await;
1850            let sid = if session_id == 0 {
1851                state.sessions.last().map(|s| s.id).unwrap_or(1)
1852            } else {
1853                session_id
1854            };
1855            // Resolve window_id (0 = active window).
1856            let wid = if window_id == 0 {
1857                state
1858                    .session(sid)
1859                    .and_then(|s| s.active_window())
1860                    .map(|w| w.id)
1861                    .unwrap_or(0)
1862            } else {
1863                window_id
1864            };
1865            // Allocate a new pane in the target window.
1866            let next_id = state.next_pane_id();
1867            let pane_id = if let Some(session) = state.session_mut(sid) {
1868                if let Some(window) = session.windows.iter_mut().find(|w| w.id == wid) {
1869                    let rows_inner = rows.max(1);
1870                    let cols_inner = cols.max(1);
1871                    let mut pane =
1872                        crate::tui::state::TuiPane::new(next_id, cols_inner, rows_inner, 0);
1873                    pane.backend = PaneBackend::Private;
1874                    pane.title = name.to_owned();
1875                    window.panes.push(pane);
1876                    // Do NOT change active_pane_id — the frame loop must keep
1877                    // publishing the existing ShellApp pane (non-private).
1878                    next_id
1879                } else {
1880                    return Err(anyhow::anyhow!(
1881                        "window {} not found in session {}",
1882                        wid,
1883                        sid
1884                    ));
1885                }
1886            } else {
1887                return Err(anyhow::anyhow!("session {} not found", sid));
1888            };
1889            (sid, pane_id)
1890        };
1891
1892        // Notify frame loop: force a full frame so the [PRIVATE] placeholder renders.
1893        {
1894            let reg = self.sessions.read().await;
1895            if let Some((sender, _)) = reg.get(&sid) {
1896                let _ = sender.send(FrameLoopCommand::MarkPanePrivate { pane_id });
1897            }
1898        }
1899
1900        let mut msg = Builder::new_default();
1901        {
1902            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
1903            resp.set_request_id(request_id);
1904            resp.set_create_private_pane_result(pane_id);
1905        }
1906        let mut buf = Vec::new();
1907        serialize::write_message(&mut buf, &msg)?;
1908        Ok(buf)
1909    }
1910
1911    // ========================================================================
1912    // Response builders
1913    // ========================================================================
1914
1915    fn build_error_response(&self, request_id: u64, message: &str, code: &str) -> Result<Vec<u8>> {
1916        let mut msg = Builder::new_default();
1917        {
1918            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
1919            resp.set_request_id(request_id);
1920            let mut err = resp.init_error();
1921            err.set_message(message);
1922            err.set_code(code);
1923        }
1924        let mut buf = Vec::new();
1925        serialize::write_message(&mut buf, &msg)?;
1926        Ok(buf)
1927    }
1928
1929    fn build_connect_response(
1930        &self,
1931        request_id: u64,
1932        viewer_id: u32,
1933        session_id: u32,
1934        windows: &[(u32, String, Vec<(u32, (u16, u16), bool)>, u32)],
1935        // (topic, mac_key, broadcast_path)
1936        streams: &[(&str, &[u8; 32], &str)],
1937    ) -> Result<Vec<u8>> {
1938        let mut msg = Builder::new_default();
1939        {
1940            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
1941            resp.set_request_id(request_id);
1942            let mut connect = resp.init_connect_result();
1943            connect.set_viewer_id(viewer_id);
1944            connect.set_session_id(session_id);
1945
1946            let reach_config = self.reach_config.read();
1947            let reach = reach_config.reach();
1948            let moql_server_identity = reach_config
1949                .moql_server_identity
1950                .clone()
1951                .unwrap_or_default();
1952
1953            // FD-indexed streams: [0]=stdin (input relay), [1]=stdout (frames)
1954            let mut stream_list = connect.reborrow().init_streams(streams.len() as u32);
1955            for (i, (topic, mac_key, broadcast_path)) in streams.iter().enumerate() {
1956                let mut si = stream_list.reborrow().get(i as u32);
1957                si.set_topic(topic);
1958                si.set_mac_key(*mac_key);
1959                si.set_broadcast_path(broadcast_path);
1960                let mut witness = si.reborrow().init_moql_server_identity();
1961                hyprstream_rpc::capnp::ToCapnp::write_to(&moql_server_identity, &mut witness);
1962                // Encode the networked reach via the shared generated ToCapnp impl
1963                // (Destination::write_to), so the wire bytes match the inference
1964                // StreamInfo's `announcedAt` 1:1.
1965                let mut reach_list = si.reborrow().init_announced_at(reach.len() as u32);
1966                for (j, dest) in reach.iter().enumerate() {
1967                    let mut db = reach_list.reborrow().get(j as u32);
1968                    hyprstream_rpc::capnp::ToCapnp::write_to(dest, &mut db);
1969                }
1970            }
1971
1972            let mut win_list = connect.init_windows(windows.len() as u32);
1973            for (i, (wid, name, panes, active_pane)) in windows.iter().enumerate() {
1974                let mut w = win_list.reborrow().get(i as u32);
1975                w.set_id(*wid);
1976                w.set_name(name);
1977                w.set_active_pane_id(*active_pane);
1978                let mut pane_list = w.init_panes(panes.len() as u32);
1979                for (j, (pid, (cols, rows), is_private)) in panes.iter().enumerate() {
1980                    let mut p = pane_list.reborrow().get(j as u32);
1981                    p.set_id(*pid);
1982                    p.set_cols(*cols);
1983                    p.set_rows(*rows);
1984                    p.set_title("");
1985                    p.set_is_private(*is_private);
1986                }
1987            }
1988        }
1989        let mut buf = Vec::new();
1990        serialize::write_message(&mut buf, &msg)?;
1991        Ok(buf)
1992    }
1993
1994    fn build_window_response(
1995        &self,
1996        request_id: u64,
1997        window_id: u32,
1998        name: &str,
1999        panes: &[(u32, (u16, u16), String, bool)],
2000    ) -> Result<Vec<u8>> {
2001        let mut msg = Builder::new_default();
2002        {
2003            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
2004            resp.set_request_id(request_id);
2005            let mut win = resp.init_create_window_result();
2006            win.set_id(window_id);
2007            win.set_name(name);
2008            win.set_active_pane_id(panes.first().map(|(id, _, _, _)| *id).unwrap_or(0));
2009            let mut pane_list = win.init_panes(panes.len() as u32);
2010            for (i, (pid, (cols, rows), title, is_private)) in panes.iter().enumerate() {
2011                let mut p = pane_list.reborrow().get(i as u32);
2012                p.set_id(*pid);
2013                p.set_cols(*cols);
2014                p.set_rows(*rows);
2015                p.set_title(title);
2016                p.set_is_private(*is_private);
2017            }
2018        }
2019        let mut buf = Vec::new();
2020        serialize::write_message(&mut buf, &msg)?;
2021        Ok(buf)
2022    }
2023
2024    fn build_snapshot_response(
2025        &self,
2026        request_id: u64,
2027        session_id: u32,
2028        generation: u64,
2029        active_window_id: u32,
2030        frame_diff: &diff::FrameDiff,
2031        windows: &[(u32, String, Vec<(u32, (u16, u16), String)>, u32)],
2032    ) -> Result<Vec<u8>> {
2033        let mut msg = Builder::new_default();
2034        {
2035            let mut resp = msg.init_root::<tui_capnp::tui_response::Builder<'_>>();
2036            resp.set_request_id(request_id);
2037            let mut snap = resp.init_snapshot_result();
2038            snap.set_session_id(session_id);
2039            snap.set_generation(generation);
2040            snap.set_active_window_id(active_window_id);
2041
2042            // Populate full frame from frame_diff
2043            let mut frame = snap.reborrow().init_frame();
2044            frame.set_cols(frame_diff.cols);
2045            frame.set_rows(frame_diff.rows);
2046            let mut cells = frame.init_cells(frame_diff.deltas.len() as u32);
2047            for (i, delta) in frame_diff.deltas.iter().enumerate() {
2048                let mut cell = cells.reborrow().get(i as u32);
2049                cell.set_x(delta.x);
2050                cell.set_y(delta.y);
2051                cell.set_symbol(&delta.symbol);
2052                cell.set_fg(diff::pack_color(delta.fg));
2053                cell.set_bg(diff::pack_color(delta.bg));
2054                cell.set_modifiers(delta.modifiers.bits());
2055            }
2056
2057            // Populate windows list
2058            let mut win_list = snap.init_windows(windows.len() as u32);
2059            for (i, (wid, name, panes, active_pane)) in windows.iter().enumerate() {
2060                let mut w = win_list.reborrow().get(i as u32);
2061                w.set_id(*wid);
2062                w.set_name(name);
2063                w.set_active_pane_id(*active_pane);
2064                let mut pane_list = w.init_panes(panes.len() as u32);
2065                for (j, (pid, (cols, rows), title)) in panes.iter().enumerate() {
2066                    let mut p = pane_list.reborrow().get(j as u32);
2067                    p.set_id(*pid);
2068                    p.set_cols(*cols);
2069                    p.set_rows(*rows);
2070                    p.set_title(title);
2071                }
2072            }
2073        }
2074        let mut buf = Vec::new();
2075        serialize::write_message(&mut buf, &msg)?;
2076        Ok(buf)
2077    }
2078}
2079
2080/// The TUI-class scope a federate credential must carry for a request (W1.3).
2081/// Maps the service's operation vocabulary onto the TUI session ceiling:
2082/// `connect` to attach a viewer, `query` for read-only views, `write` for
2083/// everything that mutates state, feeds input, or spawns.
2084#[cfg(feature = "postgres")]
2085fn federate_tui_required_scope(
2086    request: &tui_capnp::tui_request::Reader<'_>,
2087) -> Result<&'static str> {
2088    Ok(match request.which()? {
2089        tui_capnp::tui_request::Which::Connect(_) => "connect:tui:session",
2090        tui_capnp::tui_request::Which::Snapshot(_)
2091        | tui_capnp::tui_request::Which::ListWindows(_)
2092        | tui_capnp::tui_request::Which::PollStdin(_) => "query:tui:session",
2093        _ => "write:tui:session",
2094    })
2095}
2096
2097#[async_trait(?Send)]
2098impl RequestService for TuiService {
2099    fn producer_reach_config_handle(
2100        &self,
2101    ) -> Option<hyprstream_rpc::moq_stream::ProducerReachConfigHandle> {
2102        Some(self.reach_config.clone())
2103    }
2104
2105    fn moq_origin_handle(&self) -> Option<hyprstream_rpc::moq_stream::MoqStreamOriginHandle> {
2106        Some(self.moq_origin.clone())
2107    }
2108
2109    fn decode_request_body(
2110        &self,
2111        signed_body: &[u8],
2112    ) -> anyhow::Result<hyprstream_rpc::service::DecodedRequestBody> {
2113        // The ONE bounded decode (v16 §5.2): the generated decoder derives
2114        // the full method leaf; the hand-written dispatch below reads from
2115        // the same decoded message.
2116        crate::services::generated::tui_client::decode_tui_request_body(signed_body)
2117    }
2118
2119    async fn handle_request(
2120        &self,
2121        _ctx: &EnvelopeContext,
2122        body: &hyprstream_rpc::service::DecodedRequestBody,
2123    ) -> Result<(Vec<u8>, Option<Continuation>)> {
2124        let request = body.root::<tui_capnp::tui_request::Reader<'_>>()?;
2125        let request_id = request.get_id();
2126
2127        // W1.3 consumer gate: a TUI-classified credential (markers OR the
2128        // class pin — see is_federate_tui_classified) is admitted only after
2129        // full class verification, which REQUIRES the complete marker set,
2130        // plus the scope this operation needs. Unclassified credentials take
2131        // the pre-existing path unchanged; www-class credentials never reach
2132        // this service (the svc.rs deferred branch denies them here). The
2133        // mint path exists only in postgres builds, so other builds deny
2134        // classified credentials unconditionally (fail-closed).
2135        if let Some(claims) = _ctx.claims() {
2136            if self.is_federate_tui_classified(claims) {
2137                #[cfg(feature = "postgres")]
2138                {
2139                    let required = federate_tui_required_scope(&request)?;
2140                    self.admit_federate_tui(claims, required)?;
2141                }
2142                #[cfg(not(feature = "postgres"))]
2143                anyhow::bail!("Federate TUI credentials require the postgres build profile");
2144            }
2145        }
2146
2147        match request.which()? {
2148            tui_capnp::tui_request::Which::Connect(connect_reader) => {
2149                let connect = connect_reader?;
2150                let sid = connect.get_session_id();
2151                let cols = connect.get_cols();
2152                let rows = connect.get_rows();
2153                let display_mode = match connect.get_display_mode()? {
2154                    tui_capnp::DisplayMode::Capnp => DisplayMode::Capnp,
2155                    tui_capnp::DisplayMode::Structured => DisplayMode::Structured,
2156                    _ => DisplayMode::Ansi,
2157                };
2158                self.handle_connect(request_id, sid, display_mode, cols, rows, _ctx)
2159                    .await
2160            }
2161            tui_capnp::tui_request::Which::CreateWindow(()) => {
2162                Ok((self.handle_create_window(request_id).await?, None))
2163            }
2164            tui_capnp::tui_request::Which::Snapshot(sid) => {
2165                Ok((self.handle_snapshot(request_id, sid).await?, None))
2166            }
2167            tui_capnp::tui_request::Which::ListWindows(session_id) => Ok((
2168                self.handle_list_windows(request_id, session_id).await?,
2169                None,
2170            )),
2171            tui_capnp::tui_request::Which::Disconnect(viewer_id) => {
2172                Ok((self.handle_disconnect(request_id, viewer_id).await?, None))
2173            }
2174            tui_capnp::tui_request::Which::Resize(resize_reader) => {
2175                let resize = resize_reader?;
2176                let cols = resize.get_cols();
2177                let rows = resize.get_rows();
2178                Ok((self.handle_resize(request_id, cols, rows).await?, None))
2179            }
2180            tui_capnp::tui_request::Which::CloseWindow(window_id) => {
2181                Ok((self.handle_close_window(request_id, window_id).await?, None))
2182            }
2183            tui_capnp::tui_request::Which::FocusWindow(window_id) => {
2184                Ok((self.handle_focus_window(request_id, window_id).await?, None))
2185            }
2186            tui_capnp::tui_request::Which::SplitPane(split_reader) => {
2187                let split = split_reader?;
2188                let horizontal = match split.get_direction()? {
2189                    tui_capnp::SplitDirection::Horizontal => true,
2190                    tui_capnp::SplitDirection::Vertical => false,
2191                };
2192                let ratio = split.get_ratio();
2193                Ok((
2194                    self.handle_split_pane(request_id, horizontal, ratio)
2195                        .await?,
2196                    None,
2197                ))
2198            }
2199            tui_capnp::tui_request::Which::ClosePane(pane_id) => {
2200                Ok((self.handle_close_pane(request_id, pane_id).await?, None))
2201            }
2202            tui_capnp::tui_request::Which::FocusPane(pane_id) => {
2203                Ok((self.handle_focus_pane(request_id, pane_id).await?, None))
2204            }
2205            tui_capnp::tui_request::Which::SendInput(input_reader) => {
2206                let input = input_reader?;
2207                let viewer_id = input.get_viewer_id();
2208                let data = input.get_data()?;
2209                Ok((
2210                    self.handle_send_input(request_id, viewer_id, data).await?,
2211                    None,
2212                ))
2213            }
2214            tui_capnp::tui_request::Which::SpawnShell(spawn_reader) => {
2215                let spawn = spawn_reader?;
2216                let sid = spawn.get_session_id();
2217                let pane_id = spawn.get_pane_id();
2218                let cwd = spawn.get_cwd()?.to_str().unwrap_or("");
2219                self.authorize(_ctx, "tui:shell", "spawn")
2220                    .await
2221                    .map_err(|e| anyhow::anyhow!("{}", e))?;
2222                self.handle_spawn_shell(request_id, sid, pane_id, cwd).await
2223            }
2224            tui_capnp::tui_request::Which::PollStdin(viewer_id) => {
2225                Ok((self.handle_poll_stdin(request_id, viewer_id).await?, None))
2226            }
2227            tui_capnp::tui_request::Which::SpawnChromeShell(req_reader) => {
2228                self.authorize(_ctx, "tui:shell", "spawn")
2229                    .await
2230                    .map_err(|e| anyhow::anyhow!("{}", e))?;
2231                let req = req_reader?;
2232                let sid = req.get_session_id();
2233                let registry_dir = req.get_registry_dir()?.to_str().unwrap_or("").to_owned();
2234                let cols = req.get_cols();
2235                let rows = req.get_rows();
2236                let pane_id = req.get_pane_id();
2237                self.handle_spawn_chrome_shell(request_id, sid, &registry_dir, cols, rows, pane_id)
2238                    .await
2239            }
2240            tui_capnp::tui_request::Which::SpawnChatApp(req_reader) => {
2241                self.authorize(_ctx, "tui:chat", "spawn")
2242                    .await
2243                    .map_err(|e| anyhow::anyhow!("{}", e))?;
2244                let req = req_reader?;
2245                let sid = req.get_session_id();
2246                let model_ref = req.get_model_ref()?.to_str().unwrap_or("").to_owned();
2247                let cols = req.get_cols();
2248                let rows = req.get_rows();
2249                let pane_id = req.get_pane_id();
2250                self.handle_spawn_chat_app(request_id, sid, &model_ref, cols, rows, pane_id)
2251                    .await
2252            }
2253            tui_capnp::tui_request::Which::CreatePrivatePane(req_reader) => {
2254                self.authorize(_ctx, "tui:private", "create")
2255                    .await
2256                    .map_err(|e| anyhow::anyhow!("{}", e))?;
2257                let req = req_reader?;
2258                let session_id = req.get_session_id();
2259                let window_id = req.get_window_id();
2260                let cols = req.get_cols();
2261                let rows = req.get_rows();
2262                let name = req.get_name()?.to_str().unwrap_or("chat").to_owned();
2263                Ok((
2264                    self.handle_create_private_pane(
2265                        request_id, session_id, window_id, cols, rows, &name,
2266                    )
2267                    .await?,
2268                    None,
2269                ))
2270            }
2271        }
2272    }
2273
2274    fn name(&self) -> &str {
2275        "tui"
2276    }
2277
2278    fn transport(&self) -> &TransportConfig {
2279        &self.transport
2280    }
2281
2282    fn signing_key(&self) -> SigningKey {
2283        self.signing_key.clone()
2284    }
2285
2286    fn expected_audience(&self) -> Option<&str> {
2287        self.expected_audience.as_deref()
2288    }
2289
2290    fn jwt_key_source(&self) -> Option<std::sync::Arc<dyn hyprstream_rpc::auth::JwtKeySource>> {
2291        self.jwt_key_source.clone()
2292    }
2293
2294    fn build_error_payload(&self, request_id: u64, error: &str) -> Vec<u8> {
2295        self.build_error_response(request_id, error, "INTERNAL")
2296            .unwrap_or_default()
2297    }
2298}
2299
2300// ============================================================================
2301// Frame Loop
2302// ============================================================================
2303
2304/// Maximum consecutive skips before a viewer is evicted (~1s at 30fps).
2305const MAX_CONSECUTIVE_SKIPS: u32 = 30;
2306
2307/// Spawn a frame loop for a session.
2308///
2309/// The frame loop runs at ~30fps, encodes diffs based on damage notifications,
2310/// Build an ANSI frame showing `[PRIVATE]` centred in the pane, for viewers
2311/// who should not see client-owned pane content.
2312fn private_placeholder_ansi(cols: u16, rows: u16) -> Vec<u8> {
2313    let label = "[PRIVATE]";
2314    let mut out = Vec::with_capacity(256);
2315    // Clear screen + move home
2316    out.extend_from_slice(b"\x1b[2J\x1b[H");
2317    // Move to centre row
2318    let row = (rows / 2).max(1);
2319    let col = cols.saturating_sub(label.len() as u16) / 2 + 1;
2320    // Dim colour
2321    out.extend_from_slice(format!("\x1b[{};{}H\x1b[2;37m{}\x1b[0m", row, col, label).as_bytes());
2322    out
2323}
2324
2325/// and publishes to all connected viewers. Slow viewers (>30 consecutive skips)
2326/// are evicted.
2327///
2328/// Runs on a local task (`spawn_local`) because `StreamPublisher` is `!Send`.
2329/// New viewers are registered via `viewer_rx` channel from the RPC handler.
2330pub(crate) async fn run_frame_loop(
2331    state: Arc<RwLock<TuiState>>,
2332    session_id: u32,
2333    mut cmd_rx: CommandReceiver,
2334    signing_key: SigningKey,
2335    cancel: CancellationToken,
2336    stdin_queues: StdinQueues,
2337    reach_config: hyprstream_rpc::moq_stream::ProducerReachConfigHandle,
2338    moq_origin: hyprstream_rpc::moq_stream::MoqStreamOriginHandle,
2339) {
2340    let mut interval = tokio::time::interval(std::time::Duration::from_millis(33));
2341    let mut event_rx = {
2342        let s = state.read().await;
2343        s.subscribe()
2344    };
2345
2346    // Viewer list lives here (local, !Send is OK on ZMQ path)
2347    let mut viewers: Vec<ViewerHandle> = Vec::new();
2348    // Hosted processes attached to panes (pane_id → PaneProcess)
2349    let mut processes: HashMap<u32, super::process::PaneProcess> = HashMap::new();
2350    // Previous frame snapshot for incremental diffs (per-pane, keyed by pane_id)
2351    let mut prev_cells: HashMap<u32, Vec<Cell>> = HashMap::new();
2352    let mut has_damage = false;
2353    // Delayed initial frame: after a viewer registers, wait for ZMQ SUB to connect
2354    // (slow-joiner race) or for the moq subscriber to appear before the first publish.
2355    let mut initial_frame_at: Option<tokio::time::Instant> = None;
2356    // Periodic heartbeat: re-publish a full frame every 2s when viewers are present.
2357    // This guarantees late-joining viewers receive current state without waiting for new damage.
2358    let mut heartbeat_at = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
2359
2360    // StreamChannel for creating publisher sockets (ZMQ or moq, auto-dispatched).
2361    let stream_channel = StreamChannel::new(signing_key)
2362        .with_reach_config(hyprstream_rpc::moq_stream::ProducerReachConfig::default())
2363        .with_reach_config_handle(reach_config)
2364        .with_moq_origin_handle(moq_origin);
2365
2366    info!(session_id, "Frame loop started");
2367
2368    loop {
2369        tokio::select! {
2370            biased;
2371
2372            _ = cancel.cancelled() => {
2373                info!(session_id, "Frame loop cancelled");
2374                break;
2375            }
2376
2377            // Accept commands from RPC handlers
2378            Some(cmd) = cmd_rx.recv() => {
2379                match cmd {
2380                    FrameLoopCommand::RegisterViewer(pending) => {
2381                        // FD 0 (stdin): input relay publisher — only for Capnp-mode viewers
2382                        // (i.e. the CLI cast player). Ansi-mode viewers don't need it;
2383                        // their keyboard input falls through to VTE when no producer exists.
2384                        let stdin_publisher: Option<AnyStreamPublisher> = if pending.display_mode == DisplayMode::Capnp {
2385                            if let Some(stdin_ctx) = pending.stream_ctxs.first() {
2386                                match stream_channel.publisher(stdin_ctx).await {
2387                                    Ok(pub_) => Some(pub_),
2388                                    Err(e) => {
2389                                        warn!(viewer_id = pending.id, error = %e, "Failed to create stdin publisher");
2390                                        None
2391                                    }
2392                                }
2393                            } else {
2394                                None
2395                            }
2396                        } else {
2397                            None
2398                        };
2399
2400                        // FD 1 (stdout): frame output publisher
2401                        let stdout_ctx = match pending.stream_ctxs.get(1) {
2402                            Some(ctx) => ctx,
2403                            None => {
2404                                warn!(viewer_id = pending.id, "Missing stdout stream context");
2405                                continue;
2406                            }
2407                        };
2408
2409                        // Register a stdin queue for Capnp-mode viewers so they can
2410                        // use pollStdin RPC instead of subscribing to the ZMQ stream.
2411                        if pending.display_mode == DisplayMode::Capnp {
2412                            let mut queues = stdin_queues.lock();
2413                            queues.entry(pending.id).or_default();
2414                        }
2415
2416                        let publisher_result: Result<AnyStreamPublisher, _> =
2417                            stream_channel.publisher(stdout_ctx).await;
2418
2419                        match publisher_result {
2420                            Ok(publisher) => {
2421                                viewers.push(ViewerHandle {
2422                                    id: pending.id,
2423                                    publisher,
2424                                    stdin_publisher,
2425                                    display_mode: pending.display_mode,
2426                                    consecutive_skips: 0,
2427                                    cancel: pending.cancel,
2428                                });
2429                                // Schedule initial frame after a short delay to allow the
2430                                // WebTransport subscription bridge (ZMQ SUB) to connect.
2431                                initial_frame_at = Some(tokio::time::Instant::now()
2432                                    + std::time::Duration::from_millis(500));
2433                                debug!(viewer_id = pending.id, session_id, "Viewer registered in frame loop");
2434                            }
2435                            Err(e) => {
2436                                warn!(viewer_id = pending.id, error = %e, "Failed to create stdout publisher");
2437                            }
2438                        }
2439                    }
2440                    FrameLoopCommand::SendInput { viewer_id, data } => {
2441                        // Only process input from viewers that belong to this session.
2442                        // handle_send_input broadcasts to all session frame loops, so we
2443                        // must reject input from viewers registered in other sessions.
2444                        let viewer_known = viewers.iter().any(|v| v.id == viewer_id);
2445                        debug!(
2446                            session_id, viewer_id,
2447                            data_len = data.len(),
2448                            viewer_known,
2449                            processes_count = processes.len(),
2450                            "SendInput received"
2451                        );
2452                        if !viewer_known {
2453                            continue;
2454                        }
2455
2456                        // Find the active pane ID to check for an attached process
2457                        let active_pane_id = {
2458                            let s = state.read().await;
2459                            s.session(session_id)
2460                                .and_then(|sess| sess.active_window())
2461                                .and_then(|win| win.active_pane())
2462                                .map(|p| p.id)
2463                        };
2464
2465                        if let Some(pane_id) = active_pane_id {
2466                            if let Some(proc) = processes.get(&pane_id) {
2467                                // Route input to the local attached process
2468                                let send_result = proc.input_tx.try_send(
2469                                    super::process::ProcessInput::Stdin(data),
2470                                );
2471                                debug!(session_id, viewer_id, pane_id, send_ok = send_result.is_ok(), "Input routed to process");
2472                                continue;
2473                            } else {
2474                                debug!(session_id, viewer_id, pane_id, "No process for pane, falling through to consumer/producer path");
2475                            }
2476                        } else {
2477                            debug!(session_id, viewer_id, "No active pane found for session");
2478                        }
2479
2480                        // Determine if the sender is a producer (Capnp-mode viewer
2481                        // sending ANSI output, e.g. cast player) or a consumer
2482                        // (Ansi-mode viewer sending keyboard input, e.g. tui attach).
2483                        let sender_is_producer = viewers.iter()
2484                            .any(|v| v.id == viewer_id && v.display_mode == DisplayMode::Capnp);
2485
2486                        if sender_is_producer {
2487                            // Producer output → VTE render into pane
2488                            debug!(
2489                                session_id,
2490                                viewer_id,
2491                                data_len = data.len(),
2492                                data_prefix = %String::from_utf8_lossy(&data[..data.len().min(60)]).escape_default(),
2493                                "Producer sendInput → VTE feed"
2494                            );
2495                            let mut tui_state = state.write().await;
2496                            let damage_info = if let Some(session) = tui_state.session_mut(session_id) {
2497                                if let Some(window) = session.active_window_mut() {
2498                                    let window_id = window.id;
2499                                    if let Some(pane) = window.active_pane_mut() {
2500                                        let pane_id = pane.id;
2501                                        let mut performer = vte_parser::PanePerformer::new(pane);
2502                                        performer.feed(&data);
2503                                        Some((window_id, pane_id))
2504                                    } else { None }
2505                                } else { None }
2506                            } else { None };
2507                            drop(tui_state);
2508
2509                            if let Some((window_id, pane_id)) = damage_info {
2510                                has_damage = true;
2511                                let s = state.read().await;
2512                                s.notify_damage(session_id, window_id, pane_id);
2513                            }
2514                        } else {
2515                            // Consumer input → relay via stdin stream (FD 0)
2516                            // to any remote process listening (e.g. CLI cast player).
2517                            let mut relayed = false;
2518                            for viewer in &mut viewers {
2519                                if let Some(ref mut stdin_pub) = viewer.stdin_publisher {
2520                                    if stdin_pub.publish_data(&data).await.is_ok() {
2521                                        relayed = true;
2522                                    }
2523                                    // Also enqueue for pollStdin RPC — avoids ZMQ SUB in client.
2524                                    let mut queues = stdin_queues.lock();
2525                                    if let Some(queue) = queues.get_mut(&viewer.id) {
2526                                        queue.push_back(data.clone());
2527                                    }
2528                                }
2529                            }
2530
2531                            if !relayed {
2532                                // No stdin subscribers — VTE fallback (direct write to pane)
2533                                let mut tui_state = state.write().await;
2534                                let damage_info = if let Some(session) = tui_state.session_mut(session_id) {
2535                                    if let Some(window) = session.active_window_mut() {
2536                                        let window_id = window.id;
2537                                        if let Some(pane) = window.active_pane_mut() {
2538                                            let pane_id = pane.id;
2539                                            let mut performer = vte_parser::PanePerformer::new(pane);
2540                                            performer.feed(&data);
2541                                            Some((window_id, pane_id))
2542                                        } else { None }
2543                                    } else { None }
2544                                } else { None };
2545                                drop(tui_state);
2546
2547                                if let Some((window_id, pane_id)) = damage_info {
2548                                    // Set has_damage directly so the next interval tick
2549                                    // publishes the frame even if event_rx races ahead.
2550                                    has_damage = true;
2551                                    let s = state.read().await;
2552                                    s.notify_damage(session_id, window_id, pane_id);
2553                                }
2554                            }
2555                        }
2556                    }
2557                    FrameLoopCommand::EvictViewer { viewer_id } => {
2558                        if let Some(pos) = viewers.iter().position(|v| v.id == viewer_id) {
2559                            let v = viewers.remove(pos);
2560                            v.cancel.cancel();
2561                            stdin_queues.lock().remove(&viewer_id);
2562                            debug!(viewer_id, session_id, "Viewer evicted by command");
2563                            // When the last viewer disconnects, reap private panes.
2564                            // Private panes are client-owned (ChatApp renders them locally);
2565                            // retaining them server-side would show blank "window-N" tabs
2566                            // to the next viewer who connects.
2567                            if viewers.is_empty() {
2568                                use crate::tui::state::PaneBackend;
2569                                let mut st = state.write().await;
2570                                if let Some(sess) = st.session_mut(session_id) {
2571                                    for win in &mut sess.windows {
2572                                        win.panes.retain(|p| p.backend != PaneBackend::Private);
2573                                    }
2574                                }
2575                                has_damage = true;
2576                                prev_cells.clear();
2577                            }
2578                        }
2579                    }
2580                    FrameLoopCommand::SpawnProcess { pane_id, process } => {
2581                        // Kill any existing process on this pane before inserting
2582                        // the new one — prevents orphaned threads when a pane is
2583                        // reused (e.g. close + reopen with same ID).
2584                        if let Some(old) = processes.remove(&pane_id) {
2585                            let _ = old.input_tx.try_send(
2586                                super::process::ProcessInput::Kill,
2587                            );
2588                        }
2589                        processes.insert(pane_id, process);
2590                    }
2591                    FrameLoopCommand::Resize { pane_id, cols, rows } => {
2592                        if let Some(proc) = processes.get(&pane_id) {
2593                            let _ = proc.input_tx.try_send(
2594                                super::process::ProcessInput::Resize { cols, rows },
2595                            );
2596                        }
2597                    }
2598                    FrameLoopCommand::KillProcess { pane_id } => {
2599                        if let Some(proc) = processes.remove(&pane_id) {
2600                            let _ = proc.input_tx.try_send(
2601                                super::process::ProcessInput::Kill,
2602                            );
2603                        }
2604                    }
2605                    FrameLoopCommand::MarkPanePrivate { .. } => {
2606                        // Just trigger a full frame redraw; PaneBackend::Private is
2607                        // already set on the pane in TuiState by handle_create_private_pane.
2608                        has_damage = true;
2609                        prev_cells.clear();
2610                    }
2611                }
2612            }
2613
2614            Ok(event) = event_rx.recv() => {
2615                match event {
2616                    TuiEvent::Damage { session_id: sid, .. } if sid == session_id => {
2617                        has_damage = true;
2618                    }
2619                    TuiEvent::WindowClosed { session_id: sid, .. } if sid == session_id => {
2620                        has_damage = true;
2621                        prev_cells.clear(); // full frame after window change
2622                    }
2623                    TuiEvent::WindowFocused { session_id: sid, .. } if sid == session_id => {
2624                        has_damage = true;
2625                        prev_cells.clear(); // full frame so client repaints new window content
2626                    }
2627                    TuiEvent::PaneClosed { session_id: sid, .. } if sid == session_id => {
2628                        has_damage = true;
2629                    }
2630                    _ => {}
2631                }
2632            }
2633
2634            _ = interval.tick() => {
2635                // Poll attached processes for output and feed through VTE parser
2636                {
2637                    let process_pane_ids: Vec<u32> = processes.keys().copied().collect();
2638                    let mut dead_pane_ids: Vec<u32> = Vec::new();
2639                    for pane_id in process_pane_ids {
2640                        let proc = match processes.get_mut(&pane_id) {
2641                            Some(p) => p,
2642                            None => continue,
2643                        };
2644                        let mut got_output = false;
2645                        loop {
2646                            match proc.stdout_rx.try_recv() {
2647                                Ok(data) => {
2648                                    let mut tui_state = state.write().await;
2649                                    if let Some(session) = tui_state.session_mut(session_id) {
2650                                        // Search all windows for the pane
2651                                        for window in &mut session.windows {
2652                                            if let Some(idx) = window.panes.iter().position(|p| p.id == pane_id) {
2653                                                let old_title = window.panes[idx].title.clone();
2654                                                {
2655                                                    let mut performer = vte_parser::PanePerformer::new(&mut window.panes[idx]);
2656                                                    performer.feed(&data);
2657                                                }
2658                                                // Propagate OSC title changes (bash, vim, etc.) to window name.
2659                                                let new_title = window.panes[idx].title.clone();
2660                                                if !new_title.is_empty() && new_title != old_title {
2661                                                    window.name = new_title;
2662                                                }
2663                                                got_output = true;
2664                                                break;
2665                                            }
2666                                        }
2667                                    }
2668                                }
2669                                Err(tokio::sync::mpsc::error::TryRecvError::Empty) => break,
2670                                Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => {
2671                                    // Process has exited — schedule cleanup
2672                                    dead_pane_ids.push(pane_id);
2673                                    break;
2674                                }
2675                            }
2676                        }
2677                        if got_output {
2678                            has_damage = true;
2679                        }
2680                    }
2681                    for pane_id in dead_pane_ids {
2682                        debug!(pane_id, session_id, "Process exited, removing from frame loop");
2683                        processes.remove(&pane_id);
2684                        // Auto-close the pane in TuiState.
2685                        // If it's the last pane, close its window instead.
2686                        let mut tui_state = state.write().await;
2687                        let sid = tui_state.sessions.last().map(|s| s.id).unwrap_or(0);
2688                        if !tui_state.close_pane(sid, pane_id) {
2689                            // Last pane — find and close the containing window.
2690                            let win_id = tui_state.session(sid)
2691                                .and_then(|sess| sess.windows.iter()
2692                                    .find(|w| w.panes.iter().any(|p| p.id == pane_id))
2693                                    .map(|w| w.id))
2694                                .unwrap_or(0);
2695                            if win_id != 0 {
2696                                tui_state.close_window(sid, win_id);
2697                            }
2698                        }
2699                        has_damage = true;
2700                    }
2701                }
2702
2703                // Check if delayed initial frame timer has fired
2704                if let Some(t) = initial_frame_at {
2705                    if tokio::time::Instant::now() >= t {
2706                        has_damage = true;
2707                        initial_frame_at = None;
2708                        // Clear prev_cells so the diff is computed from scratch (full frame).
2709                        // This ensures newly-joined viewers (e.g. ANSI-mode Playwright viewer
2710                        // joining after a Capnp-mode producer has already been running) receive
2711                        // a complete frame rather than an empty incremental diff.
2712                        prev_cells.clear();
2713                        debug!(session_id, "Initial frame timer fired, sending first frame");
2714                        // DEBUG: dump row 0 symbols from pane buffer
2715                        {
2716                            let s = state.read().await;
2717                            if let Some(sess) = s.session(session_id) {
2718                                if let Some(win) = sess.active_window() {
2719                                    if let Some(pane) = win.active_pane() {
2720                                        let buf = pane.active_buffer();
2721                                        let row0: String = (0..buf.buffer.area().width.min(40))
2722                                            .map(|x| buf.buffer[(x, 0)].symbol().chars().next().unwrap_or('?'))
2723                                            .collect();
2724                                        debug!(session_id, row0 = %row0, "Pane buffer row0 at initial frame fire");
2725                                    }
2726                                }
2727                            }
2728                        }
2729                    }
2730                }
2731                // Periodic heartbeat: re-publish full frame so late-joining viewers
2732                // always receive current state within 2 seconds of subscribing.
2733                let now = tokio::time::Instant::now();
2734                if !viewers.is_empty() && now >= heartbeat_at {
2735                    has_damage = true;
2736                    prev_cells.clear(); // full frame for any newly-joined viewer
2737                    heartbeat_at = now + std::time::Duration::from_secs(2);
2738                    debug!(session_id, "Heartbeat: publishing full frame");
2739                }
2740
2741                if !has_damage || viewers.is_empty() {
2742                    continue;
2743                }
2744                has_damage = false;
2745
2746                // Read state and compute diff
2747                let mut tui_state = state.write().await;
2748                let generation = tui_state.generation();
2749
2750                let (ansi_bytes, capnp_bytes) = {
2751                    use crate::tui::state::PaneBackend;
2752
2753                    let session = match tui_state.session(session_id) {
2754                        Some(s) => s,
2755                        None => continue,
2756                    };
2757                    let window = match session.active_window() {
2758                        Some(w) => w,
2759                        None => continue,
2760                    };
2761                    let pane = match window.active_pane() {
2762                        Some(p) => p,
2763                        None => continue,
2764                    };
2765                    let pane_id = pane.id;
2766
2767                    // Private panes: publish a [PRIVATE] placeholder instead of real cells.
2768                    if pane.backend == PaneBackend::Private {
2769                        let needs_ansi = viewers.iter().any(|v| v.display_mode == DisplayMode::Ansi);
2770                        let ansi = if needs_ansi {
2771                            let (cols, rows) = pane.size();
2772                            Some(private_placeholder_ansi(cols, rows))
2773                        } else {
2774                            None
2775                        };
2776                        // Don't snapshot private pane cells; always send a full frame next time.
2777                        prev_cells.remove(&pane_id);
2778                        // capnp path not implemented for private panes (browser path uses ANSI)
2779                        (ansi, None::<Vec<u8>>)
2780                    } else {
2781                        let buf = pane.active_buffer();
2782                        let prev = prev_cells.get(&pane_id).map(Vec::as_slice);
2783                        let frame_diff = diff::compute_diff(buf, prev, generation, pane.cursor);
2784
2785                        // Encode for each display mode in use
2786                        let needs_ansi = viewers.iter().any(|v| v.display_mode == DisplayMode::Ansi);
2787                        let needs_capnp = viewers.iter().any(|v| v.display_mode == DisplayMode::Capnp);
2788
2789                        let ansi = if needs_ansi { Some(diff::encode_ansi(&frame_diff)) } else { None };
2790                        let capnp = if needs_capnp { Some(diff::encode_capnp(&frame_diff, pane_id)) } else { None };
2791
2792                        // Snapshot cells for next incremental diff
2793                        let area = buf.buffer.area();
2794                        let cells: Vec<Cell> = (0..area.height)
2795                            .flat_map(|y| (0..area.width).map(move |x| (x, y)))
2796                            .map(|(x, y)| buf.buffer[(x, y)].clone())
2797                            .collect();
2798                        prev_cells.insert(pane_id, cells);
2799
2800                        (ansi, capnp)
2801                    }
2802                };
2803
2804                // Clear damage on the active pane
2805                if let Some(session) = tui_state.session_mut(session_id) {
2806                    if let Some(window) = session.active_window_mut() {
2807                        if let Some(pane) = window.active_pane_mut() {
2808                            pane.active_buffer_mut().clear_damage();
2809                        }
2810                    }
2811                }
2812
2813                drop(tui_state);
2814
2815                // Publish to each viewer
2816                let mut evict_ids = Vec::new();
2817                for viewer in viewers.iter_mut() {
2818                    let data = match viewer.display_mode {
2819                        DisplayMode::Ansi => ansi_bytes.as_deref(),
2820                        DisplayMode::Capnp | DisplayMode::Structured => capnp_bytes.as_deref(), // Structured falls back to capnp encoding
2821                    };
2822                    let data = match data {
2823                        Some(d) if !d.is_empty() => d,
2824                        _ => {
2825                            debug!(viewer_id = viewer.id, mode = ?viewer.display_mode, "No data for viewer (empty or None)");
2826                            continue;
2827                        }
2828                    };
2829
2830                    debug!(viewer_id = viewer.id, data_len = data.len(), "Publishing frame to viewer");
2831                    let publish_result = tokio::time::timeout(
2832                        std::time::Duration::from_millis(100),
2833                        viewer.publisher.try_publish_data(data, 30.0),
2834                    ).await;
2835                    match publish_result {
2836                        Ok(Ok(true)) => {
2837                            viewer.consecutive_skips = 0;
2838                            debug!(viewer_id = viewer.id, "Frame published successfully");
2839                        }
2840                        Ok(Ok(false)) => {
2841                            viewer.consecutive_skips += 1;
2842                            if viewer.consecutive_skips >= MAX_CONSECUTIVE_SKIPS {
2843                                warn!(viewer_id = viewer.id, "Evicting slow viewer");
2844                                evict_ids.push(viewer.id);
2845                            }
2846                        }
2847                        Ok(Err(e)) => {
2848                            debug!(viewer_id = viewer.id, error = %e, "Viewer publish error");
2849                            evict_ids.push(viewer.id);
2850                        }
2851                        Err(_) => {
2852                            warn!(viewer_id = viewer.id, "Viewer publish timed out (100ms)");
2853                            viewer.consecutive_skips += 1;
2854                            if viewer.consecutive_skips >= MAX_CONSECUTIVE_SKIPS {
2855                                evict_ids.push(viewer.id);
2856                            }
2857                        }
2858                    }
2859                }
2860
2861                // Evict slow/errored viewers
2862                for id in &evict_ids {
2863                    if let Some(pos) = viewers.iter().position(|v| v.id == *id) {
2864                        let v = viewers.remove(pos);
2865                        v.cancel.cancel();
2866                    }
2867                }
2868            }
2869        }
2870    }
2871}
2872
2873#[cfg(test)]
2874#[allow(clippy::expect_used, clippy::unwrap_used)]
2875#[cfg(test)]
2876mod tests {
2877    use super::*;
2878
2879    // ── W1.3: the Federate TUI client-class consumer gate ─────────────────
2880
2881    #[cfg(feature = "postgres")]
2882    const GATE_HOST: &str = "https://tui-gate.test";
2883    #[cfg(feature = "postgres")]
2884    const GATE_TUI_CLIENT: &str = "hyprstream-tui-staging";
2885
2886    #[cfg(feature = "postgres")]
2887    fn gate_service(configured: bool) -> TuiService {
2888        TuiService::new(
2889            Arc::new(RwLock::new(TuiState::new(80, 24, 1000))),
2890            TransportConfig::ipc(std::path::PathBuf::from(
2891                "/tmp/hyprstream-tui-gate-test.sock",
2892            )),
2893            SigningKey::from_bytes(&[9; 32]),
2894        )
2895        .with_expected_audience(GATE_HOST.into())
2896        .with_federate_tui_client(configured.then(|| GATE_TUI_CLIENT.to_owned()))
2897    }
2898
2899    #[cfg(feature = "postgres")]
2900    fn gate_claims(scopes: &str) -> hyprstream_rpc::auth::Claims {
2901        use base64::Engine as _;
2902        let ed = ed25519_dalek::SigningKey::from_bytes(&[61; 32])
2903            .verifying_key()
2904            .to_bytes();
2905        let pq = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk_bytes(
2906            &hyprstream_rpc::crypto::pq::ml_dsa_sk_from_seed(&[62; 32]),
2907        );
2908        let now = chrono::Utc::now().timestamp();
2909        let mut claims = hyprstream_rpc::auth::Claims::new(
2910            "did:plc:abcdefghijklmnopqrstuvwx".into(),
2911            now,
2912            now + 60,
2913        )
2914        .with_issuer(GATE_HOST.into())
2915        .with_audience(Some(GATE_HOST.into()))
2916        .with_client_id(GATE_TUI_CLIENT)
2917        .with_tenant("tenant-a".into())
2918        .with_sid("tui-sid")
2919        .with_scope(Some(scopes.to_owned()))
2920        .with_cnf_jwk(&ed)
2921        .with_federate_tui_markers(
2922            base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(&pq),
2923            crate::services::oauth::federate_source::ISSUER.into(),
2924            "opaque-oidc-subject".into(),
2925        );
2926        claims.jti = Some("tui-jti".into());
2927        claims
2928    }
2929
2930    #[cfg(feature = "postgres")]
2931    #[test]
2932    fn federate_tui_gate_admits_the_configured_class_with_the_required_scope() {
2933        let service = gate_service(true);
2934        let claims = gate_claims("connect:tui:session query:tui:session write:tui:session");
2935        for required in [
2936            "connect:tui:session",
2937            "query:tui:session",
2938            "write:tui:session",
2939        ] {
2940            service
2941                .admit_federate_tui(&claims, required)
2942                .expect(required);
2943        }
2944    }
2945
2946    #[cfg(feature = "postgres")]
2947    #[test]
2948    fn federate_tui_gate_default_denies_when_unconfigured() {
2949        let service = gate_service(false);
2950        let claims = gate_claims("connect:tui:session");
2951        assert!(service
2952            .admit_federate_tui(&claims, "connect:tui:session")
2953            .is_err());
2954    }
2955
2956    #[cfg(feature = "postgres")]
2957    #[test]
2958    fn federate_tui_gate_denies_a_missing_required_scope() {
2959        let service = gate_service(true);
2960        let claims = gate_claims("connect:tui:session");
2961        assert!(service
2962            .admit_federate_tui(&claims, "connect:tui:session")
2963            .is_ok());
2964        assert!(service
2965            .admit_federate_tui(&claims, "write:tui:session")
2966            .is_err());
2967        assert!(service
2968            .admit_federate_tui(&claims, "query:tui:session")
2969            .is_err());
2970    }
2971
2972    #[cfg(feature = "postgres")]
2973    #[test]
2974    fn federate_tui_gate_denies_mixed_markers_and_class_substitution() {
2975        let service = gate_service(true);
2976        let mut mixed = gate_claims("connect:tui:session");
2977        mixed.hs_profile = Some("federate-session-v1".into());
2978        assert!(service
2979            .admit_federate_tui(&mixed, "connect:tui:session")
2980            .is_err());
2981        let mut wrong_client = gate_claims("connect:tui:session");
2982        wrong_client.client_id = Some("other-client".into());
2983        assert!(service
2984            .admit_federate_tui(&wrong_client, "connect:tui:session")
2985            .is_err());
2986    }
2987
2988    #[cfg(feature = "postgres")]
2989    #[test]
2990    fn federate_tui_class_pin_holds_with_all_markers_stripped() {
2991        let service = gate_service(true);
2992        // Every TUI marker stripped; the class pin (iss + configured
2993        // client_id) still classifies the credential, and the gate denies
2994        // it for the incomplete marker set.
2995        let mut stripped = gate_claims("connect:tui:session");
2996        stripped.hs_tui_profile = None;
2997        stripped.hs_tui_signer_pq_key_v1 = None;
2998        stripped.hs_tui_source_issuer_v1 = None;
2999        stripped.hs_tui_source_subject_v1 = None;
3000        assert!(!stripped.has_federate_tui_profile_marker());
3001        assert!(service.is_federate_tui_classified(&stripped));
3002        assert!(service
3003            .admit_federate_tui(&stripped, "connect:tui:session")
3004            .is_err());
3005        // A credential naming a different client with no markers is NOT
3006        // classified and keeps the legacy path (gate never applies).
3007        let mut ordinary = gate_claims("connect:tui:session");
3008        ordinary.hs_tui_profile = None;
3009        ordinary.hs_tui_signer_pq_key_v1 = None;
3010        ordinary.hs_tui_source_issuer_v1 = None;
3011        ordinary.hs_tui_source_subject_v1 = None;
3012        ordinary.client_id = Some("ordinary-local-client".into());
3013        assert!(!service.is_federate_tui_classified(&ordinary));
3014        // The pin requires the issuer to equal the service audience.
3015        let mut wrong_iss = stripped.clone();
3016        wrong_iss.iss = "https://other-cell.example".into();
3017        assert!(!service.is_federate_tui_classified(&wrong_iss));
3018        // Unconfigured service: the marker set still classifies. (The
3019        // stripped-shape behavior without the per-service wiring depends on
3020        // the process-global class reservation, which the dispatch fixture
3021        // w13 covers with the reservation installed.)
3022        let unconfigured = gate_service(false);
3023        assert!(unconfigured.is_federate_tui_classified(&gate_claims("connect:tui:session")));
3024    }
3025
3026    #[cfg(feature = "postgres")]
3027    #[test]
3028    fn federate_tui_scope_map_covers_the_operation_vocabulary() {
3029        fn required(build: impl Fn(&mut tui_capnp::tui_request::Builder<'_>)) -> &'static str {
3030            let mut msg = Builder::new_default();
3031            let mut req = msg.init_root::<tui_capnp::tui_request::Builder<'_>>();
3032            req.set_id(1);
3033            build(&mut req);
3034            federate_tui_required_scope(&req.reborrow_as_reader()).unwrap()
3035        }
3036        assert_eq!(
3037            required(|r| {
3038                r.reborrow().init_connect();
3039            }),
3040            "connect:tui:session"
3041        );
3042        assert_eq!(required(|r| r.set_snapshot(0)), "query:tui:session");
3043        assert_eq!(required(|r| r.set_list_windows(0)), "query:tui:session");
3044        assert_eq!(required(|r| r.set_poll_stdin(1)), "query:tui:session");
3045        assert_eq!(
3046            required(|r| {
3047                r.reborrow().init_send_input();
3048            }),
3049            "write:tui:session"
3050        );
3051        assert_eq!(
3052            required(|r| {
3053                r.reborrow().init_spawn_shell();
3054            }),
3055            "write:tui:session"
3056        );
3057        assert_eq!(required(|r| r.set_disconnect(1)), "write:tui:session");
3058    }
3059
3060    #[test]
3061    fn service_clients_fail_closed_without_a_nonempty_service_token() {
3062        assert!(nonempty_service_token(None).is_err());
3063        assert!(nonempty_service_token(Some(" \t".to_owned())).is_err());
3064        assert_eq!(
3065            nonempty_service_token(Some("bound.jwt".to_owned())).unwrap(),
3066            "bound.jwt"
3067        );
3068    }
3069
3070    #[test]
3071    fn test_display_mode() {
3072        assert_ne!(DisplayMode::Ansi, DisplayMode::Capnp);
3073        assert_ne!(DisplayMode::Capnp, DisplayMode::Structured);
3074    }
3075
3076    /// #356: the PTY StreamInfo must carry the producer's networked reach so a
3077    /// cross-process viewer dials the TUI service's QUIC `/moq` endpoint instead
3078    /// of its own local moq UDS plane. This exercises the exact encode path
3079    /// `build_connect_response` uses — `ProducerReachConfig::reach()` → `Destination::write_to`
3080    /// into the tui StreamInfo capnp `announcedAt` field — and reads it back through
3081    /// the generated `tui_client::StreamInfo` decoder, asserting the Quic dial params
3082    /// survive the round-trip intact (the chat-inference fix relied on the same
3083    /// reach being present; the bug was the TUI StreamInfo not carrying it).
3084    #[test]
3085    fn pty_stream_info_carries_dialable_reach() {
3086        use hyprstream_rpc::capnp::FromCapnp;
3087        use hyprstream_rpc::moq_stream::{NodeStreamReach, ProducerReachConfig};
3088
3089        let addr: std::net::SocketAddr = "127.0.0.1:4433".parse().expect("addr");
3090        let server_identity = hyprstream_rpc::stream_info::MoqlServerIdentity {
3091            did: "did:at9p:tui".to_owned(),
3092            epoch: 7,
3093            head_digest: vec![0x22; 64],
3094            expires_at_unix_ms: hyprstream_rpc::envelope::current_timestamp() + 60_000,
3095            ed25519: [0x23; 32],
3096            ml_dsa65: vec![0x24; 1952],
3097        };
3098        let reach = ProducerReachConfig {
3099            moql_server_identity: Some(server_identity.clone()),
3100            relay_moql_server_identity: None,
3101            iroh_node_id: None,
3102            quic_reach: Some(NodeStreamReach {
3103                addr,
3104                server_name: "localhost".to_owned(),
3105                cert_hashes: vec![[0x11u8; 32]],
3106            }),
3107            relay: None,
3108        }
3109        .reach();
3110        assert!(
3111            !reach.is_empty(),
3112            "local ProducerReachConfig must produce a dialable reach"
3113        );
3114
3115        // Build a tui StreamInfo capnp the same way build_connect_response does.
3116        let mut msg = Builder::new_default();
3117        {
3118            let mut si = msg.init_root::<tui_capnp::stream_info::Builder<'_>>();
3119            si.set_topic("deadbeef");
3120            si.set_mac_key(&[7u8; 32]);
3121            si.set_broadcast_path("local/streams/deadbeef");
3122            let mut witness = si.reborrow().init_moql_server_identity();
3123            hyprstream_rpc::capnp::ToCapnp::write_to(&server_identity, &mut witness);
3124            let mut reach_list = si.reborrow().init_announced_at(reach.len() as u32);
3125            for (j, dest) in reach.iter().enumerate() {
3126                let mut db = reach_list.reborrow().get(j as u32);
3127                hyprstream_rpc::capnp::ToCapnp::write_to(dest, &mut db);
3128            }
3129        }
3130        let mut buf = Vec::new();
3131        serialize::write_message(&mut buf, &msg).expect("serialize");
3132
3133        // Decode through the generated client StreamInfo and assert the reach
3134        // carries the Quic dial parameters intact.
3135        let reader =
3136            serialize::read_message(&buf[..], capnp::message::ReaderOptions::new()).expect("read");
3137        let si_reader = reader
3138            .get_root::<tui_capnp::stream_info::Reader<'_>>()
3139            .expect("root");
3140        let decoded =
3141            hyprstream_rpc_std::tui_client::StreamInfo::read_from(si_reader).expect("decode");
3142
3143        assert_eq!(
3144            decoded.announced_at.len(),
3145            reach.len(),
3146            "decoded StreamInfo.announcedAt must round-trip the producer reach"
3147        );
3148        // The round-tripped reach must match the service-local reach exactly.
3149        assert_eq!(
3150            decoded.announced_at, reach,
3151            "decoded StreamInfo.announcedAt must round-trip the producer reach exactly"
3152        );
3153        assert_eq!(
3154            decoded.moql_server_identity, server_identity,
3155            "decoded TUI StreamInfo must retain its resolver-verified server witness"
3156        );
3157        match &decoded.announced_at[0].transport {
3158            hyprstream_rpc::stream_info::TransportConfig::Quic(q) => {
3159                assert_eq!(q.addr, "127.0.0.1:4433");
3160                assert_eq!(q.server_name, "localhost");
3161                assert_eq!(q.cert_hashes.len(), 1);
3162            }
3163            other => panic!("expected a Quic reach, got {other:?}"),
3164        }
3165    }
3166}