feat(tenancy): establish cloud isolation foundations

tests/unit_tests/cloud/test_bootstrap.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from langbot.pkg.cloud.bootstrap import (
+    CloudBootstrapError,
+    OpenSourceDeployment,
+    VerifiedCloudDeployment,
+    resolve_deployment,
+)
+from langbot.pkg.cloud.entitlements import EntitlementSnapshot
+
+
+pytestmark = pytest.mark.asyncio
+
+
+class _Entitlements:
+    async def get_workspace_entitlement(self, workspace_uuid: str) -> EntitlementSnapshot:
+        return EntitlementSnapshot(
+            instance_uuid='instance-a',
+            workspace_uuid=workspace_uuid,
+            entitlement_revision=1,
+            status='active',
+            not_before=1,
+            expires_at=4_000_000_000,
+            features={'managed_sandbox': True},
+            limits={'managed_sandbox_sessions': 1},
+        )
+
+
+class _Provider:
+    def bootstrap(self, *, instance_uuid: str, instance_config: dict):
+        del instance_config
+        return VerifiedCloudDeployment(
+            instance_uuid=instance_uuid,
+            manifest_jti='manifest-a',
+            manifest_generation=3,
+            expires_at=4_000_000_000,
+            release='cloud-v2',
+            capabilities=frozenset({'multi_workspace_v2'}),
+            tenant_isolation_version=2,
+            entitlement_provider=_Entitlements(),
+            verification_key_id='root-2026',
+        )
+
+
+class _EntryPoint:
+    def __init__(self, value):
+        self.value = value
+
+    def load(self):
+        return self.value
+
+
+class _EntryPoints(list):
+    def select(self, *, group: str):
+        return self if group == 'langbot.cloud_bootstrap' else []
+
+
+def _cloud_config() -> dict:
+    return {
+        'database': {'use': 'postgresql'},
+        'vdb': {'use': 'pgvector'},
+        'mcp': {'stdio': {'enabled': False}},
+        # Proves mutable product metadata does not participate in selection.
+        'system': {'edition': 'community'},
+    }
+
+
+async def test_no_closed_entry_point_selects_oss_singleton_even_if_edition_says_cloud():
+    deployment = await resolve_deployment(
+        instance_uuid='instance-a',
+        instance_config={'system': {'edition': 'cloud'}},
+        entry_points=lambda: _EntryPoints(),
+    )
+
+    assert isinstance(deployment, OpenSourceDeployment)
+    assert deployment.multi_workspace_enabled is False
+
+
+async def test_verified_closed_entry_point_activates_cloud_policy():
+    deployment = await resolve_deployment(
+        instance_uuid='instance-a',
+        instance_config=_cloud_config(),
+        entry_points=lambda: _EntryPoints([_EntryPoint(_Provider)]),
+        now=1_000,
+    )
+
+    assert isinstance(deployment, VerifiedCloudDeployment)
+    assert deployment.multi_workspace_enabled is True
+    assert deployment.persistence_mode == 'cloud_runtime'
+
+
+@pytest.mark.parametrize(
+    ('field', 'value', 'message'),
+    [
+        ('database', {'use': 'sqlite'}, 'database.use=postgresql'),
+        ('vdb', {'use': 'chroma'}, 'vdb.use=pgvector'),
+        ('mcp', {'stdio': {'enabled': True}}, 'mcp.stdio.enabled=false'),
+    ],
+)
+async def test_cloud_runtime_config_is_fail_closed(field, value, message):
+    config = _cloud_config()
+    config[field] = value
+
+    with pytest.raises(CloudBootstrapError, match=message):
+        await resolve_deployment(
+            instance_uuid='instance-a',
+            instance_config=config,
+            entry_points=lambda: _EntryPoints([_EntryPoint(_Provider())]),
+            now=1_000,
+        )
+
+
+async def test_invalid_provider_never_falls_back_to_oss():
+    provider = SimpleNamespace(bootstrap=lambda **_: object())
+
+    with pytest.raises(CloudBootstrapError, match='must return VerifiedCloudDeployment'):
+        await resolve_deployment(
+            instance_uuid='instance-a',
+            instance_config=_cloud_config(),
+            entry_points=lambda: _EntryPoints([_EntryPoint(provider)]),
+            now=1_000,
+        )
+
+
+async def test_duplicate_closed_providers_fail_closed():
+    with pytest.raises(CloudBootstrapError, match='Exactly one'):
+        await resolve_deployment(
+            instance_uuid='instance-a',
+            instance_config=_cloud_config(),
+            entry_points=lambda: _EntryPoints([_EntryPoint(_Provider()), _EntryPoint(_Provider())]),
+            now=1_000,
+        )

tests/unit_tests/cloud/test_entitlements.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import pytest
+from unittest.mock import AsyncMock
+
+from langbot.pkg.cloud.entitlements import EntitlementResolver, EntitlementSnapshot, EntitlementUnavailableError
+
+
+def _snapshot(**overrides) -> EntitlementSnapshot:
+    values = {
+        'instance_uuid': 'instance-a',
+        'workspace_uuid': 'workspace-a',
+        'entitlement_revision': 7,
+        'status': 'active',
+        'not_before': 100,
+        'expires_at': 200,
+        'features': {'managed_sandbox': True, 'mcp_stdio': False},
+        'limits': {'managed_sandbox_sessions': 1},
+    }
+    values.update(overrides)
+    return EntitlementSnapshot(**values)
+
+
+def test_active_snapshot_exposes_only_generic_features_and_limits():
+    snapshot = _snapshot().require_active(
+        instance_uuid='instance-a',
+        workspace_uuid='workspace-a',
+        now=150,
+    )
+
+    snapshot.require_feature('managed_sandbox')
+    assert snapshot.limit('managed_sandbox_sessions') == 1
+    assert 'plan' not in snapshot.model_fields
+
+
+@pytest.mark.parametrize(
+    'snapshot,now',
+    [
+        (_snapshot(status='suspended'), 150),
+        (_snapshot(), 99),
+        (_snapshot(), 200),
+    ],
+)
+def test_inactive_or_expired_snapshot_fails_closed(snapshot, now):
+    with pytest.raises(EntitlementUnavailableError):
+        snapshot.require_active(
+            instance_uuid='instance-a',
+            workspace_uuid='workspace-a',
+            now=now,
+        )
+
+
+def test_scope_mismatch_fails_closed():
+    with pytest.raises(EntitlementUnavailableError, match='scope'):
+        _snapshot().require_active(
+            instance_uuid='instance-a',
+            workspace_uuid='workspace-b',
+            now=150,
+        )
+
+
+@pytest.mark.asyncio
+async def test_resolver_rejects_revision_rollback():
+    provider = AsyncMock()
+    provider.get_workspace_entitlement = AsyncMock(side_effect=[_snapshot(), _snapshot(entitlement_revision=6)])
+    resolver = EntitlementResolver('instance-a', provider)
+
+    await resolver.resolve('workspace-a', now=150)
+    with pytest.raises(EntitlementUnavailableError, match='rolled back'):
+        await resolver.resolve('workspace-a', now=150)
+
+
+@pytest.mark.asyncio
+async def test_resolver_rejects_same_revision_with_different_contents():
+    provider = AsyncMock()
+    provider.get_workspace_entitlement = AsyncMock(
+        side_effect=[
+            _snapshot(),
+            _snapshot(features={'managed_sandbox': False}),
+        ]
+    )
+    resolver = EntitlementResolver('instance-a', provider)
+
+    await resolver.resolve('workspace-a', now=150)
+    with pytest.raises(EntitlementUnavailableError, match='conflicting contents'):
+        await resolver.resolve('workspace-a', now=150)