@gitkraken/core-gitlens 0.4.0 → 0.4.101

package/src/plus/integrations/providers/bitbucket/bitbucket.ts

@@ -1,25 +1,30 @@
 import type { Account, CommitAuthor, UnidentifiedAuthor } from '../../../../git/models/author.js';
+import type { DefaultBranch } from '../../../../git/models/defaultBranch.js';
 import type { Issue } from '../../../../git/models/issue.js';
 import type { IssueOrPullRequest, IssueOrPullRequestType } from '../../../../git/models/issueOrPullRequest.js';
 import type { PullRequest } from '../../../../git/models/pullRequest.js';
 import type { Provider } from '../../../../git/models/remoteProvider.js';
 import type { RepositoryMetadata } from '../../../../git/models/repositoryMetadata.js';
-import { CancellationError } from '../../../../utils/cancellation.js';
+import { CancellationError, isCancellationError } from '../../../../utils/cancellation.js';
 import { trace } from '../../../../utils/decorators/log.js';
 import type { Disposable } from '../../../../utils/disposable.js';
 import { Logger } from '../../../../utils/logger.js';
 import type { ScopedLogger } from '../../../../utils/logger.scoped.js';
 import { getScopedLogger } from '../../../../utils/logger.scoped.js';
 import { maybeStopWatch } from '../../../../utils/stopwatch.js';
-import type { TokenInfo, TokenWithInfo } from '../../authentication/models.js';
+import type { TokenWithInfo } from '../../authentication/models.js';
 import type { IntegrationServiceContext } from '../../context.js';
 import {
 	AuthenticationError,
 	AuthenticationErrorReason,
+	isRateLimitResponse,
 	ProviderFetchError,
 	RequestClientError,
 	RequestNotFoundError,
+	toRateLimitError,
 } from '../../errors.js';
+import type { ProviderApiConfig } from '../apiConfig.js';
+import { baseProviderApiConfig } from '../apiConfig.js';
 import type { BitbucketServerCommit, BitbucketServerPullRequest } from '../bitbucket-server/models.js';
 import { normalizeBitbucketServerPullRequest } from '../bitbucket-server/models.js';
 import { fromProviderPullRequest } from '../models.js';
@@ -32,18 +37,14 @@ import {
 } from './models.js';
 
 export class BitbucketApi implements Disposable {
-	private readonly _disposable: Disposable;
+	private readonly _disposable: Disposable | undefined;
 
-	constructor(private readonly ctx: IntegrationServiceContext) {
-		this._disposable = ctx.config.onDidChange(e => {
-			if (e.httpProxy) {
-				this.resetCaches();
-			}
-		});
+	constructor(private readonly config: ProviderApiConfig) {
+		this._disposable = config.onConfigChanged?.(() => this.resetCaches());
 	}
 
 	dispose(): void {
-		this._disposable.dispose();
+		this._disposable?.dispose();
 	}
 
 	private resetCaches(): void {}
@@ -411,6 +412,130 @@ export class BitbucketApi implements Disposable {
 		}
 	}
 
+	@trace({
+		args: (provider, token, owner, repo) => ({
+			provider: provider.name,
+			token: `<token:${token.microHash}>`,
+			owner: owner,
+			repo: repo,
+		}),
+	})
+	async getRepositoryMetadata(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		repo: string,
+		options: {
+			baseUrl: string;
+		},
+		cancellation?: AbortSignal,
+	): Promise<RepositoryMetadata | undefined> {
+		const scope = getScopedLogger();
+
+		try {
+			const response = await this.getRepository(
+				provider,
+				token,
+				owner,
+				repo,
+				options.baseUrl,
+				scope,
+				cancellation,
+			);
+			if (response == null) return undefined;
+
+			let parent: RepositoryMetadata['parent'];
+			if (response.parent != null) {
+				// Derive the parent from `full_name` ("owner/repo") rather than `parent.workspace`, which is a
+				// requested field expansion Bitbucket doesn't always honor (an unexpanded parent would otherwise
+				// throw and null out the whole result).
+				// `full_name` is "owner/repo"; only report a parent when both parts are present so a malformed
+				// value doesn't produce a parent with an undefined owner/name while `isFork` stays true.
+				const [parentOwner, parentName] = response.parent.full_name.split('/');
+				if (parentOwner && parentName) {
+					parent = { owner: parentOwner, name: parentName };
+				}
+			}
+
+			return {
+				provider: provider,
+				owner: response.workspace.slug,
+				name: response.slug,
+				isFork: response.parent != null,
+				parent: parent,
+			} satisfies RepositoryMetadata;
+		} catch (ex) {
+			// Cancellations and 404s are expected outcomes for a probe; don't log them as errors.
+			if (!isCancellationError(ex) && !(ex instanceof RequestNotFoundError)) {
+				scope?.error(ex);
+			}
+			return undefined;
+		}
+	}
+
+	@trace({
+		args: (provider, token, owner, repo) => ({
+			provider: provider.name,
+			token: `<token:${token.microHash}>`,
+			owner: owner,
+			repo: repo,
+		}),
+	})
+	async getDefaultBranch(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		repo: string,
+		options: {
+			baseUrl: string;
+		},
+		cancellation?: AbortSignal,
+	): Promise<DefaultBranch | undefined> {
+		const scope = getScopedLogger();
+
+		try {
+			const response = await this.getRepository(
+				provider,
+				token,
+				owner,
+				repo,
+				options.baseUrl,
+				scope,
+				cancellation,
+			);
+			const name = response?.mainbranch?.name;
+			if (name == null) return undefined;
+
+			return { provider: provider, name: name } satisfies DefaultBranch;
+		} catch (ex) {
+			// Cancellations and 404s are expected outcomes for a probe; don't log them as errors.
+			if (!isCancellationError(ex) && !(ex instanceof RequestNotFoundError)) {
+				scope?.error(ex);
+			}
+			return undefined;
+		}
+	}
+
+	private getRepository(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		repo: string,
+		baseUrl: string,
+		scope: ScopedLogger | undefined,
+		cancellation?: AbortSignal,
+	): Promise<BitbucketRepository | undefined> {
+		return this.request<BitbucketRepository>(
+			provider,
+			token,
+			baseUrl,
+			`repositories/${owner}/${repo}`,
+			{ method: 'GET' },
+			scope,
+			cancellation,
+		);
+	}
+
 	@trace({
 		args: (provider, token, owner, repo, rev, baseUrl) => ({
 			provider: provider.name,
@@ -521,7 +646,7 @@ export class BitbucketApi implements Disposable {
 					// TODO: In future get it on to home as an warning on the integration itself "this integration has issues"
 					// even user suppresses the message it's still visible with some capacity. It's a broader thing to get other errors.
 					const commitWebUrl = `https://bitbucket.org/${owner}/${repo}/commits/${rev}`;
-					this.ctx.hooks?.ui?.onBitbucketCommitLinksAppMissing?.(commitWebUrl);
+					this.config.onBitbucketCommitLinksAppMissing?.(commitWebUrl);
 					return undefined;
 				}
 			}
@@ -669,7 +794,7 @@ export class BitbucketApi implements Disposable {
 		scope?: ScopedLogger | undefined,
 		cancellation?: AbortSignal | undefined,
 	): Promise<T | undefined> {
-		const { accessToken, ...tokenInfo } = token;
+		const { accessToken } = token;
 		const url = `${baseUrl}/${route}`;
 
 		let rsp: Response;
@@ -679,8 +804,8 @@ export class BitbucketApi implements Disposable {
 			try {
 				if (cancellation?.aborted) throw new CancellationError();
 
-				rsp = await this.ctx.http.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
-					this.ctx.http.fetch(url, {
+				rsp = await this.config.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
+					this.config.fetch(url, {
 						headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
 						signal: cancellation,
 						...options,
@@ -691,15 +816,16 @@ export class BitbucketApi implements Disposable {
 					return (await rsp.json()) as T;
 				}
 
-				throw new ProviderFetchError('Bitbucket', rsp);
+				// Reads the body so the 403 branch below can tell a throttled request from a permission failure.
+				throw await ProviderFetchError.fromResponse('Bitbucket', rsp);
 			} finally {
 				sw?.stop();
 			}
 		} catch (ex) {
 			if (ex instanceof ProviderFetchError || ex.name === 'AbortError') {
-				this.handleRequestError(provider, tokenInfo, ex, scope);
+				this.handleRequestError(provider, token, ex, scope);
 			} else if (Logger.isDebugging) {
-				this.ctx.hooks?.ui?.onError?.(`Bitbucket request failed: ${ex.message}`);
+				this.config.onError?.(`Bitbucket request failed: ${ex.message}`);
 			}
 
 			throw ex;
@@ -708,12 +834,13 @@ export class BitbucketApi implements Disposable {
 
 	private handleRequestError(
 		provider: Provider | undefined,
-		tokenInfo: TokenInfo,
+		token: TokenWithInfo,
 		ex: ProviderFetchError | (Error & { name: 'AbortError' }),
 		scope: ScopedLogger | undefined,
 	): void {
 		if (ex.name === 'AbortError' || !(ex instanceof ProviderFetchError)) throw new CancellationError(ex);
 
+		const { accessToken, ...tokenInfo } = token;
 		switch (ex.status) {
 			case 404: // Not found
 			case 410: // Gone
@@ -721,27 +848,20 @@ export class BitbucketApi implements Disposable {
 				throw new RequestNotFoundError(ex);
 			case 401: // Unauthorized
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Unauthorized, ex);
+			case 429: // Too Many Requests
+				throw toRateLimitError(ex, accessToken);
 			case 403: // Forbidden
-				// TODO: Learn the Bitbucket API docs and put it in order:
-				// 	if (ex.message.includes('rate limit')) {
-				// 		let resetAt: number | undefined;
-
-				// 		const reset = ex.response?.headers?.get('x-ratelimit-reset');
-				// 		if (reset != null) {
-				// 			resetAt = parseInt(reset, 10);
-				// 			if (Number.isNaN(resetAt)) {
-				// 				resetAt = undefined;
-				// 			}
-				// 		}
-
-				// 		throw new RequestRateLimitError(ex, token, resetAt);
-				// 	}
+				// Bitbucket returns 403 for both a permission failure and a throttled request ("API rate limit
+				// exceeded"), so the message is the discriminant. Reporting a throttle as `auth` would prompt the
+				// user to re-authenticate a healthy connection instead of retrying (see `isRateLimitResponse`).
+				if (isRateLimitResponse(ex)) throw toRateLimitError(ex, accessToken);
+
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
 			case 500: // Internal Server Error
 				scope?.error(ex);
 				if (ex.response != null) {
 					provider?.trackRequestException();
-					this.ctx.hooks?.ui?.onRequestFailed?.(
+					this.config.onRequestFailed?.(
 						`${provider?.name ?? 'Bitbucket'} failed to respond and might be experiencing issues.${
 							provider == null || provider.id === 'bitbucket'
 								? ' Please visit the [Bitbucket status page](https://bitbucket.status.atlassian.com/) for more information.'
@@ -766,9 +886,19 @@ export class BitbucketApi implements Disposable {
 
 		scope?.error(ex);
 		if (Logger.isDebugging) {
-			this.ctx.hooks?.ui?.onError?.(
+			this.config.onError?.(
 				`Bitbucket request failed: ${(ex.response as any)?.errors?.[0]?.message ?? ex.message}`,
 			);
 		}
 	}
 }
+
+/** Wires a {@link BitbucketApi} from the full runtime context, mapping `ctx` down to the narrow config. */
+export function createBitbucketApi(ctx: IntegrationServiceContext): BitbucketApi {
+	const config: ProviderApiConfig = {
+		...baseProviderApiConfig(ctx),
+		onBitbucketCommitLinksAppMissing: revLink => ctx.hooks?.ui?.onBitbucketCommitLinksAppMissing?.(revLink),
+	};
+
+	return new BitbucketApi(config);
+}

package/src/plus/integrations/providers/bitbucket-server/models.ts

@@ -1,6 +1,36 @@
-import { GitPullRequestMergeableState, GitPullRequestReviewState, GitPullRequestState } from '@gitkraken/provider-apis';
+import type {
+	GitPullRequestMergeableState as GitPullRequestMergeableStateType,
+	GitPullRequestReviewState as GitPullRequestReviewStateType,
+	GitPullRequestState as GitPullRequestStateType,
+} from '@gitkraken/provider-apis';
 import type { ProviderAccount, ProviderPullRequest } from '../models.js';
 
+type GitPullRequestMergeableState = GitPullRequestMergeableStateType;
+type GitPullRequestReviewState = GitPullRequestReviewStateType;
+type GitPullRequestState = GitPullRequestStateType;
+
+// Local runtime copies of the `@gitkraken/provider-apis` PR string enums, duplicated for the same
+// CJS-from-ESM reason as the enums in `../models.ts`. Exported so the enum-parity test can guard them
+// against upstream drift. `GitPullRequestMergeableState` is an intentional subset: Bitbucket Server
+// only ever normalizes to `Unknown`, so the parity test asserts each local entry matches the SDK
+// rather than a full mirror.
+export const GitPullRequestState = {
+	Open: 'OPEN' as GitPullRequestState,
+	Closed: 'CLOSED' as GitPullRequestState,
+	Merged: 'MERGED' as GitPullRequestState,
+} as const;
+
+export const GitPullRequestReviewState = {
+	Approved: 'APPROVED' as GitPullRequestReviewState,
+	ChangesRequested: 'CHANGES_REQUESTED' as GitPullRequestReviewState,
+	Commented: 'COMMENTED' as GitPullRequestReviewState,
+	ReviewRequested: 'REVIEW_REQUESTED' as GitPullRequestReviewState,
+} as const;
+
+export const GitPullRequestMergeableState = {
+	Unknown: 'UNKNOWN' as GitPullRequestMergeableState,
+} as const;
+
 export interface BitbucketServerLink {
 	href: string;
 }
@@ -193,6 +223,7 @@ export const normalizeBitbucketServerPullRequest = (pr: BitbucketServerPullReque
 		description: pr.description ?? null,
 		url: pr.links.self[0].href,
 		state: bitbucketStateToGitState[pr.state],
+		isCrossRepository: pr.toRef.repository.id !== pr.fromRef.repository.id,
 		isDraft: false,
 		createdDate: new Date(pr.createdDate),
 		updatedDate: new Date(pr.updatedDate),

package/src/plus/integrations/providers/bitbucket-server.ts

@@ -2,26 +2,49 @@ import type { Account, UnidentifiedAuthor } from '../../../git/models/author.js'
 import type { DefaultBranch } from '../../../git/models/defaultBranch.js';
 import type { Issue, IssueShape } from '../../../git/models/issue.js';
 import type { IssueOrPullRequest, IssueOrPullRequestType } from '../../../git/models/issueOrPullRequest.js';
-import type { PullRequest, PullRequestMergeMethod, PullRequestState } from '../../../git/models/pullRequest.js';
+import type {
+	PullRequest,
+	PullRequestMergeMethod,
+	PullRequestState,
+	PullRequestStateFilter,
+} from '../../../git/models/pullRequest.js';
+import type { GitRemote } from '../../../git/models/remote.js';
 import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
+import { CancellationError } from '../../../utils/cancellation.js';
 import { md5 } from '../../../utils/crypto.js';
 import type { Emitter } from '../../../utils/event.js';
+import type { PagedResult } from '../../../utils/paging.js';
+import { nonnullSettled } from '../../../utils/promise.js';
 import type { IntegrationAuthenticationProviderDescriptor } from '../authentication/integrationAuthenticationProvider.js';
 import type { IntegrationAuthenticationService } from '../authentication/integrationAuthenticationService.js';
-import type { IntegrationServiceContext } from '../context.js';
 import type {
 	AuthenticationSessionLike as AuthenticationSession,
 	ProviderAuthenticationSession,
 } from '../authentication/models.js';
 import { toTokenWithInfo } from '../authentication/models.js';
 import { GitSelfManagedHostIntegrationId } from '../constants.js';
+import type { IntegrationServiceContext } from '../context.js';
 import type { IntegrationConnectionChangeEvent } from '../integrationService.js';
+import type { SearchMyPullRequestsOptions } from '../models/gitHostIntegration.js';
 import { GitHostIntegration } from '../models/gitHostIntegration.js';
 import type { IntegrationKey } from '../models/integration.js';
 import type { BitbucketRepositoryDescriptor } from './bitbucket/models.js';
-import type { ProviderRepository } from './models.js';
-import { fromProviderPullRequest, providersMetadata } from './models.js';
+import type { ProviderPullRequest, ProviderRepository } from './models.js';
+import {
+	fromProviderPullRequest,
+	providerPullRequestMatchesSearch,
+	ProviderPullRequestReviewState,
+	providersMetadata,
+	PullRequestFilter,
+	toProviderPullRequestStates,
+} from './models.js';
 import type { ProvidersApi } from './providersApi.js';
+import {
+	collectProviderPagedResult,
+	flatSettledOrThrow,
+	parsePageCursor,
+	toPageCursor,
+} from './utils/providerPaging.js';
 
 const metadata = providersMetadata[GitSelfManagedHostIntegrationId.BitbucketServer];
 const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
@@ -169,10 +192,18 @@ export class BitbucketServerIntegration extends GitHostIntegration<
 		);
 	}
 
-	public override async getRepoInfo(repo: { owner: string; name: string }): Promise<ProviderRepository | undefined> {
+	public override async getRepoInfo(repo: {
+		owner: string;
+		name: string;
+		project?: string;
+		connectionId?: string;
+	}): Promise<ProviderRepository | undefined> {
 		const api = await this.getProvidersApi();
-		const tokenOptInfo = this._session ? toTokenWithInfo(this.id, this._session) : { providerId: this.id };
-		return api.getRepo(tokenOptInfo, repo.owner, repo.name, undefined, {
+		// `connectionId` targets a specific account (multi-account); omitted reads the primary.
+		const session = await this.resolveReadSession(repo.connectionId, undefined);
+		if (session == null) return undefined;
+
+		return api.getRepo(toTokenWithInfo(this.id, session), repo.owner, repo.name, repo.project, {
 			baseUrl: this.apiBaseUrl,
 		});
 	}
@@ -219,6 +250,10 @@ export class BitbucketServerIntegration extends GitHostIntegration<
 	protected override async searchProviderMyPullRequests(
 		session: ProviderAuthenticationSession,
 		repos?: BitbucketRepositoryDescriptor[],
+		_cancellation?: AbortSignal,
+		_silent?: boolean,
+		state?: PullRequestStateFilter,
+		_options?: SearchMyPullRequestsOptions,
 	): Promise<PullRequest[] | undefined> {
 		if (repos != null) {
 			// TODO: implement repos version
@@ -233,8 +268,125 @@ export class BitbucketServerIntegration extends GitHostIntegration<
 		const prs = await api.getBitbucketServerPullRequestsForCurrentUser(
 			toTokenWithInfo(this.id, session),
 			this.apiBaseUrl,
+			{ states: toProviderPullRequestStates(state) },
 		);
-		return prs?.map(pr => fromProviderPullRequest(pr, this));
+		return prs?.data.map(pr => fromProviderPullRequest(pr, this));
+	}
+
+	protected override async getProviderMyPullRequestsForUser(
+		session: ProviderAuthenticationSession,
+		options?: { state?: PullRequestStateFilter[]; cursor?: string; filters?: PullRequestFilter[] },
+	): Promise<PagedResult<ProviderPullRequest> | undefined> {
+		const api = await this.getProvidersApi();
+		const states = toProviderPullRequestStates(options?.state);
+		// provider-apis translates the public 1-based `page` to Bitbucket Server's `start` offset and normalizes
+		// `nextPageStart` back to the next page number. Thread that number inside our opaque cursor so the
+		// ProviderBackend sweep drives the drain (bounded by its maxPages).
+		const page = parsePageCursor(options?.cursor);
+		const result = await api.getBitbucketServerPullRequestsForCurrentUser(
+			toTokenWithInfo(this.id, session),
+			this.apiBaseUrl,
+			{ states: states, page: page },
+		);
+		if (result == null) return undefined;
+
+		const account = options?.filters?.length ? await this.getProviderCurrentAccount(session) : undefined;
+		const identifiers = new Set([account?.id, account?.username].filter((id): id is string => id != null));
+		if (options?.filters?.length && identifiers.size === 0) {
+			throw new Error(
+				'Unable to resolve the current Bitbucket Data Center account for the requested pull request filters.',
+			);
+		}
+
+		const values = options?.filters?.length
+			? result.data.filter(pr => {
+					const isCurrentUser = (user: { id?: string | null; username?: string | null } | null | undefined) =>
+						user != null &&
+						((user.id != null && identifiers.has(user.id)) ||
+							(user.username != null && identifiers.has(user.username)));
+					const isAuthor = isCurrentUser(pr.author);
+					const isRequestedReviewer = pr.reviews?.some(
+						review =>
+							isCurrentUser(review.reviewer) &&
+							review.state === ProviderPullRequestReviewState.ReviewRequested,
+					);
+					return (
+						(options.filters!.includes(PullRequestFilter.Author) && isAuthor) ||
+						(options.filters!.includes(PullRequestFilter.ReviewRequested) && isRequestedReviewer)
+					);
+				})
+			: result.data;
+
+		return {
+			values: values,
+			paging: {
+				more: result.hasMore,
+				cursor: result.hasMore && result.nextPage != null ? toPageCursor(result.nextPage) : '{}',
+			},
+		};
+	}
+
+	protected override async searchProviderPullRequests(
+		session: ProviderAuthenticationSession,
+		searchQuery: string,
+		repos?: BitbucketRepositoryDescriptor[],
+		cancellation?: AbortSignal,
+		options?: { include?: PullRequestState[] },
+	): Promise<PullRequest[] | undefined> {
+		if (cancellation?.aborted) throw new CancellationError();
+
+		const api = await this.getProvidersApi();
+		if (!api) return undefined;
+
+		const repoInputs =
+			repos != null
+				? repos.map(r => ({ name: r.name, namespace: r.owner }))
+				: await this.getWorkspaceRepoInputs();
+		if (cancellation?.aborted) throw new CancellationError();
+		// An explicitly-empty `repos` means "search these zero repos" -> no results; reserve `undefined`
+		// ("scope couldn't be determined") for when no repos were requested and none were discovered.
+		if (repoInputs.length === 0) return repos != null ? [] : undefined;
+
+		const token = toTokenWithInfo(this.id, session);
+		const states = toProviderPullRequestStates(options?.include);
+		const providerPullRequests = await flatSettledOrThrow(
+			repoInputs.map(async repo => {
+				const result = await collectProviderPagedResult(cursor => {
+					if (cancellation?.aborted) throw new CancellationError();
+
+					return api.getPullRequestsForRepo(token, repo, {
+						baseUrl: this.apiBaseUrl,
+						cursor: cursor,
+						states: states,
+					});
+				});
+				return result.values;
+			}),
+		);
+		if (cancellation?.aborted) throw new CancellationError();
+
+		return providerPullRequests
+			.filter(pr => providerPullRequestMatchesSearch(pr, searchQuery))
+			.map(pr => fromProviderPullRequest(pr, this));
+	}
+
+	private async getWorkspaceRepoInputs(): Promise<{ name: string; namespace: string }[]> {
+		const remotes = await this.ctx.repositories.getOpenRemotes();
+		const inputs = await nonnullSettled(
+			remotes.map(async (r: GitRemote) => {
+				const integration = await this.authenticationService.getByRemote(r);
+				if (integration !== this) return undefined;
+
+				// Use the remote provider's parsing so the Bitbucket Server `scm/<project>/<repo>` prefix is
+				// stripped; a raw `path.split('/')` would yield namespace=`scm`, name=`<project>`.
+				const namespace = r.provider?.owner;
+				const name = r.provider?.repoName;
+				return namespace != null && name != null ? { name: name, namespace: namespace } : undefined;
+			}),
+		);
+		// Dedupe: a repo with multiple remotes (e.g. `origin` + `upstream`) can map to the same input,
+		// which would otherwise fetch and return the same PRs more than once.
+		return [...new Map(inputs.map(i => [`${i.namespace}/${i.name}`, i])).values()];
 	}
 
 	protected override async searchProviderMyIssues(
@@ -244,6 +396,19 @@ export class BitbucketServerIntegration extends GitHostIntegration<
 		return Promise.resolve(undefined);
 	}
 
+	/**
+	 * Bitbucket Data Center exposes no issue tracker at all (issues live in Jira), so — like Bitbucket Cloud,
+	 * whose own tracker is deprecated — it is not an issue provider on the ProviderBackend surface. Without this
+	 * the facade would take `supportsIssues`' default `true` and route the read to a provider that registers no
+	 * issue client: the repo-scoped path fails with the SDK's `does not support function: getIssuesForReposFn`
+	 * as an opaque `kind: 'other'` warning, and `broadenIssues` first drains every repo of the org before hitting
+	 * the same failure. Its metadata already declares no issue filters, so this keeps both halves of the
+	 * capability answer consistent.
+	 */
+	override get supportsIssues(): boolean {
+		return false;
+	}
+
 	private readonly storagePrefix = 'bitbucket-server';
 	protected override async providerOnConnect(): Promise<void> {
 		if (this._session == null) return;