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
"""Instance management preserves admission policy through real remote HTTP writes.
Scenario: PERMISSIONS-013. All persistent state belongs to pytest's home;
only provider/host/runtime effects are stubbed, after the authorization seam.
"""
from __future__ import annotations
import copy
import contextlib
import json
import re
from pathlib import Path
from unittest.mock import AsyncMock
import pytest
from config import paths
from config.v2_config import V2Config
from config.v2_settings import BindCode, ChannelSettings, GuildSettings, SettingsStore, UserSettings
from storage.importer import ensure_sqlite_state
from tests.ui_server_test_helpers import _save_config, csrf_headers, remote_peer, remote_session_cookie
from vibe import api, internal_client, remote_access, ui_server
from vibe.authorization import AuthorizationContext, InstanceAuthorizationError, http_authorization_policy
BASE_URL = "https://alex.avibe.bot"
MEMBER = AuthorizationContext(
instance_role="member",
subject="manager",
instance_access_source="organization_group",
instance_kind="organization",
organization_id="org-1",
organization_member_id="membership-manager",
organization_role="member",
group_ids=frozenset(),
is_remote=True,
)
@pytest.fixture
def management_http(tmp_path, monkeypatch):
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _save_config(tmp_path, paired=True, instance_kind="organization")
ensure_sqlite_state()
SettingsStore.reset_instance()
async def reconciled(*args, **kwargs):
return {"status_code": 200, "body": {"ok": True}}
monkeypatch.setattr(internal_client, "reconcile_platforms", reconciled)
monkeypatch.setattr(internal_client, "reconcile_agent_backends", reconciled)
monkeypatch.setattr(ui_server, "_ensure_remote_access_monitoring", lambda *args: None)
def connect(role="member", *, organization_role="member", authenticated=True):
client = ui_server.app.test_client()
if authenticated:
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
remote_session_cookie(
config,
f"{role}@example.com",
role,
role=role,
access_source="owner" if role == "owner" else "organization_group",
organization_id="org-1",
organization_member_id=f"membership-{role}",
organization_role=organization_role,
group_ids=[],
),
domain="alex.avibe.bot",
)
headers = csrf_headers(client, base_url=BASE_URL)
def request(method, route, *, payload=None, csrf=True, origin=None):
request_headers = dict(headers) if csrf else {}
if origin is not None:
request_headers["Origin"] = origin
return client.request(
method,
route,
json=payload,
headers=request_headers,
base_url=BASE_URL,
environ_base=remote_peer(),
)
return request
yield connect
SettingsStore.reset_instance()
# This inventory describes retained effects independently of the policy rules.
# A newly registered Owner-only management route must be consciously classified.
_RETAINED_OWNER_ROUTES = {
# MCP Hub management runs arbitrary local commands: Owner-only (plan §7).
("POST", "/api/mcp"),
("POST", "/api/mcp/discover"),
("POST", "/api/mcp/{name}/refresh"),
("DELETE", "/api/mcp/{name}"),
("GET", "/api/mcp/{name}/oauth/start"),
("POST", "/api/mcp/{name}/oauth/complete"),
("POST", "/api/mcp/{name}/oauth/logout"),
("PUT", "/api/permissions/authorized-users"),
("PUT", "/api/permissions/projects/{project_id}/access"),
("PUT", "/api/permissions/resources/{resource_kind}/{resource_id}/access"),
("GET", "/api/agent-onboarding"),
("POST", "/api/agent-onboarding"),
("POST", "/api/remote-access/vibe-cloud/pair"),
("POST", "/api/wechat/qr_login/start"),
("POST", "/api/wechat/qr_login/poll"),
("POST", "/api/users/{user_id}/admin"),
("DELETE", "/api/users/{user_id}"),
("GET", "/api/bind-codes"),
("POST", "/api/bind-codes"),
("DELETE", "/api/bind-codes/{code}"),
("GET", "/api/setup/first-bind-code"),
# Bots are the instance Owner's (docs/plans/bots.md D1, "Web API (owner-only)").
("GET", "/api/bots"),
("POST", "/api/bots"),
("POST", "/api/bots/set"),
("POST", "/api/bots/handle-suggestion"),
("PATCH", "/api/bots/{handle}"),
("DELETE", "/api/bots/{handle}"),
("PUT", "/api/bots/{handle}/avatar"),
("GET", "/api/bots/{handle}/avatar"),
}
def test_complete_registered_api_management_inventory():
endpoints = {
(method, route.path)
for route in ui_server.app.routes
if getattr(route, "path", "").startswith("/api/")
for method in (getattr(route, "methods", None) or ())
if method not in {"HEAD", "OPTIONS"}
}
# master 297 + 10 MCP Hub routes, classified in tests/test_mcp_hub_api.py, + 8 Bots routes (Owner, above), + 2 notification preference methods
assert len(endpoints) == 317
# Editors who use Vault read avault's authorization state; the handler admits only
# instance managers to raise the Keychain dialog on the host.
for method in ("GET", "POST"):
assert (method, "/api/vault/avault-authorization") in endpoints
assert http_authorization_policy(method, "/api/vault/avault-authorization").minimum_role == "editor"
for tool in ("web_search", "web_fetch"):
retry_route = f"/api/models/hosted-tools/{tool}/services/{{source_id}}/retry"
assert ("POST", retry_route) in endpoints
assert http_authorization_policy("POST", retry_route).minimum_role == "member"
assert ("GET", "/api/sessions/main") in endpoints
assert http_authorization_policy("POST", "/api/vault/requests/{request_id}/approve-delete").minimum_role == "editor"
# Approvers still read policy and remember duration; protection fields add a service check.
for method in ("GET", "PATCH"):
assert http_authorization_policy(method, "/api/vault/settings").minimum_role == "editor"
for method in ("PUT", "DELETE"):
assert (method, "/api/vault/secrets/{name}/fields/{field}") in endpoints
assert http_authorization_policy(method, "/api/vault/secrets/LOGIN/fields/username").minimum_role == "editor"
assert http_authorization_policy("POST", "/api/desktop-mini/session").minimum_role == "editor"
assert http_authorization_policy("GET", "/api/desktop/capabilities").minimum_role == "member"
assert http_authorization_policy("GET", "/api/desktop/computer-use/status").minimum_role == "member"
assert ("POST", "/api/desktop/update/request") in endpoints
assert http_authorization_policy("POST", "/api/desktop/update/request").minimum_role == "member"
# Additive read-only backend projection inherits native backend-management
# authorization; it does not grant lower-tier credential-management access.
assert ("GET", "/api/backend/{name}/connection") in endpoints
assert http_authorization_policy("GET", "/api/backend/claude/connection").minimum_role == "member"
# Frozen from 1b191200c: independently protect all existing lower-tier grants.
baseline_read_roles = json.loads(
(Path(__file__).parent / "fixtures/member_management_existing_read_roles.json").read_text()
)
actual_read_roles = {}
owners = {
(method, raw)
for method, raw in endpoints
if http_authorization_policy(method, re.sub(r"\{[^}]+\}", "example", raw)).minimum_role == "owner"
}
assert owners == _RETAINED_OWNER_ROUTES
for method, raw in endpoints:
path = re.sub(r"\{[^}]+\}", "example", raw)
minimum = http_authorization_policy(method, path).minimum_role
if minimum in {"viewer", "editor"}:
actual_read_roles[f"{method} {path}"] = minimum
for kind in ("personal", "organization"):
for role in ("owner", "member", "editor", "viewer", None):
context = AuthorizationContext(
instance_role=role,
instance_kind=kind,
organization_role="owner",
is_remote=True,
)
if role in {"owner", "member"}:
assert context.has_role(minimum) == (role == "owner" or (method, raw) not in _RETAINED_OWNER_ROUTES)
if role in {"editor", "viewer"}:
old_minimum = baseline_read_roles.get(f"{method} {path}")
expected = old_minimum == "viewer" or (old_minimum == "editor" and role == "editor")
assert context.has_role(minimum) is expected, (role, method, path)
if role is None:
assert not context.has_role(minimum), (method, raw)
assert actual_read_roles == baseline_read_roles
@pytest.mark.parametrize("role, status", [("editor", 403), ("member", 200), ("owner", 200)])
def test_authorize_avault_http_needs_instance_management(management_http, monkeypatch, role, status):
started = []
monkeypatch.setattr(api, "start_avault_authorization", lambda: started.append(True) or {"ok": True})
request_http = management_http(role)
assert request_http("GET", "/api/vault/avault-authorization").status_code == 200
response = request_http("POST", "/api/vault/avault-authorization", payload={})
assert response.status_code == status, response.get_json()
assert started == ([True] if status == 200 else [])
@pytest.mark.parametrize("role, status", [("editor", 403), ("member", 200), ("owner", 200)])
def test_approve_delete_http_uses_management_authority(management_http, role, status):
"""The real HTTP path must pass remote authority to the deletion transaction."""
from sqlalchemy import select
from storage import vault_service
from storage.models import vault_requests, vault_secrets
from storage.vault_crypto import Sealed
request_http = management_http(role)
routes = [
route for route in ui_server.app.routes
if getattr(route, "path", "") == "/api/vault/requests/{request_id}/approve-delete"
and "POST" in (getattr(route, "methods", None) or ())
]
assert len(routes) == 1
# Native registration uses the handler itself, not a compat endpoint wrapper.
assert routes[0].endpoint is ui_server.vault_request_approve_delete_post
engine = api._vault_engine()
try:
with engine.begin() as conn:
vault_service.create_secret(conn, name="DELETE_HTTP", sealed=Sealed("ct", "nonce", "wrap"))
pending = vault_service.create_delete_request(conn, "DELETE_HTTP")
response = request_http("POST", f"/api/vault/requests/{pending['id']}/approve-delete", payload={})
assert response.status_code == status, response.get_json()
with engine.connect() as conn:
remaining = conn.execute(select(vault_secrets.c.name).where(vault_secrets.c.name == "DELETE_HTTP")).first()
decided = conn.execute(select(vault_requests.c.status).where(vault_requests.c.id == pending["id"])).scalar_one()
if status == 403:
assert response.get_json()["code"] == "resource_access_forbidden"
assert remaining is not None and decided == "pending"
else:
assert response.get_json()["removed"] is True
assert remaining is None and decided == "approved"
finally:
engine.dispose()
@pytest.mark.parametrize("role", ["owner", "member", "editor", "viewer", None])
def test_backend_connection_native_route_preserves_management_roles(management_http, monkeypatch, role):
request = management_http(role or "viewer", authenticated=role is not None)
readiness = AsyncMock(return_value={"ok": True, "ready": True, "application": "applied"})
ipc = AsyncMock(side_effect=AssertionError("no live IPC"))
monkeypatch.setattr(api, "get_backend_connection", readiness)
monkeypatch.setattr(internal_client, "backend_application", ipc)
for name in ("claude", "codex", "opencode"):
response = request("GET", f"/api/backend/{name}/connection")
if role in {"owner", "member"}:
assert response.status_code == 200, response.get_json()
assert response.get_json() == readiness.return_value
assert response.headers["Cache-Control"] == "private, no-store"
readiness.assert_awaited_with(name)
else:
assert response.status_code in {401, 403}, response.get_json()
readiness.assert_not_awaited()
previous_calls = readiness.await_count
unsupported = request("GET", "/api/backend/unknown/connection")
assert unsupported.status_code == (400 if role in {"owner", "member"} else 401 if role is None else 403)
assert readiness.await_count == previous_calls
ipc.assert_not_awaited()
@pytest.mark.parametrize(
"role, payload, status",
[
("editor", {"strict_approvals": True}, 403),
("editor", {"unlock_window_seconds": 1800}, 403),
("editor", {"last_grant_ttl": 900}, 200),
("editor", {"last_grant_ttl": "one-time"}, 200),
("editor", {"strict_approvals": True, "unlock_window_seconds": 1800, "last_grant_ttl": 900}, 403),
("member", {"strict_approvals": True}, 200),
("owner", {"strict_approvals": True}, 200),
],
)
def test_vault_settings_patch_http_splits_field_authority(management_http, role, payload, status):
"""The route remains Editor-tier, but protected settings fields require management."""
from sqlalchemy import select
from storage import vault_service
from storage.models import state_meta
request = management_http(role)
before = request("GET", "/api/vault/settings")
assert before.status_code == 200, before.get_json()
before_settings = before.get_json()["settings"]
engine = api._vault_engine()
try:
with engine.connect() as conn:
stored_before = conn.execute(
select(state_meta).where(state_meta.c.key == vault_service.VAULT_SETTINGS_META_KEY)
).first()
finally:
engine.dispose()
response = request("PATCH", "/api/vault/settings", payload=payload)
assert response.status_code == status, response.get_json()
body = response.get_json()
after = request("GET", "/api/vault/settings")
assert after.status_code == 200, after.get_json()
if status == 403:
assert body["ok"] is False
assert body["code"] == "resource_access_forbidden"
assert after.get_json()["settings"] == before_settings
engine = api._vault_engine()
try:
with engine.connect() as conn:
stored_after = conn.execute(
select(state_meta).where(state_meta.c.key == vault_service.VAULT_SETTINGS_META_KEY)
).first()
assert stored_after == stored_before # Not even a normalized/default settings row was written.
finally:
engine.dispose()
else:
expected = dict(before_settings)
expected.update(payload)
assert body["ok"] is True
assert body["settings"] == after.get_json()["settings"] == expected
@pytest.mark.parametrize("role", ["member", "owner"])
def test_manager_saves_config_credentials_and_reads_masked_result(management_http, role):
request = management_http(role)
before = V2Config.load().remote_access
response = request(
"POST",
"/api/config",
payload={
"slack": {"bot_token": "xoxb-test-member-token", "app_token": "xapp-test-member-token"},
"runtime": {"log_level": "DEBUG"},
},
)
assert response.status_code == 200, response.get_json()
saved = V2Config.load()
assert saved.slack.bot_token == "xoxb-test-member-token"
assert saved.runtime.log_level == "DEBUG"
assert saved.remote_access == before
response = request("GET", "/api/config")
assert response.status_code == 200
assert "xoxb-test-member-token" not in json.dumps(response.get_json())
assert response.get_json()["runtime"]["log_level"] == "DEBUG"
@pytest.mark.parametrize(
"payload",
[
{"slack": {"require_bind": True}},
{"telegram": {"allowed_user_ids": ["attacker"]}},
{"telegram": {"allowed_chat_ids": ["attacker"]}},
{"ui": {"trusted_public_origins": ["https://attacker.example"]}},
{"remote_access": {"vibe_cloud": {"instance_id": "other"}}},
{"__avibe_list_ops": {"telegram.allowed_user_ids": {"add": ["attacker"]}}},
{"discord": {"guild_allowlist": ["attacker"]}},
],
)
def test_member_generic_config_protects_access_fields(management_http, payload):
request = management_http()
before = paths.get_config_path().read_bytes()
response = request("POST", "/api/config", payload=payload)
assert response.status_code in {400, 403}, response.get_json()
assert paths.get_config_path().read_bytes() == before
def test_legacy_discord_admission_survives_member_credential_migration(management_http):
request = management_http()
config_payload = json.loads(paths.get_config_path().read_text())
config_payload["discord"] = {"bot_token": "test-token", "guild_denylist": ["blocked"]}
paths.get_config_path().write_text(json.dumps(config_payload))
response = request("POST", "/api/config", payload={"discord": {"bot_token": "new-test-token"}})
assert response.status_code == 200, response.get_json()
store = SettingsStore.get_instance()
assert not store.is_guild_enabled("discord", "blocked")
assert store.is_guild_enabled("discord", "other")
response = request("POST", "/api/config", payload={"discord": {"guild_denylist": []}})
assert response.status_code == 403, response.get_json()
assert not store.is_guild_enabled("discord", "blocked")
def test_member_config_equal_protected_echo_is_valid_but_omission_cannot_reset(management_http):
request = management_http()
config = V2Config.load()
config.slack.require_bind = True
config.save()
assert (
request("POST", "/api/config", payload={"slack": {"require_bind": True}, "language": "zh"}).status_code == 200
)
assert request("POST", "/api/config", payload={"runtime": {"log_level": "DEBUG"}}).status_code == 200
assert V2Config.load().slack.require_bind
assert request("POST", "/api/config", payload={"slack": None}).status_code == 403
assert V2Config.load().slack.require_bind
@pytest.mark.parametrize("role", ["editor", "viewer"])
def test_organization_owner_does_not_supply_instance_management(management_http, role):
request = management_http(role, organization_role="owner")
before = paths.get_config_path().read_bytes()
response = request("POST", "/api/config", payload={"runtime": {"log_level": "DEBUG"}})
assert response.status_code in {400, 403}
assert request("PUT", "/api/workbench/prefs", payload={"background_work_banner_enabled": False}).status_code == 403
assert paths.get_config_path().read_bytes() == before
@pytest.mark.parametrize("csrf,origin", [(False, None), (True, "https://attacker.example")])
def test_member_csrf_still_precedes_management_effects(management_http, csrf, origin):
request = management_http()
before = paths.get_config_path().read_bytes()
response = request("POST", "/api/config", payload={"language": "zh"}, csrf=csrf, origin=origin)
assert response.status_code == 403
assert paths.get_config_path().read_bytes() == before
def test_unauthenticated_remote_management_is_denied(management_http):
request = management_http(authenticated=False)
response = request("POST", "/api/config", payload={"language": "zh"})
assert response.status_code in {401, 403}
def test_member_channel_and_dm_preferences_preserve_access_state(management_http):
"""PERMISSIONS-013: Instance Member manages settings while preserving access administration."""
store = SettingsStore.get_instance()
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(require_bind=True)})
store.set_users_for_platform("telegram", {"bound": UserSettings(is_admin=True, enabled=False, bound_at="old")})
store.save()
request = management_http()
response = request(
"POST",
"/api/settings",
payload={
"platform": "telegram",
"channels": {"chat": {"enabled": False, "require_mention": False, "custom_cwd": "/tmp/ordinary"}},
},
)
assert response.status_code == 200, response.get_json()
assert not store.find_channel("chat", platform="telegram").enabled
assert store.find_channel("chat", platform="telegram").require_bind
response = request(
"POST",
"/api/users",
payload={"platform": "telegram", "users": {"bound": {"display_name": "成员", "custom_cwd": "/tmp/dm"}}},
)
assert response.status_code == 200, response.get_json()
user = store.get_user("bound", platform="telegram")
assert (user.is_admin, user.enabled, user.bound_at, user.custom_cwd) == (True, False, "old", "/tmp/dm")
readback = request("GET", "/api/users?platform=telegram").get_json()
assert readback["users"]["bound"]["display_name"] == "成员"
for patch in ({"new": {}}, {"bound": {"enabled": True}}, {"bound": {"is_admin": False}}):
assert request("POST", "/api/users", payload={"platform": "telegram", "users": patch}).status_code == 403
assert set(store.get_users_for_platform("telegram")) == {"bound"}
assert not store.get_user("bound", platform="telegram").enabled
def test_member_scope_patch_preserves_access_state(management_http):
"""PERMISSIONS-013: the single-scope settings PATCH keeps the same Member boundary."""
store = SettingsStore.get_instance()
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(enabled=True, require_bind=True)})
store.set_users_for_platform("telegram", {"bound": UserSettings(is_admin=True, enabled=False, bound_at="old")})
store.save()
request = management_http()
def patch(scope, native_id, changes):
return request("PATCH", "/api/settings/scope", payload={
"platform": "telegram", "scope": scope, "id": native_id, "changes": changes,
})
assert patch("channel", "chat", {"custom_cwd": "/tmp/ordinary"}).status_code == 200
assert patch("user", "bound", {"display_name": "成员", "custom_cwd": "/tmp/dm"}).status_code == 200
assert patch("channel", "chat", {"require_bind": False}).status_code == 403
assert patch("user", "bound", {"enabled": True}).status_code == 403
refused = patch("user", "bound", {"is_admin": False})
assert refused.status_code == 400 and refused.get_json()["code"] == "invalid_changes"
store = SettingsStore.get_instance()
channel, user = store.find_channel("chat", platform="telegram"), store.get_user("bound", platform="telegram")
assert (channel.custom_cwd, channel.require_bind) == ("/tmp/ordinary", True)
assert (user.display_name, user.custom_cwd, user.is_admin, user.enabled) == ("成员", "/tmp/dm", True, False)
@pytest.mark.parametrize(
"channels", [{}, {"chat": {}}, {"chat": {"require_bind": None}}, {"chat": {"require_bind": False}}]
)
def test_member_channel_replacement_preserves_binding_effect(management_http, channels):
store = SettingsStore.get_instance()
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(require_bind=True)})
store.save()
response = management_http()("POST", "/api/settings", payload={"platform": "telegram", "channels": channels})
assert response.status_code == (200 if channels == {"chat": {}} else 403), response.get_json()
assert store.find_channel("chat", platform="telegram").require_bind
@pytest.mark.parametrize("parent,override", [(True, False), (False, True), (True, True), (False, None)])
def test_thread_deletion_compares_actual_parent_fallback(management_http, parent, override):
store = SettingsStore.get_instance()
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(require_bind=parent)})
store.update_thread("chat", "7", ChannelSettings(require_bind=override), platform="telegram")
response = management_http()("DELETE", "/api/settings/thread?platform=telegram&channel_id=chat&thread_id=7")
assert response.status_code == (200 if parent == bool(override) else 403), response.get_json()
@pytest.mark.parametrize("mutation", ["remove", "role", "disable"])
def test_locked_member_save_cannot_undo_concurrent_membership_change(management_http, mutation):
store = SettingsStore.get_instance()
store.set_users_for_platform("telegram", {"bound": UserSettings(bound_at="old")})
store.save()
stale = copy.deepcopy(store.settings)
if mutation == "remove":
store.set_users_for_platform("telegram", {})
else:
user = store.get_user("bound", platform="telegram")
if mutation == "role":
user.is_admin = True
else:
user.enabled = False
store.save()
fresh = store._service.load_state()
stale.users["telegram::bound"].custom_cwd = "/tmp/stale-preference"
with pytest.raises(InstanceAuthorizationError):
store._service.save_state(stale, user_context=MEMBER)
assert store._service.load_state() == fresh
def test_member_guild_aliases_cannot_change_admission(management_http):
store = SettingsStore.get_instance()
store.set_guilds_for_platform("discord", {"blocked": GuildSettings(enabled=False)}, default_enabled=True)
store.save()
request = management_http()
for payload in (
{"guilds": {}, "guild_default_enabled": True},
{"guild_allowlist": ["new"], "guild_default_enabled": False},
{"guilds": {"blocked": {"enabled": True}}},
):
response = request("POST", "/api/settings", payload={"platform": "discord", **payload})
assert response.status_code == 403, response.get_json()
assert not store.is_guild_enabled("discord", "blocked")
def test_member_workbench_preferences_round_trip(management_http):
request = management_http()
response = request("PUT", "/api/workbench/prefs", payload={"background_work_banner_enabled": False})
assert response.status_code == 200, response.get_json()
assert request("GET", "/api/workbench/prefs").get_json()["background_work_banner_enabled"] is False
@pytest.mark.parametrize("role", ["owner", "member", "editor", "viewer"])
def test_remote_management_handlers_reach_only_stubbed_host_effects(management_http, monkeypatch, role):
from vibe import cli
calls = []
def effect(name):
def run(*args, **kwargs):
calls.append((name, args, kwargs))
return {"ok": True, "operation": name}
return run
async def runtime_effect(*args, **kwargs):
return effect("runtime")(*args, **kwargs)
monkeypatch.setattr(api, "get_backend_runtime_async", runtime_effect)
monkeypatch.setattr(api, "start_dependency_install_job", effect("dependency"))
monkeypatch.setattr(api, "slack_auth_test", effect("platform"))
monkeypatch.setattr(cli, "_doctor", effect("doctor"))
monkeypatch.setattr(remote_access, "apply_settings", effect("transport"))
request = management_http(role)
for method, path, payload in (
("GET", "/api/backend/claude/runtime", None),
("POST", "/api/dependencies/avault/install", {}),
("POST", "/api/slack/auth_test", {"bot_token": "test-token"}),
("POST", "/api/doctor", {"deep": True}),
("POST", "/api/remote-access/settings", {"connector_mode": "manual"}),
):
response = request(method, path, payload=payload)
assert response.status_code == (200 if role in {"owner", "member"} else 403), response.get_json()
if role in {"owner", "member"}:
assert response.get_json()["ok"]
assert [call[0] for call in calls] == (
["runtime", "dependency", "platform", "doctor", "transport"] if role in {"owner", "member"} else []
)
if calls:
assert calls[0][1] == ("claude", None)
assert calls[1][1] == ("avault",)
assert calls[2][1][0] == "test-token"
assert calls[3][2]["deep"] is True
@pytest.mark.parametrize("child_requires_bind", [True, False])
def test_channel_delete_checks_descendant_policy_in_same_transaction(management_http, child_requires_bind):
from core import chat_discovery
chat_discovery.remember_thread("telegram", "chat", "7")
store = SettingsStore.get_instance()
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(require_bind=False)})
store.update_thread("chat", "7", ChannelSettings(require_bind=child_requires_bind), platform="telegram")
before = store._service.load_state()
response = management_http()("POST", "/api/channels/delete", payload={"platform": "telegram", "id": "chat"})
assert response.status_code == (403 if child_requires_bind else 200), response.get_json()
after = store._service.load_state()
if child_requires_bind:
assert after == before
else:
assert after.channels == {} and after.threads == {}
def test_remote_member_vault_metadata_and_protected_use_boundary(management_http):
from storage import vault_service
from storage.vault_crypto import Sealed
engine = api._vault_engine()
try:
with engine.begin() as conn:
vault_service.create_secret(
conn,
name="MANAGED_TEST",
protection="protected",
sealed=Sealed(ciphertext="ct", nonce="n", wrap_meta="wm"),
)
request = management_http()
response = request(
"PATCH", "/api/vault/secrets/MANAGED_TEST", payload={"description": "managed metadata", "tags": ["test"]}
)
assert response.status_code == 200, response.get_json()
with engine.connect() as conn:
row = vault_service.get_secret_meta(conn, "MANAGED_TEST")
assert row["description"] == "managed metadata" and row["tags"] == ["test"]
result = vault_service.resolve_secret_access(
conn, "MANAGED_TEST", session_id="ses-test", user_context=MEMBER
)
assert result["status"] == "approval_required"
assert result.get("envelope") is None
assert (
management_http("editor")(
"PATCH", "/api/vault/secrets/MANAGED_TEST", payload={"description": "forbidden"}
).status_code
== 403
)
finally:
engine.dispose()
def test_member_remote_transport_save_preserves_pairing_identity(management_http, monkeypatch):
monkeypatch.setattr(remote_access, "status", lambda *args: {"running": False, "ok": True})
monkeypatch.setattr(remote_access, "edge_binding_error", lambda *args: None)
request = management_http()
before = V2Config.load().remote_access.vibe_cloud
response = request("POST", "/api/remote-access/settings", payload={"auto_recovery": not before.auto_recovery})
assert response.status_code == 200 and response.get_json()["settings_applied"], response.get_json()
after = V2Config.load().remote_access.vibe_cloud
assert after.auto_recovery != before.auto_recovery
assert (after.instance_id, after.instance_secret, after.session_secret) == (
before.instance_id,
before.instance_secret,
before.session_secret,
)
for field in ("instance_id", "session_secret", "instance_secret", "backend_url"):
response = request("POST", "/api/remote-access/settings", payload={field: "injected"})
assert response.get_json()["error"] == "remote_access_settings_invalid"
assert V2Config.load().remote_access.vibe_cloud == after
@pytest.mark.parametrize("surface", ["users", "channels", "thread", "thread_delete", "guilds", "config_guilds"])
def test_uncommitted_member_candidate_cannot_escape_through_owner_request(management_http, monkeypatch, surface):
"""Two real HTTP worker threads overlap between mutation and guarded save."""
from concurrent.futures import ThreadPoolExecutor
from threading import Event
store = SettingsStore.get_instance()
store.set_users_for_platform("telegram", {"bound": UserSettings(is_admin=False)})
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(require_bind=True)})
store.update_thread("chat", "7", ChannelSettings(require_bind=False), platform="telegram")
store.set_guilds_for_platform("discord", {"blocked": GuildSettings(enabled=False)}, default_enabled=True)
store.save()
before = store._service.load_state()
member = management_http()
owner = management_http("owner")
prepared, owner_done = Event(), Event()
save = SettingsStore.save
def paused_save(candidate, *, user_context=None):
if user_context is not None and user_context.instance_role == "member":
prepared.set()
assert owner_done.wait(10), "Owner request did not finish while Member candidate was private"
return save(candidate, user_context=user_context)
monkeypatch.setattr(SettingsStore, "save", paused_save)
mutations = {
"users": ("POST", "/api/users", {"platform": "telegram", "users": {"bound": {"is_admin": True}}}),
"channels": ("POST", "/api/settings", {"platform": "telegram", "channels": {"chat": {"require_bind": False}}}),
"thread": (
"POST",
"/api/settings/thread",
{"platform": "telegram", "channel_id": "chat", "thread_id": "7", "settings": {"require_bind": True}},
),
"thread_delete": ("DELETE", "/api/settings/thread?platform=telegram&channel_id=chat&thread_id=7", None),
"guilds": ("POST", "/api/settings", {"platform": "discord", "guilds": {"blocked": {"enabled": True}}}),
"config_guilds": ("POST", "/api/config", {"discord": {"guild_denylist": []}}),
}
method, route, payload = mutations[surface]
with ThreadPoolExecutor(max_workers=2) as pool:
member_job = pool.submit(member, method, route, payload=payload)
assert prepared.wait(10)
try:
# Read the shared cache as a controller would, before Owner's save.
assert SettingsStore.get_instance().settings == before
if surface == "config_guilds":
# Config holds its own lock, so overlap the controller's existing
# shared-store writer, which does not need to load config.
def controller_save():
store.set_channels_for_platform("slack", {"ordinary": ChannelSettings(enabled=True)})
store.save()
pool.submit(controller_save).result(timeout=10)
else:
owner_job = pool.submit(
owner,
"POST",
"/api/settings",
payload={"platform": "slack", "channels": {"ordinary": {"enabled": True}}},
)
response = owner_job.result(timeout=10)
assert response.status_code == 200, response.get_json()
finally:
owner_done.set()
response = member_job.result(timeout=10)
assert response.status_code == 403, response.get_json()
after = store._service.load_state()
assert after.users == before.users and after.threads == before.threads
assert after.guilds == before.guilds
assert after.channels["telegram::chat"].require_bind
assert after.channels["slack::ordinary"].enabled
@pytest.mark.parametrize("role", ["member", "owner"])
@pytest.mark.parametrize("surface", ["users", "channels", "thread", "thread_delete", "guilds", "config_guilds"])
def test_overlapping_settings_requests_keep_both_scopes(management_http, monkeypatch, role, surface):
"""Successful private writes merge into the lock-fresh state, not a stale whole snapshot."""
from concurrent.futures import ThreadPoolExecutor
from threading import Event
store = SettingsStore.get_instance()
store.set_users_for_platform("telegram", {"bound": UserSettings()})
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(require_bind=True)})
store.set_channels_for_platform("slack", {
"ordinary": ChannelSettings(custom_cwd="/before"),
"removed": ChannelSettings(),
})
store.update_thread("chat", "7", ChannelSettings(require_bind=True), platform="telegram")
store.set_guilds_for_platform("discord", {"blocked": GuildSettings(enabled=False)}, default_enabled=True)
store.save()
first, owner = management_http(role), management_http("owner")
prepared, committed = Event(), Event()
save = SettingsStore.save
def paused_save(candidate, *, user_context=None):
if user_context is not None and not prepared.is_set():
prepared.set()
assert committed.wait(10)
return save(candidate, user_context=user_context)
monkeypatch.setattr(SettingsStore, "save", paused_save)
mutations = {
"users": ("POST", "/api/users", {"platform": "telegram", "users": {"bound": {"custom_cwd": "/first"}}}),
"channels": ("POST", "/api/settings", {"platform": "telegram", "channels": {"chat": {"custom_cwd": "/first"}}}),
"thread": ("POST", "/api/settings/thread", {
"platform": "telegram", "channel_id": "chat", "thread_id": "7", "settings": {"custom_cwd": "/first"},
}),
"thread_delete": ("DELETE", "/api/settings/thread?platform=telegram&channel_id=chat&thread_id=7", None),
"guilds": ("POST", "/api/settings", {"platform": "discord", "guilds": {"blocked": {"enabled": False}}}),
"config_guilds": ("POST", "/api/config", {"discord": {"guild_denylist": ["blocked"]}}),
}
method, route, payload = mutations[surface]
with ThreadPoolExecutor(max_workers=2) as pool:
pending = pool.submit(first, method, route, payload=payload)
assert prepared.wait(10)
try:
if surface == "config_guilds":
# The config writer holds config lock; overlap the existing
# controller writer, not a second request needing that lock.
def controller_save():
store.set_channels_for_platform("slack", {
"ordinary": ChannelSettings(custom_cwd="/second"),
"added": ChannelSettings(enabled=True),
})
store.save()
pool.submit(controller_save).result(timeout=10)
else:
response = pool.submit(owner, "POST", "/api/settings", payload={
"platform": "slack", "channels": {
"ordinary": {"custom_cwd": "/second"}, "added": {"enabled": True},
},
}).result(timeout=10)
assert response.status_code == 200, response.get_json()
finally:
committed.set()
response = pending.result(timeout=10)
assert response.status_code == 200, response.get_json()
after = store._service.load_state()
assert after.channels["slack::ordinary"].custom_cwd == "/second"
assert after.channels["slack::added"].enabled
assert "slack::removed" not in after.channels
if surface in {"users", "channels", "thread"}:
changed = {
"users": after.users["telegram::bound"],
"channels": after.channels["telegram::chat"],
"thread": after.threads["telegram::chat/7"],
}
assert changed[surface].custom_cwd == "/first"
elif surface == "thread_delete":
assert not after.threads
@pytest.mark.parametrize("mutation", ["remove", "role", "disable"])
def test_private_member_dm_save_refuses_changed_membership(management_http, monkeypatch, mutation):
"""The real HTTP candidate must not resurrect or rewrite a concurrently changed user."""
from concurrent.futures import ThreadPoolExecutor
from threading import Event
store = SettingsStore.get_instance()
store.set_users_for_platform("telegram", {"bound": UserSettings()})
store.save()
request = management_http()
prepared, committed = Event(), Event()
save = SettingsStore.save
def paused_save(candidate, *, user_context=None):
if user_context is not None:
prepared.set()
assert committed.wait(10)
return save(candidate, user_context=user_context)
monkeypatch.setattr(SettingsStore, "save", paused_save)
with ThreadPoolExecutor(max_workers=2) as pool:
pending = pool.submit(request, "POST", "/api/users", payload={
"platform": "telegram", "users": {"bound": {"custom_cwd": "/stale"}},
})
assert prepared.wait(10)
try:
if mutation == "remove":
store.set_users_for_platform("telegram", {})
elif mutation == "role":
store.get_user("bound", platform="telegram").is_admin = True
else:
store.get_user("bound", platform="telegram").enabled = False
pool.submit(store.save).result(timeout=10)
fresh = store._service.load_state()
finally:
committed.set()
response = pending.result(timeout=10)
assert response.status_code == 403, response.get_json()
assert store._service.load_state() == fresh
def test_member_stale_access_snapshot_cannot_replay_untouched_rows(management_http, monkeypatch):
from concurrent.futures import ThreadPoolExecutor
from threading import Event
store = SettingsStore.get_instance()
store.set_channels_for_platform("telegram", {"chat": ChannelSettings()})
store.set_users_for_platform("telegram", {"changed": UserSettings(), "removed": UserSettings()})
store.set_guilds_for_platform("discord", {"before": GuildSettings()}, default_enabled=False)
store.settings.bind_codes = [BindCode("old", "one_time", "now")]
store.save()
request = management_http()
prepared, committed = Event(), Event()
save = SettingsStore.save
def paused_save(candidate, *, user_context=None):
if user_context is not None:
prepared.set()
assert committed.wait(10)
return save(candidate, user_context=user_context)
monkeypatch.setattr(SettingsStore, "save", paused_save)
with ThreadPoolExecutor(max_workers=2) as pool:
pending = pool.submit(request, "POST", "/api/settings", payload={
"platform": "telegram", "channels": {"chat": {"custom_cwd": "/ordinary"}},
})
assert prepared.wait(10)
try:
store.set_users_for_platform("telegram", {
"changed": UserSettings(is_admin=True, enabled=False), "added": UserSettings(),
})
store.set_guilds_for_platform("discord", {"after": GuildSettings()}, default_enabled=False)
store.settings.bind_codes = [BindCode("new", "one_time", "now")]
pool.submit(store.save).result(timeout=10)
fresh = store._service.load_state()
finally:
committed.set()
response = pending.result(timeout=10)
assert response.status_code == 403, response.get_json()
after = store._service.load_state()
assert after.channels["telegram::chat"].custom_cwd is None
assert after.users == fresh.users
assert after.guilds == fresh.guilds and after.guild_default_enabled == fresh.guild_default_enabled
assert after.bind_codes == fresh.bind_codes
@pytest.mark.parametrize("field", ["is_admin", "enabled", "require_bind"])
def test_member_explicit_unchanged_access_echo_is_checked_against_fresh_state(management_http, monkeypatch, field):
from concurrent.futures import ThreadPoolExecutor
from threading import Event
store = SettingsStore.get_instance()
store.set_users_for_platform("telegram", {"bound": UserSettings(is_admin=False, enabled=True)})
store.set_channels_for_platform("telegram", {"chat": ChannelSettings(require_bind=False)})
store.save()
request = management_http()
prepared, committed = Event(), Event()
save = SettingsStore.save
def paused_save(candidate, *, user_context=None):
if user_context is not None:
prepared.set()
assert committed.wait(10)
return save(candidate, user_context=user_context)
monkeypatch.setattr(SettingsStore, "save", paused_save)
if field == "require_bind":
route = "/api/settings"
payload = {"platform": "telegram", "channels": {"chat": {field: False}}}
else:
route = "/api/users"
payload = {"platform": "telegram", "users": {"bound": {field: field == "enabled"}}}
with ThreadPoolExecutor(max_workers=2) as pool:
pending = pool.submit(request, "POST", route, payload=payload)
assert prepared.wait(10)
try:
if field == "require_bind":
store.find_channel("chat", platform="telegram").require_bind = True
else:
setattr(store.get_user("bound", platform="telegram"), field, field == "is_admin")
pool.submit(store.save).result(timeout=10)
fresh = store._service.load_state()
finally:
committed.set()
response = pending.result(timeout=10)
assert response.status_code == 403, response.get_json()
assert store._service.load_state() == fresh
@pytest.mark.parametrize("raw", [
b"{", b"[]", b"null", b"\xff", b'{"discord": []}',
b'{"discord": {"bot_token": 12}}', b'{"discord": {"thread_auto_archive_minutes": 13}}',
])
def test_member_settings_save_uses_config_recovery_semantics(management_http, raw):
config_path = paths.get_config_path()
config_path.write_bytes(raw)
# Startup accepts these released/damaged shapes with recovery defaults.
recovered = V2Config.load()
assert recovered.load_warnings
result = api.save_settings({"platform": "telegram", "channels": {"safe": {"enabled": True}}}, user_context=MEMBER)
assert "safe" in result["channels"]
with contextlib.closing(SettingsStore()) as saved:
assert saved.find_channel("safe", platform="telegram").enabled
assert config_path.read_bytes() == raw # The policy read never persists recovery.
@pytest.mark.parametrize("role", ["member", "owner"])
def test_legacy_opencode_catalog_clears_recovery_and_allows_config_save(management_http, role):
"""MODEL-HUB-MIGRATION-001: disk migration restores settings writes for both roles."""
request = management_http(role)
path = paths.get_config_path()
payload = json.loads(path.read_text())
payload["model_hub"]["agents"]["opencode"].pop("models")
path.write_text(json.dumps(payload))
response = request("GET", "/api/config")
assert response.status_code == 200, response.get_json()
assert response.get_json()["config_recovery"]["required"] is False
response = request("POST", "/api/config", payload={"show_duration": True})
assert response.status_code == 200, response.get_json()
saved = V2Config.load()
assert saved.load_warnings == ()
assert saved.show_duration is True
assert saved.model_hub.agents["opencode"].models == []
assert json.loads(path.read_text())["remote_access"] == payload["remote_access"]
@pytest.mark.parametrize("discord", [[], "invalid", {"bot_token": 12}])
@pytest.mark.parametrize("surface", ["channels", "thread", "users"])
def test_remote_member_can_save_with_recovered_discord_section(management_http, discord, surface):
store = SettingsStore.get_instance()
store.set_users_for_platform("telegram", {"bound": UserSettings()})
store.save()
request = management_http()
config_path = paths.get_config_path()
payload = json.loads(config_path.read_text())
payload["discord"] = discord
config_path.write_text(json.dumps(payload))
mutations = {
"channels": ("/api/settings", {"platform": "telegram", "channels": {"safe": {"enabled": True}}}),
"thread": ("/api/settings/thread", {
"platform": "telegram", "channel_id": "safe", "thread_id": "7", "settings": {"enabled": True},
}),
"users": ("/api/users", {"platform": "telegram", "users": {"bound": {"custom_cwd": "/recovered"}}}),
}
route, body = mutations[surface]
response = request("POST", route, payload=body)
assert response.status_code == 200, response.get_json()
after = store._service.load_state()
if surface == "channels":
assert after.channels["telegram::safe"].enabled
elif surface == "thread":
assert after.threads["telegram::safe/7"].enabled
else:
assert after.users["telegram::bound"].custom_cwd == "/recovered"
# Unrelated remote identity remains intact and the raw file is not repaired here.
assert json.loads(config_path.read_text()) == payload
def test_recovery_keeps_valid_legacy_guild_admission_policy(management_http):
request = management_http()
config_path = paths.get_config_path()
payload = json.loads(config_path.read_text())
payload["discord"] = {"guild_allowlist": ["allowed"], "guild_denylist": ["blocked"]}
payload["runtime"] = []
config_path.write_text(json.dumps(payload))
recovered = V2Config.load()
assert recovered.load_warnings
assert recovered.discord.guild_allowlist == ["allowed"]
response = request("POST", "/api/settings", payload={
"platform": "discord", "guild_allowlist": ["attacker"],
})
assert response.status_code == 403, response.get_json()
response = request("POST", "/api/settings", payload={
"platform": "discord", "guilds": {"allowed": {"enabled": True}, "blocked": {"enabled": False}},
"guild_default_enabled": False,
})
assert response.status_code == 200, response.get_json()
assert json.loads(config_path.read_text()) == payload