1use bytes::Bytes;
2use futures_util::{SinkExt, StreamExt};
3use infinity_agent_core::ThreadId;
4use infinity_agent_core::message::{
5 InputMessage, InputMessageContent, SyntheticKind, TaggedSyntheticKind,
6};
7use infinity_protocol::{ClientMessage, DaemonMessage, length_delimited_codec};
8use infinity_provider_protocol::message::UserContent;
9use tokio::net::UnixStream;
10use tokio::sync::mpsc;
11use tokio_util::codec::Framed;
12
13use crate::session::SharedSessionManager;
14
15async fn list_directory_completions(input: &str) -> Vec<String> {
20 use std::path::Path;
21
22 let path = Path::new(input);
23 let (dir, prefix) = if input.ends_with('/') {
24 (path.to_owned(), "".to_owned())
25 } else {
26 (
27 path.parent().unwrap_or(Path::new("/")).to_owned(),
28 path.file_name()
29 .and_then(|n| n.to_str())
30 .unwrap_or("")
31 .to_owned(),
32 )
33 };
34
35 let Ok(mut read_dir) = tokio::fs::read_dir(&dir).await else {
36 return Vec::new();
37 };
38
39 let mut entries: Vec<String> = Vec::new();
40 while let Ok(Some(e)) = read_dir.next_entry().await {
41 let Some(name) = e.file_name().to_str().map(|s| s.to_owned()) else {
42 continue;
43 };
44 if !name.starts_with(&*prefix) {
45 continue;
46 }
47 let full = dir.join(&name);
48 match tokio::fs::metadata(&full).await {
49 Ok(m) if m.is_dir() => entries.push(format!("{}/", full.display())),
50 _ => {} }
52 }
53 entries.sort_by(|a, b| a.trim_end_matches('/').cmp(b.trim_end_matches('/')));
54 entries
55}
56
57fn is_remote_session(session_id: &str) -> Option<(&str, &str)> {
59 session_id.split_once('/')
60}
61
62fn prefix_thread_id(thread_id: Option<String>, remote_name: &str) -> Option<String> {
63 thread_id.map(|id| format!("{remote_name}/{id}"))
64}
65
66fn prefix_daemon_message(msg: DaemonMessage, remote_name: &str) -> DaemonMessage {
67 match msg {
68 DaemonMessage::Connected {
69 session_id,
70 thread_id,
71 model_name,
72 context_window,
73 title,
74 total_tokens_used,
75 provider_id,
76 } => DaemonMessage::Connected {
77 session_id: format!("{remote_name}/{session_id}"),
78 thread_id: format!("{remote_name}/{thread_id}"),
79 model_name,
80 context_window,
81 title,
82 total_tokens_used,
83 provider_id,
84 },
85 DaemonMessage::StartOutput { thread_id } => DaemonMessage::StartOutput {
86 thread_id: prefix_thread_id(thread_id, remote_name),
87 },
88 DaemonMessage::TextChunk { thread_id, chunk } => DaemonMessage::TextChunk {
89 thread_id: prefix_thread_id(thread_id, remote_name),
90 chunk,
91 },
92 DaemonMessage::ToolCall {
93 name,
94 args,
95 thread_id,
96 display_as,
97 } => DaemonMessage::ToolCall {
98 name,
99 args,
100 thread_id: prefix_thread_id(thread_id, remote_name),
101 display_as,
102 },
103 DaemonMessage::ToolResult {
104 segments,
105 thread_id,
106 } => DaemonMessage::ToolResult {
107 segments,
108 thread_id: prefix_thread_id(thread_id, remote_name),
109 },
110 DaemonMessage::Info { thread_id, text } => DaemonMessage::Info {
111 thread_id: prefix_thread_id(thread_id, remote_name),
112 text,
113 },
114 DaemonMessage::ResponseDone {
115 thread_id,
116 token_usage,
117 } => DaemonMessage::ResponseDone {
118 thread_id: prefix_thread_id(thread_id, remote_name),
119 token_usage,
120 },
121 DaemonMessage::UserInputEcho { thread_id, text } => DaemonMessage::UserInputEcho {
122 thread_id: prefix_thread_id(thread_id, remote_name),
123 text,
124 },
125 DaemonMessage::SubscriptionEvent {
126 name,
127 text,
128 thread_id,
129 } => DaemonMessage::SubscriptionEvent {
130 name,
131 text,
132 thread_id: prefix_thread_id(thread_id, remote_name),
133 },
134 DaemonMessage::OAuthRequired {
135 thread_id,
136 auth_url,
137 } => DaemonMessage::OAuthRequired {
138 thread_id: prefix_thread_id(thread_id, remote_name),
139 auth_url,
140 },
141 DaemonMessage::UserChoiceRequired {
142 thread_id,
143 id,
144 prompt,
145 choices,
146 default,
147 } => DaemonMessage::UserChoiceRequired {
148 thread_id: prefix_thread_id(thread_id, remote_name),
149 id,
150 prompt,
151 choices,
152 default,
153 },
154 DaemonMessage::ThinkingStart { thread_id } => DaemonMessage::ThinkingStart {
155 thread_id: prefix_thread_id(thread_id, remote_name),
156 },
157 DaemonMessage::ThinkingEnd { thread_id } => DaemonMessage::ThinkingEnd {
158 thread_id: prefix_thread_id(thread_id, remote_name),
159 },
160 DaemonMessage::ThinkingChunk { thread_id, chunk } => DaemonMessage::ThinkingChunk {
161 thread_id: prefix_thread_id(thread_id, remote_name),
162 chunk,
163 },
164 DaemonMessage::CompactionApplied { thread_id } => DaemonMessage::CompactionApplied {
165 thread_id: prefix_thread_id(thread_id, remote_name),
166 },
167 DaemonMessage::ModelSwitched {
168 thread_id,
169 model_name,
170 context_window,
171 provider_id,
172 } => DaemonMessage::ModelSwitched {
173 thread_id: format!("{remote_name}/{thread_id}"),
174 model_name,
175 context_window,
176 provider_id,
177 },
178 DaemonMessage::Error { thread_id, text } => DaemonMessage::Error {
179 thread_id: prefix_thread_id(thread_id, remote_name),
180 text,
181 },
182 DaemonMessage::ViewUpdate {
183 thread_id,
184 view_type,
185 content,
186 } => DaemonMessage::ViewUpdate {
187 thread_id: prefix_thread_id(thread_id, remote_name),
188 view_type,
189 content,
190 },
191 DaemonMessage::Replay {
192 history,
193 pending_choices,
194 views,
195 in_progress,
196 } => DaemonMessage::Replay {
197 history: history
198 .into_iter()
199 .map(|m| prefix_daemon_message(m, remote_name))
200 .collect(),
201 pending_choices: pending_choices
202 .into_iter()
203 .map(|m| prefix_daemon_message(m, remote_name))
204 .collect(),
205 views,
206 in_progress,
207 },
208 other => other,
209 }
210}
211
212fn strip_id(id: &str, remote_name: &str) -> String {
213 id.strip_prefix(&format!("{remote_name}/"))
214 .unwrap_or(id)
215 .to_owned()
216}
217
218fn strip_client_message(msg: ClientMessage, remote_name: &str) -> ClientMessage {
219 match msg {
220 ClientMessage::UserInput { session_id, text } => ClientMessage::UserInput {
221 session_id: strip_id(&session_id, remote_name),
222 text,
223 },
224 ClientMessage::SoftDetach { session_id } => ClientMessage::SoftDetach {
225 session_id: strip_id(&session_id, remote_name),
226 },
227 ClientMessage::ShutdownSession { session_id } => ClientMessage::ShutdownSession {
228 session_id: strip_id(&session_id, remote_name),
229 },
230 ClientMessage::ArchiveSession { session_id } => ClientMessage::ArchiveSession {
231 session_id: strip_id(&session_id, remote_name),
232 },
233 ClientMessage::SwitchModel { session_id, model } => ClientMessage::SwitchModel {
234 session_id: strip_id(&session_id, remote_name),
235 model,
236 },
237 ClientMessage::TriggerCompaction { session_id } => ClientMessage::TriggerCompaction {
238 session_id: strip_id(&session_id, remote_name),
239 },
240 other => other,
241 }
242}
243
244pub async fn handle_client(stream: UnixStream, session_manager: SharedSessionManager) {
246 let mut framed = Framed::new(stream, length_delimited_codec());
247 let (client_msg_tx, client_msg_rx) = mpsc::unbounded_channel();
248 let (daemon_msg_tx, mut daemon_msg_rx) = mpsc::unbounded_channel();
249
250 let mgr = session_manager.clone();
252 tokio::pin! {
253 let handler = handle_client_channels(client_msg_rx, daemon_msg_tx, mgr);
254 }
255
256 loop {
258 tokio::select! {
259 msg = daemon_msg_rx.recv() => {
260 let Some(msg) = msg else { break
262 };
263 let bytes = Bytes::from(serde_json::to_vec(&msg).expect("bug: failed to serialize DaemonMessage"));
264
265 if let Err(e) = framed.send(bytes).await {
266 tracing::error!("Failed to send daemon message to client: {e}");
267 break;
268 }
269 }
270 _ = &mut handler => {
271 return;
272 }
273 frame = framed.next() => {
274 match frame {
275 Some(Ok(bytes)) => {
276 let Ok(msg) = serde_json::from_slice::<ClientMessage>(&bytes) else { continue };
277 client_msg_tx.send(msg).expect("bug: client message receiver dropped");
278 }
279 Some(Err(e)) => {
280 tracing::error!("Error reading from client socket: {e}");
281 break;
282 }
283 None => {
284 tracing::info!("Client closed the connection");
285 break;
286 }
287 }
288 }
289 }
290 }
291
292 drop(client_msg_tx);
293
294 handler.await;
295}
296
297#[tracing::instrument(skip_all)]
299pub async fn handle_client_channels(
300 mut client_rx: mpsc::UnboundedReceiver<ClientMessage>,
301 daemon_tx: mpsc::UnboundedSender<DaemonMessage>,
302 session_manager: SharedSessionManager,
303) {
304 let (mut client_tx, mut client_tx_rx) = mpsc::unbounded_channel::<DaemonMessage>();
305 let mut attached_session_id: Option<ThreadId> = None;
306 let mut attached_thread_id: Option<ThreadId> = None;
307 let mut remote_proxy_tx: Option<mpsc::UnboundedSender<ClientMessage>> = None;
308 let mut remote_proxy_rx: Option<mpsc::UnboundedReceiver<DaemonMessage>> = None;
309 let mut active_remote_name: Option<String> = None;
310 let mut _booted_rap_servers: Vec<crate::rap_servers::MigrationServer> = Vec::new(); {
314 let mgr = session_manager.lock().await;
315 let remotes = mgr
316 .remote_daemons
317 .as_ref()
318 .map(|rd| rd.remote_info_list())
319 .unwrap_or_default();
320 let default_entry = mgr.catalog.default_entry();
321 let _ = daemon_tx.send(DaemonMessage::Welcome {
322 sessions: mgr.list_sessions(Some(daemon_tx.clone())).await,
323 available_models: mgr
324 .catalog
325 .models()
326 .iter()
327 .map(|m| infinity_protocol::ModelInfo {
328 display_name: m.entry.display_name.clone(),
329 provider_id: m.provider_id.clone(),
330 model_id: m.entry.model_id.clone(),
331 context_window: m.entry.context_window,
332 })
333 .collect(),
334 default_model_name: default_entry.display_name.clone(),
335 default_context_window: default_entry.context_window,
336 provider_name: mgr.catalog.default_ref().provider_id.clone(),
337 remotes,
338 });
339 }
340
341 loop {
342 tokio::select! {
343 msg = client_tx_rx.recv() => {
345 let Some(msg) = msg else {
346 tracing::error!("Session display events dropped");
347 break
348 };
349 if daemon_tx.send(msg).is_err() {
350 tracing::error!("Failed to send display event to client");
351 break;
352 }
353 }
354 msg = async {
356 match remote_proxy_rx.as_mut() {
357 Some(rx) => rx.recv().await,
358 None => std::future::pending().await,
359 }
360 } => {
361 let Some(msg) = msg else {
362 let rn = active_remote_name.as_deref().unwrap_or("unknown");
363 let _ = daemon_tx.send(DaemonMessage::Error { thread_id: None, text: format!("Remote '{rn}' connection closed") });
364 break;
365 };
366 let rn = active_remote_name.as_deref().unwrap_or("");
367 if daemon_tx.send(prefix_daemon_message(msg, rn)).is_err() { break; }
368 }
369 msg = client_rx.recv() => {
371 let Some(msg) = msg else {
372 tracing::info!("Client stream ended");
373 break
374 };
375 tracing::info!(?msg, "Received client message");
376
377 if let Some(ref proxy_tx) = remote_proxy_tx {
379 let rn = active_remote_name.as_deref().unwrap_or("");
380 match &msg {
381 ClientMessage::Disconnect => {
382 let _ = proxy_tx.send(ClientMessage::Disconnect);
384 remote_proxy_tx = None;
385 remote_proxy_rx = None;
386 active_remote_name = None;
387 attached_session_id = None;
388 attached_thread_id = None;
389 }
390 ClientMessage::Connect { .. } => {
391 let _ = proxy_tx.send(ClientMessage::Disconnect);
393 remote_proxy_tx = None;
394 remote_proxy_rx = None;
395 active_remote_name = None;
396 }
398 ClientMessage::CreateSession { .. } => {
399 let _ = proxy_tx.send(ClientMessage::Disconnect);
401 remote_proxy_tx = None;
402 remote_proxy_rx = None;
403 active_remote_name = None;
404 }
405 ClientMessage::RequestMigrate { .. } | ClientMessage::ListDirectory { .. } => {
406 }
408 _ => {
409 let _ = proxy_tx.send(strip_client_message(msg, rn));
411 continue;
412 }
413 }
414 }
415
416 match msg {
417 ClientMessage::CreateSession { cwd, location, model, keeps_session_alive } => {
418 if let Some(rname) = location {
419 let rd = {
420 let mgr = session_manager.lock().await;
421 mgr.remote_daemons.clone()
422 };
423 if let Some(rd) = rd {
424 match rd.open_raw_connection(&rname).await {
425 Ok((tx, rx)) => {
426 let _ = tx.send(ClientMessage::CreateSession { cwd, location: None, model, keeps_session_alive });
427 remote_proxy_tx = Some(tx);
428 remote_proxy_rx = Some(rx);
429 active_remote_name = Some(rname);
430 attached_session_id = None;
431 attached_thread_id = None;
432 }
433 Err(e) => {
434 let _ = daemon_tx.send(DaemonMessage::Error {
435 thread_id: None,
436 text: format!("failed to connect to remote: {e}"),
437 });
438 }
439 }
440 } else {
441 let _ = daemon_tx.send(DaemonMessage::Error {
442 thread_id: None,
443 text: "no remote daemons configured".into(),
444 });
445 }
446 } else {
447 let mgr = session_manager.lock().await;
448 let mut emit = async |msg: DaemonMessage| {
449 let _ = daemon_tx.send(msg);
450 };
451 let model = model.unwrap_or_else(|| mgr.catalog.default_ref().clone());
452 match mgr.create_session(&cwd, model, &mut emit).await {
453 Ok(sid) => {
454 mgr.attach_client(&sid, client_tx.clone(), false, keeps_session_alive).await;
455 attached_thread_id = Some(sid.clone());
456 attached_session_id = Some(sid);
457 }
458 Err(e) => { let _ = daemon_tx.send(DaemonMessage::Error { thread_id: None, text: format!("failed to create session: {e}") }); }
459 }
460 }
461 }
462 ClientMessage::Connect { session_id, thread_id, keeps_session_alive } => {
463 if let Some((rname, real_session_id)) = is_remote_session(&session_id) {
464 let real_thread_id = thread_id.as_deref().map(|t| strip_id(t, rname));
465 let rname = rname.to_owned();
466 let rd = {
467 let mgr = session_manager.lock().await;
468 mgr.remote_daemons.clone()
469 };
470 if let Some(rd) = rd {
471 match rd.connect_remote_session(&rname, real_session_id, real_thread_id.as_deref()).await {
472 Ok((tx, rx)) => {
473 remote_proxy_tx = Some(tx);
474 remote_proxy_rx = Some(rx);
475 active_remote_name = Some(rname);
476 attached_session_id = Some(ThreadId::from(session_id));
477 }
478 Err(e) => {
479 let _ = daemon_tx.send(DaemonMessage::Error {
480 thread_id: Some(session_id),
481 text: format!("failed to connect to remote: {e}"),
482 });
483 }
484 }
485 } else {
486 let _ = daemon_tx.send(DaemonMessage::Error {
487 thread_id: Some(session_id),
488 text: "no remote daemons configured".into(),
489 });
490 }
491 } else {
492 let mgr = session_manager.lock().await;
493 let mut emit = async |msg: DaemonMessage| {
494 let _ = daemon_tx.send(msg);
495 };
496 let session_tid = ThreadId::from(session_id.as_str());
497 let target = thread_id.as_deref().map(ThreadId::from).unwrap_or_else(|| session_tid.clone());
498 match mgr.resume_session(&session_tid, &target, &mut emit).await {
499 Ok(()) => {
500 mgr.attach_client(&target, client_tx.clone(), true, keeps_session_alive).await;
501 attached_thread_id = Some(target);
502 attached_session_id = Some(session_tid);
503 }
504 Err(e) => { let _ = daemon_tx.send(DaemonMessage::Error { thread_id: Some(session_id), text: format!("failed to resume session: {e}") }); }
505 }
506 }
507 }
508 ClientMessage::UserInput { session_id: thread_id, text } => {
509 if is_remote_session(&thread_id).is_some() {
510 let _ = daemon_tx.send(DaemonMessage::Error { thread_id: Some(thread_id), text: "remote is not connected".into() });
511 continue;
512 }
513 let mgr = session_manager.lock().await;
514 if !mgr
515 .send_input((
516 InputMessage {
517 content: InputMessageContent::User(UserContent::text(&text)),
518 group_id: thread_id.clone().into(),
519 metadata: None,
520 synthetic: None,
521 display_as: None,
522 subscription: false,
523 },
524 None,
525 ))
526 .await
527 {
528 let _ = daemon_tx.send(DaemonMessage::Error {
529 thread_id: Some(thread_id),
530 text: "failed to send input".into(),
531 });
532 }
533 }
534 ClientMessage::Disconnect => {
535 let (new_tx, new_rx) = mpsc::unbounded_channel::<DaemonMessage>();
536 client_tx = new_tx;
537 client_tx_rx = new_rx;
538 if let Some(ref sid) = attached_session_id {
539 let mgr = session_manager.lock().await;
540 mgr.send_idle_ping(sid);
541 }
542 attached_session_id = None;
543 attached_thread_id = None;
544 }
545 ClientMessage::SoftDetach { session_id } => {
546 let session_id = ThreadId::from(session_id);
547 let mgr = session_manager.lock().await;
548 let do_cleanup = mgr.is_session_idle(&session_id);
549 tracing::debug!(do_cleanup, "Handling SoftDetach");
550 if do_cleanup {
551 let (new_tx, new_rx) = mpsc::unbounded_channel::<DaemonMessage>();
552 client_tx = new_tx;
553 client_tx_rx = new_rx;
554 mgr.send_idle_ping(&session_id);
555 attached_session_id = None;
556 attached_thread_id = None;
557 let _ = daemon_tx.send(DaemonMessage::DetachedIdle);
558 } else {
559 let _ = daemon_tx.send(DaemonMessage::DisconnectNotIdle);
560 }
561 }
562 ClientMessage::ShutdownSession { session_id } => {
563 let session_id = ThreadId::from(session_id);
564 let mgr = session_manager.lock().await;
565 mgr.cleanup_session(&session_id).await;
566 attached_session_id = None;
567 attached_thread_id = None;
568 }
569 ClientMessage::ArchiveSession { session_id } => {
570 let session_id = ThreadId::from(session_id);
571 let mgr = session_manager.lock().await;
572 mgr.cleanup_session(&session_id).await;
573 let mut store = mgr.session_store.lock().await;
574 store.mark_archived(&session_id);
575 if let Err(e) = store.save() {
576 tracing::error!("Failed to save session store after archiving {session_id}: {e}");
577 }
578 attached_session_id = None;
579 attached_thread_id = None;
580 }
581 ClientMessage::TriggerCompaction { session_id } => {
582 let mgr = session_manager.lock().await;
583 mgr.send_input((
584 InputMessage {
585 content: InputMessageContent::User(UserContent::text("")),
586 group_id: session_id.clone().into(),
587 metadata: None,
588 synthetic: Some(SyntheticKind::Tagged(
589 TaggedSyntheticKind::Compaction,
590 )),
591 display_as: None,
592 subscription: false,
593 },
594 None,
595 ))
596 .await;
597 }
598 ClientMessage::SwitchModel { session_id: thread_id, model } => {
599 let mgr = session_manager.lock().await;
600 if let Err(e) = mgr.switch_model(&ThreadId::from(thread_id.as_str()), model, Some(&client_tx)) {
604 let _ = daemon_tx.send(DaemonMessage::Error {
605 thread_id: Some(thread_id),
606 text: format!("failed to switch model: {e}"),
607 });
608 }
609 }
610 ClientMessage::UserChoiceAnswered { choice_id, selected } => {
611 if let Some(ref thread_id) = attached_thread_id {
612 let mgr = session_manager.lock().await;
613 if let Some(pending) = mgr.state_store().pending_choice(thread_id, &choice_id) {
614 let url = pending.response_url;
615 let id = pending.id;
616 tokio::spawn(rap_protocol::log_panic("user_choice_post", async move {
617 let client = reqwest::Client::new();
618 let _ = client
619 .post(&url)
620 .json(&serde_json::json!({
621 "id": id,
622 "selected": selected
623 }))
624 .send()
625 .await;
626 }));
627 }
628 }
629 }
630 ClientMessage::RequestMigrate { session_id, to, dest_cwd } => {
631 let mgr = session_manager.clone();
632 let tx = daemon_tx.clone();
633 tokio::task::spawn_local(crate::migrate::orchestrate_migration(
634 session_id, to, dest_cwd, mgr, tx,
635 ));
636 }
637 ClientMessage::Emigrate { session_id, dest_rap_urls } => {
638 let mgr = session_manager.clone();
640 match crate::migrate::handle_emigrate(&ThreadId::from(session_id.as_str()), dest_rap_urls, &mgr).await {
641 Ok(data) => {
642 let _ = daemon_tx.send(DaemonMessage::EmigrateResult {
643 session_id,
644 session_data: data,
645 });
646 }
647 Err(e) => {
648 let _ = daemon_tx.send(DaemonMessage::Error {
649 thread_id: None,
650 text: e.to_string(),
651 });
652 }
653 }
654 }
655 ClientMessage::EmigrateDone { session_id } => {
656 let session_id = ThreadId::from(session_id);
658 let mgr = session_manager.lock().await;
659 let mut store = mgr.session_store.lock().await;
660 store.mark_archived(&session_id);
661 let _ = store.save();
662 }
663 ClientMessage::ImportSession { session_id, cwd, session_data } => {
664 let mgr = session_manager.lock().await;
666 match mgr.conversation_store().import_session(&session_data) {
667 Ok(()) => {
668 let mut store = mgr.session_store.lock().await;
669 let session_tid = ThreadId::from(session_id.as_str());
670 store.create(&session_tid, cwd);
671 store.mark_shut_down(&session_tid);
672 let _ = store.save();
673 let _ = daemon_tx.send(DaemonMessage::ImportComplete { session_id });
674 }
675 Err(e) => {
676 let _ = daemon_tx.send(DaemonMessage::Error {
677 thread_id: None,
678 text: format!("import failed: {e}"),
679 });
680 }
681 }
682 }
683 ClientMessage::BootRapServers { cwd } => {
684 let user_rap = crate::config::user_config_path().ok();
685 match crate::rap_servers::boot_migration_servers(&cwd, user_rap.as_deref()).await {
686 Ok(servers) => {
687 let server_ports = crate::rap_servers::migration_server_ports(&servers);
688 _booted_rap_servers = servers;
690 let _ = daemon_tx.send(DaemonMessage::RapServersBooted { server_ports });
691 }
692 Err(e) => {
693 let _ = daemon_tx.send(DaemonMessage::Error {
694 thread_id: None,
695 text: format!("failed to boot RAP servers: {e}"),
696 });
697 }
698 }
699 }
700 ClientMessage::ListDirectory { path, on } => {
701 if let Some(ref remote_name) = on {
702 let rd = {
704 let mgr = session_manager.lock().await;
705 mgr.remote_daemons.clone()
706 };
707 if let Some(rd) = rd {
708 let remote_name = remote_name.clone();
709 let tx = daemon_tx.clone();
710 tokio::task::spawn_local(async move {
711 match rd.open_raw_connection(&remote_name).await {
712 Ok((remote_tx, mut remote_rx)) => {
713 let _ = remote_tx.send(ClientMessage::ListDirectory {
714 path: path.clone(),
715 on: None,
716 });
717 while let Some(msg) = remote_rx.recv().await {
719 if let DaemonMessage::DirectoryListing { request_path, entries, .. } = msg {
720 let _ = tx.send(DaemonMessage::DirectoryListing {
721 request_path,
722 entries,
723 on: Some(remote_name),
724 });
725 break;
726 }
727 }
728 }
729 Err(e) => {
730 tracing::warn!("ListDirectory remote error: {e}");
731 let _ = tx.send(DaemonMessage::DirectoryListing {
732 request_path: path,
733 entries: Vec::new(),
734 on: Some(remote_name),
735 });
736 }
737 }
738 });
739 } else {
740 let _ = daemon_tx.send(DaemonMessage::DirectoryListing {
741 request_path: path,
742 entries: Vec::new(),
743 on,
744 });
745 }
746 } else {
747 let entries = list_directory_completions(&path).await;
748 let _ = daemon_tx.send(DaemonMessage::DirectoryListing {
749 request_path: path,
750 entries,
751 on: None,
752 });
753 }
754 }
755 }
756 }
757 }
758 }
759
760 drop(remote_proxy_tx);
764 drop(client_tx);
765 if let Some(ref sid) = attached_session_id
766 && active_remote_name.is_none()
767 {
768 let mgr = session_manager.lock().await;
769 mgr.send_idle_ping(sid);
770 }
771}