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