Skip to main content

infinity_daemon/
migrate.rs

1//! Session migration orchestrator.
2//!
3//! Handles migrating a session between local and remote daemons.
4//! The local daemon always acts as the orchestrator.
5
6use infinity_agent_core::ThreadId;
7use std::collections::HashMap;
8use std::path::{Path, PathBuf};
9
10use infinity_protocol::{ClientMessage, DaemonMessage, RemoteName, ThreadRef};
11use tokio::sync::mpsc::UnboundedSender;
12
13use crate::rap_servers::{MigrationServer, boot_migration_servers, migration_server_ports};
14use crate::remote::{RemoteDaemons, SshPortForward};
15use crate::session::SharedSessionManager;
16
17type BoxError = Box<dyn std::error::Error + Send + Sync>;
18
19/// Run the full migration flow for a `RequestMigrate` message.
20/// This is spawned as a task from the client handler.
21pub async fn orchestrate_migration(
22    root_thread_id: ThreadRef,
23    to: Option<RemoteName>,
24    dest_cwd: PathBuf,
25    session_manager: SharedSessionManager,
26    daemon_tx: UnboundedSender<DaemonMessage>,
27) {
28    let _ = daemon_tx.send(DaemonMessage::MigrateStarted {
29        root_thread_id: root_thread_id.clone(),
30    });
31
32    let new_root_thread_id = ThreadRef {
33        remote: to.clone(),
34        id: root_thread_id.id.clone(),
35    };
36
37    match run_migration(&root_thread_id, to.as_ref(), &dest_cwd, &session_manager).await {
38        Ok(()) => {
39            let _ = daemon_tx.send(DaemonMessage::MigrateComplete {
40                root_thread_id,
41                new_root_thread_id,
42            });
43        }
44        Err(e) => {
45            let _ = daemon_tx.send(DaemonMessage::MigrateError {
46                root_thread_id,
47                error: e.to_string(),
48            });
49        }
50    }
51}
52
53async fn run_migration(
54    session_ref: &ThreadRef,
55    to: Option<&RemoteName>,
56    dest_cwd: &Path,
57    session_manager: &SharedSessionManager,
58) -> Result<(), BoxError> {
59    let source_is_local = session_ref.remote.is_none();
60    let source_remote = session_ref.remote.clone();
61    let real_session_id = session_ref.id.clone();
62    let dest_is_local = to.is_none();
63
64    // Shut down the source session first (kills agent + original RAP servers)
65    let source_cwd = if source_is_local {
66        let mgr = session_manager.lock().await;
67        let cwd = mgr
68            .session_store
69            .lock()
70            .await
71            .get_cwd(&real_session_id)
72            .clone();
73        mgr.cleanup_session(&real_session_id).await;
74        Some(cwd)
75    } else {
76        None
77    };
78
79    // Boot destination RAP servers to discover which need migration.
80    // The handler filters server_ports to only migration-needing servers.
81    let (dest_rap_urls, dest_spawned, _tunnel_guards) =
82        boot_dest_and_tunnel(to, dest_cwd, &source_remote, session_manager).await?;
83
84    // Boot source RAP servers and migrate state
85    if source_is_local && !dest_rap_urls.is_empty() {
86        let (migration_servers, _spawned) = boot_source_rap_servers(
87            source_cwd.as_deref().expect("bug: source local but no cwd"),
88            &dest_rap_urls,
89        )
90        .await?;
91        let notifier = rap_client::notifier::RapNotifier::new(
92            migration_servers
93                .iter()
94                .map(|(_, url)| url.clone())
95                .collect(),
96            rap_client::http::SimpleHttpClient::new(),
97        );
98        if let Err(errors) = notifier
99            .request_migration(&real_session_id, &migration_servers, &dest_rap_urls)
100            .await
101        {
102            return Err(format!("RAP migration failed: {}", errors.join("; ")).into());
103        }
104    }
105
106    // Serialize session data from source
107    let session_data = if source_is_local {
108        let mgr = session_manager.lock().await;
109        mgr.conversation_store().serialize_session(&real_session_id)
110    } else {
111        let rd = {
112            let mgr = session_manager.lock().await;
113            mgr.remote_daemons.clone()
114        };
115        let rd = rd.ok_or("no remote daemons configured")?;
116
117        emigrate_from_remote(
118            &rd,
119            source_remote
120                .as_ref()
121                .expect("bug: source remote but no name"),
122            &real_session_id,
123            dest_rap_urls,
124        )
125        .await?
126    };
127
128    // Kill temporary destination RAP servers
129    drop(dest_spawned);
130
131    // Import into destination
132    if dest_is_local {
133        let mgr = session_manager.lock().await;
134        mgr.conversation_store()
135            .import_session(&session_data)
136            .map_err(|e| format!("import failed: {e}"))?;
137        let mut store = mgr.session_store.lock().await;
138        store.create(&real_session_id, dest_cwd.to_path_buf());
139        store.mark_shut_down(&real_session_id);
140        store.save()?;
141    } else {
142        let rd = {
143            let mgr = session_manager.lock().await;
144            mgr.remote_daemons.clone()
145        };
146        let rd = rd.ok_or("no remote daemons configured")?;
147        immigrate_to_remote(
148            &rd,
149            to.expect("bug: dest is remote"),
150            &real_session_id,
151            dest_cwd,
152            &session_data,
153        )
154        .await?;
155    }
156
157    // Clean up source
158    if source_is_local {
159        let mgr = session_manager.lock().await;
160        let mut store = mgr.session_store.lock().await;
161        store.mark_archived(&real_session_id);
162        store.save()?;
163    } else {
164        let rd = {
165            let mgr = session_manager.lock().await;
166            mgr.remote_daemons.clone()
167        };
168
169        if let Some(rd) = rd {
170            send_emigrate_done(
171                &rd,
172                source_remote
173                    .as_ref()
174                    .expect("bug: source remote but no name"),
175                &real_session_id,
176            )
177            .await?;
178        }
179    }
180
181    // _tunnel_guards dropped here, cleaning up SSH forwards
182    Ok(())
183}
184
185/// Boot the RAP servers at `cwd` and return the (config_id, url) pairs for
186/// the servers matching the destination's migration config_ids, plus the
187/// booted servers themselves (kept alive until the migration completes).
188async fn boot_source_rap_servers(
189    cwd: &Path,
190    dest_rap_urls: &HashMap<String, String>,
191) -> Result<(Vec<(String, String)>, Vec<MigrationServer>), BoxError> {
192    let user_rap = crate::config::user_config_path().ok();
193    let servers = boot_migration_servers(cwd, user_rap.as_deref()).await?;
194    let migration_servers: Vec<(String, String)> = servers
195        .iter()
196        .filter_map(|s| {
197            let id = s.config_id.as_ref()?;
198            dest_rap_urls
199                .contains_key(id)
200                .then(|| (id.clone(), s.url.clone()))
201        })
202        .collect();
203    Ok((migration_servers, servers))
204}
205
206/// Handle an Emigrate request: shut down session, boot fresh RAP servers,
207/// migrate state, serialize, and return the session data.
208pub async fn handle_emigrate(
209    session_id: &ThreadId<str>,
210    dest_rap_urls: HashMap<String, String>,
211    session_manager: &SharedSessionManager,
212) -> Result<String, BoxError> {
213    // Get cwd and shut down the session first
214    let cwd = {
215        let mgr = session_manager.lock().await;
216        mgr.session_store.lock().await.get_cwd(session_id).clone()
217    };
218    {
219        let mgr = session_manager.lock().await;
220        mgr.cleanup_session(session_id).await;
221    }
222
223    // Boot fresh RAP servers and perform migration
224    let (migration_servers, _spawned) = boot_source_rap_servers(&cwd, &dest_rap_urls).await?;
225    if !migration_servers.is_empty() {
226        let notifier = rap_client::notifier::RapNotifier::new(
227            migration_servers
228                .iter()
229                .map(|(_, url)| url.clone())
230                .collect(),
231            rap_client::http::SimpleHttpClient::new(),
232        );
233        if let Err(errors) = notifier
234            .request_migration(session_id, &migration_servers, &dest_rap_urls)
235            .await
236        {
237            return Err(format!("RAP migration failed: {}", errors.join("; ")).into());
238        }
239    }
240
241    let mgr = session_manager.lock().await;
242    Ok(mgr.conversation_store().serialize_session(session_id))
243}
244
245pub enum LocalOrRemoteSpawned {
246    Local(Vec<MigrationServer>),
247    Remote(UnboundedSender<ClientMessage>),
248}
249
250/// Boot RAP servers on the destination and set up SSH tunnels so the source can reach them.
251/// Returns (config_id → reachable_url, tunnel guards, spawned dest servers).
252async fn boot_dest_and_tunnel(
253    to: Option<&RemoteName>,
254    dest_cwd: &Path,
255    source_remote: &Option<RemoteName>,
256    session_manager: &SharedSessionManager,
257) -> Result<
258    (
259        HashMap<String, String>,
260        LocalOrRemoteSpawned,
261        Vec<SshPortForward>,
262    ),
263    BoxError,
264> {
265    let dest_is_local = to.is_none();
266    // Boot RAP servers on destination — server_ports is config_id → port (migration-only)
267    let (dest_server_ports, dest_spawned) = if dest_is_local {
268        let user_rap = crate::config::user_config_path().ok();
269        let servers = boot_migration_servers(dest_cwd, user_rap.as_deref()).await?;
270        let ports = migration_server_ports(&servers);
271        (ports, LocalOrRemoteSpawned::Local(servers))
272    } else {
273        tracing::info!("Launching RAP servers on remote destination to receive migration");
274        let rd = {
275            let mgr = session_manager.lock().await;
276            mgr.remote_daemons.clone()
277        };
278        let rd = rd.ok_or("no remote daemons configured")?;
279        let (tx, mut rx) = rd
280            .open_raw_connection(to.expect("bug: dest is remote"))
281            .await?;
282        tx.send(ClientMessage::BootRapServers {
283            cwd: dest_cwd.to_path_buf(),
284        })?;
285        let ports = match rx.recv().await {
286            Some(DaemonMessage::RapServersBooted { server_ports }) => server_ports,
287            Some(msg) => return Err(format!("remote sent unxpected response {:?}", msg).into()),
288            None => return Err("remote closed without sending EmigrateResult".into()),
289        };
290
291        (ports, LocalOrRemoteSpawned::Remote(tx))
292    };
293
294    // Build dest_rap_urls: config_id → reachable URL
295    let mut dest_rap_urls = HashMap::new();
296
297    let source_is_local = source_remote.is_none();
298
299    let mut tunnel_guards = Vec::new();
300
301    if dest_is_local && source_is_local {
302        // Both local — dest servers are directly reachable
303        for (id, port) in &dest_server_ports {
304            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{port}"));
305        }
306    } else if dest_is_local {
307        // Source is remote, dest is local — reverse-forward local dest ports onto the source remote
308        let rd = {
309            let mgr = session_manager.lock().await;
310            mgr.remote_daemons.clone()
311        };
312        let rd = rd.ok_or("no remote daemons configured")?;
313        let source_remote_name = source_remote
314            .as_ref()
315            .expect("bug: source remote but no name");
316        let ssh_args = rd
317            .get_ssh_args(source_remote_name)
318            .ok_or("unknown source remote")?;
319        for (id, local_port) in &dest_server_ports {
320            let (remote_port, guard) =
321                crate::remote::ssh_reverse_forward_port(&ssh_args, *local_port).await?;
322            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{remote_port}"));
323            tunnel_guards.push(guard);
324        }
325    } else if source_is_local {
326        // Source is local, dest is remote — SSH-forward remote dest ports to local
327        let rd = {
328            let mgr = session_manager.lock().await;
329            mgr.remote_daemons.clone()
330        };
331        let rd = rd.ok_or("no remote daemons configured")?;
332        let ssh_args = rd
333            .get_ssh_args(to.expect("bug: dest is remote"))
334            .ok_or("unknown remote")?;
335        for (id, remote_port) in &dest_server_ports {
336            let (local_port, guard) =
337                crate::remote::ssh_forward_port(&ssh_args, *remote_port).await?;
338            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{local_port}"));
339            tunnel_guards.push(guard);
340        }
341    } else {
342        // Both remote — chain: forward dest ports to local, then reverse-forward to source remote
343        let rd = {
344            let mgr = session_manager.lock().await;
345            mgr.remote_daemons.clone()
346        };
347        let rd = rd.ok_or("no remote daemons configured")?;
348        let dest_ssh_args = rd
349            .get_ssh_args(to.expect("bug: dest is remote"))
350            .ok_or("unknown dest remote")?;
351        let source_remote_name = source_remote
352            .as_ref()
353            .expect("bug: source remote but no name");
354        let source_ssh_args = rd
355            .get_ssh_args(source_remote_name)
356            .ok_or("unknown source remote")?;
357        for (id, dest_port) in &dest_server_ports {
358            // Step 1: forward dest remote port to local
359            let (local_port, guard1) =
360                crate::remote::ssh_forward_port(&dest_ssh_args, *dest_port).await?;
361            // Step 2: reverse-forward that local port onto source remote
362            let (source_port, guard2) =
363                crate::remote::ssh_reverse_forward_port(&source_ssh_args, local_port).await?;
364            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{source_port}"));
365            tunnel_guards.push(guard1);
366            tunnel_guards.push(guard2);
367        }
368    }
369
370    Ok((dest_rap_urls, dest_spawned, tunnel_guards))
371}
372
373/// Send Emigrate to a remote daemon and receive the serialized session data.
374async fn emigrate_from_remote(
375    rd: &RemoteDaemons,
376    remote_name: &RemoteName,
377    session_id: &ThreadId<str>,
378    dest_rap_urls: HashMap<String, String>,
379) -> Result<String, BoxError> {
380    let (tx, mut rx) = rd.open_raw_connection(remote_name).await?;
381
382    tx.send(ClientMessage::Emigrate {
383        root_thread_id: session_id.to_owned(),
384        dest_rap_urls,
385    })?;
386
387    match rx.recv().await {
388        Some(DaemonMessage::EmigrateResult { session_data, .. }) => Ok(session_data),
389        Some(msg) => Err(format!("remote sent unxpected response {:?}", msg).into()),
390        None => Err("remote closed without sending EmigrateResult".into()),
391    }
392}
393
394/// Send session data to a remote daemon for immigration.
395async fn immigrate_to_remote(
396    rd: &RemoteDaemons,
397    remote_name: &RemoteName,
398    session_id: &ThreadId<str>,
399    dest_cwd: &Path,
400    session_data: &str,
401) -> Result<(), BoxError> {
402    let (tx, mut rx) = rd.open_raw_connection(remote_name).await?;
403
404    tx.send(ClientMessage::ImportSession {
405        root_thread_id: session_id.to_owned(),
406        cwd: dest_cwd.to_path_buf(),
407        session_data: session_data.to_owned(),
408    })?;
409
410    match rx.recv().await {
411        Some(DaemonMessage::ImportComplete { .. }) => Ok(()),
412        Some(msg) => Err(format!("remote sent unxpected response {:?}", msg).into()),
413        None => Err("remote closed without sending EmigrateResult".into()),
414    }
415}
416
417/// Send EmigrateDone to a remote daemon so it can clean up.
418async fn send_emigrate_done(
419    rd: &RemoteDaemons,
420    remote_name: &RemoteName,
421    session_id: &ThreadId<str>,
422) -> Result<(), BoxError> {
423    let (tx, _rx) = rd.open_raw_connection(remote_name).await?;
424    tx.send(ClientMessage::EmigrateDone {
425        root_thread_id: session_id.to_owned(),
426    })
427    .map_err(|e| e.into())
428}