infinity-daemon 0.2.0

The Infinity daemon: hosts durable agent sessions and serves local clients.
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
//! Session migration orchestrator.
//!
//! Handles migrating a session between local and remote daemons.
//! The local daemon always acts as the orchestrator.

use infinity_agent_core::ThreadId;
use std::collections::HashMap;
use std::path::{Path, PathBuf};

use infinity_protocol::{ClientMessage, DaemonMessage, RemoteName, ThreadRef};
use tokio::sync::mpsc::UnboundedSender;

use crate::rap_servers::{MigrationServer, boot_migration_servers, migration_server_ports};
use crate::remote::{RemoteDaemons, SshPortForward};
use crate::session::SharedSessionManager;

type BoxError = Box<dyn std::error::Error + Send + Sync>;

/// Run the full migration flow for a `RequestMigrate` message.
/// This is spawned as a task from the client handler.
pub async fn orchestrate_migration(
    root_thread_id: ThreadRef,
    to: Option<RemoteName>,
    dest_cwd: PathBuf,
    session_manager: SharedSessionManager,
    daemon_tx: UnboundedSender<DaemonMessage>,
) {
    let _ = daemon_tx.send(DaemonMessage::MigrateStarted {
        root_thread_id: root_thread_id.clone(),
    });

    let new_root_thread_id = ThreadRef {
        remote: to.clone(),
        id: root_thread_id.id.clone(),
    };

    match run_migration(&root_thread_id, to.as_ref(), &dest_cwd, &session_manager).await {
        Ok(()) => {
            let _ = daemon_tx.send(DaemonMessage::MigrateComplete {
                root_thread_id,
                new_root_thread_id,
            });
        }
        Err(e) => {
            let _ = daemon_tx.send(DaemonMessage::MigrateError {
                root_thread_id,
                error: e.to_string(),
            });
        }
    }
}

async fn run_migration(
    session_ref: &ThreadRef,
    to: Option<&RemoteName>,
    dest_cwd: &Path,
    session_manager: &SharedSessionManager,
) -> Result<(), BoxError> {
    let source_is_local = session_ref.remote.is_none();
    let source_remote = session_ref.remote.clone();
    let real_session_id = session_ref.id.clone();
    let dest_is_local = to.is_none();

    // Shut down the source session first (kills agent + original RAP servers)
    let source_cwd = if source_is_local {
        let mgr = session_manager.lock().await;
        let cwd = mgr
            .session_store
            .lock()
            .await
            .get_cwd(&real_session_id)
            .clone();
        mgr.cleanup_session(&real_session_id).await;
        Some(cwd)
    } else {
        None
    };

    // Boot destination RAP servers to discover which need migration.
    // The handler filters server_ports to only migration-needing servers.
    let (dest_rap_urls, dest_spawned, _tunnel_guards) =
        boot_dest_and_tunnel(to, dest_cwd, &source_remote, session_manager).await?;

    // Boot source RAP servers and migrate state
    if source_is_local && !dest_rap_urls.is_empty() {
        let (migration_servers, _spawned) = boot_source_rap_servers(
            source_cwd.as_deref().expect("bug: source local but no cwd"),
            &dest_rap_urls,
        )
        .await?;
        let notifier = rap_client::notifier::RapNotifier::new(
            migration_servers
                .iter()
                .map(|(_, url)| url.clone())
                .collect(),
            rap_client::http::SimpleHttpClient::new(),
        );
        if let Err(errors) = notifier
            .request_migration(&real_session_id, &migration_servers, &dest_rap_urls)
            .await
        {
            return Err(format!("RAP migration failed: {}", errors.join("; ")).into());
        }
    }

    // Serialize session data from source
    let session_data = if source_is_local {
        let mgr = session_manager.lock().await;
        mgr.conversation_store().serialize_session(&real_session_id)
    } else {
        let rd = {
            let mgr = session_manager.lock().await;
            mgr.remote_daemons.clone()
        };
        let rd = rd.ok_or("no remote daemons configured")?;

        emigrate_from_remote(
            &rd,
            source_remote
                .as_ref()
                .expect("bug: source remote but no name"),
            &real_session_id,
            dest_rap_urls,
        )
        .await?
    };

    // Kill temporary destination RAP servers
    drop(dest_spawned);

    // Import into destination
    if dest_is_local {
        let mgr = session_manager.lock().await;
        mgr.conversation_store()
            .import_session(&session_data)
            .map_err(|e| format!("import failed: {e}"))?;
        let mut store = mgr.session_store.lock().await;
        store.create(&real_session_id, dest_cwd.to_path_buf());
        store.mark_shut_down(&real_session_id);
        store.save()?;
    } else {
        let rd = {
            let mgr = session_manager.lock().await;
            mgr.remote_daemons.clone()
        };
        let rd = rd.ok_or("no remote daemons configured")?;
        immigrate_to_remote(
            &rd,
            to.expect("bug: dest is remote"),
            &real_session_id,
            dest_cwd,
            &session_data,
        )
        .await?;
    }

    // Clean up source
    if source_is_local {
        let mgr = session_manager.lock().await;
        let mut store = mgr.session_store.lock().await;
        store.mark_archived(&real_session_id);
        store.save()?;
    } else {
        let rd = {
            let mgr = session_manager.lock().await;
            mgr.remote_daemons.clone()
        };

        if let Some(rd) = rd {
            send_emigrate_done(
                &rd,
                source_remote
                    .as_ref()
                    .expect("bug: source remote but no name"),
                &real_session_id,
            )
            .await?;
        }
    }

    // _tunnel_guards dropped here, cleaning up SSH forwards
    Ok(())
}

/// Boot the RAP servers at `cwd` and return the (config_id, url) pairs for
/// the servers matching the destination's migration config_ids, plus the
/// booted servers themselves (kept alive until the migration completes).
async fn boot_source_rap_servers(
    cwd: &Path,
    dest_rap_urls: &HashMap<String, String>,
) -> Result<(Vec<(String, String)>, Vec<MigrationServer>), BoxError> {
    let user_rap = crate::config::user_config_path().ok();
    let servers = boot_migration_servers(cwd, user_rap.as_deref()).await?;
    let migration_servers: Vec<(String, String)> = servers
        .iter()
        .filter_map(|s| {
            let id = s.config_id.as_ref()?;
            dest_rap_urls
                .contains_key(id)
                .then(|| (id.clone(), s.url.clone()))
        })
        .collect();
    Ok((migration_servers, servers))
}

/// Handle an Emigrate request: shut down session, boot fresh RAP servers,
/// migrate state, serialize, and return the session data.
pub async fn handle_emigrate(
    session_id: &ThreadId<str>,
    dest_rap_urls: HashMap<String, String>,
    session_manager: &SharedSessionManager,
) -> Result<String, BoxError> {
    // Get cwd and shut down the session first
    let cwd = {
        let mgr = session_manager.lock().await;
        mgr.session_store.lock().await.get_cwd(session_id).clone()
    };
    {
        let mgr = session_manager.lock().await;
        mgr.cleanup_session(session_id).await;
    }

    // Boot fresh RAP servers and perform migration
    let (migration_servers, _spawned) = boot_source_rap_servers(&cwd, &dest_rap_urls).await?;
    if !migration_servers.is_empty() {
        let notifier = rap_client::notifier::RapNotifier::new(
            migration_servers
                .iter()
                .map(|(_, url)| url.clone())
                .collect(),
            rap_client::http::SimpleHttpClient::new(),
        );
        if let Err(errors) = notifier
            .request_migration(session_id, &migration_servers, &dest_rap_urls)
            .await
        {
            return Err(format!("RAP migration failed: {}", errors.join("; ")).into());
        }
    }

    let mgr = session_manager.lock().await;
    Ok(mgr.conversation_store().serialize_session(session_id))
}

pub enum LocalOrRemoteSpawned {
    Local(Vec<MigrationServer>),
    Remote(UnboundedSender<ClientMessage>),
}

/// Boot RAP servers on the destination and set up SSH tunnels so the source can reach them.
/// Returns (config_id → reachable_url, tunnel guards, spawned dest servers).
async fn boot_dest_and_tunnel(
    to: Option<&RemoteName>,
    dest_cwd: &Path,
    source_remote: &Option<RemoteName>,
    session_manager: &SharedSessionManager,
) -> Result<
    (
        HashMap<String, String>,
        LocalOrRemoteSpawned,
        Vec<SshPortForward>,
    ),
    BoxError,
> {
    let dest_is_local = to.is_none();
    // Boot RAP servers on destination — server_ports is config_id → port (migration-only)
    let (dest_server_ports, dest_spawned) = if dest_is_local {
        let user_rap = crate::config::user_config_path().ok();
        let servers = boot_migration_servers(dest_cwd, user_rap.as_deref()).await?;
        let ports = migration_server_ports(&servers);
        (ports, LocalOrRemoteSpawned::Local(servers))
    } else {
        tracing::info!("Launching RAP servers on remote destination to receive migration");
        let rd = {
            let mgr = session_manager.lock().await;
            mgr.remote_daemons.clone()
        };
        let rd = rd.ok_or("no remote daemons configured")?;
        let (tx, mut rx) = rd
            .open_raw_connection(to.expect("bug: dest is remote"))
            .await?;
        tx.send(ClientMessage::BootRapServers {
            cwd: dest_cwd.to_path_buf(),
        })?;
        let ports = match rx.recv().await {
            Some(DaemonMessage::RapServersBooted { server_ports }) => server_ports,
            Some(msg) => return Err(format!("remote sent unxpected response {:?}", msg).into()),
            None => return Err("remote closed without sending EmigrateResult".into()),
        };

        (ports, LocalOrRemoteSpawned::Remote(tx))
    };

    // Build dest_rap_urls: config_id → reachable URL
    let mut dest_rap_urls = HashMap::new();

    let source_is_local = source_remote.is_none();

    let mut tunnel_guards = Vec::new();

    if dest_is_local && source_is_local {
        // Both local — dest servers are directly reachable
        for (id, port) in &dest_server_ports {
            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{port}"));
        }
    } else if dest_is_local {
        // Source is remote, dest is local — reverse-forward local dest ports onto the source remote
        let rd = {
            let mgr = session_manager.lock().await;
            mgr.remote_daemons.clone()
        };
        let rd = rd.ok_or("no remote daemons configured")?;
        let source_remote_name = source_remote
            .as_ref()
            .expect("bug: source remote but no name");
        let ssh_args = rd
            .get_ssh_args(source_remote_name)
            .ok_or("unknown source remote")?;
        for (id, local_port) in &dest_server_ports {
            let (remote_port, guard) =
                crate::remote::ssh_reverse_forward_port(&ssh_args, *local_port).await?;
            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{remote_port}"));
            tunnel_guards.push(guard);
        }
    } else if source_is_local {
        // Source is local, dest is remote — SSH-forward remote dest ports to local
        let rd = {
            let mgr = session_manager.lock().await;
            mgr.remote_daemons.clone()
        };
        let rd = rd.ok_or("no remote daemons configured")?;
        let ssh_args = rd
            .get_ssh_args(to.expect("bug: dest is remote"))
            .ok_or("unknown remote")?;
        for (id, remote_port) in &dest_server_ports {
            let (local_port, guard) =
                crate::remote::ssh_forward_port(&ssh_args, *remote_port).await?;
            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{local_port}"));
            tunnel_guards.push(guard);
        }
    } else {
        // Both remote — chain: forward dest ports to local, then reverse-forward to source remote
        let rd = {
            let mgr = session_manager.lock().await;
            mgr.remote_daemons.clone()
        };
        let rd = rd.ok_or("no remote daemons configured")?;
        let dest_ssh_args = rd
            .get_ssh_args(to.expect("bug: dest is remote"))
            .ok_or("unknown dest remote")?;
        let source_remote_name = source_remote
            .as_ref()
            .expect("bug: source remote but no name");
        let source_ssh_args = rd
            .get_ssh_args(source_remote_name)
            .ok_or("unknown source remote")?;
        for (id, dest_port) in &dest_server_ports {
            // Step 1: forward dest remote port to local
            let (local_port, guard1) =
                crate::remote::ssh_forward_port(&dest_ssh_args, *dest_port).await?;
            // Step 2: reverse-forward that local port onto source remote
            let (source_port, guard2) =
                crate::remote::ssh_reverse_forward_port(&source_ssh_args, local_port).await?;
            dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{source_port}"));
            tunnel_guards.push(guard1);
            tunnel_guards.push(guard2);
        }
    }

    Ok((dest_rap_urls, dest_spawned, tunnel_guards))
}

/// Send Emigrate to a remote daemon and receive the serialized session data.
async fn emigrate_from_remote(
    rd: &RemoteDaemons,
    remote_name: &RemoteName,
    session_id: &ThreadId<str>,
    dest_rap_urls: HashMap<String, String>,
) -> Result<String, BoxError> {
    let (tx, mut rx) = rd.open_raw_connection(remote_name).await?;

    tx.send(ClientMessage::Emigrate {
        root_thread_id: session_id.to_owned(),
        dest_rap_urls,
    })?;

    match rx.recv().await {
        Some(DaemonMessage::EmigrateResult { session_data, .. }) => Ok(session_data),
        Some(msg) => Err(format!("remote sent unxpected response {:?}", msg).into()),
        None => Err("remote closed without sending EmigrateResult".into()),
    }
}

/// Send session data to a remote daemon for immigration.
async fn immigrate_to_remote(
    rd: &RemoteDaemons,
    remote_name: &RemoteName,
    session_id: &ThreadId<str>,
    dest_cwd: &Path,
    session_data: &str,
) -> Result<(), BoxError> {
    let (tx, mut rx) = rd.open_raw_connection(remote_name).await?;

    tx.send(ClientMessage::ImportSession {
        root_thread_id: session_id.to_owned(),
        cwd: dest_cwd.to_path_buf(),
        session_data: session_data.to_owned(),
    })?;

    match rx.recv().await {
        Some(DaemonMessage::ImportComplete { .. }) => Ok(()),
        Some(msg) => Err(format!("remote sent unxpected response {:?}", msg).into()),
        None => Err("remote closed without sending EmigrateResult".into()),
    }
}

/// Send EmigrateDone to a remote daemon so it can clean up.
async fn send_emigrate_done(
    rd: &RemoteDaemons,
    remote_name: &RemoteName,
    session_id: &ThreadId<str>,
) -> Result<(), BoxError> {
    let (tx, _rx) = rd.open_raw_connection(remote_name).await?;
    tx.send(ClientMessage::EmigrateDone {
        root_thread_id: session_id.to_owned(),
    })
    .map_err(|e| e.into())
}