Skip to content

armgit / avibe

Public Imported from GitHub
0

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.

18.6 KB
Raw Blame
from __future__ import annotations

from dataclasses import dataclass
from typing import Any

from config import paths
from config.v2_config import AgentsConfig, PlatformsConfig, RemoteAccessConfig, RuntimeConfig, SlackConfig, UiConfig, V2Config
from core.services.skills import skill_resource_id
from storage import resource_access_service
from storage.db import get_cached_sqlite_engine
from storage.migrations import run_migrations
from storage.models import agents, vault_secrets
from vibe import remote_access


@dataclass
class _Response:
    payload: dict[str, Any]
    status_code: int = 200

    def json(self) -> dict[str, Any]:
        return self.payload


def _config() -> V2Config:
    config = V2Config(
        mode="self_host",
        version="v2",
        platform="slack",
        platforms=PlatformsConfig(enabled=["slack"], primary="slack"),
        slack=SlackConfig(bot_token=""),
        runtime=RuntimeConfig(default_cwd="."),
        agents=AgentsConfig(),
        ui=UiConfig(),
        remote_access=RemoteAccessConfig(),
    )
    cloud = config.remote_access.vibe_cloud
    cloud.enabled = True
    cloud.backend_url = "https://backend.test"
    cloud.instance_id = "inst-1"
    cloud.instance_secret = "paired-device-secret"
    return config


def _seed_policy() -> None:
    paths.ensure_data_dirs()
    run_migrations()
    engine = get_cached_sqlite_engine()
    with engine.begin() as connection:
        resource_access_service.ensure_resource_policy(
            connection,
            resource_kind="agent",
            resource_id="agent-1",
            organization_id="org-1",
            owner_user_id="owner-1",
            access_level="private",
            policy_revision=1,
            last_applied_control_plane_revision=1,
        )


def _descriptor() -> dict[str, Any]:
    return {
        "resource_kind": "agent",
        "resource_id": "agent-1",
        "display_name": "Research agent",
        "owner_user_id": "owner-1",
        "metadata_revision": 1,
        "applied_acl_revision": 1,
        "access_level": "private",
        "group_ids": [],
    }


def _seed_named_resources() -> dict[str, str]:
    paths.ensure_data_dirs()
    run_migrations()
    engine = get_cached_sqlite_engine()
    created_at = "2026-07-27T20:00:00.000001+00:00"
    resource_ids = {
        "agent": "agent-safe-name",
        "vault_secret": "vlt_safe_name",
        "skill": skill_resource_id(
            "codex",
            scope="global",
            project_dir=None,
            name="release-notes",
        ),
    }
    with engine.begin() as connection:
        connection.execute(
            agents.insert().values(
                id=resource_ids["agent"],
                name="Research Agent",
                normalized_name="research-agent",
                description="private-agent-description",
                backend="codex",
                model="private-agent-model",
                reasoning_effort="high",
                system_prompt="private-agent-prompt",
                enabled=1,
                source="user",
                source_ref="/private/agent/source",
                metadata_json='{"execution_output":"private-agent-output"}',
                created_at=created_at,
                updated_at=created_at,
            )
        )
        connection.execute(
            vault_secrets.insert().values(
                id=resource_ids["vault_secret"],
                name="PRODUCTION_API_KEY",
                tags='["private-vault-tag"]',
                kind="static",
                protection="standard",
                source="manual",
                ciphertext="private-vault-ciphertext",
                nonce="private-vault-nonce",
                wrap_meta="private-vault-wrap",
                public_meta='{"description":"private-vault-description"}',
                policy='{"allowed_hosts":["private.example"]}',
                use_count=0,
                created_at=created_at,
                updated_at=created_at,
            )
        )
        for resource_kind, resource_id in resource_ids.items():
            resource_access_service.ensure_resource_policy(
                connection,
                resource_kind=resource_kind,
                resource_id=resource_id,
                organization_id="org-1",
                owner_user_id="owner-1",
                access_level="private",
                policy_revision=3,
                last_applied_control_plane_revision=2,
            )
    return resource_ids


def test_local_descriptors_resolve_all_resource_names_without_content() -> None:
    resource_ids = _seed_named_resources()

    descriptors = remote_access._local_policy_resource_descriptors("org-1")
    by_kind = {descriptor["resource_kind"]: descriptor for descriptor in descriptors}

    assert set(by_kind) == {"agent", "vault_secret", "skill"}
    assert by_kind["agent"]["display_name"] == "Research Agent"
    assert by_kind["vault_secret"]["display_name"] == "PRODUCTION_API_KEY"
    assert by_kind["skill"]["display_name"] == "release-notes"
    allowed_descriptor_fields = {
        "resource_id",
        "resource_kind",
        "display_name",
        "owner_user_id",
        "metadata_revision",
        "applied_acl_revision",
        "access_level",
        "group_ids",
        "sync_status",
    }
    for resource_kind, resource_id in resource_ids.items():
        assert set(by_kind[resource_kind]) == allowed_descriptor_fields
        assert by_kind[resource_kind]["resource_id"] == resource_id
        assert by_kind[resource_kind]["metadata_revision"] >= 3

    serialized = repr(descriptors)
    for forbidden in (
        "private-agent-description",
        "private-agent-model",
        "private-agent-prompt",
        "private-agent-output",
        "/private/agent/source",
        "private-vault-tag",
        "private-vault-ciphertext",
        "private-vault-nonce",
        "private-vault-wrap",
        "private-vault-description",
        "private.example",
    ):
        assert forbidden not in serialized


def test_local_descriptors_omit_missing_source_rows() -> None:
    paths.ensure_data_dirs()
    run_migrations()
    engine = get_cached_sqlite_engine()
    with engine.begin() as connection:
        for resource_kind, resource_id in (
            ("agent", "missing-agent"),
            ("vault_secret", "missing-vault"),
            ("skill", "missing-skill"),
        ):
            resource_access_service.ensure_resource_policy(
                connection,
                resource_kind=resource_kind,
                resource_id=resource_id,
                organization_id="org-1",
                owner_user_id="owner-1",
                access_level="private",
            )

    assert remote_access._local_policy_resource_descriptors("org-1") == []


def test_sync_applies_only_newer_intent_and_acknowledges_exact_revision(monkeypatch) -> None:
    _seed_policy()
    config = _config()
    calls: list[dict[str, Any]] = []
    responses = iter(
        [
            _Response({"organization_id": "org-1", "resources": []}),
            _Response(
                {
                    "organization_id": "org-1",
                    "poll_after_seconds": 30,
                    "intents": [
                        {
                            "resource_kind": "agent",
                            "resource_id": "agent-1",
                            "revision": 2,
                            "access_level": "scope",
                            "group_ids": ["group-engineering"],
                        }
                    ],
                }
            ),
            _Response({"resource": {"resource_kind": "agent", "resource_id": "agent-1"}}),
            _Response({"organization_id": "org-1", "resources": []}),
            _Response(
                {
                    "organization_id": "org-1",
                    "poll_after_seconds": 30,
                    "intents": [
                        {
                            "resource_kind": "agent",
                            "resource_id": "agent-1",
                            "revision": 1,
                            "access_level": "private",
                            "group_ids": [],
                        }
                    ],
                }
            ),
        ]
    )

    def request(method: str, url: str, **kwargs: Any) -> _Response:
        calls.append({"method": method, "url": url, **kwargs})
        return next(responses)

    monkeypatch.setattr(remote_access.requests, "request", request)

    first = remote_access.sync_resource_acl_once(
        config,
        organization_id="org-1",
        resources=[_descriptor()],
    )
    second = remote_access.sync_resource_acl_once(
        config,
        organization_id="org-1",
        resources=[_descriptor()],
    )

    assert first["ok"] is True
    assert first["organizations"][0]["applied"] == 1
    assert second["ok"] is True
    assert second["organizations"][0]["skipped"] == 1
    assert [call["method"] for call in calls] == ["PUT", "GET", "POST", "PUT", "GET"]
    assert calls[0]["headers"]["X-Vibe-Device-Secret"] == "paired-device-secret"
    assert set(calls[0]["json"]["resources"][0]) <= {
        "resource_id",
        "resource_kind",
        "display_name",
        "owner_user_id",
        "metadata_revision",
        "applied_acl_revision",
        "access_level",
        "group_ids",
        "sync_status",
    }
    assert calls[2]["json"] == {
        "resource_kind": "agent",
        "resource_id": "agent-1",
        "revision": 2,
        "outcome": "applied",
    }

    engine = get_cached_sqlite_engine()
    with engine.connect() as connection:
        policy = resource_access_service.get_resource_policy("agent", "agent-1", connection=connection)
    assert policy is not None
    assert policy["access_level"] == "scope"
    assert policy["group_ids"] == ["group-engineering"]
    assert policy["last_applied_control_plane_revision"] == 2


def test_sync_offline_retains_last_applied_policy(monkeypatch) -> None:
    _seed_policy()
    config = _config()

    def request(*_args: Any, **_kwargs: Any):
        raise remote_access.requests.ConnectionError("offline")

    monkeypatch.setattr(remote_access.requests, "request", request)

    result = remote_access.sync_resource_acl_once(
        config,
        organization_id="org-1",
        resources=[_descriptor()],
    )

    assert result["ok"] is False
    assert result["organizations"][0]["error"] == "resource_acl_sync_failed"
    engine = get_cached_sqlite_engine()
    with engine.connect() as connection:
        policy = resource_access_service.get_resource_policy("agent", "agent-1", connection=connection)
    assert policy is not None
    assert policy["access_level"] == "private"
    assert policy["last_applied_control_plane_revision"] == 1


def test_sync_publishes_empty_index_after_last_organization_policy_is_deleted(monkeypatch) -> None:
    _seed_policy()
    config = _config()
    engine = get_cached_sqlite_engine()
    with engine.begin() as connection:
        assert resource_access_service.delete_resource_policy(
            connection,
            "agent",
            "agent-1",
        )
    assert resource_access_service.list_resource_organization_ids() == ["org-1"]

    def offline_request(*_args: Any, **_kwargs: Any):
        raise remote_access.requests.ConnectionError("offline")

    monkeypatch.setattr(remote_access.requests, "request", offline_request)
    offline = remote_access.sync_resource_acl_once(config)
    assert offline["ok"] is False
    assert resource_access_service.list_resource_organization_ids() == ["org-1"]

    calls: list[dict[str, Any]] = []
    responses = iter(
        [
            _Response({"organization_id": "org-1", "resources": []}),
            _Response(
                {
                    "organization_id": "org-1",
                    "poll_after_seconds": 30,
                    "intents": [],
                }
            ),
        ]
    )

    def request(method: str, url: str, **kwargs: Any) -> _Response:
        calls.append({"method": method, "url": url, **kwargs})
        return next(responses)

    monkeypatch.setattr(remote_access.requests, "request", request)

    result = remote_access.sync_resource_acl_once(config)

    assert result["ok"] is True
    assert result["organizations"][0]["organization_id"] == "org-1"
    assert [call["method"] for call in calls] == ["PUT", "GET"]
    assert calls[0]["json"]["resources"] == []
    assert resource_access_service.list_resource_organization_ids() == []


def test_malformed_intent_keeps_empty_organization_queued_for_retry(monkeypatch) -> None:
    _seed_policy()
    config = _config()
    engine = get_cached_sqlite_engine()
    with engine.begin() as connection:
        assert resource_access_service.delete_resource_policy(connection, "agent", "agent-1")

    responses = iter(
        [
            _Response({"organization_id": "org-1", "resources": []}),
            _Response(
                {
                    "organization_id": "org-1",
                    "poll_after_seconds": 30,
                    "intents": [{"resource_kind": "invalid"}],
                }
            ),
        ]
    )
    monkeypatch.setattr(remote_access.requests, "request", lambda *_args, **_kwargs: next(responses))

    result = remote_access.sync_resource_acl_once(config)

    assert result["ok"] is False
    assert result["organizations"][0]["rejected"] == 1
    assert result["organizations"][0]["ack_errors"] == 1
    assert resource_access_service.list_resource_organization_ids() == ["org-1"]


def test_applied_acl_changes_publish_one_authorization_change_for_all_resource_caches(monkeypatch) -> None:
    paths.ensure_data_dirs()
    run_migrations()
    engine = get_cached_sqlite_engine()
    resource_ids = {
        "agent": "agent-cache-revocation",
        "skill": "skill-cache-revocation",
        "vault_secret": "vault-cache-revocation",
    }
    with engine.begin() as connection:
        for resource_kind, resource_id in resource_ids.items():
            resource_access_service.ensure_resource_policy(
                connection,
                resource_kind=resource_kind,
                resource_id=resource_id,
                organization_id="org-cache-revocation",
                owner_user_id="owner-1",
                access_level="public",
                policy_revision=1,
                last_applied_control_plane_revision=1,
            )

    monkeypatch.setattr(
        remote_access,
        "publish_resource_index",
        lambda *_args, **_kwargs: {
            "organization_id": "org-cache-revocation",
            "resources": [],
        },
    )
    monkeypatch.setattr(
        remote_access,
        "pull_resource_acl_intents",
        lambda *_args, **_kwargs: {
            "organization_id": "org-cache-revocation",
            "intents": [
                {
                    "resource_kind": resource_kind,
                    "resource_id": resource_id,
                    "revision": 2,
                    "access_level": "private",
                    "group_ids": [],
                }
                for resource_kind, resource_id in resource_ids.items()
            ],
        },
    )
    monkeypatch.setattr(
        remote_access,
        "acknowledge_resource_acl_intent",
        lambda *_args, **_kwargs: {},
    )
    events: list[tuple[str, dict[str, Any]]] = []
    monkeypatch.setattr(
        "vibe.sse_broker.broker.publish",
        lambda event_type, data: events.append((event_type, data)),
    )

    result = remote_access._sync_one_organization(
        None,
        organization_id="org-cache-revocation",
        resources=[],
    )

    assert result["ok"] is True
    assert result["applied"] == 3
    assert events == [
        (
            "authorization.changed",
            {
                "project_ids": [],
                "resource_kinds": ["agent", "skill", "vault_secret"],
            },
        )
    ]


def test_transient_apply_failure_leaves_intent_unacknowledged(monkeypatch) -> None:
    _seed_policy()
    config = _config()
    calls: list[dict[str, Any]] = []
    responses = iter(
        [
            _Response({"organization_id": "org-1", "resources": []}),
            _Response(
                {
                    "organization_id": "org-1",
                    "poll_after_seconds": 30,
                    "intents": [
                        {
                            "resource_kind": "agent",
                            "resource_id": "agent-1",
                            "revision": 2,
                            "access_level": "public",
                            "group_ids": [],
                        }
                    ],
                }
            ),
        ]
    )

    def request(method: str, url: str, **kwargs: Any) -> _Response:
        calls.append({"method": method, "url": url, **kwargs})
        return next(responses)

    monkeypatch.setattr(remote_access.requests, "request", request)
    monkeypatch.setattr(
        resource_access_service,
        "apply_control_plane_intent",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(OSError("database is busy")),
    )

    result = remote_access.sync_resource_acl_once(
        config,
        organization_id="org-1",
        resources=[_descriptor()],
    )

    organization = result["organizations"][0]
    assert result["ok"] is False
    assert organization["rejected"] == 0
    assert organization["acknowledged"] == 0
    assert organization["ack_errors"] == 1
    assert [call["method"] for call in calls] == ["PUT", "GET"]

    engine = get_cached_sqlite_engine()
    with engine.connect() as connection:
        policy = resource_access_service.get_resource_policy("agent", "agent-1", connection=connection)
    assert policy is not None
    assert policy["access_level"] == "private"
    assert policy["last_applied_control_plane_revision"] == 1


def test_poll_delay_honors_successful_organization_backoff() -> None:
    result = {
        "ok": False,
        "organizations": [
            {"organization_id": "org-1", "ok": True, "poll_after_seconds": 45},
            {"organization_id": "org-2", "ok": True, "poll_after_seconds": 120},
            {"organization_id": "org-3", "ok": False, "poll_after_seconds": 300},
        ],
    }

    assert remote_access._resource_acl_poll_delay(result, 30) == 120


def test_poll_delay_falls_back_without_valid_successful_result() -> None:
    result = {
        "ok": False,
        "organizations": [
            {"organization_id": "org-1", "ok": False, "poll_after_seconds": 120},
            {"organization_id": "org-2", "ok": True, "poll_after_seconds": 0},
            {"organization_id": "org-3", "ok": True, "poll_after_seconds": "invalid"},
        ],
    }

    assert remote_access._resource_acl_poll_delay(result, 30) == 30