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.

10.1 KB
Raw Blame
from __future__ import annotations

import pytest

from tests.ui_server_test_helpers import (
    _save_config,
    csrf_headers,
    remote_peer,
    remote_session_cookie,
)
from vibe import api, remote_access
from vibe.desktop_update_request import read_desktop_update_request
from vibe.upgrade_interruptions import UpgradeInterruptions
from vibe.ui_server import app


TARGET = "3.2.4-rc.1"


def _version(*, has_update: bool = True):
    return {
        "current": "3.2.3rc11",
        "latest": TARGET if has_update else None,
        "has_update": has_update,
        "error": None,
        "managed_by": "desktop",
        "build": {"kind": "package"},
        "remote_install_allowed": False,
        "remote_request": None,
    }


def _acknowledged(*, allowed: bool = False, phase: str = "awaiting_host", error_code=None):
    remote = {
        "request_id": "",
        "target": TARGET,
        "phase": phase,
        "progress": None,
        "error_code": error_code,
        "updated_at": "2026-10-29T02:00:00Z",
    }

    async def wait(request_id: str):
        remote["request_id"] = request_id
        return (
            {
                "latest": TARGET,
                "has_update": True,
                "remote_install_allowed": allowed,
                "remote_request": remote,
            },
            remote,
        )

    return wait


@pytest.mark.parametrize(
    ("role", "expected"),
    [("owner", 409), ("member", 409), ("editor", 403), ("viewer", 403)],
)
def test_desktop_update_request_role_matrix(monkeypatch, tmp_path, role, expected) -> None:
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    config = _save_config(tmp_path, paired=True)
    client = app.test_client()
    client.set_cookie(
        remote_access.SESSION_COOKIE_NAME,
        remote_session_cookie(
            config,
            f"{role}@example.com",
            f"{role}-1",
            role=role,
            access_source="owner" if role == "owner" else "email",
        ),
        domain="alex.avibe.bot",
    )
    response = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET},
        headers=csrf_headers(client, "https://alex.avibe.bot"),
        base_url="https://alex.avibe.bot",
        environ_base=remote_peer(),
    )
    assert response.status_code == expected
    if expected == 403:
        assert response.get_json() == {
            "ok": False,
            "error": "instance_access_forbidden",
            "required_role": "member",
        }
    else:
        assert response.get_json()["error"] == "not_desktop_managed"


def test_desktop_update_request_uses_same_origin_and_csrf_guards(monkeypatch, tmp_path) -> None:
    monkeypatch.setenv("AVIBE_DESKTOP_MANAGED_RUNTIME", "1")
    monkeypatch.setenv("AVIBE_COMPUTER_USE_STATE_DIR", str(tmp_path))
    client = app.test_client()

    missing_csrf = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET},
        headers={"Origin": "http://127.0.0.1"},
    )
    assert missing_csrf.status_code == 403
    assert missing_csrf.get_json()["message"] == "Forbidden: invalid csrf token"

    headers = csrf_headers(client, "http://127.0.0.1")
    invalid_origin = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET},
        headers={**headers, "Origin": "https://attacker.example"},
        base_url="http://127.0.0.1",
    )
    assert invalid_origin.status_code == 403
    assert invalid_origin.get_json()["message"] == "Forbidden: invalid origin"
    assert read_desktop_update_request(tmp_path / "desktop-update-request.json") is None


def test_desktop_update_request_reports_confirmation_and_delivery(monkeypatch, tmp_path) -> None:
    monkeypatch.setenv("AVIBE_DESKTOP_MANAGED_RUNTIME", "1")
    monkeypatch.setenv("AVIBE_COMPUTER_USE_STATE_DIR", str(tmp_path))
    monkeypatch.setattr(api, "get_version_info", _version)

    async def interruptions():
        return UpgradeInterruptions(agents=1, watches=2, tasks=3)

    monkeypatch.setattr(
        "vibe.upgrade_interruptions.count_upgrade_interruptions",
        interruptions,
    )
    client = app.test_client()
    headers = csrf_headers(client, "http://127.0.0.1")
    needs_confirmation = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET},
        headers=headers,
        base_url="http://127.0.0.1",
    )
    assert needs_confirmation.status_code == 409
    assert needs_confirmation.get_json() == {
        "ok": False,
        "error": "confirmation_required",
        "counts": {
            "agents": 1,
            "watches": 2,
            "tasks": 3,
            "total": 6,
            "unknown": False,
        },
    }

    monkeypatch.setattr(
        "vibe.ui_server._wait_for_desktop_update_ack",
        _acknowledged(allowed=True),
    )
    accepted = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET, "confirm_interrupt": True},
        headers=headers,
        base_url="http://127.0.0.1",
    )
    assert accepted.status_code == 200
    assert accepted.get_json()["delivery"] == "install"
    assert accepted.get_json()["request_id"]


@pytest.mark.parametrize(
    ("phase", "error_code", "expected_status", "expected_error"),
    [
        ("failed", "update_in_progress", 409, "update_in_progress"),
        ("failed", "target_mismatch", 200, None),
        ("failed", "check_failed", 200, None),
    ],
)
def test_desktop_update_request_only_returns_sync_shell_rejections(
    monkeypatch,
    tmp_path,
    phase,
    error_code,
    expected_status,
    expected_error,
) -> None:
    monkeypatch.setenv("AVIBE_DESKTOP_MANAGED_RUNTIME", "1")
    monkeypatch.setenv("AVIBE_COMPUTER_USE_STATE_DIR", str(tmp_path))
    monkeypatch.setattr(api, "get_version_info", _version)

    async def no_interruptions():
        return UpgradeInterruptions(0, 0, 0)

    monkeypatch.setattr(
        "vibe.upgrade_interruptions.count_upgrade_interruptions",
        no_interruptions,
    )
    monkeypatch.setattr(
        "vibe.ui_server._wait_for_desktop_update_ack",
        _acknowledged(phase=phase, error_code=error_code),
    )
    client = app.test_client()
    response = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET},
        headers=csrf_headers(client, "http://127.0.0.1"),
        base_url="http://127.0.0.1",
    )
    assert response.status_code == expected_status
    payload = response.get_json()
    if expected_error is None:
        assert payload["ok"] is True
        assert payload["delivery"] == "prompt"
    else:
        assert payload["ok"] is False
        assert payload["error"] == expected_error


@pytest.mark.parametrize(
    ("managed", "has_update", "expected", "status"),
    [
        (False, True, "not_desktop_managed", 409),
        (True, False, "no_update_available", 409),
    ],
)
def test_desktop_update_request_preconditions(
    monkeypatch,
    tmp_path,
    managed,
    has_update,
    expected,
    status,
) -> None:
    if managed:
        monkeypatch.setenv("AVIBE_DESKTOP_MANAGED_RUNTIME", "1")
    else:
        monkeypatch.delenv("AVIBE_DESKTOP_MANAGED_RUNTIME", raising=False)
    monkeypatch.setenv("AVIBE_COMPUTER_USE_STATE_DIR", str(tmp_path))
    monkeypatch.setattr(api, "get_version_info", lambda: _version(has_update=has_update))
    client = app.test_client()
    response = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET},
        headers=csrf_headers(client, "http://127.0.0.1"),
        base_url="http://127.0.0.1",
    )
    assert response.status_code == status
    assert response.get_json()["error"] == expected


def test_desktop_update_request_expires_when_shell_does_not_ack(monkeypatch, tmp_path) -> None:
    monkeypatch.setenv("AVIBE_DESKTOP_MANAGED_RUNTIME", "1")
    monkeypatch.setenv("AVIBE_COMPUTER_USE_STATE_DIR", str(tmp_path))
    monkeypatch.setattr(api, "get_version_info", _version)

    async def no_interruptions():
        return UpgradeInterruptions(0, 0, 0)

    async def no_ack(_request_id):
        return None

    monkeypatch.setattr(
        "vibe.upgrade_interruptions.count_upgrade_interruptions",
        no_interruptions,
    )
    monkeypatch.setattr("vibe.ui_server._wait_for_desktop_update_ack", no_ack)
    client = app.test_client()
    response = client.post(
        "/api/desktop/update/request",
        json={"target_version": TARGET},
        headers=csrf_headers(client, "http://127.0.0.1"),
        base_url="http://127.0.0.1",
    )
    assert response.status_code == 503
    assert response.get_json()["error"] == "desktop_shell_unavailable"
    request = read_desktop_update_request(tmp_path / "desktop-update-request.json")
    assert request is not None
    assert request["state"] == "expired"


def test_upgrade_keeps_legacy_shape_and_optional_confirmation(monkeypatch) -> None:
    expected = {
        "ok": True,
        "message": "updated",
        "output": None,
        "activation_notice": None,
        "restarting": True,
    }
    calls = []
    monkeypatch.setattr(api, "do_upgrade", lambda: calls.append(True) or expected)

    async def active():
        return UpgradeInterruptions(1, 0, 0)

    monkeypatch.setattr("vibe.upgrade_interruptions.count_upgrade_interruptions", active)
    client = app.test_client()
    headers = csrf_headers(client, "http://127.0.0.1")

    legacy = client.post(
        "/api/upgrade",
        json={},
        headers=headers,
        base_url="http://127.0.0.1",
    )
    assert legacy.status_code == 200
    assert legacy.get_json() == expected
    assert calls == [True]

    new_client = client.post(
        "/api/upgrade",
        json={"confirm_interrupt": False},
        headers=headers,
        base_url="http://127.0.0.1",
    )
    assert new_client.status_code == 409
    assert new_client.get_json()["error"] == "confirmation_required"
    assert calls == [True]

    confirmed = client.post(
        "/api/upgrade",
        json={"confirm_interrupt": True},
        headers=headers,
        base_url="http://127.0.0.1",
    )
    assert confirmed.status_code == 200
    assert confirmed.get_json() == expected
    assert calls == [True, True]