π OpenHands: AI-Driven Development
refactor: Apply GitHub mixins pattern to BitBucket service (#10728)
Rohit Malhotra21f3ef540f6f
diff --git a/openhands/integrations/bitbucket/bitbucket_service.py b/openhands/integrations/bitbucket/bitbucket_service.pyindex d2f5908566..da9de96873 100644--- a/openhands/integrations/bitbucket/bitbucket_service.py+++ b/openhands/integrations/bitbucket/bitbucket_service.py@@ -1,32 +1,29 @@-import base64import os-import re-from typing import Any-import httpxfrom pydantic import SecretStr-from openhands.core.logger import openhands_logger as logger+from openhands.integrations.bitbucket.service import (+ BitBucketBranchesMixin,+ BitBucketFeaturesMixin,+ BitBucketPRsMixin,+ BitBucketReposMixin,+)from openhands.integrations.service_types import (- BaseGitService,- Branch,GitService,InstallationsService,- OwnerType,- PaginatedBranchesResponse,ProviderType,- Repository,- RequestMethod,- ResourceNotFoundError,- SuggestedTask,- User,)-from openhands.microagent.types import MicroagentContentResponse-from openhands.server.types import AppModefrom openhands.utils.import_utils import get_impl-class BitBucketService(BaseGitService, GitService, InstallationsService):+class BitBucketService(+ BitBucketReposMixin,+ BitBucketBranchesMixin,+ BitBucketPRsMixin,+ BitBucketFeaturesMixin,+ GitService,+ InstallationsService,+):"""Default implementation of GitService for Bitbucket integration.This is an extension point in OpenHands that allows applications to customize Bitbucket@@ -38,10 +35,6 @@ class BitBucketService(BaseGitService, GitService, InstallationsService):The class is instantiated via get_impl() in openhands.server.shared.py."""- BASE_URL = 'https://api.bitbucket.org/2.0'- token: SecretStr = SecretStr('')- refresh = False-def __init__(self,user_id: str | None = None,@@ -50,7 +43,7 @@ class BitBucketService(BaseGitService, GitService, InstallationsService):token: SecretStr | None = None,external_token_manager: bool = False,base_domain: str | None = None,- ):+ ) -> None:self.user_id = user_idself.external_token_manager = external_token_managerself.external_auth_id = external_auth_id@@ -66,695 +59,6 @@ class BitBucketService(BaseGitService, GitService, InstallationsService):def provider(self) -> str:return ProviderType.BITBUCKET.value- def _extract_owner_and_repo(self, repository: str) -> tuple[str, str]:- """Extract owner and repo from repository string.-- Args:- repository: Repository name in format 'workspace/repo_slug'-- Returns:- Tuple of (owner, repo)-- Raises:- ValueError: If repository format is invalid- """- parts = repository.split('/')- if len(parts) < 2:- raise ValueError(f'Invalid repository name: {repository}')-- return parts[-2], parts[-1]-- async def get_latest_token(self) -> SecretStr | None:- """Get latest working token of the user."""- return self.token-- async def _get_cursorrules_url(self, repository: str) -> str:- """Get the URL for checking .cursorrules file."""- # Get repository details to get the main branch- repo_details = await self.get_repository_details_from_repo_name(repository)- if not repo_details.main_branch:- raise ResourceNotFoundError(- f'Main branch not found for repository {repository}. '- f'This repository may be empty or have no default branch configured.'- )- return f'{self.BASE_URL}/repositories/{repository}/src/{repo_details.main_branch}/.cursorrules'-- async def _get_microagents_directory_url(- self, repository: str, microagents_path: str- ) -> str:- """Get the URL for checking microagents directory."""- # Get repository details to get the main branch- repo_details = await self.get_repository_details_from_repo_name(repository)- if not repo_details.main_branch:- raise ResourceNotFoundError(- f'Main branch not found for repository {repository}. '- f'This repository may be empty or have no default branch configured.'- )- return f'{self.BASE_URL}/repositories/{repository}/src/{repo_details.main_branch}/{microagents_path}'-- def _get_microagents_directory_params(self, microagents_path: str) -> dict | None:- """Get parameters for the microagents directory request. Return None if no parameters needed."""- return None-- def _is_valid_microagent_file(self, item: dict) -> bool:- """Check if an item represents a valid microagent file."""- return (- item['type'] == 'commit_file'- and item['path'].endswith('.md')- and not item['path'].endswith('README.md')- )-- def _get_file_name_from_item(self, item: dict) -> str:- """Extract file name from directory item."""- return item['path'].split('/')[-1]-- def _get_file_path_from_item(self, item: dict, microagents_path: str) -> str:- """Extract file path from directory item."""- return item['path']-- def _has_token_expired(self, status_code: int) -> bool:- return status_code == 401-- async def _get_bitbucket_headers(self) -> dict[str, str]:- """Get headers for Bitbucket API requests."""- token_value = self.token.get_secret_value()-- # Check if the token contains a colon, which indicates it's in username:password format- if ':' in token_value:- auth_str = base64.b64encode(token_value.encode()).decode()- return {- 'Authorization': f'Basic {auth_str}',- 'Accept': 'application/json',- }- else:- return {- 'Authorization': f'Bearer {token_value}',- 'Accept': 'application/json',- }-- async def _make_request(- self,- url: str,- params: dict | None = None,- method: RequestMethod = RequestMethod.GET,- ) -> tuple[Any, dict]:- """Make a request to the Bitbucket API.-- Args:- url: The URL to request- params: Optional parameters for the request- method: The HTTP method to use-- Returns:- A tuple of (response_data, response_headers)-- """- try:- async with httpx.AsyncClient() as client:- bitbucket_headers = await self._get_bitbucket_headers()- response = await self.execute_request(- client, url, bitbucket_headers, params, method- )- if self.refresh and self._has_token_expired(response.status_code):- await self.get_latest_token()- bitbucket_headers = await self._get_bitbucket_headers()- response = await self.execute_request(- client=client,- url=url,- headers=bitbucket_headers,- params=params,- method=method,- )- response.raise_for_status()- return response.json(), dict(response.headers)- except httpx.HTTPStatusError as e:- raise self.handle_http_status_error(e)- except httpx.HTTPError as e:- raise self.handle_http_error(e)-- async def get_user(self) -> User:- """Get the authenticated user's information."""- url = f'{self.BASE_URL}/user'- data, _ = await self._make_request(url)-- account_id = data.get('account_id', '')-- return User(- id=account_id,- login=data.get('username', ''),- avatar_url=data.get('links', {}).get('avatar', {}).get('href', ''),- name=data.get('display_name'),- email=None, # Bitbucket API doesn't return email in this endpoint- )-- def _parse_repository(- self, repo: dict, link_header: str | None = None- ) -> Repository:- """Parse a Bitbucket API repository response into a Repository object.-- Args:- repo: Repository data from Bitbucket API- link_header: Optional link header for pagination-- Returns:- Repository object- """- repo_id = repo.get('uuid', '')-- workspace_slug = repo.get('workspace', {}).get('slug', '')- repo_slug = repo.get('slug', '')- full_name = (- f'{workspace_slug}/{repo_slug}' if workspace_slug and repo_slug else ''- )-- is_public = not repo.get('is_private', True)- owner_type = OwnerType.ORGANIZATION- main_branch = repo.get('mainbranch', {}).get('name')-- return Repository(- id=repo_id,- full_name=full_name, # type: ignore[arg-type]- git_provider=ProviderType.BITBUCKET,- is_public=is_public,- stargazers_count=None, # Bitbucket doesn't have stars- pushed_at=repo.get('updated_on'),- owner_type=owner_type,- link_header=link_header,- main_branch=main_branch,- )-- async def search_repositories(- self, query: str, per_page: int, sort: str, order: str, public: bool- ) -> list[Repository]:- """Search for repositories."""- repositories = []-- if public:- # Extract workspace and repo from URL- # URL format: https://{domain}/{workspace}/{repo}/{additional_params}- # Split by '/' and find workspace and repo parts- url_parts = query.split('/')- if len(url_parts) >= 5: # https:, '', domain, workspace, repo- workspace_slug = url_parts[3]- repo_name = url_parts[4]-- repo = await self.get_repository_details_from_repo_name(- f'{workspace_slug}/{repo_name}'- )- repositories.append(repo)-- return repositories-- # Search for repos once workspace prefix exists- if '/' in query:- workspace_slug, repo_query = query.split('/', 1)- return await self.get_paginated_repos(- 1, per_page, sort, workspace_slug, repo_query- )-- all_installations = await self.get_installations()-- # Workspace prefix isn't complete. Search workspace names and repos underneath each workspace- matching_workspace_slugs = [- installation for installation in all_installations if query in installation- ]- for workspace_slug in matching_workspace_slugs:- # Get repositories where query matches workspace name- try:- repos = await self.get_paginated_repos(- 1, per_page, sort, workspace_slug- )- repositories.extend(repos)- except Exception:- continue-- for workspace_slug in all_installations:- # Get repositories in all workspaces where query matches repo name- try:- repos = await self.get_paginated_repos(- 1, per_page, sort, workspace_slug, query- )- repositories.extend(repos)- except Exception:- continue-- return repositories-- async def _get_user_workspaces(self) -> list[dict[str, Any]]:- """Get all workspaces the user has access to"""- url = f'{self.BASE_URL}/workspaces'- data, _ = await self._make_request(url)- return data.get('values', [])-- async def _fetch_paginated_data(- self, url: str, params: dict, max_items: int- ) -> list[dict]:- """Fetch data with pagination support for Bitbucket API.-- Args:- url: The API endpoint URL- params: Query parameters for the request- max_items: Maximum number of items to fetch-- Returns:- List of data items from all pages- """- all_items: list[dict] = []- current_url = url-- while current_url and len(all_items) < max_items:- response, _ = await self._make_request(current_url, params)-- # Extract items from response- page_items = response.get('values', [])- if not page_items: # No more items- break-- all_items.extend(page_items)-- # Get the next page URL from the response- current_url = response.get('next')-- # Clear params for subsequent requests since the next URL already contains all parameters- params = {}-- return all_items[:max_items] # Trim to max_items if needed-- async def get_installations(- self, query: str | None = None, limit: int = 100- ) -> list[str]:- workspaces_url = f'{self.BASE_URL}/workspaces'- params = {}- if query:- params['q'] = f'name~"{query}"'-- workspaces = await self._fetch_paginated_data(workspaces_url, params, limit)-- installations: list[str] = []- for workspace in workspaces:- installations.append(workspace['slug'])-- return installations-- async def get_paginated_repos(- self,- page: int,- per_page: int,- sort: str,- installation_id: str | None,- query: str | None = None,- ) -> list[Repository]:- """Get paginated repositories for a specific workspace.-- Args:- page: The page number to fetch- per_page: The number of repositories per page- sort: The sort field ('pushed', 'updated', 'created', 'full_name')- installation_id: The workspace slug to fetch repositories from (as int, will be converted to string)-- Returns:- A list of Repository objects- """- if not installation_id:- return []-- # Convert installation_id to string for use as workspace_slug- workspace_slug = installation_id- workspace_repos_url = f'{self.BASE_URL}/repositories/{workspace_slug}'-- # Map sort parameter to Bitbucket API compatible values- bitbucket_sort = sort- if sort == 'pushed':- # Bitbucket doesn't support 'pushed', use 'updated_on' instead- bitbucket_sort = '-updated_on' # Use negative prefix for descending order- elif sort == 'updated':- bitbucket_sort = '-updated_on'- elif sort == 'created':- bitbucket_sort = '-created_on'- elif sort == 'full_name':- bitbucket_sort = 'name' # Bitbucket uses 'name' not 'full_name'- else:- # Default to most recently updated first- bitbucket_sort = '-updated_on'-- params = {- 'pagelen': per_page,- 'page': page,- 'sort': bitbucket_sort,- }-- if query:- params['q'] = f'name~"{query}"'-- response, headers = await self._make_request(workspace_repos_url, params)-- # Extract repositories from the response- repos = response.get('values', [])-- # Extract next URL from response- next_link = response.get('next', '')-- # Format the link header in a way that the frontend can understand- # The frontend expects a format like: <url>; rel="next"- # where the URL contains a page parameter- formatted_link_header = ''- if next_link:- # Extract the page number from the next URL if possible- page_match = re.search(r'[?&]page=(\d+)', next_link)- if page_match:- next_page = page_match.group(1)- # Format it in a way that extractNextPageFromLink in frontend can parse- formatted_link_header = (- f'<{workspace_repos_url}?page={next_page}>; rel="next"'- )- else:- # If we can't extract the page, just use the next URL as is- formatted_link_header = f'<{next_link}>; rel="next"'-- repositories = [- self._parse_repository(repo, link_header=formatted_link_header)- for repo in repos- ]-- return repositories-- async def get_all_repositories(- self, sort: str, app_mode: AppMode- ) -> list[Repository]:- """Get repositories for the authenticated user using workspaces endpoint.-- This method gets all repositories (both public and private) that the user has access to- by iterating through their workspaces and fetching repositories from each workspace.- This approach is more comprehensive and efficient than the previous implementation- that made separate calls for public and private repositories.- """- MAX_REPOS = 1000- PER_PAGE = 100 # Maximum allowed by Bitbucket API- repositories: list[Repository] = []-- # Get user's workspaces with pagination- workspaces_url = f'{self.BASE_URL}/workspaces'- workspaces = await self._fetch_paginated_data(workspaces_url, {}, MAX_REPOS)-- for workspace in workspaces:- workspace_slug = workspace.get('slug')- if not workspace_slug:- continue-- # Get repositories for this workspace with pagination- workspace_repos_url = f'{self.BASE_URL}/repositories/{workspace_slug}'-- # Map sort parameter to Bitbucket API compatible values and ensure descending order- # to show most recently changed repos at the top- bitbucket_sort = sort- if sort == 'pushed':- # Bitbucket doesn't support 'pushed', use 'updated_on' instead- bitbucket_sort = (- '-updated_on' # Use negative prefix for descending order- )- elif sort == 'updated':- bitbucket_sort = '-updated_on'- elif sort == 'created':- bitbucket_sort = '-created_on'- elif sort == 'full_name':- bitbucket_sort = 'name' # Bitbucket uses 'name' not 'full_name'- else:- # Default to most recently updated first- bitbucket_sort = '-updated_on'-- params = {- 'pagelen': PER_PAGE,- 'sort': bitbucket_sort,- }-- # Fetch all repositories for this workspace with pagination- workspace_repos = await self._fetch_paginated_data(- workspace_repos_url, params, MAX_REPOS - len(repositories)- )-- for repo in workspace_repos:- repositories.append(self._parse_repository(repo))-- # Stop if we've reached the maximum number of repositories- if len(repositories) >= MAX_REPOS:- break-- # Stop if we've reached the maximum number of repositories- if len(repositories) >= MAX_REPOS:- break-- return repositories-- async def get_suggested_tasks(self) -> list[SuggestedTask]:- """Get suggested tasks for the authenticated user across all repositories."""- # TODO: implemented suggested tasks- return []-- async def get_repository_details_from_repo_name(- self, repository: str- ) -> Repository:- """Gets all repository details from repository name."""- owner, repo = self._extract_owner_and_repo(repository)-- url = f'{self.BASE_URL}/repositories/{owner}/{repo}'- data, _ = await self._make_request(url)-- return self._parse_repository(data)-- async def get_branches(self, repository: str) -> list[Branch]:- """Get branches for a repository."""- owner, repo = self._extract_owner_and_repo(repository)-- url = f'{self.BASE_URL}/repositories/{owner}/{repo}/refs/branches'-- # Set maximum branches to fetch (similar to GitHub/GitLab implementations)- MAX_BRANCHES = 1000- PER_PAGE = 100-- params = {- 'pagelen': PER_PAGE,- 'sort': '-target.date', # Sort by most recent commit date, descending- }-- # Fetch all branches with pagination- branch_data = await self._fetch_paginated_data(url, params, MAX_BRANCHES)-- branches = []- for branch in branch_data:- branches.append(- Branch(- name=branch.get('name', ''),- commit_sha=branch.get('target', {}).get('hash', ''),- protected=False, # Bitbucket doesn't expose this in the API- last_push_date=branch.get('target', {}).get('date', None),- )- )-- return branches-- async def get_paginated_branches(- self, repository: str, page: int = 1, per_page: int = 30- ) -> PaginatedBranchesResponse:- """Get branches for a repository with pagination."""- # Extract owner and repo from the repository string (e.g., "owner/repo")- parts = repository.split('/')- if len(parts) < 2:- raise ValueError(f'Invalid repository name: {repository}')-- owner = parts[-2]- repo = parts[-1]-- url = f'{self.BASE_URL}/repositories/{owner}/{repo}/refs/branches'-- params = {- 'pagelen': per_page,- 'page': page,- 'sort': '-target.date', # Sort by most recent commit date, descending- }-- response, _ = await self._make_request(url, params)-- branches = []- for branch in response.get('values', []):- branches.append(- Branch(- name=branch.get('name', ''),- commit_sha=branch.get('target', {}).get('hash', ''),- protected=False, # Bitbucket doesn't expose this in the API- last_push_date=branch.get('target', {}).get('date', None),- )- )-- # Bitbucket provides pagination info in the response- has_next_page = response.get('next') is not None- total_count = response.get('size') # Total number of items-- return PaginatedBranchesResponse(- branches=branches,- has_next_page=has_next_page,- current_page=page,- per_page=per_page,- total_count=total_count,- )-- async def search_branches(- self, repository: str, query: str, per_page: int = 30- ) -> list[Branch]:- """Search branches by name using Bitbucket API with `q` param."""- parts = repository.split('/')- if len(parts) < 2:- raise ValueError(f'Invalid repository name: {repository}')-- owner = parts[-2]- repo = parts[-1]-- url = f'{self.BASE_URL}/repositories/{owner}/{repo}/refs/branches'- # Bitbucket filtering: name ~ "query"- params = {- 'pagelen': per_page,- 'q': f'name~"{query}"',- 'sort': '-target.date',- }- response, _ = await self._make_request(url, params)-- branches: list[Branch] = []- for branch in response.get('values', []):- branches.append(- Branch(- name=branch.get('name', ''),- commit_sha=branch.get('target', {}).get('hash', ''),- protected=False,- last_push_date=branch.get('target', {}).get('date', None),- )- )- return branches-- async def create_pr(- self,- repo_name: str,- source_branch: str,- target_branch: str,- title: str,- body: str | None = None,- draft: bool = False,- ) -> str:- """Creates a pull request in Bitbucket.-- Args:- repo_name: The repository name in the format "workspace/repo"- source_branch: The source branch name- target_branch: The target branch name- title: The title of the pull request- body: The description of the pull request- draft: Whether to create a draft pull request-- Returns:- The URL of the created pull request- """- owner, repo = self._extract_owner_and_repo(repo_name)-- url = f'{self.BASE_URL}/repositories/{owner}/{repo}/pullrequests'-- payload = {- 'title': title,- 'description': body or '',- 'source': {'branch': {'name': source_branch}},- 'destination': {'branch': {'name': target_branch}},- 'close_source_branch': False,- 'draft': draft,- }-- data, _ = await self._make_request(- url=url, params=payload, method=RequestMethod.POST- )-- # Return the URL to the pull request- return data.get('links', {}).get('html', {}).get('href', '')-- async def get_pr_details(self, repository: str, pr_number: int) -> dict:- """Get detailed information about a specific pull request-- Args:- repository: Repository name in format 'owner/repo'- pr_number: The pull request number-- Returns:- Raw Bitbucket API response for the pull request- """- url = f'{self.BASE_URL}/repositories/{repository}/pullrequests/{pr_number}'- pr_data, _ = await self._make_request(url)-- return pr_data-- async def get_microagent_content(- self, repository: str, file_path: str- ) -> MicroagentContentResponse:- """Fetch individual file content from Bitbucket repository.-- Args:- repository: Repository name in format 'workspace/repo_slug'- file_path: Path to the file within the repository-- Returns:- MicroagentContentResponse with parsed content and triggers-- Raises:- RuntimeError: If file cannot be fetched or doesn't exist- """- # Step 1: Get repository details using existing method- repo_details = await self.get_repository_details_from_repo_name(repository)-- if not repo_details.main_branch:- logger.warning(- f'No main branch found in repository info for {repository}. '- f'Repository response: mainbranch field missing'- )- raise ResourceNotFoundError(- f'Main branch not found for repository {repository}. '- f'This repository may be empty or have no default branch configured.'- )-- # Step 2: Get file content using the main branch- file_url = f'{self.BASE_URL}/repositories/{repository}/src/{repo_details.main_branch}/{file_path}'- response, _ = await self._make_request(file_url)-- # Parse the content to extract triggers from frontmatter- return self._parse_microagent_content(response, file_path)-- async def is_pr_open(self, repository: str, pr_number: int) -> bool:- """Check if a Bitbucket pull request is still active (not closed/merged).-- Args:- repository: Repository name in format 'owner/repo'- pr_number: The PR number to check-- Returns:- True if PR is active (OPEN), False if closed/merged- """- try:- pr_details = await self.get_pr_details(repository, pr_number)-- # Bitbucket API response structure- # https://developer.atlassian.com/cloud/bitbucket/rest/api-group-pullrequests/#api-repositories-workspace-repo-slug-pullrequests-pull-request-id-get- if 'state' in pr_details:- # Bitbucket state values: OPEN, MERGED, DECLINED, SUPERSEDED- return pr_details['state'] == 'OPEN'-- # If we can't determine the state, assume it's active (safer default)- logger.warning(- f'Could not determine Bitbucket PR status for {repository}#{pr_number}. '- f'Response keys: {list(pr_details.keys())}. Assuming PR is active.'- )- return True-- except Exception as e:- logger.warning(- f'Could not determine Bitbucket PR status for {repository}#{pr_number}: {e}. '- f'Including conversation to be safe.'- )- # If we can't determine the PR status, include the conversation to be safe- return True-bitbucket_service_cls = os.environ.get('OPENHANDS_BITBUCKET_SERVICE_CLS',diff --git a/openhands/integrations/bitbucket/service/__init__.py b/openhands/integrations/bitbucket/service/__init__.pynew file mode 100644index 0000000000..836fb91da9--- /dev/null+++ b/openhands/integrations/bitbucket/service/__init__.py@@ -0,0 +1,13 @@+from .base import BitBucketMixinBase+from .branches import BitBucketBranchesMixin+from .features import BitBucketFeaturesMixin+from .prs import BitBucketPRsMixin+from .repos import BitBucketReposMixin++__all__ = [+ 'BitBucketMixinBase',+ 'BitBucketBranchesMixin',+ 'BitBucketFeaturesMixin',+ 'BitBucketPRsMixin',+ 'BitBucketReposMixin',+]diff --git a/openhands/integrations/bitbucket/service/base.py b/openhands/integrations/bitbucket/service/base.pynew file mode 100644index 0000000000..be135c5ca5--- /dev/null+++ b/openhands/integrations/bitbucket/service/base.py@@ -0,0 +1,248 @@+import base64+from typing import Any++import httpx+from pydantic import SecretStr++from openhands.integrations.service_types import (+ BaseGitService,+ OwnerType,+ ProviderType,+ Repository,+ RequestMethod,+ ResourceNotFoundError,+ User,+)+++class BitBucketMixinBase(BaseGitService):+ """+ Base mixin for BitBucket service containing common functionality+ """++ BASE_URL = 'https://api.bitbucket.org/2.0'+ token: SecretStr = SecretStr('')+ refresh = False++ def _extract_owner_and_repo(self, repository: str) -> tuple[str, str]:+ """Extract owner and repo from repository string.++ Args:+ repository: Repository name in format 'workspace/repo_slug'++ Returns:+ Tuple of (owner, repo)++ Raises:+ ValueError: If repository format is invalid+ """+ parts = repository.split('/')+ if len(parts) < 2:+ raise ValueError(f'Invalid repository name: {repository}')++ return parts[-2], parts[-1]++ async def get_latest_token(self) -> SecretStr | None:+ """Get latest working token of the user."""+ return self.token++ def _has_token_expired(self, status_code: int) -> bool:+ return status_code == 401++ async def _get_bitbucket_headers(self) -> dict[str, str]:+ """Get headers for Bitbucket API requests."""+ token_value = self.token.get_secret_value()++ # Check if the token contains a colon, which indicates it's in username:password format+ if ':' in token_value:+ auth_str = base64.b64encode(token_value.encode()).decode()+ return {+ 'Authorization': f'Basic {auth_str}',+ 'Accept': 'application/json',+ }+ else:+ return {+ 'Authorization': f'Bearer {token_value}',+ 'Accept': 'application/json',+ }++ async def _make_request(+ self,+ url: str,+ params: dict | None = None,+ method: RequestMethod = RequestMethod.GET,+ ) -> tuple[Any, dict]:+ """Make a request to the Bitbucket API.++ Args:+ url: The URL to request+ params: Optional parameters for the request+ method: The HTTP method to use++ Returns:+ A tuple of (response_data, response_headers)++ """+ try:+ async with httpx.AsyncClient() as client:+ bitbucket_headers = await self._get_bitbucket_headers()+ response = await self.execute_request(+ client, url, bitbucket_headers, params, method+ )+ if self.refresh and self._has_token_expired(response.status_code):+ await self.get_latest_token()+ bitbucket_headers = await self._get_bitbucket_headers()+ response = await self.execute_request(+ client=client,+ url=url,+ headers=bitbucket_headers,+ params=params,+ method=method,+ )+ response.raise_for_status()+ return response.json(), dict(response.headers)+ except httpx.HTTPStatusError as e:+ raise self.handle_http_status_error(e)+ except httpx.HTTPError as e:+ raise self.handle_http_error(e)++ async def _fetch_paginated_data(+ self, url: str, params: dict, max_items: int+ ) -> list[dict]:+ """Fetch data with pagination support for Bitbucket API.++ Args:+ url: The API endpoint URL+ params: Query parameters for the request+ max_items: Maximum number of items to fetch++ Returns:+ List of data items from all pages+ """+ all_items: list[dict] = []+ current_url = url++ while current_url and len(all_items) < max_items:+ response, _ = await self._make_request(current_url, params)++ # Extract items from response+ page_items = response.get('values', [])+ all_items.extend(page_items)++ # Get next page URL from response+ current_url = response.get('next')++ # Clear params for subsequent requests as they're included in the next URL+ params = {}++ return all_items[:max_items]++ async def get_user(self) -> User:+ """Get the authenticated user's information."""+ url = f'{self.BASE_URL}/user'+ data, _ = await self._make_request(url)++ account_id = data.get('account_id', '')++ return User(+ id=account_id,+ login=data.get('username', ''),+ avatar_url=data.get('links', {}).get('avatar', {}).get('href', ''),+ name=data.get('display_name'),+ email=None, # Bitbucket API doesn't return email in this endpoint+ )++ def _parse_repository(+ self, repo: dict, link_header: str | None = None+ ) -> Repository:+ """Parse a Bitbucket API repository response into a Repository object.++ Args:+ repo: Repository data from Bitbucket API+ link_header: Optional link header for pagination++ Returns:+ Repository object+ """+ repo_id = repo.get('uuid', '')++ workspace_slug = repo.get('workspace', {}).get('slug', '')+ repo_slug = repo.get('slug', '')+ full_name = (+ f'{workspace_slug}/{repo_slug}' if workspace_slug and repo_slug else ''+ )++ is_public = not repo.get('is_private', True)+ owner_type = OwnerType.ORGANIZATION+ main_branch = repo.get('mainbranch', {}).get('name')++ return Repository(+ id=repo_id,+ full_name=full_name, # type: ignore[arg-type]+ git_provider=ProviderType.BITBUCKET,+ is_public=is_public,+ stargazers_count=None, # Bitbucket doesn't have stars+ pushed_at=repo.get('updated_on'),+ owner_type=owner_type,+ link_header=link_header,+ main_branch=main_branch,+ )++ async def get_repository_details_from_repo_name(+ self, repository: str+ ) -> Repository:+ """Get repository details from repository name.++ Args:+ repository: Repository name in format 'workspace/repo_slug'++ Returns:+ Repository object with details+ """+ url = f'{self.BASE_URL}/repositories/{repository}'+ data, _ = await self._make_request(url)+ return self._parse_repository(data)++ async def _get_cursorrules_url(self, repository: str) -> str:+ """Get the URL for checking .cursorrules file."""+ # Get repository details to get the main branch+ repo_details = await self.get_repository_details_from_repo_name(repository)+ if not repo_details.main_branch:+ raise ResourceNotFoundError(+ f'Main branch not found for repository {repository}. '+ f'This repository may be empty or have no default branch configured.'+ )+ return f'{self.BASE_URL}/repositories/{repository}/src/{repo_details.main_branch}/.cursorrules'++ async def _get_microagents_directory_url(+ self, repository: str, microagents_path: str+ ) -> str:+ """Get the URL for checking microagents directory."""+ # Get repository details to get the main branch+ repo_details = await self.get_repository_details_from_repo_name(repository)+ if not repo_details.main_branch:+ raise ResourceNotFoundError(+ f'Main branch not found for repository {repository}. '+ f'This repository may be empty or have no default branch configured.'+ )+ return f'{self.BASE_URL}/repositories/{repository}/src/{repo_details.main_branch}/{microagents_path}'++ def _get_microagents_directory_params(self, microagents_path: str) -> dict | None:+ """Get parameters for the microagents directory request. Return None if no parameters needed."""+ return None++ def _is_valid_microagent_file(self, item: dict) -> bool:+ """Check if an item represents a valid microagent file."""+ return (+ item['type'] == 'commit_file'+ and item['path'].endswith('.md')+ and not item['path'].endswith('README.md')+ )++ def _get_file_name_from_item(self, item: dict) -> str:+ """Extract file name from directory item."""+ return item['path'].split('/')[-1]++ def _get_file_path_from_item(self, item: dict, microagents_path: str) -> str:+ """Extract file path from directory item."""+ return item['path']diff --git a/openhands/integrations/bitbucket/service/branches.py b/openhands/integrations/bitbucket/service/branches.pynew file mode 100644index 0000000000..4d04cf8ca9--- /dev/null+++ b/openhands/integrations/bitbucket/service/branches.py@@ -0,0 +1,116 @@+from openhands.integrations.bitbucket.service.base import BitBucketMixinBase+from openhands.integrations.service_types import Branch, PaginatedBranchesResponse+++class BitBucketBranchesMixin(BitBucketMixinBase):+ """+ Mixin for BitBucket branch-related operations+ """++ async def get_branches(self, repository: str) -> list[Branch]:+ """Get branches for a repository."""+ owner, repo = self._extract_owner_and_repo(repository)++ url = f'{self.BASE_URL}/repositories/{owner}/{repo}/refs/branches'++ # Set maximum branches to fetch (similar to GitHub/GitLab implementations)+ MAX_BRANCHES = 1000+ PER_PAGE = 100++ params = {+ 'pagelen': PER_PAGE,+ 'sort': '-target.date', # Sort by most recent commit date, descending+ }++ # Fetch all branches with pagination+ branch_data = await self._fetch_paginated_data(url, params, MAX_BRANCHES)++ branches = []+ for branch in branch_data:+ branches.append(+ Branch(+ name=branch.get('name', ''),+ commit_sha=branch.get('target', {}).get('hash', ''),+ protected=False, # Bitbucket doesn't expose this in the API+ last_push_date=branch.get('target', {}).get('date', None),+ )+ )++ return branches++ async def get_paginated_branches(+ self, repository: str, page: int = 1, per_page: int = 30+ ) -> PaginatedBranchesResponse:+ """Get branches for a repository with pagination."""+ # Extract owner and repo from the repository string (e.g., "owner/repo")+ parts = repository.split('/')+ if len(parts) < 2:+ raise ValueError(f'Invalid repository name: {repository}')++ owner = parts[-2]+ repo = parts[-1]++ url = f'{self.BASE_URL}/repositories/{owner}/{repo}/refs/branches'++ params = {+ 'pagelen': per_page,+ 'page': page,+ 'sort': '-target.date', # Sort by most recent commit date, descending+ }++ response, _ = await self._make_request(url, params)++ branches = []+ for branch in response.get('values', []):+ branches.append(+ Branch(+ name=branch.get('name', ''),+ commit_sha=branch.get('target', {}).get('hash', ''),+ protected=False, # Bitbucket doesn't expose this in the API+ last_push_date=branch.get('target', {}).get('date', None),+ )+ )++ # Bitbucket provides pagination info in the response+ has_next_page = response.get('next') is not None+ total_count = response.get('size') # Total number of items++ return PaginatedBranchesResponse(+ branches=branches,+ has_next_page=has_next_page,+ current_page=page,+ per_page=per_page,+ total_count=total_count,+ )++ async def search_branches(+ self, repository: str, query: str, per_page: int = 30+ ) -> list[Branch]:+ """Search branches by name using Bitbucket API with `q` param."""+ parts = repository.split('/')+ if len(parts) < 2:+ raise ValueError(f'Invalid repository name: {repository}')++ owner = parts[-2]+ repo = parts[-1]++ url = f'{self.BASE_URL}/repositories/{owner}/{repo}/refs/branches'+ # Bitbucket filtering: name ~ "query"+ params = {+ 'pagelen': per_page,+ 'q': f'name~"{query}"',+ 'sort': '-target.date',+ }+ response, _ = await self._make_request(url, params)++ branches: list[Branch] = []+ for branch in response.get('values', []):+ branches.append(+ Branch(+ name=branch.get('name', ''),+ commit_sha=branch.get('target', {}).get('hash', ''),+ protected=False,+ last_push_date=branch.get('target', {}).get('date', None),+ )+ )+ return branchesdiff --git a/openhands/integrations/bitbucket/service/features.py b/openhands/integrations/bitbucket/service/features.pynew file mode 100644index 0000000000..8451ad9603--- /dev/null+++ b/openhands/integrations/bitbucket/service/features.py@@ -0,0 +1,45 @@+from openhands.core.logger import openhands_logger as logger+from openhands.integrations.bitbucket.service.base import BitBucketMixinBase+from openhands.integrations.service_types import ResourceNotFoundError+from openhands.microagent.types import MicroagentContentResponse+++class BitBucketFeaturesMixin(BitBucketMixinBase):+ """+ Mixin for BitBucket feature operations (microagents, cursor rules, etc.)+ """++ async def get_microagent_content(+ self, repository: str, file_path: str+ ) -> MicroagentContentResponse:+ """Fetch individual file content from Bitbucket repository.++ Args:+ repository: Repository name in format 'workspace/repo_slug'+ file_path: Path to the file within the repository++ Returns:+ MicroagentContentResponse with parsed content and triggers++ Raises:+ RuntimeError: If file cannot be fetched or doesn't exist+ """+ # Step 1: Get repository details using existing method+ repo_details = await self.get_repository_details_from_repo_name(repository)++ if not repo_details.main_branch:+ logger.warning(+ f'No main branch found in repository info for {repository}. '+ f'Repository response: mainbranch field missing'+ )+ raise ResourceNotFoundError(+ f'Main branch not found for repository {repository}. '+ f'This repository may be empty or have no default branch configured.'+ )++ # Step 2: Get file content using the main branch+ file_url = f'{self.BASE_URL}/repositories/{repository}/src/{repo_details.main_branch}/{file_path}'+ response, _ = await self._make_request(file_url)++ # Parse the content to extract triggers from frontmatter+ return self._parse_microagent_content(response, file_path)diff --git a/openhands/integrations/bitbucket/service/prs.py b/openhands/integrations/bitbucket/service/prs.pynew file mode 100644index 0000000000..89e9d22dde--- /dev/null+++ b/openhands/integrations/bitbucket/service/prs.py@@ -0,0 +1,100 @@+from openhands.core.logger import openhands_logger as logger+from openhands.integrations.bitbucket.service.base import BitBucketMixinBase+from openhands.integrations.service_types import RequestMethod+++class BitBucketPRsMixin(BitBucketMixinBase):+ """+ Mixin for BitBucket pull request operations+ """++ async def create_pr(+ self,+ repo_name: str,+ source_branch: str,+ target_branch: str,+ title: str,+ body: str | None = None,+ draft: bool = False,+ ) -> str:+ """Creates a pull request in Bitbucket.++ Args:+ repo_name: The repository name in the format "workspace/repo"+ source_branch: The source branch name+ target_branch: The target branch name+ title: The title of the pull request+ body: The description of the pull request+ draft: Whether to create a draft pull request++ Returns:+ The URL of the created pull request+ """+ owner, repo = self._extract_owner_and_repo(repo_name)++ url = f'{self.BASE_URL}/repositories/{owner}/{repo}/pullrequests'++ payload = {+ 'title': title,+ 'description': body or '',+ 'source': {'branch': {'name': source_branch}},+ 'destination': {'branch': {'name': target_branch}},+ 'close_source_branch': False,+ 'draft': draft,+ }++ data, _ = await self._make_request(+ url=url, params=payload, method=RequestMethod.POST+ )++ # Return the URL to the pull request+ return data.get('links', {}).get('html', {}).get('href', '')++ async def get_pr_details(self, repository: str, pr_number: int) -> dict:+ """Get detailed information about a specific pull request++ Args:+ repository: Repository name in format 'owner/repo'+ pr_number: The pull request number++ Returns:+ Raw Bitbucket API response for the pull request+ """+ url = f'{self.BASE_URL}/repositories/{repository}/pullrequests/{pr_number}'+ pr_data, _ = await self._make_request(url)++ return pr_data++ async def is_pr_open(self, repository: str, pr_number: int) -> bool:+ """Check if a Bitbucket pull request is still active (not closed/merged).++ Args:+ repository: Repository name in format 'owner/repo'+ pr_number: The PR number to check++ Returns:+ True if PR is active (OPEN), False if closed/merged+ """+ try:+ pr_details = await self.get_pr_details(repository, pr_number)++ # Bitbucket API response structure+ # https://developer.atlassian.com/cloud/bitbucket/rest/api-group-pullrequests/#api-repositories-workspace-repo-slug-pullrequests-pull-request-id-get+ if 'state' in pr_details:+ # Bitbucket state values: OPEN, MERGED, DECLINED, SUPERSEDED+ return pr_details['state'] == 'OPEN'++ # If we can't determine the state, assume it's active (safer default)+ logger.warning(+ f'Could not determine Bitbucket PR status for {repository}#{pr_number}. '+ f'Response keys: {list(pr_details.keys())}. Assuming PR is active.'+ )+ return True++ except Exception as e:+ logger.warning(+ f'Could not determine Bitbucket PR status for {repository}#{pr_number}: {e}. '+ f'Including conversation to be safe.'+ )+ # If we can't determine the PR status, include the conversation to be safe+ return Truediff --git a/openhands/integrations/bitbucket/service/repos.py b/openhands/integrations/bitbucket/service/repos.pynew file mode 100644index 0000000000..1582c5f71d--- /dev/null+++ b/openhands/integrations/bitbucket/service/repos.py@@ -0,0 +1,245 @@+import re+from typing import Any++from openhands.integrations.bitbucket.service.base import BitBucketMixinBase+from openhands.integrations.service_types import Repository, SuggestedTask+from openhands.server.types import AppMode+++class BitBucketReposMixin(BitBucketMixinBase):+ """+ Mixin for BitBucket repository-related operations+ """++ async def search_repositories(+ self, query: str, per_page: int, sort: str, order: str, public: bool+ ) -> list[Repository]:+ """Search for repositories."""+ repositories = []++ if public:+ # Extract workspace and repo from URL+ # URL format: https://{domain}/{workspace}/{repo}/{additional_params}+ # Split by '/' and find workspace and repo parts+ url_parts = query.split('/')+ if len(url_parts) >= 5: # https:, '', domain, workspace, repo+ workspace_slug = url_parts[3]+ repo_name = url_parts[4]++ repo = await self.get_repository_details_from_repo_name(+ f'{workspace_slug}/{repo_name}'+ )+ repositories.append(repo)++ return repositories++ # Search for repos once workspace prefix exists+ if '/' in query:+ workspace_slug, repo_query = query.split('/', 1)+ return await self.get_paginated_repos(+ 1, per_page, sort, workspace_slug, repo_query+ )++ all_installations = await self.get_installations()++ # Workspace prefix isn't complete. Search workspace names and repos underneath each workspace+ matching_workspace_slugs = [+ installation for installation in all_installations if query in installation+ ]+ for workspace_slug in matching_workspace_slugs:+ # Get repositories where query matches workspace name+ try:+ repos = await self.get_paginated_repos(+ 1, per_page, sort, workspace_slug+ )+ repositories.extend(repos)+ except Exception:+ continue++ for workspace_slug in all_installations:+ # Get repositories in all workspaces where query matches repo name+ try:+ repos = await self.get_paginated_repos(+ 1, per_page, sort, workspace_slug, query+ )+ repositories.extend(repos)+ except Exception:+ continue++ return repositories++ async def _get_user_workspaces(self) -> list[dict[str, Any]]:+ """Get all workspaces the user has access to"""+ url = f'{self.BASE_URL}/workspaces'+ data, _ = await self._make_request(url)+ return data.get('values', [])++ async def get_installations(+ self, query: str | None = None, limit: int = 100+ ) -> list[str]:+ workspaces_url = f'{self.BASE_URL}/workspaces'+ params = {}+ if query:+ params['q'] = f'name~"{query}"'++ workspaces = await self._fetch_paginated_data(workspaces_url, params, limit)++ installations: list[str] = []+ for workspace in workspaces:+ installations.append(workspace['slug'])++ return installations++ async def get_paginated_repos(+ self,+ page: int,+ per_page: int,+ sort: str,+ installation_id: str | None,+ query: str | None = None,+ ) -> list[Repository]:+ """Get paginated repositories for a specific workspace.++ Args:+ page: The page number to fetch+ per_page: The number of repositories per page+ sort: The sort field ('pushed', 'updated', 'created', 'full_name')+ installation_id: The workspace slug to fetch repositories from (as int, will be converted to string)++ Returns:+ A list of Repository objects+ """+ if not installation_id:+ return []++ # Convert installation_id to string for use as workspace_slug+ workspace_slug = installation_id+ workspace_repos_url = f'{self.BASE_URL}/repositories/{workspace_slug}'++ # Map sort parameter to Bitbucket API compatible values+ bitbucket_sort = sort+ if sort == 'pushed':+ # Bitbucket doesn't support 'pushed', use 'updated_on' instead+ bitbucket_sort = '-updated_on' # Use negative prefix for descending order+ elif sort == 'updated':+ bitbucket_sort = '-updated_on'+ elif sort == 'created':+ bitbucket_sort = '-created_on'+ elif sort == 'full_name':+ bitbucket_sort = 'name' # Bitbucket uses 'name' not 'full_name'+ else:+ # Default to most recently updated first+ bitbucket_sort = '-updated_on'++ params = {+ 'pagelen': per_page,+ 'page': page,+ 'sort': bitbucket_sort,+ }++ if query:+ params['q'] = f'name~"{query}"'++ response, headers = await self._make_request(workspace_repos_url, params)++ # Extract repositories from the response+ repos = response.get('values', [])++ # Extract next URL from response+ next_link = response.get('next', '')++ # Format the link header in a way that the frontend can understand+ # The frontend expects a format like: <url>; rel="next"+ # where the URL contains a page parameter+ formatted_link_header = ''+ if next_link:+ # Extract the page number from the next URL if possible+ page_match = re.search(r'[?&]page=(\d+)', next_link)+ if page_match:+ next_page = page_match.group(1)+ # Format it in a way that extractNextPageFromLink in frontend can parse+ formatted_link_header = (+ f'<{workspace_repos_url}?page={next_page}>; rel="next"'+ )+ else:+ # If we can't extract the page, just use the next URL as is+ formatted_link_header = f'<{next_link}>; rel="next"'++ repositories = [+ self._parse_repository(repo, link_header=formatted_link_header)+ for repo in repos+ ]++ return repositories++ async def get_all_repositories(+ self, sort: str, app_mode: AppMode+ ) -> list[Repository]:+ """Get repositories for the authenticated user using workspaces endpoint.++ This method gets all repositories (both public and private) that the user has access to+ by iterating through their workspaces and fetching repositories from each workspace.+ This approach is more comprehensive and efficient than the previous implementation+ that made separate calls for public and private repositories.+ """+ MAX_REPOS = 1000+ PER_PAGE = 100 # Maximum allowed by Bitbucket API+ repositories: list[Repository] = []++ # Get user's workspaces with pagination+ workspaces_url = f'{self.BASE_URL}/workspaces'+ workspaces = await self._fetch_paginated_data(workspaces_url, {}, MAX_REPOS)++ for workspace in workspaces:+ workspace_slug = workspace.get('slug')+ if not workspace_slug:+ continue++ # Get repositories for this workspace with pagination+ workspace_repos_url = f'{self.BASE_URL}/repositories/{workspace_slug}'++ # Map sort parameter to Bitbucket API compatible values and ensure descending order+ # to show most recently changed repos at the top+ bitbucket_sort = sort+ if sort == 'pushed':+ # Bitbucket doesn't support 'pushed', use 'updated_on' instead+ bitbucket_sort = (+ '-updated_on' # Use negative prefix for descending order+ )+ elif sort == 'updated':+ bitbucket_sort = '-updated_on'+ elif sort == 'created':+ bitbucket_sort = '-created_on'+ elif sort == 'full_name':+ bitbucket_sort = 'name' # Bitbucket uses 'name' not 'full_name'+ else:+ # Default to most recently updated first+ bitbucket_sort = '-updated_on'++ params = {+ 'pagelen': PER_PAGE,+ 'sort': bitbucket_sort,+ }++ # Fetch all repositories for this workspace with pagination+ workspace_repos = await self._fetch_paginated_data(+ workspace_repos_url, params, MAX_REPOS - len(repositories)+ )++ for repo in workspace_repos:+ repositories.append(self._parse_repository(repo))++ # Stop if we've reached the maximum number of repositories+ if len(repositories) >= MAX_REPOS:+ break++ # Stop if we've reached the maximum number of repositories+ if len(repositories) >= MAX_REPOS:+ break++ return repositories++ async def get_suggested_tasks(self) -> list[SuggestedTask]:+ """Get suggested tasks for the authenticated user across all repositories."""+ # TODO: implemented suggested tasks+ return []