π OpenHands: AI-Driven Development
feat: expose_secrets param on /users/me + sandbox-scoped secrets API (#13383)
Xingyao Wang75c823c4862e
diff --git a/AGENTS.md b/AGENTS.mdindex 878a26e884..5bcf99cf8b 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -342,3 +342,30 @@ To add a new LLM model to OpenHands, you need to update multiple files across bo- Models appear in CLI provider selection based on the verified arrays- The `organize_models_and_providers` function groups models by provider- Default model selection prioritizes verified models for each provider++### Sandbox Settings API (SDK Credential Inheritance)++The sandbox settings API allows SDK-created conversations to inherit the user's SaaS credentials+(LLM config, secrets) securely via `LookupSecret`. Raw secret values only flow SaaSβsandbox,+never through the SDK client.++#### User Credentials with Exposed Secrets (in `openhands/app_server/user/user_router.py`):+- `GET /api/v1/users/me?expose_secrets=true` β Full user settings with unmasked secrets (e.g., `llm_api_key`)+- `GET /api/v1/users/me` β Full user settings (secrets masked, Bearer only)++Auth requirements for `expose_secrets=true`:+- Bearer token (proves user identity via `OPENHANDS_API_KEY`)+- `X-Session-API-Key` header (proves caller has an active sandbox owned by the authenticated user)++Called by `workspace.get_llm()` in the SDK to retrieve LLM config with the API key.++#### Sandbox-Scoped Secrets Endpoints (in `openhands/app_server/sandbox/sandbox_router.py`):+- `GET /sandboxes/{id}/settings/secrets` β list secret names (no values)+- `GET /sandboxes/{id}/settings/secrets/{name}` β raw secret value (called FROM sandbox)++#### Auth: `X-Session-API-Key` header, validated via `SandboxService.get_sandbox_by_session_api_key()`++#### Related SDK code (in `software-agent-sdk` repo):+- `openhands/sdk/llm/llm.py`: `LLM.api_key` accepts `SecretSource` (including `LookupSecret`)+- `openhands/workspace/cloud/workspace.py`: `get_llm()` and `get_secrets()` return LookupSecret-backed objects+- Tests: `tests/sdk/llm/test_llm_secret_source_api_key.py`, `tests/workspace/test_cloud_workspace_sdk_settings.py`diff --git a/enterprise/integrations/resolver_context.py b/enterprise/integrations/resolver_context.pyindex 441c132f2c..30e558a111 100644--- a/enterprise/integrations/resolver_context.py+++ b/enterprise/integrations/resolver_context.py@@ -60,7 +60,9 @@ class ResolverUserContext(UserContext):return provider_token.token.get_secret_value()return None- async def get_provider_tokens(self) -> PROVIDER_TOKEN_TYPE | None:+ async def get_provider_tokens(+ self, as_env_vars: bool = False+ ) -> PROVIDER_TOKEN_TYPE | dict[str, str] | None:return await self.saas_user_auth.get_provider_tokens()async def get_secrets(self) -> dict[str, SecretSource]:diff --git a/openhands/app_server/app_conversation/live_status_app_conversation_service.py b/openhands/app_server/app_conversation/live_status_app_conversation_service.pyindex 902cde7771..703899ec83 100644--- a/openhands/app_server/app_conversation/live_status_app_conversation_service.py+++ b/openhands/app_server/app_conversation/live_status_app_conversation_service.py@@ -7,7 +7,7 @@ import zipfilefrom collections import defaultdictfrom dataclasses import dataclassfrom datetime import datetime, timedelta-from typing import Any, AsyncGenerator, Sequence+from typing import Any, AsyncGenerator, Sequence, castfrom uuid import UUID, uuid4import httpx@@ -84,7 +84,7 @@ from openhands.app_server.utils.llm_metadata import (get_llm_metadata,should_set_litellm_extra_body,)-from openhands.integrations.provider import ProviderType+from openhands.integrations.provider import PROVIDER_TOKEN_TYPE, ProviderTypefrom openhands.integrations.service_types import SuggestedTaskfrom openhands.sdk import Agent, AgentContext, LocalWorkspacefrom openhands.sdk.hooks import HookConfig@@ -837,7 +837,10 @@ class LiveStatusAppConversationService(AppConversationServiceBase):secrets = await self.user_context.get_secrets()# Get all provider tokens from user authentication- provider_tokens = await self.user_context.get_provider_tokens()+ provider_tokens = cast(+ PROVIDER_TOKEN_TYPE | None,+ await self.user_context.get_provider_tokens(),+ )if not provider_tokens:return secretsdiff --git a/openhands/app_server/sandbox/sandbox_models.py b/openhands/app_server/sandbox/sandbox_models.pyindex 948e5c17c2..c64d188b34 100644--- a/openhands/app_server/sandbox/sandbox_models.py+++ b/openhands/app_server/sandbox/sandbox_models.py@@ -59,3 +59,20 @@ class SandboxInfo(BaseModel):class SandboxPage(BaseModel):items: list[SandboxInfo]next_page_id: str | None = None+++class SecretNameItem(BaseModel):+ """A secret's name and optional description (value NOT included)."""++ name: str = Field(description='The secret name/key')+ description: str | None = Field(+ default=None, description='Optional description of the secret'+ )+++class SecretNamesResponse(BaseModel):+ """Response listing available secret names (no raw values)."""++ secrets: list[SecretNameItem] = Field(+ default_factory=list, description='Available secrets'+ )diff --git a/openhands/app_server/sandbox/sandbox_router.py b/openhands/app_server/sandbox/sandbox_router.pyindex 79a3ef6b82..7b2575c3e7 100644--- a/openhands/app_server/sandbox/sandbox_router.py+++ b/openhands/app_server/sandbox/sandbox_router.py@@ -1,16 +1,30 @@"""Runtime Containers router for OpenHands App Server."""-from typing import Annotated+import logging+from typing import Annotated, cast-from fastapi import APIRouter, HTTPException, Query, status+from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response, status+from fastapi.security import APIKeyHeaderfrom openhands.agent_server.models import Successfrom openhands.app_server.config import depends_sandbox_service-from openhands.app_server.sandbox.sandbox_models import SandboxInfo, SandboxPage+from openhands.app_server.sandbox.sandbox_models import (+ SandboxInfo,+ SandboxPage,+ SecretNameItem,+ SecretNamesResponse,+)from openhands.app_server.sandbox.sandbox_service import (SandboxService,)+from openhands.app_server.sandbox.session_auth import validate_session_key+from openhands.app_server.user.auth_user_context import AuthUserContextfrom openhands.server.dependencies import get_dependencies+from openhands.server.user_auth.user_auth import (+ get_for_user as get_user_auth_for_user,+)++_logger = logging.getLogger(__name__)# We use the get_dependencies method here to signal to the OpenAPI docs that this endpoint# is protected. The actual protection is provided by SetAuthCookieMiddleware@@ -94,3 +108,104 @@ async def delete_sandbox(if not exists:raise HTTPException(status.HTTP_404_NOT_FOUND)return Success()+++# ---------------------------------------------------------------------------+# Sandbox-scoped secrets (authenticated via X-Session-API-Key)+# ---------------------------------------------------------------------------+++async def _valid_sandbox_from_session_key(+ request: Request,+ sandbox_id: str,+ session_api_key: str = Depends(+ APIKeyHeader(name='X-Session-API-Key', auto_error=False)+ ),+) -> SandboxInfo:+ """Authenticate via ``X-Session-API-Key`` and verify sandbox ownership."""+ sandbox_info = await validate_session_key(session_api_key)++ if sandbox_info.id != sandbox_id:+ raise HTTPException(+ status.HTTP_403_FORBIDDEN,+ detail='Session API key does not match sandbox',+ )++ return sandbox_info+++async def _get_user_context(sandbox_info: SandboxInfo) -> AuthUserContext:+ """Build an ``AuthUserContext`` for the sandbox owner."""+ if not sandbox_info.created_by_user_id:+ raise HTTPException(+ status.HTTP_401_UNAUTHORIZED,+ detail='Sandbox has no associated user',+ )+ user_auth = await get_user_auth_for_user(sandbox_info.created_by_user_id)+ return AuthUserContext(user_auth=user_auth)++[email protected]('/{sandbox_id}/settings/secrets')+async def list_secret_names(+ sandbox_info: SandboxInfo = Depends(_valid_sandbox_from_session_key),+) -> SecretNamesResponse:+ """List available secret names (no raw values).++ Includes both custom secrets and provider tokens (e.g. github_token).+ """+ user_context = await _get_user_context(sandbox_info)++ items: list[SecretNameItem] = []++ # Custom secrets+ secret_sources = await user_context.get_secrets()+ for name, source in secret_sources.items():+ items.append(SecretNameItem(name=name, description=source.description))++ # Provider tokens (github_token, gitlab_token, etc.)+ provider_env_vars = cast(+ dict[str, str] | None,+ await user_context.get_provider_tokens(as_env_vars=True),+ )+ if provider_env_vars:+ for env_key in provider_env_vars:+ items.append(+ SecretNameItem(name=env_key, description=f'{env_key} provider token')+ )++ return SecretNamesResponse(secrets=items)++[email protected]('/{sandbox_id}/settings/secrets/{secret_name}')+async def get_secret_value(+ secret_name: str,+ sandbox_info: SandboxInfo = Depends(_valid_sandbox_from_session_key),+) -> Response:+ """Return a single secret value as plain text.++ Called by ``LookupSecret`` inside the sandbox. Checks custom secrets+ first, then falls back to provider tokens β always resolving the+ latest token at call time.+ """+ user_context = await _get_user_context(sandbox_info)++ # Check custom secrets first+ secret_sources = await user_context.get_secrets()+ source = secret_sources.get(secret_name)+ if source is not None:+ value = source.get_value()+ if value is None:+ raise HTTPException(status.HTTP_404_NOT_FOUND, detail='Secret has no value')+ return Response(content=value, media_type='text/plain')++ # Fall back to provider tokens (resolved fresh per request)+ provider_env_vars = cast(+ dict[str, str] | None,+ await user_context.get_provider_tokens(as_env_vars=True),+ )+ if provider_env_vars:+ token_value = provider_env_vars.get(secret_name)+ if token_value is not None:+ return Response(content=token_value, media_type='text/plain')++ raise HTTPException(status.HTTP_404_NOT_FOUND, detail='Secret not found')diff --git a/openhands/app_server/sandbox/session_auth.py b/openhands/app_server/sandbox/session_auth.pynew file mode 100644index 0000000000..5ae7f418b6--- /dev/null+++ b/openhands/app_server/sandbox/session_auth.py@@ -0,0 +1,66 @@+"""Shared session-key authentication for sandbox-scoped endpoints.++Both the sandbox router and the user router need to validate+``X-Session-API-Key`` headers. This module centralises that logic so+it lives in exactly one place.++The ``InjectorState`` + ``ADMIN`` pattern used here is established in+``webhook_router.py`` β the sandbox service requires an admin context to+look up sandboxes across all users by session key, but the session key+itself acts as the proof of access.+"""++import logging++from fastapi import HTTPException, status++from openhands.app_server.config import get_global_config, get_sandbox_service+from openhands.app_server.sandbox.sandbox_models import SandboxInfo+from openhands.app_server.services.injector import InjectorState+from openhands.app_server.user.specifiy_user_context import ADMIN, USER_CONTEXT_ATTR+from openhands.server.types import AppMode++_logger = logging.getLogger(__name__)+++async def validate_session_key(session_api_key: str | None) -> SandboxInfo:+ """Validate an ``X-Session-API-Key`` and return the associated sandbox.++ Raises:+ HTTPException(401): if the key is missing or does not map to a sandbox.+ HTTPException(401): in SAAS mode if the sandbox has no owning user.+ """+ if not session_api_key:+ raise HTTPException(+ status.HTTP_401_UNAUTHORIZED,+ detail='X-Session-API-Key header is required',+ )++ # The sandbox service is scoped to users. To look up a sandbox by session+ # key (which could belong to *any* user) we need an admin context. This+ # is the same pattern used in webhook_router.valid_sandbox().+ state = InjectorState()+ setattr(state, USER_CONTEXT_ATTR, ADMIN)++ async with get_sandbox_service(state) as sandbox_service:+ sandbox_info = await sandbox_service.get_sandbox_by_session_api_key(+ session_api_key+ )++ if sandbox_info is None:+ raise HTTPException(+ status.HTTP_401_UNAUTHORIZED, detail='Invalid session API key'+ )++ if not sandbox_info.created_by_user_id:+ if get_global_config().app_mode == AppMode.SAAS:+ _logger.error(+ 'Sandbox had no user specified',+ extra={'sandbox_id': sandbox_info.id},+ )+ raise HTTPException(+ status.HTTP_401_UNAUTHORIZED,+ detail='Sandbox had no user specified',+ )++ return sandbox_infodiff --git a/openhands/app_server/user/auth_user_context.py b/openhands/app_server/user/auth_user_context.pyindex c6f7df07de..663ab0bbfd 100644--- a/openhands/app_server/user/auth_user_context.py+++ b/openhands/app_server/user/auth_user_context.py@@ -48,8 +48,27 @@ class AuthUserContext(UserContext):self._user_info = user_inforeturn user_info- async def get_provider_tokens(self) -> PROVIDER_TOKEN_TYPE | None:- return await self.user_auth.get_provider_tokens()+ async def get_provider_tokens(+ self, as_env_vars: bool = False+ ) -> PROVIDER_TOKEN_TYPE | dict[str, str] | None:+ """Return provider tokens.++ Args:+ as_env_vars: When True, return a ``dict[str, str]`` mapping env+ var names (e.g. ``github_token``) to plain-text token values,+ resolving the latest value at call time. When False (default),+ return the raw ``dict[ProviderType, ProviderToken]``.+ """+ provider_tokens = await self.user_auth.get_provider_tokens()+ if not as_env_vars:+ return provider_tokens+ results: dict[str, str] = {}+ if provider_tokens:+ for provider_type, provider_token in provider_tokens.items():+ if provider_token.token:+ env_key = ProviderHandler.get_provider_env_key(provider_type)+ results[env_key] = provider_token.token.get_secret_value()+ return resultsasync def get_provider_handler(self):provider_handler = self._provider_handler@@ -79,9 +98,9 @@ class AuthUserContext(UserContext):return tokenasync def get_secrets(self) -> dict[str, SecretSource]:- results = {}+ results: dict[str, SecretSource] = {}- # Include custom secrets...+ # Include custom secretssecrets = await self.user_auth.get_secrets()if secrets:for name, custom_secret in secrets.custom_secrets.items():diff --git a/openhands/app_server/user/specifiy_user_context.py b/openhands/app_server/user/specifiy_user_context.pyindex 0127d13129..087aac9e7f 100644--- a/openhands/app_server/user/specifiy_user_context.py+++ b/openhands/app_server/user/specifiy_user_context.py@@ -26,7 +26,9 @@ class SpecifyUserContext(UserContext):) -> str:raise NotImplementedError()- async def get_provider_tokens(self) -> PROVIDER_TOKEN_TYPE | None:+ async def get_provider_tokens(+ self, as_env_vars: bool = False+ ) -> PROVIDER_TOKEN_TYPE | dict[str, str] | None:raise NotImplementedError()async def get_latest_token(self, provider_type: ProviderType) -> str | None:diff --git a/openhands/app_server/user/user_context.py b/openhands/app_server/user/user_context.pyindex 36aee854ae..625b4cd43e 100644--- a/openhands/app_server/user/user_context.py+++ b/openhands/app_server/user/user_context.py@@ -35,8 +35,16 @@ class UserContext(ABC):"""@abstractmethod- async def get_provider_tokens(self) -> PROVIDER_TOKEN_TYPE | None:- """Get the latest tokens for all provider types"""+ async def get_provider_tokens(+ self, as_env_vars: bool = False+ ) -> PROVIDER_TOKEN_TYPE | dict[str, str] | None:+ """Get the latest tokens for all provider types.++ Args:+ as_env_vars: When True, return a ``dict[str, str]`` mapping env+ var names (e.g. ``github_token``) to plain-text token values.+ When False (default), return the raw provider token mapping.+ """@abstractmethodasync def get_latest_token(self, provider_type: ProviderType) -> str | None:diff --git a/openhands/app_server/user/user_router.py b/openhands/app_server/user/user_router.pyindex 2926c8495d..3cee936bde 100644--- a/openhands/app_server/user/user_router.py+++ b/openhands/app_server/user/user_router.py@@ -1,12 +1,18 @@"""User router for OpenHands App Server. For the moment, this simply implements the /me endpoint."""-from fastapi import APIRouter, HTTPException, status+import logging++from fastapi import APIRouter, Header, HTTPException, Query, status+from fastapi.responses import JSONResponsefrom openhands.app_server.config import depends_user_context+from openhands.app_server.sandbox.session_auth import validate_session_keyfrom openhands.app_server.user.user_context import UserContextfrom openhands.app_server.user.user_models import UserInfofrom openhands.server.dependencies import get_dependencies+_logger = logging.getLogger(__name__)+# We use the get_dependencies method here to signal to the OpenAPI docs that this endpoint# is protected. The actual protection is provided by SetAuthCookieMiddlewarerouter = APIRouter(prefix='/users', tags=['User'], dependencies=get_dependencies())@@ -18,9 +24,52 @@ user_dependency = depends_user_context()@router.get('/me')async def get_current_user(user_context: UserContext = user_dependency,+ expose_secrets: bool = Query(+ default=False,+ description='If true, return unmasked secret values (e.g. llm_api_key). '+ 'Requires a valid X-Session-API-Key header for an active sandbox '+ 'owned by the authenticated user.',+ ),+ x_session_api_key: str | None = Header(default=None),) -> UserInfo:"""Get the current authenticated user."""user = await user_context.get_user_info()if user is None:raise HTTPException(status.HTTP_401_UNAUTHORIZED, detail='Not authenticated')+ if expose_secrets:+ await _validate_session_key_ownership(user_context, x_session_api_key)+ return JSONResponse( # type: ignore[return-value]+ content=user.model_dump(mode='json', context={'expose_secrets': True})+ )return user+++async def _validate_session_key_ownership(+ user_context: UserContext,+ session_api_key: str | None,+) -> None:+ """Verify the session key belongs to a sandbox owned by the caller.++ Raises ``HTTPException`` if the key is missing, invalid, or belongs+ to a sandbox owned by a different user.+ """+ sandbox_info = await validate_session_key(session_api_key)++ # Verify the sandbox is owned by the authenticated user.+ caller_id = await user_context.get_user_id()+ if not caller_id:+ raise HTTPException(+ status.HTTP_401_UNAUTHORIZED,+ detail='Cannot determine authenticated user',+ )++ if sandbox_info.created_by_user_id != caller_id:+ _logger.warning(+ 'Session key user mismatch: sandbox owner=%s, caller=%s',+ sandbox_info.created_by_user_id,+ caller_id,+ )+ raise HTTPException(+ status.HTTP_403_FORBIDDEN,+ detail='Session API key does not belong to the authenticated user',+ )diff --git a/tests/unit/app_server/test_sandbox_secrets_router.py b/tests/unit/app_server/test_sandbox_secrets_router.pynew file mode 100644index 0000000000..5976098bc1--- /dev/null+++ b/tests/unit/app_server/test_sandbox_secrets_router.py@@ -0,0 +1,787 @@+"""Unit + integration tests for the sandbox settings endpoints and /users/me expose_secrets.++Tests:+- GET /api/v1/users/me?expose_secrets=true+- GET /api/v1/sandboxes/{sandbox_id}/settings/secrets+- GET /api/v1/sandboxes/{sandbox_id}/settings/secrets/{secret_name}+- Shared session_auth.validate_session_key()+- Integration tests exercising the real auth validation stack via HTTP+"""++import contextlib+from unittest.mock import AsyncMock, patch++import pytest+from fastapi import FastAPI, HTTPException+from fastapi.testclient import TestClient+from pydantic import SecretStr++from openhands.app_server.sandbox.sandbox_models import (+ SandboxInfo,+ SandboxStatus,+ SecretNamesResponse,+)+from openhands.app_server.sandbox.sandbox_router import (+ get_secret_value,+ list_secret_names,+)+from openhands.app_server.sandbox.session_auth import validate_session_key+from openhands.app_server.user.auth_user_context import AuthUserContext+from openhands.app_server.user.user_models import UserInfo+from openhands.app_server.user.user_router import (+ _validate_session_key_ownership,+ get_current_user,+)+from openhands.integrations.provider import ProviderHandler, ProviderToken+from openhands.integrations.service_types import ProviderType+from openhands.sdk.secret import StaticSecret++SANDBOX_ID = 'sb-test-123'+USER_ID = 'test-user-id'+++def _make_sandbox_info(+ sandbox_id: str = SANDBOX_ID,+ user_id: str | None = USER_ID,+) -> SandboxInfo:+ return SandboxInfo(+ id=sandbox_id,+ created_by_user_id=user_id,+ sandbox_spec_id='test-spec',+ status=SandboxStatus.RUNNING,+ session_api_key='session-key',+ )+++def _patch_sandbox_service(return_sandbox: SandboxInfo | None):+ """Patch ``get_sandbox_service`` in ``session_auth`` to return a mock service."""+ mock_sandbox_service = AsyncMock()+ mock_sandbox_service.get_sandbox_by_session_api_key = AsyncMock(+ return_value=return_sandbox+ )+ ctx = patch(+ 'openhands.app_server.sandbox.session_auth.get_sandbox_service',+ )+ return ctx, mock_sandbox_service+++def _create_sandbox_service_context_manager(sandbox_service):+ """Create an async context manager that yields the given sandbox service."""++ @contextlib.asynccontextmanager+ async def _context_manager(state, request=None):+ yield sandbox_service++ return _context_manager+++# ---------------------------------------------------------------------------+# validate_session_key (shared utility)+# ---------------------------------------------------------------------------+++class TestValidateSessionKey:+ """Tests for the shared session_auth.validate_session_key utility."""++ async def test_rejects_missing_key(self):+ """Missing session key raises 401."""+ with pytest.raises(HTTPException) as exc_info:+ await validate_session_key(None)+ assert exc_info.value.status_code == 401+ assert 'X-Session-API-Key' in exc_info.value.detail++ async def test_rejects_empty_string_key(self):+ """Empty string session key raises 401."""+ with pytest.raises(HTTPException) as exc_info:+ await validate_session_key('')+ assert exc_info.value.status_code == 401++ async def test_rejects_invalid_key(self):+ """Session key that maps to no sandbox raises 401."""+ ctx, mock_svc = _patch_sandbox_service(None)+ with ctx as mock_get:+ mock_get.return_value.__aenter__ = AsyncMock(return_value=mock_svc)+ mock_get.return_value.__aexit__ = AsyncMock(return_value=False)++ with pytest.raises(HTTPException) as exc_info:+ await validate_session_key('bogus-key')+ assert exc_info.value.status_code == 401+ assert 'Invalid session API key' in exc_info.value.detail++ async def test_accepts_valid_key(self):+ """Valid session key returns sandbox info."""+ sandbox = _make_sandbox_info()+ ctx, mock_svc = _patch_sandbox_service(sandbox)+ with ctx as mock_get:+ mock_get.return_value.__aenter__ = AsyncMock(return_value=mock_svc)+ mock_get.return_value.__aexit__ = AsyncMock(return_value=False)++ result = await validate_session_key('valid-key')+ assert result.id == SANDBOX_ID++ async def test_rejects_sandbox_without_user_in_saas_mode(self):+ """In SAAS mode, sandbox without created_by_user_id raises 401."""+ sandbox = _make_sandbox_info(user_id=None)+ ctx, mock_svc = _patch_sandbox_service(sandbox)+ with (+ ctx as mock_get,+ patch(+ 'openhands.app_server.sandbox.session_auth.get_global_config'+ ) as mock_cfg,+ ):+ mock_get.return_value.__aenter__ = AsyncMock(return_value=mock_svc)+ mock_get.return_value.__aexit__ = AsyncMock(return_value=False)++ from openhands.server.types import AppMode++ mock_cfg.return_value.app_mode = AppMode.SAAS++ with pytest.raises(HTTPException) as exc_info:+ await validate_session_key('valid-key')+ assert exc_info.value.status_code == 401+ assert 'no user' in exc_info.value.detail+++# ---------------------------------------------------------------------------+# GET /users/me?expose_secrets=true+# ---------------------------------------------------------------------------+++class TestGetCurrentUserExposeSecrets:+ """Test suite for GET /users/me?expose_secrets=true."""++ async def test_expose_secrets_returns_raw_api_key(self):+ """With valid session key, expose_secrets=true returns unmasked llm_api_key."""+ user_info = UserInfo(+ id=USER_ID,+ llm_model='anthropic/claude-sonnet-4-20250514',+ llm_api_key=SecretStr('sk-test-key-123'),+ llm_base_url='https://litellm.example.com',+ )+ mock_context = AsyncMock()+ mock_context.get_user_info = AsyncMock(return_value=user_info)+ mock_context.get_user_id = AsyncMock(return_value=USER_ID)++ with patch(+ 'openhands.app_server.user.user_router._validate_session_key_ownership'+ ) as mock_validate:+ mock_validate.return_value = None+ result = await get_current_user(+ user_context=mock_context,+ expose_secrets=True,+ x_session_api_key='valid-key',+ )++ # JSONResponse β parse the body+ import json++ body = json.loads(result.body)+ assert body['llm_model'] == 'anthropic/claude-sonnet-4-20250514'+ assert body['llm_api_key'] == 'sk-test-key-123'+ assert body['llm_base_url'] == 'https://litellm.example.com'++ async def test_expose_secrets_rejects_missing_session_key(self):+ """expose_secrets=true without X-Session-API-Key is rejected."""+ mock_context = AsyncMock()++ with pytest.raises(HTTPException) as exc_info:+ await _validate_session_key_ownership(mock_context, session_api_key=None)+ assert exc_info.value.status_code == 401+ assert 'X-Session-API-Key' in exc_info.value.detail++ async def test_expose_secrets_rejects_wrong_user(self):+ """expose_secrets=true with session key from different user is rejected."""+ mock_context = AsyncMock()+ mock_context.get_user_id = AsyncMock(return_value='user-A')++ other_user_sandbox = _make_sandbox_info(user_id='user-B')++ ctx, mock_svc = _patch_sandbox_service(other_user_sandbox)+ with ctx as mock_get, pytest.raises(HTTPException) as exc_info:+ mock_get.return_value.__aenter__ = AsyncMock(return_value=mock_svc)+ mock_get.return_value.__aexit__ = AsyncMock(return_value=False)++ await _validate_session_key_ownership(+ mock_context, session_api_key='stolen-key'+ )++ assert exc_info.value.status_code == 403++ async def test_expose_secrets_rejects_unknown_caller(self):+ """If caller_id cannot be determined, reject with 401."""+ mock_context = AsyncMock()+ mock_context.get_user_id = AsyncMock(return_value=None)++ sandbox = _make_sandbox_info(user_id='user-B')++ ctx, mock_svc = _patch_sandbox_service(sandbox)+ with ctx as mock_get, pytest.raises(HTTPException) as exc_info:+ mock_get.return_value.__aenter__ = AsyncMock(return_value=mock_svc)+ mock_get.return_value.__aexit__ = AsyncMock(return_value=False)++ await _validate_session_key_ownership(+ mock_context, session_api_key='some-key'+ )++ assert exc_info.value.status_code == 401+ assert 'Cannot determine authenticated user' in exc_info.value.detail++ async def test_default_masks_api_key(self):+ """Without expose_secrets, llm_api_key is masked (no session key needed)."""+ user_info = UserInfo(+ id=USER_ID,+ llm_api_key=SecretStr('sk-test-key-123'),+ )+ mock_context = AsyncMock()+ mock_context.get_user_info = AsyncMock(return_value=user_info)++ result = await get_current_user(+ user_context=mock_context, expose_secrets=False, x_session_api_key=None+ )++ # Returns UserInfo directly (FastAPI will serialize with masking)+ assert isinstance(result, UserInfo)+ assert result.llm_api_key is not None+ # The raw value is still in the object, but serialization masks it+ dumped = result.model_dump(mode='json')+ assert dumped['llm_api_key'] == '**********'+++# ---------------------------------------------------------------------------+# GET /sandboxes/{sandbox_id}/settings/secrets+# ---------------------------------------------------------------------------+++class TestListSecretNames:+ """Test suite for GET /sandboxes/{sandbox_id}/settings/secrets."""++ async def test_returns_secret_names_without_values(self):+ """Response contains names and descriptions, NOT raw values."""+ secrets = {+ 'GITHUB_TOKEN': StaticSecret(+ value=SecretStr('ghp_test123'),+ description='GitHub personal access token',+ ),+ 'MY_API_KEY': StaticSecret(+ value=SecretStr('my-api-key-value'),+ description='Custom API key',+ ),+ }+ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(return_value=secrets)+ ctx.get_provider_tokens = AsyncMock(return_value={})+ mock_ctx.return_value = ctx++ result = await list_secret_names(sandbox_info=sandbox_info)++ assert isinstance(result, SecretNamesResponse)+ assert len(result.secrets) == 2+ names = {s.name for s in result.secrets}+ assert 'GITHUB_TOKEN' in names+ assert 'MY_API_KEY' in names++ gh = next(s for s in result.secrets if s.name == 'GITHUB_TOKEN')+ assert gh.description == 'GitHub personal access token'+ # Verify no 'value' field is exposed+ assert not hasattr(gh, 'value')++ async def test_returns_empty_when_no_secrets(self):+ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(return_value={})+ ctx.get_provider_tokens = AsyncMock(return_value={})+ mock_ctx.return_value = ctx++ result = await list_secret_names(sandbox_info=sandbox_info)++ assert len(result.secrets) == 0+++# ---------------------------------------------------------------------------+# GET /sandboxes/{sandbox_id}/settings/secrets/{name}+# ---------------------------------------------------------------------------+++class TestGetSecretValue:+ """Test suite for GET /sandboxes/{sandbox_id}/settings/secrets/{name}."""++ async def test_returns_raw_secret_value(self):+ """Raw secret value returned as plain text."""+ secrets = {+ 'GITHUB_TOKEN': StaticSecret(+ value=SecretStr('ghp_actual_secret'),+ description='GitHub token',+ ),+ }+ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(return_value=secrets)+ ctx.get_provider_tokens = AsyncMock(return_value={})+ mock_ctx.return_value = ctx++ response = await get_secret_value(+ secret_name='GITHUB_TOKEN',+ sandbox_info=sandbox_info,+ )++ assert response.body == b'ghp_actual_secret'+ assert response.media_type == 'text/plain'++ async def test_returns_404_for_unknown_secret(self):+ """404 when requested secret doesn't exist in custom secrets or provider tokens."""+ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(return_value={})+ ctx.get_provider_tokens = AsyncMock(return_value={})+ mock_ctx.return_value = ctx++ with pytest.raises(HTTPException) as exc_info:+ await get_secret_value(+ secret_name='NONEXISTENT',+ sandbox_info=sandbox_info,+ )++ assert exc_info.value.status_code == 404++ async def test_returns_404_for_none_value_secret(self):+ """404 when secret exists but has None value."""+ secrets = {+ 'EMPTY_SECRET': StaticSecret(value=None),+ }+ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(return_value=secrets)+ ctx.get_provider_tokens = AsyncMock(return_value={})+ mock_ctx.return_value = ctx++ with pytest.raises(HTTPException) as exc_info:+ await get_secret_value(+ secret_name='EMPTY_SECRET',+ sandbox_info=sandbox_info,+ )++ assert exc_info.value.status_code == 404+++# ===========================================================================+# Integration tests β real HTTP requests through real auth validation logic.+#+# Only the data layer (sandbox service, user context) is mocked.+# The session key validation, ownership checks, and FastAPI routing are REAL.+# ===========================================================================+++def _build_integration_test_app(+ mock_user_context: AsyncMock | None = None,+) -> FastAPI:+ """Build a minimal FastAPI app with the real user and sandbox routers.++ The ``depends_user_context`` dependency is overridden with a mock, but the+ session key validation logic in ``validate_session_key`` and+ ``_validate_session_key_ownership`` runs unmodified.++ Router-level dependencies (e.g. ``check_session_api_key`` from ``SESSION_API_KEY``+ env var) are overridden to no-ops so we can exercise the endpoint-level auth logic+ in isolation.+ """+ from openhands.app_server.sandbox.sandbox_router import (+ router as sandbox_router,+ )+ from openhands.app_server.user.user_router import router as user_router+ from openhands.server.dependencies import check_session_api_key++ app = FastAPI()++ # Disable router-level auth (SESSION_API_KEY check) β we're testing the+ # endpoint-level session key validation, not the router middleware.+ app.dependency_overrides[check_session_api_key] = lambda: None++ if mock_user_context is not None:+ from openhands.app_server.user.user_router import user_dependency++ app.dependency_overrides[user_dependency.dependency] = lambda: mock_user_context++ app.include_router(user_router, prefix='/api/v1')+ app.include_router(sandbox_router, prefix='/api/v1')+ return app+++class TestExposeSecretsIntegration:+ """Integration tests for /users/me?expose_secrets=true via real HTTP.++ These tests exercise the full auth validation stack:+ - validate_session_key (real)+ - _validate_session_key_ownership (real)+ - ownership check (real)+ Only the data layer (sandbox service lookup, user context) is mocked.+ """++ def test_expose_secrets_without_session_key_returns_401(self):+ """Bearer token alone cannot expose secrets (no X-Session-API-Key)."""+ mock_user_ctx = AsyncMock()+ mock_user_ctx.get_user_info = AsyncMock(+ return_value=UserInfo(id=USER_ID, llm_api_key=SecretStr('sk-secret-123'))+ )+ mock_user_ctx.get_user_id = AsyncMock(return_value=USER_ID)++ app = _build_integration_test_app(mock_user_ctx)+ client = TestClient(app, raise_server_exceptions=False)++ response = client.get('/api/v1/users/me', params={'expose_secrets': 'true'})++ assert response.status_code == 401+ assert 'X-Session-API-Key' in response.json()['detail']++ def test_expose_secrets_with_invalid_session_key_returns_401(self):+ """Invalid session key (no matching sandbox) is rejected."""+ mock_user_ctx = AsyncMock()+ mock_user_ctx.get_user_info = AsyncMock(+ return_value=UserInfo(id=USER_ID, llm_api_key=SecretStr('sk-secret-123'))+ )+ mock_user_ctx.get_user_id = AsyncMock(return_value=USER_ID)++ mock_sandbox_svc = AsyncMock()+ mock_sandbox_svc.get_sandbox_by_session_api_key = AsyncMock(return_value=None)++ app = _build_integration_test_app(mock_user_ctx)+ client = TestClient(app, raise_server_exceptions=False)++ with patch(+ 'openhands.app_server.sandbox.session_auth.get_sandbox_service',+ _create_sandbox_service_context_manager(mock_sandbox_svc),+ ):+ response = client.get(+ '/api/v1/users/me',+ params={'expose_secrets': 'true'},+ headers={'X-Session-API-Key': 'bogus-key'},+ )++ assert response.status_code == 401+ assert 'Invalid session API key' in response.json()['detail']++ def test_expose_secrets_with_wrong_user_returns_403(self):+ """Session key from a different user's sandbox is rejected."""+ mock_user_ctx = AsyncMock()+ mock_user_ctx.get_user_info = AsyncMock(+ return_value=UserInfo(id='user-A', llm_api_key=SecretStr('sk-secret-123'))+ )+ mock_user_ctx.get_user_id = AsyncMock(return_value='user-A')++ # Sandbox owned by user-B+ sandbox_b = _make_sandbox_info(user_id='user-B')+ mock_sandbox_svc = AsyncMock()+ mock_sandbox_svc.get_sandbox_by_session_api_key = AsyncMock(+ return_value=sandbox_b+ )++ app = _build_integration_test_app(mock_user_ctx)+ client = TestClient(app, raise_server_exceptions=False)++ with patch(+ 'openhands.app_server.sandbox.session_auth.get_sandbox_service',+ _create_sandbox_service_context_manager(mock_sandbox_svc),+ ):+ response = client.get(+ '/api/v1/users/me',+ params={'expose_secrets': 'true'},+ headers={'X-Session-API-Key': 'stolen-key'},+ )++ assert response.status_code == 403+ assert 'does not belong' in response.json()['detail']++ def test_expose_secrets_valid_dual_auth_returns_200_unmasked(self):+ """Valid Bearer + valid session key owned by same user β 200 with secrets."""+ mock_user_ctx = AsyncMock()+ mock_user_ctx.get_user_info = AsyncMock(+ return_value=UserInfo(+ id=USER_ID,+ llm_model='anthropic/claude-sonnet-4-20250514',+ llm_api_key=SecretStr('sk-real-secret'),+ llm_base_url='https://litellm.example.com',+ )+ )+ mock_user_ctx.get_user_id = AsyncMock(return_value=USER_ID)++ sandbox = _make_sandbox_info(user_id=USER_ID)+ mock_sandbox_svc = AsyncMock()+ mock_sandbox_svc.get_sandbox_by_session_api_key = AsyncMock(+ return_value=sandbox+ )++ app = _build_integration_test_app(mock_user_ctx)+ client = TestClient(app, raise_server_exceptions=False)++ with patch(+ 'openhands.app_server.sandbox.session_auth.get_sandbox_service',+ _create_sandbox_service_context_manager(mock_sandbox_svc),+ ):+ response = client.get(+ '/api/v1/users/me',+ params={'expose_secrets': 'true'},+ headers={'X-Session-API-Key': 'valid-key'},+ )++ assert response.status_code == 200+ body = response.json()+ assert body['llm_api_key'] == 'sk-real-secret'+ assert body['llm_model'] == 'anthropic/claude-sonnet-4-20250514'+ assert body['llm_base_url'] == 'https://litellm.example.com'++ def test_default_masks_secrets_via_http(self):+ """Without expose_secrets, secrets are masked even via real HTTP."""+ mock_user_ctx = AsyncMock()+ mock_user_ctx.get_user_info = AsyncMock(+ return_value=UserInfo(+ id=USER_ID, llm_api_key=SecretStr('sk-should-be-masked')+ )+ )++ app = _build_integration_test_app(mock_user_ctx)+ client = TestClient(app, raise_server_exceptions=False)++ response = client.get('/api/v1/users/me')++ assert response.status_code == 200+ body = response.json()+ assert body['llm_api_key'] == '**********'+++class TestSandboxSecretsIntegration:+ """Integration tests for sandbox-scoped secrets endpoints via real HTTP.++ The session key validation in ``_valid_sandbox_from_session_key`` runs+ unmodified β only the sandbox service (database) is mocked.+ """++ def test_secrets_list_without_session_key_returns_401(self):+ """Missing X-Session-API-Key on secrets endpoint is rejected."""+ app = _build_integration_test_app()+ client = TestClient(app, raise_server_exceptions=False)++ response = client.get(f'/api/v1/sandboxes/{SANDBOX_ID}/settings/secrets')++ assert response.status_code == 401+ assert 'X-Session-API-Key' in response.json()['detail']++ def test_secrets_list_with_invalid_session_key_returns_401(self):+ """Invalid session key on secrets endpoint is rejected."""+ app = _build_integration_test_app()+ client = TestClient(app, raise_server_exceptions=False)++ mock_sandbox_svc = AsyncMock()+ mock_sandbox_svc.get_sandbox_by_session_api_key = AsyncMock(return_value=None)++ with patch(+ 'openhands.app_server.sandbox.session_auth.get_sandbox_service',+ _create_sandbox_service_context_manager(mock_sandbox_svc),+ ):+ response = client.get(+ f'/api/v1/sandboxes/{SANDBOX_ID}/settings/secrets',+ headers={'X-Session-API-Key': 'bogus'},+ )++ assert response.status_code == 401+ assert 'Invalid session API key' in response.json()['detail']++ def test_secrets_list_with_mismatched_sandbox_id_returns_403(self):+ """Session key maps to a different sandbox than the URL path β 403."""+ app = _build_integration_test_app()+ client = TestClient(app, raise_server_exceptions=False)++ # Session key maps to sandbox "other-sandbox", but URL says SANDBOX_ID+ other_sandbox = _make_sandbox_info(sandbox_id='other-sandbox')+ mock_sandbox_svc = AsyncMock()+ mock_sandbox_svc.get_sandbox_by_session_api_key = AsyncMock(+ return_value=other_sandbox+ )++ with patch(+ 'openhands.app_server.sandbox.session_auth.get_sandbox_service',+ _create_sandbox_service_context_manager(mock_sandbox_svc),+ ):+ response = client.get(+ f'/api/v1/sandboxes/{SANDBOX_ID}/settings/secrets',+ headers={'X-Session-API-Key': 'valid-key'},+ )++ assert response.status_code == 403+ assert 'does not match' in response.json()['detail']++ def test_sandbox_without_user_returns_401_for_secret_value(self):+ """Sandbox with no owning user β 401 when fetching a secret value."""+ app = _build_integration_test_app()+ client = TestClient(app, raise_server_exceptions=False)++ # Sandbox exists but has no owning user+ sandbox_no_user = _make_sandbox_info(user_id=None)+ mock_sandbox_svc = AsyncMock()+ mock_sandbox_svc.get_sandbox_by_session_api_key = AsyncMock(+ return_value=sandbox_no_user+ )++ with patch(+ 'openhands.app_server.sandbox.session_auth.get_sandbox_service',+ _create_sandbox_service_context_manager(mock_sandbox_svc),+ ):+ response = client.get(+ f'/api/v1/sandboxes/{SANDBOX_ID}/settings/secrets/MY_SECRET',+ headers={'X-Session-API-Key': 'valid-key'},+ )++ # _get_user_context raises 401 because created_by_user_id is None+ assert response.status_code == 401+ assert 'no associated user' in response.json()['detail']+++# ---------------------------------------------------------------------------+# Provider tokens in sandbox secrets endpoints+# ---------------------------------------------------------------------------+++class TestProviderTokensInEndpoints:+ """Verify that sandbox secrets endpoints include provider tokens resolved lazily."""++ async def test_get_provider_tokens_as_env_vars(self):+ """get_provider_tokens(as_env_vars=True) returns fresh values keyed by env name."""+ mock_user_auth = AsyncMock()+ mock_user_auth.get_provider_tokens = AsyncMock(+ return_value={+ ProviderType.GITHUB: ProviderToken(token=SecretStr('ghp_test123')),+ ProviderType.GITLAB: ProviderToken(token=SecretStr('glpat-test456')),+ }+ )++ ctx = AuthUserContext(user_auth=mock_user_auth)+ result = await ctx.get_provider_tokens(as_env_vars=True)++ gh_key = ProviderHandler.get_provider_env_key(ProviderType.GITHUB)+ gl_key = ProviderHandler.get_provider_env_key(ProviderType.GITLAB)+ assert result[gh_key] == 'ghp_test123'+ assert result[gl_key] == 'glpat-test456'++ async def test_empty_provider_tokens_excluded(self):+ """Provider tokens with empty token values are excluded."""+ mock_user_auth = AsyncMock()+ mock_user_auth.get_provider_tokens = AsyncMock(+ return_value={+ ProviderType.GITHUB: ProviderToken(token=SecretStr('')),+ }+ )++ ctx = AuthUserContext(user_auth=mock_user_auth)+ result = await ctx.get_provider_tokens(as_env_vars=True)++ gh_key = ProviderHandler.get_provider_env_key(ProviderType.GITHUB)+ assert gh_key not in result++ async def test_none_provider_tokens_returns_empty(self):+ """get_provider_tokens(as_env_vars=True) with None tokens yields empty dict."""+ mock_user_auth = AsyncMock()+ mock_user_auth.get_provider_tokens = AsyncMock(return_value=None)++ ctx = AuthUserContext(user_auth=mock_user_auth)+ result = await ctx.get_provider_tokens(as_env_vars=True)+ assert result == {}++ async def test_list_secret_names_includes_provider_tokens(self):+ """list_secret_names returns both custom secrets and provider token names."""+ custom_secrets = {+ 'MY_KEY': StaticSecret(+ value=SecretStr('my-value'), description='custom key'+ ),+ }+ gh_key = ProviderHandler.get_provider_env_key(ProviderType.GITHUB)+ provider_env_vars = {gh_key: 'ghp_test123'}++ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(return_value=custom_secrets)+ ctx.get_provider_tokens = AsyncMock(return_value=provider_env_vars)+ mock_ctx.return_value = ctx++ result = await list_secret_names(sandbox_info=sandbox_info)++ names = {s.name for s in result.secrets}+ assert 'MY_KEY' in names+ assert gh_key in names+ assert len(result.secrets) == 2++ async def test_get_secret_value_resolves_provider_token(self):+ """get_secret_value falls back to provider tokens when not in custom secrets."""+ gh_key = ProviderHandler.get_provider_env_key(ProviderType.GITHUB)+ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(return_value={})+ ctx.get_provider_tokens = AsyncMock(+ return_value={gh_key: 'ghp_fresh_token'}+ )+ mock_ctx.return_value = ctx++ response = await get_secret_value(+ secret_name=gh_key, sandbox_info=sandbox_info+ )++ assert response.body == b'ghp_fresh_token'+ assert response.media_type == 'text/plain'++ async def test_custom_secret_takes_priority_over_provider_token(self):+ """If a custom secret has the same name, it takes priority."""+ gh_key = ProviderHandler.get_provider_env_key(ProviderType.GITHUB)+ sandbox_info = _make_sandbox_info()++ with patch(+ 'openhands.app_server.sandbox.sandbox_router._get_user_context'+ ) as mock_ctx:+ ctx = AsyncMock()+ ctx.get_secrets = AsyncMock(+ return_value={+ gh_key: StaticSecret(+ value=SecretStr('custom-override'),+ description='user override',+ )+ }+ )+ # Provider token should NOT be called since custom secret matches+ ctx.get_provider_tokens = AsyncMock(return_value={gh_key: 'provider-value'})+ mock_ctx.return_value = ctx++ response = await get_secret_value(+ secret_name=gh_key, sandbox_info=sandbox_info+ )++ assert response.body == b'custom-override'