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 pytest
from sqlalchemy import select
from config import paths
from config.v2_config import V2Config
from core.dock_store import BUILTIN_DOCK_IDS, DockError
from core.show_pages import ShowPageError, ShowPageStore
from storage import media_service, project_access_service, projects_service, resource_access_service
from storage import workbench_sessions_service as sessions_service
from storage.db import create_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage.models import agent_sessions
from tests.ui_server_test_helpers import _remote_peer, _save_config
from tests.ui_server_test_helpers import csrf_headers
from vibe import api, internal_client, permissions, remote_access, ui_server
from vibe.ui_server import app
def _organization_context(
subject: str,
*,
group_ids: frozenset[str] | None = frozenset({"group-engineering"}),
organization_role: str = "member",
instance_role: str = "viewer",
) -> resource_access_service.ResourceUserContext:
return resource_access_service.ResourceUserContext(
subject=subject,
email=f"{subject}@example.com",
organization_id="org-1",
organization_member_id=f"member-{subject}",
organization_role=organization_role,
group_ids=group_ids,
instance_role=instance_role,
instance_access_source="organization_group",
is_remote=True,
)
def _organization_cookie(
config,
*,
subject: str,
groups: list[str] | None = None,
instance_role: str = "viewer",
organization_role: str = "member",
) -> str:
claims = {
"vibe_instance_id": "inst_123",
"vibe_instance_role": instance_role,
"vibe_instance_access_source": "organization_group",
"vibe_organization_id": "org-1",
"vibe_organization_member_id": f"member-{subject}",
"vibe_organization_role": organization_role,
"vibe_membership_version": "membership-v2",
"vibe_instance_authorization_revision": 0,
}
if groups is not None:
claims["vibe_group_ids"] = groups
return remote_access.make_session_cookie(
config,
f"{subject}@example.com",
subject,
session_claims=claims,
)
def _paired_config(tmp_path, *, instance_kind: str):
config = _save_config(tmp_path)
cloud = config.remote_access.vibe_cloud
cloud.backend_url = "https://backend.example"
cloud.instance_secret = "device-secret"
cloud.instance_kind = instance_kind
config.save()
remote_access._replace_authorization_revision(config, 0)
return config
def _ownership(
mode: str,
*,
organization_id: str | None = None,
source: str = "live",
) -> dict:
return {
"mode": mode,
"instance_id": "inst_123",
"organization_id": organization_id,
"source": source,
}
def _seed_show_pages() -> ShowPageStore:
if not paths.get_config_path().exists():
V2Config.default().save()
store = ShowPageStore()
for session_id in ("ses-private", "ses-public", "ses-scope"):
store.ensure(session_id)
return store
@pytest.mark.parametrize("instance_role", ["viewer", "editor", "owner"])
def test_show_require_access_follows_instance_role_alone(
monkeypatch, tmp_path, instance_role
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = _seed_show_pages()
try:
page = store.require_access(
"ses-private",
user_context=_organization_context("member-1", instance_role=instance_role),
)
assert page.session_id == "ses-private"
finally:
store.close()
@pytest.mark.parametrize(
("subject", "instance_role", "organization_role"),
[
("owner-2", "owner", "owner"),
("member-1", "viewer", "member"),
],
)
def test_remote_show_page_surfaces_follow_instance_role(
monkeypatch,
tmp_path,
subject,
instance_role,
organization_role,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path)
store = _seed_show_pages()
store.close()
async def _runtime_response(*args, **kwargs):
return ui_server.FastAPIResponse(content=b"Show Page", media_type="text/html")
monkeypatch.setattr(ui_server, "_show_page_runtime_response", _runtime_response)
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(
config,
subject=subject,
groups=["group-engineering"],
instance_role=instance_role,
organization_role=organization_role,
),
domain="alex.avibe.bot",
)
catalog = client.get(
"/api/show-pages",
base_url="https://alex.avibe.bot",
environ_base=_remote_peer(),
)
mutation = client.post(
"/api/show-pages/ses-public/availability",
json={"offline": True},
headers=csrf_headers(client, "https://alex.avibe.bot"),
base_url="https://alex.avibe.bot",
environ_base=_remote_peer(),
)
page = client.get(
"/show/ses-private/",
base_url="https://alex.avibe.bot",
environ_base=_remote_peer(),
headers={"Accept": "text/html"},
follow_redirects=False,
)
assert catalog.status_code == 200
pages = catalog.get_json()["pages"]
# §3.2: the catalog is the Instance role alone — no Resource ACL filter, so a
# plain Viewer still sees every page; only manage/publish flags follow Editor.
assert {item["session_id"] for item in pages} == {"ses-private", "ses-public", "ses-scope"}
if instance_role == "owner":
assert all(item.get("path") for item in pages)
assert all(item["can_manage"] for item in pages)
assert all(item["can_publish_public"] for item in pages)
else:
assert all("path" not in item for item in pages)
assert all(not item["can_manage"] for item in pages)
assert all(not item["can_publish_public"] for item in pages)
assert mutation.status_code == (200 if instance_role == "owner" else 403)
# §3.2: every Instance Viewer enters /show.
assert page.status_code == 200
def test_show_page_creation_uses_exact_instance_organization_without_request_claims(
monkeypatch,
tmp_path,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_paired_config(tmp_path, instance_kind="organization")
monkeypatch.setattr(
permissions,
"resolve_current_instance_ownership",
lambda: _ownership("organization", organization_id="org-1"),
)
owner_context = _organization_context("owner-1", instance_role="owner")
store = ShowPageStore()
try:
project_path = tmp_path / "project"
project_path.mkdir()
with store.engine.begin() as connection:
project = projects_service.create_project(connection, str(project_path))
session = sessions_service.create_session(
connection, scope_id=project["scope_id"], agent_backend="codex"
)
project_access_service.apply_project_access_intent(
connection,
{
"project_id": project["id"],
"revision": 1,
"mode": "restricted",
"bindings": [{
"principal_kind": "email",
"principal_value": "[email protected]",
"access_role": "editor",
}],
},
)
created = store.ensure(session["id"])
assert created.session_id == session["id"]
# §3.2: show_page no longer registers a Resource ACL row, so creation
# writes no policy and the fence is not consulted for admission.
with store.engine.connect() as connection:
with pytest.raises(
resource_access_service.ResourceAccessError,
match="invalid_resource_kind",
):
resource_access_service.get_resource_policy(
"show_page", created.session_id, connection=connection
)
page = store.ensure("ses-org-public", user_context=owner_context)
assert page.session_id == "ses-org-public"
assert page.visibility == "private"
assert page.share_id
finally:
store.close()
def test_show_require_access_is_group_agnostic(monkeypatch, tmp_path) -> None:
"""§3.2: /show admission ignores the group claims that only /p audience uses."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = _seed_show_pages()
try:
page = store.require_access(
"ses-scope",
user_context=_organization_context("member-1", group_ids=None),
)
assert page.session_id == "ses-scope"
finally:
store.close()
def test_organization_admin_without_instance_owner_role_cannot_manage_pages(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = _seed_show_pages()
admin = _organization_context(
"admin-1",
group_ids=frozenset({"group-sales"}),
organization_role="admin",
instance_role="viewer",
)
owner = _organization_context("owner-1", instance_role="owner")
try:
public_page = store.update_visibility("ses-private", "public", user_context=owner)
# §3.2: /show admission is the Instance Viewer role alone, so an
# Organization admin that is still a plain Instance Viewer enters /show…
assert store.require_access("ses-private", user_context=admin).session_id == "ses-private"
# …but management stays reserved to Instance Editor/Owner.
with pytest.raises(ShowPageError):
store.update_visibility("ses-private", "private", user_context=admin)
republished = store.update_visibility("ses-private", "public", user_context=owner)
rotated, previous_share_id = store.rotate_share("ses-private", user_context=owner)
custom, rotated_share_id = store.set_share_id("ses-private", "owner-link", user_context=owner)
assert public_page.visibility == "public"
assert republished.visibility == "public"
assert previous_share_id == republished.share_id
assert rotated_share_id == rotated.share_id
assert custom.share_id == "owner-link"
assert store.require_access("ses-scope", user_context=admin).session_id == "ses-scope"
finally:
store.close()
def test_availability_mutation_is_editor_gated_and_returns_payload(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_save_config(tmp_path)
store = _seed_show_pages()
store.close()
viewer = _organization_context("member-1", instance_role="viewer")
editor = _organization_context("editor-1", instance_role="editor")
monkeypatch.setattr(
resource_access_service,
"resolve_resource_access_context",
lambda _value=None: viewer,
)
with pytest.raises(ShowPageError):
api.set_show_page_availability("ses-private", True)
monkeypatch.setattr(
resource_access_service,
"resolve_resource_access_context",
lambda _value=None: editor,
)
offline = api.set_show_page_availability("ses-private", True)
online = api.set_show_page_availability("ses-private", False)
# §3.2: an Instance Editor both manages and uses the page, so the mutation
# response carries the full payload (no use/management split to redact).
assert offline["ok"] is True
assert offline["offline"] is True
assert online["ok"] is True
assert online["offline"] is False
def test_remote_show_page_editor_can_control_sharing_without_instance_owner_role(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = _seed_show_pages()
page_owner = _organization_context("owner-1", instance_role="editor")
try:
published = store.update_visibility("ses-private", "public", user_context=page_owner)
closed = store.update_visibility("ses-private", "private", user_context=page_owner)
republished = store.update_visibility("ses-private", "public", user_context=page_owner)
rotated, previous_share_id = store.rotate_share("ses-private", user_context=page_owner)
customized, rotated_share_id = store.set_share_id(
"ses-private",
"page-owner-link",
user_context=page_owner,
)
assert published.visibility == "public"
assert closed.visibility == "private"
assert previous_share_id == republished.share_id
assert rotated_share_id == rotated.share_id
assert customized.share_id == "page-owner-link"
finally:
store.close()
def test_remote_show_page_viewer_mutations_are_instance_role_denied(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path)
store = ShowPageStore()
project_path = tmp_path / "project"
project_path.mkdir()
with store.engine.begin() as connection:
project = projects_service.create_project(connection, str(project_path))
session = sessions_service.create_session(
connection,
scope_id=project["scope_id"],
agent_backend="codex",
)
session_id = session["id"]
store.ensure(session_id)
store.close()
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(config, subject="owner-1", groups=[], instance_role="viewer"),
domain="alex.avibe.bot",
)
request_options = {
"headers": csrf_headers(client, "https://alex.avibe.bot"),
"base_url": "https://alex.avibe.bot",
"environ_base": _remote_peer(),
}
ensured = client.post(
f"/api/show-pages/{session_id}/ensure",
json={},
**request_options,
)
availability = client.post(
f"/api/show-pages/{session_id}/availability",
json={"offline": True},
**request_options,
)
settings = client.post(
f"/api/show-pages/{session_id}/access-settings/read",
json={"page_id": session_id},
**request_options,
)
applied = client.post(
f"/api/show-pages/{session_id}/access-settings/apply",
json={
"page_id": session_id,
"expected_revision": 0,
"target_access_mode": "public",
"target_share_id": "viewer-owner-link",
"target_emails": [],
},
**request_options,
)
assert ensured.status_code == 403
assert availability.status_code == 403
assert settings.status_code == 403
assert applied.status_code == 403
def test_organization_admin_viewer_reads_access_metadata_but_cannot_manage(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_save_config(tmp_path)
store = _seed_show_pages()
store.close()
admin = _organization_context(
"admin-1",
group_ids=frozenset({"group-sales"}),
organization_role="admin",
instance_role="viewer",
)
monkeypatch.setattr(resource_access_service, "resolve_resource_access_context", lambda _value=None: admin)
# §3.2: an Organization admin that is still an Instance Viewer may read the
# access metadata (can_use follows the Instance role) but never manage it.
response = api.get_show_page_access("ses-scope")
assert response["can_use"] is True
assert response["can_manage"] is False
assert response["can_publish_public"] is False
def test_existing_show_page_is_adopted_idempotently_without_changing_link_access(
monkeypatch,
tmp_path,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-legacy")
applied = store.apply_access(
"ses-legacy",
expected_revision=0,
target_access_mode="limited",
target_share_id="stable-link",
target_emails=["[email protected]"],
)
store.set_offline("ses-legacy", True)
before = store.get_access("ses-legacy")
assert applied.status == "applied"
_paired_config(tmp_path, instance_kind="organization")
monkeypatch.setattr(
permissions,
"resolve_current_instance_ownership",
lambda: _ownership("organization", organization_id="org-1"),
)
page = store.ensure("ses-legacy")
store.ensure("ses-legacy")
with store.engine.connect() as connection:
with pytest.raises(
resource_access_service.ResourceAccessError,
match="invalid_resource_kind",
):
resource_access_service.get_resource_policy(
"show_page",
page.session_id,
connection=connection,
)
after = store.get_access("ses-legacy")
# §3.2: adoption is a no-op — no policy is written and the page's link
# access is untouched across repeated ensures.
assert before == after
assert page.offline
finally:
store.close()
def test_show_page_access_api_follows_instance_role(
monkeypatch,
tmp_path,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-access-meta")
_paired_config(tmp_path, instance_kind="organization")
monkeypatch.setattr(
permissions,
"resolve_current_instance_ownership",
lambda: _ownership("organization", organization_id="org-1"),
)
instance_editor = _organization_context("editor-1", instance_role="editor")
response = api.get_show_page_access(
"ses-access-meta",
user_context=instance_editor,
)
assert response["ownership_status"] == "unchanged"
assert response["can_use"] is True
assert response["can_manage"] is True
assert response["can_publish_public"] is True
# §3.2: reading metadata never writes a show_page Resource ACL row.
with store.engine.connect() as connection:
with pytest.raises(
resource_access_service.ResourceAccessError,
match="invalid_resource_kind",
):
resource_access_service.get_resource_policy(
"show_page",
"ses-access-meta",
connection=connection,
)
finally:
store.close()
def test_show_page_access_api_distinguishes_personal_and_organization_modes(monkeypatch, tmp_path) -> None:
personal_home = tmp_path / "personal"
monkeypatch.setenv("AVIBE_HOME", str(personal_home))
_paired_config(personal_home, instance_kind="personal")
personal_store = ShowPageStore()
try:
personal_store.ensure("ses-personal")
finally:
personal_store.close()
personal = app.test_client().get("/api/show-pages/ses-personal/access")
assert personal.status_code == 200
assert personal.get_json() == {
"ok": True,
"mode": "personal",
"ownership_status": "unchanged",
"instance_id": "inst_123",
"organization_id": None,
"policy_organization_id": None,
"access_level": "private",
"group_ids": [],
"policy_revision": None,
"last_applied_control_plane_revision": None,
"can_use": True,
"can_manage": True,
"can_publish_public": True,
}
organization_home = tmp_path / "organization"
monkeypatch.setenv("AVIBE_HOME", str(organization_home))
config = _paired_config(organization_home, instance_kind="organization")
monkeypatch.setattr(
permissions,
"resolve_current_instance_ownership",
lambda: _ownership("organization", organization_id="org-1"),
)
store = ShowPageStore()
try:
store.ensure("ses-organization")
finally:
store.close()
local_organization = app.test_client().get(
"/api/show-pages/ses-organization/access",
base_url="http://127.0.0.1:15131",
)
assert local_organization.status_code == 200
assert local_organization.get_json()["instance_id"] == "inst_123"
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(config, subject="owner-1", groups=["group-engineering"], instance_role="owner"),
domain="alex.avibe.bot",
)
organization = client.get(
"/api/show-pages/ses-organization/access",
base_url="https://alex.avibe.bot",
environ_base=_remote_peer(),
)
assert organization.status_code == 200
assert organization.get_json() == {
"ok": True,
"mode": "organization",
"ownership_status": "unchanged",
"instance_id": "inst_123",
"organization_id": "org-1",
# §3.2: no show_page Resource ACL row exists, so the applied-audience
# fields are the private/empty/None baseline, never a scope policy.
"policy_organization_id": None,
"access_level": "private",
"group_ids": [],
"policy_revision": None,
"last_applied_control_plane_revision": None,
"can_use": True,
"can_manage": True,
"can_publish_public": True,
}
def test_show_access_adoption_is_policy_free(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-adopt")
applied = store.apply_access(
"ses-adopt",
expected_revision=0,
target_access_mode="limited",
target_share_id="adopt-link",
target_emails=["[email protected]"],
)
before_access = store.get_access("ses-adopt")
_paired_config(tmp_path, instance_kind="organization")
monkeypatch.setattr(
permissions,
"resolve_current_instance_ownership",
lambda: _ownership("organization", organization_id="org-1"),
)
store.ensure("ses-adopt")
store.ensure("ses-adopt")
# §3.2: adoption never writes a show_page Resource ACL row and never
# touches the page's link access, no matter how many times ensure runs.
with store.engine.connect() as connection:
with pytest.raises(
resource_access_service.ResourceAccessError,
match="invalid_resource_kind",
):
resource_access_service.get_resource_policy(
"show_page", "ses-adopt", connection=connection
)
assert applied.status == "applied"
assert store.get_access("ses-adopt") == before_access
finally:
store.close()
def test_show_access_organization_mode_never_reports_policy_conflict(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-org")
_paired_config(tmp_path, instance_kind="organization")
monkeypatch.setattr(
permissions,
"resolve_current_instance_ownership",
lambda: _ownership("organization", organization_id="org-1"),
)
response = api.get_show_page_access("ses-org")
# §3.2: with no policy row to diverge from the instance organization, the
# legacy "conflict" status is gone — every Instance Viewer may use the page.
assert response["ownership_status"] == "unchanged"
assert response["mode"] == "organization"
assert response["organization_id"] == "org-1"
assert response["policy_organization_id"] is None
assert response["can_use"] is True
assert (
store.require_access(
"ses-org",
user_context=_organization_context("member-1"),
).session_id
== "ses-org"
)
assert len(store.list(user_context=_organization_context("member-1"))) == 1
finally:
store.close()
@pytest.mark.parametrize(
"failure",
[
pytest.param(
permissions.PermissionsUnavailableError("permissions_backend_unavailable"),
id="backend-unavailable",
),
pytest.param(OSError("config unavailable"), id="config-io-error"),
pytest.param(TypeError("config shape changed"), id="config-type-error"),
pytest.param(ValueError("config value changed"), id="config-value-error"),
],
)
def test_organization_pending_is_stable_private_and_does_not_block_local_creation(
monkeypatch,
tmp_path,
failure: Exception,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_paired_config(tmp_path, instance_kind="organization")
monkeypatch.setattr(
permissions,
"get_current_permissions",
lambda _config=None: (_ for _ in ()).throw(failure),
)
store = ShowPageStore()
try:
created = store.ensure("ses-pending")
response = api.get_show_page_access("ses-pending")
# §3.2: a pending fence still never writes a show_page Resource ACL row.
with store.engine.connect() as connection:
with pytest.raises(
resource_access_service.ResourceAccessError,
match="invalid_resource_kind",
):
resource_access_service.get_resource_policy(
"show_page", "ses-pending", connection=connection
)
assert created.session_id == "ses-pending"
assert response["mode"] == "organization_pending"
assert response["ownership_status"] == "pending"
assert response["access_level"] == "private"
assert response["organization_id"] is None
assert response["can_use"] is True
finally:
store.close()
def test_last_known_organization_binding_is_exact_instance_scoped(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path, instance_kind="organization")
store = ShowPageStore()
try:
with store.engine.begin() as connection:
permissions.remember_show_page_instance_ownership(
connection,
_ownership("organization", organization_id="org-1"),
)
monkeypatch.setattr(
permissions,
"get_current_permissions",
lambda _config=None: (_ for _ in ()).throw(
permissions.PermissionsUnavailableError("permissions_backend_unavailable")
),
)
offline = permissions.resolve_current_instance_ownership()
assert offline == _ownership(
"organization",
organization_id="org-1",
source="stored",
)
config.remote_access.vibe_cloud.instance_id = "inst-new"
config.save()
repaired = permissions.resolve_current_instance_ownership()
assert repaired["mode"] == "organization_pending"
assert repaired["instance_id"] == "inst-new"
assert repaired["organization_id"] is None
finally:
store.close()
def test_ownership_fence_rejects_stale_pairing_before_persisting(monkeypatch, tmp_path) -> None:
"""A stale ownership snapshot cannot bind the fence to a former pairing."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_paired_config(tmp_path, instance_kind="organization")
store = ShowPageStore()
try:
with store.engine.begin() as connection:
fence = permissions.remember_show_page_instance_ownership(
connection,
{
"mode": "organization",
"instance_id": "inst-other",
"organization_id": "org-1",
"source": "live",
},
)
# The writer fails closed to the current pending fence instead of
# persisting an organization binding for the former instance.
assert fence["mode"] == "organization_pending"
assert fence["instance_id"] == "inst_123"
assert fence["organization_id"] is None
assert permissions.current_show_page_instance_ownership()["mode"] == "organization_pending"
finally:
store.close()
def test_show_page_access_api_reports_missing_page_as_definitive_denial(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
response = app.test_client().get("/api/show-pages/ses-missing/access")
assert response.status_code == 404
assert response.get_json()["code"] == "show_page_not_found"
def _show_access_payload(page_id: str, *, revision: int = 0) -> dict:
return {
"page_id": page_id,
"access_mode": "private",
"share_id": "stable-link",
"revision": revision,
"normalized_emails": [],
}
def test_show_access_owner_read_and_apply_use_controller_ipc(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-access-settings")
finally:
store.close()
calls: list[tuple[str, dict]] = []
async def _read(payload):
calls.append(("read", payload))
return {
"status_code": 200,
"body": {"show_access": _show_access_payload("ses-access-settings")},
}
async def _apply(payload):
calls.append(("apply", payload))
return {
"status_code": 200,
"body": {
"status": "applied",
"show_access": {
**_show_access_payload("ses-access-settings", revision=1),
"access_mode": "limited",
"normalized_emails": ["[email protected]"],
},
},
}
monkeypatch.setattr(internal_client, "show_access_settings_read", _read)
monkeypatch.setattr(internal_client, "show_access_apply", _apply)
client = app.test_client()
headers = csrf_headers(client)
loaded = client.post(
"/api/show-pages/ses-access-settings/access-settings/read",
json={"page_id": "ses-access-settings"},
headers=headers,
)
request_payload = {
"page_id": "ses-access-settings",
"expected_revision": 0,
"target_access_mode": "limited",
"target_share_id": "stable-link",
"target_emails": ["[email protected]"],
}
applied = client.post(
"/api/show-pages/ses-access-settings/access-settings/apply",
json=request_payload,
headers=headers,
)
assert loaded.status_code == 200
assert loaded.headers["Cache-Control"] == "private, no-store"
assert loaded.headers["Vary"] == "Cookie"
assert loaded.get_json()["show_access"]["page_id"] == "ses-access-settings"
assert applied.status_code == 200
assert applied.get_json()["status"] == "applied"
assert calls == [
("read", {"page_id": "ses-access-settings"}),
("apply", request_payload),
]
def test_show_access_route_identity_mismatch_is_rejected_before_ipc(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
async def _unexpected(_payload):
pytest.fail("identity mismatch must not reach controller IPC")
monkeypatch.setattr(internal_client, "show_access_settings_read", _unexpected)
client = app.test_client()
response = client.post(
"/api/show-pages/ses-route/access-settings/read",
json={"page_id": "ses-other"},
headers=csrf_headers(client),
)
assert response.status_code == 400
assert response.get_json() == {
"ok": False,
"error": "show_access_page_identity_mismatch",
}
def test_show_access_malformed_apply_is_rejected_before_ipc(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
async def _unexpected(_payload):
pytest.fail("malformed request must not reach controller IPC")
monkeypatch.setattr(internal_client, "show_access_apply", _unexpected)
client = app.test_client()
response = client.post(
"/api/show-pages/ses-route/access-settings/apply",
json={
"page_id": "ses-route",
"expected_revision": True,
"target_access_mode": "limited",
"target_share_id": ["not-a-string"],
"target_emails": ["[email protected]"],
},
headers=csrf_headers(client),
)
assert response.status_code == 400
assert response.get_json()["error"] == "invalid_show_access_apply_request"
def test_show_access_non_owner_is_rejected_before_ipc(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = _seed_show_pages()
store.close()
viewer = _organization_context("member-1", instance_role="viewer")
monkeypatch.setattr(
resource_access_service,
"resolve_resource_access_context",
lambda _value=None: viewer,
)
async def _unexpected(_payload):
pytest.fail("unauthorized request must not reach controller IPC")
monkeypatch.setattr(internal_client, "show_access_settings_read", _unexpected)
client = app.test_client()
response = client.post(
"/api/show-pages/ses-public/access-settings/read",
json={"page_id": "ses-public"},
headers=csrf_headers(client),
)
assert response.status_code == 403
assert response.get_json()["code"] == "resource_access_forbidden"
def test_show_access_internal_identity_mismatch_hides_email_data(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-access-settings")
finally:
store.close()
async def _mismatched(_payload):
return {
"status_code": 200,
"body": {
"show_access": {
**_show_access_payload("ses-other"),
"access_mode": "limited",
"normalized_emails": ["[email protected]"],
}
},
}
monkeypatch.setattr(internal_client, "show_access_settings_read", _mismatched)
client = app.test_client()
response = client.post(
"/api/show-pages/ses-access-settings/access-settings/read",
json={"page_id": "ses-access-settings"},
headers=csrf_headers(client),
)
assert response.status_code == 502
assert response.get_json() == {
"ok": False,
"error": "show_access_internal_protocol_error",
}
assert "[email protected]" not in response.text
def test_show_access_controller_unavailable_is_retryable(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-access-settings")
finally:
store.close()
async def _unavailable(_payload):
raise internal_client.InternalServerUnavailable("missing controller socket")
monkeypatch.setattr(internal_client, "show_access_settings_read", _unavailable)
client = app.test_client()
response = client.post(
"/api/show-pages/ses-access-settings/access-settings/read",
json={"page_id": "ses-access-settings"},
headers=csrf_headers(client),
)
assert response.status_code == 503
assert response.get_json()["error"] == "show_access_controller_unavailable"
def test_show_access_conflict_returns_current_snapshot(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
store = ShowPageStore()
try:
store.ensure("ses-access-settings")
finally:
store.close()
async def _conflict(_payload):
return {
"status_code": 200,
"body": {
"status": "conflict",
"show_access": _show_access_payload("ses-access-settings", revision=3),
},
}
monkeypatch.setattr(internal_client, "show_access_apply", _conflict)
client = app.test_client()
response = client.post(
"/api/show-pages/ses-access-settings/access-settings/apply",
json={
"page_id": "ses-access-settings",
"expected_revision": 2,
"target_access_mode": "public",
"target_share_id": "stable-link",
"target_emails": [],
},
headers=csrf_headers(client),
)
assert response.status_code == 200
assert response.get_json()["status"] == "conflict"
assert response.get_json()["show_access"]["revision"] == 3
def test_remote_org_dock_requires_editor_role(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path)
store = _seed_show_pages()
store.close()
owner = _organization_context("owner-1", instance_role="owner")
member = _organization_context("member-1")
admin = _organization_context(
"admin-1",
group_ids=frozenset({"group-sales"}),
organization_role="admin",
instance_role="owner",
)
# §3.2: dock pin/unpin/reorder stay reserved to Instance Editor/Owner; a
# plain Viewer is denied the mutation even when it is an Organization admin.
with pytest.raises(ShowPageError):
api.pin_dock_show_page("ses-public", user_context=member)
api.pin_dock_show_page("ses-scope", user_context=admin)
for session_id in ("ses-private", "ses-public", "ses-scope"):
api.pin_dock_show_page(session_id, user_context=owner)
dock = api.get_dock(user_context=member)["dock"]
visible_ids = {pin["session_id"] for pin in dock["pins"]}
# §3.2: read filtering follows the Instance Viewer role alone — every pinned
# page is visible, private included (no Resource ACL filter to hide it).
assert visible_ids == {"ses-private", "ses-public", "ses-scope"}
assert sum(1 for entry in dock["order"] if entry.startswith("show:")) == 3
with pytest.raises(ShowPageError):
api.pin_dock_show_page("ses-private", user_context=member)
with pytest.raises(ShowPageError):
api.unpin_dock_show_page("ses-public", user_context=member)
with pytest.raises(ShowPageError):
api.set_dock_order([], user_context=member)
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(
config,
subject="member-1",
groups=["group-engineering"],
instance_role="viewer",
),
domain="alex.avibe.bot",
)
response = client.delete(
"/api/dock/pins/ses-public",
headers=csrf_headers(client, "https://alex.avibe.bot"),
base_url="https://alex.avibe.bot",
environ_base=_remote_peer(),
)
assert response.status_code == 403
def test_remote_owner_dock_order_persists(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_save_config(tmp_path)
store = _seed_show_pages()
store.close()
owner = _organization_context("owner-1", instance_role="owner")
admin = _organization_context("admin-1", organization_role="admin", instance_role="owner")
for session_id in ("ses-private", "ses-public", "ses-scope"):
api.pin_dock_show_page(session_id, user_context=owner)
visible = api.get_dock(user_context=admin)["dock"]
known = [
"files",
"terminal",
"editor",
"library",
*(f"show:{pin['session_id']}" for pin in visible["pins"]),
]
submitted = ["show:ses-scope", "show:ses-public", "files"]
updated = api.set_dock_order(submitted, known=known, user_context=admin)["dock"]
assert updated["order"] == submitted
owner_dock = api.get_dock(user_context=owner)["dock"]
assert "show:ses-private" not in owner_dock["order"]
assert owner_dock["order"] == submitted
def test_untrusted_dock_context_fails_closed(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_save_config(tmp_path)
store = _seed_show_pages()
store.close()
owner = _organization_context("owner-1", instance_role="owner")
api.pin_dock_show_page("ses-public", user_context=owner)
unresolved = resource_access_service.ResourceUserContext()
dock = api.get_dock(user_context=unresolved)["dock"]
assert dock["pins"] == []
assert "show:ses-public" not in dock["order"]
with pytest.raises(ShowPageError, match="Show Page access is not permitted"):
api.unpin_dock_show_page("ses-public", user_context=unresolved)
with pytest.raises(DockError, match="unknown id"):
api.set_dock_order(
[*BUILTIN_DOCK_IDS, "show:ses-public"],
user_context=unresolved,
)
def test_remote_viewer_archive_is_denied_under_instance_role(monkeypatch, tmp_path) -> None:
from unittest.mock import AsyncMock
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path)
project_dir = tmp_path / "project"
project_dir.mkdir()
ensure_sqlite_state()
engine = create_sqlite_engine(paths.get_sqlite_state_path())
try:
with engine.begin() as connection:
project = projects_service.create_project(connection, str(project_dir))
session_id = sessions_service.create_session(
connection,
scope_id=project["scope_id"],
agent_backend="claude",
)["id"]
project_access_service.apply_project_access_intent(
connection,
{
"project_id": project["id"],
"revision": 1,
"mode": "restricted",
"bindings": [{
"principal_kind": "email",
"principal_value": "[email protected]",
"access_role": "viewer",
}],
},
)
store = ShowPageStore()
try:
store.ensure(session_id)
finally:
store.close()
archive_session = AsyncMock()
monkeypatch.setattr("vibe.internal_client.archive_session", archive_session)
# §3.2: archiving a session that has a Show Page stays reserved to the
# Instance Editor role; a plain Instance Viewer with project read access
# is still denied before any controller IPC.
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(
config,
subject="member-1",
groups=["group-engineering"],
instance_role="viewer",
),
domain="alex.avibe.bot",
)
response = client.delete(
f"/api/sessions/{session_id}",
headers=csrf_headers(client, "https://alex.avibe.bot"),
base_url="https://alex.avibe.bot",
environ_base=_remote_peer(),
)
assert response.status_code == 403
archive_session.assert_not_awaited()
with engine.connect() as connection:
assert connection.execute(
select(agent_sessions.c.status).where(agent_sessions.c.id == session_id)
).scalar_one() != "archived"
finally:
engine.dispose()
def test_remote_org_show_annotation_media_follows_instance_role(
monkeypatch,
tmp_path,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path)
project_dir = tmp_path / "project"
project_dir.mkdir()
ensure_sqlite_state()
engine = create_sqlite_engine(paths.get_sqlite_state_path())
try:
with engine.begin() as connection:
project = projects_service.create_project(connection, str(project_dir))
session_id = sessions_service.create_session(
connection,
scope_id=project["scope_id"],
agent_backend="claude",
)["id"]
project_access_service.apply_project_access_intent(
connection,
{
"project_id": project["id"],
"revision": 1,
"mode": "restricted",
"bindings": [{
"principal_kind": "email",
"principal_value": "[email protected]",
"access_role": "viewer",
}],
},
)
store = ShowPageStore()
try:
store.ensure(session_id)
finally:
store.close()
def _screenshot(name: str) -> str:
path = tmp_path / f"{name}.png"
path.write_bytes(b"\x89PNG\r\n\x1a\n" + name.encode("ascii"))
return str(path.resolve())
with engine.begin() as connection:
tokens = {
source: media_service.register(
connection,
scope_id=project["scope_id"],
session_id=session_id,
kind="image",
source=source,
local_path=_screenshot(source),
)
for source in ("show_annotation", "agent_reply")
}
orphan_token = media_service.register(
connection,
scope_id=None,
session_id=None,
kind="image",
source="show_annotation",
local_path=_screenshot("orphan"),
)
def _client(subject: str):
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(
config,
subject=subject,
groups=["group-engineering"],
instance_role="viewer",
),
domain="alex.avibe.bot",
)
return client
def _media(client, token: str):
return client.get(
f"/api/media/{token}",
base_url="https://alex.avibe.bot",
environ_base=_remote_peer(),
)
in_scope = _client("member-1")
# §3.2: a show_annotation screenshot inherits the page's /show admission
# (Instance Viewer role) alone — the Project/session role does NOT stack
# on top — so a viewer OUTSIDE the restricted Project still reads its own
# page's annotation bytes, while non-annotation media keeps the project gate.
out_of_scope = _client("member-2")
assert _media(out_of_scope, tokens["show_annotation"]).status_code == 200
assert _media(out_of_scope, tokens["agent_reply"]).status_code == 404
assert _media(in_scope, tokens["show_annotation"]).status_code == 200
assert _media(in_scope, tokens["agent_reply"]).status_code == 200
# An annotation with no page to check against cannot be authorized.
assert _media(in_scope, orphan_token).status_code == 404
finally:
engine.dispose()