Skip to content

🙌 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.py
new file mode 100644
index 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.py
index 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_MODE
from openhands.core.config.utils import load_openhands_config
from 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.py
index 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 deployment
IS_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 constants
ROLE_OWNER = 'owner'
ROLE_ADMIN = 'admin'
diff --git a/enterprise/server/routes/auth.py b/enterprise/server/routes/auth.py
index 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_id
from 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 occur
diff --git a/enterprise/storage/user.py b/enterprise/storage/user.py
index e60c3f1f6a..8214a931cb 100644
--- a/enterprise/storage/user.py
+++ b/enterprise/storage/user.py
@@ -36,6 +36,7 @@ class User(Base): # type: ignore
git_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)
# Relationships
role = relationship('Role', back_populates='users')
diff --git a/enterprise/storage/user_store.py b/enterprise/storage/user_store.py
index 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 Org
from storage.org_member import OrgMember
+from storage.role import Role
from storage.role_store import RoleStore
from storage.user import User
from 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()
+
@staticmethod
async 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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_tos
mock_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_tos
mock_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.asyncio
async 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.asyncio
async 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'),
+ ),
):
# Act
result = 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_url
diff --git a/enterprise/tests/unit/test_user_store.py b/enterprise/tests/unit/test_user_store.py
index 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 None
diff --git a/frontend/__tests__/components/features/onboarding/onboarding-form.test.tsx b/frontend/__tests__/components/features/onboarding/onboarding-form.test.tsx
index 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 flow
await 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 size
await 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 3
await 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 2
await 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.ts
index 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.tsx
index 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.ts
index 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.ts
index 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.json
index 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.tsx
index 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>
+ )}
<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"
+ 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.py
new file mode 100644
index 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.py
index 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_validator
from 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 ProviderType
from openhands.server.types import AppMode
@@ -16,6 +20,14 @@ class WebClientFeatureFlags(BaseModel):
hide_users_page: bool = False
hide_billing_page: bool = False
hide_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 self
class 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.py
new file mode 100644
index 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'