Skip to content

Open source Grok Bot alternative, Bring your own agent and subscription: message Claude Code, Codex, Gemini CLI, Cursor, Copilot and 40+ AI agents as bots on your own computer, from iPhone, Mac, Windows, Linux or terminal. Agent-agnostic and free. Also a Muse and Dots alternative. Built in Rust.

6.1 KB
Raw Blame
//! After a host restart, what was running starts again; from then on, what listens is read and clients told.

use super::run::launch;
use super::{DevServers, KV_PREFIX, Live, Saved, Status, detected, forget, platform, ports, save};
use crate::LockExt;
use crate::agent::process::Process;
use crate::hub::Hub;
use crate::store::now_ms;
use anyhow::Result;
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc;
use std::time::Duration;

/// A server that shows no port by now counts as running (a watch build may never listen).
pub(super) const SETTLE_MS: i64 = 5_000;
/// How often ports are read while a server is new, and after that.
const SCAN_FAST: Duration = Duration::from_secs(1);
const SCAN_SLOW: Duration = Duration::from_secs(10);
const NEW_FOR_MS: i64 = 30_000;

/// Brings back what was running before the host stopped, then keeps ports up to date.
pub async fn scan_loop(hub: Arc<Hub>) {
    if let Err(error) = resume(&hub).await {
        tracing::warn!(error = format!("{error:#}"), "couldn't restore dev servers");
    }
    let mut interfaces = Vec::new();
    loop {
        scan(&hub, &mut interfaces).await;
        let wait = if hub.dev_servers.any_new() { SCAN_FAST } else { SCAN_SLOW };
        tokio::select! {
            () = tokio::time::sleep(wait) => {}
            () = hub.dev_servers.wake.notified() => {}
        }
    }
}

/// After a host restart a server that was running starts again. After a computer restart it stays stopped, one tap
/// away: an abandoned server shouldn't come back at every login.
async fn resume(hub: &Arc<Hub>) -> Result<()> {
    let keys = hub.store.kv_prefix(KV_PREFIX);
    let saved: Vec<Saved> = keys
        .iter()
        .filter_map(|key| hub.store.kv_get(key))
        .filter_map(|json| serde_json::from_str(&json).ok())
        .collect();
    let booted = tokio::task::spawn_blocking(platform::boot_ms).await?;
    let mut again = Vec::new();
    for mut server in saved {
        let bot_exists = hub.store.bot(&server.bot)?.is_some_and(|row| !row.deleted);
        if !bot_exists {
            forget(&hub.store, &server.id)?;
            continue;
        }
        let same_boot = platform::same_boot(server.boot_ms, booted);
        // A crashed host on Unix leaves the server holding its port.
        if same_boot && let Some(leader) = server.leader.clone() {
            tokio::task::spawn_blocking(move || platform::kill_if_same(leader.pid, &leader.start)).await?;
        }
        if server.wanted && same_boot {
            again.push(server.id.clone());
        } else if server.wanted {
            server.wanted = false;
            save(&hub.store, &server);
        }
        let bot = server.bot.clone();
        hub.dev_servers.live.locked().insert(server.id.clone(), Live::stopped(server));
        hub.emit_bot(&bot);
    }
    for id in again {
        if let Err(error) = launch(hub, &id).await {
            tracing::warn!(error = format!("{error:#}"), "couldn't restart a dev server");
        }
    }
    Ok(())
}

impl DevServers {
    fn any_new(&self) -> bool {
        let now = now_ms();
        self.live.locked().values().any(|live| {
            live.status == Status::Starting
                || (live.status == Status::Running && live.started_at.is_some_and(|at| now - at < NEW_FOR_MS))
        })
    }

    pub(super) fn agents_running(&self) -> Vec<detected::RunningAgent> {
        let mut agents = self.agents.locked();
        agents.retain(|_, agent| agent.acp.strong_count() > 0);
        agents
            .iter()
            .filter_map(|(bot, agent)| {
                Some(detected::RunningAgent {
                    bot: bot.clone(),
                    acp: agent.acp.upgrade()?,
                    programs: agent.programs.clone(),
                })
            })
            .collect()
    }
}

/// Reads what listens, and tells clients what changed. `known`: this computer's addresses at the last scan.
async fn scan(hub: &Arc<Hub>, known: &mut Vec<IpAddr>) {
    let servers = &hub.dev_servers;
    let running: Vec<(String, Arc<tokio::sync::Mutex<Process>>)> = servers
        .live
        .locked()
        .iter()
        .filter_map(|(id, live)| Some((id.clone(), live.run.as_ref()?.process.clone())))
        .collect();
    let agents = servers.agents_running();
    let had_detected = !servers.detected.locked().is_empty();
    if running.is_empty() && agents.is_empty() && !had_detected {
        return;
    }
    let read = tokio::task::spawn_blocking(|| anyhow::Ok((ports::listening()?, ports::interfaces()))).await;
    let (listening, interfaces) = match read.map_err(anyhow::Error::from).flatten() {
        Ok(read) => read,
        Err(error) => {
            tracing::warn!(error = format!("{error:#}"), "couldn't read listening ports");
            return;
        }
    };
    let moved = *known != interfaces;
    *known = interfaces;
    let pids: Vec<u32> = listening.iter().map(|l| l.pid).collect();
    for (id, process) in running {
        let members = process.lock().await.members(&pids);
        let sockets = ports::sockets_of(&listening, &members);
        update(hub, &id, sockets, moved).await;
    }
    detected::scan(hub, &agents, &listening, moved).await;
}

/// Records a server's sockets. `moved`: this computer's addresses changed, so those of a server on all of them did.
async fn update(hub: &Hub, id: &str, sockets: Vec<SocketAddr>, moved: bool) {
    let stale = hub.dev_servers.live.locked().get(id).is_some_and(|live| {
        live.sockets != sockets || (moved && sockets.iter().any(|socket| socket.ip().is_unspecified()))
    });
    // Reading the addresses starts a process, so only when something changed.
    let ports = if stale {
        let sockets = sockets.clone();
        tokio::task::spawn_blocking(move || ports::urls(&sockets)).await.ok()
    } else {
        None
    };
    let bot = {
        let mut live = hub.dev_servers.live.locked();
        let Some(entry) = live.get_mut(id) else { return };
        // It may have ended while the addresses were read.
        let ports = ports.filter(|_| entry.run.is_some());
        if !entry.observed(sockets, ports, now_ms()) {
            return;
        }
        entry.saved.bot.clone()
    };
    hub.emit_bot(&bot);
}