🙌 OpenHands: AI-Driven Development
feat: Add DEPLOYMENT_MODE detection for conditional onboarding (#13675)
HeyItsChloeb4b77fbc3154
diff --git a/enterprise/migrations/versions/107_add_onboarding_completed_to_user.py b/enterprise/migrations/versions/107_add_onboarding_completed_to_user.pynew file mode 100644index 0000000000..8aca4ca06f--- /dev/null+++ b/enterprise/migrations/versions/107_add_onboarding_completed_to_user.py@@ -0,0 +1,31 @@+"""Add onboarding_completed column to user table.++Tracks whether a user has completed the onboarding flow.+Used to redirect new SaaS users to /onboarding after accepting TOS.++Revision ID: 107+Revises: 106+Create Date: 2026-03-31+"""++from typing import Sequence, Union++import sqlalchemy as sa+from alembic import op++# revision identifiers, used by Alembic.+revision: str = '107'+down_revision: Union[str, None] = '106'+branch_labels: Union[str, Sequence[str], None] = None+depends_on: Union[str, Sequence[str], None] = None+++def upgrade() -> None:+ op.add_column(+ 'user',+ sa.Column('onboarding_completed', sa.Boolean(), nullable=True, default=False),+ )+++def downgrade() -> None:+ op.drop_column('user', 'onboarding_completed')diff --git a/enterprise/server/config.py b/enterprise/server/config.pyindex dbccc94a55..6e5a784715 100644--- a/enterprise/server/config.py+++ b/enterprise/server/config.py@@ -20,6 +20,7 @@ from server.auth.constants import (GITLAB_APP_CLIENT_ID,RECAPTCHA_SITE_KEY,)+from server.constants import DEPLOYMENT_MODEfrom openhands.core.config.utils import load_openhands_configfrom openhands.integrations.service_types import ProviderType@@ -179,6 +180,7 @@ class SaaSServerConfig(ServerConfig):'ENABLE_JIRA': self.enable_jira,'ENABLE_JIRA_DC': self.enable_jira_dc,'ENABLE_LINEAR': self.enable_linear,+ 'DEPLOYMENT_MODE': DEPLOYMENT_MODE,},'PROVIDERS_CONFIGURED': providers_configured,}diff --git a/enterprise/server/constants.py b/enterprise/server/constants.pyindex 4e9734c770..cc930b7c4b 100644--- a/enterprise/server/constants.py+++ b/enterprise/server/constants.py@@ -15,6 +15,33 @@ IS_FEATURE_ENV = () # Does not include the staging deploymentIS_LOCAL_ENV = bool(HOST == 'localhost')++# _is_all_hands_managed_domain() can be removed/replaced when a self-hosted specific+# env var is created (e.g is_self_hosted` or `deployment_mode`)+def _is_all_hands_managed_domain(host: str) -> bool:+ """Check if the host is an All-Hands managed domain."""+ return (+ host == 'app.all-hands.dev'+ or host == 'app.openhands.ai'+ or host.endswith('.all-hands.dev')+ or host.endswith('.openhands.ai')+ )+++def _get_deployment_mode() -> str:+ """Determine deployment mode based on WEB_HOST.++ Returns:+ 'cloud' for All-Hands managed infrastructure (app.all-hands.dev, etc.)+ 'self_hosted' for enterprise self-hosted deployments (customer domains)+ """+ if _is_all_hands_managed_domain(HOST):+ return 'cloud'+ return 'self_hosted'+++DEPLOYMENT_MODE = _get_deployment_mode()+# Role name constantsROLE_OWNER = 'owner'ROLE_ADMIN = 'admin'diff --git a/enterprise/server/routes/auth.py b/enterprise/server/routes/auth.pyindex 218ba4c2fe..6f3438a4b6 100644--- a/enterprise/server/routes/auth.py+++ b/enterprise/server/routes/auth.py@@ -27,7 +27,10 @@ from server.auth.user.user_authorizer import (depends_user_authorizer,)from server.config import sign_token-from server.constants import IS_FEATURE_ENV, IS_LOCAL_ENV+from server.constants import (+ DEPLOYMENT_MODE,+ IS_FEATURE_ENV,+)from server.routes.event_webhook import _get_session_api_key, _get_user_idfrom server.services.org_invitation_service import (EmailMismatchError,@@ -462,8 +465,20 @@ async def keycloak_callback(tos_redirect_url = f'{tos_redirect_url}&invitation_success=true'response = RedirectResponse(tos_redirect_url, status_code=302)else:+ # User has accepted TOS - check if they need onboarding+ # Only redirect to onboarding if user has a valid offline token,+ # otherwise they need to complete the Keycloak offline token flow first+ if valid_offline_token and await _should_redirect_to_onboarding(user_id, user):+ redirect_url = f'{web_url}/onboarding'+ logger.info(+ 'Redirecting returning user to onboarding',+ extra={'user_id': user_id, 'deployment_mode': DEPLOYMENT_MODE},+ )if invitation_token:- redirect_url = f'{redirect_url}&invitation_success=true'+ if '?' in redirect_url:+ redirect_url = f'{redirect_url}&invitation_success=true'+ else:+ redirect_url = f'{redirect_url}?invitation_success=true'response = RedirectResponse(redirect_url, status_code=302)set_response_cookie(@@ -471,7 +486,7 @@ async def keycloak_callback(response=response,keycloak_access_token=keycloak_access_token,keycloak_refresh_token=keycloak_refresh_token,- secure=True if redirect_url.startswith('https') else False,+ secure=True if web_url.startswith('https') else False,accepted_tos=has_accepted_tos,)@@ -512,8 +527,23 @@ async def keycloak_offline_callback(code: str, state: str, request: Request):user_id=user_info.sub, offline_token=keycloak_refresh_token)+ user = await UserStore.get_user_by_id(user_info.sub)+ has_accepted_tos = user is not None and user.accepted_tos is not None+redirect_url, _, _ = _extract_oauth_state(state)- return RedirectResponse(redirect_url if redirect_url else web_url, status_code=302)+ default_url = redirect_url if redirect_url else web_url+ final_url = await _get_post_auth_redirect(user_info.sub, default_url, web_url, user)++ response = RedirectResponse(final_url, status_code=302)+ set_response_cookie(+ request=request,+ response=response,+ keycloak_access_token=keycloak_access_token,+ keycloak_refresh_token=keycloak_refresh_token,+ secure=True if web_url.startswith('https') else False,+ accepted_tos=has_accepted_tos,+ )+ return response@oauth_router.get('/github/callback')@@ -549,6 +579,74 @@ async def authenticate(request: Request):return response+async def _should_redirect_to_onboarding(user_id: str, user: User) -> bool:+ """Check if user should be redirected to onboarding after TOS acceptance.++ Backend always redirects applicable users to /onboarding. The frontend+ checks the ENABLE_ONBOARDING feature flag (localStorage) and redirects+ to / if the flag is disabled. This avoids needing helm chart changes.+++ Returns True if:+ - User has onboarding_completed explicitly set to False (new users)+ - Either:+ - Deployment mode is 'cloud' (all users)+ - Deployment mode is 'self_hosted' AND user is the super admin+ (first owner in their current org to accept TOS)++ Returns False if:+ - User has onboarding_completed=True (already completed)+ - User has onboarding_completed=None (existing users before this feature)+ """+ # Already completed onboarding+ if user.onboarding_completed is True:+ return False++ # Existing user before this feature (NULL in database)+ if user.onboarding_completed is None:+ return False++ # Cloud SaaS: all users go to onboarding+ if DEPLOYMENT_MODE == 'cloud':+ return True++ # Self-hosted SaaS: only the super admin (first owner to accept TOS in the org)+ if DEPLOYMENT_MODE == 'self_hosted':+ first_owner = await UserStore.get_first_owner_in_org(user.current_org_id)+ if first_owner and str(first_owner.id) == user_id:+ return True++ return False+++async def _get_post_auth_redirect(+ user_id: str, default_url: str, web_url: str, user: User | None = None+) -> str:+ """Determine where to redirect user after authentication completes.++ Called after offline token is stored to determine final redirect destination.+ Checks for pending user flows (e.g., onboarding) before falling back to default.++ Args:+ user_id: The user's ID.+ default_url: The default URL to redirect to if no special flow is needed.+ web_url: The base web URL for constructing absolute paths.+ user: Optional user object to avoid refetching.++ Returns:+ The URL to redirect the user to.+ """+ if not user:+ user = await UserStore.get_user_by_id(user_id)+ if user and await _should_redirect_to_onboarding(user_id, user):+ logger.info(+ 'Redirecting user to onboarding',+ extra={'user_id': user_id, 'deployment_mode': DEPLOYMENT_MODE},+ )+ return f'{web_url}/onboarding'+ return default_url++@api_router.post('/accept_tos')async def accept_tos(request: Request):user_auth = cast(SaasUserAuth, await get_user_auth(request))@@ -589,6 +687,12 @@ async def accept_tos(request: Request):logger.info(f'User {user_id} accepted TOS')+ # Determine final redirect - but don't override if it's the offline token flow+ # (the offline callback will handle post-auth redirect after storing the token)+ is_offline_flow = 'offline' in redirect_url+ if not is_offline_flow:+ redirect_url = await _get_post_auth_redirect(user_id, redirect_url, web_url)+response = JSONResponse(status_code=status.HTTP_200_OK, content={'redirect_url': redirect_url})@@ -598,12 +702,42 @@ async def accept_tos(request: Request):response=response,keycloak_access_token=access_token.get_secret_value(),keycloak_refresh_token=refresh_token.get_secret_value(),- secure=not IS_LOCAL_ENV,+ secure=True if web_url.startswith('https') else False,accepted_tos=True,)return response+@api_router.post('/complete_onboarding')+async def complete_onboarding(request: Request):+ """Mark onboarding as completed for the current user."""+ user_auth = cast(SaasUserAuth, await get_user_auth(request))+ user_id = await user_auth.get_user_id()++ if not user_id:+ return JSONResponse(+ status_code=status.HTTP_401_UNAUTHORIZED,+ content={'error': 'User is not authenticated'},+ )++ user = await UserStore.mark_onboarding_completed(user_id)+ if not user:+ return JSONResponse(+ status_code=status.HTTP_404_NOT_FOUND,+ content={'error': 'User not found'},+ )++ logger.info(+ 'User completed onboarding',+ extra={'user_id': user_id},+ )++ return JSONResponse(+ status_code=status.HTTP_200_OK,+ content={'message': 'Onboarding completed'},+ )++@api_router.post('/logout')async def logout(request: Request):# Always create the response object first to ensure we can return it even if errors occurdiff --git a/enterprise/storage/user.py b/enterprise/storage/user.pyindex e60c3f1f6a..8214a931cb 100644--- a/enterprise/storage/user.py+++ b/enterprise/storage/user.py@@ -36,6 +36,7 @@ class User(Base): # type: ignoregit_user_email = Column(String, nullable=True)sandbox_grouping_strategy = Column(String, nullable=True)disabled_skills = Column(JSON, nullable=True)+ onboarding_completed = Column(Boolean, nullable=True, default=False)# Relationshipsrole = relationship('Role', back_populates='users')diff --git a/enterprise/storage/user_store.py b/enterprise/storage/user_store.pyindex 0bdcd2cf4e..6151f0bca2 100644--- a/enterprise/storage/user_store.py+++ b/enterprise/storage/user_store.py@@ -24,6 +24,7 @@ from storage.encrypt_utils import ()from storage.org import Orgfrom storage.org_member import OrgMember+from storage.role import Rolefrom storage.role_store import RoleStorefrom storage.user import Userfrom storage.user_settings import UserSettings@@ -749,6 +750,65 @@ class UserStore:await session.refresh(user)return user+ @staticmethod+ async def mark_onboarding_completed(user_id: str) -> Optional[User]:+ """Mark the user's onboarding as completed.++ Args:+ user_id: The user's ID (Keycloak user ID)++ Returns:+ User: The updated user object, or None if user not found+ """+ async with a_session_maker() as session:+ result = await session.execute(+ select(User).filter(User.id == uuid.UUID(user_id)).with_for_update()+ )+ user = result.scalars().first()+ if not user:+ logger.warning(+ 'mark_onboarding_completed:user_not_found',+ extra={'user_id': user_id},+ )+ return None++ user.onboarding_completed = True+ await session.commit()+ await session.refresh(user)+ logger.info(+ 'mark_onboarding_completed:success',+ extra={'user_id': user_id},+ )+ return user++ @staticmethod+ async def get_first_owner_in_org(org_id: UUID) -> Optional[User]:+ """Get the first owner in an organization who accepted the Terms of Service.++ This user is considered the super admin for that org in self-hosted deployments.+ The super admin is identified as the owner with the earliest accepted_tos timestamp.++ Args:+ org_id: The organization UUID++ Returns:+ User: The first owner to accept TOS in this org, or None if not found.+ """+ async with a_session_maker() as session:+ result = await session.execute(+ select(User)+ .join(OrgMember, OrgMember.user_id == User.id)+ .join(Role, Role.id == OrgMember.role_id)+ .filter(+ OrgMember.org_id == org_id,+ Role.name == 'owner',+ User.accepted_tos.isnot(None),+ )+ .order_by(User.accepted_tos.asc())+ .limit(1)+ )+ return result.scalars().first()+@staticmethodasync def backfill_contact_name(user_id: str, user_info: dict) -> None:"""Update contact_name on the personal org if it still has a username-style value.diff --git a/enterprise/tests/unit/server/routes/test_auth_onboarding.py b/enterprise/tests/unit/server/routes/test_auth_onboarding.pynew file mode 100644index 0000000000..76e29a9d0c--- /dev/null+++ b/enterprise/tests/unit/server/routes/test_auth_onboarding.py@@ -0,0 +1,330 @@+"""Tests for onboarding-related auth routes and functions.++Tests for:+- _should_redirect_to_onboarding() function+- _get_post_auth_redirect() function+- /complete_onboarding endpoint+"""++import uuid+from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from fastapi import Request, status+from fastapi.responses import JSONResponse+from server.auth.saas_user_auth import SaasUserAuth+from server.routes.auth import (+ _get_post_auth_redirect,+ _should_redirect_to_onboarding,+ complete_onboarding,+)+from storage.user import User++# --- Fixtures ---+++def mock_request():+ """Create a mock FastAPI Request."""+ request = MagicMock(spec=Request)+ request.url = MagicMock()+ request.url.hostname = 'localhost'+ request.url.netloc = 'localhost:8000'+ request.base_url = 'http://localhost:8000/'+ request.headers = {}+ request.cookies = {}+ return request+++def mock_user():+ """Create a mock User object."""+ user = MagicMock(spec=User)+ user.id = uuid.uuid4()+ user.current_org_id = uuid.uuid4()+ user.onboarding_completed = False+ return user+++# --- Tests for _should_redirect_to_onboarding ---+++class TestShouldRedirectToOnboarding:+ """Tests for the _should_redirect_to_onboarding function."""++ @pytest.mark.asyncio+ async def test_returns_false_when_onboarding_completed(self, mock_user):+ """Test that completed onboarding users are not redirected."""+ mock_user.onboarding_completed = True++ result = await _should_redirect_to_onboarding('user-123', mock_user)++ assert result is False++ @pytest.mark.asyncio+ async def test_returns_true_for_cloud_mode_new_user(self, mock_user):+ """Test that cloud mode users with incomplete onboarding are redirected."""+ mock_user.onboarding_completed = False++ with patch('server.routes.auth.DEPLOYMENT_MODE', 'cloud'):+ result = await _should_redirect_to_onboarding('user-123', mock_user)++ assert result is True++ @pytest.mark.asyncio+ async def test_returns_true_for_self_hosted_super_admin(self, mock_user):+ """Test that the super admin (first owner to accept TOS) is redirected."""+ mock_user.onboarding_completed = False+ user_id = str(mock_user.id)++ # Mock this user as the first owner in the org (super admin)+ first_owner = MagicMock(spec=User)+ first_owner.id = mock_user.id++ with (+ patch('server.routes.auth.DEPLOYMENT_MODE', 'self_hosted'),+ patch(+ 'server.routes.auth.UserStore.get_first_owner_in_org',+ new_callable=AsyncMock,+ return_value=first_owner,+ ),+ ):+ result = await _should_redirect_to_onboarding(user_id, mock_user)++ assert result is True++ @pytest.mark.asyncio+ async def test_returns_false_for_self_hosted_non_super_admin_owner(self, mock_user):+ """Test that owners who aren't the super admin are NOT redirected."""+ mock_user.onboarding_completed = False+ user_id = str(mock_user.id)++ # Mock a different user as the first owner (super admin)+ first_owner = MagicMock(spec=User)+ first_owner.id = uuid.uuid4() # Different user++ with (+ patch('server.routes.auth.DEPLOYMENT_MODE', 'self_hosted'),+ patch(+ 'server.routes.auth.UserStore.get_first_owner_in_org',+ new_callable=AsyncMock,+ return_value=first_owner,+ ),+ ):+ result = await _should_redirect_to_onboarding(user_id, mock_user)++ assert result is False++ @pytest.mark.asyncio+ async def test_returns_false_for_self_hosted_when_no_owner_found(self, mock_user):+ """Test that users are not redirected when no owner is found."""+ mock_user.onboarding_completed = False+ user_id = str(mock_user.id)++ with (+ patch('server.routes.auth.DEPLOYMENT_MODE', 'self_hosted'),+ patch(+ 'server.routes.auth.UserStore.get_first_owner_in_org',+ new_callable=AsyncMock,+ return_value=None,+ ),+ ):+ result = await _should_redirect_to_onboarding(user_id, mock_user)++ assert result is False++ @pytest.mark.asyncio+ async def test_passes_current_org_id_to_get_first_owner(self, mock_user):+ """Test that get_first_owner_in_org is called with user's current_org_id."""+ mock_user.onboarding_completed = False+ user_id = str(mock_user.id)+ mock_get_first_owner = AsyncMock(return_value=None)++ with (+ patch('server.routes.auth.DEPLOYMENT_MODE', 'self_hosted'),+ patch(+ 'server.routes.auth.UserStore.get_first_owner_in_org',+ mock_get_first_owner,+ ),+ ):+ await _should_redirect_to_onboarding(user_id, mock_user)++ mock_get_first_owner.assert_called_once_with(mock_user.current_org_id)+++# --- Tests for _get_post_auth_redirect ---+++class TestGetPostAuthRedirect:+ """Tests for the _get_post_auth_redirect function."""++ @pytest.mark.asyncio+ async def test_returns_onboarding_url_when_onboarding_needed(self, mock_user):+ """Test that onboarding URL is returned when user needs onboarding."""+ mock_user.onboarding_completed = False+ user_id = str(mock_user.id)++ with (+ patch('server.routes.auth.DEPLOYMENT_MODE', 'cloud'),+ patch(+ 'server.routes.auth.UserStore.get_user_by_id',+ new_callable=AsyncMock,+ return_value=mock_user,+ ),+ ):+ result = await _get_post_auth_redirect(+ user_id, 'https://example.com/', 'https://example.com'+ )++ assert result == 'https://example.com/onboarding'++ @pytest.mark.asyncio+ async def test_returns_default_url_when_onboarding_completed(self, mock_user):+ """Test that default URL is returned when user has completed onboarding."""+ mock_user.onboarding_completed = True+ user_id = str(mock_user.id)++ with patch(+ 'server.routes.auth.UserStore.get_user_by_id',+ new_callable=AsyncMock,+ return_value=mock_user,+ ):+ result = await _get_post_auth_redirect(+ user_id, 'https://example.com/dashboard', 'https://example.com'+ )++ assert result == 'https://example.com/dashboard'++ @pytest.mark.asyncio+ async def test_returns_default_url_when_user_not_found(self):+ """Test that default URL is returned when user is not found."""+ with patch(+ 'server.routes.auth.UserStore.get_user_by_id',+ new_callable=AsyncMock,+ return_value=None,+ ):+ result = await _get_post_auth_redirect(+ 'nonexistent-user', 'https://example.com/', 'https://example.com'+ )++ assert result == 'https://example.com/'++ @pytest.mark.asyncio+ async def test_logs_when_redirecting_to_onboarding(self, mock_user):+ """Test that a log message is emitted when redirecting to onboarding."""+ mock_user.onboarding_completed = False+ user_id = str(mock_user.id)++ with (+ patch('server.routes.auth.DEPLOYMENT_MODE', 'cloud'),+ patch(+ 'server.routes.auth.UserStore.get_user_by_id',+ new_callable=AsyncMock,+ return_value=mock_user,+ ),+ patch('server.routes.auth.logger') as mock_logger,+ ):+ await _get_post_auth_redirect(+ user_id, 'https://example.com/', 'https://example.com'+ )++ mock_logger.info.assert_called_once()+ call_args = mock_logger.info.call_args+ assert call_args[0][0] == 'Redirecting user to onboarding'+ assert call_args[1]['extra']['user_id'] == user_id+++# --- Tests for /complete_onboarding endpoint ---+++class TestCompleteOnboardingEndpoint:+ """Tests for the complete_onboarding API endpoint."""++ @pytest.mark.asyncio+ async def test_returns_401_when_not_authenticated(self, mock_request):+ """Test that unauthenticated requests return 401."""+ mock_user_auth = MagicMock(spec=SaasUserAuth)+ mock_user_auth.get_user_id = AsyncMock(return_value=None)++ with patch(+ 'server.routes.auth.get_user_auth',+ new_callable=AsyncMock,+ return_value=mock_user_auth,+ ):+ result = await complete_onboarding(mock_request)++ assert isinstance(result, JSONResponse)+ assert result.status_code == status.HTTP_401_UNAUTHORIZED++ @pytest.mark.asyncio+ async def test_returns_404_when_user_not_found(self, mock_request):+ """Test that request for non-existent user returns 404."""+ user_id = str(uuid.uuid4())+ mock_user_auth = MagicMock(spec=SaasUserAuth)+ mock_user_auth.get_user_id = AsyncMock(return_value=user_id)++ with (+ patch(+ 'server.routes.auth.get_user_auth',+ new_callable=AsyncMock,+ return_value=mock_user_auth,+ ),+ patch(+ 'server.routes.auth.UserStore.mark_onboarding_completed',+ new_callable=AsyncMock,+ return_value=None,+ ),+ ):+ result = await complete_onboarding(mock_request)++ assert isinstance(result, JSONResponse)+ assert result.status_code == status.HTTP_404_NOT_FOUND++ @pytest.mark.asyncio+ async def test_returns_200_on_success(self, mock_request, mock_user):+ """Test successful onboarding completion returns 200."""+ user_id = str(uuid.uuid4())+ mock_user_auth = MagicMock(spec=SaasUserAuth)+ mock_user_auth.get_user_id = AsyncMock(return_value=user_id)++ with (+ patch(+ 'server.routes.auth.get_user_auth',+ new_callable=AsyncMock,+ return_value=mock_user_auth,+ ),+ patch(+ 'server.routes.auth.UserStore.mark_onboarding_completed',+ new_callable=AsyncMock,+ return_value=mock_user,+ ),+ ):+ result = await complete_onboarding(mock_request)++ assert isinstance(result, JSONResponse)+ assert result.status_code == status.HTTP_200_OK++ @pytest.mark.asyncio+ async def test_calls_mark_onboarding_completed_with_user_id(+ self, mock_request, mock_user+ ):+ """Test that mark_onboarding_completed is called with the correct user_id."""+ user_id = str(uuid.uuid4())+ mock_user_auth = MagicMock(spec=SaasUserAuth)+ mock_user_auth.get_user_id = AsyncMock(return_value=user_id)+ mock_mark_completed = AsyncMock(return_value=mock_user)++ with (+ patch(+ 'server.routes.auth.get_user_auth',+ new_callable=AsyncMock,+ return_value=mock_user_auth,+ ),+ patch(+ 'server.routes.auth.UserStore.mark_onboarding_completed',+ mock_mark_completed,+ ),+ ):+ await complete_onboarding(mock_request)++ mock_mark_completed.assert_called_once_with(user_id)diff --git a/enterprise/tests/unit/server/test_constants.py b/enterprise/tests/unit/server/test_constants.pynew file mode 100644index 0000000000..f1deccbab9--- /dev/null+++ b/enterprise/tests/unit/server/test_constants.py@@ -0,0 +1,105 @@+"""Tests for enterprise server constants, specifically DEPLOYMENT_MODE detection."""++from unittest.mock import patch++import pytest+++class TestDeploymentMode:+ """Tests for _get_deployment_mode() and _is_all_hands_managed_domain() functions."""++ @pytest.mark.parametrize(+ 'web_host,expected_mode',+ [+ # All-Hands managed domains should return 'cloud'+ ('app.all-hands.dev', 'cloud'),+ ('staging.all-hands.dev', 'cloud'),+ ('feature-123.staging.all-hands.dev', 'cloud'),+ ('pr-456.staging.all-hands.dev', 'cloud'),+ ('app.openhands.ai', 'cloud'),+ # Customer domains should return 'self_hosted'+ ('openhands.acme.com', 'self_hosted'),+ ('internal.company.io', 'self_hosted'),+ ('dev.mycompany.net', 'self_hosted'),+ ('openhands.example.org', 'self_hosted'),+ ('localhost', 'self_hosted'), # localhost is not a managed domain+ # Edge cases+ ('all-hands.dev', 'self_hosted'), # Not a subdomain, so not managed+ ('fake-all-hands.dev', 'self_hosted'),+ ('app.all-hands.dev.evil.com', 'self_hosted'),+ ],+ )+ def test_deployment_mode_detection(self, web_host: str, expected_mode: str):+ """Test that DEPLOYMENT_MODE is correctly determined based on WEB_HOST."""+ with patch.dict('os.environ', {'WEB_HOST': web_host}):+ # Need to reimport to pick up the mocked environment variable+ import importlib++ import server.constants as constants_module++ importlib.reload(constants_module)++ assert constants_module.DEPLOYMENT_MODE == expected_mode++ @pytest.mark.parametrize(+ 'host,expected',+ [+ ('app.all-hands.dev', True),+ ('staging.all-hands.dev', True),+ ('feature.staging.all-hands.dev', True),+ ('app.openhands.ai', True),+ ('localhost', False), # localhost is not a managed domain+ ('customer.example.com', False),+ ('all-hands.dev', False),+ ],+ )+ def test_is_all_hands_managed_domain(self, host: str, expected: bool):+ """Test _is_all_hands_managed_domain() helper function."""+ from server.constants import _is_all_hands_managed_domain++ assert _is_all_hands_managed_domain(host) == expected++ def test_deployment_mode_default_is_cloud(self):+ """Test that default WEB_HOST (app.all-hands.dev) results in 'cloud' mode."""+ with patch.dict('os.environ', {}, clear=True):+ # Remove WEB_HOST to test default+ import importlib+ import os++ if 'WEB_HOST' in os.environ:+ del os.environ['WEB_HOST']++ import server.constants as constants_module++ importlib.reload(constants_module)++ # Default WEB_HOST is 'app.all-hands.dev' which should be 'cloud'+ assert constants_module.DEPLOYMENT_MODE == 'cloud'+++class TestDeploymentModeInConfig:+ """Tests for DEPLOYMENT_MODE being exposed in config API."""++ def test_deployment_mode_included_in_feature_flags(self):+ """Test that DEPLOYMENT_MODE is included in FEATURE_FLAGS from get_config()."""+ from server.config import SaaSServerConfig++ with patch('server.config.DEPLOYMENT_MODE', 'cloud'):+ saas_config = SaaSServerConfig()+ config = saas_config.get_config()++ assert 'FEATURE_FLAGS' in config+ assert 'DEPLOYMENT_MODE' in config['FEATURE_FLAGS']+ assert config['FEATURE_FLAGS']['DEPLOYMENT_MODE'] == 'cloud'++ def test_deployment_mode_self_hosted_in_feature_flags(self):+ """Test that self_hosted DEPLOYMENT_MODE is included in FEATURE_FLAGS."""+ from server.config import SaaSServerConfig++ with patch('server.config.DEPLOYMENT_MODE', 'self_hosted'):+ saas_config = SaaSServerConfig()+ config = saas_config.get_config()++ assert 'FEATURE_FLAGS' in config+ assert 'DEPLOYMENT_MODE' in config['FEATURE_FLAGS']+ assert config['FEATURE_FLAGS']['DEPLOYMENT_MODE'] == 'self_hosted'diff --git a/enterprise/tests/unit/test_auth_routes.py b/enterprise/tests/unit/test_auth_routes.pyindex 25f5aadd8e..5ebda80769 100644--- a/enterprise/tests/unit/test_auth_routes.py+++ b/enterprise/tests/unit/test_auth_routes.py@@ -187,6 +187,11 @@ async def test_keycloak_callback_success_with_valid_offline_token(patch('server.routes.auth.set_response_cookie') as mock_set_cookie,patch('server.routes.auth.UserStore') as mock_user_store,patch('server.routes.auth.posthog') as mock_posthog,+ patch(+ 'server.routes.auth._should_redirect_to_onboarding',+ new_callable=AsyncMock,+ return_value=False,+ ),):# Mock user with accepted_tosmock_user = MagicMock()@@ -439,6 +444,11 @@ async def test_keycloak_callback_success_without_offline_token(patch('server.routes.auth.KEYCLOAK_CLIENT_ID', 'test-client'),patch('server.routes.auth.UserStore') as mock_user_store,patch('server.routes.auth.posthog') as mock_posthog,+ patch(+ 'server.routes.auth._should_redirect_to_onboarding',+ new_callable=AsyncMock,+ return_value=False,+ ),):# Mock user with accepted_tosmock_user = MagicMock()@@ -484,19 +494,101 @@ async def test_keycloak_callback_success_without_offline_token(mock_token_manager.store_idp_tokens.assert_called_once_with(ProviderType.GITHUB, 'test_user_id', 'test_access_token')- # When redirecting to Keycloak for offline token, redirect_url becomes https://keycloak...- # so secure=True is expected+ # secure is based on web_url (http://localhost:8000/), not redirect_url+ # So secure=False because web_url starts with 'http://'mock_set_cookie.assert_called_once_with(request=mock_request,response=result,keycloak_access_token='test_access_token',keycloak_refresh_token='test_refresh_token',- secure=True,+ secure=False,accepted_tos=True,)mock_posthog.set.assert_called_once()+async def test_keycloak_callback_redirects_to_keycloak_when_offline_token_invalid(+ mock_request, create_keycloak_user_info+):+ """Test that keycloak_callback redirects to Keycloak when offline token is invalid.++ When a user doesn't have a valid offline token, they should be redirected+ to Keycloak to obtain one, rather than proceeding with invitation processing.+ """+ with (+ patch('server.routes.auth.token_manager') as mock_token_manager,+ patch('server.routes.auth.set_response_cookie') as mock_set_cookie,+ patch(+ 'server.routes.auth.KEYCLOAK_SERVER_URL_EXT', 'https://keycloak.example.com'+ ),+ patch('server.routes.auth.KEYCLOAK_REALM_NAME', 'test-realm'),+ patch('server.routes.auth.KEYCLOAK_CLIENT_ID', 'test-client'),+ patch('server.routes.auth.UserStore') as mock_user_store,+ patch('server.routes.auth.posthog'),+ patch('server.routes.auth.OrgInvitationService') as mock_invitation_service,+ patch(+ 'server.routes.auth._should_redirect_to_onboarding',+ new_callable=AsyncMock,+ return_value=False,+ ),+ ):+ # Mock user with accepted_tos+ mock_user = MagicMock()+ mock_user.id = 'test_user_id'+ mock_user.current_org_id = 'test_org_id'+ mock_user.accepted_tos = '2025-01-01'++ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)+ mock_user_store.backfill_contact_name = AsyncMock()+ mock_user_store.backfill_user_email = AsyncMock()++ mock_token_manager.get_keycloak_tokens = AsyncMock(+ return_value=('test_access_token', 'test_refresh_token')+ )+ mock_token_manager.get_user_info = AsyncMock(+ return_value=create_keycloak_user_info(+ sub='test_user_id',+ preferred_username='test_user',+ identity_provider='github',+ email_verified=True,+ )+ )+ mock_token_manager.store_idp_tokens = AsyncMock()+ mock_token_manager.validate_offline_token = AsyncMock(return_value=False)++ # Call with an invitation token to verify it's NOT processed+ import base64+ import json++ state_data = {+ 'redirect_url': 'https://example.com/original-page',+ 'invitation_token': 'inv-test-token-123',+ }+ encoded_state = base64.urlsafe_b64encode(+ json.dumps(state_data).encode()+ ).decode()++ result = await keycloak_callback(+ code='test_code',+ state=encoded_state,+ request=mock_request,+ user_authorizer=create_mock_user_authorizer(),+ )++ # Should redirect to Keycloak for offline token+ assert isinstance(result, RedirectResponse)+ assert 'keycloak.example.com' in result.headers['location']+ assert 'offline_access' in result.headers['location']++ # Cookie should be set with accepted_tos=True (user has accepted TOS)+ mock_set_cookie.assert_called_once()+ assert mock_set_cookie.call_args[1]['accepted_tos'] is True++ # Invitation service should NOT be called (early return before invitation processing)+ mock_invitation_service.accept_invitation.assert_not_called()++@pytest.mark.asyncioasync def test_keycloak_callback_account_linking_error(mock_request):"""Test keycloak_callback with account linking error."""@@ -575,7 +667,21 @@ async def test_keycloak_offline_callback_success(mock_request, create_keycloak_user_info):"""Test successful keycloak_offline_callback."""- with patch('server.routes.auth.token_manager') as mock_token_manager:+ with (+ patch('server.routes.auth.token_manager') as mock_token_manager,+ patch('server.routes.auth.UserStore') as mock_user_store,+ patch('server.routes.auth.set_response_cookie'),+ patch(+ 'server.routes.auth._get_post_auth_redirect',+ new_callable=AsyncMock,+ return_value='test_state',+ ),+ ):+ # Mock user with accepted_tos+ mock_user = MagicMock()+ mock_user.accepted_tos = '2025-01-01'+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)+mock_token_manager.get_keycloak_tokens = AsyncMock(return_value=('test_access_token', 'test_refresh_token'))@@ -598,6 +704,43 @@ async def test_keycloak_offline_callback_success()+async def test_keycloak_offline_callback_redirects_to_onboarding(+ mock_request, create_keycloak_user_info+):+ """Test keycloak_offline_callback redirects to onboarding when needed."""+ with (+ patch('server.routes.auth.token_manager') as mock_token_manager,+ patch('server.routes.auth.UserStore') as mock_user_store,+ patch('server.routes.auth.set_response_cookie'),+ patch(+ 'server.routes.auth._get_post_auth_redirect',+ new_callable=AsyncMock,+ return_value='http://localhost:8000/onboarding',+ ),+ ):+ # Mock user with accepted_tos+ mock_user = MagicMock()+ mock_user.accepted_tos = '2025-01-01'+ mock_user_store.get_user_by_id = AsyncMock(return_value=mock_user)++ mock_token_manager.get_keycloak_tokens = AsyncMock(+ return_value=('test_access_token', 'test_refresh_token')+ )+ mock_token_manager.get_user_info = AsyncMock(+ return_value=create_keycloak_user_info(sub='test_user_id')+ )+ mock_token_manager.store_offline_token = AsyncMock()++ result = await keycloak_offline_callback(+ 'test_code', 'test_state', mock_request+ )++ assert isinstance(result, RedirectResponse)+ assert result.status_code == 302+ assert result.headers['location'] == 'http://localhost:8000/onboarding'++@pytest.mark.asyncioasync def test_authenticate_success():"""Test successful authentication."""@@ -2042,12 +2185,20 @@ async def test_accept_tos_stores_timezone_naive_datetime(mock_request):mock_request.json = AsyncMock(return_value={'redirect_url': 'http://example.com'})+ # Mock user for onboarding check (user already completed onboarding)+ mock_user_for_onboarding = MagicMock()+ mock_user_for_onboarding.onboarding_completed = True+with (patch('server.routes.auth.get_user_auth', AsyncMock(return_value=mock_user_auth)),patch('server.routes.auth.a_session_maker', return_value=mock_session_context),patch('server.routes.auth.set_response_cookie'),+ patch(+ 'server.routes.auth._get_post_auth_redirect',+ AsyncMock(return_value='http://example.com'),+ ),):# Actresult = await accept_tos(mock_request)@@ -2058,3 +2209,65 @@ async def test_accept_tos_stores_timezone_naive_datetime(mock_request):# The datetime assigned to user.accepted_tos must be timezone-naive# (compatible with TIMESTAMP WITHOUT TIME ZONE database column)assert mock_user.accepted_tos.tzinfo is None+++async def test_accept_tos_preserves_offline_flow_redirect(mock_request):+ """Test that accept_tos does not override redirect_url when it's the offline token flow."""+ # Arrange+ test_user_id = '12345678-1234-5678-1234-567812345678'+ offline_redirect_url = 'https://auth.example.com/realms/test/protocol/openid-connect/auth?redirect_uri=https://example.com/oauth/keycloak/offline/callback'++ mock_user = MagicMock()+ mock_user.id = test_user_id++ mock_result = MagicMock()+ mock_result.scalar_one_or_none.return_value = mock_user++ mock_session = AsyncMock()+ mock_session.execute.return_value = mock_result+ mock_session.commit = AsyncMock()++ mock_session_context = AsyncMock()+ mock_session_context.__aenter__.return_value = mock_session+ mock_session_context.__aexit__.return_value = None++ mock_user_auth = MagicMock(spec=SaasUserAuth)+ mock_user_auth.get_access_token = AsyncMock(+ return_value=SecretStr('test_access_token')+ )+ mock_user_auth.refresh_token = SecretStr('test_refresh_token')+ mock_user_auth.get_user_id = AsyncMock(return_value=test_user_id)++ mock_request.json = AsyncMock(return_value={'redirect_url': offline_redirect_url})++ mock_get_post_auth_redirect = AsyncMock(+ return_value='http://example.com/onboarding'+ )++ with (+ patch(+ 'server.routes.auth.get_user_auth', AsyncMock(return_value=mock_user_auth)+ ),+ patch('server.routes.auth.a_session_maker', return_value=mock_session_context),+ patch('server.routes.auth.set_response_cookie'),+ patch(+ 'server.routes.auth._get_post_auth_redirect',+ mock_get_post_auth_redirect,+ ),+ ):+ # Act+ result = await accept_tos(mock_request)++ # Assert+ assert isinstance(result, JSONResponse)+ assert result.status_code == status.HTTP_200_OK++ # _get_post_auth_redirect should NOT be called for offline flow+ mock_get_post_auth_redirect.assert_not_called()++ # The redirect_url should be preserved (not overridden to onboarding)+ import json++ response_body = json.loads(result.body.decode())+ assert response_body['redirect_url'] == offline_redirect_urldiff --git a/enterprise/tests/unit/test_user_store.py b/enterprise/tests/unit/test_user_store.pyindex e5c4262711..cee7374c5d 100644--- a/enterprise/tests/unit/test_user_store.py+++ b/enterprise/tests/unit/test_user_store.py@@ -1325,3 +1325,354 @@ async def test_migrate_user_sql_multiple_conversations(async_session_maker):# statements that have SQLite/UUID compatibility issues in the test environment.# The SQL migration tests above (test_migrate_user_sql_type_handling, etc.) verify# the SQL operations work correctly with proper type handling.+++# --- Tests for mark_onboarding_completed ---+++async def test_mark_onboarding_completed_success(async_session_maker):+ """Test successfully marking onboarding as completed."""+ user_id = uuid.uuid4()+ org_id = uuid.uuid4()++ # Create test data+ async with async_session_maker() as session:+ org = Org(id=org_id, name='test-org')+ session.add(org)+ user = User(id=user_id, current_org_id=org_id, onboarding_completed=False)+ session.add(user)+ await session.commit()++ # Test marking onboarding complete+ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.mark_onboarding_completed(str(user_id))++ assert result is not None+ assert result.id == user_id+ assert result.onboarding_completed is True+++async def test_mark_onboarding_completed_user_not_found(async_session_maker):+ """Test that mark_onboarding_completed returns None for non-existent user."""+ non_existent_id = str(uuid.uuid4())++ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.mark_onboarding_completed(non_existent_id)++ assert result is None+++async def test_mark_onboarding_completed_already_completed(async_session_maker):+ """Test marking onboarding complete for user who already completed it."""+ user_id = uuid.uuid4()+ org_id = uuid.uuid4()++ # Create user with onboarding already completed+ async with async_session_maker() as session:+ org = Org(id=org_id, name='test-org')+ session.add(org)+ user = User(id=user_id, current_org_id=org_id, onboarding_completed=True)+ session.add(user)+ await session.commit()++ # Should still succeed and return user+ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.mark_onboarding_completed(str(user_id))++ assert result is not None+ assert result.id == user_id+ assert result.onboarding_completed is True+++async def test_mark_onboarding_completed_user_with_null_onboarding(async_session_maker):+ """Test marking onboarding complete for user with null onboarding_completed value."""+ user_id = uuid.uuid4()+ org_id = uuid.uuid4()++ # Create user with null onboarding_completed (default)+ async with async_session_maker() as session:+ org = Org(id=org_id, name='test-org')+ session.add(org)+ user = User(+ id=user_id, current_org_id=org_id+ ) # onboarding_completed defaults to None+ session.add(user)+ await session.commit()++ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.mark_onboarding_completed(str(user_id))++ assert result is not None+ assert result.id == user_id+ assert result.onboarding_completed is True+++# --- Tests for get_first_owner_in_org ---+++async def test_get_first_owner_in_org_returns_first_owner(async_session_maker):+ """Test that get_first_owner_in_org returns the owner with earliest accepted_tos."""+ from datetime import datetime, timedelta++ from storage.org_member import OrgMember+ from storage.role import Role++ org_id = uuid.uuid4()+ first_owner_id = uuid.uuid4()+ second_owner_id = uuid.uuid4()++ async with async_session_maker() as session:+ # Create org+ org = Org(id=org_id, name='test-org')+ session.add(org)++ # Create owner role+ owner_role = Role(id=1, name='owner', rank=10)+ session.add(owner_role)++ # Create first owner (earlier TOS acceptance)+ first_owner = User(+ id=first_owner_id,+ current_org_id=org_id,+ accepted_tos=datetime.now() - timedelta(days=10),+ )+ session.add(first_owner)++ # Create second owner (later TOS acceptance)+ second_owner = User(+ id=second_owner_id,+ current_org_id=org_id,+ accepted_tos=datetime.now() - timedelta(days=5),+ )+ session.add(second_owner)++ await session.flush()++ # Add both as org members with owner role+ first_member = OrgMember(+ org_id=org_id,+ user_id=first_owner_id,+ role_id=owner_role.id,+ llm_api_key='test-key-1',+ )+ session.add(first_member)++ second_member = OrgMember(+ org_id=org_id,+ user_id=second_owner_id,+ role_id=owner_role.id,+ llm_api_key='test-key-2',+ )+ session.add(second_member)++ await session.commit()++ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.get_first_owner_in_org(org_id)++ assert result is not None+ assert result.id == first_owner_id+++async def test_get_first_owner_in_org_ignores_non_owners(async_session_maker):+ """Test that get_first_owner_in_org ignores users with non-owner roles."""+ from datetime import datetime, timedelta++ from storage.org_member import OrgMember+ from storage.role import Role++ org_id = uuid.uuid4()+ admin_id = uuid.uuid4()+ owner_id = uuid.uuid4()++ async with async_session_maker() as session:+ # Create org+ org = Org(id=org_id, name='test-org')+ session.add(org)++ # Create roles+ owner_role = Role(id=1, name='owner', rank=10)+ admin_role = Role(id=2, name='admin', rank=20)+ session.add(owner_role)+ session.add(admin_role)++ # Create admin with earlier TOS acceptance+ admin_user = User(+ id=admin_id,+ current_org_id=org_id,+ accepted_tos=datetime.now() - timedelta(days=10),+ )+ session.add(admin_user)++ # Create owner with later TOS acceptance+ owner_user = User(+ id=owner_id,+ current_org_id=org_id,+ accepted_tos=datetime.now() - timedelta(days=5),+ )+ session.add(owner_user)++ await session.flush()++ # Add admin member+ admin_member = OrgMember(+ org_id=org_id,+ user_id=admin_id,+ role_id=admin_role.id,+ llm_api_key='test-key-admin',+ )+ session.add(admin_member)++ # Add owner member+ owner_member = OrgMember(+ org_id=org_id,+ user_id=owner_id,+ role_id=owner_role.id,+ llm_api_key='test-key-owner',+ )+ session.add(owner_member)++ await session.commit()++ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.get_first_owner_in_org(org_id)++ # Should return the owner, not the admin (even though admin has earlier TOS)+ assert result is not None+ assert result.id == owner_id+++async def test_get_first_owner_in_org_returns_none_when_no_owners(async_session_maker):+ """Test that get_first_owner_in_org returns None when org has no owners."""+ from datetime import datetime++ from storage.org_member import OrgMember+ from storage.role import Role++ org_id = uuid.uuid4()+ member_id = uuid.uuid4()++ async with async_session_maker() as session:+ # Create org+ org = Org(id=org_id, name='test-org')+ session.add(org)++ # Create member role only+ member_role = Role(id=3, name='member', rank=100)+ session.add(member_role)++ # Create user with member role+ member_user = User(+ id=member_id,+ current_org_id=org_id,+ accepted_tos=datetime.now(),+ )+ session.add(member_user)++ await session.flush()++ # Add as member+ member = OrgMember(+ org_id=org_id,+ user_id=member_id,+ role_id=member_role.id,+ llm_api_key='test-key',+ )+ session.add(member)++ await session.commit()++ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.get_first_owner_in_org(org_id)++ assert result is None+++async def test_get_first_owner_in_org_ignores_owners_without_tos(async_session_maker):+ """Test that get_first_owner_in_org ignores owners who haven't accepted TOS."""+ from datetime import datetime++ from storage.org_member import OrgMember+ from storage.role import Role++ org_id = uuid.uuid4()+ owner_no_tos_id = uuid.uuid4()+ owner_with_tos_id = uuid.uuid4()++ async with async_session_maker() as session:+ # Create org+ org = Org(id=org_id, name='test-org')+ session.add(org)++ # Create owner role+ owner_role = Role(id=1, name='owner', rank=10)+ session.add(owner_role)++ # Create owner without TOS+ owner_no_tos = User(+ id=owner_no_tos_id,+ current_org_id=org_id,+ accepted_tos=None,+ )+ session.add(owner_no_tos)++ # Create owner with TOS+ owner_with_tos = User(+ id=owner_with_tos_id,+ current_org_id=org_id,+ accepted_tos=datetime.now(),+ )+ session.add(owner_with_tos)++ await session.flush()++ # Add both as owners+ member_no_tos = OrgMember(+ org_id=org_id,+ user_id=owner_no_tos_id,+ role_id=owner_role.id,+ llm_api_key='test-key-1',+ )+ session.add(member_no_tos)++ member_with_tos = OrgMember(+ org_id=org_id,+ user_id=owner_with_tos_id,+ role_id=owner_role.id,+ llm_api_key='test-key-2',+ )+ session.add(member_with_tos)++ await session.commit()++ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.get_first_owner_in_org(org_id)++ # Should return the owner who has accepted TOS+ assert result is not None+ assert result.id == owner_with_tos_id+++async def test_get_first_owner_in_org_returns_none_for_empty_org(async_session_maker):+ """Test that get_first_owner_in_org returns None for org with no members."""+ org_id = uuid.uuid4()++ async with async_session_maker() as session:+ # Create org only, no members+ org = Org(id=org_id, name='empty-org')+ session.add(org)+ await session.commit()++ with patch('storage.user_store.a_session_maker', async_session_maker):+ result = await UserStore.get_first_owner_in_org(org_id)++ assert result is Nonediff --git a/frontend/__tests__/components/features/onboarding/onboarding-form.test.tsx b/frontend/__tests__/components/features/onboarding/onboarding-form.test.tsxindex 489fc692ef..8f99b384cf 100644--- a/frontend/__tests__/components/features/onboarding/onboarding-form.test.tsx+++ b/frontend/__tests__/components/features/onboarding/onboarding-form.test.tsx@@ -1,15 +1,20 @@-import { screen } from "@testing-library/react";+import { render, screen } from "@testing-library/react";import userEvent from "@testing-library/user-event";-import { MemoryRouter } from "react-router";+import { createRoutesStub } from "react-router";import { beforeEach, describe, expect, it, vi } from "vitest";-import { renderWithProviders } from "../../../../test-utils";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import { I18nextProvider } from "react-i18next";+import i18n from "i18next";import OnboardingForm from "#/routes/onboarding-form";const mockMutate = vi.fn();const mockNavigate = vi.fn();-const mockUseConfig = vi.fn();+const mockUseMe = vi.fn();const mockTrackOnboardingCompleted = vi.fn();+// Loader data set in beforeEach for each test suite+let loaderData: { config: { app_mode: string; feature_flags: { deployment_mode: string } } };+vi.mock("react-router", async (importOriginal) => {const original = await importOriginal<typeof import("react-router")>();return {@@ -24,8 +29,8 @@ vi.mock("#/hooks/mutation/use-submit-onboarding", () => ({}),}));-vi.mock("#/hooks/query/use-config", () => ({- useConfig: () => mockUseConfig(),+vi.mock("#/hooks/query/use-me", () => ({+ useMe: () => mockUseMe(),}));vi.mock("#/hooks/use-tracking", () => ({@@ -34,49 +39,71 @@ vi.mock("#/hooks/use-tracking", () => ({}),}));-const renderOnboardingForm = () => {- return renderWithProviders(- <MemoryRouter>- <OnboardingForm />- </MemoryRouter>,+const renderOnboardingForm = async () => {+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false } },+ });++ const RouterStub = createRoutesStub([+ {+ path: "/",+ Component: OnboardingForm,+ loader: () => loaderData,+ },+ ]);++ const result = render(+ <I18nextProvider i18n={i18n}>+ <QueryClientProvider client={queryClient}>+ <RouterStub initialEntries={["/"]} />+ </QueryClientProvider>+ </I18nextProvider>,);++ // Wait for the component to render+ await screen.findByTestId("onboarding-form");+ return result;};-describe("OnboardingForm - SaaS Mode", () => {+describe("OnboardingForm - Cloud Mode", () => {beforeEach(() => {mockMutate.mockClear();mockNavigate.mockClear();mockTrackOnboardingCompleted.mockClear();- mockUseConfig.mockReturnValue({- data: { app_mode: "saas" },- isLoading: false,- });+ loaderData = {+ config: {+ app_mode: "saas",+ feature_flags: { deployment_mode: "cloud" },+ },+ };+ // Cloud mode tracks all users, role doesn't matter+ mockUseMe.mockReturnValue({ data: { role: "member" } });});- it("should render with the correct test id", () => {- renderOnboardingForm();+ it("should render with the correct test id", async () => {+ await renderOnboardingForm();expect(screen.getByTestId("onboarding-form")).toBeInTheDocument();});- it("should render the first step initially", () => {- renderOnboardingForm();+ it("should render the first step initially", async () => {+ await renderOnboardingForm();expect(screen.getByTestId("step-header")).toBeInTheDocument();expect(screen.getByTestId("step-content")).toBeInTheDocument();expect(screen.getByTestId("step-actions")).toBeInTheDocument();});- it("should display step progress indicator with 3 bars for saas mode", () => {- renderOnboardingForm();+ it("should display step progress indicator with 3 bars for cloud mode", async () => {+ await renderOnboardingForm();const stepHeader = screen.getByTestId("step-header");const progressBars = stepHeader.querySelectorAll(".rounded-full");expect(progressBars).toHaveLength(3);});- it("should have the Next button disabled when no option is selected", () => {- renderOnboardingForm();+ it("should have the Next button disabled when no option is selected", async () => {+ await renderOnboardingForm();const nextButton = screen.getByRole("button", { name: /next/i });expect(nextButton).toBeDisabled();@@ -84,7 +111,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should enable the Next button when an option is selected", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();await user.click(screen.getByTestId("step-option-solo"));@@ -94,7 +121,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should advance to the next step when Next is clicked", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();// On step 1, first progress bar should be filled (bg-white)const stepHeader = screen.getByTestId("step-header");@@ -111,7 +138,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should disable Next button again on new step until option is selected", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();await user.click(screen.getByTestId("step-option-solo"));await user.click(screen.getByRole("button", { name: /next/i }));@@ -122,7 +149,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should call submitOnboarding with selections when finishing the last step", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();// Step 1 - select org size (first step in saas mode - single select)await user.click(screen.getByTestId("step-option-org_2_10"));@@ -146,11 +173,11 @@ describe("OnboardingForm - SaaS Mode", () => {});});- it("should track onboarding completion to PostHog in SaaS mode", async () => {+ it("should track onboarding completion to PostHog in cloud mode", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();- // Complete the full SaaS onboarding flow+ // Complete the full cloud onboarding flowawait user.click(screen.getByTestId("step-option-org_2_10"));await user.click(screen.getByRole("button", { name: /next/i }));@@ -168,8 +195,8 @@ describe("OnboardingForm - SaaS Mode", () => {});});- it("should render 5 options on step 1 (org size question)", () => {- renderOnboardingForm();+ it("should render 5 options on step 1 (org size question)", async () => {+ await renderOnboardingForm();const options = screen.getAllByRole("button")@@ -181,7 +208,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should preserve selections when navigating through steps", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();// Select org size on step 1 (single select)await user.click(screen.getByTestId("step-option-solo"));@@ -207,7 +234,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should allow selecting multiple options on multi-select steps", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();// Step 1 - select org size (single select)await user.click(screen.getByTestId("step-option-solo"));@@ -234,7 +261,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should allow deselecting options on multi-select steps", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();// Step 1 - select org sizeawait user.click(screen.getByTestId("step-option-solo"));@@ -262,7 +289,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should show all progress bars filled on the last step", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();// Navigate to step 3await user.click(screen.getByTestId("step-option-solo"));@@ -277,8 +304,8 @@ describe("OnboardingForm - SaaS Mode", () => {expect(progressBars).toHaveLength(3);});- it("should not render the Back button on the first step", () => {- renderOnboardingForm();+ it("should not render the Back button on the first step", async () => {+ await renderOnboardingForm();const backButton = screen.queryByRole("button", { name: /back/i });expect(backButton).not.toBeInTheDocument();@@ -286,7 +313,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should render the Back button on step 2", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();await user.click(screen.getByTestId("step-option-solo"));await user.click(screen.getByRole("button", { name: /next/i }));@@ -297,7 +324,7 @@ describe("OnboardingForm - SaaS Mode", () => {it("should go back to the previous step when Back is clicked", async () => {const user = userEvent.setup();- renderOnboardingForm();+ await renderOnboardingForm();// Navigate to step 2await user.click(screen.getByTestId("step-option-solo"));@@ -316,3 +343,197 @@ describe("OnboardingForm - SaaS Mode", () => {expect(progressBars).toHaveLength(1);});});++describe("OnboardingForm - Self-Hosted Mode", () => {+ // Self-hosted mode has 3 steps: org_name, org_size, use_case+ // The role question is cloud-only and not shown in self-hosted mode++ beforeEach(() => {+ mockMutate.mockClear();+ mockNavigate.mockClear();+ mockTrackOnboardingCompleted.mockClear();+ loaderData = {+ config: {+ app_mode: "saas",+ feature_flags: { deployment_mode: "self_hosted" },+ },+ };+ // Self-hosted mode only tracks org owners+ mockUseMe.mockReturnValue({ data: { role: "owner" } });+ });++ it("should render with the correct test id", async () => {+ await renderOnboardingForm();++ expect(screen.getByTestId("onboarding-form")).toBeInTheDocument();+ });++ it("should display step progress indicator with 3 bars for self-hosted mode", async () => {+ await renderOnboardingForm();++ // Self-hosted has 3 steps: org_name, org_size, use_case (role is cloud-only)+ const stepHeader = screen.getByTestId("step-header");+ const progressBars = stepHeader.querySelectorAll(".rounded-full");+ expect(progressBars).toHaveLength(3);+ });++ it("should start with org_name question as first step with two input fields", async () => {+ await renderOnboardingForm();++ // The first step in self-hosted mode should be org_name with two inputs+ const orgNameInput = screen.getByTestId("form-input-org_name");+ const orgDomainInput = screen.getByTestId("form-input-org_domain");+ expect(orgNameInput).toBeInTheDocument();+ expect(orgDomainInput).toBeInTheDocument();+ });++ it("should call submitOnboarding with all selections including org_name when finishing", async () => {+ const user = userEvent.setup();+ await renderOnboardingForm();++ // Step 1 - enter org name and domain (input fields)+ const orgNameInput = screen.getByTestId("form-input-org_name");+ const orgDomainInput = screen.getByTestId("form-input-org_domain");+ await user.type(orgNameInput, "Acme Corp");+ await user.type(orgDomainInput, "acme.com");+ await user.click(screen.getByRole("button", { name: /next/i }));++ // Step 2 - select org size (single select)+ await user.click(screen.getByTestId("step-option-org_2_10"));+ await user.click(screen.getByRole("button", { name: /next/i }));++ // Step 3 - select use case (multi-select) - this is the last step in self-hosted mode+ await user.click(screen.getByTestId("step-option-new_features"));+ await user.click(screen.getByRole("button", { name: /finish/i }));++ expect(mockMutate).toHaveBeenCalledTimes(1);+ expect(mockMutate).toHaveBeenCalledWith({+ selections: {+ org_name: "Acme Corp",+ org_domain: "acme.com",+ org_size: "org_2_10",+ use_case: ["new_features"],+ },+ });+ });++ it("should track onboarding completion in self-hosted mode", async () => {+ const user = userEvent.setup();+ await renderOnboardingForm();++ // Complete the full self-hosted onboarding flow (3 steps)+ const orgNameInput = screen.getByTestId("form-input-org_name");+ const orgDomainInput = screen.getByTestId("form-input-org_domain");+ await user.type(orgNameInput, "Test Company");+ await user.type(orgDomainInput, "test.com");+ await user.click(screen.getByRole("button", { name: /next/i }));++ await user.click(screen.getByTestId("step-option-org_2_10"));+ await user.click(screen.getByRole("button", { name: /next/i }));++ await user.click(screen.getByTestId("step-option-new_features"));+ await user.click(screen.getByRole("button", { name: /finish/i }));++ expect(mockTrackOnboardingCompleted).toHaveBeenCalledTimes(1);+ // Note: role is not included since role question is cloud-only+ expect(mockTrackOnboardingCompleted).toHaveBeenCalledWith({+ role: undefined,+ orgSize: "org_2_10",+ useCase: ["new_features"],+ });+ });++ it("should show all 3 progress bars filled on the last step", async () => {+ const user = userEvent.setup();+ await renderOnboardingForm();++ // Navigate through all 3 steps+ const orgNameInput = screen.getByTestId("form-input-org_name");+ const orgDomainInput = screen.getByTestId("form-input-org_domain");+ await user.type(orgNameInput, "Test Company");+ await user.type(orgDomainInput, "test.com");+ await user.click(screen.getByRole("button", { name: /next/i }));++ await user.click(screen.getByTestId("step-option-org_2_10"));+ await user.click(screen.getByRole("button", { name: /next/i }));++ // On step 3, all three progress bars should be filled+ const stepHeader = screen.getByTestId("step-header");+ const progressBars = stepHeader.querySelectorAll(".bg-white");+ expect(progressBars).toHaveLength(3);+ });++ it("should have Next button disabled when both org_name inputs are empty", async () => {+ await renderOnboardingForm();++ const nextButton = screen.getByRole("button", { name: /next/i });+ expect(nextButton).toBeDisabled();+ });++ it("should enable Next button when both org_name and org_domain are entered", async () => {+ const user = userEvent.setup();+ await renderOnboardingForm();++ const orgNameInput = screen.getByTestId("form-input-org_name");+ const orgDomainInput = screen.getByTestId("form-input-org_domain");+ await user.type(orgNameInput, "My Company");+ await user.type(orgDomainInput, "mycompany.com");++ const nextButton = screen.getByRole("button", { name: /next/i });+ expect(nextButton).not.toBeDisabled();+ });++ it("should NOT track onboarding completion for non-owners in self-hosted mode", async () => {+ // Override the mock to return a member (non-owner) role+ mockUseMe.mockReturnValue({ data: { role: "member" } });++ const user = userEvent.setup();+ await renderOnboardingForm();++ // Complete the full self-hosted onboarding flow (3 steps)+ const orgNameInput = screen.getByTestId("form-input-org_name");+ const orgDomainInput = screen.getByTestId("form-input-org_domain");+ await user.type(orgNameInput, "Test Company");+ await user.type(orgDomainInput, "test.com");+ await user.click(screen.getByRole("button", { name: /next/i }));++ await user.click(screen.getByTestId("step-option-org_2_10"));+ await user.click(screen.getByRole("button", { name: /next/i }));++ await user.click(screen.getByTestId("step-option-new_features"));+ await user.click(screen.getByRole("button", { name: /finish/i }));++ // Tracking should NOT be called for non-owners in self-hosted mode+ expect(mockTrackOnboardingCompleted).not.toHaveBeenCalled();++ // But onboarding submission should still work+ expect(mockMutate).toHaveBeenCalledTimes(1);+ });++ it("should NOT track onboarding completion for admins in self-hosted mode", async () => {+ // Override the mock to return an admin role+ mockUseMe.mockReturnValue({ data: { role: "admin" } });++ const user = userEvent.setup();+ await renderOnboardingForm();++ // Complete the full self-hosted onboarding flow (3 steps)+ const orgNameInput = screen.getByTestId("form-input-org_name");+ const orgDomainInput = screen.getByTestId("form-input-org_domain");+ await user.type(orgNameInput, "Test Company");+ await user.type(orgDomainInput, "test.com");+ await user.click(screen.getByRole("button", { name: /next/i }));++ await user.click(screen.getByTestId("step-option-org_2_10"));+ await user.click(screen.getByRole("button", { name: /next/i }));++ await user.click(screen.getByTestId("step-option-new_features"));+ await user.click(screen.getByRole("button", { name: /finish/i }));++ // Tracking should NOT be called for admins in self-hosted mode (only owners)+ expect(mockTrackOnboardingCompleted).not.toHaveBeenCalled();++ // But onboarding submission should still work+ expect(mockMutate).toHaveBeenCalledTimes(1);+ });+});diff --git a/frontend/src/api/option-service/option.types.ts b/frontend/src/api/option-service/option.types.tsindex 3fcc0201a3..d9440eda27 100644--- a/frontend/src/api/option-service/option.types.ts+++ b/frontend/src/api/option-service/option.types.ts@@ -1,5 +1,7 @@import { Provider } from "#/types/settings";+export type DeploymentMode = "cloud" | "self_hosted";+/*** Structured response from ``GET /api/options/models``.*@@ -26,6 +28,7 @@ export interface WebClientFeatureFlags {hide_users_page: boolean;hide_billing_page: boolean;hide_integrations_page: boolean;+ deployment_mode?: DeploymentMode;}export interface WebClientConfig {diff --git a/frontend/src/constants/onboarding.tsx b/frontend/src/constants/onboarding.tsxindex 3dc7715a8c..83cc2efdc6 100644--- a/frontend/src/constants/onboarding.tsx+++ b/frontend/src/constants/onboarding.tsx@@ -1,6 +1,6 @@import { I18nKey } from "#/i18n/declaration";-export type OnboardingAppMode = "saas" | "self-hosted";+export type OnboardingAppMode = "cloud" | "self-hosted" | "oss";interface BaseOnboardingQuestion {id: string;@@ -43,9 +43,9 @@ export const ONBOARDING_FORM: OnboardingQuestion[] = [{id: "org_size",type: "single",- app_mode: ["saas", "self-hosted"],+ app_mode: ["cloud", "self-hosted"],questionKey: I18nKey.ONBOARDING$ORG_SIZE_QUESTION,- subtitleKey: I18nKey.ONBOARDING$ORG_SIZE_SUBTITLE,+ subtitleKey: I18nKey.ONBOARDING$SELECT_ONE_SUBTITLE,answerOptions: [{ key: I18nKey.ONBOARDING$ORG_SIZE_SOLO, id: "solo" },{ key: I18nKey.ONBOARDING$ORG_SIZE_2_10, id: "org_2_10" },@@ -57,9 +57,9 @@ export const ONBOARDING_FORM: OnboardingQuestion[] = [{id: "use_case",type: "multi",- app_mode: ["saas", "self-hosted"],+ app_mode: ["cloud", "self-hosted"],questionKey: I18nKey.ONBOARDING$USE_CASE_QUESTION,- subtitleKey: I18nKey.ONBOARDING$USE_CASE_SUBTITLE,+ subtitleKey: I18nKey.ONBOARDING$SELECT_MULTIPLE_SUBTITLE,answerOptions: [{ key: I18nKey.ONBOARDING$USE_CASE_NEW_FEATURES, id: "new_features" },{@@ -78,8 +78,9 @@ export const ONBOARDING_FORM: OnboardingQuestion[] = [{id: "role",type: "single",- app_mode: ["saas"],+ app_mode: ["cloud"],questionKey: I18nKey.ONBOARDING$ROLE_QUESTION,+ subtitleKey: I18nKey.ONBOARDING$SELECT_ONE_SUBTITLE,answerOptions: [{key: I18nKey.ONBOARDING$ROLE_SOFTWARE_ENGINEER,diff --git a/frontend/src/hooks/mutation/use-submit-onboarding.ts b/frontend/src/hooks/mutation/use-submit-onboarding.tsindex 13e9eead10..de922a88e9 100644--- a/frontend/src/hooks/mutation/use-submit-onboarding.ts+++ b/frontend/src/hooks/mutation/use-submit-onboarding.ts@@ -1,5 +1,6 @@-import { useMutation } from "@tanstack/react-query";+import { useMutation, useQueryClient } from "@tanstack/react-query";import { useNavigate } from "react-router";+import { openHands } from "#/api/open-hands-axios";import { displayErrorToast } from "#/utils/custom-toast-handlers";type SubmitOnboardingArgs = {@@ -8,14 +9,18 @@ type SubmitOnboardingArgs = {export const useSubmitOnboarding = () => {const navigate = useNavigate();+ const queryClient = useQueryClient();return useMutation({- mutationFn: async ({ selections }: SubmitOnboardingArgs) =>- // TODO: mark onboarding as complete- // TODO: persist user responses- ({ selections }),+ mutationFn: async ({ selections }: SubmitOnboardingArgs) => {+ // Mark onboarding as complete+ await openHands.post("/api/complete_onboarding");+ return { selections };+ },onSuccess: () => {- const finalRedirectUrl = "/"; // TODO: use redirect url from api response+ queryClient.invalidateQueries({ queryKey: ["settings"] });++ const finalRedirectUrl = "/";// Check if the redirect URL is an external URL (starts with http or https)if (finalRedirectUrl.startsWith("http://") ||diff --git a/frontend/src/i18n/declaration.ts b/frontend/src/i18n/declaration.tsindex 87a656361e..f96a499299 100644--- a/frontend/src/i18n/declaration.ts+++ b/frontend/src/i18n/declaration.ts@@ -1133,14 +1133,14 @@ export enum I18nKey {ONBOARDING$ORG_NAME_INPUT_NAME = "ONBOARDING$ORG_NAME_INPUT_NAME",ONBOARDING$ORG_NAME_INPUT_DOMAIN = "ONBOARDING$ORG_NAME_INPUT_DOMAIN",ONBOARDING$ORG_SIZE_QUESTION = "ONBOARDING$ORG_SIZE_QUESTION",- ONBOARDING$ORG_SIZE_SUBTITLE = "ONBOARDING$ORG_SIZE_SUBTITLE",+ ONBOARDING$SELECT_ONE_SUBTITLE = "ONBOARDING$SELECT_ONE_SUBTITLE",ONBOARDING$ORG_SIZE_SOLO = "ONBOARDING$ORG_SIZE_SOLO",ONBOARDING$ORG_SIZE_2_10 = "ONBOARDING$ORG_SIZE_2_10",ONBOARDING$ORG_SIZE_11_50 = "ONBOARDING$ORG_SIZE_11_50",ONBOARDING$ORG_SIZE_51_200 = "ONBOARDING$ORG_SIZE_51_200",ONBOARDING$ORG_SIZE_200_PLUS = "ONBOARDING$ORG_SIZE_200_PLUS",ONBOARDING$USE_CASE_QUESTION = "ONBOARDING$USE_CASE_QUESTION",- ONBOARDING$USE_CASE_SUBTITLE = "ONBOARDING$USE_CASE_SUBTITLE",+ ONBOARDING$SELECT_MULTIPLE_SUBTITLE = "ONBOARDING$SELECT_MULTIPLE_SUBTITLE",ONBOARDING$USE_CASE_NEW_FEATURES = "ONBOARDING$USE_CASE_NEW_FEATURES",ONBOARDING$USE_CASE_APP_FROM_SCRATCH = "ONBOARDING$USE_CASE_APP_FROM_SCRATCH",ONBOARDING$USE_CASE_FIXING_BUGS = "ONBOARDING$USE_CASE_FIXING_BUGS",diff --git a/frontend/src/i18n/translation.json b/frontend/src/i18n/translation.jsonindex 2734e9d071..371838298c 100644--- a/frontend/src/i18n/translation.json+++ b/frontend/src/i18n/translation.json@@ -19263,7 +19263,7 @@"uk": "Якого розміру організація, в якій ви працюєте?","ca": "De quina mida és la vostra organització?"},- "ONBOARDING$ORG_SIZE_SUBTITLE": {+ "ONBOARDING$SELECT_ONE_SUBTITLE": {"en": "Select one","ja": "1つ選択","zh-CN": "选择一个",@@ -19382,7 +19382,7 @@"uk": "Для яких випадків використання ви хочете використовувати OpenHands?","ca": "Per a quins casos d'ús voleu fer servir OpenHands?"},- "ONBOARDING$USE_CASE_SUBTITLE": {+ "ONBOARDING$SELECT_MULTIPLE_SUBTITLE": {"en": "Check all that apply","ja": "該当するものをすべて選択","zh-CN": "选择所有适用的",diff --git a/frontend/src/routes/onboarding-form.tsx b/frontend/src/routes/onboarding-form.tsxindex 88e71f75aa..c64961f1e5 100644--- a/frontend/src/routes/onboarding-form.tsx+++ b/frontend/src/routes/onboarding-form.tsx@@ -1,6 +1,6 @@import React from "react";import { useTranslation } from "react-i18next";-import { useNavigate, redirect } from "react-router";+import { useNavigate, redirect, useLoaderData } from "react-router";import StepHeader from "#/components/features/onboarding/step-header";import { StepContent } from "#/components/features/onboarding/step-content";import { BrandButton } from "#/components/features/settings/brand-button";@@ -10,26 +10,43 @@ import { useSubmitOnboarding } from "#/hooks/mutation/use-submit-onboarding";import { useTracking } from "#/hooks/use-tracking";import { ENABLE_ONBOARDING } from "#/utils/feature-flags";import { cn } from "#/utils/utils";-import { useConfig } from "#/hooks/query/use-config";+import { useMe } from "#/hooks/query/use-me";import {ONBOARDING_FORM,OnboardingQuestion,OnboardingAppMode,} from "#/constants/onboarding";+import {+ DeploymentMode,+ WebClientConfig,+} from "#/api/option-service/option.types";+import { queryClient } from "#/query-client-config";+import OptionService from "#/api/option-service/option-service.api";export const clientLoader = async () => {- if (!ENABLE_ONBOARDING()) {+ let config = queryClient.getQueryData<WebClientConfig>(["web-client-config"]);+ if (!config) {+ config = await OptionService.getConfig();+ queryClient.setQueryData<WebClientConfig>(["web-client-config"], config);+ }++ // Only allow access to onboarding for SaaS mode (cloud or self-hosted)+ // OSS users should never reach /onboarding+ if (config?.app_mode !== "saas" || !ENABLE_ONBOARDING()) {return redirect("/");}- return null;+ return { config };};type OnboardingAnswers = Record<string, string | string[]>;-function getOnboardingAppMode(): OnboardingAppMode {- // TODO: query for app mode (saas or self hosted super user)- return "saas";+function getOnboardingAppMode(+ deploymentMode: DeploymentMode | undefined,+): OnboardingAppMode {+ if (deploymentMode === "self_hosted") return "self-hosted";+ if (deploymentMode === "cloud") return "cloud";+ return "oss";}function getAnswerAsArray(answers: OnboardingAnswers, key: string): string[] {@@ -63,11 +80,15 @@ function getTranslatedInputFields(function OnboardingForm() {const { t } = useTranslation();const navigate = useNavigate();- const config = useConfig({ enabled: true });+ const loaderData = useLoaderData<typeof clientLoader>();+ const config = loaderData?.config;+ const { data: me } = useMe();const { mutate: submitOnboarding } = useSubmitOnboarding();const { trackOnboardingCompleted } = useTracking();- const onboardingAppMode: OnboardingAppMode = getOnboardingAppMode();+ const onboardingAppMode: OnboardingAppMode = getOnboardingAppMode(+ config?.feature_flags?.deployment_mode,+ );const steps = React.useMemo(() =>@@ -148,8 +169,16 @@ function OnboardingForm() {if (isLastStep) {submitOnboarding({ selections: answers });- // Only track onboarding for SaaS users- if (config.data?.app_mode === "saas") {+ // Track onboarding completion based on deployment mode:+ // - Cloud mode: track ALL users+ // - Self-hosted mode: track only org owners (SuperAdmin)+ const deploymentMode = config?.feature_flags?.deployment_mode;+ const isOwner = me?.role === "owner";+ const shouldTrack =+ deploymentMode === "cloud" ||+ (deploymentMode === "self_hosted" && isOwner);++ if (shouldTrack) {trackOnboardingCompleted({role: typeof answers.role === "string" ? answers.role : undefined,orgSize:@@ -180,59 +209,61 @@ function OnboardingForm() {const translatedInputFields = getTranslatedInputFields(currentStep, t);return (- <div- data-testid="onboarding-form"- className="w-[500px] max-w-[calc(100vw-2rem)] mx-auto p-4 sm:p-6 flex flex-col justify-center overflow-hidden"- >- <div className="flex flex-col items-center mb-4">- <OpenHandsLogoWhite width={55} height={55} />- </div>- <StepHeader- title={t(currentStep.questionKey)}- subtitle={- currentStep.subtitleKey ? t(currentStep.subtitleKey) : undefined- }- currentStep={currentStepIndex + 1}- totalSteps={steps.length}- />- <StepContent- options={translatedOptions}- inputFields={translatedInputFields}- selectedOptionIds={currentSelections}- inputValues={inputValues}- onSelectOption={handleSelectOption}- onInputChange={handleInputChange}- />+ <div className="min-h-screen flex items-center justify-center"><div- data-testid="step-actions"- className="flex justify-end items-center gap-3"+ data-testid="onboarding-form"+ className="w-[500px] max-w-[calc(100vw-2rem)] mx-auto p-4 sm:p-6 flex flex-col justify-center overflow-hidden">- {!isFirstStep && (+ <div className="flex flex-col items-center mb-4">+ <OpenHandsLogoWhite width={55} height={55} />+ </div>+ <StepHeader+ title={t(currentStep.questionKey)}+ subtitle={+ currentStep.subtitleKey ? t(currentStep.subtitleKey) : undefined+ }+ currentStep={currentStepIndex + 1}+ totalSteps={steps.length}+ />+ <StepContent+ options={translatedOptions}+ inputFields={translatedInputFields}+ selectedOptionIds={currentSelections}+ inputValues={inputValues}+ onSelectOption={handleSelectOption}+ onInputChange={handleInputChange}+ />+ <div+ data-testid="step-actions"+ className="flex justify-end items-center gap-3"+ >+ {!isFirstStep && (+ <BrandButton+ type="button"+ variant="secondary"+ onClick={handleBack}+ className="flex-1 px-4 sm:px-6 py-2.5 bg-[050505] text-white border hover:bg-white border-[#242424] hover:text-black"+ >+ {t(I18nKey.ONBOARDING$BACK_BUTTON)}+ </BrandButton>+ )}<BrandButtontype="button"- variant="secondary"- onClick={handleBack}- className="flex-1 px-4 sm:px-6 py-2.5 bg-[050505] text-white border hover:bg-white border-[#242424] hover:text-black"+ variant="primary"+ onClick={handleNext}+ isDisabled={!isStepComplete}+ className={cn(+ "px-4 sm:px-6 py-2.5 bg-white text-black hover:bg-white/90",+ isFirstStep ? "w-1/2" : "flex-1",+ )}>- {t(I18nKey.ONBOARDING$BACK_BUTTON)}+ {t(+ isLastStep+ ? I18nKey.ONBOARDING$FINISH_BUTTON+ : I18nKey.ONBOARDING$NEXT_BUTTON,+ )}</BrandButton>- )}- <BrandButton- type="button"- variant="primary"- onClick={handleNext}- isDisabled={!isStepComplete}- className={cn(- "px-4 sm:px-6 py-2.5 bg-white text-black hover:bg-white/90",- isFirstStep ? "w-1/2" : "flex-1",- )}- >- {t(- isLastStep- ? I18nKey.ONBOARDING$FINISH_BUTTON- : I18nKey.ONBOARDING$NEXT_BUTTON,- )}- </BrandButton>+ </div></div></div>);diff --git a/openhands/app_server/web_client/web_client_deployment_mode.py b/openhands/app_server/web_client/web_client_deployment_mode.pynew file mode 100644index 0000000000..b903783094--- /dev/null+++ b/openhands/app_server/web_client/web_client_deployment_mode.py@@ -0,0 +1,26 @@+import os+from typing import Literal++DeploymentMode = Literal['cloud', 'self_hosted']+++# This can be removed / replaced when a DeploymentMode (or similar) env var is created.+def get_deployment_mode() -> DeploymentMode | None:+ """Get deployment mode based on OH_WEB_HOST environment variable.++ Returns:+ 'cloud' for All-Hands managed infrastructure (app.all-hands.dev, etc.)+ 'self_hosted' for enterprise self-hosted deployments (customer domains)+ None if WEB_HOST is not set+ """+ web_host = os.getenv('OH_WEB_HOST', os.getenv('WEB_HOST', '')).strip()+ if not web_host:+ return None+ if (+ web_host == 'app.all-hands.dev'+ or web_host == 'app.openhands.ai'+ or web_host.endswith('.all-hands.dev')+ or web_host.endswith('.openhands.ai')+ ):+ return 'cloud'+ return 'self_hosted'diff --git a/openhands/app_server/web_client/web_client_models.py b/openhands/app_server/web_client/web_client_models.pyindex a42a397a9e..bcb57df4b1 100644--- a/openhands/app_server/web_client/web_client_models.py+++ b/openhands/app_server/web_client/web_client_models.py@@ -1,8 +1,12 @@from datetime import datetime-from pydantic import BaseModel+from pydantic import BaseModel, model_validatorfrom openhands.agent_server.env_parser import DiscriminatedUnionMixin+from openhands.app_server.web_client.web_client_deployment_mode import (+ DeploymentMode,+ get_deployment_mode,+)from openhands.integrations.service_types import ProviderTypefrom openhands.server.types import AppMode@@ -16,6 +20,14 @@ class WebClientFeatureFlags(BaseModel):hide_users_page: bool = Falsehide_billing_page: bool = Falsehide_integrations_page: bool = False+ deployment_mode: DeploymentMode | None = None++ # This can be removed / replaced when a DeploymentMode (or similar) env var is created.+ @model_validator(mode='after')+ def set_deployment_mode(self) -> 'WebClientFeatureFlags':+ if self.deployment_mode is None:+ self.deployment_mode = get_deployment_mode()+ return selfclass WebClientConfig(DiscriminatedUnionMixin):diff --git a/tests/unit/app_server/test_web_client_deployment_mode.py b/tests/unit/app_server/test_web_client_deployment_mode.pynew file mode 100644index 0000000000..7eb26eff39--- /dev/null+++ b/tests/unit/app_server/test_web_client_deployment_mode.py@@ -0,0 +1,81 @@+"""Tests for web_client_deployment_mode module."""++from unittest.mock import patch++import pytest++from openhands.app_server.web_client.web_client_deployment_mode import (+ get_deployment_mode,+)+++class TestGetDeploymentMode:+ """Tests for get_deployment_mode() function."""++ @pytest.mark.parametrize(+ 'web_host,expected',+ [+ # All-Hands managed domains should return 'cloud'+ ('app.all-hands.dev', 'cloud'),+ ('staging.all-hands.dev', 'cloud'),+ ('feature-123.staging.all-hands.dev', 'cloud'),+ ('app.openhands.ai', 'cloud'),+ ('subdomain.openhands.ai', 'cloud'),+ # Customer domains should return 'self_hosted'+ ('openhands.acme.com', 'self_hosted'),+ ('internal.company.io', 'self_hosted'),+ ('dev.mycompany.net', 'self_hosted'),+ # Edge cases - not subdomains+ ('all-hands.dev', 'self_hosted'),+ ('openhands.ai', 'self_hosted'),+ # Malicious domains+ ('fake-all-hands.dev', 'self_hosted'),+ ('app.all-hands.dev.evil.com', 'self_hosted'),+ ],+ )+ def test_deployment_mode_detection(self, web_host: str, expected: str):+ """Test that deployment mode is correctly determined based on WEB_HOST."""+ with patch.dict('os.environ', {'WEB_HOST': web_host}, clear=False):+ result = get_deployment_mode()+ assert result == expected++ def test_returns_none_when_web_host_empty(self):+ """Test that empty WEB_HOST returns None."""+ with patch.dict('os.environ', {'WEB_HOST': ''}, clear=False):+ result = get_deployment_mode()+ assert result is None++ def test_returns_none_when_web_host_not_set(self):+ """Test that missing WEB_HOST returns None."""+ with patch.dict('os.environ', {}, clear=True):+ result = get_deployment_mode()+ assert result is None++ def test_returns_none_when_web_host_whitespace_only(self):+ """Test that whitespace-only WEB_HOST returns None."""+ with patch.dict('os.environ', {'WEB_HOST': ' '}, clear=False):+ result = get_deployment_mode()+ assert result is None++ def test_oh_web_host_takes_precedence_over_web_host(self):+ """Test that OH_WEB_HOST takes precedence over WEB_HOST."""+ with patch.dict(+ 'os.environ',+ {'OH_WEB_HOST': 'app.all-hands.dev', 'WEB_HOST': 'customer.example.com'},+ clear=False,+ ):+ result = get_deployment_mode()+ assert result == 'cloud'++ def test_falls_back_to_web_host_when_oh_web_host_not_set(self):+ """Test that WEB_HOST is used when OH_WEB_HOST is not set."""+ with patch.dict(+ 'os.environ', {'WEB_HOST': 'customer.example.com'}, clear=False+ ):+ # Ensure OH_WEB_HOST is not set+ import os++ if 'OH_WEB_HOST' in os.environ:+ del os.environ['OH_WEB_HOST']+ result = get_deployment_mode()+ assert result == 'self_hosted'