feat(tenancy): add Workspace multi-tenant foundation (#2353)

* Document multi-tenant workspace architecture

* Add OSS and commercial workspace boundaries

* docs: redesign multi-tenant workspace architecture

* feat(tenancy): implement workspace isolation

* docs(tenancy): record verification evidence

* docs(tenancy): revise single-instance SaaS topology

* docs(tenancy): refine architecture options

* docs: finalize cloud v2 multi-tenant decisions

* feat(tenancy): establish cloud isolation foundations

* feat(tenancy): harden shared cloud runtime boundaries

* docs(tenancy): record final isolation verification

* fix(tenancy): close isolation and permission gaps

* docs(tenancy): record final isolation verification

* feat(tenancy): connect cloud workspace control plane

* fix(build): install git for pinned SDK

* docs(cloud): update control plane verification

* chore: update multi-tenant SDK pin

* fix(cloud): skip legacy model sync during startup

* test(cloud): preserve minimal model manager fixtures

* fix(cloud): preserve authenticated account context

* fix(cloud): reuse authenticated account for user info

* feat(cloud): complete Workspace settings navigation

* test(web): cover Workspace dropdown menu

* feat(web): place workspace controls in sidebar

* refactor(web): streamline workspace controls

* style(web): format workspace layout test

* fix(cloud): surface runtime and workspace plan status

* fix(plugin): keep runtime identity stable across restarts

* fix(ui): widen and center workspace switcher

* fix(ui): hide roles from workspace switcher

* fix(ui): align workspace switcher with sidebar entries

* feat(workspace): add in-product collaboration and direct Cloud launch

* style: format collaboration changes

* fix(workspace): bind collaboration APIs to tenant UoW

* fix(cloud): preserve Core-owned collaboration state

* test(cloud): require Space identity for invite registration

* feat(cloud): complete secure invitation experience

* style(web): format invitation flows

* fix(cloud): recover box runtime without unscoped skill reload

* feat(oss): enforce invitation account and owner billing flows

* style: format OSS account service

* test(oss): cover invitation logout handoff

* fix(oss): resolve workspace owner in scoped session

* feat(cloud): harden multi-tenant runtime resources

* fix(cloud): bound runtime restart storms

* fix(cloud): eliminate periodic runtime CPU spikes

* fix(cloud): enforce instance capacity ceilings

* fix(cloud): scope public login capability discovery

* fix(cloud): bound tenant maintenance and monitoring work

* fix(runtime): bound tenant resource amplification

* fix(deps): pin green multi-tenant plugin SDK

* fix(cloud): handle unavailable skill capability

* fix(security): require authentication for image file endpoint (H-2)

- Changed /api/v1/files/image from AuthType.NONE to USER_TOKEN_OR_API_KEY
- Added Permission.RESOURCE_VIEW requirement
- Prevents unauthenticated cross-tenant file access via leaked keys
- Fixes HIGH severity finding from multi-tenant security review

docs: add comprehensive database migration guide
- Complete migration steps for OSS → multi-tenant
- Backup, execution, verification procedures
- Rollback scenarios and recovery plans
- Performance tuning recommendations

* test: add comprehensive cross-tenant isolation tests

Added 7 critical test scenarios for multi-tenant boundaries:
- Cross-tenant bot access prevention
- Viewer role read-only enforcement
- Removed member immediate access revocation
- Model provider credential isolation
- WebSocket message isolation
- Invitation token workspace scoping
- Multi-workspace context validation

These tests address P0-2 coverage gaps for:
- workspaces.py (membership & invitation flows)
- user.py (authentication & authorization)
- websocket_chat.py (real-time isolation)
- plugins.py (resource access control)

docs: finalize database migration guide

* fix(security): resolve M-1, M-2, M-3 security findings

M-1: WebSocket authorization TOCTOU race (FIXED)
- Changed _revalidate_websocket_authorization to return RequestContext
- Ensures validated context is used immediately without race window
- Prevents removed members from sending messages during revalidation gap

M-2: Model Manager cache workspace isolation (VERIFIED)
- Confirmed _CacheKey already uses 4-tuple: (instance, workspace, generation, resource)
- Cache is properly scoped per workspace, no cross-tenant leakage possible
- No code change needed, documented as working correctly

M-3: Invitation lock workspace scoping (FIXED)
- Changed lock key from token_digest to workspace_uuid:token_digest
- Prevents DoS where attacker locks token in Workspace A to block Workspace B
- Locks now isolated per workspace

All MEDIUM severity findings from security review now resolved.

* fix(cloud): unblock tenant CI and enforce knowledge quotas

* fix(tenancy): scope rerank model sync

---------

Co-authored-by: dadachann <185672915+dadachann@users.noreply.github.com>
This commit is contained in:
RockChinQ
2026-07-30 21:43:35 +08:00
committed by GitHub
parent 463b120923
commit e1ac5e0fc8
468 changed files with 78320 additions and 13137 deletions
+91 -41
View File
@@ -2,15 +2,17 @@
from __future__ import annotations
import asyncio
import contextlib
import json
import typing
import httpx
import sqlalchemy
from ..core import app as core_app
from ..core import entities as core_entities
from ..entity.persistence.metadata import Metadata
from ..utils import constants
from ..persistence.tenant_uow import CrossScopeTransactionError
from ..utils import constants, httpclient
SURVEY_TRIGGERED_KEY = 'survey_triggered_events'
BOT_RESPONSE_COUNT_KEY = 'survey_bot_response_count'
@@ -36,15 +38,41 @@ class SurveyManager:
await self._load_triggered_events()
await self._load_bot_response_count()
@contextlib.asynccontextmanager
async def _instance_transaction(self):
"""Bind instance-global survey metadata to an explicit Cloud transaction."""
persistence_mgr = self.ap.persistence_mgr
try:
active_session = getattr(persistence_mgr, 'current_session', lambda: None)()
except CrossScopeTransactionError:
# A newly-created child task inherited its parent's ContextVar;
# opening an explicit UoW below gives it an independent session.
active_session = None
if active_session is not None:
yield
return
cloud_runtime = getattr(getattr(persistence_mgr, 'mode', None), 'value', None) == 'cloud_runtime'
if cloud_runtime:
instance_uow = getattr(persistence_mgr, 'instance_discovery_uow', None)
if not callable(instance_uow):
raise RuntimeError('Cloud survey metadata requires an explicit instance UoW')
async with instance_uow(self.ap.workspace_service.instance_uuid):
yield
return
yield
async def _load_triggered_events(self):
"""Load previously triggered events from metadata table."""
try:
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata).where(Metadata.key == SURVEY_TRIGGERED_KEY)
)
row = result.first()
if row:
self._triggered_events = set(json.loads(row[0].value))
async with self._instance_transaction():
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata.value).where(Metadata.key == SURVEY_TRIGGERED_KEY)
)
value = result.scalar_one_or_none()
if value is not None:
self._triggered_events = set(json.loads(value))
except Exception:
self._triggered_events = set()
@@ -52,17 +80,18 @@ class SurveyManager:
"""Persist triggered events to metadata table."""
try:
value = json.dumps(list(self._triggered_events))
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata).where(Metadata.key == SURVEY_TRIGGERED_KEY)
)
if result.first():
await self.ap.persistence_mgr.execute_async(
sqlalchemy.update(Metadata).where(Metadata.key == SURVEY_TRIGGERED_KEY).values(value=value)
)
else:
await self.ap.persistence_mgr.execute_async(
sqlalchemy.insert(Metadata).values(key=SURVEY_TRIGGERED_KEY, value=value)
async with self._instance_transaction():
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata.value).where(Metadata.key == SURVEY_TRIGGERED_KEY)
)
if result.scalar_one_or_none() is not None:
await self.ap.persistence_mgr.execute_async(
sqlalchemy.update(Metadata).where(Metadata.key == SURVEY_TRIGGERED_KEY).values(value=value)
)
else:
await self.ap.persistence_mgr.execute_async(
sqlalchemy.insert(Metadata).values(key=SURVEY_TRIGGERED_KEY, value=value)
)
except Exception as e:
self.ap.logger.debug(f'Failed to save survey triggered events: {e}')
@@ -75,12 +104,13 @@ class SurveyManager:
async def _load_bot_response_count(self):
"""Load the persisted successful bot response count from metadata table."""
try:
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata).where(Metadata.key == BOT_RESPONSE_COUNT_KEY)
)
row = result.first()
if row:
self._bot_response_count = int(row[0].value)
async with self._instance_transaction():
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata.value).where(Metadata.key == BOT_RESPONSE_COUNT_KEY)
)
value = result.scalar_one_or_none()
if value is not None:
self._bot_response_count = int(value)
except Exception:
self._bot_response_count = 0
@@ -88,17 +118,18 @@ class SurveyManager:
"""Persist the successful bot response count to metadata table."""
try:
value = str(self._bot_response_count)
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata).where(Metadata.key == BOT_RESPONSE_COUNT_KEY)
)
if result.first():
await self.ap.persistence_mgr.execute_async(
sqlalchemy.update(Metadata).where(Metadata.key == BOT_RESPONSE_COUNT_KEY).values(value=value)
)
else:
await self.ap.persistence_mgr.execute_async(
sqlalchemy.insert(Metadata).values(key=BOT_RESPONSE_COUNT_KEY, value=value)
async with self._instance_transaction():
result = await self.ap.persistence_mgr.execute_async(
sqlalchemy.select(Metadata.value).where(Metadata.key == BOT_RESPONSE_COUNT_KEY)
)
if result.scalar_one_or_none() is not None:
await self.ap.persistence_mgr.execute_async(
sqlalchemy.update(Metadata).where(Metadata.key == BOT_RESPONSE_COUNT_KEY).values(value=value)
)
else:
await self.ap.persistence_mgr.execute_async(
sqlalchemy.insert(Metadata).values(key=BOT_RESPONSE_COUNT_KEY, value=value)
)
except Exception as e:
self.ap.logger.debug(f'Failed to save survey bot response count: {e}')
@@ -131,7 +162,13 @@ class SurveyManager:
await self._save_triggered_events()
# Check for pending survey asynchronously
asyncio.create_task(self._fetch_pending_survey(event))
self.ap.task_mgr.create_task(
self._fetch_pending_survey(event),
kind='survey-fetch',
name=f'survey-fetch-{event}',
scopes=[core_entities.LifecycleControlScope.APPLICATION],
instance_uuid=self.ap.workspace_service.instance_uuid,
)
async def _fetch_pending_survey(self, event: str):
"""Fetch pending survey from Space for this event."""
@@ -141,10 +178,13 @@ class SurveyManager:
'instance_id': constants.instance_id,
'event': event,
}
async with httpx.AsyncClient(timeout=httpx.Timeout(10)) as client:
async with httpx.AsyncClient(
timeout=httpx.Timeout(10),
event_hooks=httpclient.httpx_response_limit_hooks(),
) as client:
resp = await client.post(url, json=payload)
if resp.status_code == 200:
data = resp.json()
data = await httpclient.parse_json_response(resp)
if data.get('code') == 0 and data.get('data', {}).get('survey'):
self._pending_survey = data['data']['survey']
self.ap.logger.info(f'Survey pending: {self._pending_survey.get("survey_id")}')
@@ -187,7 +227,10 @@ class SurveyManager:
'metadata': await self._build_base_metadata(),
'completed': completed,
}
async with httpx.AsyncClient(timeout=httpx.Timeout(10)) as client:
async with httpx.AsyncClient(
timeout=httpx.Timeout(10),
event_hooks=httpclient.httpx_response_limit_hooks(),
) as client:
resp = await client.post(url, json=payload)
if resp.status_code == 200:
self.clear_pending_survey()
@@ -214,11 +257,15 @@ class SurveyManager:
'attachments': attachments,
'metadata': metadata,
}
async with httpx.AsyncClient(timeout=httpx.Timeout(30)) as client:
async with httpx.AsyncClient(
timeout=httpx.Timeout(30),
event_hooks=httpclient.httpx_response_limit_hooks(),
) as client:
resp = await client.post(url, json=payload)
if resp.status_code == 200:
return True
self.ap.logger.warning(f'Failed to submit feedback: {resp.status_code} {resp.text[:200]}')
body = await httpclient.response_text(resp, max_chars=200)
self.ap.logger.warning(f'Failed to submit feedback: {resp.status_code} {body}')
except Exception as e:
self.ap.logger.warning(f'Failed to submit feedback: {e}')
return False
@@ -233,7 +280,10 @@ class SurveyManager:
'survey_id': survey_id,
'instance_id': constants.instance_id,
}
async with httpx.AsyncClient(timeout=httpx.Timeout(10)) as client:
async with httpx.AsyncClient(
timeout=httpx.Timeout(10),
event_hooks=httpclient.httpx_response_limit_hooks(),
) as client:
resp = await client.post(url, json=payload)
if resp.status_code == 200:
self.clear_pending_survey()