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 asyncio
from concurrent.futures import ThreadPoolExecutor
import itertools
import json
import threading
import time
from typing import Any
import pytest
from config.v2_config import (
AgentsConfig,
PlatformsConfig,
RemoteAccessConfig,
RuntimeConfig,
SlackConfig,
UiConfig,
V2Config,
)
from tests.ui_server_test_helpers import csrf_headers
from storage import remote_access_authorization_service
from storage.lock import MigrationLockTimeout
from vibe import remote_access, ui_server
from vibe.authorization import context_from_session_payload
from vibe.sse_broker import broker
from vibe.ui_compat import g
from vibe.ui_server import app
@pytest.fixture(autouse=True)
def _clear_authorization_refresh_process_state():
with remote_access._AUTHORIZATION_REFRESH_LOCK:
remote_access._AUTHORIZATION_REFRESH_FAILURES.clear()
remote_access._AUTHORIZATION_REFRESH_RESULTS.clear()
remote_access._AUTHORIZATION_REFRESH_FLIGHTS.clear()
with remote_access._AUTHORIZATION_BACKGROUND_REFRESH_LOCK:
remote_access._AUTHORIZATION_BACKGROUND_REFRESHES.clear()
yield
with remote_access._AUTHORIZATION_REFRESH_LOCK:
remote_access._AUTHORIZATION_REFRESH_FAILURES.clear()
remote_access._AUTHORIZATION_REFRESH_RESULTS.clear()
remote_access._AUTHORIZATION_REFRESH_FLIGHTS.clear()
def _paired_config(tmp_path, *, revision: int = 41) -> V2Config:
import os
os.environ["AVIBE_HOME"] = str(tmp_path)
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.backend_url = "https://backend.test"
cloud.public_url = "https://alex.avibe.bot"
cloud.client_id = "vr_client_123"
cloud.instance_id = "inst_123"
cloud.instance_kind = "organization"
cloud.instance_secret = "instance-secret"
cloud.session_secret = "session-secret"
cloud.authorization_endpoint = "https://backend.test/oauth/authorize"
cloud.redirect_uri = "https://alex.avibe.bot/auth/callback"
config.save()
remote_access._clear_authorization_revision_cache()
remote_access._replace_authorization_revision(config, revision)
return config
# Binding-row seeding is the CALLER's job: some tests need an absent
# row (upgrade path), others need a ready row (concurrent resolvers).
def _organization_claims(
config: V2Config,
*,
revision: int = 41,
role: str = "editor",
) -> dict[str, Any]:
return {
"vibe_instance_id": config.remote_access.vibe_cloud.instance_id,
"vibe_instance_role": role,
"vibe_instance_access_source": "organization_group",
"vibe_instance_authorization_revision": revision,
"vibe_organization_id": "org_123",
"vibe_organization_member_id": "member_123",
"vibe_organization_role": "member",
"vibe_group_ids": ["group_research"],
"vibe_membership_version": "membership-v1",
}
def _organization_cookie(
config: V2Config,
*,
revision: int = 41,
subject: str = "user-1",
) -> str:
return remote_access.make_session_cookie(
config,
f"{subject}@example.com",
subject,
session_claims=_organization_claims(config, revision=revision),
)
def _authorization_context_response(
config: V2Config,
request_payload: dict[str, Any],
*,
revision: int,
instance_kind: str = "organization",
) -> dict[str, Any]:
return {
"sub": request_payload["sub"],
"email": request_payload["email"],
"instance_kind": instance_kind,
**_organization_claims(config, revision=revision),
}
def test_personal_session_slides_past_claim_and_original_identity_deadlines(
monkeypatch,
tmp_path,
):
"""Scenario: AUTH-SETUP-402."""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
base = int(time.time())
monkeypatch.setattr(remote_access.time, "time", lambda: base)
cookie = remote_access.make_session_cookie(
config,
"[email protected]",
"personal-owner",
session_claims={
"vibe_instance_id": "inst_123",
"vibe_instance_role": "owner",
"vibe_instance_access_source": "owner",
"vibe_instance_authorization_revision": 41,
},
)
monkeypatch.setattr(
remote_access.time,
"time",
lambda: base + remote_access.PERSONAL_SESSION_RENEW_AFTER_SECONDS + 1,
)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
first = remote_access.resolve_current_authorization(config, identity)
assert first.current is True
renewed_cookie = remote_access.renew_session_cookie(config, first.payload)
renewed_identity = remote_access.parse_session_identity(config, renewed_cookie)
assert renewed_identity is not None
assert renewed_identity["claims_issued_at"] == base
monkeypatch.setattr(
remote_access.time,
"time",
lambda: base + remote_access.PERSONAL_SESSION_TTL_SECONDS + 60,
)
after_original_expiry = remote_access.parse_session_identity(config, renewed_cookie)
assert after_original_expiry is not None
result = remote_access.resolve_current_authorization(config, after_original_expiry)
assert result.current is True
assert result.policy == "personal"
assert result.payload["claims_issued_at"] == base
def test_validated_remote_payload_projects_paired_instance_kind(tmp_path):
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
payload = remote_access._validated_authorization_payload(
config,
{
"sub": "personal-user",
"email": "[email protected]",
"instance_id": "inst_123",
},
{
"id": "authorization-1",
"claims": {**_organization_claims(config), "vibe_instance_kind": "personal"},
},
)
assert payload is not None
assert context_from_session_payload(payload).is_personal_instance
def test_cached_authorization_from_previous_instance_kind_refreshes_before_personal_bypass(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
calls = []
def refresh(_config, _method, _suffix, payload, **kwargs):
calls.append(payload)
return _authorization_context_response(
config,
payload,
revision=41,
instance_kind="personal",
)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
result = remote_access.resolve_current_authorization(config, identity)
assert result.current is True
assert result.refreshed is True
assert result.policy == "personal"
assert len(calls) == 1
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=int(time.time()),
)
assert record is not None
assert record["claims"]["vibe_instance_kind"] == "personal"
def test_partial_pairing_cannot_restore_cached_personal_authorization(tmp_path):
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = ""
config.save()
payload = remote_access._validated_authorization_payload(
config,
{
"sub": "personal-user",
"email": "[email protected]",
"instance_id": "inst_123",
},
{
"id": "authorization-1",
"claims": {**_organization_claims(config), "vibe_instance_kind": "organization"},
},
)
assert payload is None
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
resolution = remote_access.resolve_current_authorization(
config,
identity,
allow_refresh=False,
)
assert resolution.state == "unavailable"
assert resolution.reason == "pairing_unavailable"
def test_organization_to_personal_reclassification_revalidates_before_the_bypass(
monkeypatch,
tmp_path,
):
"""A reclassified pairing must re-earn every cached authorization."""
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
reference = identity["authorization_ref"]
now = int(time.time())
admitted = remote_access_authorization_service.load_reference_record(
reference=reference,
instance_id="inst_123",
subject="user-1",
now=now,
)
assert admitted is not None
assert admitted["authorization_state"] == "current"
historical_reference = remote_access_authorization_service.upsert_scoped(
reference=None,
instance_id="inst_123",
subject="historical-user",
email="[email protected]",
scope_kind="retired_scope",
scope_ref="retired-reference",
authorization_state="current",
claims={"vibe_instance_id": "inst_123"},
last_checked_at=now,
updated_at=now,
)
assert remote_access._persist_instance_kind("inst_123", "personal", reconcile=True)
reclassified = V2Config.load()
assert reclassified.remote_access.vibe_cloud.instance_kind == "personal"
invalidated = remote_access_authorization_service.load_reference_record(
reference=reference,
instance_id="inst_123",
subject="user-1",
now=now,
)
assert invalidated is not None
assert invalidated["authorization_state"] == "stale"
historical = remote_access_authorization_service.load_reference_record(
reference=historical_reference,
instance_id="inst_123",
subject="historical-user",
now=now,
)
assert historical is not None
assert historical["authorization_state"] == "stale"
# The cached Organization claims must not be re-projected as Personal.
blocked = remote_access.resolve_current_authorization(
reclassified,
identity,
allow_refresh=False,
)
assert blocked.current is False
assert blocked.reason == "authorization_context_missing"
calls = []
def refresh(_config, _method, _suffix, payload, **kwargs):
calls.append(payload)
return _authorization_context_response(
config,
payload,
revision=41,
instance_kind="personal",
)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
result = remote_access.resolve_current_authorization(reclassified, identity)
assert result.current is True
assert result.refreshed is True
assert result.policy == "personal"
# Synchronous revalidation, not a background hint that would let the
# Personal bypass answer this very request from the stale row.
assert len(calls) == 1
revalidated = remote_access_authorization_service.load_reference_record(
reference=reference,
instance_id="inst_123",
subject="user-1",
now=now,
)
assert revalidated is not None
assert revalidated["authorization_state"] == "current"
assert revalidated["claims"]["vibe_instance_kind"] == "personal"
def test_instance_kind_persistence_failure_leaves_no_kind_tagged_current_row(
monkeypatch,
tmp_path,
):
"""A failed kind write must not leave a usable Personal projection behind."""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = ""
config.save()
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
reference = identity["authorization_ref"]
now = int(time.time())
# Collapse the failure backoff so the retry below exercises the network
# path instead of the short-circuit that protects the backend.
monkeypatch.setattr(remote_access, "AUTHORIZATION_REFRESH_FAILURE_BACKOFF_SECONDS", 0.0)
monkeypatch.setattr(
remote_access,
"current_authorization_revision",
lambda *args, **kwargs: 42,
)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda _config, _method, _suffix, payload, **kwargs: _authorization_context_response(
config,
payload,
revision=42,
instance_kind="personal",
),
)
real_save_config = remote_access.api.save_config
attempted: list[dict[str, Any]] = []
def failing_save_config(payload, **kwargs):
attempted.append(payload)
raise OSError("read-only config")
monkeypatch.setattr(remote_access.api, "save_config", failing_save_config)
blocked = remote_access.resolve_current_authorization(config, identity)
assert blocked.state == "unavailable"
assert blocked.reason == "instance_kind_persistence_failed"
assert attempted
assert V2Config.load().remote_access.vibe_cloud.instance_kind == ""
stored = remote_access_authorization_service.load_reference_record(
reference=reference,
instance_id="inst_123",
subject="user-1",
now=now,
)
assert stored is not None
assert "vibe_instance_kind" not in stored["claims"]
kindless_payload = remote_access._validated_authorization_payload(
config,
identity,
stored,
)
assert kindless_payload is not None
assert context_from_session_payload(kindless_payload).is_personal_instance is False
monkeypatch.setattr(remote_access.api, "save_config", real_save_config)
retried = remote_access.resolve_current_authorization(config, identity)
assert retried.current is True
assert retried.policy == "personal"
assert V2Config.load().remote_access.vibe_cloud.instance_kind == "personal"
repaired = remote_access_authorization_service.load_reference_record(
reference=reference,
instance_id="inst_123",
subject="user-1",
now=now,
)
assert repaired is not None
assert repaired["claims"]["vibe_instance_kind"] == "personal"
def test_refresh_from_a_previous_binding_generation_is_discarded(monkeypatch, tmp_path):
"""An in-flight response that outlived its binding must not be cached."""
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
binding_before = remote_access_authorization_service.load_instance_binding_state()
assert binding_before is not None
def repair_while_in_flight(_config, _method, _suffix, payload, **kwargs):
# A re-pair lands while this authorization response is in flight.
remote_access._transition_instance_binding(
instance_id="inst_repair",
instance_kind="personal",
)
return _authorization_context_response(config, payload, revision=41)
monkeypatch.setattr(remote_access, "_device_json_request", repair_while_in_flight)
result = remote_access._refresh_authorization_context(
config,
identity,
record,
now=now,
force=True,
)
assert result.state == "unavailable"
assert result.reason == "instance_binding_changed"
binding_after = remote_access_authorization_service.load_instance_binding_state()
assert binding_after is not None
assert binding_after["generation"] > binding_before["generation"]
assert binding_after["instance_id"] == "inst_repair"
with remote_access._AUTHORIZATION_REFRESH_LOCK:
assert remote_access._AUTHORIZATION_REFRESH_RESULTS == {}
assert remote_access._AUTHORIZATION_REFRESH_FAILURES == {}
# The discarded generation must not be answerable from cache either.
assert (
remote_access.resolve_current_authorization(
config,
identity,
allow_refresh=False,
).current
is False
)
def test_stale_cross_process_kind_response_cannot_reverse_durable_generation(
monkeypatch,
tmp_path,
):
"""A UI-process in-flight Personal response must not undo a controller reclass.
The controller and UI server are separate processes; the in-memory
binding epoch cannot fence this. The durable generation in state_meta
is the compare-and-swap token both processes share.
"""
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="personal",
)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
cookie = remote_access.make_session_cookie(
config,
"[email protected]",
"user-1",
session_claims={
"vibe_instance_id": "inst_123",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"vibe_instance_authorization_revision": 41,
},
)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
observed_generation = remote_access_authorization_service.current_instance_binding_generation()
# Controller heartbeat in another process: Personal -> Organization.
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
config.remote_access.vibe_cloud.instance_kind = "organization"
config.save()
newer = remote_access_authorization_service.load_instance_binding_state()
assert newer is not None
assert newer["generation"] > observed_generation
assert newer["instance_kind"] == "organization"
# Stale UI-process in-flight epoch is unchanged; durable generation is not.
monkeypatch.setattr(remote_access, "_authorization_binding_epoch", lambda: 0)
persisted = remote_access._persist_instance_kind(
"inst_123",
"personal",
expected_binding_generation=observed_generation,
expected_binding_epoch=0,
)
assert persisted is False
assert V2Config.load().remote_access.vibe_cloud.instance_kind == "organization"
after = remote_access_authorization_service.load_instance_binding_state()
assert after is not None
assert after["generation"] == newer["generation"]
assert after["instance_kind"] == "organization"
def test_stale_write_is_refused_under_cross_process_config_lock(tmp_path):
"""Two threads contend on config_file_lock; the stale writer must abort.
This is the real cross-process lock boundary (the same lock V2Config.save
uses), not the in-process epoch.
"""
from config.v2_config import config_file_lock
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="personal",
)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
observed = remote_access_authorization_service.current_instance_binding_generation()
# flock is process-level, so two threads in one process cannot actually
# block each other on config_file_lock. Model the cross-process race as:
# snapshot generation, then a controller advance under that lock, then a
# stale persist that must CAS-fail against the durable generation.
with config_file_lock():
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
config.remote_access.vibe_cloud.instance_kind = "organization"
config.save()
controller_generation = (
remote_access_authorization_service.current_instance_binding_generation()
)
stale_ok = remote_access._persist_instance_kind(
"inst_123",
"personal",
expected_binding_generation=observed,
)
assert stale_ok is False
assert controller_generation > observed
assert V2Config.load().remote_access.vibe_cloud.instance_kind == "organization"
after = remote_access_authorization_service.load_instance_binding_state()
assert after is not None
assert after["instance_kind"] == "organization"
assert after["generation"] == controller_generation
def test_stale_denied_response_does_not_recreate_revoked_row(monkeypatch, tmp_path):
"""A 403 captured before a transition must not recreate a revoked row."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
started = remote_access_authorization_service.begin_instance_binding_transition(
instance_id="inst_123",
instance_kind="organization",
)
assert remote_access_authorization_service.complete_instance_binding_transition(
instance_id="inst_123",
instance_kind="organization",
generation=started["generation"],
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
observed = remote_access_authorization_service.current_instance_binding_generation()
real_generation = remote_access_authorization_service.current_instance_binding_generation
calls = {"n": 0}
def deny_after_transition(_config, _method, _suffix, payload, **kwargs):
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="personal",
)
raise remote_access.BackendRequestError(403, {"error": "access_denied"})
def generation(*, ensure: bool = True) -> int:
calls["n"] += 1
if calls["n"] == 1:
return observed
return real_generation(ensure=ensure)
monkeypatch.setattr(remote_access, "_device_json_request", deny_after_transition)
monkeypatch.setattr(
remote_access_authorization_service,
"current_instance_binding_generation",
generation,
)
result = remote_access._fetch_authorization_context(
config,
identity,
record,
now=now,
observed_revision=41,
)
assert result.state == "unavailable"
assert result.reason == "instance_binding_changed"
stored = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
if stored is not None:
assert stored.get("authorization_state") != "revoked"
def test_personal_revision_hint_refreshes_in_background_without_blocking(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
entered = threading.Event()
release = threading.Event()
finished = threading.Event()
def unavailable(*args, **kwargs):
entered.set()
release.wait(timeout=1)
finished.set()
raise remote_access.BackendRequestError(503, {"error": "unavailable"})
monkeypatch.setattr(remote_access, "_device_json_request", unavailable)
result = remote_access.resolve_current_authorization(config, identity)
assert result.current is True
assert result.policy == "personal"
assert entered.wait(timeout=1)
assert finished.is_set() is False
release.set()
assert finished.wait(timeout=1)
def test_organization_scheduled_refresh_does_not_block_when_revision_matches(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
base = int(time.time())
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
refresh_at = base + remote_access.ORGANIZATION_AUTHORIZATION_REFRESH_SECONDS + 1
assert remote_access_authorization_service.mark_matching_revision_checked(
instance_id="inst_123",
authorization_revision=41,
checked_at=refresh_at,
) == 1
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 41)
scheduled = []
monkeypatch.setattr(
remote_access,
"_schedule_authorization_refresh",
lambda *args, **kwargs: scheduled.append((args, kwargs)),
)
monkeypatch.setattr(
remote_access,
"_refresh_authorization_context",
lambda *args, **kwargs: (_ for _ in ()).throw(
AssertionError("routine matching-revision refresh blocked the request")
),
)
result = remote_access.resolve_current_authorization(
config,
identity,
now=refresh_at,
)
assert result.current is True
assert result.policy == "organization"
assert result.reason == "authorization_refresh_scheduled"
assert len(scheduled) == 1
def test_organization_refresh_grace_expiry_and_recovery(monkeypatch, tmp_path):
"""Scenario: AUTH-SETUP-403."""
config = _paired_config(tmp_path)
base = int(time.time())
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
checked_at = base + remote_access.ORGANIZATION_AUTHORIZATION_REFRESH_SECONDS
assert remote_access_authorization_service.mark_matching_revision_checked(
instance_id="inst_123",
authorization_revision=41,
checked_at=checked_at,
) == 1
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: (_ for _ in ()).throw(
remote_access.BackendRequestError(503, {"error": "unavailable"})
),
)
within_grace = remote_access.resolve_current_authorization(
config,
identity,
now=checked_at + 1,
)
assert within_grace.current is True
assert within_grace.reason == "authorization_grace"
remote_access._AUTHORIZATION_REFRESH_FAILURES.clear()
after_grace = remote_access.resolve_current_authorization(
config,
identity,
now=checked_at + remote_access.ORGANIZATION_AUTHORIZATION_OUTAGE_GRACE_SECONDS + 1,
)
assert after_grace.state == "unavailable"
assert after_grace.reason == "authorization_grace_expired"
remote_access._AUTHORIZATION_REFRESH_FAILURES.clear()
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda _config, _method, _suffix, payload, **kwargs: _authorization_context_response(
config,
payload,
revision=42,
),
)
recovered = remote_access.resolve_current_authorization(
config,
identity,
now=checked_at + remote_access.ORGANIZATION_AUTHORIZATION_OUTAGE_GRACE_SECONDS + 2,
)
assert recovered.current is True
assert recovered.refreshed is True
assert recovered.payload["vibe_instance_authorization_revision"] == 42
def test_unknown_instance_kind_requires_durable_backfill_before_access(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = ""
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda _config, _method, _suffix, payload, **kwargs: _authorization_context_response(
config,
payload,
revision=42,
),
)
monkeypatch.setattr(
remote_access,
"_persist_instance_kind",
lambda *args, **kwargs: (_ for _ in ()).throw(OSError("read-only config")),
)
result = remote_access.resolve_current_authorization(config, identity)
assert result.state == "unavailable"
assert result.reason == "instance_kind_persistence_failed"
assert config.remote_access.vibe_cloud.instance_kind == ""
def test_authorization_record_read_failure_is_unavailable(monkeypatch, tmp_path):
config = _paired_config(tmp_path)
identity = remote_access.parse_session_identity(config, _organization_cookie(config))
assert identity is not None
monkeypatch.setattr(
remote_access_authorization_service,
"load_reference_record",
lambda **kwargs: (_ for _ in ()).throw(OSError("database unavailable")),
)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: (_ for _ in ()).throw(
AssertionError("storage failure must not trigger an unscoped refresh")
),
)
result = remote_access.resolve_current_authorization(config, identity)
assert result.state == "unavailable"
assert result.reason == "authorization_record_unavailable"
def test_revision_poll_touches_every_matching_current_context_only(tmp_path):
now = int(time.time())
rows = (
("user-match", 7, "current"),
("user-other", 8, "current"),
("user-revoked", 7, "revoked"),
)
for subject, revision, state in rows:
remote_access_authorization_service.upsert_scoped(
reference=None,
instance_id="inst_123",
subject=subject,
email=f"{subject}@example.com",
scope_kind="instance",
scope_ref="inst_123",
authorization_state=state,
claims={"vibe_instance_authorization_revision": revision},
last_checked_at=now,
updated_at=now,
)
assert remote_access_authorization_service.mark_matching_revision_checked(
instance_id="inst_123",
authorization_revision=7,
checked_at=now + 30,
) == 1
checked = {
subject: remote_access_authorization_service.load_scoped(
instance_id="inst_123",
subject=subject,
scope_kind="instance",
scope_ref="inst_123",
)["last_checked_at"]
for subject, _revision, _state in rows
}
assert checked == {
"user-match": now + 30,
"user-other": now,
"user-revoked": now,
}
def test_concurrent_resolvers_share_one_authorization_context_refresh(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
calls = 0
calls_lock = threading.Lock()
def refresh(_config, _method, _suffix, payload, **kwargs):
nonlocal calls
with calls_lock:
calls += 1
time.sleep(0.05)
return _authorization_context_response(config, payload, revision=42)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
with ThreadPoolExecutor(max_workers=2) as executor:
results = list(executor.map(
lambda _index: remote_access.resolve_current_authorization(config, identity),
range(2),
))
assert calls == 1
assert all(result.current and result.refreshed for result in results)
def test_authorization_context_refreshes_for_different_subjects_run_concurrently(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
identities = []
for subject in ("user-1", "user-2"):
identity = remote_access.parse_session_identity(
config,
_organization_cookie(config, subject=subject),
)
assert identity is not None
identities.append(identity)
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
entered = threading.Barrier(2)
refreshed_subjects = []
calls_lock = threading.Lock()
def refresh(_config, _method, _suffix, payload, **kwargs):
with calls_lock:
refreshed_subjects.append(payload["sub"])
entered.wait(timeout=2)
return _authorization_context_response(config, payload, revision=42)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
with ThreadPoolExecutor(max_workers=2) as executor:
results = list(executor.map(
lambda identity: remote_access.resolve_current_authorization(config, identity),
identities,
))
assert set(refreshed_subjects) == {"user-1", "user-2"}
assert all(result.current and result.refreshed for result in results)
def test_concurrent_revocation_refresh_is_reused_and_persisted(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
identity = remote_access.parse_session_identity(config, _organization_cookie(config))
assert identity is not None
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
calls = 0
calls_lock = threading.Lock()
def revoke(*args, **kwargs):
nonlocal calls
with calls_lock:
calls += 1
time.sleep(0.05)
raise remote_access.BackendRequestError(403, {"error": "access_denied"})
monkeypatch.setattr(remote_access, "_device_json_request", revoke)
with ThreadPoolExecutor(max_workers=2) as executor:
results = list(executor.map(
lambda _index: remote_access.resolve_current_authorization(config, identity),
range(2),
))
assert calls == 1
assert all(result.state == "revoked" for result in results)
with remote_access._AUTHORIZATION_REFRESH_LOCK:
remote_access._AUTHORIZATION_REFRESH_RESULTS.clear()
persisted = remote_access.resolve_current_authorization(config, identity)
assert persisted.state == "revoked"
assert calls == 1
def test_refresh_backoff_starts_when_the_network_request_finishes(
monkeypatch,
tmp_path,
):
config = _paired_config(tmp_path)
identity = remote_access.parse_session_identity(config, _organization_cookie(config))
assert identity is not None
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
monotonic_values = itertools.chain(
(100.0, 110.0, 110.05, 110.1, 110.15),
itertools.repeat(110.2),
)
monkeypatch.setattr(remote_access.time, "monotonic", lambda: next(monotonic_values))
calls = 0
def unavailable(*args, **kwargs):
nonlocal calls
calls += 1
raise remote_access.BackendRequestError(503, {"error": "unavailable"})
monkeypatch.setattr(remote_access, "_device_json_request", unavailable)
remote_access.resolve_current_authorization(config, identity)
remote_access.resolve_current_authorization(config, identity)
assert calls == 1
def test_revoked_authorization_recovers_after_revision_change(monkeypatch, tmp_path):
config = _paired_config(tmp_path)
identity = remote_access.parse_session_identity(config, _organization_cookie(config))
assert identity is not None
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 42)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: (_ for _ in ()).throw(
remote_access.BackendRequestError(403, {"error": "access_denied"})
),
)
assert remote_access.resolve_current_authorization(config, identity).state == "revoked"
monkeypatch.setattr(remote_access, "current_authorization_revision", lambda *args, **kwargs: 43)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda _config, _method, _suffix, payload, **kwargs: _authorization_context_response(
config,
payload,
revision=43,
),
)
recovered = remote_access.resolve_current_authorization(config, identity)
assert recovered.current is True
assert recovered.refreshed is True
assert recovered.payload["vibe_instance_authorization_revision"] == 43
def test_explicit_login_can_revalidate_revoked_authorization(monkeypatch, tmp_path):
config = _paired_config(tmp_path)
identity = remote_access.parse_session_identity(config, _organization_cookie(config))
assert identity is not None
observed_revision = 42
monkeypatch.setattr(
remote_access,
"current_authorization_revision",
lambda *args, **kwargs: observed_revision,
)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: (_ for _ in ()).throw(
remote_access.BackendRequestError(403, {"error": "access_denied"})
),
)
assert remote_access.resolve_current_authorization(config, identity).state == "revoked"
refresh_calls = 0
def refresh(_config, _method, _suffix, payload, **kwargs):
nonlocal refresh_calls
refresh_calls += 1
return _authorization_context_response(config, payload, revision=42)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
assert remote_access.resolve_current_authorization(config, identity).state == "revoked"
recovered = remote_access.resolve_current_authorization(
config,
identity,
refresh_revoked=True,
)
assert recovered.current is True
assert recovered.refreshed is True
assert refresh_calls == 1
def test_remote_login_forces_revoked_authorization_revalidation(monkeypatch, tmp_path):
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
refresh_flags = []
def resolve(_config, identity, **kwargs):
refresh_flags.append(kwargs.get("refresh_revoked"))
return remote_access.AuthorizationResolution("current", payload=identity)
monkeypatch.setattr(remote_access, "resolve_current_authorization", resolve)
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
cookie,
domain="alex.avibe.bot",
)
response = client.get(
"/auth/login?next=/inbox",
base_url="https://alex.avibe.bot",
follow_redirects=False,
)
assert response.status_code == 302
assert response.headers["Location"] == "/inbox"
assert refresh_flags[-1] is True
assert refresh_flags.count(True) == 1
def test_browser_logout_invalidates_http_sse_and_websocket(monkeypatch, tmp_path):
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
payload = remote_access.parse_session_cookie(config, cookie)
assert identity is not None
assert payload is not None
assert remote_access.revoke_browser_session(identity) is True
client = app.test_client()
client.set_cookie(remote_access.SESSION_COOKIE_NAME, cookie, domain="alex.avibe.bot")
assert client.get(
"/api/session",
base_url="https://alex.avibe.bot",
).get_json()["authenticated"] is False
monkeypatch.setattr(ui_server, "_AUTHORIZATION_REVISION_RECHECK_SECONDS", 0.001)
async def exercise() -> None:
with app.test_request_context(
"/api/events",
base_url="https://alex.avibe.bot",
headers={"Cookie": f"{remote_access.SESSION_COOKIE_NAME}={cookie}"},
):
g.authorization_context = context_from_session_payload(payload)
g.remote_session_identity = identity
g.remote_session_payload = payload
response = await ui_server.workbench_events()
iterator = response.body_iterator.__aiter__()
try:
terminal = await asyncio.wait_for(iterator.__anext__(), timeout=1)
assert '"state":"invalid_identity"' in terminal
with pytest.raises(StopAsyncIteration):
await iterator.__anext__()
finally:
await iterator.aclose()
outcome = await asyncio.wait_for(
ui_server._wait_for_remote_session_authorization_loss(
config,
identity,
payload,
session_cookie=cookie,
request_host="alex.avibe.bot",
),
timeout=1,
)
assert outcome == "invalid_identity"
asyncio.run(exercise())
def test_legacy_browser_logout_derives_a_stable_revocation_identity(tmp_path):
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
legacy_payload = remote_access.parse_session_identity(config, cookie)
assert legacy_payload is not None
legacy_payload.pop("browser_session_id")
legacy_cookie = remote_access._encode_session_cookie(
config.remote_access.vibe_cloud.session_secret,
legacy_payload,
)
accepted_identity = remote_access.parse_session_identity(config, legacy_cookie)
assert accepted_identity is not None
assert accepted_identity["browser_session_id"] == remote_access.parse_session_identity(
config,
legacy_cookie,
)["browser_session_id"]
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
legacy_cookie,
domain="alex.avibe.bot",
)
response = client.post(
"/auth/logout",
base_url="https://alex.avibe.bot",
json={},
headers=csrf_headers(client, "https://alex.avibe.bot"),
)
assert response.status_code == 200
assert remote_access.parse_session_identity(config, legacy_cookie) is None
assert remote_access.session_identity_is_current(accepted_identity) is False
@pytest.mark.parametrize(
("state", "status_code", "error"),
[
("revoked", 403, "remote_access_revoked"),
("unavailable", 503, "remote_access_authorization_unavailable"),
],
)
def test_remote_authorization_failure_serves_spa_shell_but_rejects_api(
monkeypatch,
tmp_path,
state,
status_code,
error,
):
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
monkeypatch.setattr(
remote_access,
"resolve_current_authorization",
lambda *args, **kwargs: remote_access.AuthorizationResolution(state),
)
client = app.test_client()
client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
cookie,
domain="alex.avibe.bot",
)
shell = client.get(
"/",
base_url="https://alex.avibe.bot",
headers={"Accept": "text/html"},
)
protected = client.get(
"/api/config",
base_url="https://alex.avibe.bot",
headers={"Accept": "application/json"},
)
assert shell.status_code == 200
assert shell.headers["content-type"].startswith("text/html")
assert protected.status_code == status_code
assert protected.get_json()["error"] == error
def _delayed_authorization_revision_sync_writer(
home: str,
entered: Any,
release: Any,
result_queue: Any,
) -> None:
import os as _os
_os.environ["AVIBE_HOME"] = home
from config.v2_config import V2Config as _V2Config
from vibe import remote_access as _remote_access
config = _V2Config.load()
state_path = _remote_access._authorization_revision_state_path()
original_read_json = _remote_access.runtime.read_json
paused = False
def delayed_read_json(path):
nonlocal paused
payload = original_read_json(path)
if path == state_path and not paused:
paused = True
entered.set()
if not release.wait(timeout=15):
raise AssertionError("delayed revision writer was never released")
return payload
_remote_access.runtime.read_json = delayed_read_json
try:
result_queue.put(("ok", _remote_access._replace_authorization_revision(config, 42)))
except Exception as exc:
result_queue.put(("error", repr(exc)))
def _authorization_revision_acknowledgement_writer(
home: str,
attempted: Any,
done: Any,
result_queue: Any,
) -> None:
import os as _os
_os.environ["AVIBE_HOME"] = home
from config.v2_config import V2Config as _V2Config
from vibe import remote_access as _remote_access
config = _V2Config.load()
attempted.set()
try:
result_queue.put(("ok", _remote_access.acknowledge_authorization_revision(config, 43)))
except Exception as exc:
result_queue.put(("error", repr(exc)))
finally:
done.set()
def test_authorization_revision_device_contract_is_monotonic(monkeypatch, tmp_path):
"""I1057-AC2/AC3: one paired-device watermark drives every hostname."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
calls = []
def request(cfg, method, suffix, payload=None, *, timeout=8.0):
calls.append((cfg, method, suffix, payload, timeout))
return {"authorization_revision": 42}
monkeypatch.setattr(remote_access, "_device_json_request", request)
assert remote_access.sync_authorization_revision_once(config) == {
"ok": True,
"authorization_revision": 42,
}
assert calls == [(config, "GET", "authorization-revision", None, 8.0)]
assert remote_access.current_authorization_revision(config) == 42
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: {"authorization_revision": 41},
)
assert remote_access.sync_authorization_revision_once(config) == {
"ok": False,
"error": "authorization_revision_regressed",
}
assert remote_access.current_authorization_revision(config) == 42
def test_authorization_revision_writes_are_monotonic_across_processes(
monkeypatch,
tmp_path,
):
"""A delayed synchronization write cannot replace a newer acknowledgement."""
import multiprocessing as mp
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
_paired_config(tmp_path, revision=41)
ctx = mp.get_context("spawn")
sync_entered = ctx.Event()
release_sync = ctx.Event()
acknowledgement_attempted = ctx.Event()
acknowledgement_done = ctx.Event()
sync_result = ctx.Queue()
acknowledgement_result = ctx.Queue()
sync_writer = ctx.Process(
target=_delayed_authorization_revision_sync_writer,
args=(str(tmp_path), sync_entered, release_sync, sync_result),
)
acknowledgement_writer = ctx.Process(
target=_authorization_revision_acknowledgement_writer,
args=(
str(tmp_path),
acknowledgement_attempted,
acknowledgement_done,
acknowledgement_result,
),
)
sync_writer.start()
assert sync_entered.wait(timeout=15), "sync writer never entered its transaction"
acknowledgement_writer.start()
assert acknowledgement_attempted.wait(timeout=15), "acknowledgement writer never attempted"
assert not acknowledgement_done.wait(timeout=1), (
"acknowledgement writer bypassed the synchronization transaction"
)
release_sync.set()
sync_writer.join(timeout=15)
acknowledgement_writer.join(timeout=15)
assert sync_writer.exitcode == 0, f"sync writer failed: {sync_writer.exitcode}"
assert acknowledgement_writer.exitcode == 0, (
f"acknowledgement writer failed: {acknowledgement_writer.exitcode}"
)
assert sync_result.get(timeout=5) == ("ok", 42)
assert acknowledgement_result.get(timeout=5) == ("ok", 43)
persisted = remote_access.runtime.read_json(
remote_access._authorization_revision_state_path()
)
assert persisted["authorization_revision"] == 43
def test_authorization_revision_cache_observes_another_process_watermark(
monkeypatch,
tmp_path,
):
"""A controller cache must observe a mutation persisted by the UI server."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path, revision=41)
claims = _organization_claims(config, revision=41)
source_updated_at = time.time()
assert remote_access.session_authorization_revision_state(
config,
claims,
now=source_updated_at,
) == "current"
remote_access.runtime.write_json(
remote_access._authorization_revision_state_path(), # noqa: SLF001
{
"schema_version": 1,
"instance_id": "inst_123",
"authorization_revision": 42,
"source_updated_at": source_updated_at,
},
)
assert remote_access.session_authorization_revision_state(
config,
claims,
now=source_updated_at,
) == "mismatch"
@pytest.mark.parametrize(
("changed_field", "replacement"),
(
("backend_url", "https://other-backend.test"),
("instance_id", "inst_new"),
("instance_secret", "other-secret"),
),
)
def test_authorization_revision_acknowledgement_rejects_a_stale_pairing(
monkeypatch,
tmp_path,
changed_field,
replacement,
):
"""A mutation from instance A cannot replace the watermark after pairing B."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path, revision=41)
current = V2Config.load()
setattr(current.remote_access.vibe_cloud, changed_field, replacement)
current.save()
with pytest.raises(
remote_access.AuthorizationRevisionPairingChangedError,
match="authorization_revision_pairing_changed",
):
remote_access.acknowledge_authorization_revision(config, 42)
persisted = remote_access.runtime.read_json(
remote_access._authorization_revision_state_path()
)
assert persisted["instance_id"] == "inst_123"
assert persisted["authorization_revision"] == 41
def test_authorization_revision_acknowledgement_rechecks_pairing_at_locked_write(
monkeypatch,
tmp_path,
):
"""A pairing switch at the watermark lock cannot let the old write through."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path, revision=41)
original_lock = remote_access._authorization_revision_file_lock # noqa: SLF001
switched = False
def switch_before_locked_read(path):
nonlocal switched
if not switched:
switched = True
current = V2Config.load()
current.remote_access.vibe_cloud.instance_id = "inst_new"
current.save()
return original_lock(path)
monkeypatch.setattr(
remote_access,
"_authorization_revision_file_lock",
switch_before_locked_read,
)
with pytest.raises(
remote_access.AuthorizationRevisionPairingChangedError,
match="authorization_revision_pairing_changed",
):
remote_access.acknowledge_authorization_revision(config, 42)
persisted = remote_access.runtime.read_json(
remote_access._authorization_revision_state_path()
)
assert persisted["instance_id"] == "inst_123"
assert persisted["authorization_revision"] == 41
@pytest.mark.parametrize("persistence_failure", ("write_error", "lock_timeout"))
def test_authorization_revision_sync_rejects_an_unpersisted_watermark(
monkeypatch,
tmp_path,
persistence_failure,
):
config = _paired_config(tmp_path)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *_args, **_kwargs: {"authorization_revision": 42},
)
if persistence_failure == "write_error":
monkeypatch.setattr(
remote_access.runtime,
"write_json",
lambda *_args, **_kwargs: (_ for _ in ()).throw(OSError("read-only state")),
)
else:
def timed_out_lock(_path):
raise MigrationLockTimeout("watermark lock timed out")
monkeypatch.setattr(
remote_access,
"_authorization_revision_file_lock",
timed_out_lock,
)
assert remote_access.sync_authorization_revision_once(config) == {
"ok": False,
"error": "authorization_revision_sync_failed",
}
assert remote_access.current_authorization_revision(config) == 41
@pytest.mark.parametrize(
"malformed",
(
b"\xff",
b"{not-json",
b'{"schema_version":1,"instance_id":"inst_123","authorization_revision":"bad","source_updated_at":0}',
),
)
def test_authorization_revision_read_treats_malformed_content_as_absent(
monkeypatch,
tmp_path,
malformed,
):
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
remote_access._authorization_revision_state_path().write_bytes(malformed) # noqa: SLF001
remote_access._clear_authorization_revision_cache() # noqa: SLF001
assert remote_access.current_authorization_revision(config) is None
@pytest.mark.parametrize(
"malformed",
(
b"\xff",
b"{not-json",
b'{"schema_version":1,"instance_id":"inst_123","authorization_revision":"bad","source_updated_at":0}',
),
)
def test_authorization_acknowledgement_keeps_memory_revision_when_rewrite_fails(
monkeypatch,
tmp_path,
malformed,
):
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
state_path = remote_access._authorization_revision_state_path() # noqa: SLF001
state_path.write_bytes(malformed)
remote_access._clear_authorization_revision_cache() # noqa: SLF001
published = []
monkeypatch.setattr(
remote_access.runtime,
"write_json",
lambda *_args, **_kwargs: (_ for _ in ()).throw(OSError("read-only state")),
)
monkeypatch.setattr(
broker,
"publish",
lambda event_type, data: published.append((event_type, data)),
)
assert remote_access.acknowledge_authorization_revision(config, 42) == 42
assert remote_access.current_authorization_revision(config) == 42
assert published == [
("authorization.changed", {"instance_authorization_revision": 42})
]
def test_authorization_revision_sync_keeps_strict_write_after_malformed_read(
monkeypatch,
tmp_path,
):
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
remote_access._authorization_revision_state_path().write_bytes(b"\xff") # noqa: SLF001
remote_access._clear_authorization_revision_cache() # noqa: SLF001
monkeypatch.setattr(
remote_access.runtime,
"write_json",
lambda *_args, **_kwargs: (_ for _ in ()).throw(OSError("read-only state")),
)
with pytest.raises(OSError, match="read-only state"):
remote_access._replace_authorization_revision(config, 42) # noqa: SLF001
def test_paired_session_requires_signed_current_revision(monkeypatch, tmp_path):
"""I1057-AC4: unsigned, missing, and stale authorization versions fail closed."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
missing = _organization_claims(config)
missing.pop("vibe_instance_authorization_revision")
with pytest.raises(
remote_access.OAuthCodeExchangeError,
match="invalid_authorization_revision",
):
remote_access.make_session_cookie(
config,
"[email protected]",
"user-1",
session_claims=missing,
)
with pytest.raises(
remote_access.OAuthCodeExchangeError,
match="stale_authorization_revision",
):
_organization_cookie(config, revision=40)
@pytest.mark.parametrize(
"hosted_change",
[
"role_downgrade",
"group_membership_removal",
"group_archival",
"member_removal",
"access_binding_removal",
],
)
def test_revision_advance_revokes_active_editor_http_session(
monkeypatch,
tmp_path,
hosted_change,
):
"""I1057-AC1/AC2: narrowing invalidates a remote session with chat enabled."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
payload = remote_access.parse_session_cookie(config, cookie)
assert payload is not None
assert context_from_session_payload(payload).can_chat is True
client = app.test_client()
client.set_cookie(remote_access.SESSION_COOKIE_NAME, cookie, domain="alex.avibe.bot")
headers = csrf_headers(client, "https://alex.avibe.bot")
before = client.post(
"/api/sessions",
base_url="https://alex.avibe.bot",
headers=headers,
json={},
)
assert before.status_code == 400
assert hosted_change
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: (_ for _ in ()).throw(
remote_access.BackendRequestError(403, {"error": "access_denied"})
),
)
remote_access._replace_authorization_revision(config, 42)
after = client.post(
"/api/sessions",
base_url="https://alex.avibe.bot",
headers=headers,
json={},
)
assert after.status_code == 403
assert after.get_json()["error"] == "remote_access_revoked"
def test_default_and_custom_hostname_sessions_share_revision(monkeypatch, tmp_path):
"""I1057-AC3: host-scoped cookies cannot retain divergent authorization."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
remote_access._replace_active_hostnames(config, ["max.fileguard.io"])
default_client = app.test_client()
custom_client = app.test_client()
default_client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(config, subject="default-user"),
domain="alex.avibe.bot",
)
custom_client.set_cookie(
remote_access.SESSION_COOKIE_NAME,
_organization_cookie(config, subject="custom-user"),
domain="max.fileguard.io",
)
assert default_client.get(
"/api/session",
base_url="https://alex.avibe.bot",
).get_json()["authenticated"] is True
assert custom_client.get(
"/api/session",
base_url="https://max.fileguard.io",
).get_json()["authenticated"] is True
refreshed_subjects = []
def refresh(_config, method, suffix, payload=None, *, timeout=8.0):
assert (method, suffix, timeout) == ("POST", "authorization-context", 8.0)
refreshed_subjects.append(payload["sub"])
return {
"sub": payload["sub"],
"email": payload["email"],
"instance_kind": "organization",
**_organization_claims(config, revision=42),
}
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
remote_access._replace_authorization_revision(config, 42)
default_session = default_client.get(
"/api/session",
base_url="https://alex.avibe.bot",
).get_json()
custom_session = custom_client.get(
"/api/session",
base_url="https://max.fileguard.io",
).get_json()
assert default_session["authenticated"] is True
assert default_session["authorization_state"] == "current"
assert custom_session["authenticated"] is True
assert custom_session["authorization_state"] == "current"
assert refreshed_subjects == ["default-user", "custom-user"]
def test_revision_snapshot_expiry_and_renewal_fail_closed(monkeypatch, tmp_path):
"""I1057-AC4: offline snapshots and renewal races cannot extend old claims."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
payload = remote_access.parse_session_cookie(config, cookie)
assert payload is not None
remote_access._replace_authorization_revision(config, 42)
with pytest.raises(
remote_access.OAuthCodeExchangeError,
match="stale_authorization_revision",
):
remote_access.make_session_cookie(
config,
"[email protected]",
"user-1",
session_claims=payload,
)
remote_access._replace_authorization_revision(config, 42)
snapshot = remote_access._load_authorization_revision_snapshot(config)
assert snapshot is not None
_, updated_at = snapshot
assert remote_access.session_authorization_is_current(
config,
{"vibe_instance_authorization_revision": 42},
now=updated_at + remote_access.AUTHORIZATION_REVISION_MAX_AGE_SECONDS + 1,
) is False
def test_workbench_and_show_sse_end_after_revision_change(monkeypatch, tmp_path):
"""I1057-AC4/AC6: active and resumed SSE streams converge on the watermark."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
payload = remote_access.parse_session_cookie(config, cookie)
identity = remote_access.parse_session_identity(config, cookie)
assert payload is not None
assert identity is not None
context = context_from_session_payload(payload)
class EmptyShowEventStore:
def list(self, *args, **kwargs):
return {"events": [], "next_after_id": None}
def close(self):
return None
monkeypatch.setattr(ui_server, "_show_session_event_store", EmptyShowEventStore)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: (_ for _ in ()).throw(
remote_access.BackendRequestError(403, {"error": "access_denied"})
),
)
async def exercise() -> None:
with app.test_request_context(
"/api/events",
base_url="https://alex.avibe.bot",
headers={"Cookie": f"{remote_access.SESSION_COOKIE_NAME}={cookie}"},
):
g.authorization_context = context
g.remote_session_identity = identity
g.remote_session_payload = payload
response = await ui_server.workbench_events()
iterator = response.body_iterator.__aiter__()
try:
for _ in range(3):
await iterator.__anext__()
remote_access._replace_authorization_revision(config, 42)
terminal = await asyncio.wait_for(iterator.__anext__(), timeout=1)
assert '"state":"revoked"' in terminal
with pytest.raises(StopAsyncIteration):
await asyncio.wait_for(iterator.__anext__(), timeout=1)
finally:
await iterator.aclose()
remote_access._replace_authorization_revision(config, 42)
show_response = await ui_server._show_events_stream(
"ses123",
after_id="show_evt_resume",
authorization_context=context,
remote_session_identity=identity,
remote_session_payload=payload,
remote_session_cookie=cookie,
remote_request_host="alex.avibe.bot",
remote_config=config,
)
show_iterator = show_response.body_iterator.__aiter__()
try:
terminal = await asyncio.wait_for(show_iterator.__anext__(), timeout=1)
assert '"state":"revoked"' in terminal
with pytest.raises(StopAsyncIteration):
await asyncio.wait_for(show_iterator.__anext__(), timeout=1)
finally:
await show_iterator.aclose()
asyncio.run(exercise())
def test_websocket_reconnect_and_active_waiter_recheck_revision(monkeypatch, tmp_path):
"""I1057-AC4/AC6: active sockets close and stale reconnects are rejected."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
class Socket:
cookies = {remote_access.SESSION_COOKIE_NAME: cookie}
websocket = Socket()
monkeypatch.setattr(ui_server, "_websocket_is_local_request", lambda *args: False)
monkeypatch.setattr(ui_server, "_remote_access_host_allowed", lambda *args: True)
monkeypatch.setattr(ui_server, "_websocket_normalized_host", lambda *args: "alex.avibe.bot")
monkeypatch.setattr(ui_server, "_AUTHORIZATION_REVISION_RECHECK_SECONDS", 0.001)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda *args, **kwargs: (_ for _ in ()).throw(
remote_access.BackendRequestError(403, {"error": "access_denied"})
),
)
payload = ui_server._remote_access_websocket_session_payload(websocket, config)
identity = remote_access.parse_session_identity(config, cookie)
assert payload is not None
assert identity is not None
async def exercise() -> None:
waiter = asyncio.create_task(
ui_server._wait_for_remote_session_authorization_loss(
config,
identity,
payload,
session_cookie=cookie,
request_host="alex.avibe.bot",
)
)
await asyncio.sleep(0)
remote_access._replace_authorization_revision(config, 42)
assert await asyncio.wait_for(waiter, timeout=1) == "revoked"
asyncio.run(exercise())
assert ui_server._remote_access_websocket_session_payload(websocket, config) is None
def test_remote_websocket_authorization_rejects_disabled_cloud(monkeypatch, tmp_path):
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
config.remote_access.vibe_cloud.enabled = False
class Socket:
cookies = {remote_access.SESSION_COOKIE_NAME: cookie}
monkeypatch.setattr(ui_server, "_websocket_is_local_request", lambda *args: False)
monkeypatch.setattr(ui_server, "_remote_access_host_allowed", lambda *args: True)
monkeypatch.setattr(ui_server, "_websocket_normalized_host", lambda *args: "alex.avibe.bot")
monkeypatch.setattr(
remote_access,
"resolve_current_authorization_async",
lambda *args, **kwargs: (_ for _ in ()).throw(
AssertionError("disabled remote socket reached the authorization resolver")
),
)
identity, resolution = asyncio.run(
ui_server._remote_access_websocket_authorization(Socket(), config)
)
assert identity is None
assert resolution.state == "invalid_identity"
assert resolution.reason == "remote_access_disabled"
def test_live_remote_authorization_rechecks_the_remote_entry_gate(
monkeypatch,
tmp_path,
):
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
monkeypatch.setattr(
remote_access,
"resolve_current_authorization_async",
lambda *args, **kwargs: (_ for _ in ()).throw(
AssertionError("invalid live session reached the authorization resolver")
),
)
config.remote_access.vibe_cloud.enabled = False
config.save()
disabled = asyncio.run(
ui_server._live_remote_authorization_resolution(
config,
identity,
session_cookie=cookie,
request_host="alex.avibe.bot",
)
)
assert disabled.state == "invalid_identity"
assert disabled.reason == "remote_access_disabled"
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.session_secret = "rotated-session-secret"
config.save()
rotated = asyncio.run(
ui_server._live_remote_authorization_resolution(
config,
identity,
session_cookie=cookie,
request_host="alex.avibe.bot",
)
)
assert rotated.state == "invalid_identity"
assert rotated.reason == "identity_invalid"
config.remote_access.vibe_cloud.session_secret = "session-secret"
config.remote_access.vibe_cloud.public_url = "https://other.avibe.bot"
config.save()
moved = asyncio.run(
ui_server._live_remote_authorization_resolution(
config,
identity,
session_cookie=cookie,
request_host="alex.avibe.bot",
)
)
assert moved.state == "invalid_identity"
assert moved.reason == "remote_access_host_mismatch"
def test_terminal_websocket_reports_stale_remote_session_after_accept(
monkeypatch,
tmp_path,
):
"""I1057-AC4: no terminal service starts before a state-specific close."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
class RecordingWebSocket:
client = None
headers = {"host": "alex.avibe.bot"}
query_params = {}
def __init__(self):
self.calls = []
async def accept(self):
self.calls.append(("accept", None))
async def close(self, code=1000):
self.calls.append(("close", code))
websocket = RecordingWebSocket()
monkeypatch.setattr(ui_server, "_terminal_enabled", lambda: True)
monkeypatch.setattr(ui_server, "TERMINAL_SUPPORTED", True)
monkeypatch.setattr(ui_server, "_terminal_origin_allowed", lambda socket: True)
monkeypatch.setattr(ui_server, "_load_remote_access_config", lambda: config)
monkeypatch.setattr(ui_server, "_websocket_is_local_request", lambda *a: False)
monkeypatch.setattr(
ui_server,
"_remote_access_websocket_authorization",
lambda *args, **kwargs: asyncio.sleep(
0,
result=(None, remote_access.AuthorizationResolution("unavailable")),
),
)
monkeypatch.setattr(
ui_server,
"get_terminal_service",
lambda: (_ for _ in ()).throw(AssertionError("stale socket reached terminal")),
)
asyncio.run(ui_server.terminal_websocket(websocket, "test"))
assert websocket.calls == [
("accept", None),
("close", ui_server._AUTHORIZATION_UNAVAILABLE_WEBSOCKET_CLOSE_CODE),
]
def test_trusted_local_access_ignores_hosted_revision_state(monkeypatch, tmp_path):
"""I1057-AC5: trusted local access stays owner-equivalent while sync is offline."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
config = _paired_config(tmp_path)
state_path = remote_access._authorization_revision_state_path()
state_path.unlink()
remote_access._clear_authorization_revision_cache()
assert remote_access.current_authorization_revision(config) is None
response = app.test_client().get(
"/api/config",
base_url="http://127.0.0.1:5123",
)
assert response.status_code == 200
assert response.get_json()["runtime"]["default_cwd"] == "."
def test_denied_response_during_reconciliation_does_not_persist_revoked(
monkeypatch,
tmp_path,
):
"""Regression PR #1606 r1: a 403 racing a same-generation reconciliation
must not persist a revoked row the completed binding then trips over."""
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
# A reconciliation begins BEFORE the refresh starts: same generation is
# captured, and completing a transition does not increment it.
started = remote_access_authorization_service.begin_instance_binding_transition(
instance_id="inst_123",
instance_kind="personal",
)
assert (
started["state"]
== remote_access_authorization_service.INSTANCE_BINDING_STATE_RECONCILING
)
def deny(*args, **kwargs):
raise remote_access.BackendRequestError(403, {"error": "access_denied"})
monkeypatch.setattr(remote_access, "_device_json_request", deny)
result = remote_access._fetch_authorization_context(
config,
identity,
record,
now=now,
observed_revision=41,
)
assert result.state == "unavailable"
assert result.reason == "instance_binding_changed"
stored = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
if stored is not None:
assert stored.get("authorization_state") != "revoked"
def test_known_kind_without_binding_row_bootstraps_a_durable_transition(tmp_path):
"""Regression PR #1606 r1: upgrade path — config carries a kind but the
state_meta binding row is absent; the gate must earn a validated row
through one real transition instead of trusting the config value."""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
# Simulate an upgrade: config has a known kind, the new state_meta row
# has not been written yet.
from storage.db import get_cached_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage.models import state_meta
from sqlalchemy import delete as sa_delete
ensure_sqlite_state()
engine = get_cached_sqlite_engine()
with engine.begin() as conn:
conn.execute(
sa_delete(state_meta).where(
state_meta.c.key == remote_access_authorization_service.INSTANCE_BINDING_STATE_META_KEY
)
)
assert (
remote_access_authorization_service.load_instance_binding_state(ensure=False)
is None
)
# The storage gate alone fails closed for a known kind with no row.
assert remote_access_authorization_service.binding_is_ready_for_pairing(
instance_id="inst_123",
instance_kind="personal",
ensure=False,
) is False
# The consumer gate bootstraps one durable transition, then admits.
assert remote_access.binding_is_ready(config) is True
state = remote_access_authorization_service.load_instance_binding_state(ensure=False)
assert state is not None
assert state["state"] == remote_access_authorization_service.INSTANCE_BINDING_STATE_READY
assert state["instance_id"] == "inst_123"
assert state["instance_kind"] == "personal"
assert state["generation"] >= 1
def test_personal_to_organization_reclassification_rejects_stale_personal_row(
monkeypatch,
tmp_path,
):
"""Regression PR #1606 r2: the kind-mismatch refresh must run before the
Organization branch too — a stale personal-tagged row must not be served
as current under the reclassified Organization policy."""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="personal",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
stored = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert stored is not None
assert stored["claims"]["vibe_instance_kind"] == "personal"
# Controller heartbeat reclassifies Personal -> Organization.
assert remote_access._persist_instance_kind("inst_123", "organization", reconcile=True)
reclassified = V2Config.load()
assert reclassified.remote_access.vibe_cloud.instance_kind == "organization"
# The old personal-tagged row must not answer under the Organization policy.
blocked = remote_access.resolve_current_authorization(
reclassified,
identity,
allow_refresh=False,
)
assert blocked.current is False
calls = []
def refresh(_config, _method, _suffix, payload, **kwargs):
calls.append(payload)
return _authorization_context_response(
config,
payload,
revision=41,
instance_kind="organization",
)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
result = remote_access.resolve_current_authorization(reclassified, identity)
assert result.current is True
assert result.refreshed is True
assert result.policy == "organization"
assert len(calls) == 1
revalidated = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert revalidated is not None
assert revalidated["claims"]["vibe_instance_kind"] == "organization"
def test_revoked_write_refused_when_transition_completes_between_check_and_write(
monkeypatch,
tmp_path,
):
"""Regression PR #1606 r3: the compare and the authorization-row write
are one atomic CAS under the binding lock. Completing a transition
between a TOCTOU-style check and the write must refuse the revoked upsert.
"""
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
started = remote_access_authorization_service.begin_instance_binding_transition(
instance_id="inst_123",
instance_kind="personal",
)
captured = remote_access_authorization_service.current_instance_binding_generation()
def deny(*args, **kwargs):
# Completes AFTER _fetch captured the reconciling generation and
# BEFORE the revoked upsert — the atomic CAS must refuse the write.
remote_access_authorization_service.complete_instance_binding_transition(
instance_id="inst_123",
instance_kind="personal",
generation=started["generation"],
)
raise remote_access.BackendRequestError(403, {"error": "access_denied"})
monkeypatch.setattr(remote_access, "_device_json_request", deny)
result = remote_access._fetch_authorization_context(
config,
identity,
record,
now=now,
observed_revision=41,
)
stored = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert result.reason == "instance_binding_changed" or (
stored is not None and stored.get("authorization_state") != "revoked"
)
if stored is not None:
assert stored.get("authorization_state") != "revoked"
# The captured generation is no longer current.
assert remote_access_authorization_service.current_instance_binding_generation() >= captured
def test_kindless_current_row_revalidates_after_known_kind_bootstrap(
monkeypatch,
tmp_path,
):
"""Regression PR #1606 r4: a released current row with no vibe_instance_kind
must refresh on the first request after a known-kind Personal pairing
bootstraps, instead of returning a kindless payload.
"""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
claims = dict(record["claims"])
claims.pop("vibe_instance_kind", None)
remote_access_authorization_service.upsert_scoped(
reference=record["id"],
instance_id="inst_123",
subject="user-1",
email=record["email"],
scope_kind=record["scope_kind"],
scope_ref=record["scope_ref"],
authorization_state="current",
claims=claims,
last_checked_at=now,
updated_at=now,
)
calls = []
def refresh(_config, _method, _suffix, payload, **kwargs):
calls.append(payload)
return _authorization_context_response(
config,
payload,
revision=41,
instance_kind="personal",
)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
result = remote_access.resolve_current_authorization(config, identity)
assert result.current is True
assert result.refreshed is True
assert result.policy == "personal"
assert len(calls) == 1
assert result.payload is not None
assert result.payload.get("vibe_instance_kind") == "personal"
def test_binding_decoder_rejects_explicit_non_v1_schema_versions(tmp_path):
"""Regression PR #1606 r5: only a genuinely absent schema_version defaults
to v1; explicit 0 or 2 must fail closed.
"""
config = _paired_config(tmp_path)
from storage.db import get_cached_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage.models import state_meta
from sqlalchemy.dialects.sqlite import insert as sqlite_insert
ensure_sqlite_state()
engine = get_cached_sqlite_engine()
for version in (0, 2):
payload = json.dumps(
{
"schema_version": version,
"state": "ready",
"instance_id": "inst_123",
"instance_kind": "personal",
"generation": 1,
"updated_at": "1",
},
sort_keys=True,
separators=(",", ":"),
)
with engine.begin() as conn:
statement = sqlite_insert(state_meta).values(
key=remote_access_authorization_service.INSTANCE_BINDING_STATE_META_KEY,
value_json=payload,
updated_at="1",
)
conn.execute(
statement.on_conflict_do_update(
index_elements=[state_meta.c.key],
set_={"value_json": payload, "updated_at": "1"},
)
)
decoded = remote_access_authorization_service.load_instance_binding_state(
ensure=False
)
assert decoded is None or decoded.get("state") == remote_access_authorization_service.INSTANCE_BINDING_STATE_INVALID
assert remote_access_authorization_service.binding_is_ready_for_pairing(
instance_id="inst_123",
instance_kind="personal",
ensure=False,
) is False
def test_refresh_cache_does_not_serve_personal_payload_after_org_reclassification(
monkeypatch,
tmp_path,
):
"""Class 1: in-memory refresh cache is bound to generation.
After a successful Personal refresh, a Personal→Org reclassification
within the 5s window must not return the cached Personal payload.
"""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="personal",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
calls = []
def refresh(_config, _method, _suffix, payload, **kwargs):
calls.append(payload)
kind = V2Config.load().remote_access.vibe_cloud.instance_kind or "personal"
return _authorization_context_response(
config,
payload,
revision=41,
instance_kind=kind if kind in {"personal", "organization"} else "personal",
)
monkeypatch.setattr(remote_access, "_device_json_request", refresh)
first = remote_access.resolve_current_authorization(config, identity)
assert first.current is True
assert first.policy == "personal"
first_calls = len(calls)
assert remote_access._persist_instance_kind("inst_123", "organization", reconcile=True)
reclassified = V2Config.load()
second = remote_access.resolve_current_authorization(reclassified, identity)
assert second.policy != "personal" or second.current is False or second.refreshed is True
if second.current:
assert second.policy == "organization"
assert len(calls) > first_calls
def test_in_flight_auth_during_same_instance_kind_transition_is_binding_changed(
monkeypatch,
tmp_path,
):
"""Class 3: same-instance generation advance IS instance_binding_changed."""
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
captured = remote_access_authorization_service.current_instance_binding_generation()
def flip_then_respond(_config, _method, _suffix, payload, **kwargs):
remote_access._persist_instance_kind("inst_123", "personal", reconcile=True)
return _authorization_context_response(
config, payload, revision=41, instance_kind="organization"
)
monkeypatch.setattr(remote_access, "_device_json_request", flip_then_respond)
result = remote_access._fetch_authorization_context(
config, identity, record, now=now, observed_revision=41
)
assert result.reason == "instance_binding_changed"
assert result.reason != "instance_kind_persistence_failed"
# A subsequent request for the new binding is not 5s-denied by the old failure.
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda _c, _m, _s, payload, **k: _authorization_context_response(
config, payload, revision=41, instance_kind="personal"
),
)
later = remote_access.resolve_current_authorization(V2Config.load(), identity)
assert later.reason != "authorization_refresh_backoff"
assert remote_access_authorization_service.current_instance_binding_generation() > captured
def test_successful_context_store_refused_when_generation_advances_after_persist_kind(
monkeypatch,
tmp_path,
):
"""Class close: every authorization-row write carries the REQUEST generation.
persist-kind CAS succeeds at request gen; a peer then completes a
transition (gen advances) before store. Recapturing live generation
would let the stale 200 resurrect a current row. Store must refuse.
"""
config = _paired_config(tmp_path)
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="organization",
)
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
original_state = record.get("authorization_state")
captured = remote_access_authorization_service.current_instance_binding_generation()
original_store = remote_access._store_scoped_authorization
advanced = {"done": False}
def store_after_peer_transition(*args, **kwargs):
if not advanced["done"]:
advanced["done"] = True
remote_access._persist_instance_kind("inst_123", "personal", reconcile=True)
return original_store(*args, **kwargs)
monkeypatch.setattr(remote_access, "_store_scoped_authorization", store_after_peer_transition)
monkeypatch.setattr(
remote_access,
"_device_json_request",
lambda _c, _m, _s, payload, **k: _authorization_context_response(
config, payload, revision=41, instance_kind="organization"
),
)
result = remote_access._fetch_authorization_context(
config, identity, record, now=now, observed_revision=41
)
stored = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert result.reason == "instance_binding_changed"
assert result.current is False
if stored is not None:
# Must not resurrect a current Organization row under the new Personal binding.
if stored.get("authorization_state") == "current":
claims = stored.get("claims") or {}
assert claims.get("vibe_instance_kind") != "organization" or (
stored.get("authorization_state") == original_state
)
assert remote_access_authorization_service.current_instance_binding_generation() > captured
def test_interactive_gate_is_read_once_and_failed_gate_never_collapses_to_legacy(
monkeypatch,
tmp_path,
):
"""Class 2 (interactive path): one binding-gate snapshot per evaluation.
A reconciling that begins between record admission and the former second
gate call must not collapse instance_kind to None and return the old
Personal payload through the legacy branch.
"""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
remote_access._transition_instance_binding(
instance_id="inst_123",
instance_kind="personal",
)
cookie = remote_access.make_session_cookie(
config,
"[email protected]",
"user-1",
session_claims={
"vibe_instance_id": config.remote_access.vibe_cloud.instance_id,
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"vibe_instance_kind": "personal",
"vibe_instance_authorization_revision": 41,
},
)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
calls = {"n": 0}
real_gate = remote_access.binding_is_ready
def counting_gate(*args, **kwargs):
calls["n"] += 1
# Simulate a peer entering reconciling right after the first read:
# any SECOND read within one evaluation would observe False.
if calls["n"] == 1:
return real_gate(*args, **kwargs)
return False
monkeypatch.setattr(remote_access, "binding_is_ready", counting_gate)
result = remote_access.resolve_current_authorization(config, identity)
# One evaluation = one gate read; the flip value is never consumed.
assert calls["n"] == 1
# With the single ready snapshot the personal branch ran (not legacy).
assert result.current is True
assert result.policy == "personal"
# Failed gate at snapshot time: fail closed (refresh/unavailable), never
# legacy-current with the old Personal payload.
calls["n"] = 0
monkeypatch.setattr(remote_access, "binding_is_ready", lambda *a, **k: False)
blocked = remote_access.resolve_current_authorization(
config, identity, allow_refresh=False
)
assert blocked.current is False
assert blocked.state in {"unavailable", "invalid_identity"}
def test_unsupported_stored_kind_fails_closed_on_the_interactive_path(
monkeypatch,
tmp_path,
):
"""A persisted scoped row with kind="enterprise" under a legacy no-kind
pairing must fail closed instead of falling through legacy-current."""
config = _paired_config(tmp_path)
config.remote_access.vibe_cloud.instance_kind = ""
config.save()
cookie = _organization_cookie(config)
identity = remote_access.parse_session_identity(config, cookie)
assert identity is not None
now = int(time.time())
record = remote_access_authorization_service.load_reference_record(
reference=identity["authorization_ref"],
instance_id="inst_123",
subject="user-1",
now=now,
)
assert record is not None
claims = dict(record.get("claims") or {})
claims["vibe_instance_kind"] = "enterprise"
remote_access_authorization_service.upsert_scoped(
reference=str(record["id"]),
instance_id="inst_123",
subject="user-1",
email="[email protected]",
scope_kind=str(record.get("scope_kind") or "instance"),
scope_ref=str(record.get("scope_ref") or "inst_123"),
authorization_state="current",
claims=claims,
last_checked_at=now,
updated_at=now,
)
blocked = remote_access.resolve_current_authorization(
config, identity, allow_refresh=False
)
assert blocked.current is False
assert blocked.state == "unavailable"