π OpenHands: AI-Driven Development
fix(backend): add organization filtering to V1 conversation queries (#12923)
Hiep Le2aabe2ed8c4e
diff --git a/enterprise/server/utils/saas_app_conversation_info_injector.py b/enterprise/server/utils/saas_app_conversation_info_injector.pyindex 31f0c633c4..51d857aba1 100644--- a/enterprise/server/utils/saas_app_conversation_info_injector.py+++ b/enterprise/server/utils/saas_app_conversation_info_injector.py@@ -22,11 +22,63 @@ from openhands.app_server.app_conversation.app_conversation_models import (from openhands.app_server.app_conversation.sql_app_conversation_info_service import (SQLAppConversationInfoService,)+from openhands.app_server.errors import AuthErrorfrom openhands.app_server.services.injector import InjectorStateclass SaasSQLAppConversationInfoService(SQLAppConversationInfoService):- """Extended SQLAppConversationInfoService with user-based filtering and SAAS metadata handling."""+ """Extended SQLAppConversationInfoService with user and organization-based filtering and SAAS metadata handling."""++ async def _get_current_user(self) -> User | None:+ """Get the current user using the existing db_session.++ Uses self.db_session to avoid opening a separate database session.++ Returns:+ User object or None if no user_id is available+ """+ user_id_str = await self.user_context.get_user_id()+ if not user_id_str:+ return None++ user_id_uuid = UUID(user_id_str)+ result = await self.db_session.execute(+ select(User).where(User.id == user_id_uuid)+ )+ return result.scalars().first()++ async def _apply_user_and_org_filter(self, query):+ """Apply user_id and org_id filters to ensure conversation isolation.++ Filters conversations by:+ - user_id: Only show conversations belonging to the current user+ - org_id: Only show conversations belonging to the user's current organization++ Args:+ query: SQLAlchemy query to apply filters to++ Returns:+ Query with user and organization filters applied++ Raises:+ AuthError: If no user_id is available (secure default: deny access)+ """+ user_id_str = await self.user_context.get_user_id()+ if not user_id_str:+ # Secure default: no user means no access, not "show everything"+ raise AuthError('User authentication required')++ user_id_uuid = UUID(user_id_str)+ query = query.where(StoredConversationMetadataSaas.user_id == user_id_uuid)++ # Filter by organization ID to ensure conversations are isolated per organization+ user = await self._get_current_user()+ if user and user.current_org_id is not None:+ query = query.where(+ StoredConversationMetadataSaas.org_id == user.current_org_id+ )++ return queryasync def _secure_select(self):query = (@@ -38,13 +90,7 @@ class SaasSQLAppConversationInfoService(SQLAppConversationInfoService):).where(StoredConversationMetadata.conversation_version == 'V1'))-- user_id_str = await self.user_context.get_user_id()- if user_id_str:- user_id_uuid = UUID(user_id_str)- query = query.where(StoredConversationMetadataSaas.user_id == user_id_uuid)-- return query+ return await self._apply_user_and_org_filter(query)async def _secure_select_with_saas_metadata(self):"""Select query that includes SAAS metadata for retrieving user_id."""@@ -57,13 +103,7 @@ class SaasSQLAppConversationInfoService(SQLAppConversationInfoService):).where(StoredConversationMetadata.conversation_version == 'V1'))-- user_id_str = await self.user_context.get_user_id()- if user_id_str:- user_id_uuid = UUID(user_id_str)- query = query.where(StoredConversationMetadataSaas.user_id == user_id_uuid)-- return query+ return await self._apply_user_and_org_filter(query)async def search_app_conversation_info(self,@@ -155,21 +195,16 @@ class SaasSQLAppConversationInfoService(SQLAppConversationInfoService):"""Count conversations matching the given filters with SAAS metadata."""query = (select(func.count(StoredConversationMetadata.conversation_id))- .select_from(- StoredConversationMetadata.join(- StoredConversationMetadataSaas,- StoredConversationMetadata.conversation_id- == StoredConversationMetadataSaas.conversation_id,- )+ .join(+ StoredConversationMetadataSaas,+ StoredConversationMetadata.conversation_id+ == StoredConversationMetadataSaas.conversation_id,).where(StoredConversationMetadata.conversation_version == 'V1'))- # Apply user filtering- user_id_str = await self.user_context.get_user_id()- if user_id_str:- user_id_uuid = UUID(user_id_str)- query = query.where(StoredConversationMetadataSaas.user_id == user_id_uuid)+ # Apply user and organization filtering+ query = await self._apply_user_and_org_filter(query)query = self._apply_filters_with_saas_metadata(query=query,diff --git a/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.py b/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.pyindex 66827379e1..6135f870be 100644--- a/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.py+++ b/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.py@@ -10,8 +10,12 @@ from unittest.mock import AsyncMock, MagicMockfrom uuid import UUID, uuid4import pytest+from sqlalchemy import selectfrom sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_enginefrom sqlalchemy.pool import StaticPool+from storage.base import Base+from storage.org import Org+from storage.user import Userfrom enterprise.server.utils.saas_app_conversation_info_injector import (SaasSQLAppConversationInfoService,@@ -20,10 +24,15 @@ from openhands.app_server.app_conversation.app_conversation_models import (AppConversationInfo,)from openhands.app_server.user.specifiy_user_context import SpecifyUserContext-from openhands.app_server.utils.sql_utils import Basefrom openhands.integrations.service_types import ProviderTypefrom openhands.storage.data_models.conversation_metadata import ConversationTrigger+# Test UUIDs+USER1_ID = UUID('a1111111-1111-1111-1111-111111111111')+USER2_ID = UUID('b2222222-2222-2222-2222-222222222222')+ORG1_ID = UUID('c1111111-1111-1111-1111-111111111111')+ORG2_ID = UUID('d2222222-2222-2222-2222-222222222222')+@pytest.fixtureasync def async_engine():@@ -55,6 +64,41 @@ async def async_session(async_engine) -> AsyncGenerator[AsyncSession, None]:yield db_session+async def async_session_with_users(async_engine) -> AsyncGenerator[AsyncSession, None]:+ """Create an async session with pre-populated Org and User rows for testing."""+ async_session_maker = async_sessionmaker(+ async_engine, class_=AsyncSession, expire_on_commit=False+ )++ async with async_session_maker() as db_session:+ # Insert Orgs first (required for User foreign key)+ org1 = Org(+ id=ORG1_ID,+ name='test-org-1',+ enable_default_condenser=True,+ enable_proactive_conversation_starters=True,+ )+ org2 = Org(+ id=ORG2_ID,+ name='test-org-2',+ enable_default_condenser=True,+ enable_proactive_conversation_starters=True,+ )+ db_session.add(org1)+ db_session.add(org2)+ await db_session.flush()++ # Insert Users+ user1 = User(id=USER1_ID, current_org_id=ORG1_ID)+ user2 = User(id=USER2_ID, current_org_id=ORG2_ID)+ db_session.add(user1)+ db_session.add(user2)+ await db_session.commit()++ yield db_session++@pytest.fixturedef service(async_session) -> SaasSQLAppConversationInfoService:"""Create a SQLAppConversationInfoService instance for testing."""@@ -178,15 +222,26 @@ class TestSaasSQLAppConversationInfoService:assert user1_id != user2_id@pytest.mark.asyncio- async def test_secure_select_includes_user_filtering(+ async def test_secure_select_includes_user_and_org_filtering(self,- saas_service_user1: SaasSQLAppConversationInfoService,+ async_session_with_users: AsyncSession,):- """Test that _secure_select method includes user filtering."""- # This test verifies that the _secure_select method exists and can be called- # The actual SQL generation is tested implicitly through integration- query = await saas_service_user1._secure_select()- assert query is not None+ """Test that _secure_select method includes both user_id and org_id filtering."""+ service = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER1_ID)),+ )++ query = await service._secure_select()++ # Convert query to string to verify filters are present+ query_str = str(query.compile(compile_kwargs={'literal_binds': True}))++ # Verify user_id filter is present+ assert str(USER1_ID) in query_str or str(USER1_ID).replace('-', '') in query_str++ # Verify org_id filter is present (user1 is in org1)+ assert str(ORG1_ID) in query_str or str(ORG1_ID).replace('-', '') in query_str@pytest.mark.asyncioasync def test_to_info_with_user_id_functionality(@@ -241,100 +296,32 @@ class TestSaasSQLAppConversationInfoService:assert result.sandbox_id == 'test-sandbox'@pytest.mark.asyncio- async def test_user_isolation(+ async def test_user_isolation_different_users(self,- async_session: AsyncSession,- multiple_conversation_infos: list[AppConversationInfo],+ async_session_with_users: AsyncSession,):- """Test that user isolation works correctly."""- from unittest.mock import MagicMock-- from storage.user import User-- # Mock the database session execute method to return mock users- # This mock intercepts User queries and returns a mock user object- # with user_id and org_id the same as the user_id_uuid from the query- original_execute = async_session.execute-- async def mock_execute(query):- query_str = str(query)-- # Check if this is a User query- if '"user"' in query_str.lower() and '"user".id' in query_str.lower():- # Extract the UUID from the query parameters- # The query will have bound parameters, we need to get the UUID value- if hasattr(query, 'compile'):- try:- compiled = query.compile(compile_kwargs={'literal_binds': True})- query_with_params = str(compiled)-- # Extract UUID from the query string- import re-- # Try both formats: with dashes and without dashes- uuid_pattern_with_dashes = r'[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}'- uuid_pattern_without_dashes = r'[a-f0-9]{32}'-- uuid_match = re.search(- uuid_pattern_with_dashes, query_with_params- )- if not uuid_match:- uuid_match = re.search(- uuid_pattern_without_dashes, query_with_params- )-- if uuid_match:- user_id_str = uuid_match.group(0)- # If the UUID doesn't have dashes, add them- if len(user_id_str) == 32 and '-' not in user_id_str:- # Convert from 'a1111111111111111111111111111111' to 'a1111111-1111-1111-1111-111111111111'- user_id_str = f'{user_id_str[:8]}-{user_id_str[8:12]}-{user_id_str[12:16]}-{user_id_str[16:20]}-{user_id_str[20:]}'- user_id_uuid = UUID(user_id_str)-- # Create a mock user with user_id and org_id the same as user_id_uuid- mock_user = MagicMock(spec=User)- mock_user.id = user_id_uuid- mock_user.current_org_id = user_id_uuid-- # Create a mock result- mock_result = MagicMock()- mock_result.scalar_one_or_none.return_value = mock_user- return mock_result- except Exception:- # If there's any error in parsing, fall back to original execute- pass-- # For all other queries, use the original execute method- return await original_execute(query)-- # Apply the mock- async_session.execute = mock_execute-+ """Test that different users cannot see each other's conversations."""# Create services for different usersuser1_service = SaasSQLAppConversationInfoService(- db_session=async_session,- user_context=SpecifyUserContext(- user_id='a1111111-1111-1111-1111-111111111111'- ),+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER1_ID)),)user2_service = SaasSQLAppConversationInfoService(- db_session=async_session,- user_context=SpecifyUserContext(- user_id='b2222222-2222-2222-2222-222222222222'- ),+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER2_ID)),)# Create conversations for different usersuser1_info = AppConversationInfo(id=uuid4(),- created_by_user_id='a1111111-1111-1111-1111-111111111111',+ created_by_user_id=str(USER1_ID),sandbox_id='sandbox_user1',title='User 1 Conversation',)user2_info = AppConversationInfo(id=uuid4(),- created_by_user_id='b2222222-2222-2222-2222-222222222222',+ created_by_user_id=str(USER2_ID),sandbox_id='sandbox_user2',title='User 2 Conversation',)@@ -346,18 +333,12 @@ class TestSaasSQLAppConversationInfoService:# User 1 should only see their conversationuser1_page = await user1_service.search_app_conversation_info()assert len(user1_page.items) == 1- assert (- user1_page.items[0].created_by_user_id- == 'a1111111-1111-1111-1111-111111111111'- )+ assert user1_page.items[0].created_by_user_id == str(USER1_ID)# User 2 should only see their conversationuser2_page = await user2_service.search_app_conversation_info()assert len(user2_page.items) == 1- assert (- user2_page.items[0].created_by_user_id- == 'b2222222-2222-2222-2222-222222222222'- )+ assert user2_page.items[0].created_by_user_id == str(USER2_ID)# User 1 should not be able to get user 2's conversationuser2_from_user1 = await user1_service.get_app_conversation_info(user2_info.id)@@ -366,3 +347,142 @@ class TestSaasSQLAppConversationInfoService:# User 2 should not be able to get user 1's conversationuser1_from_user2 = await user2_service.get_app_conversation_info(user1_info.id)assert user1_from_user2 is None++ @pytest.mark.asyncio+ async def test_same_user_org_switching_isolation(+ self,+ async_session_with_users: AsyncSession,+ ):+ """Test that the same user switching orgs cannot see conversations from other orgs.++ This tests the actual bug scenario: a user creates a conversation in org1,+ then switches to org2, and should NOT see org1's conversations.+ """+ # Create service for user1 in org1+ user1_service_org1 = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER1_ID)),+ )++ # Create a conversation while user is in org1+ conv_in_org1 = AppConversationInfo(+ id=uuid4(),+ created_by_user_id=str(USER1_ID),+ sandbox_id='sandbox_org1',+ title='Conversation in Org 1',+ )+ await user1_service_org1.save_app_conversation_info(conv_in_org1)++ # Verify user can see the conversation in org1+ page_in_org1 = await user1_service_org1.search_app_conversation_info()+ assert len(page_in_org1.items) == 1+ assert page_in_org1.items[0].title == 'Conversation in Org 1'++ # Simulate user switching to org2 by updating current_org_id using ORM+ result = await async_session_with_users.execute(+ select(User).where(User.id == USER1_ID)+ )+ user_to_update = result.scalars().first()+ user_to_update.current_org_id = ORG2_ID+ await async_session_with_users.commit()+ # Clear SQLAlchemy's identity map cache to simulate a new request+ async_session_with_users.expire_all()++ # Create new service instance (simulating a new request after org switch)+ user1_service_org2 = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER1_ID)),+ )++ # User should NOT see org1's conversations after switching to org2+ page_in_org2 = await user1_service_org2.search_app_conversation_info()+ assert (+ len(page_in_org2.items) == 0+ ), 'User should not see conversations from org1 after switching to org2'++ # User should not be able to get the specific conversation from org1+ conv_from_org2 = await user1_service_org2.get_app_conversation_info(+ conv_in_org1.id+ )+ assert (+ conv_from_org2 is None+ ), 'User should not be able to access org1 conversation from org2'++ # Now create a conversation in org2+ conv_in_org2 = AppConversationInfo(+ id=uuid4(),+ created_by_user_id=str(USER1_ID),+ sandbox_id='sandbox_org2',+ title='Conversation in Org 2',+ )+ await user1_service_org2.save_app_conversation_info(conv_in_org2)++ # User should only see org2's conversation+ page_in_org2_after = await user1_service_org2.search_app_conversation_info()+ assert len(page_in_org2_after.items) == 1+ assert page_in_org2_after.items[0].title == 'Conversation in Org 2'++ # Switch back to org1 and verify isolation works both ways+ result = await async_session_with_users.execute(+ select(User).where(User.id == USER1_ID)+ )+ user_to_update = result.scalars().first()+ user_to_update.current_org_id = ORG1_ID+ await async_session_with_users.commit()+ async_session_with_users.expire_all()++ user1_service_back_to_org1 = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER1_ID)),+ )++ # User should only see org1's conversation now+ page_back_in_org1 = (+ await user1_service_back_to_org1.search_app_conversation_info()+ )+ assert len(page_back_in_org1.items) == 1+ assert page_back_in_org1.items[0].title == 'Conversation in Org 1'++ @pytest.mark.asyncio+ async def test_count_respects_org_isolation(+ self,+ async_session_with_users: AsyncSession,+ ):+ """Test that count_app_conversation_info respects org isolation."""+ # Create service for user1 in org1+ user1_service = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER1_ID)),+ )++ # Create conversations in org1+ for i in range(3):+ conv = AppConversationInfo(+ id=uuid4(),+ created_by_user_id=str(USER1_ID),+ sandbox_id=f'sandbox_org1_{i}',+ title=f'Org1 Conversation {i}',+ )+ await user1_service.save_app_conversation_info(conv)++ # Count should be 3+ count_org1 = await user1_service.count_app_conversation_info()+ assert count_org1 == 3++ # Switch to org2 using ORM+ result = await async_session_with_users.execute(+ select(User).where(User.id == USER1_ID)+ )+ user_to_update = result.scalars().first()+ user_to_update.current_org_id = ORG2_ID+ await async_session_with_users.commit()+ async_session_with_users.expire_all()++ user1_service_org2 = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=SpecifyUserContext(user_id=str(USER1_ID)),+ )++ # Count should be 0 in org2+ count_org2 = await user1_service_org2.count_app_conversation_info()+ assert count_org2 == 0