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.

8.1 KB
Raw Blame
"""Actual UI → pinned packaged Runtime → TS → real Vault CLI → GitHub fake."""
import asyncio
import fcntl
import importlib.util
import os
from pathlib import Path
import shlex
import shutil
import socket

import httpx
import pytest
import uvicorn

from config import paths
from core import show_runtime
from tests.test_feedback_intake import APP, github, real_vault, make_payload  # noqa: F401
from tests.test_show_api import create_ingress
from vibe import ui_server

# Capture opt-in artifact paths before the hermetic fixture strips the environment.
MANIFEST = os.environ.get("AVIBE_FEEDBACK_RUNTIME_MANIFEST")
ARCHIVE = os.environ.get("AVIBE_FEEDBACK_RUNTIME_ARCHIVE")


async def test_real_http_packaged_runtime_receipts_and_private_ledger(real_vault, tmp_path, monkeypatch):
    if not MANIFEST or not ARCHIVE:
        pytest.skip("Set AVIBE_FEEDBACK_RUNTIME_MANIFEST and AVIBE_FEEDBACK_RUNTIME_ARCHIVE to SHA-verified deployment artifacts")
    spec = importlib.util.spec_from_file_location("prepare_feedback_runtime", APP / "integration/prepare-runtime.py")
    prepare = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(prepare)
    runtime = prepare.prepare(Path(MANIFEST), Path(ARCHIVE), tmp_path / "runtime-package")
    ingress = create_ingress(tmp_path)
    for name in ("api", "lib"):
        shutil.copytree(APP / name, ingress.workspace / name, dirs_exist_ok=True)
    for name in ("worker.py", ".show-api.json"):
        shutil.copyfile(APP / name, ingress.workspace / name)
    monkeypatch.setenv("AVIBE_FEEDBACK_APP_ROOT", str(ingress.workspace))
    monkeypatch.setenv("AVIBE_FEEDBACK_PYTHON", os.sys.executable)
    monkeypatch.setenv("HTTP_PROXY", "http://127.0.0.1:1")
    monkeypatch.setenv("HTTPS_PROXY", "http://127.0.0.1:1")
    monkeypatch.setenv("ALL_PROXY", "http://127.0.0.1:1")
    monkeypatch.setenv("NO_PROXY", "")
    manager = show_runtime.ShowRuntimeManager(
        command=shlex.join([shutil.which("node"), str(runtime / "packages/runtime/dist/cli.js")]),
        workspace_root=paths.get_show_pages_dir(), runtime_dir=tmp_path / "runtime-state", auto_install=False, offline=True,
    )
    monkeypatch.setattr(show_runtime, "get_show_runtime_manager", lambda: manager)
    listener = socket.socket()
    listener.bind(("127.0.0.1",0))
    port = listener.getsockname()[1]
    server = uvicorn.Server(uvicorn.Config(ui_server.app, lifespan="off", log_level="error"))
    task = None
    prefix = f"/p/{ingress.page.share_id}"
    headers = {"Host":"alex.avibe.bot", "Content-Type":"application/json"}
    try:
        ready = await manager.ensure()
        assert ready.available, ready.reason
        task = asyncio.create_task(server.serve(sockets=[listener]))
        for _ in range(100):
            if server.started:
                break
            await asyncio.sleep(.02)
        assert server.started
        async with httpx.AsyncClient(base_url=f"http://127.0.0.1:{port}", trust_env=False, timeout=35) as client:
            payload = make_payload()
            import json
            request_id = json.loads(payload)["request_id"]
            posted = await client.post(prefix + "/api/feedback", content=payload, headers=headers)
            assert posted.status_code == 202, posted.text
            assert posted.json() == {"ok":True}, "Native POST must remain status only"
            found = await client.get(prefix + "/api/feedback-status", params={"request_id":request_id}, headers=headers)
            assert found.status_code == 200, found.text
            assert found.json() == dict(schema_version=1, request_id=request_id, state="created", issue_number=100,
                                        issue_url="https://github.com/avibe-bot/avibe/issues/100")
            assert found.headers["cache-control"] == "no-store"
            repeat = await client.post(prefix + "/api/feedback", content=payload, headers=headers)
            assert repeat.status_code == 202
            conflict = await client.post(prefix + "/api/feedback", content=make_payload(request_id, body="changed"), headers=headers)
            assert conflict.status_code == 409
            invalid = await client.post(prefix + "/api/feedback", content=b'\xff', headers=headers)
            assert invalid.status_code == 400
            huge = await client.post(prefix + "/api/feedback", content=b'x'*32769, headers=headers)
            assert huge.status_code == 413
            wrong_method = await client.put(prefix + "/api/feedback", content=payload, headers=headers)
            assert wrong_method.status_code in (403,404,405)
            absent = await client.get(prefix + "/api/feedback-status", params={"request_id":"1afe402a-a181-4487-8f65-42e22c3f7fab"}, headers=headers)
            assert absent.status_code == 404
            assert len(real_vault.issues) == 1
            # DB/WAL/SHM live outside every Show workspace. Public static, asset,
            # API and absolute filesystem attempts must never return their bytes.
            for suffix in ("", "-wal", "-shm"):
                database = os.environ["AVIBE_FEEDBACK_DATABASE"] + suffix
                for route in (f"/ledger.sqlite{suffix}", f"/assets/ledger.sqlite{suffix}", f"/api/ledger.sqlite{suffix}", f"/@fs{database}", f"/../../{database.lstrip('/')}"):
                    leak = await client.get(prefix + route, headers=headers)
                    assert "SQLite format" not in leak.text
                    assert "Observed: 中文" not in leak.text
                    assert "synthetic-feedback-pat" not in leak.text
            unknown_payload = make_payload(title="Write completed before disconnect")
            real_vault.mode = "disconnect"
            result = await client.post(prefix + "/api/feedback", content=unknown_payload, headers=headers)
            assert result.status_code == 503
            unknown_id = json.loads(unknown_payload)["request_id"]
            unknown = await client.get(prefix + "/api/feedback-status", params={"request_id":unknown_id}, headers=headers)
            assert unknown.json() == dict(schema_version=1, request_id=unknown_id, state="unknown")
            await client.post(prefix + "/api/feedback", content=unknown_payload, headers=headers)
            assert len(real_vault.issues) == 2
            # Actual worker started through HTTP/CLI must publish a durable
            # known-no-write result when both kernel slots are occupied.
            locks = [open(os.environ["AVIBE_FEEDBACK_DATABASE"] + f".slot{i}", "a") for i in range(2)]
            saturated_payload = make_payload(title="Saturated worker slots")
            saturated_id = json.loads(saturated_payload)["request_id"]
            try:
                for lock in locks:
                    fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
                saturated = await client.post(prefix + "/api/feedback", content=saturated_payload, headers=headers)
                assert saturated.status_code == 503
                failed = await client.get(prefix + "/api/feedback-status", params={"request_id":saturated_id}, headers=headers)
                assert failed.json() == dict(schema_version=1, request_id=saturated_id, state="failed")
            finally:
                for lock in locks:
                    lock.close()
            assert len(real_vault.issues) == 2
            # Fill the persistent admission quota and prove 429 creates no row.
            from tests.test_feedback_intake import load_worker
            worker = load_worker()
            with worker._database() as db:
                import time
                db.execute("UPDATE limits SET count=5,window=? WHERE name='minute'", (int(time.time())//60,))
            limited_payload = make_payload(title="Pre-reservation limited")
            limited = await client.post(prefix + "/api/feedback", content=limited_payload, headers=headers)
            assert limited.status_code == 429
            missing = await client.get(prefix + "/api/feedback-status", params={"request_id":json.loads(limited_payload)["request_id"]}, headers=headers)
            assert missing.status_code == 404 and len(real_vault.issues) == 2
    finally:
        server.should_exit = True
        if task:
            await asyncio.wait_for(task,10)
        listener.close()
        manager.stop()