@gitkraken/core-gitlens 0.3.1 → 0.4.0

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

@@ -0,0 +1,282 @@
+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 { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
+import { md5 } from '../../../utils/crypto.js';
+import type { Emitter } from '../../../utils/event.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 { IntegrationConnectionChangeEvent } from '../integrationService.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 { ProvidersApi } from './providersApi.js';
+
+const metadata = providersMetadata[GitSelfManagedHostIntegrationId.BitbucketServer];
+const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
+
+export class BitbucketServerIntegration extends GitHostIntegration<
+	GitSelfManagedHostIntegrationId.BitbucketServer,
+	BitbucketRepositoryDescriptor
+> {
+	readonly authProvider: IntegrationAuthenticationProviderDescriptor = authProvider;
+	readonly id = GitSelfManagedHostIntegrationId.BitbucketServer;
+	protected readonly key =
+		`${this.id}:${this.domain}` satisfies IntegrationKey<GitSelfManagedHostIntegrationId.BitbucketServer>;
+	readonly name: string = 'Bitbucket Data Center';
+
+	constructor(
+		ctx: IntegrationServiceContext,
+		authenticationService: IntegrationAuthenticationService,
+		getProvidersApi: () => Promise<ProvidersApi>,
+		didChangeConnection: Emitter<IntegrationConnectionChangeEvent>,
+		private readonly _domain: string,
+	) {
+		super(ctx, authenticationService, getProvidersApi, didChangeConnection);
+	}
+
+	get domain(): string {
+		return this._domain;
+	}
+
+	protected get apiBaseUrl(): string {
+		const protocol = this._session?.protocol ?? 'https:';
+		return `${protocol}//${this.domain}/rest/api/1.0`;
+	}
+
+	protected override async mergeProviderPullRequest(
+		session: ProviderAuthenticationSession,
+		pr: PullRequest,
+		options?: {
+			mergeMethod?: PullRequestMergeMethod;
+		},
+	): Promise<boolean> {
+		const api = await this.getProvidersApi();
+		return api.mergePullRequest(toTokenWithInfo(this.id, session), pr, {
+			mergeMethod: options?.mergeMethod,
+			baseUrl: this.apiBaseUrl,
+		});
+	}
+
+	protected override async getProviderAccountForCommit(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		rev: string,
+		options?: {
+			avatarSize?: number;
+		},
+	): Promise<Account | UnidentifiedAuthor | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getServerAccountForCommit(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			rev,
+			this.apiBaseUrl,
+			{
+				avatarSize: options?.avatarSize,
+			},
+		);
+	}
+
+	protected override async getProviderAccountForEmail(
+		_session: AuthenticationSession,
+		_repo: BitbucketRepositoryDescriptor,
+		_email: string,
+		_options?: {
+			avatarSize?: number;
+		},
+	): Promise<Account | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	protected override async getProviderDefaultBranch(
+		_session: AuthenticationSession,
+		_repo: BitbucketRepositoryDescriptor,
+	): Promise<DefaultBranch | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	protected override async getProviderLinkedIssueOrPullRequest(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		{ id }: { id: string; key: string },
+		type: undefined | IssueOrPullRequestType,
+	): Promise<IssueOrPullRequest | undefined> {
+		if (type === 'issue') {
+			return undefined;
+		}
+		return (await this.authenticationService.apis.bitbucket)?.getServerPullRequestById(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			id,
+			this.apiBaseUrl,
+		);
+	}
+
+	protected override async getProviderIssue(
+		_session: AuthenticationSession,
+		_repo: BitbucketRepositoryDescriptor,
+		_id: string,
+	): Promise<Issue | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	protected override async getProviderPullRequestForBranch(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		branch: string,
+		_options?: {
+			avatarSize?: number;
+			include?: PullRequestState[];
+		},
+	): Promise<PullRequest | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getServerPullRequestForBranch(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			branch,
+			this.apiBaseUrl,
+		);
+	}
+
+	protected override async getProviderPullRequestForCommit(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		rev: string,
+	): Promise<PullRequest | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getServerPullRequestForCommit(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			rev,
+			this.apiBaseUrl,
+		);
+	}
+
+	public override async getRepoInfo(repo: { owner: string; name: 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, {
+			baseUrl: this.apiBaseUrl,
+		});
+	}
+
+	protected override async getProviderRepositoryMetadata(
+		_session: AuthenticationSession,
+		_repo: BitbucketRepositoryDescriptor,
+		_cancellation?: AbortSignal,
+	): Promise<RepositoryMetadata | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	private _accounts: Map<string, Account | undefined> | undefined;
+	protected override async getProviderCurrentAccount(
+		session: ProviderAuthenticationSession,
+	): Promise<Account | undefined> {
+		const { accessToken } = session;
+		this._accounts ??= new Map<string, Account | undefined>();
+
+		const cachedAccount = this._accounts.get(accessToken);
+		if (cachedAccount == null) {
+			const api = await this.getProvidersApi();
+			const user = await api.getCurrentUser(toTokenWithInfo(this.id, session), {
+				baseUrl: this.apiBaseUrl,
+			});
+			this._accounts.set(
+				accessToken,
+				user
+					? {
+							provider: this,
+							id: user.id,
+							name: user.name ?? undefined,
+							email: user.email ?? undefined,
+							avatarUrl: user.avatarUrl ?? undefined,
+							username: user.username ?? undefined,
+						}
+					: undefined,
+			);
+		}
+
+		return this._accounts.get(accessToken);
+	}
+
+	protected override async searchProviderMyPullRequests(
+		session: ProviderAuthenticationSession,
+		repos?: BitbucketRepositoryDescriptor[],
+	): Promise<PullRequest[] | undefined> {
+		if (repos != null) {
+			// TODO: implement repos version
+			return undefined;
+		}
+
+		const api = await this.getProvidersApi();
+		if (!api) {
+			return undefined;
+		}
+
+		const prs = await api.getBitbucketServerPullRequestsForCurrentUser(
+			toTokenWithInfo(this.id, session),
+			this.apiBaseUrl,
+		);
+		return prs?.map(pr => fromProviderPullRequest(pr, this));
+	}
+
+	protected override async searchProviderMyIssues(
+		_session: AuthenticationSession,
+		_repos?: BitbucketRepositoryDescriptor[],
+	): Promise<IssueShape[] | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	private readonly storagePrefix = 'bitbucket-server';
+	protected override async providerOnConnect(): Promise<void> {
+		if (this._session == null) return;
+
+		const accountStorageKey = md5(this._session.accessToken);
+
+		const storedAccount = this.ctx.storage.get(`${this.storagePrefix}:${accountStorageKey}:account`);
+
+		let account: Account | undefined = storedAccount?.data ? { ...storedAccount.data, provider: this } : undefined;
+
+		if (storedAccount == null) {
+			account = await this.getProviderCurrentAccount(this._session);
+			if (account != null) {
+				// Clear all other stored workspaces and repositories and accounts when our session changes
+				await this.ctx.storage.deleteWithPrefix(this.storagePrefix);
+				await this.ctx.storage.store(`${this.storagePrefix}:${accountStorageKey}:account`, {
+					v: 1,
+					timestamp: Date.now(),
+					data: {
+						id: account.id,
+						name: account.name,
+						email: account.email,
+						avatarUrl: account.avatarUrl,
+						username: account.username,
+					},
+				});
+			}
+		}
+		this._accounts ??= new Map<string, Account | undefined>();
+		this._accounts.set(this._session.accessToken, account);
+	}
+
+	protected override providerOnDisconnect(): void {
+		this._accounts = undefined;
+	}
+}

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

@@ -0,0 +1,350 @@
+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 { GitRemote } from '../../../git/models/remote.js';
+import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
+import { md5 } from '../../../utils/crypto.js';
+import { uniqueBy } from '../../../utils/iterable.js';
+import { flatSettled, nonnullSettled } from '../../../utils/promise.js';
+import type { IntegrationAuthenticationProviderDescriptor } from '../authentication/integrationAuthenticationProvider.js';
+import type {
+	AuthenticationSessionLike as AuthenticationSession,
+	ProviderAuthenticationSession,
+} from '../authentication/models.js';
+import { toTokenWithInfo } from '../authentication/models.js';
+import { GitCloudHostIntegrationId } from '../constants.js';
+import { GitHostIntegration } from '../models/gitHostIntegration.js';
+import type { BitbucketRepositoryDescriptor, BitbucketWorkspaceDescriptor } from './bitbucket/models.js';
+import { fromProviderPullRequest, providersMetadata } from './models.js';
+
+const metadata = providersMetadata[GitCloudHostIntegrationId.Bitbucket];
+const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
+
+export class BitbucketIntegration extends GitHostIntegration<
+	GitCloudHostIntegrationId.Bitbucket,
+	BitbucketRepositoryDescriptor
+> {
+	readonly authProvider: IntegrationAuthenticationProviderDescriptor = authProvider;
+	readonly id = GitCloudHostIntegrationId.Bitbucket;
+	protected readonly key = this.id;
+	readonly name: string = 'Bitbucket';
+	get domain(): string {
+		return metadata.domain;
+	}
+
+	protected get apiBaseUrl(): string {
+		return 'https://api.bitbucket.org/2.0';
+	}
+
+	protected override async mergeProviderPullRequest(
+		session: ProviderAuthenticationSession,
+		pr: PullRequest,
+		options?: {
+			mergeMethod?: PullRequestMergeMethod;
+		},
+	): Promise<boolean> {
+		const api = await this.getProvidersApi();
+		return api.mergePullRequest(toTokenWithInfo(this.id, session), pr, {
+			mergeMethod: options?.mergeMethod,
+		});
+	}
+
+	protected override async getProviderAccountForCommit(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		rev: string,
+		options?: {
+			avatarSize?: number;
+		},
+	): Promise<Account | UnidentifiedAuthor | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getAccountForCommit(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			rev,
+			this.apiBaseUrl,
+			{
+				avatarSize: options?.avatarSize,
+			},
+		);
+	}
+
+	protected override async getProviderAccountForEmail(
+		_session: AuthenticationSession,
+		_repo: BitbucketRepositoryDescriptor,
+		_email: string,
+		_options?: {
+			avatarSize?: number;
+		},
+	): Promise<Account | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	protected override async getProviderDefaultBranch(
+		_session: AuthenticationSession,
+		_repo: BitbucketRepositoryDescriptor,
+	): Promise<DefaultBranch | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	protected override async getProviderLinkedIssueOrPullRequest(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		{ id }: { id: string; key: string },
+		type: undefined | IssueOrPullRequestType,
+	): Promise<IssueOrPullRequest | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getIssueOrPullRequest(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			id,
+			this.apiBaseUrl,
+			{
+				type: type,
+			},
+		);
+	}
+
+	protected override async getProviderIssue(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		id: string,
+	): Promise<Issue | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getIssue(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			id,
+			this.apiBaseUrl,
+		);
+	}
+
+	protected override async getProviderPullRequestForBranch(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		branch: string,
+		_options?: {
+			avatarSize?: number;
+			include?: PullRequestState[];
+		},
+	): Promise<PullRequest | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getPullRequestForBranch(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			branch,
+			this.apiBaseUrl,
+		);
+	}
+
+	protected override async getProviderPullRequestForCommit(
+		session: ProviderAuthenticationSession,
+		repo: BitbucketRepositoryDescriptor,
+		rev: string,
+	): Promise<PullRequest | undefined> {
+		return (await this.authenticationService.apis.bitbucket)?.getPullRequestForCommit(
+			this,
+			toTokenWithInfo(this.id, session),
+			repo.owner,
+			repo.name,
+			rev,
+			this.apiBaseUrl,
+		);
+	}
+
+	protected override async getProviderRepositoryMetadata(
+		_session: AuthenticationSession,
+		_repo: BitbucketRepositoryDescriptor,
+		_cancellation?: AbortSignal,
+	): Promise<RepositoryMetadata | undefined> {
+		return Promise.resolve(undefined);
+	}
+
+	private _accounts: Map<string, Account | undefined> | undefined;
+	protected override async getProviderCurrentAccount(
+		session: ProviderAuthenticationSession,
+	): Promise<Account | undefined> {
+		const { accessToken } = session;
+		this._accounts ??= new Map<string, Account | undefined>();
+
+		const cachedAccount = this._accounts.get(accessToken);
+		if (cachedAccount == null) {
+			const api = await this.getProvidersApi();
+			const user = await api.getCurrentUser(toTokenWithInfo(this.id, session));
+			this._accounts.set(
+				accessToken,
+				user
+					? {
+							provider: this,
+							id: user.id,
+							name: user.name ?? undefined,
+							email: user.email ?? undefined,
+							avatarUrl: user.avatarUrl ?? undefined,
+							username: user.username ?? undefined,
+						}
+					: undefined,
+			);
+		}
+
+		return this._accounts.get(accessToken);
+	}
+
+	private _workspaces: Map<string, BitbucketWorkspaceDescriptor[] | undefined> | undefined;
+	private async getProviderResourcesForCurrentUser(
+		session: ProviderAuthenticationSession,
+		force: boolean = false,
+	): Promise<BitbucketWorkspaceDescriptor[] | undefined> {
+		this._workspaces ??= new Map<string, BitbucketWorkspaceDescriptor[] | undefined>();
+		const { accessToken } = session;
+		const cachedResources = this._workspaces.get(accessToken);
+
+		if (cachedResources == null || force) {
+			const api = await this.getProvidersApi();
+
+			const resources = await api.getBitbucketResourcesForCurrentUser(toTokenWithInfo(this.id, session));
+			this._workspaces.set(
+				accessToken,
+				resources != null ? resources.map(r => ({ ...r, key: r.id, name: r.name ?? r.slug })) : undefined,
+			);
+		}
+
+		return this._workspaces.get(accessToken);
+	}
+
+	protected override async searchProviderMyPullRequests(
+		session: ProviderAuthenticationSession,
+		repos?: BitbucketRepositoryDescriptor[],
+	): Promise<PullRequest[] | undefined> {
+		if (repos != null) {
+			// TODO: implement repos version
+			return undefined;
+		}
+
+		const api = await this.getProvidersApi();
+		if (!api) {
+			return undefined;
+		}
+
+		const remotes = await this.ctx.repositories.getOpenRemotes();
+		const workspaceRepos = await nonnullSettled(
+			remotes.map(async (r: GitRemote) => {
+				const integration = await this.authenticationService.getByRemote(r);
+				const [namespace, name] = r.path.split('/');
+				return integration?.id === this.id ? { name: name, namespace: namespace } : undefined;
+			}),
+		);
+
+		const user = await this.getProviderCurrentAccount(session);
+		if (user?.username == null) return undefined;
+
+		const workspaces = await this.getProviderResourcesForCurrentUser(session);
+		if (workspaces == null || workspaces.length === 0) return undefined;
+
+		const authoredPrs = workspaces.map(async ws => {
+			const prs = await api.getBitbucketPullRequestsAuthoredByUserForWorkspace(
+				toTokenWithInfo(this.id, session),
+				user.id,
+				ws.slug,
+			);
+			return prs?.map(pr => fromProviderPullRequest(pr, this));
+		});
+
+		const reviewingPrs = api
+			.getPullRequestsForRepos(toTokenWithInfo(this.id, session), workspaceRepos, {
+				query: `state="OPEN" AND reviewers.uuid="${user.id}"`,
+			})
+			.then(r => r.values?.map(pr => fromProviderPullRequest(pr, this)));
+
+		return [
+			...uniqueBy(
+				await flatSettled([...authoredPrs, reviewingPrs]),
+				pr => pr.url,
+				(orig, _cur) => orig,
+			),
+		];
+	}
+
+	protected override async searchProviderMyIssues(
+		session: ProviderAuthenticationSession,
+		repos?: BitbucketRepositoryDescriptor[],
+	): Promise<IssueShape[] | undefined> {
+		if (repos == null || repos.length === 0) return undefined;
+
+		const user = await this.getProviderCurrentAccount(session);
+		if (user?.username == null) return undefined;
+
+		const api = await this.authenticationService.apis.bitbucket;
+		if (!api) return undefined;
+
+		const issueResult = await flatSettled(
+			repos.map(repo => {
+				return api.getUsersIssuesForRepo(
+					this,
+					toTokenWithInfo(this.id, session),
+					user.id,
+					repo.owner,
+					repo.name,
+					this.apiBaseUrl,
+				);
+			}),
+		);
+		return issueResult;
+	}
+
+	private readonly storagePrefix = 'bitbucket';
+	protected override async providerOnConnect(): Promise<void> {
+		if (this._session == null) return;
+
+		const accountStorageKey = md5(this._session.accessToken);
+
+		const storedAccount = this.ctx.storage.get(`${this.storagePrefix}:${accountStorageKey}:account`);
+		const storedWorkspaces = this.ctx.storage.get(`${this.storagePrefix}:${accountStorageKey}:workspaces`);
+
+		let account: Account | undefined = storedAccount?.data ? { ...storedAccount.data, provider: this } : undefined;
+
+		let workspaces = storedWorkspaces?.data?.map((o: BitbucketWorkspaceDescriptor) => ({ ...o }));
+
+		if (storedAccount == null) {
+			account = await this.getProviderCurrentAccount(this._session);
+			if (account != null) {
+				// Clear all other stored workspaces and repositories and accounts when our session changes
+				await this.ctx.storage.deleteWithPrefix(this.storagePrefix);
+				await this.ctx.storage.store(`${this.storagePrefix}:${accountStorageKey}:account`, {
+					v: 1,
+					timestamp: Date.now(),
+					data: {
+						id: account.id,
+						name: account.name,
+						email: account.email,
+						avatarUrl: account.avatarUrl,
+						username: account.username,
+					},
+				});
+			}
+		}
+		this._accounts ??= new Map<string, Account | undefined>();
+		this._accounts.set(this._session.accessToken, account);
+
+		if (storedWorkspaces == null) {
+			workspaces = await this.getProviderResourcesForCurrentUser(this._session, true);
+			await this.ctx.storage.store(`${this.storagePrefix}:${accountStorageKey}:workspaces`, {
+				v: 1,
+				timestamp: Date.now(),
+				data: workspaces,
+			});
+		}
+		this._workspaces ??= new Map<string, BitbucketWorkspaceDescriptor[] | undefined>();
+		this._workspaces.set(this._session.accessToken, workspaces);
+	}
+
+	protected override providerOnDisconnect(): void {
+		this._accounts = undefined;
+		this._workspaces = undefined;
+	}
+}

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

@@ -0,0 +1,64 @@
+import { AuthenticationErrorReason } from '../../../../git/errors.js';
+import type { Provider } from '../../../../git/models/remoteProvider.js';
+import type { GitHubApiConfig } from '../../../git-github/api/config.js';
+import { GitHubApi } from '../../../git-github/api/github.js';
+import type { IntegrationServiceContext } from '../../context.js';
+
+export { GitHubApi } from '../../../git-github/api/github.js';
+
+export function createGitHubApi(ctx: IntegrationServiceContext): GitHubApi {
+	const launchpad = () => ctx.config.getLaunchpadOptions();
+
+	const config: GitHubApiConfig = {
+		isWeb: ctx.http.isWeb,
+		fetch: ctx.http.fetch.bind(ctx.http),
+		wrapForForcedInsecureSSL: ctx.http.wrapForForcedInsecureSSL.bind(ctx.http),
+
+		onConfigChanged: (listener: () => void) =>
+			ctx.config.onDidChange(e => {
+				if (e.httpProxy) {
+					listener();
+				}
+			}),
+
+		onAuthenticationFailure: async (error, provider: Provider | undefined) => {
+			if (
+				error.reason === AuthenticationErrorReason.Unauthorized ||
+				error.reason === AuthenticationErrorReason.Forbidden
+			) {
+				const reauthenticate = await ctx.hooks?.onReauthenticationRequired?.(
+					`${error.message}. Would you like to try reauthenticating${
+						error.reason === AuthenticationErrorReason.Forbidden ? ' to provide additional access' : ''
+					}?`,
+				);
+
+				if (reauthenticate) {
+					await provider?.reauthenticate();
+					return true;
+				}
+			} else {
+				ctx.hooks?.ui?.onError?.(error.message);
+			}
+			return false;
+		},
+
+		onRequestError: (provider: Provider | undefined, message: string) => {
+			if (message.includes('timeout')) {
+				ctx.hooks?.ui?.onRequestTimedOut?.(provider?.name ?? 'GitHub');
+			} else {
+				ctx.hooks?.ui?.onRequestFailed?.(message);
+			}
+		},
+
+		onDebugError: (message: string) => {
+			ctx.hooks?.ui?.onError?.(message);
+		},
+
+		getLaunchpadQueryLimit: () => launchpad().queryLimit ?? 100,
+		getLaunchpadIgnoredRepositories: () => [...(launchpad().ignoredRepositories ?? [])],
+		getLaunchpadIncludedOrganizations: () => [...(launchpad().includedOrganizations ?? [])],
+		getLaunchpadIgnoredOrganizations: () => [...(launchpad().ignoredOrganizations ?? [])],
+	};
+
+	return new GitHubApi(config);
+}