π OpenHands: AI-Driven Development
feat(jira-dc): share linked OAuth token with eligible conversations (#14697)
Alona30457edcd647
diff --git a/enterprise/integrations/jira_dc/jira_dc_conversation_secret_enricher.py b/enterprise/integrations/jira_dc/jira_dc_conversation_secret_enricher.pynew file mode 100644index 0000000000..bb453bba79--- /dev/null+++ b/enterprise/integrations/jira_dc/jira_dc_conversation_secret_enricher.py@@ -0,0 +1,227 @@+from __future__ import annotations++from datetime import timedelta+from urllib.parse import urlparse+from uuid import UUID++from integrations.jira_dc.jira_dc_user_token import (+ JiraDcUserToken,+ JiraDcUserTokenError,+ get_user_jira_dc_token,+)+from pydantic import SecretStr+from server.auth.constants import JIRA_DC_BASE_URL, JIRA_DC_ENABLE_OAUTH+from server.auth.token_manager import TokenManager+from storage.jira_dc_integration_store import JiraDcIntegrationStore+from storage.jira_dc_workspace import JiraDcWorkspace++from openhands.app_server.app_conversation.app_conversation_models import (+ ConversationTrigger,+)+from openhands.app_server.app_conversation.conversation_secret_enricher import (+ ConversationSecretEnricher,+ ConversationSecretEnrichment,+)+from openhands.app_server.services.jwt_service import JwtService+from openhands.app_server.user.user_context import UserContext+from openhands.app_server.user.user_models import UserInfo+from openhands.app_server.utils.logger import openhands_logger as logger+from openhands.sdk.secret import LookupSecret, SecretSource, StaticSecret++JIRA_DC_SECRET_HINT = """You have credentialed access to the Jira Data Center REST API:++ - Base URL: $JIRA_DC_BASE_URL+ - Auth: Authorization: Bearer $JIRA_DC_TOKEN++The token value is supplied only as a sandbox secret/environment variable. Never echo or log the value of $JIRA_DC_TOKEN."""+++def _workspace_matches_configured_jira_dc_host(workspace_name: str) -> bool:+ configured_host = urlparse(JIRA_DC_BASE_URL).hostname+ if not configured_host:+ return False+ return workspace_name.lower() == configured_host.lower()+++def _append_jira_dc_hint(system_message_suffix: str | None) -> str:+ if not system_message_suffix:+ return JIRA_DC_SECRET_HINT+ if 'JIRA_DC_TOKEN' in system_message_suffix:+ return system_message_suffix+ return f'{system_message_suffix}\n\n{JIRA_DC_SECRET_HINT}'+++async def _get_effective_org_id(user_context: UserContext) -> UUID | None:+ resolver_org_id = getattr(user_context, 'resolver_org_id', None)+ if resolver_org_id is not None:+ return resolver_org_id++ # Known org-bearing UserContext shapes: resolver starts set resolver_org_id;+ # user-auth starts expose get_effective_org_id on one of these auth attrs.+ for auth_attr in ('saas_user_auth', 'user_auth'):+ user_auth = getattr(user_context, auth_attr, None)+ get_effective_org_id = getattr(user_auth, 'get_effective_org_id', None)+ if callable(get_effective_org_id):+ return await get_effective_org_id()+ return None+++async def _effective_org_matches(+ *,+ workspace_id: int,+ workspace_org_id: UUID,+ user_context: UserContext,+) -> bool:+ effective_org_id = await _get_effective_org_id(user_context)+ if effective_org_id is None:+ # Expected best-effort skip, not an anomaly: keep at info to avoid noise.+ logger.info(+ '[Jira DC] Skipping Jira DC token injection because workspace %s is '+ 'org-scoped but no effective org was resolved',+ workspace_id,+ )+ return False+ return effective_org_id == workspace_org_id+++async def _workspace_matches_context(+ workspace: JiraDcWorkspace, user_context: UserContext+) -> bool:+ workspace_org_id = getattr(workspace, 'org_id', None)+ if workspace_org_id is None:+ return True+ return await _effective_org_matches(+ workspace_id=workspace.id,+ workspace_org_id=workspace_org_id,+ user_context=user_context,+ )+++async def _resolve_user_token(+ *,+ user_id: str,+ workspace_id: int,+ token_manager: TokenManager,+ store: JiraDcIntegrationStore,+ strict: bool,+) -> JiraDcUserToken | None:+ try:+ return await get_user_jira_dc_token(+ keycloak_user_id=user_id,+ workspace_id=workspace_id,+ token_manager=token_manager,+ store=store,+ )+ except JiraDcUserTokenError:+ if strict:+ raise+ logger.warning(+ '[Jira DC] Skipping Jira DC token injection because the linked user '+ 'does not have a usable token',+ exc_info=True,+ )+ return None+++class JiraDcConversationSecretEnricher(ConversationSecretEnricher):+ async def enrich(+ self,+ *,+ user_context: UserContext,+ user: UserInfo,+ trigger: ConversationTrigger | None,+ system_message_suffix: str | None,+ web_url: str | None,+ jwt_service: JwtService,+ access_token_hard_timeout: timedelta | None,+ ) -> ConversationSecretEnrichment:+ # Identity is resolved via user_context; `user` is required only by the interface.+ del user++ if not JIRA_DC_ENABLE_OAUTH:+ return ConversationSecretEnrichment(+ system_message_suffix=system_message_suffix+ )++ user_id = await user_context.get_user_id()+ if not user_id:+ return ConversationSecretEnrichment(+ system_message_suffix=system_message_suffix+ )++ store = JiraDcIntegrationStore.get_instance()+ jira_dc_user = await store.get_user_by_active_workspace(user_id)+ if not jira_dc_user:+ return ConversationSecretEnrichment(+ system_message_suffix=system_message_suffix+ )++ workspace = await store.get_workspace_by_id(jira_dc_user.jira_dc_workspace_id)+ if not workspace or workspace.status != 'active':+ return ConversationSecretEnrichment(+ system_message_suffix=system_message_suffix+ )+ if not _workspace_matches_configured_jira_dc_host(workspace.name):+ return ConversationSecretEnrichment(+ system_message_suffix=system_message_suffix+ )+ if not await _workspace_matches_context(workspace, user_context):+ return ConversationSecretEnrichment(+ system_message_suffix=system_message_suffix+ )++ secrets: dict[str, SecretSource] = {+ 'JIRA_DC_BASE_URL': StaticSecret(+ value=SecretStr(JIRA_DC_BASE_URL),+ description='Jira Data Center base URL',+ )+ }++ token_manager = TokenManager()+ strict = trigger == ConversationTrigger.JIRA+ if web_url:+ if strict:+ # Jira resolver starts must fail before launching the sandbox so+ # the webhook manager can post the existing re-link prompt.+ await _resolve_user_token(+ user_id=user_id,+ workspace_id=workspace.id,+ token_manager=token_manager,+ store=store,+ strict=True,+ )+ access_token = jwt_service.create_jws_token(+ payload={+ 'user_id': user_id,+ 'integration': 'jira_dc',+ 'secret_name': 'JIRA_DC_TOKEN',+ 'workspace_id': workspace.id,+ },+ expires_in=access_token_hard_timeout,+ )+ secrets['JIRA_DC_TOKEN'] = LookupSecret(+ url=f'{web_url}/integration/jira-dc/secrets/token',+ headers={'X-Access-Token': access_token},+ description='Jira Data Center OAuth access token',+ )+ else:+ user_token = await _resolve_user_token(+ user_id=user_id,+ workspace_id=workspace.id,+ token_manager=token_manager,+ store=store,+ strict=strict,+ )+ if user_token is None:+ return ConversationSecretEnrichment(+ system_message_suffix=system_message_suffix+ )+ secrets['JIRA_DC_TOKEN'] = StaticSecret(+ value=user_token.access_token,+ description='Jira Data Center OAuth access token',+ )++ return ConversationSecretEnrichment(+ secrets=secrets,+ system_message_suffix=_append_jira_dc_hint(system_message_suffix),+ )diff --git a/enterprise/integrations/jira_dc/jira_dc_view.py b/enterprise/integrations/jira_dc/jira_dc_view.pyindex 2944458f59..b65710d15b 100644--- a/enterprise/integrations/jira_dc/jira_dc_view.py+++ b/enterprise/integrations/jira_dc/jira_dc_view.py@@ -12,18 +12,13 @@ from integrations.jira_dc.jira_dc_types import (JiraDcViewInterface,StartingConvoException,)-from integrations.jira_dc.jira_dc_user_token import (- get_user_jira_dc_token,-)from integrations.jira_dc.jira_dc_v1_callback_processor import JiraDcV1CallbackProcessorfrom integrations.models import JobContextfrom integrations.resolver_context import ResolverUserContextfrom integrations.resolver_org_router import resolve_org_for_repofrom integrations.utils import CONVERSATION_URLfrom jinja2 import Environment-from pydantic import SecretStrfrom server.auth.constants import JIRA_DC_ENABLE_OAUTH-from server.auth.token_manager import TokenManagerfrom storage.jira_dc_conversation import JiraDcConversationfrom storage.jira_dc_integration_store import JiraDcIntegrationStorefrom storage.jira_dc_user import JiraDcUser@@ -129,29 +124,6 @@ class JiraDcNewConversationView(JiraDcViewInterface):injector_state = InjectorState()- sandbox_secrets: dict[str, SecretStr] = {}- if JIRA_DC_ENABLE_OAUTH:- # Resolve per-user OAuth token and inject into sandbox environment.- # JiraDcUserTokenError is intentionally not caught here β it propagates- # to start_job which posts a re-link comment on the Jira issue.- # TODO(jira-dc-account-token): move Jira credentials to the shared- # account-level integration capability path and use LookupSecret so- # non-Jira triggers can resolve the freshest token without copying- # this resolver-scoped StaticSecret pattern.- token_manager = TokenManager()- user_token = await get_user_jira_dc_token(- keycloak_user_id=self.jira_dc_user.keycloak_user_id,- workspace_id=self.jira_dc_workspace.id,- token_manager=token_manager,- store=integration_store,- )- sandbox_secrets['JIRA_DC_TOKEN'] = SecretStr(- user_token.access_token.get_secret_value()- )- sandbox_secrets['JIRA_DC_BASE_URL'] = SecretStr(- self.job_context.base_api_url- )-# Create the V1 conversation start requeststart_request = AppConversationStartRequest(conversation_id=UUID(self.conversation_id),@@ -163,7 +135,6 @@ class JiraDcNewConversationView(JiraDcViewInterface):title=f'Jira DC Issue {self.job_context.issue_key}: {self.job_context.issue_title or "Unknown"}',trigger=ConversationTrigger.JIRA,processors=[jira_dc_callback_processor],- secrets=sandbox_secrets,)# Set up the Jira DC user context for the V1 systemdiff --git a/enterprise/server/config.py b/enterprise/server/config.pyindex b2410e576c..aa6fdf7759 100644--- a/enterprise/server/config.py+++ b/enterprise/server/config.py@@ -64,6 +64,10 @@ class SaaSServerConfig(ServerConfig):settings_store_class: str = 'storage.saas_settings_store.SaasSettingsStore'secret_store_class: str = 'storage.saas_secrets_store.SaasSecretsStore'user_auth_class: str = 'server.auth.saas_user_auth.SaasUserAuth'+ conversation_secret_enricher_class: str | None = (+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.'+ 'JiraDcConversationSecretEnricher'+ )analytics_user_provider_class: str = ('analytics.saas_user_provider.SaasAnalyticsUserProvider')diff --git a/enterprise/server/routes/integration/jira_dc.py b/enterprise/server/routes/integration/jira_dc.pyindex 6bce9f00f4..4659dfcc0a 100644--- a/enterprise/server/routes/integration/jira_dc.py+++ b/enterprise/server/routes/integration/jira_dc.py@@ -12,17 +12,25 @@ import httpxfrom fastapi import (APIRouter,BackgroundTasks,+ Depends,HTTPException,Request,+ Response,status,)from fastapi.responses import JSONResponse, RedirectResponse+from fastapi.security import APIKeyHeaderfrom integrations.jira_dc.jira_dc_manager import JiraDcManagerfrom integrations.jira_dc.jira_dc_service_account import (get_jira_dc_managed_service_account,get_jira_dc_service_account_config_error,)+from integrations.jira_dc.jira_dc_user_token import (+ JiraDcUserTokenError,+ get_user_jira_dc_token,+)from integrations.models import Message, SourceType+from jwt import InvalidTokenErrorfrom pydantic import BaseModel, Field, field_validatorfrom server.auth.constants import (AUTOMATION_EVENT_FORWARDING_ENABLED,@@ -37,6 +45,8 @@ from server.constants import WEB_HOSTfrom server.services.automation_event_service import AutomationEventServicefrom storage.redis import get_redis_client+from openhands.app_server.config import depends_jwt_service+from openhands.app_server.services.jwt_service import JwtServicefrom openhands.app_server.user_auth.user_auth import get_user_authfrom openhands.app_server.utils.logger import openhands_logger as logger@@ -185,6 +195,7 @@ jira_dc_integration_router = APIRouter(prefix='/integration/jira-dc')token_manager = TokenManager()jira_dc_manager = JiraDcManager(token_manager)automation_event_service = AutomationEventService(token_manager)+jwt_dependency = depends_jwt_service()redis_client = get_redis_client()@@ -206,6 +217,75 @@ def _workspace_matches_configured_jira_dc_host(workspace_name: str) -> bool:return workspace_name.lower() == configured_workspace.lower()+@jira_dc_integration_router.get('/secrets/token')+async def get_jira_dc_secret_token(+ access_token: str | None = Depends(+ APIKeyHeader(name='X-Access-Token', auto_error=False)+ ),+ jwt_service: JwtService = jwt_dependency,+) -> Response:+ """Resolve the linked user's Jira DC OAuth token for sandbox LookupSecret."""+ try:+ if not access_token:+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)++ payload = jwt_service.verify_jws_token(access_token)+ if (+ payload.get('integration') != 'jira_dc'+ or payload.get('secret_name') != 'JIRA_DC_TOKEN'+ ):+ raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)++ user_id = payload.get('user_id')+ workspace_id = payload.get('workspace_id')+ if not user_id or not workspace_id:+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)+ try:+ workspace_id_int = int(workspace_id)+ except (TypeError, ValueError):+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)++ workspace = await jira_dc_manager.integration_store.get_workspace_by_id(+ workspace_id_int+ )+ if (+ not workspace+ or workspace.status != 'active'+ or not _workspace_matches_configured_jira_dc_host(workspace.name)+ ):+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)++ jira_dc_user = await jira_dc_manager.integration_store.get_active_user_by_keycloak_id_and_workspace(+ user_id,+ workspace.id,+ )+ if not jira_dc_user:+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)++ user_token = await get_user_jira_dc_token(+ keycloak_user_id=user_id,+ workspace_id=workspace.id,+ token_manager=token_manager,+ store=jira_dc_manager.integration_store,+ )+ return Response(+ content=user_token.access_token.get_secret_value(),+ media_type='text/plain',+ )+ except HTTPException:+ raise+ except (InvalidTokenError, ValueError):+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)+ except JiraDcUserTokenError:+ logger.warning('[Jira DC] Linked Jira DC token is unavailable', exc_info=True)+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)+ except Exception:+ logger.warning(+ '[Jira DC] Failed to resolve Jira DC secret token', exc_info=True+ )+ raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)++async def _handle_workspace_link_creation(user_id: str,jira_dc_user_id: str,diff --git a/enterprise/tests/unit/integrations/jira_dc/test_jira_dc_conversation_secret_enricher.py b/enterprise/tests/unit/integrations/jira_dc/test_jira_dc_conversation_secret_enricher.pynew file mode 100644index 0000000000..1606d9d967--- /dev/null+++ b/enterprise/tests/unit/integrations/jira_dc/test_jira_dc_conversation_secret_enricher.py@@ -0,0 +1,199 @@+from datetime import timedelta+from types import SimpleNamespace+from unittest.mock import AsyncMock, MagicMock, patch+from uuid import UUID++import pytest+from integrations.jira_dc.jira_dc_conversation_secret_enricher import (+ JiraDcConversationSecretEnricher,+)+from integrations.jira_dc.jira_dc_user_token import (+ JiraDcUserToken,+ JiraDcUserTokenError,+)+from pydantic import SecretStr++from openhands.app_server.app_conversation.app_conversation_models import (+ ConversationTrigger,+)+from openhands.sdk.secret import LookupSecret, StaticSecret++ORG_ID = UUID('00000000-0000-0000-0000-000000000123')+OTHER_ORG_ID = UUID('00000000-0000-0000-0000-000000000456')+++class FakeUserContext:+ def __init__(self, *, user_id: str = 'kc-user', org_id: UUID | None = ORG_ID):+ self.user_id = user_id+ self.user_auth = MagicMock()+ self.user_auth.get_effective_org_id = AsyncMock(return_value=org_id)++ async def get_user_id(self) -> str:+ return self.user_id+++def _linked_store(*, org_id: UUID | None = ORG_ID):+ store = MagicMock()+ store.get_user_by_active_workspace = AsyncMock(+ return_value=SimpleNamespace(jira_dc_workspace_id=7)+ )+ store.get_workspace_by_id = AsyncMock(+ return_value=SimpleNamespace(+ id=7,+ name='jira.example.com',+ status='active',+ org_id=org_id,+ )+ )+ return store+++async def test_enricher_adds_jira_dc_lookup_secret_for_linked_user():+ store = _linked_store()+ jwt_service = MagicMock()+ jwt_service.create_jws_token.return_value = 'signed-token'++ with (+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_ENABLE_OAUTH',+ True,+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_BASE_URL',+ 'https://jira.example.com',+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JiraDcIntegrationStore.get_instance',+ return_value=store,+ ),+ ):+ enrichment = await JiraDcConversationSecretEnricher().enrich(+ user_context=FakeUserContext(),+ user=MagicMock(id='kc-user'),+ trigger=ConversationTrigger.SLACK,+ system_message_suffix='Existing instructions.',+ web_url='https://openhands.example.com',+ jwt_service=jwt_service,+ access_token_hard_timeout=timedelta(minutes=5),+ )++ assert isinstance(enrichment.secrets['JIRA_DC_BASE_URL'], StaticSecret)+ assert (+ enrichment.secrets['JIRA_DC_BASE_URL'].value.get_secret_value()+ == 'https://jira.example.com'+ )+ token_secret = enrichment.secrets['JIRA_DC_TOKEN']+ assert isinstance(token_secret, LookupSecret)+ assert (+ token_secret.url+ == 'https://openhands.example.com/integration/jira-dc/secrets/token'+ )+ assert token_secret.headers == {'X-Access-Token': 'signed-token'}+ assert 'JIRA_DC_TOKEN' in (enrichment.system_message_suffix or '')+++async def test_enricher_skips_org_scoped_workspace_when_context_org_differs():+ store = _linked_store(org_id=OTHER_ORG_ID)++ with (+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_ENABLE_OAUTH',+ True,+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_BASE_URL',+ 'https://jira.example.com',+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JiraDcIntegrationStore.get_instance',+ return_value=store,+ ),+ ):+ enrichment = await JiraDcConversationSecretEnricher().enrich(+ user_context=FakeUserContext(org_id=ORG_ID),+ user=MagicMock(id='kc-user'),+ trigger=ConversationTrigger.SLACK,+ system_message_suffix='Existing instructions.',+ web_url='https://openhands.example.com',+ jwt_service=MagicMock(),+ access_token_hard_timeout=timedelta(minutes=5),+ )++ assert enrichment.secrets == {}+ assert enrichment.system_message_suffix == 'Existing instructions.'+++async def test_enricher_validates_token_before_jira_triggered_start():+ store = _linked_store()+ get_token = AsyncMock(+ return_value=JiraDcUserToken(access_token=SecretStr('token'), expires_at=0)+ )+ jwt_service = MagicMock()+ jwt_service.create_jws_token.return_value = 'signed-token'++ with (+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_ENABLE_OAUTH',+ True,+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_BASE_URL',+ 'https://jira.example.com',+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JiraDcIntegrationStore.get_instance',+ return_value=store,+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.get_user_jira_dc_token',+ get_token,+ ),+ ):+ await JiraDcConversationSecretEnricher().enrich(+ user_context=FakeUserContext(),+ user=MagicMock(id='kc-user'),+ trigger=ConversationTrigger.JIRA,+ system_message_suffix=None,+ web_url='https://openhands.example.com',+ jwt_service=jwt_service,+ access_token_hard_timeout=timedelta(minutes=5),+ )++ get_token.assert_awaited_once()+++async def test_enricher_propagates_token_error_for_jira_triggered_start():+ store = _linked_store()++ with (+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_ENABLE_OAUTH',+ True,+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JIRA_DC_BASE_URL',+ 'https://jira.example.com',+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.JiraDcIntegrationStore.get_instance',+ return_value=store,+ ),+ patch(+ 'integrations.jira_dc.jira_dc_conversation_secret_enricher.get_user_jira_dc_token',+ AsyncMock(side_effect=JiraDcUserTokenError('re-link required')),+ ),+ ):+ with pytest.raises(JiraDcUserTokenError):+ await JiraDcConversationSecretEnricher().enrich(+ user_context=FakeUserContext(),+ user=MagicMock(id='kc-user'),+ trigger=ConversationTrigger.JIRA,+ system_message_suffix=None,+ web_url='https://openhands.example.com',+ jwt_service=MagicMock(),+ access_token_hard_timeout=timedelta(minutes=5),+ )diff --git a/enterprise/tests/unit/integrations/jira_dc/test_jira_dc_view.py b/enterprise/tests/unit/integrations/jira_dc/test_jira_dc_view.pyindex 279065e6f4..83403430ac 100644--- a/enterprise/tests/unit/integrations/jira_dc/test_jira_dc_view.py+++ b/enterprise/tests/unit/integrations/jira_dc/test_jira_dc_view.py@@ -4,17 +4,15 @@ from unittest.mock import AsyncMock, MagicMock, patchfrom uuid import UUIDimport pytest-from integrations.jira_dc.jira_dc_user_token import (- JiraDcUserToken,- JiraDcUserTokenError,-)from integrations.jira_dc.jira_dc_view import (JiraDcExistingConversationView,JiraDcFactory,JiraDcNewConversationView,)-from pydantic import SecretStr+from openhands.app_server.app_conversation.app_conversation_models import (+ ConversationTrigger,+)from openhands.app_server.integrations.service_types import ProviderType, Repository@@ -95,34 +93,22 @@ async def test_new_conversation_resolves_org_from_selected_repo_claim(# ----------------------------------------------------------------------------# Token injection into AppConversationStartRequest+# V1 AppConversationStartRequest setup# ----------------------------------------------------------------------------def _make_start_conversation_patches(user_token=None, token_error=None):+def _make_start_conversation_patches():"""Return a context-manager stack that stubs everything _create_v1_conversation touches."""import contextlib@contextlib.asynccontextmanagerasync def _patches(view):- mock_token = user_token or JiraDcUserToken(- access_token=SecretStr('the_access_token'), expires_at=9999999999- )-mock_app_conversation_service = AsyncMock()mock_app_conversation_service.start_app_conversation = AsyncMock(return_value=aiter([]))with (- patch(- 'integrations.jira_dc.jira_dc_view.get_user_jira_dc_token',- new=AsyncMock(- return_value=mock_token,- side_effect=token_error,- ),- ),- patch('integrations.jira_dc.jira_dc_view.TokenManager'),patch('integrations.jira_dc.jira_dc_view.integration_store'),patch('integrations.jira_dc.jira_dc_view.resolve_org_for_repo',@@ -148,10 +134,10 @@ async def aiter(iterable):@pytest.mark.asyncio-async def test_create_v1_conversation_injects_jira_dc_token(+async def test_create_v1_conversation_delegates_jira_dc_token_enrichment(new_conversation_view, mock_jinja_env):- """start_request.secrets must contain JIRA_DC_TOKEN and JIRA_DC_BASE_URL."""+ """Jira credentials are added by the shared app conversation enricher."""new_conversation_view.conversation_id = 'a1b2c3d4e5f64a5b8c9d0e1f2a3b4c5d'captured_requests = []@@ -166,21 +152,15 @@ async def test_create_v1_conversation_injects_jira_dc_token(assert len(captured_requests) == 1req = captured_requests[0]- assert req.secrets is not None- assert 'JIRA_DC_TOKEN' in req.secrets- assert req.secrets['JIRA_DC_TOKEN'].get_secret_value() == 'the_access_token'- assert 'JIRA_DC_BASE_URL' in req.secrets- assert (- req.secrets['JIRA_DC_BASE_URL'].get_secret_value()- == new_conversation_view.job_context.base_api_url- )+ assert req.trigger == ConversationTrigger.JIRA+ assert req.secrets is None@pytest.mark.asyncio-async def test_create_v1_conversation_skips_jira_dc_token_when_oauth_disabled(+async def test_create_v1_conversation_does_not_fetch_jira_dc_token(new_conversation_view, mock_jinja_env):- """Legacy email-match mode must not require per-user OAuth tokens."""+ """The resolver must not bypass the shared secret enricher."""new_conversation_view.conversation_id = 'a1b2c3d4e5f64a5b8c9d0e1f2a3b4c5d'captured_requests = []@@ -189,48 +169,9 @@ async def test_create_v1_conversation_skips_jira_dc_token_when_oauth_disabled(returnyield # make it an async generator- mock_app_conversation_service = AsyncMock()- mock_app_conversation_service.start_app_conversation = _fake_start- get_token = AsyncMock()-- with (- patch('integrations.jira_dc.jira_dc_view.JIRA_DC_ENABLE_OAUTH', False),- patch('integrations.jira_dc.jira_dc_view.get_user_jira_dc_token', get_token),- patch('integrations.jira_dc.jira_dc_view.TokenManager'),- patch('integrations.jira_dc.jira_dc_view.integration_store'),- patch(- 'integrations.jira_dc.jira_dc_view.resolve_org_for_repo',- new=AsyncMock(return_value=None),- ),- patch('integrations.jira_dc.jira_dc_view.ProviderHandler'),- patch(- 'integrations.jira_dc.jira_dc_view.get_app_conversation_service',- ) as mock_svc_ctx,- ):- mock_svc_ctx.return_value.__aenter__ = AsyncMock(- return_value=mock_app_conversation_service- )- mock_svc_ctx.return_value.__aexit__ = AsyncMock(return_value=False)-+ async with _make_start_conversation_patches()(new_conversation_view) as mock_svc:+ mock_svc.start_app_conversation = _fake_startawait new_conversation_view._create_v1_conversation(mock_jinja_env)- get_token.assert_not_called()assert len(captured_requests) == 1- assert captured_requests[0].secrets == {}---async def test_create_v1_conversation_propagates_token_error(- new_conversation_view, mock_jinja_env-):- """JiraDcUserTokenError must propagate so start_job can post a re-link comment."""- with (- patch(- 'integrations.jira_dc.jira_dc_view.get_user_jira_dc_token',- new=AsyncMock(side_effect=JiraDcUserTokenError('no token')),- ),- patch('integrations.jira_dc.jira_dc_view.TokenManager'),- patch('integrations.jira_dc.jira_dc_view.integration_store'),- ):- with pytest.raises(JiraDcUserTokenError):- await new_conversation_view._create_v1_conversation(mock_jinja_env)+ assert captured_requests[0].secrets is Nonediff --git a/enterprise/tests/unit/server/routes/test_jira_dc_integration_routes.py b/enterprise/tests/unit/server/routes/test_jira_dc_integration_routes.pyindex 1713614f95..94c4e80771 100644--- a/enterprise/tests/unit/server/routes/test_jira_dc_integration_routes.py+++ b/enterprise/tests/unit/server/routes/test_jira_dc_integration_routes.py@@ -2,6 +2,7 @@ import jsonimport uuidfrom contextlib import asynccontextmanagerfrom datetime import datetime+from types import SimpleNamespacefrom unittest.mock import AsyncMock, MagicMock, patchfrom urllib.parse import parse_qs, urlparse@@ -9,7 +10,8 @@ import pytestfrom fastapi import HTTPException, Request, statusfrom fastapi.responses import RedirectResponsefrom integrations.jira_dc.jira_dc_service_account import JiraDcServiceAccount-from pydantic import ValidationError+from integrations.jira_dc.jira_dc_user_token import JiraDcUserToken+from pydantic import SecretStr, ValidationErrorfrom server.auth.saas_user_auth import SaasUserAuthfrom server.routes.integration.jira_dc import (JiraDcLinkCreate,@@ -19,6 +21,7 @@ from server.routes.integration.jira_dc import (create_jira_dc_workspace,create_workspace_link,get_current_workspace_link,+ get_jira_dc_secret_token,jira_dc_callback,jira_dc_connection_events,unlink_workspace,@@ -141,6 +144,52 @@ def mock_user_auth():return auth+@patch(+ 'server.routes.integration.jira_dc.get_user_jira_dc_token', new_callable=AsyncMock+)+@patch('server.routes.integration.jira_dc.jira_dc_manager')+async def test_get_jira_dc_secret_token_success(mock_manager, mock_get_token):+ store = AsyncMock()+ mock_manager.integration_store = store+ store.get_workspace_by_id.return_value = SimpleNamespace(+ id=7,+ name='jira.example.com',+ status='active',+ )+ store.get_active_user_by_keycloak_id_and_workspace.return_value = MagicMock()+ mock_get_token.return_value = JiraDcUserToken(+ access_token=SecretStr('plain-token'), expires_at=0+ )+ jwt_service = MagicMock()+ jwt_service.verify_jws_token.return_value = {+ 'integration': 'jira_dc',+ 'secret_name': 'JIRA_DC_TOKEN',+ 'user_id': 'kc-user',+ 'workspace_id': 7,+ }++ with (+ patch('server.routes.integration.jira_dc.JIRA_DC_ENABLE_OAUTH', True),+ patch(+ 'server.routes.integration.jira_dc.JIRA_DC_BASE_URL',+ 'https://jira.example.com',+ ),+ ):+ response = await get_jira_dc_secret_token(+ access_token='signed-token',+ jwt_service=jwt_service,+ )++ assert response.body == b'plain-token'+ store.get_workspace_by_id.assert_awaited_once_with(7)+ store.get_active_user_by_keycloak_id_and_workspace.assert_awaited_once_with(+ 'kc-user',+ 7,+ )+ mock_get_token.assert_awaited_once()++@pytest.mark.asyncio@patch('server.routes.integration.jira_dc.jira_dc_manager', new_callable=AsyncMock)@patch('server.routes.integration.jira_dc.redis_client', new_callable=MagicMock)diff --git a/openhands/app_server/app_conversation/conversation_secret_enricher.py b/openhands/app_server/app_conversation/conversation_secret_enricher.pynew file mode 100644index 0000000000..8fe4665864--- /dev/null+++ b/openhands/app_server/app_conversation/conversation_secret_enricher.py@@ -0,0 +1,40 @@+from __future__ import annotations++from dataclasses import dataclass, field+from datetime import timedelta++from openhands.app_server.app_conversation.app_conversation_models import (+ ConversationTrigger,+)+from openhands.app_server.services.jwt_service import JwtService+from openhands.app_server.user.user_context import UserContext+from openhands.app_server.user.user_models import UserInfo+from openhands.sdk.secret import SecretSource+++@dataclass+class ConversationSecretEnrichment:+ secrets: dict[str, SecretSource] = field(default_factory=dict)+ system_message_suffix: str | None = None+++class ConversationSecretEnricher:+ """Extension point for integration-scoped conversation secrets.++ This intentionally runs only while building a conversation start request.+ It should not be used for persisted custom secrets or sandbox settings+ secret listing.+ """++ async def enrich(+ self,+ *,+ user_context: UserContext,+ user: UserInfo,+ trigger: ConversationTrigger | None,+ system_message_suffix: str | None,+ web_url: str | None,+ jwt_service: JwtService,+ access_token_hard_timeout: timedelta | None,+ ) -> ConversationSecretEnrichment:+ return ConversationSecretEnrichment(system_message_suffix=system_message_suffix)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 34768eeced..d35a088806 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@@ -6,7 +6,7 @@ import tempfileimport zipfilefrom collections import defaultdictfrom collections.abc import Mapping-from dataclasses import dataclass+from dataclasses import dataclass, fieldfrom datetime import datetime, timedeltafrom typing import Any, AsyncGenerator, Sequence, castfrom uuid import UUID, uuid4@@ -50,6 +50,9 @@ from openhands.app_server.app_conversation.app_conversation_service_base importfrom openhands.app_server.app_conversation.app_conversation_start_task_service import (AppConversationStartTaskService,)+from openhands.app_server.app_conversation.conversation_secret_enricher import (+ ConversationSecretEnricher,+)from openhands.app_server.app_conversation.hook_loader import (load_hooks_from_agent_server,)@@ -91,6 +94,7 @@ from openhands.app_server.utils.docker_utils import (replace_localhost_hostname_for_docker,)from openhands.app_server.utils.git import ensure_valid_git_branch_name+from openhands.app_server.utils.import_utils import get_implfrom openhands.app_server.utils.llm_metadata import (get_llm_metadata,should_set_litellm_extra_body,@@ -159,6 +163,9 @@ class LiveStatusAppConversationService(AppConversationServiceBase):web_url: str | Noneopenhands_provider_base_url: str | Noneaccess_token_hard_timeout: timedelta | None+ conversation_secret_enricher: ConversationSecretEnricher = field(+ default_factory=ConversationSecretEnricher+ )app_mode: str | None = Noneasync def _get_sandbox_grouping_strategy(self) -> SandboxGroupingStrategy:@@ -333,6 +340,7 @@ class LiveStatusAppConversationService(AppConversationServiceBase):working_dir,request.agent_type,request.llm_model,+ trigger=request.trigger,remote_workspace=remote_workspace,selected_repository=request.selected_repository,plugins=request.plugins,@@ -974,42 +982,78 @@ class LiveStatusAppConversationService(AppConversationServiceBase):PROVIDER_TOKEN_TYPE | None,await self.user_context.get_provider_tokens(),)- if not provider_tokens:- return secrets+ if provider_tokens:+ # Create secrets for each provider token+ for provider_type, provider_token in provider_tokens.items():+ if not provider_token.token:+ continue- # Create secrets for each provider token- for provider_type, provider_token in provider_tokens.items():- if not provider_token.token:- continue+ secret_name = f'{provider_type.name}_TOKEN'+ description = f'{provider_type.name} authentication token'++ if self.web_url:+ # Create an access token for web-based authentication+ access_token = self.jwt_service.create_jws_token(+ payload={+ 'user_id': user.id,+ 'provider_type': provider_type.value,+ },+ expires_in=self.access_token_hard_timeout,+ )+ headers = {'X-Access-Token': access_token}++ secrets[secret_name] = LookupSecret(+ url=self.web_url + '/api/v1/webhooks/secrets',+ headers=headers,+ description=description,+ )+ else:+ # Use static token for environments without web URL access+ static_token = await self.user_context.get_latest_token(+ provider_type+ )+ if static_token:+ secrets[secret_name] = StaticSecret(+ value=SecretStr(static_token), description=description+ )- secret_name = f'{provider_type.name}_TOKEN'- description = f'{provider_type.name} authentication token'+ return secrets- if self.web_url:- # Create an access token for web-based authentication- access_token = self.jwt_service.create_jws_token(- payload={- 'user_id': user.id,- 'provider_type': provider_type.value,- },- expires_in=self.access_token_hard_timeout,- )- headers = {'X-Access-Token': access_token}+ async def _setup_conversation_secrets(+ self,+ user: UserInfo,+ trigger: ConversationTrigger | None,+ system_message_suffix: str | None,+ ) -> tuple[dict, str | None]:+ """Set up custom, git provider, and integration-scoped secrets.- secrets[secret_name] = LookupSecret(- url=self.web_url + '/api/v1/webhooks/secrets',- headers=headers,- description=description,+ Args:+ user: User information containing authentication details+ trigger: Trigger that started the conversation.+ system_message_suffix: Current system message suffix.++ Returns:+ Tuple of secrets and updated system message suffix.+ """+ secrets = await self._setup_secrets_for_git_providers(user)++ enrichment = await self.conversation_secret_enricher.enrich(+ user_context=self.user_context,+ user=user,+ trigger=trigger,+ system_message_suffix=system_message_suffix,+ web_url=self.web_url,+ jwt_service=self.jwt_service,+ access_token_hard_timeout=self.access_token_hard_timeout,+ )+ for name, source in enrichment.secrets.items():+ if name in secrets:+ _logger.warning(+ 'Integration-provided secret %r overrides existing secret', name)- else:- # Use static token for environments without web URL access- static_token = await self.user_context.get_latest_token(provider_type)- if static_token:- secrets[secret_name] = StaticSecret(- value=SecretStr(static_token), description=description- )+ secrets[name] = source- return secrets+ return secrets, enrichment.system_message_suffixdef _configure_llm(self, user: UserInfo, llm_model: str | None) -> LLM:"""Configure LLM settings.@@ -1326,6 +1370,7 @@ class LiveStatusAppConversationService(AppConversationServiceBase):working_dir: str,agent_type: AgentType = AgentType.DEFAULT,llm_model: str | None = None,+ trigger: ConversationTrigger | None = None,remote_workspace: AsyncRemoteWorkspace | None = None,selected_repository: str | None = None,plugins: list[PluginSpec] | None = None,@@ -1350,6 +1395,7 @@ class LiveStatusAppConversationService(AppConversationServiceBase):working_dir: Working directory pathagent_type: Type of agent (DEFAULT or PLAN)llm_model: Optional specific LLM model to use+ trigger: Optional conversation trigger.remote_workspace: Optional remote workspace instanceselected_repository: Optional repository nameplugins: Optional list of plugins to load@@ -1366,6 +1412,8 @@ class LiveStatusAppConversationService(AppConversationServiceBase):sandbox=sandbox,conversation_id=conversation_id,initial_message=initial_message,+ system_message_suffix=system_message_suffix,+ trigger=trigger,working_dir=working_dir,selected_repository=selected_repository,plugins=plugins,@@ -1387,7 +1435,11 @@ class LiveStatusAppConversationService(AppConversationServiceBase):# --- secrets --------------------------------------------------------# Start with secrets from git providers and database- secrets = await self._setup_secrets_for_git_providers(user)+ secrets, system_message_suffix = await self._setup_conversation_secrets(+ user,+ trigger,+ system_message_suffix,+ )# Merge API-provided secrets (they take precedence over existing ones)if api_secrets:@@ -1602,6 +1654,8 @@ class LiveStatusAppConversationService(AppConversationServiceBase):conversation_id: UUID,initial_message: SendMessageRequest | None,working_dir: str,+ system_message_suffix: str | None = None,+ trigger: ConversationTrigger | None = None,selected_repository: str | None = None,plugins: list[PluginSpec] | None = None,api_secrets: dict[str, SecretStr] | None = None,@@ -1623,6 +1677,8 @@ class LiveStatusAppConversationService(AppConversationServiceBase):conversation_id: Unique conversation identifierinitial_message: Optional initial message to sendworking_dir: Working directory path+ system_message_suffix: Optional suffix for system message.+ trigger: Optional conversation trigger.selected_repository: Optional repository nameplugins: Optional list of plugins to loadapi_secrets: Optional secrets passed directly via the API.@@ -1637,9 +1693,8 @@ class LiveStatusAppConversationService(AppConversationServiceBase):# (e.g. X-Access-Token) are redacted by the SDK serializer because# "TOKEN" matches SECRET_KEY_PATTERNS, leaving headers: {} and# causing provider auth to silently fail at subprocess launch.- # Use the raw custom secrets directly, then fold in git provider tokens- # as StaticSecrets (bypassing the LookupSecret wrapping that- # _setup_secrets_for_git_providers does for non-ACP paths).+ # Use raw custom secrets, static git provider tokens, and static+ # integration-scoped secrets for ACP conversations.secrets: dict = await self.user_context.get_secrets()provider_tokens = cast(PROVIDER_TOKEN_TYPE | None,@@ -1657,6 +1712,23 @@ class LiveStatusAppConversationService(AppConversationServiceBase):description=f'{provider_type.name} authentication token',)+ enrichment = await self.conversation_secret_enricher.enrich(+ user_context=self.user_context,+ user=user,+ trigger=trigger,+ system_message_suffix=system_message_suffix,+ web_url=None,+ jwt_service=self.jwt_service,+ access_token_hard_timeout=self.access_token_hard_timeout,+ )+ for name, source in enrichment.secrets.items():+ if name in secrets:+ _logger.warning(+ 'Integration-provided secret %r overrides existing secret', name+ )+ secrets[name] = source+ system_message_suffix = enrichment.system_message_suffix+if api_secrets:from openhands.app_server.constants import (validate_secret_name,@@ -1681,14 +1753,17 @@ class LiveStatusAppConversationService(AppConversationServiceBase):# across pause/resume β matching the regular-agent lifecycle (#1274).# Strip llm.api_key/base_url to prevent proxy settings from leaking# into the subprocess env (ACP CLIs handle their own LLM calls).- acp_settings_for_agent = acp_settings.model_copy(- update={- 'acp_isolate_data_dir': True,- 'llm': acp_settings.llm.model_copy(- update={'api_key': None, 'base_url': None}- ),- }- )+ settings_update: dict[str, Any] = {+ 'acp_isolate_data_dir': True,+ 'llm': acp_settings.llm.model_copy(+ update={'api_key': None, 'base_url': None}+ ),+ }+ if system_message_suffix:+ settings_update['agent_context'] = AgentContext(+ system_message_suffix=system_message_suffix+ )+ acp_settings_for_agent = acp_settings.model_copy(update=settings_update)acp_agent = acp_settings_for_agent.create_agent()sdk_plugins: list[PluginSource] | None = None@@ -2216,12 +2291,18 @@ class LiveStatusAppConversationServiceInjector(AppConversationServiceInjector):# Get app_mode for SaaS modeapp_mode = None+ conversation_secret_enricher = ConversationSecretEnricher()try:from openhands.app_server.shared import server_configapp_mode = (server_config.app_mode.value if server_config.app_mode else None)+ enricher_cls = get_impl(+ ConversationSecretEnricher,+ server_config.conversation_secret_enricher_class,+ )+ conversation_secret_enricher = enricher_cls()except (ImportError, AttributeError):# If server_config is not available (e.g., in tests), continue without itpass@@ -2244,5 +2325,6 @@ class LiveStatusAppConversationServiceInjector(AppConversationServiceInjector):web_url=web_url,openhands_provider_base_url=config.openhands_provider_base_url,access_token_hard_timeout=access_token_hard_timeout,+ conversation_secret_enricher=conversation_secret_enricher,app_mode=app_mode,)diff --git a/openhands/app_server/server_config/server_config.py b/openhands/app_server/server_config/server_config.pyindex 52b0d13bf7..a90dec6051 100644--- a/openhands/app_server/server_config/server_config.py+++ b/openhands/app_server/server_config/server_config.py@@ -23,6 +23,7 @@ class ServerConfig(ServerConfigInterface):user_auth_class: str = ('openhands.app_server.user_auth.default_user_auth.DefaultUserAuth')+ conversation_secret_enricher_class: str | None = Noneanalytics_user_provider_class: str | None = Noneenable_v1: bool = os.getenv('ENABLE_V1') != '0'