Skip to content

πŸ™Œ 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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.py
new file mode 100644
index 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.py
index 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 management
diff --git a/enterprise/server/routes/integration/bitbucket_dc.py b/enterprise/server/routes/integration/bitbucket_dc.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 == 200
diff --git a/enterprise/tests/unit/storage/test_bitbucket_dc_webhook_store.py b/enterprise/tests/unit/storage/test_bitbucket_dc_webhook_store.py
new file mode 100644
index 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.py
index 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 None
self.user_id = user_id
self.external_token_manager = external_token_manager
self.external_auth_id = external_auth_id
diff --git a/openhands/app_server/integrations/bitbucket_data_center/service/base.py b/openhands/app_server/integrations/bitbucket_data_center/service/base.py
index 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 programmatically
async 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.py
index 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, timezone
from 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, RequestMethod
class 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.py
index 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.py
index 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 SecretStr
from 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 ─────────────────────────────────────────────────────────────────