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::{
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
17/// List directory entries matching a partial path for tab-completion.
18/// Given "/home/user/fo", lists entries in "/home/user/" that start with "fo".
19/// Given "/home/user/", lists all entries in "/home/user/".
20/// Directories get a trailing `/` in the result.
21async 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            _ => {} // only complete directories
53        }
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
235/// Handle a client over a unix socket (serialized framing).
236pub 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    // Spawn the core handler
242    let mgr = session_manager.clone();
243    tokio::pin! {
244        let handler = handle_client_channels(client_msg_rx, daemon_msg_tx, mgr);
245    }
246
247    // Bridge: framed socket <-> channels
248    loop {
249        tokio::select! {
250            msg = daemon_msg_rx.recv() => {
251                let Some(msg) = msg else { // handle_client_channels has dropped the senders, so we disconnect
252                    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/// Handle a client over raw mpsc channels (for in-memory mode, no serialization).
289#[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(); // prevents shutdown until close
302
303    // Send Welcome immediately
304    {
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            // Forward session display events to client
335            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            // Forward remote proxy messages to client (prefixed)
346            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            // Handle client messages
362            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 connected to a remote session, forward most messages there
370                if let Some(ref proxy_tx) = remote_proxy_tx {
371                    match &msg {
372                        ClientMessage::Disconnect => {
373                            // Disconnect from remote: drop proxy, also disconnect locally
374                            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                            // Switching sessions: tear down current remote proxy first
383                            let _ = proxy_tx.send(ClientMessage::Disconnect);
384                            remote_proxy_tx = None;
385                            remote_proxy_rx = None;
386                            active_remote_name = None;
387                            // Fall through to handle the new Connect below
388                        }
389                        ClientMessage::CreateSession { .. } => {
390                            // Tear down current remote proxy; fall through to handle below
391                            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                            // Always handled locally; fall through without tearing down proxy
398                        }
399                        _ => {
400                            // Forward everything else to remote (stripped)
401                            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                        // `switch_model` delivers the confirmation to this
594                        // client exactly once: via its subscription when
595                        // attached, directly otherwise.
596                        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                        // Daemon-to-daemon: shut down session, migrate RAP servers, serialize, return data
632                        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                        // Daemon-to-daemon: immigration complete, archive local session
650                        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                        // Daemon-to-daemon: import a serialized session
658                        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                                // Keep the servers alive until this connection closes.
681                                _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                            // Forward to the remote daemon
695                            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                                            // Wait for the DirectoryListing response
710                                            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    // Client stream ended — drop client_tx to invalidate subscriber senders,
753    // then ping idle so the agent can shut down if it was already idle.
754    // Also tear down any active remote proxy and kill booted RAP servers.
755    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}