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.

19.8 KB
Raw Blame
//! Host messages: the event stream and command replies.

use std::collections::HashMap;

use serde_json::{Value, json};

use super::{After, App, Bot, Dir, Entry, Focus, Msg, Overlay, Status, merge_toggles};

/// An entry the mirror doesn't hold, below the floor its bot's loaded chat had when this
/// connection began: `seq` grows with insertion, so it predates the window and only arrived because
/// its rev was bumped (a rewrite, a reaction). History paging brings it.
fn outside_window(floor: Option<i64>, held: bool, e: &Entry) -> bool {
    !held && floor.is_some_and(|f| e.seq < f)
}

impl App {
    pub fn on_msg(&mut self, m: Msg) {
        match m {
            Msg::Online(on) => {
                self.online = on;
                if !on && self.error.is_none() && self.bots.is_empty() {
                    // Say why instead of spinning on "Connecting…".
                    self.call("hello", json!({}), After::Hello);
                }
                if on {
                    self.error = None;
                    // Every reconnect: the host may have been updated (or replaced) meanwhile.
                    self.call("hello", json!({}), After::Hello);
                }
            }
            Msg::Rewind => {
                self.bots.clear();
                self.entries.clear();
                self.history_done.clear();
                self.floors.clear();
            }
            Msg::Connected { since } => {
                self.stream_since = since;
                self.floors.clear();
            }
            Msg::Event(v) => self.on_event(&v),
            Msg::Reply(after, r) => self.on_reply(after, r),
            Msg::FileDownload { id, status, done } => {
                if self.download.as_ref().is_some_and(|job| job.id == id) {
                    self.flash(&status.unwrap_or_else(|error| format!("Download failed: {error}")));
                    if done {
                        self.download = None;
                    }
                }
            }
            Msg::Term(id, v) => self.on_term(&id, &v),
        }
    }

    fn on_event(&mut self, v: &Value) {
        match v["type"].as_str() {
            Some("hello") => {
                self.snapshot_floors();
                self.network = v["network"].clone();
                if !v["usage"].is_null() {
                    self.usage = v["usage"].clone();
                }
            }
            Some("usage") => self.usage = v["usage"].clone(),
            Some("screen") => self.screen = v["screen"].clone(),
            Some("network") => self.network_changed(&v["network"]),
            Some("cloud") => self.cloud = v["cloud"].clone(),
            Some("pairingRequests") => self.pairing_requests_changed(v),
            Some("bot") => {
                self.upsert_bot(&v["bot"]);
                self.memory_moved(&v["bot"]);
            }
            Some("artifact") => self.artifact_changed(&v["artifact"]),
            Some("entry") => {
                if let Some((bot, e)) = Entry::parse(&v["entry"])
                    && !self.outside_window(&bot, &e)
                {
                    if !self.entries.get(&bot).is_some_and(|m| m.contains_key(&e.seq)) {
                        self.entry_added(&bot, &e);
                    }
                    self.entries.entry(bot).or_default().insert(e.seq, e);
                }
            }
            _ => {}
        }
    }

    /// A catch-up from `since > 0` starts: remember where each bot's loaded chat begins.
    fn snapshot_floors(&mut self) {
        self.floors = if self.stream_since > 0 {
            self.entries
                .iter()
                .filter_map(|(bot, loaded)| {
                    let oldest = loaded.values().filter(|e| e.seq > 0).map(|e| e.seq).min();
                    Some((bot.clone(), oldest?))
                })
                .collect()
        } else {
            HashMap::new()
        };
    }

    fn outside_window(&self, bot: &str, e: &Entry) -> bool {
        let held = self.entries.get(bot).is_some_and(|m| m.contains_key(&e.seq));
        outside_window(self.floors.get(bot).copied(), held, e)
    }

    fn upsert_bot(&mut self, v: &Value) {
        let Some(id) = v["id"].as_str() else { return };
        if v["deleted"].as_bool().unwrap_or(false) {
            self.bots.remove(id);
            self.entries.remove(id);
            self.floors.remove(id);
            self.drafts.remove(id);
            self.files.remove(id);
            if self.selected.as_deref() == Some(id) {
                self.selected = None;
                self.reply = None;
                self.pick = None;
                self.chat_page = false;
                self.typing = false;
            }
            return;
        }
        let Some(new) = Bot::parse(v) else { return };
        // Marked read once per change.
        if self.bots.get(&new.id).is_none_or(|old| old.unread != new.unread) {
            self.reading.remove(&new.id);
        }
        let old = self.bots.insert(new.id.clone(), new.clone());
        let Some(old) = old else { return };
        let watching = self.selected.as_deref() == Some(new.id.as_str()) && self.chat_visible() && self.term_focused;
        // A member's turn in a group is the group's: it alone says done / needs you.
        if !new.notify || watching || old.away().is_some() || new.away().is_some() {
            return;
        }
        if new.status == Status::NeedsInput && old.status != Status::NeedsInput {
            self.toast(format!("{} needs you", new.name), true);
        } else if old.status == Status::Working && new.status == Status::Idle {
            self.toast(format!("{} is done", new.name), false);
        } else if old.status != Status::Error && new.status == Status::Error {
            self.toast(format!("{} hit an error", new.name), true);
        }
    }

    fn on_reply(&mut self, after: After, r: Result<Value, String>) {
        if let After::Connection(id, step) = after {
            self.connection_reply(&id, step, r);
            return;
        }
        if let After::Sent(key) = after {
            self.sent(&key, r);
            return;
        }
        if let After::Answered(entry) = after {
            self.answering.remove(&entry);
            if let Err(e) = r {
                self.flash(&e);
            }
            return;
        }
        if let After::Sheet(s) = after {
            self.on_sheet_reply(s, r);
            return;
        }
        if let After::Network(n) = after {
            self.network_reply(n, r);
            return;
        }
        if let After::UsageOrder(to) = after {
            self.usage_order_answered(to, r);
            return;
        }
        if matches!(after, After::Pairing | After::Cloud | After::PairingRequests | After::PairingDecided) {
            self.pair_reply(&after, r);
            return;
        }
        let v = match r {
            Ok(v) => v,
            Err(e) => {
                match after {
                    After::Hello => self.error = Some(e),
                    After::Tracked => {}
                    After::History(id) => {
                        self.history_busy.remove(&id);
                    }
                    After::Saved => match self.overlays.last_mut() {
                        Some(Overlay::Form(f)) => {
                            f.saving = false;
                            f.error = Some(e);
                        }
                        Some(Overlay::NewBot(n)) => {
                            n.saving = false;
                            n.error = Some(e);
                        }
                        Some(Overlay::Group(g)) => {
                            g.saving = false;
                            g.error = Some(e);
                        }
                        _ => {}
                    },
                    After::Dirs(id) | After::WorkspaceSelected(id) => {
                        if let Some(Overlay::Folder(p)) = self.overlays.last_mut()
                            && p.request_id == id
                        {
                            p.error = Some(e);
                            p.busy = false;
                        }
                    }
                    _ => self.flash(&e),
                }
                return;
            }
        };
        match after {
            After::Nothing
            | After::Tracked
            | After::Answered(_)
            | After::Sheet(_)
            | After::Network(_)
            | After::UsageOrder(_)
            | After::Sent(_)
            | After::Connection(_, _)
            | After::Pairing
            | After::Cloud
            | After::PairingRequests
            | After::PairingDecided => {}
            After::Installed => {
                self.error = None;
                self.flash("Host installed; connecting…");
                self.call("hello", json!({}), After::Hello);
            }
            After::Hello => {
                self.custom_icons = v["icons"].is_object();
                self.mismatch = crate::compat::check(env!("CARGO_PKG_VERSION"), crate::compat::MIN_HOST, &v);
                v["name"].as_str().unwrap_or("computer").clone_into(&mut self.host);
                v["version"].as_str().unwrap_or_default().clone_into(&mut self.host_version);
                v["home"].as_str().unwrap_or_default().clone_into(&mut self.home);
                self.backends = v["backends"].as_array().cloned().unwrap_or_default();
                self.analytics_hello(&v);
                self.screen = v["screen"].clone();
            }
            After::Analytics => self.analytics_set(&v),
            After::Backends => {
                self.backends = v["backends"].as_array().cloned().unwrap_or_default();
                self.flash("Agents refreshed");
            }
            After::Update => match v["state"]["availableVersion"].as_str() {
                Some(version) => self.flash(&format!("Version {version} is available: run codync-host update")),
                None => self.flash("The host is up to date."),
            },
            After::History(id) => {
                self.history_busy.remove(&id);
                let list = v["entries"].as_array().cloned().unwrap_or_default();
                if list.is_empty() {
                    self.history_done.insert(id);
                }
                for e in &list {
                    if let Some((bot, e)) = Entry::parse(e) {
                        self.entries.entry(bot).or_default().entry(e.seq).or_insert(e);
                    }
                }
            }
            After::WorkspaceSelected(id) => {
                if matches!(self.overlays.last(), Some(Overlay::Folder(p)) if p.request_id == id)
                    && let Some(path) = v["path"].as_str().filter(|p| !p.is_empty())
                {
                    self.overlays.pop();
                    self.folder_chosen(path.to_owned());
                }
            }
            After::Dirs(id) => {
                if let Some(Overlay::Folder(p)) = self.overlays.last_mut()
                    && p.request_id == id
                {
                    v["path"].as_str().unwrap_or_default().clone_into(&mut p.path);
                    p.busy = false;
                    p.remembers = v["recent"].is_array();
                    p.recent = v["recent"]
                        .as_array()
                        .into_iter()
                        .flatten()
                        .filter_map(|item| {
                            let path = item["path"].as_str()?;
                            Some(Dir { name: path.to_owned(), path: path.to_owned(), git: false })
                        })
                        .collect();
                    p.parent = v["parent"].as_str().map(str::to_owned);
                    p.dirs = v["dirs"]
                        .as_array()
                        .into_iter()
                        .flatten()
                        .map(|d| Dir {
                            name: d["name"].as_str().unwrap_or_default().to_owned(),
                            path: d["path"].as_str().unwrap_or_default().to_owned(),
                            git: d["isGit"].as_bool().unwrap_or(false),
                        })
                        .collect();
                    p.query.clear();
                    p.cursor = 0;
                    p.error = None;
                }
            }
            After::Saved => {
                let saved = self
                    .overlays
                    .iter()
                    .rposition(|o| matches!(o, Overlay::Form(_) | Overlay::NewBot(_) | Overlay::Group(_)));
                // A new bot or group opens ready to type; an edit goes back to where it was.
                let created = saved.is_some_and(|i| match &self.overlays[i] {
                    Overlay::NewBot(_) => true,
                    Overlay::Group(g) => g.group_id.is_none(),
                    _ => false,
                });
                if let Some(i) = saved {
                    self.overlays.truncate(i);
                }
                if let Some(id) = v["bot"]["id"].as_str() {
                    let id = id.to_owned();
                    self.upsert_bot(&v["bot"]);
                    if created {
                        self.select(&id);
                        self.chat_page = true;
                        self.focus = Focus::Chat;
                        self.typing = true;
                    }
                }
            }
            After::Connectors | After::Skills => {
                let connectors = matches!(after, After::Connectors);
                let list = self.set_plugins(connectors, v["items"].as_array().cloned().unwrap_or_default());
                if connectors {
                    self.market.0 = list;
                } else {
                    self.market.1 = list;
                }
                for o in &mut self.overlays {
                    if let Overlay::Form(f) = o {
                        if connectors {
                            merge_toggles(&mut f.connectors, &self.market.0);
                        } else {
                            merge_toggles(&mut f.skills, &self.market.1);
                        }
                    }
                }
            }
        }
    }

    fn sent(&mut self, key: &str, result: Result<Value, String>) {
        let Some(sent) = self.sends.get_mut(key) else { return };
        sent.busy = false;
        match result {
            Ok(value) => {
                if self.drafts.get(key).is_some_and(|d| d.text.trim() == sent.text)
                    && self.files.get(key).map_or(&[][..], Vec::as_slice) == sent.files
                {
                    self.drafts.remove(key);
                    self.files.remove(key);
                    self.pasted.remove(key);
                }
                self.sends.remove(key);
                if self.selected.as_deref() == Some(key) {
                    self.reply = None;
                }
                // The stream may already hold a newer copy (its delivery status).
                if let Some((bot, e)) = Entry::parse(&value["entry"]) {
                    self.entries.entry(bot).or_default().entry(e.seq).or_insert(e);
                }
                self.flash("Sent");
            }
            Err(error) => self.flash(&format!("{error} Draft kept; Enter retries, Ctrl+C clears text.")),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::super::{Editor, FIELDS, Field, PendingSend, test_app};
    use super::*;

    fn entry_event(seq: i64) -> Value {
        json!({"type": "entry", "entry": {"botId": "a", "id": format!("e{seq}"), "seq": seq, "turn": seq,
            "kind": "user"}})
    }

    fn seqs(app: &App) -> Vec<i64> {
        app.entries.get("a").map(|m| m.keys().copied().collect()).unwrap_or_default()
    }

    fn connect(app: &mut App, since: i64) {
        app.on_msg(Msg::Connected { since });
        app.on_event(&json!({"type": "hello"}));
    }

    #[test]
    fn rewritten_entry_below_the_floor_waits_for_paging() {
        let mut app = test_app();
        for seq in [5, 6] {
            app.on_event(&entry_event(seq));
        }
        connect(&mut app, 40);
        app.on_event(&entry_event(2));
        assert_eq!(seqs(&app), [5, 6], "below the floor: dropped");
        let mut update = entry_event(5);
        update["entry"]["reactions"] = json!(["x"]);
        app.on_event(&update);
        app.on_event(&entry_event(7));
        assert_eq!(seqs(&app), [5, 6, 7], "held updates and newer entries apply");
        app.on_reply(After::History("a".into()), Ok(json!({"entries": [entry_event(3)["entry"]]})));
        assert_eq!(seqs(&app), [3, 5, 6, 7], "history inserts older entries");
    }

    #[test]
    fn a_full_catch_up_accepts_entries_in_rev_order() {
        let mut app = test_app();
        app.on_event(&entry_event(9)); // a sent message's reply, before catch-up
        connect(&mut app, 0);
        for seq in [4, 2, 7] {
            app.on_event(&entry_event(seq));
        }
        assert_eq!(seqs(&app), [2, 4, 7, 9]);
        connect(&mut app, 40);
        app.on_event(&entry_event(1));
        assert_eq!(seqs(&app), [2, 4, 7, 9], "a later resume floors at the loaded window");
        connect(&mut app, 0);
        app.on_event(&entry_event(1));
        assert_eq!(seqs(&app), [1, 2, 4, 7, 9], "each connection replaces the floors");
    }

    #[test]
    fn floor_rule_is_pure() {
        let (_, e) = Entry::parse(&entry_event(3)["entry"]).expect("parses");
        assert!(outside_window(Some(5), false, &e));
        assert!(!outside_window(Some(5), true, &e));
        assert!(!outside_window(Some(3), false, &e));
        assert!(!outside_window(None, false, &e));
    }

    #[test]
    fn send_failure_keeps_text_files_and_nonce_for_retry() {
        let mut app = test_app();
        let key = "bot";
        let files = vec![std::path::PathBuf::from("/tmp/report.txt")];
        app.drafts.insert(key.into(), Editor::with("draft"));
        app.files.insert(key.into(), files.clone());
        app.sends.insert(
            key.into(),
            PendingSend { text: "draft".into(), files: files.clone(), nonce: "same-nonce".into(), busy: true },
        );
        app.on_reply(After::Sent(key.into()), Err("Disconnected".into()));
        assert_eq!(app.drafts[key].text, "draft");
        assert_eq!(app.files[key], files);
        assert_eq!(app.sends[key].nonce, "same-nonce");
        assert!(!app.sends[key].busy);
        app.on_reply(After::Sent(key.into()), Ok(json!({})));
        assert!(!app.drafts.contains_key(key));
        assert!(!app.files.contains_key(key));
    }

    #[test]
    fn late_send_success_does_not_erase_a_new_draft() {
        let mut app = test_app();
        app.drafts.insert("bot".into(), Editor::with("new draft"));
        app.sends.insert(
            "bot".into(),
            PendingSend { text: "old draft".into(), files: vec![], nonce: "n".into(), busy: true },
        );
        app.on_reply(After::Sent("bot".into()), Ok(json!({})));
        assert_eq!(app.drafts["bot"].text, "new draft");
    }

    #[test]
    fn computer_permission_survives_loading_the_editor() {
        let mut app = test_app();
        app.upsert_bot(&json!({"id":"b", "computer":true}));
        assert!(app.bots["b"].computer);
        assert!(FIELDS.contains(&Field::Computer));
    }

    #[test]
    fn fast_mode_survives_loading_the_editor() {
        let mut app = test_app();
        app.upsert_bot(&json!({"id":"b", "fastMode":true}));
        assert!(app.bots["b"].fast_mode);
        assert!(FIELDS.contains(&Field::Fast));
    }

    #[test]
    fn a_refused_fast_mode_reads_its_reason() {
        let mut app = test_app();
        app.upsert_bot(
            &json!({"id":"b", "fastMode":true, "fastModeSupport":"refused", "fastModeIssue":"requires extra usage"}),
        );
        assert!(app.bots["b"].fast_shown());
        assert!(app.bots["b"].fast_refusal().is_some_and(|why| why.contains("requires extra usage")));
        app.upsert_bot(&json!({"id":"g", "kind":"group", "fastModeSupport":"offered"}));
        assert!(!app.bots["g"].fast_shown());
    }
}