1use 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
19pub 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 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 let (dest_rap_urls, dest_spawned, _tunnel_guards) =
93 boot_dest_and_tunnel(to, dest_cwd, &source_remote, session_manager).await?;
94
95 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 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 drop(dest_spawned);
141
142 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 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 Ok(())
194}
195
196async 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
217pub 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 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 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
261async 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 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 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 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 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 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 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 let (local_port, guard1) =
371 crate::remote::ssh_forward_port(&dest_ssh_args, *dest_port).await?;
372 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
384async 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
405async 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
428async 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}