1use 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
19pub 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 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 let (dest_rap_urls, dest_spawned, _tunnel_guards) =
82 boot_dest_and_tunnel(to, dest_cwd, &source_remote, session_manager).await?;
83
84 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 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 drop(dest_spawned);
130
131 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 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 Ok(())
183}
184
185async 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
206pub 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 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 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
250async 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 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 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 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 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 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 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 let (local_port, guard1) =
360 crate::remote::ssh_forward_port(&dest_ssh_args, *dest_port).await?;
361 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
373async 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
394async 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
417async 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}