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.

15.0 KB
Raw Blame
//! A bot's dev servers: `/servers` or a click on the port in the chat's header. Clients name a server and never send a
//! command.

use crossterm::event::{KeyCode, KeyEvent};
use serde::Deserialize;
use serde_json::json;

use super::super::app::{After, App, Overlay, copy};
use super::super::l10n::tr;
use super::{Reply, open_browser};
use crate::analytics::reported::{DevServerAction, Reported};
use crate::dev_servers::Status;

const STARTED_BY_SHELL: &str = "Started through the bot's shell: it stops with the bot";
const ONLY_ON_COMPUTER: &str = "Only reachable on the computer";

#[derive(Clone, Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct DevServer {
    pub id: String,
    pub name: String,
    pub command: String,
    pub status: Status,
    pub ports: Vec<DevServerPort>,
    pub exit_code: Option<i32>,
    pub managed: bool,
}

#[derive(Clone, Debug, Default, Deserialize)]
#[serde(default)]
pub struct DevServerPort {
    pub port: u16,
    pub local: String,
    pub remote: Vec<String>,
}

impl DevServer {
    /// What its row shows beside the name.
    pub fn value(&self) -> String {
        match self.status {
            Status::Starting => "Starting".to_owned(),
            Status::Failed => "Failed to start".to_owned(),
            Status::Stopped => "Stopped".to_owned(),
            Status::Running if self.ports.is_empty() => "Running".to_owned(),
            Status::Running => self.ports.iter().map(|p| format!(":{}", p.port)).collect::<Vec<_>>().join(" "),
        }
    }

    fn opens(&self) -> bool {
        self.status == Status::Running && !self.ports.is_empty()
    }

    /// The port to use: on its computer the first, what a browser there opens; elsewhere the first that other devices
    /// can reach, or the first if none listens beyond its computer.
    fn port_from(&self, here: bool) -> Option<&DevServerPort> {
        let beyond = if here { None } else { self.ports.iter().find(|port| !port.remote.is_empty()) };
        beyond.or_else(|| self.ports.first())
    }

    /// Where it can be reached from elsewhere, a line each: every address, since this device may reach only some of them.
    pub fn reachable(&self) -> Vec<String> {
        let Some(port) = self.port_from(false).filter(|_| self.opens()) else { return Vec::new() };
        if port.remote.is_empty() {
            vec![format!("{} · {}", port.local, tr(ONLY_ON_COMPUTER))]
        } else {
            port.remote.clone()
        }
    }

    fn restarts(&self) -> bool {
        self.managed && self.status != Status::Starting
    }

    fn stops(&self) -> bool {
        self.status.active()
    }

    fn removes(&self) -> bool {
        self.managed && !self.status.active()
    }

    /// What the selected server's keys do: the sheet's footer offers only these.
    pub fn key_hints(&self) -> Vec<&'static str> {
        let mut keys = vec!["↑↓ select"];
        if self.opens() {
            keys.extend(["enter open", "c copy"]);
        } else if self.managed {
            keys.push("enter logs");
        }
        if self.managed {
            keys.push("l logs");
        }
        if self.restarts() {
            keys.push(if self.status.active() { "r restart" } else { "r start" });
        }
        if self.stops() {
            keys.push("s stop");
        }
        if self.removes() {
            keys.push("x remove");
        }
        keys.push("esc close");
        keys
    }

    /// What the sheet says of the selected server beyond its row.
    pub fn note(&self) -> String {
        if self.managed { self.exit_note().unwrap_or_default() } else { tr(STARTED_BY_SHELL).into_owned() }
    }

    fn exit_note(&self) -> Option<String> {
        let code = self.exit_code.filter(|_| self.status == Status::Failed)?;
        Some(tr("Exit code {code}").replace("{code}", &code.to_string()))
    }
}

/// What the chat's header shows of a bot's servers.
#[derive(Debug, PartialEq, Eq)]
pub enum DevServerSummary {
    Running(String),
    Starting,
    Failed,
}

pub fn summary(servers: &[DevServer]) -> Option<DevServerSummary> {
    let running: Vec<&DevServer> = servers.iter().filter(|s| s.status == Status::Running).collect();
    let first = running.iter().find(|s| !s.ports.is_empty()).or_else(|| running.first());
    if let Some(first) = first {
        let label = first.ports.first().map_or_else(|| first.name.clone(), |p| format!(":{}", p.port));
        let more = running.len() - 1;
        return Some(DevServerSummary::Running(if more > 0 { format!("{label} +{more}") } else { label }));
    }
    if servers.iter().any(|s| s.status == Status::Starting) {
        return Some(DevServerSummary::Starting);
    }
    servers.iter().any(|s| s.status == Status::Failed).then_some(DevServerSummary::Failed)
}

pub struct DevServersSheet {
    pub bot: String,
    pub selected: usize,
    /// The selected server's log, once opened: `None` lists the servers.
    pub logs: Option<LogsView>,
}

pub struct LogsView {
    pub id: String,
    pub name: String,
    /// The line under its name: the command, and how it ended if it failed.
    pub detail: String,
    pub text: Option<String>,
    /// Why the last read failed. What an earlier one read stays in `text`.
    pub error: Option<String>,
    pub scroll: usize,
}

impl App {
    pub(in crate::tui) fn open_dev_servers(&mut self) {
        let Some(bot) = self.bot().filter(|bot| !bot.dev_servers.is_empty()).map(|bot| bot.id.clone()) else { return };
        self.overlays.push(Overlay::DevServers(DevServersSheet { bot, selected: 0, logs: None }));
    }

    /// The answer to `read_logs`, for the sheet still showing that server.
    pub(super) fn dev_server_logs(&mut self, id: &str, read: Result<String, String>) {
        for overlay in &mut self.overlays {
            if let Overlay::DevServers(sheet) = overlay
                && let Some(logs) = sheet.logs.as_mut().filter(|logs| logs.id == id)
            {
                match read {
                    Ok(text) => {
                        logs.text = Some(text);
                        logs.error = None;
                    }
                    Err(error) => logs.error = Some(error),
                }
                return;
            }
        }
    }

    fn servers_of(&self, bot: &str) -> Vec<DevServer> {
        self.bots.get(bot).map(|bot| bot.dev_servers.clone()).unwrap_or_default()
    }

    pub(in crate::tui) fn dev_servers_key(&mut self, mut sheet: DevServersSheet, k: KeyEvent) -> Option<Overlay> {
        if let Some(logs) = &mut sheet.logs {
            match k.code {
                KeyCode::Esc | KeyCode::Char('q') => sheet.logs = None,
                KeyCode::Up | KeyCode::Char('k') => logs.scroll += 1,
                KeyCode::Down | KeyCode::Char('j') => logs.scroll = logs.scroll.saturating_sub(1),
                KeyCode::Char('r') => self.read_logs(&sheet.bot, &logs.id),
                _ => {}
            }
            return Some(Overlay::DevServers(sheet));
        }
        let servers = self.servers_of(&sheet.bot);
        if servers.is_empty() {
            return None;
        }
        sheet.selected = sheet.selected.min(servers.len() - 1);
        let server = &servers[sheet.selected];
        let call = |app: &Self, method: &'static str| {
            app.call(method, json!({"botId": sheet.bot, "id": server.id}), After::Nothing);
        };
        match k.code {
            KeyCode::Esc | KeyCode::Char('q') => return None,
            KeyCode::Up | KeyCode::Char('k') => sheet.selected = (sheet.selected + servers.len() - 1) % servers.len(),
            KeyCode::Down | KeyCode::Char('j') => sheet.selected = (sheet.selected + 1) % servers.len(),
            KeyCode::Enter if server.opens() => self.open_dev_server(server),
            KeyCode::Enter | KeyCode::Char('l') if server.managed => {
                sheet.logs = Some(self.logs_of(&sheet.bot, server));
            }
            KeyCode::Char('c') if server.opens() => self.copy_dev_server(server),
            KeyCode::Char('r') if server.restarts() => call(self, "devServerRestart"),
            KeyCode::Char('s') if server.stops() => call(self, "devServerStop"),
            KeyCode::Char('x') if server.removes() => call(self, "devServerRemove"),
            _ => {}
        }
        Some(Overlay::DevServers(sheet))
    }

    fn read_logs(&self, bot: &str, id: &str) {
        self.call("devServerLogs", json!({"botId": bot, "id": id}), After::Sheet(Reply::DevServerLogs(id.to_owned())));
    }

    fn logs_of(&self, bot: &str, server: &DevServer) -> LogsView {
        self.read_logs(bot, &server.id);
        let detail = match server.exit_note() {
            Some(note) => format!("{} · {note}", server.command),
            None => server.command.clone(),
        };
        LogsView { id: server.id.clone(), name: server.name.clone(), detail, text: None, error: None, scroll: 0 }
    }

    /// In this computer's browser. Anywhere else (a tunnel looks the same from here) shows where it can be reached.
    fn open_dev_server(&mut self, server: &DevServer) {
        if self.on_this_computer && server.port_from(true).is_some_and(|port| open_browser(&port.local, &self.url)) {
            self.track_dev_server(DevServerAction::Open);
            return;
        }
        self.hint =
            Some((server.reachable().join(" · "), std::time::Instant::now() + std::time::Duration::from_secs(5)));
    }

    fn copy_dev_server(&mut self, server: &DevServer) {
        let here = self.on_this_computer;
        let Some(port) = server.port_from(here) else { return };
        copy(if here { &port.local } else { port.remote.first().unwrap_or(&port.local) });
        self.track_dev_server(DevServerAction::Copy);
        self.flash(if here || !port.remote.is_empty() { "Copied" } else { ONLY_ON_COMPUTER });
    }

    fn track_dev_server(&self, action: DevServerAction) {
        self.track(Reported::DevServerAction { action });
    }
}

#[cfg(test)]
mod tests {
    use super::{DevServer, DevServerPort, DevServerSummary, Status, summary, tr};

    fn server(status: Status, port: Option<u16>) -> DevServer {
        DevServer {
            name: "watch".into(),
            status,
            ports: port.map(|port| DevServerPort { port, ..Default::default() }).into_iter().collect(),
            managed: true,
            ..Default::default()
        }
    }

    #[test]
    fn the_header_shows_a_port_and_how_many_more_run() {
        assert_eq!(summary(&[]), None);
        assert_eq!(summary(&[server(Status::Stopped, None)]), None);
        assert_eq!(summary(&[server(Status::Running, Some(5173))]), Some(DevServerSummary::Running(":5173".into())));
        let many =
            [server(Status::Running, None), server(Status::Running, Some(5173)), server(Status::Running, Some(8787))];
        assert_eq!(summary(&many), Some(DevServerSummary::Running(":5173 +2".into())));
        assert_eq!(summary(&[server(Status::Running, None)]), Some(DevServerSummary::Running("watch".into())));
    }

    #[test]
    fn running_outranks_starting_which_outranks_failed() {
        let failed = server(Status::Failed, None);
        assert_eq!(summary(&[failed.clone(), server(Status::Starting, None)]), Some(DevServerSummary::Starting));
        assert_eq!(summary(std::slice::from_ref(&failed)), Some(DevServerSummary::Failed));
        assert_eq!(summary(&[failed, server(Status::Running, Some(1))]), Some(DevServerSummary::Running(":1".into())));
    }

    #[test]
    fn elsewhere_it_shows_every_address_or_says_it_stays_on_the_computer() {
        let port = |remote: &[&str]| DevServerPort {
            port: 5173,
            local: "http://localhost:5173".into(),
            remote: remote.iter().map(ToString::to_string).collect(),
        };
        let with = |ports| DevServer { ports, ..server(Status::Running, None) };
        let (tailscale, lan) = ("http://100.64.0.1:5173", "http://192.168.1.20:5173");
        assert_eq!(with(vec![port(&[lan])]).reachable(), [lan]);
        assert_eq!(with(vec![port(&[tailscale, lan])]).reachable(), [tailscale, lan]);
        let only_here = with(vec![port(&[])]).reachable();
        assert!(only_here[0].starts_with("http://localhost:5173 · "), "{only_here:?}");
        // The first port listens only on the computer; the second doesn't.
        assert_eq!(with(vec![port(&[]), port(&[lan])]).reachable(), [lan]);
        assert_eq!(with(vec![]).reachable(), Vec::<String>::new());
        let stopped = DevServer { ports: vec![port(&[lan])], ..server(Status::Stopped, None) };
        assert_eq!(stopped.reachable(), Vec::<String>::new());
    }

    #[test]
    fn on_its_computer_it_uses_the_first_port_and_elsewhere_the_first_others_can_reach() {
        let port = |port, remote: &[&str]| DevServerPort {
            port,
            remote: remote.iter().map(ToString::to_string).collect(),
            ..Default::default()
        };
        let mixed = DevServer {
            ports: vec![port(3000, &[]), port(5173, &["http://192.168.1.20:5173"])],
            ..server(Status::Running, None)
        };
        assert_eq!(mixed.port_from(true).map(|p| p.port), Some(3000));
        assert_eq!(mixed.port_from(false).map(|p| p.port), Some(5173));
        let only_here = DevServer { ports: vec![port(3000, &[])], ..server(Status::Running, None) };
        assert_eq!(only_here.port_from(false).map(|p| p.port), Some(3000));
    }

    #[test]
    fn the_footer_offers_only_the_keys_that_apply() {
        let keys = |server: &DevServer| server.key_hints().join(" · ");
        assert_eq!(
            keys(&server(Status::Running, Some(1))),
            "↑↓ select · enter open · c copy · l logs · r restart · s stop · esc close"
        );
        assert_eq!(
            keys(&server(Status::Running, None)),
            "↑↓ select · enter logs · l logs · r restart · s stop · esc close"
        );
        assert_eq!(keys(&server(Status::Starting, None)), "↑↓ select · enter logs · l logs · s stop · esc close");
        assert_eq!(
            keys(&server(Status::Failed, None)),
            "↑↓ select · enter logs · l logs · r start · x remove · esc close"
        );
        let shell = DevServer { managed: false, ..server(Status::Running, Some(1)) };
        assert_eq!(keys(&shell), "↑↓ select · enter open · c copy · s stop · esc close");
    }

    #[test]
    fn a_status_from_a_newer_host_reads_as_stopped() {
        let server: DevServer = serde_json::from_str(r#"{"status": "sleeping", "managed": true}"#).expect("it decodes");
        assert_eq!(server.status, Status::Stopped);
        assert_eq!(server.value(), "Stopped");
    }

    #[test]
    fn the_sheet_says_how_it_ended_or_that_it_ends_with_the_bot() {
        let failed = DevServer { exit_code: Some(3), ..server(Status::Failed, None) };
        // Through `tr`: another test may have set the process's language.
        assert_eq!(failed.note(), tr("Exit code {code}").replace("{code}", "3"));
        assert_eq!(server(Status::Running, None).note(), "");
        let shell = DevServer { managed: false, ..server(Status::Running, None) };
        assert_eq!(shell.note(), tr("Started through the bot's shell: it stops with the bot"));
    }
}