Skip to content

πŸ™Œ 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.py
new file mode 100644
index 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.py
index 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 JiraDcV1CallbackProcessor
from integrations.models import JobContext
from integrations.resolver_context import ResolverUserContext
from integrations.resolver_org_router import resolve_org_for_repo
from integrations.utils import CONVERSATION_URL
from jinja2 import Environment
-from pydantic import SecretStr
from server.auth.constants import JIRA_DC_ENABLE_OAUTH
-from server.auth.token_manager import TokenManager
from storage.jira_dc_conversation import JiraDcConversation
from storage.jira_dc_integration_store import JiraDcIntegrationStore
from 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 request
start_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 system
diff --git a/enterprise/server/config.py b/enterprise/server/config.py
index 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.py
index 6bce9f00f4..4659dfcc0a 100644
--- a/enterprise/server/routes/integration/jira_dc.py
+++ b/enterprise/server/routes/integration/jira_dc.py
@@ -12,17 +12,25 @@ import httpx
from fastapi import (
APIRouter,
BackgroundTasks,
+ Depends,
HTTPException,
Request,
+ Response,
status,
)
from fastapi.responses import JSONResponse, RedirectResponse
+from fastapi.security import APIKeyHeader
from integrations.jira_dc.jira_dc_manager import JiraDcManager
from 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 InvalidTokenError
from pydantic import BaseModel, Field, field_validator
from server.auth.constants import (
AUTOMATION_EVENT_FORWARDING_ENABLED,
@@ -37,6 +45,8 @@ from server.constants import WEB_HOST
from server.services.automation_event_service import AutomationEventService
from storage.redis import get_redis_client
+from openhands.app_server.config import depends_jwt_service
+from openhands.app_server.services.jwt_service import JwtService
from openhands.app_server.user_auth.user_auth import get_user_auth
from 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.py
new file mode 100644
index 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.py
index 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, patch
from uuid import UUID
import 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.asynccontextmanager
async 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) == 1
req = 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(
return
yield # 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_start
await 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 None
diff --git a/enterprise/tests/unit/server/routes/test_jira_dc_integration_routes.py b/enterprise/tests/unit/server/routes/test_jira_dc_integration_routes.py
index 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 json
import uuid
from contextlib import asynccontextmanager
from datetime import datetime
+from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
from urllib.parse import parse_qs, urlparse
@@ -9,7 +10,8 @@ import pytest
from fastapi import HTTPException, Request, status
from fastapi.responses import RedirectResponse
from 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, ValidationError
from server.auth.saas_user_auth import SaasUserAuth
from 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.py
new file mode 100644
index 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.py
index 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 tempfile
import zipfile
from collections import defaultdict
from collections.abc import Mapping
-from dataclasses import dataclass
+from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Any, AsyncGenerator, Sequence, cast
from uuid import UUID, uuid4
@@ -50,6 +50,9 @@ from openhands.app_server.app_conversation.app_conversation_service_base import
from 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_impl
from 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 | None
openhands_provider_base_url: str | None
access_token_hard_timeout: timedelta | None
+ conversation_secret_enricher: ConversationSecretEnricher = field(
+ default_factory=ConversationSecretEnricher
+ )
app_mode: str | None = None
async 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_suffix
def _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 path
agent_type: Type of agent (DEFAULT or PLAN)
llm_model: Optional specific LLM model to use
+ trigger: Optional conversation trigger.
remote_workspace: Optional remote workspace instance
selected_repository: Optional repository name
plugins: 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 identifier
initial_message: Optional initial message to send
working_dir: Working directory path
+ system_message_suffix: Optional suffix for system message.
+ trigger: Optional conversation trigger.
selected_repository: Optional repository name
plugins: Optional list of plugins to load
api_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 mode
app_mode = None
+ conversation_secret_enricher = ConversationSecretEnricher()
try:
from openhands.app_server.shared import server_config
app_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 it
pass
@@ -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.py
index 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 = None
analytics_user_provider_class: str | None = None
enable_v1: bool = os.getenv('ENABLE_V1') != '0'