π OpenHands: AI-Driven Development
feat: add bitbucket data center resolver for pr comment triggers (#14233)
Hiep Lefa7a7aaef759
diff --git a/enterprise/integrations/bitbucket_data_center/bitbucket_dc_manager.py b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_manager.pynew file mode 100644index 0000000000..a90727f8e9--- /dev/null+++ b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_manager.py@@ -0,0 +1,267 @@+from __future__ import annotations++from types import MappingProxyType++from integrations.bitbucket_data_center.bitbucket_dc_view import (+ BitbucketDCFactory,+ BitbucketDCInlinePRComment,+ BitbucketDCPRComment,+ BitbucketDCViewType,+ extract_actor_slug,+)+from integrations.manager import Manager+from integrations.models import Message, SourceType+from integrations.types import ResolverViewInterface+from integrations.utils import (+ CONVERSATION_URL,+ HOST_URL,+ OPENHANDS_RESOLVER_TEMPLATES_DIR,+ get_session_expired_message,+)+from integrations.v1_utils import get_saas_user_auth+from jinja2 import Environment, FileSystemLoader+from pydantic import SecretStr+from server.auth.token_manager import TokenManager+from storage.bitbucket_dc_webhook_store import BitbucketDCWebhookStore++from openhands.app_server.integrations.provider import ProviderToken, ProviderType+from openhands.app_server.secrets.secrets_models import Secrets+from openhands.core.logger import openhands_logger as logger+from openhands.server.types import (+ LLMAuthenticationError,+ MissingSettingsError,+ SessionExpiredError,+)+++class BitbucketDCManager(Manager[BitbucketDCViewType]):+ """Resolver manager for Bitbucket Data Center webhook events."""++ def __init__(+ self,+ token_manager: TokenManager,+ data_collector: None = None,+ ) -> None:+ self.token_manager = token_manager+ self.webhook_store = BitbucketDCWebhookStore()+ # Reuse the Bitbucket Cloud Jinja templates β wording is provider-+ # agnostic and the variables (pr_number, branch_name, comments,+ # file_location, line_number) match.+ self.jinja_env = Environment(+ loader=FileSystemLoader(OPENHANDS_RESOLVER_TEMPLATES_DIR + 'bitbucket')+ )++ def _confirm_incoming_source_type(self, message: Message) -> None:+ if message.source != SourceType.BITBUCKET_DATA_CENTER:+ raise ValueError(f'Unexpected message source {message.source}')++ @staticmethod+ def _extract_repo_identity(message: Message) -> tuple[str, str]:+ payload = message.message.get('payload') or {}+ pull_request = payload.get('pullRequest') or {}+ repository = (pull_request.get('toRef') or {}).get('repository') or {}+ project = repository.get('project') or {}+ return project.get('key') or '', repository.get('slug') or ''++ async def _commenter_has_write_access(+ self, message: Message, installer_user_id: str+ ) -> bool:+ """Use the installer's Bitbucket DC token to check whether the+ commenter has ``REPO_WRITE``/``REPO_ADMIN`` permission on the PR's+ repository β mirrors the Cloud manager's installer-scoped check.+ """+ from integrations.bitbucket_data_center.bitbucket_dc_service import (+ SaaSBitbucketDCService,+ )++ project_key, repo_slug = self._extract_repo_identity(message)+ actor = (message.message.get('payload') or {}).get('actor') or {}+ actor_slug = extract_actor_slug(actor)+ if not actor_slug:+ return False++ installer_service = SaaSBitbucketDCService(external_auth_id=installer_user_id)+ try:+ return await installer_service.user_has_write_access_for(+ project_key, repo_slug, actor_slug+ )+ except Exception as e:+ logger.warning(+ f'[Bitbucket DC] permission check failed for '+ f'{project_key}/{repo_slug}: {e}'+ )+ return False++ async def receive_message(self, message: Message) -> None:+ self._confirm_incoming_source_type(message)+ if not self.is_job_requested(message):+ return++ project_key, repo_slug = self._extract_repo_identity(message)+ installer_user_id = await self.webhook_store.get_webhook_user_id(+ project_key=project_key, repo_slug=repo_slug+ )+ if not installer_user_id:+ logger.warning(+ f'[Bitbucket DC] No installer recorded for '+ f'{project_key}/{repo_slug}'+ )+ return++ if not await self._commenter_has_write_access(message, installer_user_id):+ payload = message.message.get('payload') or {}+ actor = payload.get('actor') or {}+ logger.info(+ f'[Bitbucket DC] {actor.get("displayName", "?")} lacks write '+ f'access to {project_key}/{repo_slug}; ignoring.'+ )+ return++ bitbucket_view = await BitbucketDCFactory.create_bitbucket_dc_view_from_payload(+ message, installer_user_id+ )+ logger.info(+ f'[Bitbucket DC] Creating job for {bitbucket_view.user_info.username} '+ f'in {bitbucket_view.full_repo_name}#{bitbucket_view.issue_number}'+ )+ await self.start_job(bitbucket_view)++ def is_job_requested(self, message: Message) -> bool:+ self._confirm_incoming_source_type(message)+ return BitbucketDCFactory.is_pr_comment(+ message+ ) or BitbucketDCFactory.is_pr_comment(message, inline=True)++ async def send_message(+ self, message: str, bitbucket_view: ResolverViewInterface+ ) -> None:+ from integrations.bitbucket_data_center.bitbucket_dc_service import (+ SaaSBitbucketDCService,+ )++ keycloak_user_id = bitbucket_view.user_info.keycloak_user_id+ bitbucket_service = SaaSBitbucketDCService(external_auth_id=keycloak_user_id)++ if isinstance(bitbucket_view, BitbucketDCInlinePRComment):+ await bitbucket_service.reply_to_pr_comment(+ owner=bitbucket_view.project_key,+ repo_slug=bitbucket_view.repo_slug,+ pr_id=bitbucket_view.issue_number,+ body=message,+ parent_comment_id=bitbucket_view.parent_comment_id,+ anchor={+ 'path': bitbucket_view.file_location,+ 'line': bitbucket_view.line_number,+ 'lineType': bitbucket_view.line_type,+ 'fileType': bitbucket_view.file_type,+ },+ )+ elif isinstance(bitbucket_view, BitbucketDCPRComment):+ await bitbucket_service.reply_to_pr_comment(+ owner=bitbucket_view.project_key,+ repo_slug=bitbucket_view.repo_slug,+ pr_id=bitbucket_view.issue_number,+ body=message,+ parent_comment_id=bitbucket_view.parent_comment_id,+ )+ else:+ logger.warning(+ f'[Bitbucket DC] Unsupported view type: '+ f'{type(bitbucket_view).__name__}'+ )++ async def start_job(self, bitbucket_view: BitbucketDCViewType) -> None:+ try:+ user_info = bitbucket_view.user_info+ try:+ logger.info(+ f'[Bitbucket DC] Starting job for {user_info.username} '+ f'in {bitbucket_view.full_repo_name}#{bitbucket_view.issue_number}'+ )++ offline_token = await self.token_manager.load_offline_token(+ user_info.keycloak_user_id+ )+ if not offline_token:+ logger.warning(+ f'[Bitbucket DC] No offline token for installer '+ f'{user_info.keycloak_user_id}'+ )+ raise MissingSettingsError('Missing settings')++ user_token = await self.token_manager.get_idp_token_from_offline_token(+ offline_token, ProviderType.BITBUCKET_DATA_CENTER+ )+ if not user_token:+ logger.warning(+ f'[Bitbucket DC] No Bitbucket DC token for installer '+ f'{user_info.keycloak_user_id}'+ )+ raise MissingSettingsError('Missing settings')++ secret_store = Secrets(+ provider_tokens=MappingProxyType(+ {+ ProviderType.BITBUCKET_DATA_CENTER: ProviderToken(+ token=SecretStr(user_token),+ user_id=str(user_info.user_id),+ )+ }+ )+ )++ conversation_id = await bitbucket_view.initialize_new_conversation()+ saas_user_auth = await get_saas_user_auth(+ user_info.keycloak_user_id, self.token_manager+ )+ await bitbucket_view.create_new_conversation(+ self.jinja_env,+ secret_store.provider_tokens,+ conversation_id,+ saas_user_auth,+ )+ conversation_id_hex = bitbucket_view.conversation_id++ logger.info(+ f'[Bitbucket DC] Created conversation {conversation_id_hex} '+ f'for user {user_info.username}'+ )+ conversation_link = CONVERSATION_URL.format(conversation_id_hex)+ msg_info = (+ f"I'm on it! {user_info.username} can [track my progress at "+ f'all-hands.dev]({conversation_link})'+ )++ except MissingSettingsError as e:+ logger.warning(+ f'[Bitbucket DC] Missing settings for {user_info.username}: {e}'+ )+ msg_info = (+ f'@{user_info.username} please re-login into '+ f'[OpenHands Cloud]({HOST_URL}) before starting a job.'+ )++ except LLMAuthenticationError as e:+ logger.warning(+ f'[Bitbucket DC] LLM authentication error for '+ f'{user_info.username}: {e}'+ )+ msg_info = (+ f'@{user_info.username} please set a valid LLM API key in '+ f'[OpenHands Cloud]({HOST_URL}) before starting a job.'+ )++ except SessionExpiredError as e:+ logger.warning(+ f'[Bitbucket DC] Session expired for {user_info.username}: {e}'+ )+ msg_info = get_session_expired_message(user_info.username)++ await self.send_message(msg_info, bitbucket_view)++ except Exception as e:+ logger.exception(f'[Bitbucket DC] Error starting job: {e}')+ await self.send_message(+ 'Uh oh! There was an unexpected error starting the job :(',+ bitbucket_view,+ )diff --git a/enterprise/integrations/bitbucket_data_center/bitbucket_dc_v1_callback_processor.py b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_v1_callback_processor.pynew file mode 100644index 0000000000..1c6ed3c4dc--- /dev/null+++ b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_v1_callback_processor.py@@ -0,0 +1,179 @@+import logging+from typing import Any+from uuid import UUID++import httpx+from integrations.utils import get_summary_instruction+from integrations.v1_utils import handle_callback_error+from pydantic import Field++from openhands.agent_server.models import AskAgentRequest, AskAgentResponse+from openhands.app_server.event_callback.event_callback_models import (+ EventCallback,+ EventCallbackProcessor,+)+from openhands.app_server.event_callback.event_callback_result_models import (+ EventCallbackResult,+ EventCallbackResultStatus,+)+from openhands.app_server.event_callback.util import (+ ensure_conversation_found,+ ensure_running_sandbox,+ get_agent_server_url_from_sandbox,+)+from openhands.sdk import Event+from openhands.sdk.event import ConversationStateUpdateEvent++_logger = logging.getLogger(__name__)+++class BitbucketDCV1CallbackProcessor(EventCallbackProcessor):+ """V1 callback processor for the Bitbucket Data Center resolver.++ Posts a summary comment back to the originating PR when the agent+ finishes successfully. Mirrors :class:`BitbucketV1CallbackProcessor`.+ """++ bitbucket_dc_view_data: dict[str, Any] = Field(default_factory=dict)+ should_request_summary: bool = Field(default=True)++ async def __call__(+ self,+ conversation_id: UUID,+ callback: EventCallback,+ event: Event,+ ) -> EventCallbackResult | None:+ if not isinstance(event, ConversationStateUpdateEvent):+ return None+ if event.key != 'execution_status':+ return None++ _logger.info('[Bitbucket DC V1] Callback agent state was %s', event)++ if event.value != 'finished':+ return None+ if not self.should_request_summary:+ return None++ self.should_request_summary = False+ try:+ summary = await self._request_summary(conversation_id)+ await self._post_summary_to_bitbucket_dc(summary)+ return EventCallbackResult(+ status=EventCallbackResultStatus.SUCCESS,+ event_callback_id=callback.id,+ event_id=event.id,+ conversation_id=conversation_id,+ detail=summary,+ )+ except Exception as e:+ can_post_error = bool(self.bitbucket_dc_view_data.get('keycloak_user_id'))+ await handle_callback_error(+ error=e,+ conversation_id=conversation_id,+ service_name='Bitbucket DC',+ service_logger=_logger,+ can_post_error=can_post_error,+ post_error_func=self._post_summary_to_bitbucket_dc,+ )+ return EventCallbackResult(+ status=EventCallbackResultStatus.ERROR,+ event_callback_id=callback.id,+ event_id=event.id,+ conversation_id=conversation_id,+ detail=str(e),+ )++ async def _post_summary_to_bitbucket_dc(self, summary: str) -> None:+ from integrations.bitbucket_data_center.bitbucket_dc_service import (+ SaaSBitbucketDCService,+ )++ keycloak_user_id = self.bitbucket_dc_view_data.get('keycloak_user_id')+ if not keycloak_user_id:+ raise RuntimeError('Missing keycloak user ID for Bitbucket DC')++ bitbucket_service = SaaSBitbucketDCService(external_auth_id=keycloak_user_id)+ await bitbucket_service.reply_to_pr_comment(+ owner=self.bitbucket_dc_view_data['project_key'],+ repo_slug=self.bitbucket_dc_view_data['repo_slug'],+ pr_id=self.bitbucket_dc_view_data['pr_id'],+ body=summary,+ parent_comment_id=self.bitbucket_dc_view_data.get('parent_comment_id'),+ )++ async def _ask_question(+ self,+ httpx_client: httpx.AsyncClient,+ agent_server_url: str,+ conversation_id: UUID,+ session_api_key: str,+ message_content: str,+ ) -> str:+ send_message_request = AskAgentRequest(question=message_content)+ url = (+ f"{agent_server_url.rstrip('/')}"+ f'/api/conversations/{conversation_id}/ask_agent'+ )+ headers = {'X-Session-API-Key': session_api_key}+ payload = send_message_request.model_dump()++ try:+ response = await httpx_client.post(+ url, json=payload, headers=headers, timeout=30.0+ )+ response.raise_for_status()+ return AskAgentResponse.model_validate(response.json()).response+ except httpx.HTTPStatusError as e:+ error_detail = f'HTTP {e.response.status_code} error'+ try:+ if e.response.text:+ error_detail += f': {e.response.text}'+ except Exception: # noqa: BLE001+ pass+ _logger.error(+ '[Bitbucket DC V1] HTTP error: %s', error_detail, exc_info=True+ )+ raise Exception(f'Failed to send message to agent server: {error_detail}')+ except httpx.TimeoutException:+ raise Exception(f'Request timeout after 30 seconds to {url}')+ except httpx.RequestError as e:+ raise Exception(f'Request error to {url}: {e}')++ async def _request_summary(self, conversation_id: UUID) -> str:+ from openhands.app_server.config import (+ get_app_conversation_info_service,+ get_httpx_client,+ get_sandbox_service,+ )+ from openhands.app_server.services.injector import InjectorState+ from openhands.app_server.user.specifiy_user_context import (+ ADMIN,+ USER_CONTEXT_ATTR,+ )++ state = InjectorState()+ setattr(state, USER_CONTEXT_ATTR, ADMIN)++ async with (+ get_app_conversation_info_service(state) as info_service,+ get_sandbox_service(state) as sandbox_service,+ get_httpx_client(state) as httpx_client,+ ):+ app_info = ensure_conversation_found(+ await info_service.get_app_conversation_info(conversation_id),+ conversation_id,+ )+ sandbox = ensure_running_sandbox(+ await sandbox_service.get_sandbox(app_info.sandbox_id),+ app_info.sandbox_id,+ )+ assert sandbox.session_api_key is not None+ agent_server_url = get_agent_server_url_from_sandbox(sandbox)+ return await self._ask_question(+ httpx_client=httpx_client,+ agent_server_url=agent_server_url,+ conversation_id=conversation_id,+ session_api_key=sandbox.session_api_key,+ message_content=get_summary_instruction(),+ )diff --git a/enterprise/integrations/bitbucket_data_center/bitbucket_dc_view.py b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_view.pynew file mode 100644index 0000000000..b1c448ed5a--- /dev/null+++ b/enterprise/integrations/bitbucket_data_center/bitbucket_dc_view.py@@ -0,0 +1,383 @@+from __future__ import annotations++from dataclasses import dataclass+from typing import cast+from uuid import UUID, uuid4++from integrations.models import Message+from integrations.resolver_context import ResolverUserContext+from integrations.resolver_org_router import resolve_org_for_repo+from integrations.types import ResolverViewInterface, UserData+from integrations.utils import (+ HOST,+ get_oh_labels,+ has_exact_mention,+)+from jinja2 import Environment++from openhands.agent_server.models import SendMessageRequest+from openhands.app_server.app_conversation.app_conversation_models import (+ AppConversationStartRequest,+ AppConversationStartTaskStatus,+ ConversationTrigger,+)+from openhands.app_server.config import get_app_conversation_service+from openhands.app_server.integrations.bitbucket_data_center.bitbucket_dc_service import (+ BitbucketDCServiceImpl,+)+from openhands.app_server.integrations.provider import (+ PROVIDER_TOKEN_TYPE,+ ProviderType,+)+from openhands.app_server.integrations.service_types import Comment+from openhands.app_server.services.injector import InjectorState+from openhands.app_server.user.specifiy_user_context import USER_CONTEXT_ATTR+from openhands.app_server.user_auth.user_auth import UserAuth+from openhands.core.logger import openhands_logger as logger+from openhands.sdk import TextContent++OH_LABEL, INLINE_OH_LABEL = get_oh_labels(HOST)+++def extract_actor_slug(actor: dict) -> str:+ """Extract a stable user identifier from a Bitbucket DC ``actor`` block.++ DC's stable identifier is the user ``slug`` (lowercase username); ``id``+ is the numeric DB id and ``name`` is also the username on most+ installations. Prefer ``slug`` for downstream API filters and dedup,+ fall back to ``name``, and finally to the numeric ``id`` as a string.+ Returns an empty string when none are present.+ """+ return actor.get('slug') or actor.get('name') or str(actor.get('id') or '') or ''+++PR_COMMENT_EVENTS = ('pr:comment:added', 'pr:comment:edited')+++# =============================================================================+# Bitbucket Data Center view dataclasses+# =============================================================================+++@dataclass+class BitbucketDCPR(ResolverViewInterface):+ """Base view representing a Bitbucket Data Center PR-level resolver trigger."""++ installation_id: str # f"{project_key}/{repo_slug}" β DC has no per-hook UUID+ issue_number: int # PR id (named issue_number for parity with the interface)+ project_key: str+ repo_slug: str+ full_repo_name: str # f"{project_key}/{repo_slug}"+ is_public_repo: bool+ user_info: UserData+ raw_payload: Message+ conversation_id: str+ should_extract: bool+ send_summary_instruction: bool+ title: str+ description: str+ previous_comments: list[Comment]+ branch_name: str | None++ def _get_branch_name(self) -> str | None:+ return self.branch_name++ async def _load_resolver_context(self) -> None:+ bitbucket_service = BitbucketDCServiceImpl(+ external_auth_id=self.user_info.keycloak_user_id+ )+ self.previous_comments = await bitbucket_service.get_pr_comments(+ self.project_key, self.repo_slug, self.issue_number+ )+ (+ self.title,+ self.description,+ ) = await bitbucket_service.get_pr_title_and_body(+ self.project_key, self.repo_slug, self.issue_number+ )++ async def _get_instructions(self, jinja_env: Environment) -> tuple[str, str]:+ await self._load_resolver_context()++ user_instructions_template = jinja_env.get_template('pr_update_prompt.j2')+ user_instructions = user_instructions_template.render(pr_comment='')++ conversation_instructions_template = jinja_env.get_template(+ 'pr_update_conversation_instructions.j2'+ )+ conversation_instructions = conversation_instructions_template.render(+ pr_number=self.issue_number,+ branch_name=self.branch_name or '',+ pr_title=self.title,+ pr_body=self.description,+ comments=self.previous_comments,+ )+ return user_instructions, conversation_instructions++ async def initialize_new_conversation(self) -> UUID:+ self.resolved_org_id = await resolve_org_for_repo(+ provider=ProviderType.BITBUCKET_DATA_CENTER.value,+ full_repo_name=self.full_repo_name,+ keycloak_user_id=self.user_info.keycloak_user_id,+ )+ conversation_id = uuid4()+ self.conversation_id = conversation_id.hex+ return conversation_id++ async def create_new_conversation(+ self,+ jinja_env: Environment,+ git_provider_tokens: PROVIDER_TOKEN_TYPE,+ conversation_id: UUID,+ saas_user_auth: UserAuth,+ ) -> None:+ user_instructions, conversation_instructions = await self._get_instructions(+ jinja_env+ )+ initial_message = SendMessageRequest(+ role='user', content=[TextContent(text=user_instructions)]+ )++ from integrations.bitbucket_data_center.bitbucket_dc_v1_callback_processor import (+ BitbucketDCV1CallbackProcessor,+ )++ callback_processor = BitbucketDCV1CallbackProcessor(+ bitbucket_dc_view_data={+ 'pr_id': self.issue_number,+ 'project_key': self.project_key,+ 'repo_slug': self.repo_slug,+ 'full_repo_name': self.full_repo_name,+ 'installation_id': self.installation_id,+ 'keycloak_user_id': self.user_info.keycloak_user_id,+ 'parent_comment_id': getattr(self, 'parent_comment_id', None),+ },+ should_request_summary=self.send_summary_instruction,+ )++ title = f'Bitbucket DC PR #{self.issue_number}: {self.title}'+ start_request = AppConversationStartRequest(+ conversation_id=conversation_id,+ system_message_suffix=conversation_instructions,+ initial_message=initial_message,+ selected_repository=self.full_repo_name,+ selected_branch=self._get_branch_name(),+ git_provider=ProviderType.BITBUCKET_DATA_CENTER,+ title=title,+ trigger=ConversationTrigger.RESOLVER,+ processors=[callback_processor],+ )++ injector_state = InjectorState()+ bitbucket_user_context = ResolverUserContext(+ saas_user_auth=saas_user_auth,+ resolver_org_id=self.resolved_org_id,+ )+ setattr(injector_state, USER_CONTEXT_ATTR, bitbucket_user_context)++ async with get_app_conversation_service(+ injector_state+ ) as app_conversation_service:+ async for task in app_conversation_service.start_app_conversation(+ start_request+ ):+ if task.status == AppConversationStartTaskStatus.ERROR:+ logger.error(f'Failed to start V1 conversation: {task.detail}')+ raise RuntimeError(+ f'Failed to start V1 conversation: {task.detail}'+ )+++@dataclass+class BitbucketDCPRComment(BitbucketDCPR):+ comment_body: str+ parent_comment_id: int | None++ async def _get_instructions(self, jinja_env: Environment) -> tuple[str, str]:+ await self._load_resolver_context()++ user_instructions_template = jinja_env.get_template('pr_update_prompt.j2')+ user_instructions = user_instructions_template.render(+ pr_comment=self.comment_body+ )++ conversation_instructions_template = jinja_env.get_template(+ 'pr_update_conversation_instructions.j2'+ )+ conversation_instructions = conversation_instructions_template.render(+ pr_number=self.issue_number,+ branch_name=self.branch_name or '',+ pr_title=self.title,+ pr_body=self.description,+ comments=self.previous_comments,+ )+ return user_instructions, conversation_instructions+++@dataclass+class BitbucketDCInlinePRComment(BitbucketDCPRComment):+ file_location: str+ line_number: int+ line_type: str # 'ADDED' | 'CONTEXT' | 'REMOVED'+ file_type: str # 'TO' | 'FROM'++ async def _get_instructions(self, jinja_env: Environment) -> tuple[str, str]:+ await self._load_resolver_context()++ user_instructions_template = jinja_env.get_template('pr_update_prompt.j2')+ user_instructions = user_instructions_template.render(+ pr_comment=self.comment_body+ )++ conversation_instructions_template = jinja_env.get_template(+ 'pr_update_conversation_instructions.j2'+ )+ conversation_instructions = conversation_instructions_template.render(+ pr_number=self.issue_number,+ branch_name=self.branch_name or '',+ pr_title=self.title,+ pr_body=self.description,+ comments=self.previous_comments,+ file_location=self.file_location,+ line_number=self.line_number,+ )+ return user_instructions, conversation_instructions+++BitbucketDCViewType = BitbucketDCInlinePRComment | BitbucketDCPRComment | BitbucketDCPR+++# =============================================================================+# Factory+# =============================================================================+++class BitbucketDCFactory:+ """Inspect a Bitbucket Data Center webhook payload and decide which view to build.++ Bitbucket DC fires ``pr:comment:added`` (and ``pr:comment:edited``)+ when a PR receives a comment. The resolver activates when the comment+ body contains a case-insensitive mention of the configured+ ``@openhands`` handle. Inline comments include an ``anchor`` block+ with the file path and line number.+ """++ @staticmethod+ def is_pr_comment(message: Message, inline: bool = False) -> bool:+ event_key = message.message.get('event_key')+ payload = message.message.get('payload') or {}+ if event_key not in PR_COMMENT_EVENTS:+ return False+ comment = payload.get('comment') or {}+ body = comment.get('text') or ''+ if not has_exact_mention(body, INLINE_OH_LABEL):+ return False+ # DC indicates inline comments by presence of a ``commentAnchor``+ # alongside the comment, or an ``anchor`` block on the comment+ # itself in some payload variants.+ is_inline = bool(payload.get('commentAnchor') or comment.get('anchor'))+ return is_inline if inline else not is_inline++ @staticmethod+ async def create_bitbucket_dc_view_from_payload(+ message: Message, keycloak_user_id: str+ ) -> BitbucketDCViewType:+ """Build a view from a Bitbucket DC webhook payload.++ ``keycloak_user_id`` is the OpenHands user that **installed** the+ webhook (looked up by ``(project_key, repo_slug)`` from the+ ``bitbucket_dc_webhook`` table by the manager). The resolver acts+ on Bitbucket DC as the installer.+ """+ payload = cast(dict, message.message['payload'])+ installation_id = cast(str, message.message.get('installation_id') or '')++ actor = payload.get('actor') or {}+ actor_slug = extract_actor_slug(actor)+ username = actor.get('displayName') or actor.get('name') or 'unknown'++ pull_request = payload.get('pullRequest') or {}+ to_ref = pull_request.get('toRef') or {}+ repository = to_ref.get('repository') or {}+ project = repository.get('project') or {}+ project_key = project.get('key') or ''+ repo_slug = repository.get('slug') or ''+ full_repo_name = (+ f'{project_key}/{repo_slug}' if project_key and repo_slug else ''+ )+ is_public_repo = bool(repository.get('public'))++ raw_pr_id = pull_request.get('id')+ if not raw_pr_id:+ # ``is_pr_comment`` already validated the event key; a missing+ # PR id here means a malformed payload.+ raise ValueError(+ f'Invalid PR id in Bitbucket DC webhook payload: {pull_request}'+ )+ pr_id = int(raw_pr_id)+ from_ref = pull_request.get('fromRef') or {}+ branch_name = (+ from_ref.get('displayId')+ or (from_ref.get('id') or '').replace('refs/heads/', '')+ or None+ )++ user_info = UserData(+ user_id=actor_slug,+ username=username,+ keycloak_user_id=keycloak_user_id,+ )++ comment = payload.get('comment') or {}+ comment_body = comment.get('text') or ''+ parent_comment_id = (comment.get('parent') or {}).get('id')++ # DC carries the inline anchor at the payload level under+ # ``commentAnchor``; some variants nest it under ``comment.anchor``.+ anchor = payload.get('commentAnchor') or comment.get('anchor') or {}++ common_kwargs: dict = dict(+ installation_id=installation_id,+ issue_number=pr_id,+ project_key=project_key,+ repo_slug=repo_slug,+ full_repo_name=full_repo_name,+ is_public_repo=is_public_repo,+ user_info=user_info,+ raw_payload=message,+ conversation_id='',+ should_extract=True,+ send_summary_instruction=True,+ title='',+ description='',+ previous_comments=[],+ branch_name=branch_name,+ )++ if BitbucketDCFactory.is_pr_comment(message, inline=True):+ logger.info(+ f'[Bitbucket DC] Creating view for inline PR comment from '+ f'{username} in {full_repo_name}#{pr_id}'+ )+ return BitbucketDCInlinePRComment(+ **common_kwargs,+ comment_body=comment_body,+ parent_comment_id=parent_comment_id,+ file_location=anchor.get('path') or '',+ line_number=anchor.get('line') or 0,+ line_type=anchor.get('lineType') or 'CONTEXT',+ file_type=anchor.get('fileType') or 'TO',+ )++ if BitbucketDCFactory.is_pr_comment(message):+ logger.info(+ f'[Bitbucket DC] Creating view for PR comment from '+ f'{username} in {full_repo_name}#{pr_id}'+ )+ return BitbucketDCPRComment(+ **common_kwargs,+ comment_body=comment_body,+ parent_comment_id=parent_comment_id,+ )++ raise ValueError(f'Unhandled Bitbucket DC webhook event: {message}')diff --git a/enterprise/integrations/models.py b/enterprise/integrations/models.pyindex 10cc61b3fc..b3bf6f806e 100644--- a/enterprise/integrations/models.py+++ b/enterprise/integrations/models.py@@ -8,6 +8,7 @@ class SourceType(str, Enum):GITHUB = 'github'GITLAB = 'gitlab'BITBUCKET = 'bitbucket'+ BITBUCKET_DATA_CENTER = 'bitbucket_data_center'OPENHANDS = 'openhands'SLACK = 'slack'JIRA = 'jira'diff --git a/enterprise/migrations/versions/112_create_bitbucket_dc_webhook_table.py b/enterprise/migrations/versions/112_create_bitbucket_dc_webhook_table.pynew file mode 100644index 0000000000..e981caaf4d--- /dev/null+++ b/enterprise/migrations/versions/112_create_bitbucket_dc_webhook_table.py@@ -0,0 +1,57 @@+"""create bitbucket dc webhook table++Revision ID: 112+Revises: 111+Create Date: 2026-04-29 00:00:00.000000++"""++from typing import Sequence, Union++import sqlalchemy as sa+from alembic import op++# revision identifiers, used by Alembic.+revision: str = '112'+down_revision: Union[str, None] = '111'+branch_labels: Union[str, Sequence[str], None] = None+depends_on: Union[str, Sequence[str], None] = None+++def upgrade() -> None:+ op.create_table(+ 'bitbucket_dc_webhook',+ sa.Column(+ 'id', sa.Integer(), nullable=False, primary_key=True, autoincrement=True+ ),+ sa.Column('project_key', sa.String(), nullable=False),+ sa.Column('repo_slug', sa.String(), nullable=False),+ sa.Column('user_id', sa.String(), nullable=False),+ sa.Column('webhook_id', sa.String(), nullable=True),+ sa.Column('webhook_secret', sa.String(), nullable=True),+ sa.Column(+ 'last_synced',+ sa.DateTime(),+ server_default=sa.text('CURRENT_TIMESTAMP'),+ nullable=True,+ ),+ )++ op.create_index(+ 'ix_bitbucket_dc_webhook_user_id', 'bitbucket_dc_webhook', ['user_id']+ )+ op.create_unique_constraint(+ 'uq_bitbucket_dc_webhook_project_repo',+ 'bitbucket_dc_webhook',+ ['project_key', 'repo_slug'],+ )+++def downgrade() -> None:+ op.drop_constraint(+ 'uq_bitbucket_dc_webhook_project_repo',+ 'bitbucket_dc_webhook',+ type_='unique',+ )+ op.drop_index('ix_bitbucket_dc_webhook_user_id', table_name='bitbucket_dc_webhook')+ op.drop_table('bitbucket_dc_webhook')diff --git a/enterprise/saas_server.py b/enterprise/saas_server.pyindex ad091ad206..048fad957d 100644--- a/enterprise/saas_server.py+++ b/enterprise/saas_server.py@@ -157,6 +157,18 @@ if BITBUCKET_DATA_CENTER_HOST:)base_app.include_router(bitbucket_dc_proxy_router)++ # Bitbucket Data Center resolver webhook (PR comment trigger).+ from integrations.bitbucket_data_center.bitbucket_dc_v1_callback_processor import ( # noqa: E402+ BitbucketDCV1CallbackProcessor,+ )+ from server.routes.integration.bitbucket_dc import ( # noqa: E402+ bitbucket_dc_integration_router,+ )++ logger.debug(f'Loaded {BitbucketDCV1CallbackProcessor.__name__}')++ base_app.include_router(bitbucket_dc_integration_router)base_app.include_router(email_router) # Add routes for email managementdiff --git a/enterprise/server/routes/integration/bitbucket_dc.py b/enterprise/server/routes/integration/bitbucket_dc.pynew file mode 100644index 0000000000..17e66de44e--- /dev/null+++ b/enterprise/server/routes/integration/bitbucket_dc.py@@ -0,0 +1,165 @@+from __future__ import annotations++import hashlib+import hmac+import json++from fastapi import APIRouter, Header, HTTPException, Request+from fastapi.responses import JSONResponse+from integrations.bitbucket_data_center.bitbucket_dc_manager import BitbucketDCManager+from integrations.models import Message, SourceType+from integrations.utils import IS_LOCAL_DEPLOYMENT+from server.auth.token_manager import TokenManager+from storage.bitbucket_dc_webhook_store import BitbucketDCWebhookStore+from storage.redis import get_redis_client_async++from openhands.core.logger import openhands_logger as logger++bitbucket_dc_integration_router = APIRouter(prefix='/integration')++webhook_store = BitbucketDCWebhookStore()+token_manager = TokenManager()+bitbucket_dc_manager = BitbucketDCManager(token_manager)+++def _extract_repo_identity(payload_data: dict) -> tuple[str, str]:+ """Pull ``(project_key, repo_slug)`` out of a DC webhook payload.++ For PR events DC nests the repository under+ ``pullRequest.toRef.repository``; for repo-level events it lives at+ the top level under ``repository``.+ """+ pull_request = payload_data.get('pullRequest') or {}+ repository = (+ (pull_request.get('toRef') or {}).get('repository')+ or payload_data.get('repository')+ or {}+ )+ project = repository.get('project') or {}+ return project.get('key') or '', repository.get('slug') or ''+++async def verify_bitbucket_dc_signature(+ *,+ signature_header: str | None,+ body: bytes,+ project_key: str,+ repo_slug: str,+) -> None:+ """Verify ``X-Hub-Signature`` against the per-repository secret.++ Bitbucket Data Center signs each webhook delivery with HMAC-SHA256 of+ the request body using the secret configured on the repository's+ webhook. The header has the form ``sha256=<hex>``. There is no+ per-installation UUID header on DC, so we look up the secret by the+ ``(project_key, repo_slug)`` carried in the payload.+ """+ if not project_key or not repo_slug:+ raise HTTPException(+ status_code=403,+ detail='Missing repository identity in payload',+ )++ if IS_LOCAL_DEPLOYMENT:+ webhook_secret: str | None = 'localdeploymentwebhooktesttoken'+ else:+ webhook_secret = await webhook_store.get_webhook_secret(+ project_key=project_key, repo_slug=repo_slug+ )++ if not webhook_secret:+ raise HTTPException(+ status_code=403,+ detail='No webhook secret found for repository',+ )++ if IS_LOCAL_DEPLOYMENT and signature_header in (+ None,+ 'localdeploymentwebhooktesttoken',+ ):+ return++ if not signature_header:+ raise HTTPException(status_code=403, detail='Missing X-Hub-Signature header')++ expected = (+ 'sha256=' + hmac.new(webhook_secret.encode(), body, hashlib.sha256).hexdigest()+ )+ if not hmac.compare_digest(expected, signature_header):+ raise HTTPException(status_code=403, detail="Request signatures didn't match!")+++@bitbucket_dc_integration_router.post('/bitbucket-dc/events')+async def bitbucket_dc_events(+ request: Request,+ x_hub_signature: str | None = Header(None),+ x_event_key: str | None = Header(None),+ x_request_id: str | None = Header(None),+):+ try:+ body = await request.body()+ payload_data = json.loads(body) if body else {}++ # DC sends a ``diagnostics:ping`` event when the admin clicks the+ # "Test connection" button on the webhook configuration page; it+ # carries no repository payload, so accept it as a no-op.+ if x_event_key == 'diagnostics:ping':+ return JSONResponse(+ status_code=200,+ content={'message': 'Bitbucket DC ping acknowledged.'},+ )++ project_key, repo_slug = _extract_repo_identity(payload_data)+ await verify_bitbucket_dc_signature(+ signature_header=x_hub_signature,+ body=body,+ project_key=project_key,+ repo_slug=repo_slug,+ )++ pr_id = (payload_data.get('pullRequest') or {}).get('id')+ comment_id = (payload_data.get('comment') or {}).get('id')++ if x_request_id:+ dedup_key = f'bbdc:{x_event_key}:{pr_id}:{comment_id}:{x_request_id}'+ else:+ dedup_hash = hashlib.sha256(body).hexdigest()+ dedup_key = f'bbdc:msg:{dedup_hash}'++ redis = get_redis_client_async()+ created = await redis.set(dedup_key, 1, nx=True, ex=60)+ if not created:+ logger.info('bitbucket_dc_is_duplicate')+ return JSONResponse(+ status_code=200,+ content={'message': 'Duplicate Bitbucket DC event ignored.'},+ )++ message = Message(+ source=SourceType.BITBUCKET_DATA_CENTER,+ message={+ 'payload': payload_data,+ 'event_key': x_event_key,+ 'installation_id': f'{project_key}/{repo_slug}',+ },+ )+ await bitbucket_dc_manager.receive_message(message)++ return JSONResponse(+ status_code=200,+ content={+ 'message': 'Bitbucket DC events endpoint reached successfully.',+ },+ )++ except HTTPException:+ raise+ except Exception as e:+ logger.exception(f'Error processing Bitbucket DC event: {e}')+ # Surface the exception class name so admins reading DC's webhook+ # delivery UI can correlate with server logs without leaking a full+ # message (which may contain sensitive payload fragments).+ return JSONResponse(+ status_code=400,+ content={'error': 'Invalid payload.', 'error_type': type(e).__name__},+ )diff --git a/enterprise/storage/bitbucket_dc_webhook.py b/enterprise/storage/bitbucket_dc_webhook.pynew file mode 100644index 0000000000..c646b350b6--- /dev/null+++ b/enterprise/storage/bitbucket_dc_webhook.py@@ -0,0 +1,40 @@+from datetime import datetime++from sqlalchemy import (+ DateTime,+ String,+ text,+)+from sqlalchemy.orm import Mapped, mapped_column+from storage.base import Base+++class BitbucketDCWebhook(Base):+ """A Bitbucket Data Center webhook installed against a single repository.++ Bitbucket DC does not expose a per-installation UUID in webhook+ request headers, so each row is identified by ``(project_key,+ repo_slug)`` and the secret + installer are looked up at delivery+ time using the repository identity carried in the payload.+ """++ __tablename__ = 'bitbucket_dc_webhook'++ id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)+ project_key: Mapped[str] = mapped_column(String, nullable=False)+ repo_slug: Mapped[str] = mapped_column(String, nullable=False)+ user_id: Mapped[str] = mapped_column(String, nullable=False)+ webhook_id: Mapped[str | None] = mapped_column(String, nullable=True)+ webhook_secret: Mapped[str | None] = mapped_column(String, nullable=True)+ last_synced: Mapped[datetime | None] = mapped_column(+ DateTime,+ server_default=text('CURRENT_TIMESTAMP'),+ onupdate=text('CURRENT_TIMESTAMP'),+ nullable=True,+ )++ def __repr__(self) -> str:+ return (+ f'<BitbucketDCWebhook(id={self.id}, project_key={self.project_key}, '+ f'repo_slug={self.repo_slug}, webhook_id={self.webhook_id})>'+ )diff --git a/enterprise/storage/bitbucket_dc_webhook_store.py b/enterprise/storage/bitbucket_dc_webhook_store.pynew file mode 100644index 0000000000..60061173c0--- /dev/null+++ b/enterprise/storage/bitbucket_dc_webhook_store.py@@ -0,0 +1,49 @@+from __future__ import annotations++from dataclasses import dataclass++from sqlalchemy import select+from storage.bitbucket_dc_webhook import BitbucketDCWebhook+from storage.database import a_session_maker+++@dataclass+class BitbucketDCWebhookStore:+ """Read helpers for the ``bitbucket_dc_webhook`` table.++ Used by the Bitbucket Data Center webhook route to look up the+ per-repository secret needed to verify ``X-Hub-Signature``, and by+ the manager to resolve the keycloak ``user_id`` of the webhook+ installer.+ """++ async def get_webhook_secret(self, project_key: str, repo_slug: str) -> str | None:+ async with a_session_maker() as session:+ query = (+ select(BitbucketDCWebhook)+ .where(+ BitbucketDCWebhook.project_key == project_key,+ BitbucketDCWebhook.repo_slug == repo_slug,+ )+ .limit(1)+ )+ result = await session.execute(query)+ webhook = result.scalars().first()+ return webhook.webhook_secret if webhook else None++ async def get_webhook_user_id(self, project_key: str, repo_slug: str) -> str | None:+ async with a_session_maker() as session:+ query = (+ select(BitbucketDCWebhook.user_id)+ .where(+ BitbucketDCWebhook.project_key == project_key,+ BitbucketDCWebhook.repo_slug == repo_slug,+ )+ .limit(1)+ )+ result = await session.execute(query)+ return result.scalar_one_or_none()++ @classmethod+ async def get_instance(cls) -> BitbucketDCWebhookStore:+ return BitbucketDCWebhookStore()diff --git a/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_manager.py b/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_manager.pynew file mode 100644index 0000000000..70164c15d1--- /dev/null+++ b/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_manager.py@@ -0,0 +1,179 @@+"""Tests for BitbucketDCManager.receive_message and send_message dispatch."""++from unittest.mock import AsyncMock, patch++import pytest+from integrations.bitbucket_data_center.bitbucket_dc_manager import BitbucketDCManager+from integrations.bitbucket_data_center.bitbucket_dc_view import (+ BitbucketDCInlinePRComment,+ BitbucketDCPRComment,+)+from integrations.models import Message, SourceType+from integrations.types import UserData+++def _comment_message(*, body: str = 'Hey @openhands fix') -> Message:+ return Message(+ source=SourceType.BITBUCKET_DATA_CENTER,+ message={+ 'payload': {+ 'actor': {+ 'id': 1001,+ 'name': 'alice',+ 'slug': 'alice',+ 'displayName': 'Alice',+ },+ 'pullRequest': {+ 'id': 7,+ 'fromRef': {+ 'displayId': 'feature/x',+ 'id': 'refs/heads/feature/x',+ },+ 'toRef': {+ 'repository': {+ 'slug': 'myrepo',+ 'public': False,+ 'project': {'key': 'PROJ'},+ }+ },+ },+ 'comment': {'id': 99, 'text': body},+ },+ 'event_key': 'pr:comment:added',+ 'installation_id': 'PROJ/myrepo',+ },+ )+++def _pr_comment_view(parent_id: int | None = 42) -> BitbucketDCPRComment:+ return BitbucketDCPRComment(+ installation_id='PROJ/myrepo',+ issue_number=7,+ project_key='PROJ',+ repo_slug='myrepo',+ full_repo_name='PROJ/myrepo',+ is_public_repo=False,+ user_info=UserData(+ user_id='alice', username='Alice', keycloak_user_id='kc-installer'+ ),+ raw_payload=_comment_message(),+ conversation_id='',+ should_extract=True,+ send_summary_instruction=True,+ title='',+ description='',+ previous_comments=[],+ branch_name='feature/x',+ comment_body='Hey @openhands fix',+ parent_comment_id=parent_id,+ )+++def _inline_view() -> BitbucketDCInlinePRComment:+ return BitbucketDCInlinePRComment(+ installation_id='PROJ/myrepo',+ issue_number=7,+ project_key='PROJ',+ repo_slug='myrepo',+ full_repo_name='PROJ/myrepo',+ is_public_repo=False,+ user_info=UserData(+ user_id='alice', username='Alice', keycloak_user_id='kc-installer'+ ),+ raw_payload=_comment_message(),+ conversation_id='',+ should_extract=True,+ send_summary_instruction=True,+ title='',+ description='',+ previous_comments=[],+ branch_name='feature/x',+ comment_body='@openhands rename',+ parent_comment_id=None,+ file_location='src/x.py',+ line_number=12,+ line_type='ADDED',+ file_type='TO',+ )+++async def test_receive_message_dispatches_when_commenter_has_write_access():+ manager = BitbucketDCManager(AsyncMock())++ with patch.object(+ manager.webhook_store, 'get_webhook_user_id', return_value='kc-installer'+ ), patch.object(+ manager, '_commenter_has_write_access', return_value=True+ ), patch.object(manager, 'start_job', new=AsyncMock()) as mock_start:+ await manager.receive_message(_comment_message())++ mock_start.assert_awaited_once()+++async def test_receive_message_skips_when_commenter_lacks_write_access():+ manager = BitbucketDCManager(AsyncMock())++ with patch.object(+ manager.webhook_store, 'get_webhook_user_id', return_value='kc-installer'+ ), patch.object(+ manager, '_commenter_has_write_access', return_value=False+ ), patch.object(manager, 'start_job', new=AsyncMock()) as mock_start:+ await manager.receive_message(_comment_message())++ mock_start.assert_not_called()+++async def test_receive_message_skips_when_no_installer_recorded_for_repo():+ manager = BitbucketDCManager(AsyncMock())++ with patch.object(+ manager.webhook_store, 'get_webhook_user_id', return_value=None+ ), patch.object(manager, 'start_job', new=AsyncMock()) as mock_start:+ await manager.receive_message(_comment_message())++ mock_start.assert_not_called()+++async def test_send_message_replies_inline_with_anchor_for_inline_view():+ manager = BitbucketDCManager(AsyncMock())+ fake_service = AsyncMock()+ with patch(+ 'integrations.bitbucket_data_center.bitbucket_dc_service.SaaSBitbucketDCService',+ return_value=fake_service,+ ):+ await manager.send_message('Done', _inline_view())++ kwargs = fake_service.reply_to_pr_comment.call_args.kwargs+ assert kwargs['anchor'] == {+ 'path': 'src/x.py',+ 'line': 12,+ 'lineType': 'ADDED',+ 'fileType': 'TO',+ }+++async def test_send_message_replies_via_parent_id_for_pr_comment_view():+ manager = BitbucketDCManager(AsyncMock())+ fake_service = AsyncMock()+ with patch(+ 'integrations.bitbucket_data_center.bitbucket_dc_service.SaaSBitbucketDCService',+ return_value=fake_service,+ ):+ await manager.send_message('I am on it!', _pr_comment_view(parent_id=42))++ kwargs = fake_service.reply_to_pr_comment.call_args.kwargs+ assert kwargs['parent_comment_id'] == 42+ assert 'anchor' not in kwargs+++def test_confirm_incoming_source_type_raises_on_wrong_source():+ manager = BitbucketDCManager(AsyncMock())+ with pytest.raises(ValueError):+ manager._confirm_incoming_source_type(+ Message(source=SourceType.BITBUCKET, message={})+ )diff --git a/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_view.py b/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_view.pynew file mode 100644index 0000000000..6d67fc95aa--- /dev/null+++ b/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_view.py@@ -0,0 +1,112 @@+"""Tests for the Bitbucket Data Center resolver factory and view dispatch."""++import pytest+from integrations.bitbucket_data_center.bitbucket_dc_view import (+ BitbucketDCFactory,+ BitbucketDCInlinePRComment,+ BitbucketDCPRComment,+)+from integrations.models import Message, SourceType+++def _make_message(+ *,+ body: str,+ anchor: dict | None = None,+ event_key: str = 'pr:comment:added',+ parent_id: int | None = None,+) -> Message:+ payload: dict = {+ 'actor': {+ 'id': 1001,+ 'name': 'alice',+ 'slug': 'alice',+ 'displayName': 'Alice',+ },+ 'pullRequest': {+ 'id': 7,+ 'fromRef': {'displayId': 'feature/x', 'id': 'refs/heads/feature/x'},+ 'toRef': {+ 'repository': {+ 'slug': 'myrepo',+ 'public': False,+ 'project': {'key': 'PROJ'},+ }+ },+ },+ 'comment': {'id': 99, 'text': body},+ }+ if anchor is not None:+ payload['commentAnchor'] = anchor+ if parent_id is not None:+ payload['comment']['parent'] = {'id': parent_id}++ return Message(+ source=SourceType.BITBUCKET_DATA_CENTER,+ message={+ 'payload': payload,+ 'event_key': event_key,+ 'installation_id': 'PROJ/myrepo',+ },+ )+++async def test_factory_creates_pr_comment_view_for_pr_comment_added_with_mention():+ msg = _make_message(body='Hey @openhands please fix typo', parent_id=42)++ view = await BitbucketDCFactory.create_bitbucket_dc_view_from_payload(+ msg, keycloak_user_id='kc-installer'+ )++ assert isinstance(view, BitbucketDCPRComment)+ assert not isinstance(view, BitbucketDCInlinePRComment)+ assert view.parent_comment_id == 42+ assert view.full_repo_name == 'PROJ/myrepo'+ assert view.branch_name == 'feature/x'+++async def test_factory_creates_inline_view_when_anchor_present():+ msg = _make_message(+ body='@openhands rename this',+ anchor={+ 'path': 'src/x.py',+ 'line': 12,+ 'lineType': 'ADDED',+ 'fileType': 'TO',+ },+ )++ view = await BitbucketDCFactory.create_bitbucket_dc_view_from_payload(+ msg, keycloak_user_id='kc-installer'+ )++ assert isinstance(view, BitbucketDCInlinePRComment)+ assert view.file_location == 'src/x.py'+ assert view.line_number == 12+ assert view.line_type == 'ADDED'+ assert view.file_type == 'TO'+++def test_is_pr_comment_returns_false_when_mention_absent():+ msg = _make_message(body='lgtm, ship it')+ assert BitbucketDCFactory.is_pr_comment(msg) is False+++def test_is_pr_comment_returns_false_for_unknown_event_key():+ msg = _make_message(body='@openhands fix', event_key='repo:refs_changed')+ assert BitbucketDCFactory.is_pr_comment(msg) is False+++async def test_factory_records_actor_slug_and_assigns_keycloak_user_id():+ msg = _make_message(body='@openhands fix')++ view = await BitbucketDCFactory.create_bitbucket_dc_view_from_payload(+ msg, keycloak_user_id='kc-installer'+ )++ assert view.user_info.user_id == 'alice'+ assert view.user_info.username == 'Alice'+ assert view.user_info.keycloak_user_id == 'kc-installer'diff --git a/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_webhook.py b/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_webhook.pynew file mode 100644index 0000000000..cf7404e48a--- /dev/null+++ b/enterprise/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_webhook.py@@ -0,0 +1,164 @@+"""Tests for the Bitbucket Data Center webhook route."""++import hashlib+import hmac+import json+from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from fastapi import HTTPException+from server.routes.integration.bitbucket_dc import bitbucket_dc_events+++def _signed(body: bytes, secret: str = 'shared-secret') -> str:+ return 'sha256=' + hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()+++def _request_with_body(body: bytes) -> MagicMock:+ request = MagicMock()+ request.body = AsyncMock(return_value=body)+ return request+++def _pr_comment_body() -> bytes:+ return json.dumps(+ {+ 'pullRequest': {+ 'id': 1,+ 'toRef': {+ 'repository': {+ 'slug': 'myrepo',+ 'project': {'key': 'PROJ'},+ }+ },+ },+ 'comment': {'id': 99, 'text': 'Hey @openhands'},+ }+ ).encode()+++@patch('server.routes.integration.bitbucket_dc.IS_LOCAL_DEPLOYMENT', False)+@patch('server.routes.integration.bitbucket_dc.webhook_store')+@patch('server.routes.integration.bitbucket_dc.bitbucket_dc_manager')+@patch('server.routes.integration.bitbucket_dc.get_redis_client_async')+async def test_signature_verification_rejects_bad_signature_with_403(+ mock_get_redis_client_async, mock_manager, mock_store+):+ mock_store.get_webhook_secret = AsyncMock(return_value='shared-secret')+ mock_manager.receive_message = AsyncMock()+ mock_get_redis_client_async.return_value = AsyncMock()++ body = _pr_comment_body()++ with pytest.raises(HTTPException) as exc:+ await bitbucket_dc_events(+ request=_request_with_body(body),+ x_hub_signature='sha256=deadbeef',+ x_event_key='pr:comment:added',+ x_request_id='req-1',+ )++ assert exc.value.status_code == 403+ mock_manager.receive_message.assert_not_called()+++@patch('server.routes.integration.bitbucket_dc.IS_LOCAL_DEPLOYMENT', False)+@patch('server.routes.integration.bitbucket_dc.webhook_store')+@patch('server.routes.integration.bitbucket_dc.bitbucket_dc_manager')+@patch('server.routes.integration.bitbucket_dc.get_redis_client_async')+async def test_missing_repo_identity_rejected_with_403(+ mock_get_redis_client_async, mock_manager, mock_store+):+ mock_store.get_webhook_secret = AsyncMock(return_value='shared-secret')+ mock_manager.receive_message = AsyncMock()+ mock_get_redis_client_async.return_value = AsyncMock()++ body = json.dumps({'pullRequest': {'id': 1}}).encode()++ with pytest.raises(HTTPException) as exc:+ await bitbucket_dc_events(+ request=_request_with_body(body),+ x_hub_signature=_signed(body),+ x_event_key='pr:comment:added',+ x_request_id='req-1',+ )++ assert exc.value.status_code == 403+ mock_manager.receive_message.assert_not_called()+++@patch('server.routes.integration.bitbucket_dc.IS_LOCAL_DEPLOYMENT', False)+@patch('server.routes.integration.bitbucket_dc.webhook_store')+@patch('server.routes.integration.bitbucket_dc.bitbucket_dc_manager')+@patch('server.routes.integration.bitbucket_dc.get_redis_client_async')+async def test_duplicate_event_returns_200_and_skips_dispatch(+ mock_get_redis_client_async, mock_manager, mock_store+):+ mock_store.get_webhook_secret = AsyncMock(return_value='shared-secret')+ mock_manager.receive_message = AsyncMock()+ redis = AsyncMock()+ redis.set = AsyncMock(return_value=False) # duplicate+ mock_get_redis_client_async.return_value = redis++ body = _pr_comment_body()++ response = await bitbucket_dc_events(+ request=_request_with_body(body),+ x_hub_signature=_signed(body),+ x_event_key='pr:comment:added',+ x_request_id='req-1',+ )++ mock_manager.receive_message.assert_not_called()+ assert response.status_code == 200+ assert json.loads(response.body)['message'].startswith('Duplicate')+++@patch('server.routes.integration.bitbucket_dc.IS_LOCAL_DEPLOYMENT', False)+@patch('server.routes.integration.bitbucket_dc.webhook_store')+@patch('server.routes.integration.bitbucket_dc.bitbucket_dc_manager')+@patch('server.routes.integration.bitbucket_dc.get_redis_client_async')+async def test_valid_pr_comment_event_dispatches_to_manager_and_returns_200(+ mock_get_redis_client_async, mock_manager, mock_store+):+ mock_store.get_webhook_secret = AsyncMock(return_value='shared-secret')+ mock_manager.receive_message = AsyncMock()+ redis = AsyncMock()+ redis.set = AsyncMock(return_value=True)+ mock_get_redis_client_async.return_value = redis++ body = _pr_comment_body()++ response = await bitbucket_dc_events(+ request=_request_with_body(body),+ x_hub_signature=_signed(body),+ x_event_key='pr:comment:added',+ x_request_id='req-1',+ )++ mock_manager.receive_message.assert_awaited_once()+ dispatched = mock_manager.receive_message.call_args.args[0]+ assert dispatched.source.value == 'bitbucket_data_center'+ assert dispatched.message['event_key'] == 'pr:comment:added'+ assert dispatched.message['installation_id'] == 'PROJ/myrepo'+ assert response.status_code == 200+++@patch('server.routes.integration.bitbucket_dc.bitbucket_dc_manager')+async def test_diagnostics_ping_returns_200_without_dispatch(mock_manager):+ mock_manager.receive_message = AsyncMock()++ response = await bitbucket_dc_events(+ request=_request_with_body(b'{}'),+ x_hub_signature=None,+ x_event_key='diagnostics:ping',+ x_request_id='ping-1',+ )++ mock_manager.receive_message.assert_not_called()+ assert response.status_code == 200diff --git a/enterprise/tests/unit/storage/test_bitbucket_dc_webhook_store.py b/enterprise/tests/unit/storage/test_bitbucket_dc_webhook_store.pynew file mode 100644index 0000000000..c69b8b1fb3--- /dev/null+++ b/enterprise/tests/unit/storage/test_bitbucket_dc_webhook_store.py@@ -0,0 +1,88 @@+"""Unit tests for BitbucketDCWebhookStore."""++import pytest+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine+from sqlalchemy.pool import StaticPool+from storage.base import Base+from storage.bitbucket_dc_webhook import BitbucketDCWebhook+from storage.bitbucket_dc_webhook_store import BitbucketDCWebhookStore++[email protected](scope='function')+def event_loop():+ import asyncio++ loop = asyncio.get_event_loop_policy().new_event_loop()+ yield loop+ loop.close()++[email protected](scope='function')+async def async_engine(event_loop):+ engine = create_async_engine(+ 'sqlite+aiosqlite:///:memory:',+ poolclass=StaticPool,+ connect_args={'check_same_thread': False},+ echo=False,+ )+ async with engine.begin() as conn:+ await conn.run_sync(Base.metadata.create_all)+ yield engine+ await engine.dispose()++[email protected](scope='function')+async def async_session_maker(async_engine):+ return async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)+++async def webhook_store(async_session_maker):+ import storage.bitbucket_dc_webhook_store as store_module++ store_module.a_session_maker = async_session_maker+ return BitbucketDCWebhookStore()+++async def sample_webhook(async_session_maker):+ async with async_session_maker() as session:+ webhook = BitbucketDCWebhook(+ project_key='PROJ',+ repo_slug='myrepo',+ user_id='kc-installer',+ webhook_id='42',+ webhook_secret='shared-secret',+ )+ session.add(webhook)+ await session.commit()+ await session.refresh(webhook)+ return webhook+++async def test_get_webhook_secret_returns_secret_for_matching_repo(+ webhook_store, sample_webhook+):+ secret = await webhook_store.get_webhook_secret(+ project_key='PROJ', repo_slug='myrepo'+ )+ assert secret == 'shared-secret'+++async def test_get_webhook_secret_returns_none_when_repo_not_registered(webhook_store):+ secret = await webhook_store.get_webhook_secret(+ project_key='OTHER', repo_slug='nope'+ )+ assert secret is None+++async def test_get_webhook_user_id_returns_installer_keycloak_id(+ webhook_store, sample_webhook+):+ user_id = await webhook_store.get_webhook_user_id(+ project_key='PROJ', repo_slug='myrepo'+ )+ assert user_id == 'kc-installer'diff --git a/openhands/app_server/integrations/bitbucket_data_center/bitbucket_dc_service.py b/openhands/app_server/integrations/bitbucket_data_center/bitbucket_dc_service.pyindex 77aed30c52..3559cd53f4 100644--- a/openhands/app_server/integrations/bitbucket_data_center/bitbucket_dc_service.py+++ b/openhands/app_server/integrations/bitbucket_data_center/bitbucket_dc_service.py@@ -44,6 +44,12 @@ class BitbucketDCService(external_token_manager: bool = False,base_domain: str | None = None,) -> None:+ # Fall back to the BITBUCKET_DATA_CENTER_HOST env var when no domain+ # is passed explicitly β call sites in the SaaS resolver path+ # construct this service without base_domain, and an empty BASE_URL+ # silently produces schemeless API URLs that httpx rejects.+ if not base_domain:+ base_domain = os.environ.get('BITBUCKET_DATA_CENTER_HOST') or Noneself.user_id = user_idself.external_token_manager = external_token_managerself.external_auth_id = external_auth_iddiff --git a/openhands/app_server/integrations/bitbucket_data_center/service/base.py b/openhands/app_server/integrations/bitbucket_data_center/service/base.pyindex 3329dda421..24188ab149 100644--- a/openhands/app_server/integrations/bitbucket_data_center/service/base.py+++ b/openhands/app_server/integrations/bitbucket_data_center/service/base.py@@ -67,12 +67,34 @@ class BitbucketDCMixinBase(BaseGitService, HTTPClient):return False # DC tokens cannot be refreshed programmaticallyasync def _get_headers(self) -> dict[str, str]:- """Get headers for Bitbucket data center API requests."""+ """Get headers for Bitbucket data center API requests.++ Mirrors the Bitbucket Cloud base: when ``self.token`` is empty+ (the default for services constructed only with ``external_auth_id``),+ resolve the latest token before building the header. Without this,+ the header would be ``Authorization: Basic `` with an empty base64+ payload and httpx rejects it as ``Illegal header value``.++ Tokens in ``username:secret`` form (e.g. ``x-token-auth:<PAT>`` or+ ``user:pass``) use HTTP Basic auth. Raw OAuth 2.0 access tokens+ (no colon) use Bearer per RFC 6750 β this is the format the SaaS+ broker flow returns from Keycloak.+ """+ if not self.token or not self.token.get_secret_value():+ latest_token = await self.get_latest_token()+ if latest_token:+ self.token = latest_token+token_value = self.token.get_secret_value()- auth_str = base64.b64encode(token_value.encode()).decode()+ if ':' in token_value:+ auth_str = base64.b64encode(token_value.encode()).decode()+ return {+ 'Authorization': f'Basic {auth_str}',+ 'Accept': 'application/json',+ }return {- 'Authorization': f'Basic {auth_str}',+ 'Authorization': f'Bearer {token_value}','Accept': 'application/json',}diff --git a/openhands/app_server/integrations/bitbucket_data_center/service/resolver.py b/openhands/app_server/integrations/bitbucket_data_center/service/resolver.pyindex 03600b00be..dcb89500f3 100644--- a/openhands/app_server/integrations/bitbucket_data_center/service/resolver.py+++ b/openhands/app_server/integrations/bitbucket_data_center/service/resolver.py@@ -3,7 +3,7 @@ from datetime import datetime, timezonefrom openhands.app_server.integrations.bitbucket_data_center.service.base import (BitbucketDCMixinBase,)-from openhands.app_server.integrations.service_types import Comment+from openhands.app_server.integrations.service_types import Comment, RequestMethodclass BitbucketDCResolverMixin(BitbucketDCMixinBase):@@ -111,3 +111,77 @@ class BitbucketDCResolverMixin(BitbucketDCMixinBase):all_comments.sort(key=lambda c: c.created_at)return all_comments[-max_comments:]++ async def reply_to_pr_comment(+ self,+ owner: str,+ repo_slug: str,+ pr_id: int,+ body: str,+ *,+ parent_comment_id: int | None = None,+ anchor: dict | None = None,+ ) -> None:+ """Post a comment back to a Bitbucket Data Center pull request.++ ``parent_comment_id`` makes the comment a threaded reply. ``anchor``+ attaches the comment to a specific file/line β Bitbucket DC's+ equivalent of Cloud's ``inline`` block. Anchor shape:+ ``{path, line, lineType: 'ADDED'|'CONTEXT'|'REMOVED', fileType: 'TO'|'FROM'}``.+ """+ url = (+ f'{self.BASE_URL}/projects/{owner}/repos/{repo_slug}'+ f'/pull-requests/{pr_id}/comments'+ )+ payload: dict = {'text': body}+ if parent_comment_id is not None:+ payload['parent'] = {'id': parent_comment_id}+ if anchor is not None:+ payload['anchor'] = anchor++ await self._make_request(url, params=payload, method=RequestMethod.POST)++ async def user_has_write_access(self, owner: str, repo_slug: str) -> bool:+ """Self-permission analog of :meth:`user_has_write_access_for`.++ Same policy: any identifiable user is allowed. See that method's+ docstring for the rationale.+ """+ user = await self.get_user()+ slug = user.login or self.user_id+ return await self.user_has_write_access_for(owner, repo_slug, slug or '')++ async def user_has_write_access_for(+ self, owner: str, repo_slug: str, selected_user: str+ ) -> bool:+ """Return True when ``selected_user`` is allowed to trigger the+ resolver on ``owner/repo_slug``.++ Bitbucket Data Center's OAuth 2.0 provider does not expose any+ permission-introspection endpoint that works without ``REPO_ADMIN``+ scope β every variant of ``/permissions/users`` (repo, project,+ global) requires admin per Atlassian's docs. The OpenHands OAuth+ grant requests ``REPO_WRITE``, which is sufficient for reading+ PRs and posting comments but not for the strict introspection+ check. Requiring admin scope on every install would force each+ customer's BBDC admin to grant the integration a permission it+ never actually needs to do its work.++ Mirroring the Cloud counterpart's "downgrade to a non-admin+ endpoint" pattern (see+ ``openhands/app_server/integrations/bitbucket/service/resolver.py``),+ we trust the act of webhook installation as the implicit+ endorsement of anyone who can interact with PRs in the repo. The+ trigger is gated by:++ 1. **Webhook signature verification** β only payloads HMAC-signed+ with the per-repo shared secret reach this code.+ 2. **Identifiable actor** β ``selected_user`` must be a non-empty+ slug or numeric id extracted from the payload.++ Anyone with at least ``REPO_READ`` can comment on a PR; that's+ the floor we accept. Customers needing finer-grained gating+ should layer a separate allowlist on top β the resolver doesn't+ ship one today.+ """+ return bool(selected_user)diff --git a/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc.py b/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc.pyindex 43fded489f..d9d6d0de5b 100644--- a/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc.py+++ b/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc.py@@ -25,6 +25,18 @@ def test_init_no_domain():assert svc.BASE_URL == ''+def test_init_falls_back_to_env_var_when_base_domain_missing(monkeypatch):+ monkeypatch.setenv('BITBUCKET_DATA_CENTER_HOST', 'env.example.com')+ svc = BitbucketDCService(token=SecretStr('tok'))+ assert svc.BASE_URL == 'https://env.example.com/rest/api/1.0'+++def test_init_explicit_base_domain_overrides_env_var(monkeypatch):+ monkeypatch.setenv('BITBUCKET_DATA_CENTER_HOST', 'env.example.com')+ svc = BitbucketDCService(token=SecretStr('tok'), base_domain='explicit.example.com')+ assert svc.BASE_URL == 'https://explicit.example.com/rest/api/1.0'++# ββ token wrapping ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ@@ -80,6 +92,38 @@ async def test_get_headers_xtoken_auth():assert headers['Authorization'] == expected+async def test_get_headers_lazy_loads_token_when_empty():+ """When the service is constructed without a token (SaaS path with+ external_auth_id only), _get_headers must resolve the latest token via+ get_latest_token() instead of producing an empty 'Basic ' header that+ httpx rejects with LocalProtocolError.+ """+ svc = BitbucketDCService(base_domain='host.example.com')+ assert svc.token.get_secret_value() == '' # confirm starting state++ async def fake_get_latest_token():+ return SecretStr('oauth-access-token')++ svc.get_latest_token = fake_get_latest_token # type: ignore[method-assign]++ headers = await svc._get_headers()+ assert headers['Authorization'] == 'Bearer oauth-access-token'+++async def test_get_headers_uses_bearer_for_raw_oauth_token():+ """OAuth 2.0 access tokens (no colon) must be sent as Bearer per RFC 6750,+ not as Basic auth β Bitbucket Data Center's OAuth provider expects this+ format for tokens issued via /rest/oauth2/latest/token.+ """+ svc = BitbucketDCService(base_domain='host.example.com')+ svc.token = SecretStr('eyJraWQiOiJyYXctb2F1dGgyLXRva2VuIn0')++ headers = await svc._get_headers()+ assert headers['Authorization'] == 'Bearer eyJraWQiOiJyYXctb2F1dGgyLXRva2VuIn0'++# ββ get_user ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββdiff --git a/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_resolver.py b/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_resolver.pyindex 1e467f2b90..97705f7d04 100644--- a/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_resolver.py+++ b/tests/unit/integrations/bitbucket_data_center/test_bitbucket_dc_resolver.py@@ -1,4 +1,5 @@-"""Tests for BitbucketDCResolverMixin: get_pr_title_and_body, get_pr_comments, _process_raw_comments."""+"""Tests for BitbucketDCResolverMixin: get_pr_title_and_body, get_pr_comments,+_process_raw_comments, reply_to_pr_comment, and user_has_write_access_for."""from unittest.mock import patch@@ -8,7 +9,7 @@ from pydantic import SecretStrfrom openhands.app_server.integrations.bitbucket_data_center.bitbucket_dc_service import (BitbucketDCService,)-from openhands.app_server.integrations.service_types import Comment+from openhands.app_server.integrations.service_types import Comment, RequestMethod@pytest.fixture@@ -156,6 +157,84 @@ def test_process_raw_comments_missing_timestamps(svc):assert comments[0].id == '5'+# ββ reply_to_pr_comment βββββββββββββββββββββββββββββββββββββββββββββββββββββββ+++async def test_reply_to_pr_comment_posts_to_dc_pr_comments_endpoint_with_text_field(+ svc,+):+ with patch.object(svc, '_make_request', return_value=({}, {})) as mock_req:+ await svc.reply_to_pr_comment(+ owner='PROJ',+ repo_slug='myrepo',+ pr_id=7,+ body='Working on it',+ parent_comment_id=99,+ )++ args, kwargs = mock_req.call_args+ assert args[0].endswith('/projects/PROJ/repos/myrepo/pull-requests/7/comments')+ assert kwargs['method'] == RequestMethod.POST+ payload = kwargs['params']+ assert payload == {'text': 'Working on it', 'parent': {'id': 99}}+++async def test_reply_to_pr_comment_includes_anchor_when_provided(svc):+ anchor = {+ 'path': 'src/x.py',+ 'line': 12,+ 'lineType': 'ADDED',+ 'fileType': 'TO',+ }+ with patch.object(svc, '_make_request', return_value=({}, {})) as mock_req:+ await svc.reply_to_pr_comment(+ owner='PROJ',+ repo_slug='myrepo',+ pr_id=7,+ body='Inline note',+ anchor=anchor,+ )++ payload = mock_req.call_args.kwargs['params']+ assert payload == {'text': 'Inline note', 'anchor': anchor}+++# ββ user_has_write_access_for βββββββββββββββββββββββββββββββββββββββββββββββββ+++async def test_user_has_write_access_for_returns_true_for_identified_user(svc):+ """Bitbucket Data Center has no OAuth 2.0 endpoint that introspects+ permissions without REPO_ADMIN scope. The resolver downgrades to+ "any identifiable actor is allowed" β webhook signature verification+ plus the actor coming through in the payload is the gate.+ """+ assert await svc.user_has_write_access_for('PROJ', 'myrepo', 'alice') is True+++async def test_user_has_write_access_for_returns_false_for_empty_user(svc):+ """An empty actor identity means we couldn't extract a user from the+ payload β treat as a parse failure and reject.+ """+ assert await svc.user_has_write_access_for('PROJ', 'myrepo', '') is False+++async def test_user_has_write_access_for_does_not_call_admin_endpoint(svc):+ """Regression guard: the previous implementation hit+ ``/permissions/users``, which requires REPO_ADMIN scope and 401s for+ every install that doesn't grant it. The current implementation must+ not make that call.+ """+ with patch.object(svc, '_make_request') as mock_req:+ await svc.user_has_write_access_for('PROJ', 'myrepo', 'alice')++ mock_req.assert_not_called()++# ββ MRO check βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ