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 types import SimpleNamespace
import pytest
from config.v2_config import (
AgentsConfig,
PlatformsConfig,
RemoteAccessConfig,
RuntimeConfig,
SlackConfig,
UiConfig,
V2Config,
)
from core.vibe_agents import VibeAgentStore
from storage import (
media_service,
message_deliveries,
messages_service,
project_access_service,
projects_service,
resource_access_service,
)
from storage.db import create_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage.models import agent_sessions, media_object_references, media_objects, scopes
from storage.workbench_sessions_service import create_session
from tests.ui_server_test_helpers import csrf_headers, remote_session_cookie
from vibe import api, internal_client, remote_access, ui_server
from vibe.authorization import AuthorizationContext
from vibe.sse_broker import broker
from vibe.ui_server import app
REMOTE_ORIGIN = "https://alex.avibe.bot"
REMOTE_PEER = {"REMOTE_ADDR": "203.0.113.10"}
def _save_config() -> V2Config:
config = V2Config(
mode="self_host",
version="v2",
platform="slack",
platforms=PlatformsConfig(enabled=["slack"], primary="slack"),
slack=SlackConfig(bot_token=""),
runtime=RuntimeConfig(default_cwd="."),
agents=AgentsConfig(),
ui=UiConfig(),
remote_access=RemoteAccessConfig(),
)
cloud = config.remote_access.vibe_cloud
cloud.enabled = True
cloud.public_url = REMOTE_ORIGIN
cloud.client_id = "vr_client_123"
cloud.instance_id = "inst_123"
cloud.session_secret = "session-secret"
cloud.authorization_endpoint = "https://backend.test/oauth/authorize"
cloud.redirect_uri = f"{REMOTE_ORIGIN}/auth/callback"
config.save()
return config
def _intent(project_id: str, email: str, role: str = "editor") -> dict:
return {
"project_id": project_id,
"revision": 1,
"mode": "restricted",
"bindings": [
{
"principal_kind": "email",
"principal_value": email,
"access_role": role,
}
],
}
def _group_intent(project_id: str, group_id: str, role: str = "editor") -> dict:
return {
"project_id": project_id,
"revision": 1,
"mode": "restricted",
"bindings": [
{
"principal_kind": "organization_group",
"principal_value": group_id,
"access_role": role,
}
],
}
def _setup_state(tmp_path) -> tuple[V2Config, dict[str, str]]:
config = _save_config()
ensure_sqlite_state()
engine = create_sqlite_engine()
project_a_dir = tmp_path / "project-a"
project_b_dir = tmp_path / "project-b"
project_a_dir.mkdir()
project_b_dir.mkdir()
shared_media = tmp_path / "shared.txt"
shared_media.write_text("shared media", encoding="utf-8")
with engine.begin() as conn:
project_a = projects_service.create_project(conn, str(project_a_dir), display_name="A")
project_b = projects_service.create_project(conn, str(project_b_dir), display_name="B")
session_a = create_session(conn, scope_id=project_a["scope_id"], agent_backend="codex")
session_b = create_session(conn, scope_id=project_b["scope_id"], agent_backend="codex")
unscoped = create_session(conn, scope_id=None, agent_backend="codex")
for project, session in ((project_a, session_a), (project_b, session_b)):
messages_service.append(
conn,
scope_id=project["scope_id"],
session_id=session["id"],
platform="avibe",
author="agent",
message_type="result",
text="shared needle",
)
media_a_token = media_service.register(
conn,
scope_id=project_a["scope_id"],
session_id=session_a["id"],
kind="file",
source="agent_reply",
local_path=str(shared_media.resolve()),
)
media_b_token = media_service.register(
conn,
scope_id=project_b["scope_id"],
session_id=session_b["id"],
kind="file",
source="agent_reply",
local_path=str(shared_media.resolve()),
)
assert media_a_token != media_b_token
project_access_service.apply_project_access_intent(
conn,
_intent(project_a["id"], "[email protected]"),
)
project_access_service.apply_project_access_intent(
conn,
_group_intent(project_b["id"], "grp_beta"),
)
engine.dispose()
return config, {
"project_a": project_a["id"],
"project_b": project_b["id"],
"session_a": session_a["id"],
"session_b": session_b["id"],
"unscoped": unscoped["id"],
"media_a": media_a_token,
"media_b": media_b_token,
}
def _remote_client(
config: V2Config,
*,
role: str,
email: str,
active_org: bool = True,
):
client = app.test_client()
if active_org:
cookie = remote_session_cookie(
config,
email,
f"user-{role}-{email}",
role=role,
access_source="organization_group",
organization_id="org-1",
organization_member_id=f"member-{email}",
organization_role="member",
group_ids=[],
)
else:
cookie = remote_session_cookie(config, email, f"user-{role}-{email}", role=role)
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
cookie,
domain="alex.avibe.bot",
)
return client
def _get(client, path: str):
return client.get(path, base_url=REMOTE_ORIGIN, environ_base=REMOTE_PEER)
def test_active_org_member_can_use_every_project_runtime_surface(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
scopes.update()
.where(scopes.c.native_id == ids["project_a"])
.values(metadata_json=json.dumps({"host_path_hint": "/private/host"}))
)
client = _remote_client(config, role="editor", email="[email protected]")
monkeypatch.setattr(
api,
"list_show_pages",
lambda **_kwargs: {
"ok": True,
"count": 3,
"pages": [
{"session_id": ids["session_a"]},
{"session_id": ids["session_b"]},
{"session_id": ids["unscoped"]},
],
},
)
project_rows = _get(client, "/api/projects").get_json()["projects"]
assert {row["id"] for row in project_rows} == {ids["project_a"]}
project_a = next(row for row in project_rows if row["id"] == ids["project_a"])
assert project_a["folder_path"] == str((tmp_path / "project-a").resolve())
assert project_a["metadata"] == {"host_path_hint": "/private/host"}
assert project_a["capabilities"] == {"can_chat": True, "has_folder": True}
sessions = _get(client, "/api/sessions?status=active").get_json()["sessions"]
assert {row["id"] for row in sessions} == {
ids["session_a"],
}
sessions_by_id = {row["id"]: row for row in sessions}
local_sessions = app.test_client().get(
"/api/sessions?status=active",
base_url="http://localhost",
).get_json()["sessions"]
local_sessions_by_id = {row["id"]: row for row in local_sessions}
for session_id in (ids["session_a"],):
assert sessions_by_id[session_id]["workdir"] == local_sessions_by_id[session_id]["workdir"]
assert sessions_by_id[session_id]["metadata"] == local_sessions_by_id[session_id]["metadata"]
assert _get(client, f"/api/projects/{ids['project_a']}").status_code == 200
assert _get(client, f"/api/projects/{ids['project_b']}").status_code == 404
session = _get(client, f"/api/sessions/{ids['session_a']}").get_json()
assert session["workdir"] == str((tmp_path / "project-a").resolve())
assert session["metadata"] == {"created_via": "workbench"}
assert session["capabilities"] == {"can_chat": True}
assert _get(client, f"/api/sessions/{ids['session_a']}/messages").status_code == 200
assert _get(client, f"/api/sessions/{ids['session_b']}/messages").status_code == 404
assert _get(client, f"/api/sessions/{ids['unscoped']}").status_code == 404
search = _get(client, "/api/search/messages?q=needle").get_json()
assert {row["session_id"] for row in search["sessions"]} == {
ids["session_a"],
}
inbox = _get(client, "/api/inbox").get_json()
assert {row["session_id"] for row in inbox["sessions"]} == {
ids["session_a"],
}
assert set(inbox["unread_by_session"]) == {ids["session_a"]}
media_response = _get(client, f"/api/media/{ids['media_a']}")
assert media_response.status_code == 200
assert media_response.headers["Cache-Control"] == "private, no-store"
assert _get(client, f"/api/media/{ids['media_b']}").status_code == 404
show_pages = _get(client, "/api/show-pages").get_json()
assert {page["session_id"] for page in show_pages["pages"]} == {
ids["session_a"],
ids["session_b"],
ids["unscoped"],
}
assert show_pages["count"] == 3
published = []
monkeypatch.setattr(broker, "publish", lambda event_type, data: published.append((event_type, data)))
headers = csrf_headers(client, REMOTE_ORIGIN)
mark_read = client.post(
f"/api/sessions/{ids['session_a']}/mark-read",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={},
)
assert mark_read.status_code == 200
allowed_action = client.post(
f"/api/sessions/{ids['session_a']}/attachments",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={},
)
hidden_action = client.post(
f"/api/sessions/{ids['session_b']}/attachments",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={},
)
# Empty JSON is rejected by the upload parser, but the request must reach
# the endpoint rather than being stopped by the remote execution gate.
assert allowed_action.status_code != 403 or allowed_action.get_json().get("code") != "remote_execution_disabled"
assert hidden_action.status_code != 403 or hidden_action.get_json().get("code") != "remote_execution_disabled"
def test_member_operates_restricted_projects_by_id_and_folder(monkeypatch, tmp_path) -> None:
"""Member list/detail/reuse/mutation share current-instance scope."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
client = _remote_client(config, role="member", email="[email protected]")
headers = csrf_headers(client, REMOTE_ORIGIN)
assert {row["id"] for row in _get(client, "/api/projects").get_json()["projects"]} == {
ids["project_a"], ids["project_b"]
}
engine = create_sqlite_engine()
with engine.connect() as conn:
before = [project_access_service.get_project_policy(conn, ids[key]) for key in ("project_a", "project_b")]
for key, folder in (("project_a", "project-a"), ("project_b", "project-b")):
project_id = ids[key]
assert _get(client, f"/api/projects/{project_id}").status_code == 200
reused = client.post(
"/api/projects", base_url=REMOTE_ORIGIN, environ_base=REMOTE_PEER,
headers=headers, json={"folder_path": str(tmp_path / folder)},
)
assert reused.status_code == 201
assert reused.get_json()["id"] == project_id
changed = client.patch(
f"/api/projects/{project_id}", base_url=REMOTE_ORIGIN, environ_base=REMOTE_PEER,
headers=headers, json={"display_name": "成员管理"},
)
assert changed.status_code == 200
assert changed.get_json()["display_name"] == "成员管理"
with engine.connect() as conn:
assert [project_access_service.get_project_policy(conn, ids[key]) for key in ("project_a", "project_b")] == before
for key in ("project_a", "project_b"):
assert client.delete(
f"/api/projects/{ids[key]}", base_url=REMOTE_ORIGIN, environ_base=REMOTE_PEER,
headers=headers,
).status_code == 200
engine.dispose()
def test_session_bootstrap_uses_effective_project_chat_role(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
project_access_service.apply_project_access_intent(
conn,
{
**_intent(ids["project_a"], "[email protected]", role="viewer"),
"revision": 2,
},
)
scope_id = project_access_service.project_scope_id(ids["project_a"])
message_deliveries.enqueue_queued(
conn,
scope_id=scope_id,
session_id=ids["session_a"],
text="editor-only queued prompt",
)
message_deliveries.set_draft(
conn,
ids["session_a"],
"editor-only draft",
)
with engine.connect() as conn:
draft_state = message_deliveries.get_draft_state(conn, ids["session_a"])
expected_draft = {
"text": "editor-only draft",
"updated_at": draft_state["updated_at"],
}
assert expected_draft["updated_at"]
monkeypatch.setattr(
api,
"get_vibe_agents",
lambda **kwargs: {
"agents": [{"name": "editor-agent", "backend": "codex", "enabled": True}],
"default_agent_name": "editor-agent",
},
)
client = _remote_client(config, role="editor", email="[email protected]")
viewer_project = _get(client, f"/api/projects/{ids['project_a']}").get_json()
assert viewer_project["capabilities"] == {"can_chat": False, "has_folder": True}
assert viewer_project["folder_path"] == ""
assert viewer_project["metadata"] == {}
viewer_session = _get(client, f"/api/sessions/{ids['session_a']}")
assert viewer_session.status_code == 200
assert viewer_session.get_json()["capabilities"] == {"can_chat": False}
assert viewer_session.get_json()["id"] == ids["session_a"]
viewer_bootstrap = _get(client, f"/api/sessions/{ids['session_a']}/bootstrap")
assert viewer_bootstrap.status_code == 200
viewer_payload = viewer_bootstrap.get_json()
assert viewer_payload["capabilities"] == {"can_chat": False}
assert viewer_payload["agents"] == []
assert viewer_payload["default_agent_name"] is None
assert viewer_payload["queued"] == []
assert viewer_payload["draft"] == {"text": ""}
assert [message["text"] for message in viewer_payload["messages"]] == ["shared needle"]
assert viewer_payload["session"]["workdir"] == str((tmp_path / "project-a").resolve())
assert viewer_payload["session"]["metadata"] == {"created_via": "workbench"}
with engine.begin() as conn:
project_access_service.apply_project_access_intent(
conn,
{
**_intent(ids["project_a"], "[email protected]"),
"revision": 3,
},
)
editor_session = _get(client, f"/api/sessions/{ids['session_a']}")
assert editor_session.status_code == 200
assert editor_session.get_json()["capabilities"] == {"can_chat": True}
editor_bootstrap = _get(client, f"/api/sessions/{ids['session_a']}/bootstrap")
assert editor_bootstrap.status_code == 200
editor_payload = editor_bootstrap.get_json()
assert editor_payload["capabilities"] == {"can_chat": True}
assert editor_payload["agents"][0]["name"] == "editor-agent"
assert editor_payload["default_agent_name"] == "editor-agent"
assert editor_payload["queued"][0]["text"] == "editor-only queued prompt"
assert editor_payload["draft"] == expected_draft
# Editors receive the non-sensitive runtime UI projection used by ChatPage;
# Owner-only management data remains available only to the Owner payload.
# Asserted as the declared key set rather than as named exclusions: any
# block that starts reaching non-owners fails here even if nobody thought
# to forbid it, and cloud pairing appears only as a readiness boolean —
# never as an endpoint, identifier, or secret.
assert editor_payload["config"]["ui"]["chat_message_font_size"]
assert set(editor_payload["config"]) == set(api._EDITOR_CONFIG_WRITE_FIELDS) | set(
api._NON_OWNER_CONFIG_CONTEXT_FIELDS
)
assert editor_payload["config"]["remote_access"] == {"vibe_cloud": {"paired": False}}
owner = _remote_client(config, role="owner", email="[email protected]")
owner_payload = _get(owner, f"/api/sessions/{ids['session_a']}/bootstrap").get_json()
assert owner_payload["config"]["runtime"]["default_cwd"] == "."
assert "agents" in owner_payload["config"]
assert "memory" not in owner_payload["config"]
assert "remote_access" in owner_payload["config"]
local_payload = app.test_client().get(
f"/api/sessions/{ids['session_a']}/bootstrap",
base_url="http://localhost",
).get_json()
assert local_payload["config"]["runtime"]["default_cwd"] == "."
draft_get = _get(client, f"/api/sessions/{ids['session_a']}/draft")
draft_put = client.put(
f"/api/sessions/{ids['session_a']}/draft",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=csrf_headers(client, REMOTE_ORIGIN),
json={
"text": "remote overwrite",
"expected_updated_at": expected_draft["updated_at"],
},
)
assert draft_get.status_code == 200
assert draft_get.get_json() == expected_draft
assert draft_put.status_code == 200
with engine.connect() as conn:
assert message_deliveries.get_draft(conn, ids["session_a"])["text"] == "remote overwrite"
editor_project = _get(client, f"/api/projects/{ids['project_a']}").get_json()
assert editor_project["capabilities"] == {"can_chat": True, "has_folder": True}
def test_editor_config_write_always_answers_with_a_renderable_code(monkeypatch, tmp_path) -> None:
"""Every rejected Editor config write leaves the API as a client-renderable code.
Stated over the ways an Editor write can fail rather than over the one
message a review happened to name: a field outside the write allowlist is
refused up front, and an allowlisted field carrying a bad value is refused
much later inside ``V2Config.from_payload``. Both leave through the same
chokepoint, so a non-English client never has to render a raw English
validation sentence. The accepted write is asserted alongside them so the
codes cannot be produced by an endpoint that refuses everything.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, _ids = _setup_state(tmp_path)
client = _remote_client(config, role="editor", email="[email protected]")
def _post(payload: dict):
return client.post(
"/api/config",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=csrf_headers(client, REMOTE_ORIGIN),
json=payload,
)
forbidden = _post({"runtime": {"default_cwd": "/tmp/editor-should-not-write"}, "memory": {"enabled": True}})
assert forbidden.status_code == 400
assert forbidden.get_json()["error"] == {
"code": "editor_config_write_forbidden",
"message": "editor_config_write_forbidden",
}
invalid = _post({"ack_mode": "not-a-mode"})
assert invalid.status_code == 400
assert invalid.get_json()["error"] == {
"code": "editor_config_write_invalid",
"message": "editor_config_write_invalid",
}
accepted = _post({"ack_mode": "reaction", "memory": {"enabled": {"malformed": True}}})
assert accepted.status_code == 200
assert V2Config.load().ack_mode == "reaction"
assert not hasattr(V2Config.load(), "memory")
assert V2Config.load().runtime.default_cwd == "."
def test_editor_cannot_persist_a_credential_through_the_config_write(monkeypatch, tmp_path) -> None:
"""Editor keeps its preference-only schema across all credential sections.
The field registry independently enumerates credential-bearing sections;
Member management is covered by the signed remote management scenarios.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, _ids = _setup_state(tmp_path)
secret_sections = {
section: fields for section, fields in api._PLATFORM_SECRET_FIELDS.items()
}
secret_sections["remote_access"] = ("provider",)
secret_sections["gateway"] = api._GATEWAY_SECRET_FIELDS
assert set(secret_sections) & api._EDITOR_CONFIG_WRITE_FIELDS == set()
def _stored_secrets() -> dict:
loaded = V2Config.load()
state = {
f"{section}.{field}": getattr(getattr(loaded, section, None), field, None)
for section, fields in secret_sections.items()
if section != "remote_access"
for field in fields
}
cloud = loaded.remote_access.vibe_cloud
state["remote_access.instance_id"] = cloud.instance_id
state["remote_access.client_id"] = cloud.client_id
state["remote_access.session_secret"] = cloud.session_secret
return state
baseline = _stored_secrets()
assert baseline["slack.bot_token"] == ""
assert baseline["remote_access.instance_id"] == "inst_123"
for role in ("editor",):
client = _remote_client(config, role=role, email=f"{role}@example.com")
headers = csrf_headers(client, REMOTE_ORIGIN)
for section, fields in secret_sections.items():
for field in fields:
response = client.post(
"/api/config",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={section: {field: "stolen-credential"}},
)
assert response.status_code == 400, (role, section, field)
assert response.get_json()["error"] == {
"code": "editor_config_write_forbidden",
"message": "editor_config_write_forbidden",
}, (role, section, field)
# Refused, not merely unpersisted: the allowlisted preference still
# saves, so the refusals above are the schema and not a dead endpoint.
accepted = client.post(
"/api/config",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={"ack_mode": "reaction"},
)
assert accepted.status_code == 200, role
assert _stored_secrets() == baseline
assert V2Config.load().ack_mode == "reaction"
def test_config_write_requires_an_object_body_whatever_the_role(monkeypatch, tmp_path) -> None:
"""A config write is a patch object, and a body that is not one is refused.
Stated over the JSON value space rather than over the shapes a review
happened to name: the route decoded the body with the usual ``request.json
or {}``, which turned every falsy value — including a missing body — into
an empty patch, so a malformed write persisted nothing and still answered
200. Truthy non-objects were refused only because they survived that
coercion, which is why an enumeration would have missed exactly the half
that was broken. Both roles are asserted because the rule belongs to the
route, not to the Editor allowlist that happened to cover one side of it.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, _ids = _setup_state(tmp_path)
editor = _remote_client(config, role="editor", email="[email protected]")
owner = app.test_client()
editor_headers = {**csrf_headers(editor, REMOTE_ORIGIN), "Content-Type": "application/json"}
owner_headers = {**csrf_headers(owner, "http://localhost"), "Content-Type": "application/json"}
def _post_body(body):
return (
editor.post(
"/api/config",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=editor_headers,
content=json.dumps(body),
),
owner.post(
"/api/config",
base_url="http://localhost",
headers=owner_headers,
content=json.dumps(body),
),
)
for body in (None, [], [1], "", "text", 0, 1, False, True):
editor_response, owner_response = _post_body(body)
assert editor_response.status_code == 400, body
assert editor_response.get_json()["error"] == {
"code": "editor_config_write_invalid",
"message": "editor_config_write_invalid",
}, body
# The Owner keeps the descriptive message its Settings pages render.
assert owner_response.status_code == 400, body
assert owner_response.get_json()["error"] == "Config payload must be an object", body
# An empty object is a valid no-op patch, so the refusals above cannot be
# produced by a route that has started refusing every body.
editor_response, owner_response = _post_body({})
assert editor_response.status_code == 200
assert owner_response.status_code == 200
assert V2Config.load().ack_mode == "typing"
def test_archived_project_invalidates_retained_remote_urls(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
published = []
monkeypatch.setattr(
broker,
"publish",
lambda event_type, data: published.append((event_type, data)),
)
local = app.test_client()
archive = local.delete(
f"/api/projects/{ids['project_a']}",
base_url="http://localhost",
headers=csrf_headers(local, "http://localhost"),
)
assert archive.status_code == 200
assert (
"authorization.changed",
{"project_ids": [ids["project_a"]]},
) in published
monkeypatch.setattr(
api,
"list_show_pages",
lambda **_kwargs: {
"ok": True,
"count": 1,
"pages": [{"session_id": ids["session_a"]}],
},
)
client = _remote_client(config, role="editor", email="[email protected]")
assert _get(client, "/api/projects").get_json()["projects"] == []
archived_project = _get(client, f"/api/projects/{ids['project_a']}")
assert archived_project.status_code == 404
assert _get(client, f"/api/sessions/{ids['session_a']}/messages").status_code == 404
assert _get(client, f"/api/media/{ids['media_a']}").status_code == 404
assert _get(client, "/api/show-pages").get_json()["pages"] == [
{"session_id": ids["session_a"]}
]
response = client.post(
f"/api/sessions/{ids['session_a']}/attachments",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=csrf_headers(client, REMOTE_ORIGIN),
json={},
)
assert response.status_code != 403 or response.get_json().get("code") != "remote_execution_disabled"
def test_legacy_media_token_uses_all_migrated_session_references(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
engine = create_sqlite_engine()
token = "legacy-shared-token"
with engine.begin() as conn:
original = media_service.get_by_token(conn, ids["media_a"])
assert original is not None
conn.execute(media_objects.insert().values(**{**original, "token": token}))
conn.execute(
media_object_references.insert(),
[
{
"token": token,
"session_id": ids["session_a"],
"created_at": original["created_at"],
},
{
"token": token,
"session_id": ids["session_b"],
"created_at": original["created_at"],
},
],
)
alice = _remote_client(config, role="editor", email="[email protected]")
beta = _remote_client(config, role="editor", email="[email protected]")
beta.set_cookie(
remote_access.SESSION_COOKIE_NAME,
remote_session_cookie(
config,
"[email protected]",
"user-beta",
role="editor",
organization_id="org_beta",
organization_member_id="member_beta",
organization_role="member",
group_ids=["grp_beta"],
),
domain="alex.avibe.bot",
)
assert _get(alice, f"/api/media/{token}").status_code == 200
assert _get(beta, f"/api/media/{token}").status_code == 200
def test_remote_editor_message_persists_authoritative_identity_and_dispatches(
monkeypatch,
tmp_path,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
engine = create_sqlite_engine()
client = _remote_client(config, role="editor", email="[email protected]")
store = VibeAgentStore()
try:
agent = store.create(name="remote-editor-agent", backend="codex")
with store.engine.begin() as conn:
resource_access_service.ensure_resource_policy(
conn,
resource_kind="agent",
resource_id=agent.id,
organization_id=None,
owner_user_id="[email protected]",
access_level="private",
)
finally:
store.close()
with engine.begin() as conn:
conn.execute(
agent_sessions.update()
.where(agent_sessions.c.id == ids["session_a"])
.values(agent_id=agent.id, agent_name=agent.name)
)
with engine.connect() as conn:
before_ids = {
row["id"]
for row in messages_service.list_session_messages(
conn,
session_id=ids["session_a"],
limit=500,
)["messages"]
}
dispatch_calls = []
async def dispatch_async(payload):
dispatch_calls.append(payload)
return {"status_code": 202, "body": {"delivery_state": "queued"}}
monkeypatch.setattr(internal_client, "dispatch_async", dispatch_async)
response = client.post(
f"/api/sessions/{ids['session_a']}/messages",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=csrf_headers(client, REMOTE_ORIGIN),
json={
"text": "Run it",
"metadata": {
"_web_push_authorization_contexts": [
{"user_key": "remote:spoofed", "email": "[email protected]"}
],
"resource_user_context": {
"sub": "spoofed",
"vibe_instance_role": "owner",
"vibe_instance_access_source": "owner",
},
},
},
)
assert response.status_code == 202
assert len(dispatch_calls) == 1
assert dispatch_calls[0]["text"] == "Run it"
with engine.connect() as conn:
stored = message_deliveries.get_delivery(conn, response.get_json()["id"])
after_ids = {
row["id"]
for row in messages_service.list_session_messages(
conn,
session_id=ids["session_a"],
limit=500,
)["messages"]
}
assert stored is not None
stored_metadata = message_deliveries.delivery_payload(stored)["metadata"]
assert stored_metadata["resource_user_context"]["sub"] == "[email protected]"
assert stored_metadata["resource_user_context"]["vibe_instance_role"] == "editor"
assert stored_metadata["_web_push_authorization_contexts"][0]["sub"] == (
"[email protected]"
)
assert "spoofed" not in json.dumps(stored_metadata)
assert after_ids == before_ids
def test_viewer_no_match_owner_and_local_matrix(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
conn.execute(
scopes.update()
.where(scopes.c.native_id == ids["project_a"])
.values(metadata_json=json.dumps({"host_path_hint": "/private/host"}))
)
conn.execute(
agent_sessions.update()
.where(agent_sessions.c.id == ids["session_a"])
.values(
workdir=str((tmp_path / "project-a").resolve()),
metadata_json=json.dumps({"host_session_hint": "/private/session"}),
)
)
engine.dispose()
viewer = _remote_client(config, role="viewer", email="[email protected]")
viewer_projects = _get(viewer, "/api/projects").get_json()["projects"]
viewer_project = next(row for row in viewer_projects if row["id"] == ids["project_a"])
assert viewer_project["folder_path"] == ""
assert viewer_project["metadata"] == {}
viewer_project_detail = _get(viewer, f"/api/projects/{ids['project_a']}").get_json()
assert viewer_project_detail["folder_path"] == ""
assert viewer_project_detail["metadata"] == {}
assert _get(viewer, f"/api/sessions/{ids['session_a']}").status_code == 200
assert _get(viewer, f"/api/sessions/{ids['session_b']}").status_code == 404
headers = csrf_headers(viewer, REMOTE_ORIGIN)
mark_read = viewer.post(
f"/api/sessions/{ids['session_a']}/mark-read",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={},
)
assert mark_read.status_code == 200
for action in ("messages", "attachments", "cancel"):
response = viewer.post(
f"/api/sessions/{ids['session_a']}/{action}",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={"text": "viewer must not send"} if action == "messages" else {},
)
assert response.status_code == 403
assert viewer.post(
"/api/sessions",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers=headers,
json={"project_id": ids["project_a"]},
).status_code == 403
no_match = _remote_client(
config,
role="editor",
email="[email protected]",
active_org=False,
)
assert _get(no_match, "/api/projects").status_code == 200
assert _get(no_match, "/api/projects").get_json()["projects"] == []
assert _get(no_match, "/api/sessions").status_code == 200
assert _get(no_match, f"/api/sessions/{ids['session_a']}").status_code == 404
no_match_headers = csrf_headers(no_match, REMOTE_ORIGIN)
denied = no_match.post(
"/api/sessions",
base_url=REMOTE_ORIGIN,
environ_base=REMOTE_PEER,
headers={**no_match_headers, "Accept-Language": "zh-CN,zh;q=0.9"},
json={"project_id": ids["project_a"]},
)
assert denied.status_code == 403
organization_member = app.test_client()
organization_member.set_cookie(
remote_access.SESSION_COOKIE_NAME,
remote_session_cookie(
config,
"[email protected]",
"user-org-member",
role="editor",
access_source="organization_group",
organization_id="org_beta",
organization_member_id="member_beta",
organization_role="member",
group_ids=["grp_beta"],
),
domain="alex.avibe.bot",
)
assert {row["id"] for row in _get(organization_member, "/api/projects").get_json()["projects"]} == {ids["project_b"]}
assert _get(organization_member, f"/api/sessions/{ids['session_b']}").status_code == 200
assert _get(organization_member, f"/api/sessions/{ids['session_a']}").status_code == 404
assert _get(organization_member, f"/api/media/{ids['media_b']}").status_code == 200
assert _get(organization_member, f"/api/media/{ids['media_a']}").status_code == 404
owner = _remote_client(config, role="owner", email="[email protected]")
owner_projects = _get(owner, "/api/projects").get_json()["projects"]
assert {row["id"] for row in owner_projects} == {
ids["project_a"],
ids["project_b"],
}
owner_project_a = next(row for row in owner_projects if row["id"] == ids["project_a"])
assert owner_project_a["folder_path"] == str((tmp_path / "project-a").resolve())
assert owner_project_a["metadata"] == {"host_path_hint": "/private/host"}
owner_project = _get(owner, f"/api/projects/{ids['project_a']}").get_json()
assert owner_project["folder_path"] == str((tmp_path / "project-a").resolve())
assert owner_project["metadata"] == {"host_path_hint": "/private/host"}
owner_bootstrap = _get(owner, "/api/workbench/projects-bootstrap").get_json()
bootstrap_project_a = next(
row for row in owner_bootstrap["projects"] if row["id"] == ids["project_a"]
)
assert bootstrap_project_a["folder_path"] == str((tmp_path / "project-a").resolve())
assert bootstrap_project_a["metadata"] == {"host_path_hint": "/private/host"}
owner_sessions = _get(owner, "/api/sessions").get_json()["sessions"]
owner_session_a = next(row for row in owner_sessions if row["id"] == ids["session_a"])
assert owner_session_a["workdir"] == str((tmp_path / "project-a").resolve())
assert owner_session_a["metadata"] == {"host_session_hint": "/private/session"}
owner_session_a = _get(owner, f"/api/sessions/{ids['session_a']}").get_json()
assert owner_session_a["workdir"] == str((tmp_path / "project-a").resolve())
assert owner_session_a["metadata"] == {"host_session_hint": "/private/session"}
assert _get(owner, f"/api/sessions/{ids['unscoped']}").status_code == 200
local = app.test_client()
local_projects = local.get("/api/projects", base_url="http://localhost").get_json()["projects"]
assert {row["id"] for row in local_projects} == {ids["project_a"], ids["project_b"]}
local_project_a = next(row for row in local_projects if row["id"] == ids["project_a"])
assert local_project_a["folder_path"] == str((tmp_path / "project-a").resolve())
assert local_project_a["metadata"] == {"host_path_hint": "/private/host"}
local_session_a = local.get(
f"/api/sessions/{ids['session_a']}",
base_url="http://localhost",
).get_json()
assert local_session_a["workdir"] == str((tmp_path / "project-a").resolve())
assert local_session_a["metadata"] == {"host_session_hint": "/private/session"}
assert local.get(f"/api/sessions/{ids['unscoped']}", base_url="http://localhost").status_code == 200
def test_show_page_payload_redacts_path_for_viewers(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
engine = create_sqlite_engine()
with engine.begin() as conn:
project_access_service.apply_project_access_intent(
conn,
{
**_intent(ids["project_a"], "[email protected]", role="viewer"),
"revision": 2,
},
)
monkeypatch.setattr(
api,
"list_show_pages",
lambda **_kwargs: {
"ok": True,
"count": 1,
"pages": [{"session_id": ids["session_a"], "path": "/private/show-page"}],
},
)
viewer = _remote_client(config, role="viewer", email="[email protected]")
viewer_page = _get(viewer, "/api/show-pages").get_json()["pages"][0]
assert "path" not in viewer_page
editor = _remote_client(config, role="editor", email="[email protected]")
editor_page = _get(editor, "/api/show-pages").get_json()["pages"][0]
assert "path" not in editor_page
owner = _remote_client(config, role="owner", email="[email protected]")
owner_page = _get(owner, "/api/show-pages").get_json()["pages"][0]
assert owner_page["path"] == "/private/show-page"
def test_show_page_mutation_payload_redacts_direct_and_nested_pages(monkeypatch) -> None:
context = AuthorizationContext(
instance_role="editor",
email="[email protected]",
subject="user-editor",
is_remote=True,
)
class _Connection:
def __enter__(self):
return self
def __exit__(self, *_exc_info):
return False
class _Engine:
def connect(self):
return _Connection()
monkeypatch.setattr(ui_server, "_projects_engine", lambda: _Engine())
monkeypatch.setattr(
project_access_service,
"get_effective_session_role",
lambda _conn, _context, _session_id: "viewer",
)
monkeypatch.setattr(
project_access_service,
"get_session_project_id",
lambda _conn, _session_id: "project-1",
)
monkeypatch.setattr(project_access_service, "session_exists", lambda _conn, _session_id: True)
monkeypatch.setattr(
resource_access_service,
"can_manage_resource_acl",
lambda _context, _kind, _resource_id, *, connection: False,
)
direct = ui_server._show_page_response_for_request(
{"ok": True, "session_id": "session-a", "path": "/private/page"},
context,
)
nested = ui_server._show_page_response_for_request(
{
"ok": True,
"page": {"session_id": "session-a", "path": "/private/page"},
},
context,
)
assert "path" not in direct
assert "path" not in nested["page"]
def test_show_page_payload_preserves_path_for_non_project_page_owner(monkeypatch) -> None:
context = AuthorizationContext(
instance_role="editor",
email="[email protected]",
subject="user-editor",
is_remote=True,
)
class _Connection:
def __enter__(self):
return self
def __exit__(self, *_exc_info):
return False
class _Engine:
def connect(self):
return _Connection()
monkeypatch.setattr(ui_server, "_projects_engine", lambda: _Engine())
monkeypatch.setattr(
project_access_service,
"get_effective_session_role",
lambda _conn, _context, _session_id: None,
)
monkeypatch.setattr(
project_access_service,
"get_session_project_id",
lambda _conn, _session_id: None,
)
monkeypatch.setattr(project_access_service, "session_exists", lambda _conn, _session_id: True)
monkeypatch.setattr(
resource_access_service,
"can_manage_resource_acl",
lambda _context, _kind, _resource_id, *, connection: True,
)
payload = ui_server._show_page_response_for_request(
{"ok": True, "session_id": "im-session", "path": "/private/page"},
context,
)
assert payload["path"] == "/private/page"
def test_show_page_payload_project_viewer_downgrade_wins_over_instance_editor(monkeypatch) -> None:
context = AuthorizationContext(
instance_role="editor",
email="[email protected]",
subject="user-editor",
is_remote=True,
)
class _Connection:
def __enter__(self):
return self
def __exit__(self, *_exc_info):
return False
class _Engine:
def connect(self):
return _Connection()
monkeypatch.setattr(ui_server, "_projects_engine", lambda: _Engine())
monkeypatch.setattr(
project_access_service,
"get_effective_session_role",
lambda _conn, _context, _session_id: "viewer",
)
monkeypatch.setattr(
project_access_service,
"get_session_project_id",
lambda _conn, _session_id: "project-1",
)
monkeypatch.setattr(project_access_service, "session_exists", lambda _conn, _session_id: True)
payload = ui_server._show_page_response_for_request(
{"ok": True, "session_id": "project-session", "path": "/private/page"},
context,
)
assert "path" not in payload
def test_show_page_payload_does_not_treat_inaccessible_project_as_unscoped(monkeypatch) -> None:
context = AuthorizationContext(
instance_role="editor",
email="[email protected]",
subject="user-editor",
is_remote=True,
)
class _Connection:
def __enter__(self):
return self
def __exit__(self, *_exc_info):
return False
class _Engine:
def connect(self):
return _Connection()
monkeypatch.setattr(ui_server, "_projects_engine", lambda: _Engine())
monkeypatch.setattr(
project_access_service,
"get_effective_session_role",
lambda _conn, _context, _session_id: None,
)
monkeypatch.setattr(
project_access_service,
"get_session_project_id",
lambda _conn, _session_id: "project-removed-binding",
)
monkeypatch.setattr(project_access_service, "session_exists", lambda _conn, _session_id: True)
payload = ui_server._show_page_response_for_request(
{"ok": True, "session_id": "project-session", "path": "/private/page"},
context,
)
assert "path" not in payload
def test_show_page_payload_redacts_path_when_session_is_missing(monkeypatch) -> None:
context = AuthorizationContext(
instance_role="editor",
email="[email protected]",
subject="user-editor",
is_remote=True,
)
class _Connection:
def __enter__(self):
return self
def __exit__(self, *_exc_info):
return False
class _Engine:
def connect(self):
return _Connection()
monkeypatch.setattr(ui_server, "_projects_engine", lambda: _Engine())
monkeypatch.setattr(project_access_service, "session_exists", lambda _conn, _session_id: False)
payload = ui_server._show_page_response_for_request(
{"ok": True, "session_id": "deleted-session", "path": "/private/page"},
context,
)
assert "path" not in payload
@pytest.mark.parametrize("role", ["viewer", "editor"])
def test_retry_notice_update_stream_keeps_remote_session_acl(monkeypatch, tmp_path, role) -> None:
import asyncio
from vibe.sse_broker import broker
from vibe.ui_compat import g
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_config, ids = _setup_state(tmp_path)
context = AuthorizationContext(
instance_role=role,
email="[email protected]",
subject="user-editor",
instance_access_source="organization_group",
organization_id="org-1",
organization_member_id="member-1",
organization_role="member",
is_remote=True,
)
visible = {
"id": "notice",
"session_id": ids["session_a"],
"content": {"failure_retry": {"delivery_id": "retry-delivery", "state": "queued"}},
}
async def collect():
with ui_server.app.test_request_context("/api/events"):
g.authorization_context = context
response = await ui_server.workbench_events()
iterator = response.body_iterator.__aiter__()
try:
for _ in range(3):
await iterator.__anext__()
broker.publish("message.updated", {**visible, "session_id": ids["session_b"]})
broker.publish("message.updated", {**visible, "session_id": "missing-session"})
broker.publish("message.updated", visible)
return await asyncio.wait_for(iterator.__anext__(), timeout=1)
finally:
await iterator.aclose()
frame = asyncio.run(collect())
if isinstance(frame, bytes):
frame = frame.decode("utf-8")
assert "event: message.updated\n" in frame
data = next(line.removeprefix("data: ") for line in frame.splitlines() if line.startswith("data: "))
assert json.loads(data)["data"] == visible
def test_project_access_filters_sse_and_show_websocket(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, ids = _setup_state(tmp_path)
context = AuthorizationContext(
instance_role="editor",
email="[email protected]",
subject="user-editor",
instance_access_source="organization_group",
organization_id="org-1",
organization_member_id="member-1",
organization_role="member",
is_remote=True,
)
visible_payload = json.dumps({"type": "session.status", "data": {"session_id": ids["session_a"]}})
hidden_payload = json.dumps({"type": "session.status", "data": {"session_id": ids["session_b"]}})
assert ui_server._workbench_event_visible_to_context(context, "session.status", visible_payload) is True
assert ui_server._workbench_event_visible_to_context(context, "session.status", hidden_payload) is False
assert ui_server._workbench_event_visible_to_context(
context,
"authorization.changed",
json.dumps({"type": "authorization.changed", "data": {"project_ids": []}}),
) is True
cookie = remote_session_cookie(
config,
"[email protected]",
"user-editor",
role="editor",
access_source="organization_group",
organization_id="org-1",
organization_member_id="member-1",
organization_role="member",
group_ids=["grp_beta"],
)
websocket = SimpleNamespace(
client=SimpleNamespace(host="203.0.113.10"),
headers={"host": "alex.avibe.bot"},
cookies={remote_access.SESSION_COOKIE_NAME: cookie},
url=SimpleNamespace(scheme="wss"),
)
assert ui_server._show_runtime_websocket_authorized(
websocket,
minimum_role="viewer",
project_session_id=ids["session_a"],
) is True
# §3.2: /show admission follows the Instance role alone, independent of the
# Project ACL, so the show websocket authorizes a page outside the caller's
# Project access exactly like an in-Project one (a Viewer enters every page).
assert ui_server._show_runtime_websocket_authorized(
websocket,
minimum_role="viewer",
project_session_id=ids["session_b"],
) is True
def test_terminal_websocket_requires_editor_role_without_a_project(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config, _ids = _setup_state(tmp_path)
viewer_cookie = remote_session_cookie(
config,
"[email protected]",
"user-viewer",
role="viewer",
access_source="organization_group",
organization_id="org-1",
organization_member_id="member-viewer",
organization_role="member",
group_ids=["grp_beta"],
)
editor_cookie = remote_session_cookie(
config,
"[email protected]",
"user-editor",
role="editor",
access_source="organization_group",
organization_id="org-1",
organization_member_id="member-1",
organization_role="member",
group_ids=["grp_beta"],
)
viewer_socket = SimpleNamespace(
client=SimpleNamespace(host="203.0.113.10"),
headers={"host": "alex.avibe.bot"},
cookies={remote_access.SESSION_COOKIE_NAME: viewer_cookie},
url=SimpleNamespace(scheme="wss"),
)
editor_socket = SimpleNamespace(
client=SimpleNamespace(host="203.0.113.10"),
headers={"host": "alex.avibe.bot"},
cookies={remote_access.SESSION_COOKIE_NAME: editor_cookie},
url=SimpleNamespace(scheme="wss"),
)
assert ui_server._show_runtime_websocket_authorized(
viewer_socket,
minimum_role="editor",
) is False
assert ui_server._show_runtime_websocket_authorized(
editor_socket,
minimum_role="editor",
) is True