Skip to content

armgit / Edge0

Public Imported from GitHub
0

Run 35B MoE models in ~2.5 GB of RAM. Weights stream from SSD; a trained router predicts loads a step ahead. Mac, iPhone, Android, Windows supported

Python
8.8 KB
Raw Blame
//! The shell holds every daemon connection. The webview never sees tokens or host addresses.

use std::sync::RwLock;

use edge0_core::paths::Home;
use edge0_core::protocol::SystemSnapshot;
use serde_json::Value;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BridgeTarget {
    pub base: String,
    pub loopback: bool,
}

impl BridgeTarget {
    pub fn from_base(base: &str) -> Option<Self> {
        let u = url_like(base)?;
        Some(Self {
            base: base.trim_end_matches('/').to_string(),
            loopback: {
                let lo = std::net::Ipv4Addr::LOCALHOST.to_string();
                u.0 == lo || u.0 == "localhost" || u.0 == "::1"
            },
        })
    }
}

fn url_like(s: &str) -> Option<(String, Option<u16>)> {
    let rest = s
        .strip_prefix("http://")
        .or_else(|| s.strip_prefix("https://"))?;
    let hostport = rest.trim_end_matches('/');
    match hostport.rsplit_once(':') {
        Some((h, p)) => Some((h.to_string(), p.parse().ok())),
        None => Some((hostport.to_string(), None)),
    }
}

#[derive(Debug, thiserror::Error)]
pub enum BridgeError {
    #[error("Local service not found: {0}. Open edge0.app or run `edge0 serve`")]
    NoService(String),
    #[error("Authentication required: non-loopback targets need EDGE0_TOKEN")]
    TokenRequired,
    #[error("{message}")]
    Api {
        status: u16,
        code: Option<String>,
        message: String,
    },
    #[error("Protocol decode failed: {0}")]
    Decode(String),
}

impl BridgeError {
    pub fn code(&self) -> Option<&str> {
        match self {
            BridgeError::Api { code, .. } => code.as_deref(),
            _ => None,
        }
    }
    pub fn status(&self) -> Option<u16> {
        match self {
            BridgeError::Api { status, .. } => Some(*status),
            _ => None,
        }
    }

    pub fn to_json(&self) -> String {
        serde_json::json!({
            "status": self.status(),
            "code": self.code(),
            "message": self.to_string(),
        })
        .to_string()
    }
}

pub struct Bridge {
    http: reqwest::Client,
    /// No overall timeout: reqwest `.timeout()` covers the whole body and would cut long chat streams.
    stream_http: reqwest::Client,
    probe_http: reqwest::Client,
    target: RwLock<Option<BridgeTarget>>,
    pinned: bool,
    home: Home,
    env_token: Option<String>,
}

impl Bridge {
    pub fn new(home: Home) -> Self {
        Self::with_override(
            home,
            std::env::var("EDGE0_HOST").ok(),
            std::env::var("EDGE0_TOKEN").ok(),
        )
    }

    pub fn with_override(home: Home, host: Option<String>, token: Option<String>) -> Self {
        let http = reqwest::Client::builder()
            .timeout(std::time::Duration::from_secs(30))
            .no_proxy() // user outbound proxies must not intercept loopback
            .build()
            .expect("reqwest client");
        let stream_http = reqwest::Client::builder()
            .connect_timeout(std::time::Duration::from_secs(5))
            .no_proxy()
            .build()
            .expect("reqwest stream client");
        let (pinned, target) = match host
            .filter(|s| !s.trim().is_empty())
            .and_then(|s| BridgeTarget::from_base(&s))
        {
            Some(t) => (true, Some(t)),
            None => (false, None),
        };
        let probe_http = reqwest::Client::builder()
            .timeout(std::time::Duration::from_millis(2500))
            .connect_timeout(std::time::Duration::from_millis(1000))
            .no_proxy()
            .build()
            .expect("probe client");
        Self {
            http,
            stream_http,
            probe_http,
            target: RwLock::new(target),
            pinned,
            home,
            env_token: token.filter(|s| !s.trim().is_empty()),
        }
    }

    pub fn set_target(&self, t: BridgeTarget) {
        if !self.pinned {
            *self.target.write().unwrap() = Some(t);
        }
    }

    pub fn clear_target(&self) {
        if !self.pinned {
            *self.target.write().unwrap() = None;
        }
    }

    pub fn target(&self) -> Option<BridgeTarget> {
        self.target.read().unwrap().clone()
    }

    fn token(&self, t: &BridgeTarget) -> Option<String> {
        // Loopback is unauthenticated by contract; attaching a token would mis-label GUI traffic as cli.
        if !t.loopback {
            return self.env_token.clone();
        }
        None
    }

    fn req(&self, method: &str, path: &str) -> Result<reqwest::RequestBuilder, BridgeError> {
        self.req_with(&self.http, method, path)
    }

    fn req_with(
        &self,
        client: &reqwest::Client,
        method: &str,
        path: &str,
    ) -> Result<reqwest::RequestBuilder, BridgeError> {
        let t = self
            .target()
            .ok_or_else(|| BridgeError::NoService(path.to_string()))?;
        if !t.loopback && self.env_token.is_none() {
            return Err(BridgeError::TokenRequired);
        }
        let url = format!("{}{}", t.base, path);
        let mut r = match method {
            "GET" => client.get(&url),
            "DELETE" => client.delete(&url),
            _ => client.post(&url),
        };
        if let Some(tok) = self.token(&t) {
            r = r.bearer_auth(tok);
        }
        r = r.header(
            "x-edge0-client-version",
            edge0_core::version::daemon_version(),
        );
        Ok(r)
    }

    pub async fn get_json(&self, path: &str) -> Result<Value, BridgeError> {
        let resp = self
            .req("GET", path)?
            .send()
            .await
            .map_err(|_| BridgeError::NoService(path.to_string()))?;
        decode(resp).await
    }

    pub async fn post_json(&self, path: &str, body: Value) -> Result<Value, BridgeError> {
        let resp = self
            .req("POST", path)?
            .json(&body)
            .send()
            .await
            .map_err(|_| BridgeError::NoService(path.to_string()))?;
        decode(resp).await
    }

    pub async fn req_delete(&self, path: &str) -> Result<Value, BridgeError> {
        let resp = self
            .req("DELETE", path)?
            .send()
            .await
            .map_err(|_| BridgeError::NoService(path.to_string()))?;
        decode(resp).await
    }

    pub async fn system(&self) -> Result<SystemSnapshot, BridgeError> {
        let v = self.get_json("/v1/edge0/system").await?;
        serde_json::from_value(v).map_err(|e| BridgeError::Decode(e.to_string()))
    }

    pub async fn open_stream(
        &self,
        path: &str,
        body: Value,
    ) -> Result<reqwest::Response, BridgeError> {
        self.req_with(&self.stream_http, "POST", path)?
            .header("accept", "text/event-stream")
            .json(&body)
            .send()
            .await
            .map_err(|_| BridgeError::NoService(path.to_string()))
    }

    pub async fn open_events(&self, since: Option<u64>) -> Result<reqwest::Response, BridgeError> {
        let mut r = self.req_with(&self.stream_http, "GET", "/v1/edge0/events")?;
        if let Some(seq) = since {
            r = r.header("last-event-id", seq.to_string());
        }
        r.header("accept", "text/event-stream")
            .send()
            .await
            .map_err(|_| BridgeError::NoService("/v1/edge0/events".to_string()))
    }

    pub async fn health(&self, base: &str) -> Option<serde_json::Value> {
        let mut r = self.probe_http.get(format!("{base}/health"));
        if let Some(t) = BridgeTarget::from_base(base).filter(|t| !t.loopback) {
            if let Some(tok) = self.token(&t) {
                r = r.bearer_auth(tok);
            }
        }
        let resp = r.send().await.ok()?;
        if !resp.status().is_success() {
            return None;
        }
        resp.json().await.ok()
    }

    pub async fn health_ok(&self, base: &str) -> bool {
        self.health(base).await.is_some()
    }

    pub fn http(&self) -> &reqwest::Client {
        &self.http
    }

    pub fn home(&self) -> &Home {
        &self.home
    }
}

async fn decode(resp: reqwest::Response) -> Result<Value, BridgeError> {
    let status = resp.status();
    let v: Value = resp.json().await.unwrap_or(Value::Null);
    if status.is_success() {
        return Ok(v);
    }
    let err = v.get("error");
    let code = err.and_then(|e| e.get("code")).and_then(Value::as_str);
    let message = err
        .and_then(|e| e.get("message"))
        .and_then(Value::as_str)
        .map(str::to_string)
        .unwrap_or_else(|| format!("HTTP {status}"));
    if let Some(id) = code {
        if edge0_core::errorcodes::lookup(id).is_none() {
            return Err(BridgeError::Decode(format!(
                "Unknown error code {id} (not in error-codes.md)"
            )));
        }
    }
    Err(BridgeError::Api {
        status: status.as_u16(),
        code: code.map(str::to_string),
        message,
    })
}