feat(tenancy): implement workspace isolation

tests/integration/api/test_pipelines.py

@@ -9,10 +9,13 @@ Run: uv run pytest tests/integration/api/test_pipelines.py -q
 
 from __future__ import annotations
 
+import json
 import pytest
 from unittest.mock import MagicMock, AsyncMock, Mock
+from types import SimpleNamespace
 
 from tests.factories import FakeApp
+from langbot.pkg.workspace.errors import WorkspaceNotFoundError
 
 
 pytestmark = pytest.mark.integration
@@ -54,6 +57,7 @@ def mock_circular_import_chain():
     ):
         # Import groups after mocking to populate preregistered_groups
         import langbot.pkg.api.http.controller.groups.pipelines.pipelines as _pipelines  # noqa: E402, F401
+        import langbot.pkg.api.http.controller.groups.pipelines.websocket_chat as _websocket_chat  # noqa: E402, F401
 
         yield
 
@@ -75,10 +79,25 @@ def fake_pipeline_app():
     )
 
     # Auth services
+    account = SimpleNamespace(uuid='account-test', user='test@example.com')
     app.user_service = Mock()
     app.user_service.is_initialized = AsyncMock(return_value=True)
     app.user_service.verify_jwt_token = AsyncMock(return_value='test@example.com')
-    app.user_service.get_user_by_email = AsyncMock(return_value=Mock(email='test@example.com'))
+    app.user_service.get_user_by_email = AsyncMock(return_value=account)
+    app.user_service.get_authenticated_account = AsyncMock(return_value=account)
+    app.workspace_collaboration_service = SimpleNamespace(
+        resolve_account_workspace=AsyncMock(
+            return_value=SimpleNamespace(
+                workspace=SimpleNamespace(uuid='workspace-test'),
+                membership=SimpleNamespace(
+                    uuid='membership-test',
+                    role='owner',
+                    projection_revision=0,
+                ),
+                execution=SimpleNamespace(instance_uuid='instance-test', placement_generation=1),
+            )
+        )
+    )
     app.apikey_service = Mock()
     app.apikey_service.verify_api_key = AsyncMock(return_value=True)
 
@@ -119,6 +138,15 @@ def fake_pipeline_app():
     app.bot_service.get_bots = AsyncMock(return_value=[])
     app.bot_service.create_bot = AsyncMock(return_value={'uuid': 'new-bot-uuid'})
 
+    # Workspace-scoped dashboard WebSocket proxy
+    websocket_adapter = Mock()
+    websocket_adapter.get_websocket_messages = Mock(return_value=[])
+    websocket_adapter.reset_session = Mock()
+    websocket_adapter.handle_websocket_message = AsyncMock()
+    websocket_proxy_bot = Mock(adapter=websocket_adapter)
+    app.platform_mgr = Mock()
+    app.platform_mgr.get_websocket_proxy_bot = AsyncMock(return_value=websocket_proxy_bot)
+
     # MCP service (for extensions endpoint)
     app.mcp_service = Mock()
     app.mcp_service.get_mcp_servers = AsyncMock(return_value=[])
@@ -278,3 +306,147 @@ class TestPipelineExtensionsEndpoint:
         assert response.status_code == 200
         data = await response.get_json()
         assert data['code'] == 0
+
+    @pytest.mark.asyncio
+    async def test_get_extensions_redacts_available_plugin_secrets(
+        self,
+        quart_test_client,
+        fake_pipeline_app,
+    ):
+        connector = fake_pipeline_app.plugin_connector
+        raw_plugin = {
+            'plugin_config': {'apiKey': 'plugin-secret'},
+            'debug': {'plugin_debug_key': 'debug-secret'},
+        }
+        connector.list_plugins.return_value = [raw_plugin]
+        try:
+            response = await quart_test_client.get(
+                '/api/v1/pipelines/test-pipeline-uuid/extensions',
+                headers={'Authorization': 'Bearer test_token'},
+            )
+        finally:
+            connector.list_plugins.return_value = []
+
+        assert response.status_code == 200
+        plugin = (await response.get_json())['data']['available_plugins'][0]
+        assert plugin['plugin_config']['apiKey'] == '***'
+        assert plugin['debug']['plugin_debug_key'] == '***'
+        assert raw_plugin['plugin_config']['apiKey'] == 'plugin-secret'
+
+    @pytest.mark.asyncio
+    async def test_get_extensions_hides_connector_bound_to_another_workspace(
+        self,
+        quart_test_client,
+        fake_pipeline_app,
+    ):
+        connector = fake_pipeline_app.plugin_connector
+        original_enabled = connector.is_enable_plugin
+        connector.is_enable_plugin = True
+        connector.require_workspace_context.reset_mock()
+        connector.list_plugins.reset_mock()
+        connector.require_workspace_context.side_effect = WorkspaceNotFoundError('Plugin resource not found')
+        try:
+            response = await quart_test_client.get(
+                '/api/v1/pipelines/test-pipeline-uuid/extensions',
+                headers={'Authorization': 'Bearer test_token'},
+            )
+        finally:
+            connector.require_workspace_context.side_effect = None
+            connector.is_enable_plugin = original_enabled
+
+        assert response.status_code == 404
+        connector.list_plugins.assert_not_awaited()
+
+
+@pytest.mark.usefixtures('mock_circular_import_chain')
+class TestPipelineDashboardWebSocket:
+    @pytest.mark.asyncio
+    async def test_websocket_authenticates_before_registering(self, quart_test_client, fake_pipeline_app):
+        async with quart_test_client.websocket(
+            '/api/v1/pipelines/test-pipeline-uuid/ws/connect?session_type=person',
+            headers={'Origin': 'http://localhost'},
+        ) as websocket:
+            await websocket.send(
+                json.dumps(
+                    {
+                        'type': 'authenticate',
+                        'token': 'test_token',
+                        'workspace_uuid': 'workspace-test',
+                    }
+                )
+            )
+            connected = json.loads(await websocket.receive())
+            assert connected['type'] == 'connected'
+            assert connected['pipeline_uuid'] == 'test-pipeline-uuid'
+            await websocket.send(json.dumps({'type': 'disconnect'}))
+
+        fake_pipeline_app.workspace_collaboration_service.resolve_account_workspace.assert_awaited_with(
+            'account-test',
+            'workspace-test',
+        )
+        fake_pipeline_app.platform_mgr.get_websocket_proxy_bot.assert_awaited()
+
+    @pytest.mark.asyncio
+    async def test_websocket_rejects_non_auth_first_frame(self, quart_test_client):
+        async with quart_test_client.websocket(
+            '/api/v1/pipelines/test-pipeline-uuid/ws/connect?session_type=person',
+            headers={'Origin': 'http://localhost'},
+        ) as websocket:
+            await websocket.send(json.dumps({'type': 'message', 'message': []}))
+            response = json.loads(await websocket.receive())
+            assert response == {'type': 'error', 'message': 'Unauthorized'}
+
+    @pytest.mark.asyncio
+    async def test_websocket_rechecks_revocable_membership_before_each_message(
+        self,
+        quart_test_client,
+        fake_pipeline_app,
+    ):
+        access = fake_pipeline_app.workspace_collaboration_service.resolve_account_workspace.return_value
+        adapter = fake_pipeline_app.platform_mgr.get_websocket_proxy_bot.return_value.adapter
+        original_role = access.membership.role
+        adapter.handle_websocket_message.reset_mock()
+        try:
+            async with quart_test_client.websocket(
+                '/api/v1/pipelines/test-pipeline-uuid/ws/connect?session_type=person',
+                headers={'Origin': 'http://localhost'},
+            ) as websocket:
+                await websocket.send(
+                    json.dumps(
+                        {
+                            'type': 'authenticate',
+                            'token': 'test_token',
+                            'workspace_uuid': 'workspace-test',
+                        }
+                    )
+                )
+                assert json.loads(await websocket.receive())['type'] == 'connected'
+
+                access.membership.role = 'viewer'
+                await websocket.send(json.dumps({'type': 'message', 'message': []}))
+                assert json.loads(await websocket.receive()) == {
+                    'type': 'error',
+                    'message': 'Unauthorized',
+                }
+        finally:
+            access.membership.role = original_role
+
+        adapter.handle_websocket_message.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_dashboard_history_requires_runtime_permission(self, quart_test_client, fake_pipeline_app):
+        access = fake_pipeline_app.workspace_collaboration_service.resolve_account_workspace.return_value
+        original_role = access.membership.role
+        access.membership.role = 'viewer'
+        try:
+            response = await quart_test_client.get(
+                '/api/v1/pipelines/test-pipeline-uuid/ws/messages/person',
+                headers={
+                    'Authorization': 'Bearer test_token',
+                    'X-Workspace-Id': 'workspace-test',
+                },
+            )
+        finally:
+            access.membership.role = original_role
+
+        assert response.status_code == 403