1use 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
31pub(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#[derive(Debug, Clone, Copy, PartialEq, Eq)]
72pub enum DisplayMode {
73 Ansi,
74 Capnp,
75 Structured,
76}
77
78struct ViewerHandle {
89 id: u32,
91 publisher: AnyStreamPublisher,
93 stdin_publisher: Option<AnyStreamPublisher>,
96 display_mode: DisplayMode,
98 consecutive_skips: u32,
100 cancel: CancellationToken,
102}
103
104pub(crate) struct PendingViewer {
109 id: u32,
110 #[allow(dead_code)]
111 session_id: u32,
112 display_mode: DisplayMode,
113 cancel: CancellationToken,
114 stream_ctxs: Vec<StreamContext>,
116}
117
118#[allow(dead_code)]
124pub(crate) enum FrameLoopCommand {
125 RegisterViewer(PendingViewer),
127 SendInput { viewer_id: u32, data: Vec<u8> },
129 EvictViewer { viewer_id: u32 },
131 SpawnProcess {
133 pane_id: u32,
134 process: super::process::PaneProcess,
135 },
136 Resize { pane_id: u32, cols: u16, rows: u16 },
138 KillProcess { pane_id: u32 },
140 MarkPanePrivate { pane_id: u32 },
142}
143
144pub(crate) type CommandSender = tokio::sync::mpsc::UnboundedSender<FrameLoopCommand>;
146pub(crate) type CommandReceiver = tokio::sync::mpsc::UnboundedReceiver<FrameLoopCommand>;
147
148type SessionRegistry = Arc<RwLock<HashMap<u32, (CommandSender, CancellationToken)>>>;
151
152type StdinQueues = Arc<parking_lot::Mutex<HashMap<u32, std::collections::VecDeque<Vec<u8>>>>>;
160
161pub struct TuiService {
172 state: Arc<RwLock<TuiState>>,
174 next_viewer_id: AtomicU32,
176 transport: TransportConfig,
178 signing_key: SigningKey,
180 reach_config: hyprstream_rpc::moq_stream::ProducerReachConfigHandle,
182 moq_origin: hyprstream_rpc::moq_stream::MoqStreamOriginHandle,
184 sessions: SessionRegistry,
186 stdin_queues: StdinQueues,
188 policy_client: Option<PolicyClient>,
190 expected_audience: Option<String>,
192 jwt_key_source: Option<std::sync::Arc<dyn hyprstream_rpc::auth::JwtKeySource>>,
194 vfs_ns: Option<std::sync::Arc<hyprstream_vfs::Namespace>>,
196 vfs_subject: Option<hyprstream_rpc::Subject>,
198 vfs_proxy_tx: std::sync::OnceLock<tokio::sync::mpsc::Sender<hyprstream_vfs::proxy::VfsRequest>>,
201 federate_tui_client: Option<String>,
208}
209
210impl TuiService {
211 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 pub fn with_policy_client(mut self, client: PolicyClient) -> Self {
240 self.policy_client = Some(client);
241 self
242 }
243
244 pub fn with_expected_audience(mut self, audience: String) -> Self {
246 self.expected_audience = Some(audience);
247 self
248 }
249
250 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 pub fn with_federate_tui_client(mut self, client: Option<String>) -> Self {
262 self.federate_tui_client = client;
263 self
264 }
265
266 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 #[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 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 #[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 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 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 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 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 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 let mut resized_pane: Option<u32> = None;
436 if cols > 0 && rows > 0 {
437 state.default_cols = cols;
438 state.default_rows = rows;
439 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 let reach_config = self.reach_config.read().clone();
487 let make_stream_ctx = |label: &str| -> Result<StreamContext> {
488 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 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 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 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 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 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 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 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 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 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 {
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 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 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 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 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 .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 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 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 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 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 ®istry,
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 {
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 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 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 {
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 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 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 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 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 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 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 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 {
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 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 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 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 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 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 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#[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 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 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, ®istry_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
2300const MAX_CONSECUTIVE_SKIPS: u32 = 30;
2306
2307fn private_placeholder_ansi(cols: u16, rows: u16) -> Vec<u8> {
2313 let label = "[PRIVATE]";
2314 let mut out = Vec::with_capacity(256);
2315 out.extend_from_slice(b"\x1b[2J\x1b[H");
2317 let row = (rows / 2).max(1);
2319 let col = cols.saturating_sub(label.len() as u16) / 2 + 1;
2320 out.extend_from_slice(format!("\x1b[{};{}H\x1b[2;37m{}\x1b[0m", row, col, label).as_bytes());
2322 out
2323}
2324
2325pub(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 let mut viewers: Vec<ViewerHandle> = Vec::new();
2348 let mut processes: HashMap<u32, super::process::PaneProcess> = HashMap::new();
2350 let mut prev_cells: HashMap<u32, Vec<Cell>> = HashMap::new();
2352 let mut has_damage = false;
2353 let mut initial_frame_at: Option<tokio::time::Instant> = None;
2356 let mut heartbeat_at = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
2359
2360 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 Some(cmd) = cmd_rx.recv() => {
2379 match cmd {
2380 FrameLoopCommand::RegisterViewer(pending) => {
2381 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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(); }
2623 TuiEvent::WindowFocused { session_id: sid, .. } if sid == session_id => {
2624 has_damage = true;
2625 prev_cells.clear(); }
2627 TuiEvent::PaneClosed { session_id: sid, .. } if sid == session_id => {
2628 has_damage = true;
2629 }
2630 _ => {}
2631 }
2632 }
2633
2634 _ = interval.tick() => {
2635 {
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 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 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 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 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 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 if let Some(t) = initial_frame_at {
2705 if tokio::time::Instant::now() >= t {
2706 has_damage = true;
2707 initial_frame_at = None;
2708 prev_cells.clear();
2713 debug!(session_id, "Initial frame timer fired, sending first frame");
2714 {
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 let now = tokio::time::Instant::now();
2734 if !viewers.is_empty() && now >= heartbeat_at {
2735 has_damage = true;
2736 prev_cells.clear(); 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 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 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 prev_cells.remove(&pane_id);
2778 (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 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 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 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 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(), };
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 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 #[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 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 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 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 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 #[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 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 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 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}