Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

13.2 KB
Raw Blame
use std::collections::VecDeque;
use std::io::{Read, Write};
use std::net::TcpListener;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

use avibe_runtime_host::notifications::{
    HttpNotificationTransport, NotificationPreferences, NotificationTransport, SseDecoder,
};
use avibe_runtime_host::LoopbackOrigin;
use serde_json::json;

struct FakeServer {
    origin: LoopbackOrigin,
    requests: Arc<Mutex<Vec<String>>>,
    stopped: Arc<AtomicBool>,
    thread: Option<std::thread::JoinHandle<()>>,
}

impl FakeServer {
    fn start(responses: impl IntoIterator<Item = Vec<u8>>) -> Self {
        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
        listener.set_nonblocking(true).unwrap();
        let origin = LoopbackOrigin::parse(&format!("http://{}", listener.local_addr().unwrap())).unwrap();
        let requests = Arc::new(Mutex::new(Vec::new()));
        let received = requests.clone();
        let stopped = Arc::new(AtomicBool::new(false));
        let stop = stopped.clone();
        let mut responses = responses.into_iter().collect::<VecDeque<_>>();
        let thread = std::thread::spawn(move || {
            while !stop.load(Ordering::SeqCst) {
                match listener.accept() {
                    Ok((mut stream, _)) => {
                        stream.set_nonblocking(false).unwrap();
                        stream.set_read_timeout(Some(Duration::from_millis(50))).unwrap();
                        stream.set_write_timeout(Some(Duration::from_secs(1))).unwrap();
                        let mut request = Vec::new();
                        let deadline = Instant::now() + Duration::from_secs(3);
                        while !request.windows(4).any(|chunk| chunk == b"\r\n\r\n") {
                            if stop.load(Ordering::SeqCst) {
                                return;
                            }
                            assert!(
                                Instant::now() < deadline,
                                "request headers must arrive before the deadline"
                            );
                            let mut buffer = [0; 1024];
                            match stream.read(&mut buffer) {
                                Ok(0) => panic!("request headers were truncated"),
                                Ok(length) => request.extend_from_slice(&buffer[..length]),
                                Err(error)
                                    if matches!(
                                        error.kind(),
                                        std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
                                    ) =>
                                {
                                    continue
                                }
                                Err(error) => panic!("fake request failed: {error}"),
                            }
                            assert!(request.len() <= 16 * 1024);
                        }
                        received.lock().unwrap().push(String::from_utf8(request).unwrap());
                        let response = responses.pop_front().expect("only the expected requests are allowed");
                        let _ = stream.write_all(&response);
                    }
                    Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
                        std::thread::sleep(Duration::from_millis(1));
                    }
                    Err(error) => panic!("fake listener failed: {error}"),
                }
            }
        });
        Self {
            origin,
            requests,
            stopped,
            thread: Some(thread),
        }
    }

    fn transport(&self) -> HttpNotificationTransport {
        HttpNotificationTransport::new(self.origin.clone()).unwrap()
    }
}

impl Drop for FakeServer {
    fn drop(&mut self) {
        self.stopped.store(true, Ordering::SeqCst);
        if let Some(thread) = self.thread.take() {
            let result = thread.join();
            if !std::thread::panicking() {
                result.expect("fake server exited cleanly");
            }
        }
    }
}

fn response(status: &str, content_type: &str, body: &[u8]) -> Vec<u8> {
    let mut response = format!(
        "HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
        body.len()
    )
    .into_bytes();
    response.extend_from_slice(body);
    response
}

#[tokio::test]
async fn production_framing_uses_only_the_adopted_origin_and_reconnect_never_sends_a_replay_cursor() {
    let event = b": stream connected\n\nevent: connected\ndata: {}\n\n: ping\n\nid: never-replay\nevent: vaults.updated\ndata: {\"type\":\"vaults.updated\",\"data\":{\"request_id\":\"request\",\"request_status\":\"pending\"}}\n\n";
    let server = FakeServer::start([
        response("200 OK", "text/event-stream; charset=utf-8", event),
        response("200 OK", "text/event-stream", b": stream connected\n\n"),
    ]);
    let transport = server.transport();
    let mut first = transport.connect().await.unwrap();
    let mut decoder = SseDecoder::new();
    let mut frames = Vec::new();
    while let Some(chunk) = first.next_chunk().await.unwrap() {
        frames.extend(decoder.push(&chunk));
    }
    assert_eq!(frames.len(), 2);
    assert_eq!(frames[1].event, "vaults.updated");
    let mut second = transport.connect().await.unwrap();
    while second.next_chunk().await.unwrap().is_some() {}
    let requests = server.requests.lock().unwrap();
    assert_eq!(requests.len(), 2);
    for request in requests.iter() {
        let normalized = request.to_ascii_lowercase();
        assert!(request.starts_with("GET /api/events HTTP/1.1\r\n"));
        assert!(normalized.contains("accept: text/event-stream\r\n"));
        for forbidden in ["last-event-id:", "authorization:", "cookie:"] {
            assert!(!normalized.contains(forbidden));
        }
    }
}

#[tokio::test]
async fn stream_and_detail_redirects_never_delegate_trust_to_another_origin() {
    let target = FakeServer::start([]);
    let redirect = format!(
        "HTTP/1.1 302 Found\r\nLocation: {}/api/events\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
        target.origin.as_str()
    )
    .into_bytes();
    let server = FakeServer::start([redirect.clone(), redirect.clone(), redirect.clone(), redirect]);
    let transport = server.transport();
    assert!(transport.connect().await.is_err());
    assert!(transport.run_detail("run").await.is_none());
    assert!(transport.unread_total().await.is_none());
    assert!(transport.preferences().await.is_none());
    assert!(target.requests.lock().unwrap().is_empty());
    assert_eq!(server.requests.lock().unwrap().len(), 4);
}

#[tokio::test]
async fn stream_requires_a_successful_sse_response_not_an_arbitrary_live_http_endpoint() {
    let server = FakeServer::start([
        response("200 OK", "text/html", b"<html>not SSE</html>"),
        response("503 Unavailable", "text/event-stream", b": unavailable\n\n"),
        response("204 No Content", "text/event-stream", b""),
    ]);
    for _ in 0..3 {
        assert!(server.transport().connect().await.is_err());
    }
}

#[tokio::test]
async fn refetch_requires_the_requested_run_and_bounds_untrusted_detail_bodies() {
    let valid = json!({"ok": true, "run": {
        "id": "run", "started_at": "2026-09-10T12:00:00Z", "updated_at": "2026-09-10T12:00:30Z",
        "notification_category": "bot",
        "session_project_name": "avibe-app", "session_label": "桌面版检查更新", "definition_name": null,
    }});
    let server = FakeServer::start([
        response("200 OK", "application/json", valid.to_string().as_bytes()),
        response(
            "200 OK",
            "application/json",
            json!({"ok": true, "run": {"id": "another"}}).to_string().as_bytes(),
        ),
        response("404 Not Found", "application/json", b"{}"),
        response("200 OK", "application/json", b"not-json"),
        response("200 OK", "application/json", &vec![b'x'; 256 * 1024 + 1]),
        b"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 999999999\r\nConnection: close\r\n\r\n"
            .to_vec(),
    ]);
    let transport = server.transport();
    let detail = transport.run_detail("run").await.unwrap();
    assert_eq!(detail.stamps.started_at, Some("2026-09-10T12:00:00Z".into()));
    assert_eq!(detail.stamps.updated_at, Some("2026-09-10T12:00:30Z".into()));
    assert_eq!(detail.notification_category.as_deref(), Some("bot"));
    assert_eq!(detail.source(), Some("avibe-app · 桌面版检查更新".into()));
    for _ in 0..5 {
        assert!(transport.run_detail("run").await.is_none());
    }
    for request in server.requests.lock().unwrap().iter() {
        assert!(request.starts_with("GET /api/harness/runs/run HTTP/1.1\r\n"));
    }
}

#[tokio::test]
async fn identifiers_are_encoded_as_one_path_segment_not_runtime_selected_routes() {
    let server = FakeServer::start([response("404 Not Found", "application/json", b"{}")]);
    let transport = server.transport();
    for key in ["", ".", ".."] {
        assert!(transport.run_detail(key).await.is_none());
    }
    assert!(server.requests.lock().unwrap().is_empty());
    assert!(transport.run_detail("../settings?token=secret#片段").await.is_none());
    let requests = server.requests.lock().unwrap();
    assert_eq!(requests.len(), 1);
    assert!(
        requests[0].starts_with("GET /api/harness/runs/..%2Fsettings%3Ftoken=secret%23%E7%89%87%E6%AE%B5 HTTP/1.1\r\n")
    );
}

#[tokio::test]
async fn preferences_require_a_complete_valid_snapshot_on_the_adopted_origin() {
    let server = FakeServer::start([
        response(
            "200 OK",
            "application/json",
            br#"{"ok":true,"preferences":{"enabled":true,"bots":false,"sessions":true,"future":[]}}"#,
        ),
        response("404 Not Found", "application/json", b"{}"),
        response(
            "200 OK",
            "application/json",
            br#"{"ok":false,"preferences":{"enabled":true,"bots":true,"sessions":true}}"#,
        ),
        response(
            "200 OK",
            "application/json",
            br#"{"ok":true,"preferences":{"enabled":true}}"#,
        ),
        response(
            "200 OK",
            "application/json",
            br#"{"ok":true,"preferences":{"enabled":true,"bots":"false","sessions":true}}"#,
        ),
        response("200 OK", "application/json", b"not-json"),
        response("200 OK", "application/json", &vec![b' '; 256 * 1024 + 1]),
    ]);
    let transport = server.transport();
    assert_eq!(
        transport.preferences().await,
        Some(NotificationPreferences {
            enabled: true,
            bots: false,
            sessions: true
        })
    );
    for _ in 0..6 {
        assert_eq!(transport.preferences().await, None);
    }
    let requests = server.requests.lock().unwrap();
    assert_eq!(requests.len(), 7);
    for request in requests.iter() {
        assert!(request.starts_with("GET /api/notifications/preferences HTTP/1.1\r\n"));
        for forbidden in ["authorization:", "cookie:"] {
            assert!(!request.to_ascii_lowercase().contains(forbidden));
        }
    }
}

#[tokio::test]
async fn unread_total_prefers_loud_badge_total_and_only_falls_back_when_absent() {
    let server = FakeServer::start([
        response(
            "200 OK",
            "application/json",
            br#"{"sessions":[],"unread_by_session":{"a":2,"b":1},"unread_total":3}"#,
        ),
        response("200 OK", "application/json", br#"{"unread_total":9,"badge_total":2}"#),
        response("200 OK", "application/json", br#"{"unread_total":9,"badge_total":0}"#),
        response("200 OK", "application/json", br#"{"badge_total":4}"#),
        response("200 OK", "application/json", br#"{"sessions":[],"unread_total":0}"#),
        response("200 OK", "application/json", br#"{"unread_total":9,"badge_total":-1}"#),
        response(
            "200 OK",
            "application/json",
            br#"{"unread_total":9,"badge_total":null}"#,
        ),
        response("200 OK", "application/json", br#"{"unread_total":9,"badge_total":"2"}"#),
        response("401 Unauthorized", "application/json", br#"{"unread_total":9}"#),
        response("200 OK", "application/json", br#"{"unread_total":-1}"#),
        response("200 OK", "application/json", br#"{"sessions":[]}"#),
        response("200 OK", "text/html", b"<html>"),
        response("200 OK", "application/json", &vec![b' '; 300 * 1024]),
    ]);
    let transport = server.transport();
    assert_eq!(transport.unread_total().await, Some(3));
    assert_eq!(transport.unread_total().await, Some(2));
    assert_eq!(transport.unread_total().await, Some(0));
    assert_eq!(transport.unread_total().await, Some(4));
    assert_eq!(transport.unread_total().await, Some(0));
    for _ in 0..8 {
        assert_eq!(transport.unread_total().await, None);
    }
    let requests = server.requests.lock().unwrap();
    assert_eq!(requests.len(), 13);
    for request in requests.iter() {
        let normalized = request.to_ascii_lowercase();
        assert!(request.starts_with("GET /api/inbox?platform=avibe&limit=1 HTTP/1.1\r\n"));
        for forbidden in ["authorization:", "cookie:"] {
            assert!(!normalized.contains(forbidden));
        }
    }
}