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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
from __future__ import annotations
import json
from unittest.mock import Mock
import pytest
from storage import vault_service
from storage.vault_crypto import Sealed
from tests.ui_server_test_helpers import csrf_headers
from vibe import api
from vibe.ui_server import app
def _sealed(suffix: str = "1") -> Sealed:
return Sealed(ciphertext=f"ct-{suffix}", nonce=f"n-{suffix}", wrap_meta=f"wm-{suffix}")
def _mock_avault_p2(monkeypatch):
monkeypatch.setattr(api, "_require_avault_p2_surface", lambda _feature: None)
monkeypatch.setattr(api, "_require_avault_grant_delivery_surface", lambda _feature: None)
monkeypatch.setattr(api, "avault_agent_pubkey", lambda: {"public_key": "pk", "fingerprint": "fp"})
def _issued_agent_dek_payload(request_id: str) -> dict:
issued = api.create_vault_agent_bindings_batch({"request_id": request_id, "grant_duration": 300})
return {
"agent_pubkey": issued["agent_pubkey"],
"deks": [
{
"name": item["name"],
"dek_blindbox": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "ct"},
"approval": item["approval"],
}
for item in issued["items"]
],
}
def test_rest_create_rejects_protected_plaintext_value(monkeypatch):
seal = Mock(return_value=_sealed())
monkeypatch.setattr(api, "avault_seal_blind_box", seal)
client = app.test_client()
response = client.post(
"/api/vault/secrets",
json={"name": "NO_PLAINTEXT", "protection": "protected", "value": "secret"},
headers=csrf_headers(client),
)
assert response.status_code == 400
assert response.get_json()["code"] == "plaintext_value_rejected"
seal.assert_not_called()
def test_rest_create_accepts_blind_box(monkeypatch):
seal = Mock(return_value=_sealed("rest"))
monkeypatch.setattr(api, "avault_seal_blind_box", seal)
client = app.test_client()
blind_box = {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "ct"}
response = client.post(
"/api/vault/secrets",
json={"name": "REST_KEY", "blind_box": blind_box},
headers=csrf_headers(client),
)
assert response.status_code == 200
assert response.get_json()["secret"]["name"] == "REST_KEY"
seal.assert_called_once_with("REST_KEY", blind_box)
def test_rest_create_rejects_standard_plaintext_value(monkeypatch):
seal = Mock()
monkeypatch.setattr(api, "avault_seal_blind_box", seal)
client = app.test_client()
response = client.post(
"/api/vault/secrets",
json={"name": "REST_FALLBACK", "value": "secret"},
headers=csrf_headers(client),
)
assert response.status_code == 400
assert response.get_json()["code"] == "plaintext_value_rejected"
seal.assert_not_called()
def test_rest_list_invalid_tag_returns_vault_error():
client = app.test_client()
response = client.get("/api/vault/secrets?tag=bad%20tag")
assert response.status_code == 409
assert response.get_json()["code"] == "invalid_request"
def test_rest_delete_protected_without_assertion_deletes(monkeypatch):
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
api.create_vault_secret(
{
"name": "PROTECTED_HTTP_DELETE",
"protection": "protected",
"sealed": {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"},
}
)
client = app.test_client()
response = client.delete("/api/vault/secrets/PROTECTED_HTTP_DELETE", headers=csrf_headers(client))
assert response.status_code == 200
assert response.get_json()["removed"] is True
with api._vault_engine().connect() as conn:
with pytest.raises(vault_service.SecretNotFoundError):
vault_service.get_secret_meta(conn, "PROTECTED_HTTP_DELETE")
def test_rest_create_rejects_plaintext_value_in_mixed_payloads(monkeypatch):
seal = Mock()
monkeypatch.setattr(api, "avault_seal_blind_box", seal)
client = app.test_client()
standard = client.post(
"/api/vault/secrets",
json={
"name": "MIXED_REST",
"blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "ct"},
"value": "secret",
},
headers=csrf_headers(client),
)
protected = client.post(
"/api/vault/secrets",
json={
"name": "MIXED_PROTECTED_REST",
"protection": "protected",
"sealed": {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"},
"value": "secret",
},
headers=csrf_headers(client),
)
assert standard.status_code == 400
assert standard.get_json()["code"] == "plaintext_value_rejected"
assert protected.status_code == 400
assert protected.get_json()["code"] == "plaintext_value_rejected"
seal.assert_not_called()
def test_rest_create_rejects_nested_plaintext_value_fields(monkeypatch):
seal = Mock()
monkeypatch.setattr(api, "avault_seal_blind_box", seal)
client = app.test_client()
standard = client.post(
"/api/vault/secrets",
json={
"name": "NESTED_REST",
"blind_box": {
"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1",
"enc": "enc",
"ct": "ct",
"value": "secret",
},
},
headers=csrf_headers(client),
)
protected = client.post(
"/api/vault/secrets",
json={
"name": "NESTED_PROTECTED_REST",
"protection": "protected",
"sealed": {
"ciphertext": "ct",
"nonce": "n",
"wrap_meta": "wm",
"value": "secret",
},
},
headers=csrf_headers(client),
)
assert standard.status_code == 400
assert standard.get_json()["code"] == "plaintext_value_rejected"
assert protected.status_code == 400
assert protected.get_json()["code"] == "plaintext_value_rejected"
seal.assert_not_called()
def test_rest_agent_pubkey_route(monkeypatch):
monkeypatch.setattr(api, "avault_agent_pubkey", Mock(return_value={"public_key": "pk", "fingerprint": "fp"}))
client = app.test_client()
response = client.get("/api/vault/agent/pubkey")
assert response.status_code == 200
assert response.get_json() == {"ok": True, "public_key": "pk", "fingerprint": "fp"}
def test_rest_vault_settings_roundtrip():
client = app.test_client()
defaults = client.get("/api/vault/settings")
saved = client.patch(
"/api/vault/settings",
json={"unlock_window_seconds": 300, "strict_approvals": True, "last_grant_ttl": 900},
headers=csrf_headers(client),
)
assert defaults.status_code == 200
assert defaults.get_json()["settings"]["unlock_window_seconds"] == 600
assert saved.status_code == 200
assert saved.get_json()["settings"] == {
"unlock_window_seconds": 300,
"strict_approvals": True,
"last_grant_ttl": 900,
}
assert saved.get_json()["policy"]["windowSeconds"] == 300
rejected = client.patch(
"/api/vault/settings",
json={"strict_approvals": "false"},
headers=csrf_headers(client),
)
assert rejected.status_code == 409
assert rejected.get_json()["code"] == "invalid_request"
def test_rest_reveal_context_route(monkeypatch):
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
api.create_vault_secret(
{
"name": "PROTECTED_REST_REVEAL",
"protection": "protected",
"sealed": {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"},
}
)
client = app.test_client()
response = client.post(
"/api/vault/secrets/PROTECTED_REST_REVEAL/reveal-context",
json={},
headers=csrf_headers(client),
)
assert response.status_code == 200
body = response.get_json()
assert body["context"]["purpose"] == "reveal"
assert body["envelope"] == {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"}
assert body["context"]["release"] == {
"name": "PROTECTED_REST_REVEAL",
"envelopeHash": api._envelope_hash(body["envelope"]),
}
def test_rest_agent_bindings_batch_route(monkeypatch):
_mock_avault_p2(monkeypatch)
monkeypatch.setattr(api, "avault_agent_pubkey", Mock(return_value={"public_key": "pk", "fingerprint": "fp"}))
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
api.create_vault_secret(
{
"name": "PROTECTED_REST_BINDING",
"protection": "protected",
"sealed": {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"},
}
)
requested = api.request_vault_access({"name": "PROTECTED_REST_BINDING", "session_id": "ses_1"})["request"]
client = app.test_client()
response = client.post(
"/api/vault/agent-bindings:batch",
json={"request_id": requested["id"], "grant_duration": 300},
headers=csrf_headers(client),
)
assert response.status_code == 200
body = response.get_json()
assert body["grant_id"] == requested["card"]["grant_options"][0]["grant_id"]
assert [item["name"] for item in body["items"]] == ["PROTECTED_REST_BINDING"]
def test_rest_agent_binding_legacy_route_bridge(monkeypatch):
_mock_avault_p2(monkeypatch)
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
api.create_vault_secret(
{
"name": "PROTECTED_REST_LEGACY_BINDING",
"protection": "protected",
"sealed": {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"},
}
)
requested = api.request_vault_access({"name": "PROTECTED_REST_LEGACY_BINDING", "session_id": "ses_1"})["request"]
client = app.test_client()
response = client.post(
"/api/vault/agent-binding",
json={
"request_id": requested["id"],
"grant_id": requested["card"]["grant_options"][0]["grant_id"],
"name": "PROTECTED_REST_LEGACY_BINDING",
"ttl_seconds": 300,
},
headers=csrf_headers(client),
)
assert response.status_code == 200
body = response.get_json()
assert body["grant_id"] == requested["card"]["grant_options"][0]["grant_id"]
assert body["binding"]["context"]["purpose"] == "agent-deliver"
assert body["binding"]["context"]["name"] == "PROTECTED_REST_LEGACY_BINDING"
assert set(body["approval"]) == {"nonce", "expires_at_unix"}
def test_rest_security_headers_delegate_webauthn_to_self_and_sandbox():
client = app.test_client()
response = client.get("/api/csrf-token")
permissions = response.headers["Permissions-Policy"]
# Chrome only honors WebAuthn delegation to the cross-origin sandbox iframe when the
# allowlist includes `self` (an origin-only allowlist does not reach the child) — see
# VAULT_SANDBOX_PERMISSIONS_POLICY. Still narrowly scoped to self + the sandbox origin.
assert 'publickey-credentials-get=(self "https://sandbox.avibe.bot")' in permissions
assert 'publickey-credentials-create=(self "https://sandbox.avibe.bot")' in permissions
assert 'clipboard-write=(self "https://sandbox.avibe.bot")' in permissions
assert "publickey-credentials-get=*" not in permissions
assert "publickey-credentials-create=*" not in permissions
assert "frame-src 'self' https://sandbox.avibe.bot" in response.headers["Content-Security-Policy"]
def test_spa_document_security_headers_delegate_webauthn_to_self_and_sandbox():
client = app.test_client()
response = client.request("HEAD", "/vaults", base_url="http://127.0.0.1:5123")
assert response.status_code == 200
assert "text/html" in response.headers["content-type"]
permissions = response.headers["Permissions-Policy"]
# See the companion REST test: `self` is required for the cross-origin iframe delegation.
assert 'publickey-credentials-get=(self "https://sandbox.avibe.bot")' in permissions
assert 'publickey-credentials-create=(self "https://sandbox.avibe.bot")' in permissions
assert 'clipboard-write=(self "https://sandbox.avibe.bot")' in permissions
assert "publickey-credentials-get=*" not in permissions
assert "publickey-credentials-create=*" not in permissions
assert "frame-src 'self' https://sandbox.avibe.bot" in response.headers["Content-Security-Policy"]
def test_rest_vault_authz_options_use_sandbox_rp_origin():
client = app.test_client()
response = client.post(
"/api/vault/authz/factors/webauthn/options",
json={},
headers=csrf_headers(client),
)
assert response.status_code == 200
payload = response.get_json()
assert payload["rp_id"] == "sandbox.avibe.bot"
assert payload["origin"] == "https://sandbox.avibe.bot"
assert payload["webauthn"]["rp"]["id"] == "sandbox.avibe.bot"
def test_rest_requests_and_grants_routes(monkeypatch):
_mock_avault_p2(monkeypatch)
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
monkeypatch.setattr(api, "avault_agent_grant", Mock(return_value={"granted": 1, "ttl_secs": 300}))
monkeypatch.setattr(api, "avault_agent_release", Mock(return_value={"released": True}))
api.create_vault_secret(
{
"name": "PROTECTED_REST",
"protection": "protected",
"sealed": {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"},
}
)
client = app.test_client()
with api._vault_engine().begin() as conn:
from storage import vault_service
req = vault_service.create_access_request(
conn,
"PROTECTED_REST",
requester={"session_id": "ses_1"},
delivery={"session_id": "ses_1"},
)
issued = _issued_agent_dek_payload(req["id"])
grant_response = client.post(
"/api/vault/grants",
json={
"session_id": "ses_1",
"request_id": req["id"],
**issued,
},
headers=csrf_headers(client),
)
assert grant_response.status_code == 200
grant_id = grant_response.get_json()["grant"]["id"]
assert client.get("/api/vault/grants").get_json()["grants"][0]["id"] == grant_id
revoke_response = client.delete(f"/api/vault/grants/{grant_id}", headers=csrf_headers(client))
assert revoke_response.status_code == 200
assert revoke_response.get_json()["grant"]["status"] == "revoked"
with api._vault_engine().begin() as conn:
vault_service.create_access_request(conn, "PROTECTED_REST", delivery={"command": "python sync.py"})
inbox = client.get("/api/vault/requests").get_json()
assert inbox["requests"][0]["card"]["card_type"] == "approval"
def test_rest_request_get_hydrates_browser_unlock_material_for_protected_access(monkeypatch):
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
api.create_vault_secret(
{
"name": "PROTECTED_REST",
"protection": "protected",
"sealed": {"ciphertext": "ct-protected", "nonce": "n-protected", "wrap_meta": "wm-protected"},
}
)
requested = api.request_vault_access({"name": "PROTECTED_REST", "session_id": "ses_1"})
client = app.test_client()
response = client.get(f"/api/vault/requests/{requested['request']['id']}")
assert response.status_code == 200
card = response.get_json()["request"]["card"]
assert card["secret_unlock_material"] == {
"name": "PROTECTED_REST",
"kind": "static",
"envelope": {"ciphertext": "ct-protected", "nonce": "n-protected", "wrap_meta": "wm-protected"},
}
agent_payload = api.get_vault_request(requested["request"]["id"])
assert "secret_unlock_material" not in json.dumps(agent_payload)
def test_rest_grant_rejects_mismatched_request(monkeypatch):
_mock_avault_p2(monkeypatch)
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
monkeypatch.setattr(api, "avault_agent_grant", Mock(return_value={"granted": 1, "ttl_secs": 300}))
api.create_vault_secret(
{
"name": "A_KEY",
"protection": "protected",
"sealed": {"ciphertext": "ct-a", "nonce": "n-a", "wrap_meta": "wm-a"},
}
)
api.create_vault_secret(
{
"name": "B_KEY",
"protection": "protected",
"sealed": {"ciphertext": "ct-b", "nonce": "n-b", "wrap_meta": "wm-b"},
}
)
with api._vault_engine().begin() as conn:
from storage import vault_service
req = vault_service.create_access_request(conn, "A_KEY", requester={"session_id": "ses_1"}, delivery={"session_id": "ses_1"})
client = app.test_client()
response = client.post(
"/api/vault/grants",
json={
"member_names": ["B_KEY"],
"source_selector": {"env": ["B_KEY"]},
"session_id": "ses_1",
"request_id": req["id"],
"deks": [
{
"name": "B_KEY",
"dek_blindbox": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "ct"},
"approval": {"nonce": "bm9uY2UtMTIzNDU2", "expires_at_unix": 4102444800},
}
],
},
headers=csrf_headers(client),
)
assert response.status_code == 409
assert response.get_json()["code"] == "invalid_request"
def test_rest_fulfill_access_request_route(monkeypatch):
_mock_avault_p2(monkeypatch)
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
agent_grant = Mock(return_value={"granted": 1, "ttl_secs": 300})
monkeypatch.setattr(api, "avault_agent_grant", agent_grant)
api.create_vault_secret(
{
"name": "PROTECTED_REST",
"protection": "protected",
"sealed": {"ciphertext": "ct", "nonce": "n", "wrap_meta": "wm"},
}
)
requested = api.request_vault_access({"name": "PROTECTED_REST", "session_id": "ses_1"})
client = app.test_client()
issued = _issued_agent_dek_payload(requested["request"]["id"])
response = client.post(
f"/api/vault/requests/{requested['request']['id']}/fulfill-access",
json={
"session_id": "ses_1",
**issued,
},
headers=csrf_headers(client),
)
assert response.status_code == 200
assert response.get_json()["result"]["type"] == "grant"
assert agent_grant.call_count == 1
def test_rest_fulfill_access_request_unknown_default_scope_returns_vault_error(monkeypatch):
_mock_avault_p2(monkeypatch)
client = app.test_client()
response = client.post(
"/api/vault/requests/vrq_missing/fulfill-access",
json={
"deks": [
{
"name": "PROTECTED_REST",
"dek_blindbox": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "ct"},
"approval": {"nonce": "bm9uY2UtMTIzNDU2", "expires_at_unix": 4102444800},
}
],
},
headers=csrf_headers(client),
)
assert response.status_code == 404
assert response.get_json()["code"] == "request_not_found"
def test_rest_sign_errors_are_stable(monkeypatch):
monkeypatch.setattr(api, "avault_seal_blind_box", Mock(return_value=_sealed()))
client = app.test_client()
missing = client.post(
"/api/vault/sign",
json={"name": "NOPE", "digest": "00" * 32},
headers=csrf_headers(client),
)
assert missing.status_code == 404
assert missing.get_json()["code"] == "secret_not_found"
api.create_vault_secret({"name": "STATIC_KEY", "blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "ct"}})
not_key = client.post(
"/api/vault/sign",
json={"name": "STATIC_KEY", "digest": "00" * 32},
headers=csrf_headers(client),
)
assert not_key.status_code == 409
assert not_key.get_json()["code"] == "not_signing_key"
def test_rest_field_put_delete_routes_use_canonical_record_name(monkeypatch):
seal = Mock(side_effect=[_sealed("default"), _sealed("username"), _sealed("newer")])
monkeypatch.setattr(api, "avault_seal_blind_box", seal)
api.create_vault_secret(
{
"name": "REST_LOGIN",
"blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "default"},
}
)
client = app.test_client()
headers = csrf_headers(client)
put = client.put(
"/api/vault/secrets/REST_LOGIN/fields/username",
json={
"record": "REST_LOGIN.username",
"blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "username"},
},
headers=headers,
)
assert put.status_code == 200
assert put.get_json()["secret"]["fields"] == ["value", "username"]
assert seal.call_args_list[1].args[0] == "REST_LOGIN.username"
old_version = put.get_json()["secret"]["updated_at"]
newer = api.update_vault_secret_field("REST_LOGIN", "username", {
"record": "REST_LOGIN.username",
"blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "newer"},
})
stale = client.delete(
"/api/vault/secrets/REST_LOGIN/fields/username",
json={"expected_updated_at": old_version}, headers=headers,
)
assert stale.status_code == 409
assert stale.get_json()["code"] == "secret_conflict"
assert api.get_vault_secrets()["secrets"][0]["fields"] == ["value", "username"]
removed = client.delete(
"/api/vault/secrets/REST_LOGIN/fields/username",
json={"expected_updated_at": newer["secret"]["updated_at"]}, headers=headers,
)
assert removed.status_code == 200
assert removed.get_json()["secret"]["fields"] == ["value"]
def test_rest_field_routes_reject_plaintext_and_default_delete(monkeypatch):
seal = Mock(return_value=_sealed())
monkeypatch.setattr(api, "avault_seal_blind_box", seal)
api.create_vault_secret(
{
"name": "REST_LOGIN",
"blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "default"},
}
)
client = app.test_client()
headers = csrf_headers(client)
rejected = client.put(
"/api/vault/secrets/REST_LOGIN/fields/password",
json={
"record": "REST_LOGIN.password",
"blind_box": {"scheme": "hpke-x25519-hkdfsha256-aes256gcm-v1", "enc": "enc", "ct": "password"},
"nested": {"value": "plaintext"},
},
headers=headers,
)
assert rejected.status_code == 400
assert rejected.get_json()["code"] == "plaintext_value_rejected"
seal.assert_called_once()
default_delete = client.delete("/api/vault/secrets/REST_LOGIN/fields/value", headers=headers)
assert default_delete.status_code == 409
assert default_delete.get_json()["code"] == "invalid_request"