π OpenHands: AI-Driven Development
feat: Add organization/authorization info to /api/v1/users/me endpoint (#13822)
chuckbutkus60ece6d7c2e6
diff --git a/enterprise/saas_server.py b/enterprise/saas_server.pyindex 434652befd..fd6fb31682 100644--- a/enterprise/saas_server.py+++ b/enterprise/saas_server.py@@ -49,6 +49,9 @@ from server.routes.readiness import readiness_router # noqa: E402from server.routes.service import service_router # noqa: E402from server.routes.user import saas_user_router # noqa: E402from server.routes.user_app_settings import user_app_settings_router # noqa: E402+from server.routes.users_v1 import ( # noqa: E402+ override_users_me_endpoint,+)from server.sharing.shared_conversation_router import ( # noqa: E402router as shared_conversation_router,)@@ -123,6 +126,10 @@ base_app.include_router(# This must happen after all routers are includedoverride_llm_models_dependency(base_app)+# Override the /api/v1/users/me endpoint to include organization info+# This replaces the OSS endpoint with a SAAS version that adds org_id, org_name, role, permissions+override_users_me_endpoint(base_app)+base_app.include_router(invitation_router) # Add routes for org invitation managementbase_app.include_router(invitation_accept_router) # Add route for accepting invitationsadd_github_proxy_routes(base_app)diff --git a/enterprise/server/auth/saas_user_auth.py b/enterprise/server/auth/saas_user_auth.pyindex 15f50cc40b..42bdd9f640 100644--- a/enterprise/server/auth/saas_user_auth.py+++ b/enterprise/server/auth/saas_user_auth.py@@ -14,6 +14,10 @@ from server.auth.auth_error import (ExpiredError,NoCredentialsError,)+from server.auth.authorization import (+ get_role_permissions,+ get_user_org_role,+)from server.auth.constants import BITBUCKET_DATA_CENTER_HOSTfrom server.auth.token_manager import TokenManagerfrom server.config import get_config@@ -23,10 +27,12 @@ from sqlalchemy import delete, selectfrom storage.api_key_store import ApiKeyStorefrom storage.auth_tokens import AuthTokensfrom storage.database import a_session_maker+from storage.org_store import OrgStorefrom storage.saas_secrets_store import SaasSecretsStorefrom storage.saas_settings_store import SaasSettingsStorefrom storage.user_authorization import UserAuthorizationTypefrom storage.user_authorization_store import UserAuthorizationStore+from storage.user_store import UserStorefrom tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_fixedfrom openhands.integrations.provider import (@@ -64,6 +70,12 @@ class SaasUserAuth(UserAuth):api_key_org_id: UUID | None = None # Org bound to the API key used for authapi_key_id: int | None = Noneapi_key_name: str | None = None+ # Organization context fields - populated lazily via get_org_info()+ _org_id: str | None = None+ _org_name: str | None = None+ _role: str | None = None+ _permissions: list[str] | None = None+ _org_info_loaded: bool = Falsedef get_api_key_org_id(self) -> UUID | None:"""Get the organization ID bound to the API key used for authentication.@@ -242,6 +254,72 @@ class SaasUserAuth(UserAuth):)return mcp_api_key+ async def get_org_info(self) -> dict | None:+ """Get organization info for the current user.++ Lazily loads and caches organization data including:+ - org_id: Current organization ID+ - org_name: Current organization name+ - role: User's role in the organization+ - permissions: List of permission names for the role++ Returns:+ dict with org_id, org_name, role, permissions or None if not available+ """+ if self._org_info_loaded:+ if self._org_id is None:+ return None+ return {+ 'org_id': self._org_id,+ 'org_name': self._org_name,+ 'role': self._role,+ 'permissions': self._permissions,+ }++ # Mark as loaded to avoid repeated attempts on failure+ self._org_info_loaded = True++ try:+ # Get user and their current org+ user = await UserStore.get_user_by_id(self.user_id)+ if not user:+ logger.warning(f'User {self.user_id} not found for org info')+ return None++ # Get the current org+ org = await OrgStore.get_org_by_id(user.current_org_id)+ if not org:+ logger.warning(+ f'Organization {user.current_org_id} not found for user {self.user_id}'+ )+ return None++ # Get user's role in the current org+ role = await get_user_org_role(self.user_id, user.current_org_id)+ role_name = role.name if role else None++ # Get permissions for the role+ permissions: list[str] = []+ if role_name:+ role_permissions = get_role_permissions(role_name)+ permissions = [p.value for p in role_permissions]++ # Cache the results+ self._org_id = str(user.current_org_id)+ self._org_name = org.name+ self._role = role_name+ self._permissions = permissions++ return {+ 'org_id': self._org_id,+ 'org_name': self._org_name,+ 'role': self._role,+ 'permissions': self._permissions,+ }+ except Exception as e:+ logger.error(f'Error fetching org info for user {self.user_id}: {e}')+ return None+@classmethodasync def get_instance(cls, request: Request) -> UserAuth:logger.debug('saas_user_auth_get_instance')diff --git a/enterprise/server/models/__init__.py b/enterprise/server/models/__init__.pynew file mode 100644index 0000000000..54d33320ac--- /dev/null+++ b/enterprise/server/models/__init__.py@@ -0,0 +1 @@+# Enterprise server modelsdiff --git a/enterprise/server/models/user_models.py b/enterprise/server/models/user_models.pynew file mode 100644index 0000000000..314c92db5d--- /dev/null+++ b/enterprise/server/models/user_models.py@@ -0,0 +1,16 @@+"""SAAS-specific user models that extend OSS UserInfo with organization fields."""++from openhands.app_server.user.user_models import UserInfo+++class SaasUserInfo(UserInfo):+ """User info model for SAAS mode with organization context.++ Extends the base UserInfo with SAAS-specific fields for organization+ membership, role, and permissions.+ """++ org_id: str | None = None+ org_name: str | None = None+ role: str | None = None+ permissions: list[str] | None = Nonediff --git a/enterprise/server/routes/users_v1.py b/enterprise/server/routes/users_v1.pynew file mode 100644index 0000000000..737230ac49--- /dev/null+++ b/enterprise/server/routes/users_v1.py@@ -0,0 +1,106 @@+"""SAAS-specific extensions for the /api/v1/users endpoints.++This module provides SAAS-specific implementations that extend the OSS+user endpoints with organization context (org_id, org_name, role, permissions).+"""++import logging++from fastapi import APIRouter, FastAPI, Header, HTTPException, Query, status+from fastapi.responses import JSONResponse+from server.auth.saas_user_auth import SaasUserAuth+from server.models.user_models import SaasUserInfo++from openhands.app_server.config import depends_user_context+from openhands.app_server.sandbox.session_auth import validate_session_key_ownership+from openhands.app_server.user.auth_user_context import AuthUserContext+from openhands.app_server.user.user_context import UserContext+from openhands.app_server.utils.dependencies import get_dependencies++_logger = logging.getLogger(__name__)++saas_users_v1_router = APIRouter(+ prefix='/api/v1/users', tags=['User'], dependencies=get_dependencies()+)+user_dependency = depends_user_context()+++@saas_users_v1_router.get('/me')+async def get_current_user_saas(+ user_context: UserContext = user_dependency,+ expose_secrets: bool = Query(+ default=False,+ description='If true, return unmasked secret values (e.g. llm_api_key). '+ 'Requires a valid X-Session-API-Key header for an active sandbox '+ 'owned by the authenticated user.',+ ),+ x_session_api_key: str | None = Header(default=None),+) -> SaasUserInfo:+ """Get the current authenticated user with SAAS-specific org info.++ Returns user settings along with organization context:+ - org_id: Current organization ID+ - org_name: Current organization name+ - role: User's role in the organization+ - permissions: List of permission strings for the role+ """+ # Get base user info from the context+ base_user_info = await user_context.get_user_info()+ if base_user_info is None:+ raise HTTPException(status.HTTP_401_UNAUTHORIZED, detail='Not authenticated')++ # Build SAAS user info from base settings+ user_info_data = base_user_info.model_dump(+ mode='json', context={'expose_secrets': True}+ )++ # Add org info if available (from SaasUserAuth)+ org_info = await _get_org_info_from_context(user_context)+ if org_info:+ user_info_data.update(org_info)++ user_info = SaasUserInfo(**user_info_data)++ if expose_secrets:+ await validate_session_key_ownership(user_context, x_session_api_key)+ return JSONResponse( # type: ignore[return-value]+ content=user_info.model_dump(mode='json', context={'expose_secrets': True})+ )+ return user_info+++async def _get_org_info_from_context(user_context: UserContext) -> dict | None:+ """Extract org info from the user context if available.++ This works by checking if the underlying user_auth is a SaasUserAuth+ instance that has the get_org_info method.+ """+ # Check if this is an AuthUserContext with a SaasUserAuth+ if isinstance(user_context, AuthUserContext):+ user_auth = user_context.user_auth+ if isinstance(user_auth, SaasUserAuth):+ return await user_auth.get_org_info()+ return None+++def override_users_me_endpoint(app: FastAPI) -> None:+ """Override the OSS /api/v1/users/me endpoint with SAAS version.++ This removes the base OSS endpoint and registers the SAAS version+ which includes organization context (org_id, org_name, role, permissions).++ Must be called after the app is created in saas_server.py.+ """+ # Find and remove the OSS /api/v1/users/me route+ routes_to_remove = []+ for route in app.routes:+ if hasattr(route, 'path') and route.path == '/api/v1/users/me':+ routes_to_remove.append(route)++ for route in routes_to_remove:+ app.routes.remove(route)+ _logger.debug('Removed OSS route: %s', route.path)++ # Add the SAAS version+ app.include_router(saas_users_v1_router)+ _logger.debug('Added SAAS /api/v1/users/me endpoint')diff --git a/enterprise/tests/unit/server/auth/__init__.py b/enterprise/tests/unit/server/auth/__init__.pynew file mode 100644index 0000000000..e69de29bb2diff --git a/enterprise/tests/unit/server/auth/test_saas_user_auth_org_info.py b/enterprise/tests/unit/server/auth/test_saas_user_auth_org_info.pynew file mode 100644index 0000000000..9644f312c8--- /dev/null+++ b/enterprise/tests/unit/server/auth/test_saas_user_auth_org_info.py@@ -0,0 +1,351 @@+"""Unit tests for SaasUserAuth.get_org_info() using SQLite in-memory database.++These tests exercise the real `get_org_info()` implementation with actual DB queries+to catch regressions in the SAAS org lookup logic.+"""++import uuid+from unittest.mock import patch++import pytest+from pydantic import SecretStr+from server.auth.saas_user_auth import SaasUserAuth+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine+from sqlalchemy.pool import StaticPool+from storage.base import Base+from storage.org import Org+from storage.org_member import OrgMember+from storage.role import Role+from storage.user import User+++async def async_engine():+ """Create an async SQLite engine for testing."""+ engine = create_async_engine(+ 'sqlite+aiosqlite:///:memory:',+ poolclass=StaticPool,+ connect_args={'check_same_thread': False},+ )+ return engine+++async def async_session_maker(async_engine):+ """Create an async session maker bound to the async engine."""+ session_maker = async_sessionmaker(+ bind=async_engine,+ class_=AsyncSession,+ expire_on_commit=False,+ )+ async with async_engine.begin() as conn:+ await conn.run_sync(Base.metadata.create_all)+ return session_maker+++def user_id():+ """Generate a unique user ID for tests."""+ return str(uuid.uuid4())+++def org_id():+ """Generate a unique org ID for tests."""+ return uuid.uuid4()+++async def create_role(session_maker, name: str, rank: int) -> Role:+ """Helper to create a role in the test database."""+ async with session_maker() as session:+ role = Role(name=name, rank=rank)+ session.add(role)+ await session.commit()+ await session.refresh(role)+ return role+++async def create_org(session_maker, org_id: uuid.UUID, name: str) -> Org:+ """Helper to create an org in the test database."""+ async with session_maker() as session:+ org = Org(+ id=org_id,+ name=name,+ org_version=1,+ enable_default_condenser=True,+ enable_proactive_conversation_starters=True,+ )+ session.add(org)+ await session.commit()+ await session.refresh(org)+ return org+++async def create_user(session_maker, user_id: str, current_org_id: uuid.UUID) -> User:+ """Helper to create a user in the test database."""+ async with session_maker() as session:+ user = User(+ id=uuid.UUID(user_id),+ current_org_id=current_org_id,+ user_consents_to_analytics=True,+ )+ session.add(user)+ await session.commit()+ await session.refresh(user)+ return user+++async def create_org_member(+ session_maker,+ org_id: uuid.UUID,+ user_id: str,+ role_id: int,+ status: str = 'active',+ llm_api_key: str = 'test-api-key',+) -> OrgMember:+ """Helper to create an org member in the test database."""+ async with session_maker() as session:+ org_member = OrgMember(+ org_id=org_id,+ user_id=uuid.UUID(user_id),+ role_id=role_id,+ status=status,+ llm_api_key=llm_api_key,+ )+ session.add(org_member)+ await session.commit()+ await session.refresh(org_member)+ return org_member+++class TestGetOrgInfoWithRealDB:+ """Tests for get_org_info() using in-memory SQLite database."""++ @pytest.mark.asyncio+ async def test_get_org_info_returns_correct_data_for_owner(+ self, async_session_maker, user_id, org_id+ ):+ """Test that get_org_info returns correct data for an owner role."""+ # Set up test data+ owner_role = await create_role(async_session_maker, 'owner', 1)+ await create_org(async_session_maker, org_id, 'Test Organization')+ await create_user(async_session_maker, user_id, org_id)+ await create_org_member(async_session_maker, org_id, user_id, owner_role.id)++ # Create SaasUserAuth instance+ user_auth = SaasUserAuth(+ user_id=user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ # Patch the global a_session_maker in all stores that use it+ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ org_info = await user_auth.get_org_info()++ assert org_info is not None+ assert org_info['org_id'] == str(org_id)+ assert org_info['org_name'] == 'Test Organization'+ assert org_info['role'] == 'owner'+ assert isinstance(org_info['permissions'], list)+ # Owner should have many permissions+ assert len(org_info['permissions']) > 0+ assert 'manage_secrets' in org_info['permissions']++ @pytest.mark.asyncio+ async def test_get_org_info_returns_correct_data_for_member(+ self, async_session_maker, user_id, org_id+ ):+ """Test that get_org_info returns correct data for a member role."""+ # Set up test data+ member_role = await create_role(async_session_maker, 'member', 3)+ await create_org(async_session_maker, org_id, 'Member Org')+ await create_user(async_session_maker, user_id, org_id)+ await create_org_member(async_session_maker, org_id, user_id, member_role.id)++ user_auth = SaasUserAuth(+ user_id=user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ org_info = await user_auth.get_org_info()++ assert org_info is not None+ assert org_info['org_id'] == str(org_id)+ assert org_info['org_name'] == 'Member Org'+ assert org_info['role'] == 'member'+ # Member should have limited permissions+ assert isinstance(org_info['permissions'], list)++ @pytest.mark.asyncio+ async def test_get_org_info_returns_correct_data_for_admin(+ self, async_session_maker, user_id, org_id+ ):+ """Test that get_org_info returns correct data for an admin role."""+ # Set up test data+ admin_role = await create_role(async_session_maker, 'admin', 2)+ await create_org(async_session_maker, org_id, 'Admin Org')+ await create_user(async_session_maker, user_id, org_id)+ await create_org_member(async_session_maker, org_id, user_id, admin_role.id)++ user_auth = SaasUserAuth(+ user_id=user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ org_info = await user_auth.get_org_info()++ assert org_info is not None+ assert org_info['org_id'] == str(org_id)+ assert org_info['org_name'] == 'Admin Org'+ assert org_info['role'] == 'admin'+ assert isinstance(org_info['permissions'], list)++ @pytest.mark.asyncio+ async def test_get_org_info_returns_none_when_user_not_found(+ self, async_session_maker+ ):+ """Test that get_org_info returns None when user doesn't exist."""+ nonexistent_user_id = str(uuid.uuid4())++ user_auth = SaasUserAuth(+ user_id=nonexistent_user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ org_info = await user_auth.get_org_info()++ assert org_info is None++ @pytest.mark.asyncio+ async def test_get_org_info_returns_none_when_org_not_found(+ self, async_session_maker, user_id+ ):+ """Test that get_org_info returns None when user's org doesn't exist."""+ nonexistent_org_id = uuid.uuid4()++ # Create user pointing to nonexistent org+ async with async_session_maker() as session:+ user = User(+ id=uuid.UUID(user_id),+ current_org_id=nonexistent_org_id,+ user_consents_to_analytics=True,+ )+ session.add(user)+ await session.commit()++ user_auth = SaasUserAuth(+ user_id=user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ org_info = await user_auth.get_org_info()++ assert org_info is None++ @pytest.mark.asyncio+ async def test_get_org_info_caches_result(+ self, async_session_maker, user_id, org_id+ ):+ """Test that get_org_info caches the result and doesn't hit DB twice."""+ # Set up test data+ owner_role = await create_role(async_session_maker, 'owner', 1)+ await create_org(async_session_maker, org_id, 'Cached Org')+ await create_user(async_session_maker, user_id, org_id)+ await create_org_member(async_session_maker, org_id, user_id, owner_role.id)++ user_auth = SaasUserAuth(+ user_id=user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ # First call+ org_info1 = await user_auth.get_org_info()+ assert org_info1 is not None+ assert user_auth._org_info_loaded is True++ # Second call should return cached result+ org_info2 = await user_auth.get_org_info()+ assert org_info2 is not None+ assert org_info1 == org_info2++ @pytest.mark.asyncio+ async def test_get_org_info_caches_none_result(self, async_session_maker):+ """Test that get_org_info caches None result for nonexistent user."""+ nonexistent_user_id = str(uuid.uuid4())++ user_auth = SaasUserAuth(+ user_id=nonexistent_user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ # First call+ org_info1 = await user_auth.get_org_info()+ assert org_info1 is None+ assert user_auth._org_info_loaded is True++ # Second call should return cached None without hitting DB+ org_info2 = await user_auth.get_org_info()+ assert org_info2 is None++ @pytest.mark.asyncio+ async def test_get_org_info_with_unknown_role_returns_empty_permissions(+ self, async_session_maker, user_id, org_id+ ):+ """Test that get_org_info returns empty permissions for unknown role."""+ # Create a custom role that isn't in the ROLE_PERMISSIONS mapping+ custom_role = await create_role(async_session_maker, 'custom_role', 99)+ await create_org(async_session_maker, org_id, 'Custom Org')+ await create_user(async_session_maker, user_id, org_id)+ await create_org_member(async_session_maker, org_id, user_id, custom_role.id)++ user_auth = SaasUserAuth(+ user_id=user_id,+ refresh_token=SecretStr('mock_refresh_token'),+ )++ with patch('storage.user_store.a_session_maker', async_session_maker), patch(+ 'storage.org_store.a_session_maker', async_session_maker+ ), patch(+ 'storage.org_member_store.a_session_maker', async_session_maker+ ), patch('storage.role_store.a_session_maker', async_session_maker):+ org_info = await user_auth.get_org_info()++ assert org_info is not None+ assert org_info['org_id'] == str(org_id)+ assert org_info['role'] == 'custom_role'+ # Unknown roles should have empty permissions+ assert org_info['permissions'] == []diff --git a/enterprise/tests/unit/server/routes/test_users_v1.py b/enterprise/tests/unit/server/routes/test_users_v1.pynew file mode 100644index 0000000000..3881f377ac--- /dev/null+++ b/enterprise/tests/unit/server/routes/test_users_v1.py@@ -0,0 +1,283 @@+"""Unit tests for SAAS-specific /api/v1/users endpoints.++Tests:+- SaasUserInfo model with org fields+- get_current_user_saas endpoint with org info+- _get_org_info_from_context helper function+"""++from unittest.mock import AsyncMock, MagicMock++import pytest+++class TestSaasUserInfoModel:+ """Test suite for SaasUserInfo model."""++ def test_saas_user_info_with_all_org_fields(self):+ """SaasUserInfo should accept all org-related fields."""+ from server.models.user_models import SaasUserInfo++ user_info = SaasUserInfo(+ id='user-123',+ org_id='org-456',+ org_name='Test Organization',+ role='admin',+ permissions=['read', 'write', 'delete'],+ )++ assert user_info.id == 'user-123'+ assert user_info.org_id == 'org-456'+ assert user_info.org_name == 'Test Organization'+ assert user_info.role == 'admin'+ assert user_info.permissions == ['read', 'write', 'delete']++ def test_saas_user_info_without_org_fields(self):+ """SaasUserInfo should work without org fields (fallback mode)."""+ from server.models.user_models import SaasUserInfo++ user_info = SaasUserInfo(id='user-123')++ assert user_info.id == 'user-123'+ assert user_info.org_id is None+ assert user_info.org_name is None+ assert user_info.role is None+ assert user_info.permissions is None++ def test_saas_user_info_with_partial_org_fields(self):+ """SaasUserInfo should handle partial org fields (e.g., role is None)."""+ from server.models.user_models import SaasUserInfo++ user_info = SaasUserInfo(+ id='user-123',+ org_id='org-456',+ org_name='Test Organization',+ role=None,+ permissions=[],+ )++ assert user_info.org_id == 'org-456'+ assert user_info.org_name == 'Test Organization'+ assert user_info.role is None+ assert user_info.permissions == []++ def test_saas_user_info_model_dump_includes_org_fields(self):+ """SaasUserInfo model_dump should include org fields."""+ from server.models.user_models import SaasUserInfo++ user_info = SaasUserInfo(+ id='user-123',+ org_id='org-456',+ org_name='Test Organization',+ role='member',+ permissions=['read'],+ )++ data = user_info.model_dump()+ assert data['org_id'] == 'org-456'+ assert data['org_name'] == 'Test Organization'+ assert data['role'] == 'member'+ assert data['permissions'] == ['read']++ def test_saas_user_info_extends_base_user_info(self):+ """SaasUserInfo should inherit from UserInfo base class."""+ from server.models.user_models import SaasUserInfo++ from openhands.app_server.user.user_models import UserInfo++ assert issubclass(SaasUserInfo, UserInfo)+++class TestGetOrgInfoFromContext:+ """Test suite for _get_org_info_from_context helper function."""++ @pytest.mark.asyncio+ async def test_returns_org_info_from_saas_user_auth(self):+ """Should return org info when context has SaasUserAuth."""+ from server.auth.saas_user_auth import SaasUserAuth+ from server.routes.users_v1 import _get_org_info_from_context++ from openhands.app_server.user.auth_user_context import AuthUserContext++ # Create a SaasUserAuth with mocked get_org_info+ mock_user_auth = MagicMock(spec=SaasUserAuth)+ mock_user_auth.get_org_info = AsyncMock(+ return_value={+ 'org_id': 'org-456',+ 'org_name': 'Test Organization',+ 'role': 'admin',+ 'permissions': ['read', 'write'],+ }+ )++ # Create AuthUserContext with the mock+ context = MagicMock(spec=AuthUserContext)+ context.user_auth = mock_user_auth++ org_info = await _get_org_info_from_context(context)++ assert org_info is not None+ assert org_info['org_id'] == 'org-456'+ assert org_info['org_name'] == 'Test Organization'+ assert org_info['role'] == 'admin'+ mock_user_auth.get_org_info.assert_called_once()++ @pytest.mark.asyncio+ async def test_returns_none_for_non_auth_user_context(self):+ """Should return None when context is not AuthUserContext."""+ from server.routes.users_v1 import _get_org_info_from_context++ from openhands.app_server.user.user_context import UserContext++ # Create a non-AuthUserContext+ mock_context = MagicMock(spec=UserContext)++ org_info = await _get_org_info_from_context(mock_context)++ assert org_info is None++ @pytest.mark.asyncio+ async def test_returns_none_for_non_saas_user_auth(self):+ """Should return None when user_auth is not SaasUserAuth."""+ from server.routes.users_v1 import _get_org_info_from_context++ from openhands.app_server.user.auth_user_context import AuthUserContext+ from openhands.server.user_auth.user_auth import UserAuth++ # Create AuthUserContext with a non-SaasUserAuth+ mock_user_auth = MagicMock(spec=UserAuth)+ mock_context = MagicMock(spec=AuthUserContext)+ mock_context.user_auth = mock_user_auth++ org_info = await _get_org_info_from_context(mock_context)++ assert org_info is None+++class TestGetCurrentUserSaasEndpoint:+ """Test suite for get_current_user_saas endpoint."""++ @pytest.fixture+ def mock_user_context(self):+ """Create a mock user context."""+ return AsyncMock()++ @pytest.mark.asyncio+ async def test_endpoint_returns_saas_user_info_with_org_fields(+ self, mock_user_context+ ):+ """Endpoint should return SaasUserInfo with org fields."""+ from unittest.mock import patch++ from server.models.user_models import SaasUserInfo+ from server.routes.users_v1 import get_current_user_saas++ from openhands.app_server.user.user_models import UserInfo++ # Mock base user info+ base_user_info = UserInfo(id='user-123', llm_model='test-model')+ mock_user_context.get_user_info = AsyncMock(return_value=base_user_info)++ # Mock _get_org_info_from_context to return org info+ org_info = {+ 'org_id': 'org-456',+ 'org_name': 'Test Organization',+ 'role': 'member',+ 'permissions': ['read', 'write'],+ }++ with patch(+ 'server.routes.users_v1._get_org_info_from_context',+ return_value=org_info,+ ):+ result = await get_current_user_saas(+ user_context=mock_user_context, expose_secrets=False+ )++ assert isinstance(result, SaasUserInfo)+ assert result.id == 'user-123'+ assert result.org_id == 'org-456'+ assert result.org_name == 'Test Organization'+ assert result.role == 'member'+ assert result.permissions == ['read', 'write']++ @pytest.mark.asyncio+ async def test_endpoint_returns_saas_user_info_without_org_fields(+ self, mock_user_context+ ):+ """Endpoint should work when org info is not available."""+ from unittest.mock import patch++ from server.models.user_models import SaasUserInfo+ from server.routes.users_v1 import get_current_user_saas++ from openhands.app_server.user.user_models import UserInfo++ # Mock base user info+ base_user_info = UserInfo(id='user-123', llm_model='test-model')+ mock_user_context.get_user_info = AsyncMock(return_value=base_user_info)++ # Mock _get_org_info_from_context to return None+ with patch(+ 'server.routes.users_v1._get_org_info_from_context',+ return_value=None,+ ):+ result = await get_current_user_saas(+ user_context=mock_user_context, expose_secrets=False+ )++ assert isinstance(result, SaasUserInfo)+ assert result.id == 'user-123'+ assert result.org_id is None+ assert result.org_name is None+ assert result.role is None+ assert result.permissions is None++ @pytest.mark.asyncio+ async def test_endpoint_raises_401_when_user_info_is_none(self, mock_user_context):+ """Endpoint should raise 401 when user info is None."""+ from fastapi import HTTPException+ from server.routes.users_v1 import get_current_user_saas++ mock_user_context.get_user_info = AsyncMock(return_value=None)++ with pytest.raises(HTTPException) as exc_info:+ await get_current_user_saas(+ user_context=mock_user_context, expose_secrets=False+ )++ assert exc_info.value.status_code == 401+ assert exc_info.value.detail == 'Not authenticated'+++class TestOverrideUsersEndpoint:+ """Test suite for override_users_me_endpoint function."""++ def test_override_removes_oss_route_and_adds_saas_route(self):+ """override_users_me_endpoint should remove OSS route and add SAAS route."""+ from fastapi import FastAPI+ from server.routes.users_v1 import override_users_me_endpoint++ # Create a minimal app with a mock OSS route+ app = FastAPI()++ @app.get('/api/v1/users/me')+ def mock_oss_endpoint():+ return {'source': 'oss'}++ # Verify OSS route exists+ oss_routes = [+ r for r in app.routes if hasattr(r, 'path') and r.path == '/api/v1/users/me'+ ]+ assert len(oss_routes) == 1+ assert oss_routes[0].endpoint.__name__ == 'mock_oss_endpoint'++ # Apply the override+ override_users_me_endpoint(app)++ # Verify SAAS route exists and OSS route is gone+ saas_routes = [+ r for r in app.routes if hasattr(r, 'path') and r.path == '/api/v1/users/me'+ ]+ assert len(saas_routes) == 1+ assert saas_routes[0].endpoint.__name__ == 'get_current_user_saas'diff --git a/openhands/app_server/sandbox/session_auth.py b/openhands/app_server/sandbox/session_auth.pyindex 5ae7f418b6..e327e03b3a 100644--- a/openhands/app_server/sandbox/session_auth.py+++ b/openhands/app_server/sandbox/session_auth.py@@ -10,7 +10,10 @@ look up sandboxes across all users by session key, but the session keyitself acts as the proof of access."""+from __future__ import annotations+import logging+from typing import TYPE_CHECKINGfrom fastapi import HTTPException, status@@ -20,6 +23,9 @@ from openhands.app_server.services.injector import InjectorStatefrom openhands.app_server.user.specifiy_user_context import ADMIN, USER_CONTEXT_ATTRfrom openhands.server.types import AppMode+if TYPE_CHECKING:+ from openhands.app_server.user.user_context import UserContext+_logger = logging.getLogger(__name__)@@ -64,3 +70,42 @@ async def validate_session_key(session_api_key: str | None) -> SandboxInfo:)return sandbox_info+++async def validate_session_key_ownership(+ user_context: UserContext,+ session_api_key: str | None,+) -> None:+ """Validate session key and verify it belongs to a sandbox owned by the caller.++ This combines session key validation with ownership verification, ensuring+ the session key is valid AND belongs to a sandbox owned by the authenticated user.++ Args:+ user_context: The authenticated user's context.+ session_api_key: The session API key to validate.++ Raises:+ HTTPException(401): if the key is missing, invalid, or user cannot be determined.+ HTTPException(403): if the sandbox is owned by a different user.+ """+ sandbox_info = await validate_session_key(session_api_key)++ # Verify the sandbox is owned by the authenticated user.+ caller_id = await user_context.get_user_id()+ if not caller_id:+ raise HTTPException(+ status.HTTP_401_UNAUTHORIZED,+ detail='Cannot determine authenticated user',+ )++ if sandbox_info.created_by_user_id != caller_id:+ _logger.warning(+ 'Session key user mismatch: sandbox owner=%s, caller=%s',+ sandbox_info.created_by_user_id,+ caller_id,+ )+ raise HTTPException(+ status.HTTP_403_FORBIDDEN,+ detail='Session API key does not belong to the authenticated user',+ )diff --git a/openhands/app_server/user/user_router.py b/openhands/app_server/user/user_router.pyindex c09d55c1db..461bb3d27d 100644--- a/openhands/app_server/user/user_router.py+++ b/openhands/app_server/user/user_router.py@@ -1,19 +1,15 @@"""User router for OpenHands App Server. For the moment, this simply implements the /me endpoint."""-import logging-from fastapi import APIRouter, Header, HTTPException, Query, statusfrom fastapi.responses import JSONResponsefrom openhands.app_server.config import depends_user_context-from openhands.app_server.sandbox.session_auth import validate_session_key+from openhands.app_server.sandbox.session_auth import validate_session_key_ownershipfrom openhands.app_server.user.user_context import UserContextfrom openhands.app_server.user.user_models import UserInfofrom openhands.app_server.utils.dependencies import get_dependenciesfrom openhands.integrations.service_types import UserGitInfo-_logger = logging.getLogger(__name__)-# We use the get_dependencies method here to signal to the OpenAPI docs that this endpoint# is protected. The actual protection is provided by SetAuthCookieMiddlewarerouter = APIRouter(prefix='/users', tags=['User'], dependencies=get_dependencies())@@ -38,7 +34,7 @@ async def get_current_user(if user is None:raise HTTPException(status.HTTP_401_UNAUTHORIZED, detail='Not authenticated')if expose_secrets:- await _validate_session_key_ownership(user_context, x_session_api_key)+ await validate_session_key_ownership(user_context, x_session_api_key)return JSONResponse( # type: ignore[return-value]content=user.model_dump(mode='json', context={'expose_secrets': True}))@@ -54,34 +50,3 @@ async def get_current_user_git_info(if user is None:raise HTTPException(status.HTTP_401_UNAUTHORIZED, detail='Not authenticated')return user---async def _validate_session_key_ownership(- user_context: UserContext,- session_api_key: str | None,-) -> None:- """Verify the session key belongs to a sandbox owned by the caller.-- Raises ``HTTPException`` if the key is missing, invalid, or belongs- to a sandbox owned by a different user.- """- sandbox_info = await validate_session_key(session_api_key)-- # Verify the sandbox is owned by the authenticated user.- caller_id = await user_context.get_user_id()- if not caller_id:- raise HTTPException(- status.HTTP_401_UNAUTHORIZED,- detail='Cannot determine authenticated user',- )-- if sandbox_info.created_by_user_id != caller_id:- _logger.warning(- 'Session key user mismatch: sandbox owner=%s, caller=%s',- sandbox_info.created_by_user_id,- caller_id,- )- raise HTTPException(- status.HTTP_403_FORBIDDEN,- detail='Session API key does not belong to the authenticated user',- )diff --git a/tests/unit/app_server/test_sandbox_secrets_router.py b/tests/unit/app_server/test_sandbox_secrets_router.pyindex 5d9543f34e..02b7875d6b 100644--- a/tests/unit/app_server/test_sandbox_secrets_router.py+++ b/tests/unit/app_server/test_sandbox_secrets_router.py@@ -25,13 +25,13 @@ from openhands.app_server.sandbox.sandbox_router import (get_secret_value,list_secret_names,)-from openhands.app_server.sandbox.session_auth import validate_session_key+from openhands.app_server.sandbox.session_auth import (+ validate_session_key,+ validate_session_key_ownership,+)from openhands.app_server.user.auth_user_context import AuthUserContextfrom openhands.app_server.user.user_models import UserInfo-from openhands.app_server.user.user_router import (- _validate_session_key_ownership,- get_current_user,-)+from openhands.app_server.user.user_router import get_current_userfrom openhands.integrations.provider import ProviderHandler, ProviderTokenfrom openhands.integrations.service_types import ProviderTypefrom openhands.sdk.secret import StaticSecret@@ -165,7 +165,7 @@ class TestGetCurrentUserExposeSecrets:mock_context.get_user_id = AsyncMock(return_value=USER_ID)with patch(- 'openhands.app_server.user.user_router._validate_session_key_ownership'+ 'openhands.app_server.user.user_router.validate_session_key_ownership') as mock_validate:mock_validate.return_value = Noneresult = await get_current_user(@@ -187,7 +187,7 @@ class TestGetCurrentUserExposeSecrets:mock_context = AsyncMock()with pytest.raises(HTTPException) as exc_info:- await _validate_session_key_ownership(mock_context, session_api_key=None)+ await validate_session_key_ownership(mock_context, session_api_key=None)assert exc_info.value.status_code == 401assert 'X-Session-API-Key' in exc_info.value.detail@@ -203,7 +203,7 @@ class TestGetCurrentUserExposeSecrets:mock_get.return_value.__aenter__ = AsyncMock(return_value=mock_svc)mock_get.return_value.__aexit__ = AsyncMock(return_value=False)- await _validate_session_key_ownership(+ await validate_session_key_ownership(mock_context, session_api_key='stolen-key')@@ -221,7 +221,7 @@ class TestGetCurrentUserExposeSecrets:mock_get.return_value.__aenter__ = AsyncMock(return_value=mock_svc)mock_get.return_value.__aexit__ = AsyncMock(return_value=False)- await _validate_session_key_ownership(+ await validate_session_key_ownership(mock_context, session_api_key='some-key')@@ -403,7 +403,7 @@ def _build_integration_test_app(The ``depends_user_context`` dependency is overridden with a mock, but thesession key validation logic in ``validate_session_key`` and- ``_validate_session_key_ownership`` runs unmodified.+ ``validate_session_key_ownership`` runs unmodified.Router-level dependencies (e.g. ``check_session_api_key`` from ``SESSION_API_KEY``env var) are overridden to no-ops so we can exercise the endpoint-level auth logic@@ -436,7 +436,7 @@ class TestExposeSecretsIntegration:These tests exercise the full auth validation stack:- validate_session_key (real)- - _validate_session_key_ownership (real)+ - validate_session_key_ownership (real)- ownership check (real)Only the data layer (sandbox service lookup, user context) is mocked."""