Skip to content

πŸ™Œ 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.py
index 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: E402
from server.routes.service import service_router # noqa: E402
from server.routes.user import saas_user_router # noqa: E402
from 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: E402
router as shared_conversation_router,
)
@@ -123,6 +126,10 @@ base_app.include_router(
# This must happen after all routers are included
override_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 management
base_app.include_router(invitation_accept_router) # Add route for accepting invitations
add_github_proxy_routes(base_app)
diff --git a/enterprise/server/auth/saas_user_auth.py b/enterprise/server/auth/saas_user_auth.py
index 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_HOST
from server.auth.token_manager import TokenManager
from server.config import get_config
@@ -23,10 +27,12 @@ from sqlalchemy import delete, select
from storage.api_key_store import ApiKeyStore
from storage.auth_tokens import AuthTokens
from storage.database import a_session_maker
+from storage.org_store import OrgStore
from storage.saas_secrets_store import SaasSecretsStore
from storage.saas_settings_store import SaasSettingsStore
from storage.user_authorization import UserAuthorizationType
from storage.user_authorization_store import UserAuthorizationStore
+from storage.user_store import UserStore
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_fixed
from 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 auth
api_key_id: int | None = None
api_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 = False
def 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
+
@classmethod
async 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__.py
new file mode 100644
index 0000000000..54d33320ac
--- /dev/null
+++ b/enterprise/server/models/__init__.py
@@ -0,0 +1 @@
+# Enterprise server models
diff --git a/enterprise/server/models/user_models.py b/enterprise/server/models/user_models.py
new file mode 100644
index 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 = None
diff --git a/enterprise/server/routes/users_v1.py b/enterprise/server/routes/users_v1.py
new file mode 100644
index 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__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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 key
itself acts as the proof of access.
"""
+from __future__ import annotations
+
import logging
+from typing import TYPE_CHECKING
from fastapi import HTTPException, status
@@ -20,6 +23,9 @@ from openhands.app_server.services.injector import InjectorState
from openhands.app_server.user.specifiy_user_context import ADMIN, USER_CONTEXT_ATTR
from 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.py
index 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, status
from fastapi.responses import JSONResponse
from 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_ownership
from openhands.app_server.user.user_context import UserContext
from openhands.app_server.user.user_models import UserInfo
from openhands.app_server.utils.dependencies import get_dependencies
from 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 SetAuthCookieMiddleware
router = 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.py
index 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 AuthUserContext
from 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_user
from openhands.integrations.provider import ProviderHandler, ProviderToken
from openhands.integrations.service_types import ProviderType
from 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 = None
result = 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 == 401
assert '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 the
session 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.
"""