Skip to main content

infinity_daemon/
client_handler.rs

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
15/// List directory entries matching a partial path for tab-completion.
16/// Given "/home/user/fo", lists entries in "/home/user/" that start with "fo".
17/// Given "/home/user/", lists all entries in "/home/user/".
18/// Directories get a trailing `/` in the result.
19async 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            _ => {} // only complete directories
51        }
52    }
53    entries.sort_by(|a, b| a.trim_end_matches('/').cmp(b.trim_end_matches('/')));
54    entries
55}
56
57/// Split "remote_name/real_id" into (remote_name, real_id).
58fn 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
244/// Handle a client over a unix socket (serialized framing).
245pub 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    // Spawn the core handler
251    let mgr = session_manager.clone();
252    tokio::pin! {
253        let handler = handle_client_channels(client_msg_rx, daemon_msg_tx, mgr);
254    }
255
256    // Bridge: framed socket <-> channels
257    loop {
258        tokio::select! {
259            msg = daemon_msg_rx.recv() => {
260                let Some(msg) = msg else { // handle_client_channels has dropped the senders, so we disconnect
261                    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/// Handle a client over raw mpsc channels (for in-memory mode, no serialization).
298#[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(); // prevents shutdown until close
311
312    // Send Welcome immediately
313    {
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            // Forward session display events to client
344            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            // Forward remote proxy messages to client (prefixed)
355            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            // Handle client messages
370            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 connected to a remote session, forward most messages there
378                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                            // Disconnect from remote: drop proxy, also disconnect locally
383                            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                            // Switching sessions: tear down current remote proxy first
392                            let _ = proxy_tx.send(ClientMessage::Disconnect);
393                            remote_proxy_tx = None;
394                            remote_proxy_rx = None;
395                            active_remote_name = None;
396                            // Fall through to handle the new Connect below
397                        }
398                        ClientMessage::CreateSession { .. } => {
399                            // Tear down current remote proxy; fall through to handle below
400                            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                            // Always handled locally; fall through without tearing down proxy
407                        }
408                        _ => {
409                            // Forward everything else to remote (stripped)
410                            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                        // `switch_model` delivers the confirmation to this
601                        // client exactly once: via its subscription when
602                        // attached, directly otherwise.
603                        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                        // Daemon-to-daemon: shut down session, migrate RAP servers, serialize, return data
639                        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                        // Daemon-to-daemon: immigration complete, archive local session
657                        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                        // Daemon-to-daemon: import a serialized session
665                        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                                // Keep the servers alive until this connection closes.
689                                _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                            // Forward to the remote daemon
703                            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                                            // Wait for the DirectoryListing response
718                                            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    // Client stream ended — drop client_tx to invalidate subscriber senders,
761    // then ping idle so the agent can shut down if it was already idle.
762    // Also tear down any active remote proxy and kill booted RAP servers.
763    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}