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.

7.5 KB
Raw Blame
//! Track Registry package releases without interrupting running connectors.

use super::{Connector, connectors, install::package_reference, registry::registry_server, update_connectors};
use crate::{LockExt, hub::Hub, store::Store};
use anyhow::{Result, anyhow, bail};
use serde_json::Value;
use std::{collections::HashMap, sync::Arc, time::Duration};
use tokio::time::Instant;

const CHECK_INTERVAL: Duration = Duration::from_hours(6);
const RETRY_INTERVAL: Duration = Duration::from_mins(15);
const POLL_INTERVAL: Duration = Duration::from_mins(1);

pub async fn automatic_loop(hub: Arc<Hub>) {
    let mut tracker = Tracker::default();
    loop {
        // Clients and bot sessions unlock the vault when needed. Background
        // updates must not cause an unsolicited keychain prompt at login.
        if hub.store.secret_key.locked().is_some()
            && let Err(error) = tracker.refresh_due(&hub.store, Instant::now(), registry_server).await
        {
            tracing::warn!(error = format!("{error:#}"), "connector update check failed");
        }
        tokio::time::sleep(POLL_INTERVAL).await;
    }
}

/// Refresh one connector immediately before its process is launched. A failed
/// lookup is deliberately ignored by callers so an installed version remains
/// usable while the Registry or network is unavailable.
pub async fn refresh_connector(store: &Store, id: &str) {
    let Some(before) = connectors(store).ok().and_then(|all| all.into_iter().find(|c| c.id == id)) else {
        return;
    };
    let Some(name) = before.registry_name.as_deref().filter(|_| PackageKind::for_connector(&before).is_some()) else {
        return;
    };
    match registry_server(name).await.and_then(|server| apply_latest(store, &before, &server)) {
        Ok(true) => tracing::info!(connector = id, "connector updated for its next launch"),
        Ok(false) => {}
        Err(error) => tracing::debug!(connector = id, error = format!("{error:#}"), "connector update unavailable"),
    }
}

#[derive(Default)]
struct Tracker {
    next_check: HashMap<String, Instant>,
}

impl Tracker {
    async fn refresh_due(
        &mut self,
        store: &Store,
        now: Instant,
        lookup: impl AsyncFn(&str) -> Result<Value>,
    ) -> Result<()> {
        let installed = connectors(store)?;
        self.next_check.retain(|id, _| installed.iter().any(|c| c.id == *id));
        for c in installed {
            let Some(name) = c.registry_name.as_deref().filter(|_| PackageKind::for_connector(&c).is_some()) else {
                continue;
            };
            if self.next_check.get(&c.id).is_some_and(|next| *next > now) {
                continue;
            }
            let result = match lookup(name).await {
                Ok(server) => apply_latest(store, &c, &server),
                Err(error) => Err(error),
            };
            let interval = match result {
                Ok(changed) => {
                    if changed {
                        tracing::info!(connector = c.id, "connector updated for its next launch");
                    }
                    CHECK_INTERVAL
                }
                Err(error) => {
                    tracing::warn!(
                        connector = c.id,
                        error = format!("{error:#}"),
                        "keeping installed connector version"
                    );
                    RETRY_INTERVAL
                }
            };
            self.next_check.insert(c.id, now + interval);
        }
        Ok(())
    }
}

#[derive(Clone, Copy, PartialEq)]
enum PackageKind {
    Npm,
    Pypi,
    Oci,
    Nuget,
}

impl PackageKind {
    fn for_connector(c: &Connector) -> Option<Self> {
        match c.command.as_deref()? {
            "npx" => Some(Self::Npm),
            "uvx" => Some(Self::Pypi),
            "docker" => Some(Self::Oci),
            "dnx" => Some(Self::Nuget),
            _ => None,
        }
    }

    fn registry_type(self) -> &'static str {
        match self {
            Self::Npm => "npm",
            Self::Pypi => "pypi",
            Self::Oci => "oci",
            Self::Nuget => "nuget",
        }
    }

    fn split_reference(self, reference: &str) -> Option<(&str, &str)> {
        match self {
            Self::Npm | Self::Nuget => reference.rsplit_once('@'),
            Self::Pypi => reference.split_once("=="),
            Self::Oci => {
                reference.split_once('@').or_else(|| reference.rsplit_once(':').filter(|(_, tag)| !tag.contains('/')))
            }
        }
    }
}

struct Replacement {
    index: usize,
    reference: String,
}

/// Match by runtime and package identity, never by the Registry array index.
/// Only the version-bearing argument changes; credentials and user flags stay put.
fn replacement(c: &Connector, server: &Value) -> Result<Option<Replacement>> {
    let Some(kind) = PackageKind::for_connector(c) else { return Ok(None) };
    let mut matched = None;
    for p in server["packages"].as_array().into_iter().flatten() {
        if p["registryType"] != kind.registry_type() || p["transport"]["type"].as_str().is_some_and(|t| t != "stdio") {
            continue;
        }
        let Some(id) = p["identifier"].as_str() else { continue };
        let identity =
            if kind == PackageKind::Oci { kind.split_reference(id).map_or(id, |(name, _)| name) } else { id };
        for (index, arg) in c.args.iter().enumerate() {
            let Some((name, old_version)) = kind.split_reference(arg) else { continue };
            if name != identity {
                continue;
            }
            if matched.is_some() {
                bail!("Registry package selection is ambiguous; keeping installed version");
            }
            let reference = package_reference(p)?;
            let (_, new_version) =
                kind.split_reference(&reference).ok_or_else(|| anyhow!("invalid package reference"))?;
            // Avoid downgrades when a stale Registry replica serves an older release.
            let parse = |v: &str| semver::Version::parse(v.strip_prefix('v').unwrap_or(v));
            if let (Ok(old), Ok(new)) = (parse(old_version), parse(new_version))
                && new < old
            {
                bail!("Registry returned an older package version; keeping installed version");
            }
            matched = Some(Replacement { index, reference });
        }
    }
    matched.map(Some).ok_or_else(|| anyhow!("installed package is no longer offered by the Registry"))
}

fn apply_latest(store: &Store, before: &Connector, server: &Value) -> Result<bool> {
    if before.registry_name.is_none() || before.command.is_none() {
        return Ok(false);
    }
    if server["name"].as_str() != before.registry_name.as_deref() {
        bail!("Registry returned a different server");
    }
    let Some(change) = replacement(before, server)? else { return Ok(false) };
    if before.args[change.index] == change.reference {
        return Ok(false);
    }
    update_connectors(store, |all| {
        let Some(current) = all.iter_mut().find(|c| c.id == before.id) else { return Ok(false) };
        // A concurrent credential edit is preserved. A removal or replacement
        // must never be undone by a lookup that started before it.
        if current.registry_name != before.registry_name
            || current.command != before.command
            || current.args != before.args
        {
            return Ok(false);
        }
        current.args[change.index] = change.reference;
        Ok(true)
    })
}

#[cfg(test)]
#[path = "updates_tests.rs"]
mod tests;