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