@gitkraken/core-gitlens 0.3.1 → 0.4.0

package/src/plus/integrations/integrationService.ts

@@ -0,0 +1,924 @@
+import type { Account } from '../../git/models/author.js';
+import type { IssueShape } from '../../git/models/issue.js';
+import type { PullRequest } from '../../git/models/pullRequest.js';
+import type { GitRemote } from '../../git/models/remote.js';
+import type { RemoteProviderId } from '../../git/models/remoteProvider.js';
+import type { ResourceDescriptor } from '../../git/models/resourceDescriptor.js';
+import { gate } from '../../utils/decorators/gate.js';
+import { debug, trace } from '../../utils/decorators/log.js';
+import type { Disposable } from '../../utils/disposable.js';
+import { fromDisposables } from '../../utils/disposable.js';
+import type { Event } from '../../utils/event.js';
+import { Emitter } from '../../utils/event.js';
+import { filterMap, flatten } from '../../utils/iterable.js';
+import { getScopedLogger } from '../../utils/logger.scoped.js';
+import type {
+	ConfiguredIntegrationsChangeEvent,
+	ConfiguredIntegrationService,
+} from './authentication/configuredIntegrationService.js';
+import type { IntegrationAuthenticationService } from './authentication/integrationAuthenticationService.js';
+import type { ConfiguredIntegrationDescriptor } from './authentication/models.js';
+import {
+	getSupportedCloudIntegrationIds,
+	isSupportedCloudIntegrationId,
+	toIntegrationId,
+} from './authentication/models.js';
+import type {
+	CloudGitSelfManagedHostIntegrationIds,
+	IntegrationIds,
+	SupportedCloudIntegrationIds,
+} from './constants.js';
+import {
+	GitCloudHostIntegrationId,
+	GitSelfManagedHostIntegrationId,
+	IssuesCloudHostIntegrationId,
+} from './constants.js';
+import type { AuthenticationSessionsChangeEvent, IntegrationServiceContext } from './context.js';
+import type { GitHostIntegration } from './models/gitHostIntegration.js';
+import type {
+	Integration,
+	IntegrationBase,
+	IntegrationById,
+	IntegrationKey,
+	IntegrationResult,
+} from './models/integration.js';
+import type { IssuesIntegration } from './models/issuesIntegration.js';
+import type { ApiClients } from './providers/apiClients.js';
+import { createApiClients } from './providers/apiClients.js';
+import type { GitHubApi } from './providers/github/github.js';
+import type { ProvidersApi } from './providers/providersApi.js';
+import type { Source } from './telemetry.js';
+import {
+	convertRemoteProviderIdToIntegrationId,
+	getIntegrationIdForRemote,
+	isCloudGitSelfManagedHostIntegrationId,
+	isGitCloudHostIntegrationId,
+	isGitSelfManagedHostIntegrationId,
+} from './utils/integration.utils.js';
+
+export interface ConnectionStateChangeEvent {
+	key: string;
+	reason: 'connected' | 'disconnected';
+}
+
+/** @internal Event emitted when an integration connection state changes  */
+export interface IntegrationConnectionChangeEvent extends ConnectionStateChangeEvent {
+	integration: IntegrationBase;
+}
+
+export class IntegrationService implements Disposable {
+	get onDidChange(): Event<ConfiguredIntegrationsChangeEvent> {
+		return this.configuredIntegrationService.onDidChange;
+	}
+
+	private readonly _onDidChangeConnectionState = new Emitter<ConnectionStateChangeEvent>();
+	get onDidChangeConnectionState(): Event<ConnectionStateChangeEvent> {
+		return this._onDidChangeConnectionState.event;
+	}
+
+	private readonly _connectedCache = new Set<string>();
+	private readonly _disposable: Disposable;
+	private _integrations = new Map<IntegrationKey, Integration>();
+	private readonly _onDidChangeIntegrationConnection = new Emitter<IntegrationConnectionChangeEvent>();
+	private readonly _apiDisposables: Disposable[] = [];
+	private _apis: ApiClients | undefined;
+
+	/** The package-built, memoized per-provider API clients (was injected via the now-removed `ctx.apis`). */
+	get apis(): ApiClients {
+		return (this._apis ??= createApiClients(this.ctx, this._apiDisposables));
+	}
+
+	/** The shared `GitHubApi` instance — also consumed by the host's GitHub git provider (one instance). */
+	get github(): Promise<GitHubApi | undefined> {
+		return this.apis.github;
+	}
+
+	constructor(
+		private readonly authenticationService: IntegrationAuthenticationService,
+		private readonly configuredIntegrationService: ConfiguredIntegrationService,
+		private readonly ctx: IntegrationServiceContext,
+	) {
+		this._disposable = fromDisposables(
+			ctx.config.onDidChange(e => {
+				if (e.remotes) {
+					this._ignoreSSLErrors.clear();
+				}
+			}),
+			ctx.account.onDidChangeSessions(this.onAuthenticationSessionsChanged, this),
+			ctx.account.onDidCheckIn(this.onUserCheckedIn, this),
+			ctx.account.onDidChange(this.onSubscriptionChanged, this),
+			this._onDidChangeIntegrationConnection.event(this.onIntegrationConnectionChanged, this),
+		);
+	}
+
+	dispose(): void {
+		this._integrations.forEach(i => i.dispose());
+		this._integrations.clear();
+		this._disposable?.dispose();
+		// The facade (`createIntegrationManager`) hands us sole ownership of these, so disposing the manager
+		// must tear them down too — otherwise cached auth providers (+ their host session listeners) and the
+		// configured-integrations emitter outlive the manager.
+		this.authenticationService.dispose();
+		this.configuredIntegrationService.dispose();
+		this._onDidChangeConnectionState.dispose();
+		this._onDidChangeIntegrationConnection.dispose();
+		this._apiDisposables.forEach(d => d.dispose());
+	}
+
+	@debug()
+	async connectCloudIntegrations(
+		connect?: { integrationIds: SupportedCloudIntegrationIds[]; skipIfConnected?: boolean; skipPreSync?: boolean },
+		source?: Source,
+	): Promise<boolean> {
+		const scope = getScopedLogger();
+		const integrationIds = connect?.integrationIds;
+		this.ctx.hooks?.connection?.onStarted?.({ integrationIds: integrationIds }, source);
+
+		const connectedIntegrations = new Set<string>();
+		if (integrationIds?.length) {
+			if (connect?.skipIfConnected && !connect?.skipPreSync) {
+				await this.syncCloudIntegrations(true);
+			}
+
+			for (const integrationId of integrationIds) {
+				try {
+					const integration = await this.get(integrationId);
+					if (integration == null) continue;
+
+					if (integration.maybeConnected ?? (await integration.isConnected())) {
+						connectedIntegrations.add(integrationId);
+					}
+				} catch (ex) {
+					scope?.warn(
+						`Failed to get integration ${integrationId} by its ID. Consider it as not-connected and ignore. Error message: ${ex.message}`,
+						scope,
+					);
+				}
+			}
+
+			if (connect?.skipIfConnected && connectedIntegrations.size === integrationIds.length) {
+				return true;
+			}
+		}
+
+		// The host owns the GK-Dev connect round-trip end-to-end (URL/query, exchange-token-vs-redirect,
+		// open, await its OAuth callback, sign-in + redeem). The package only orchestrates state/sync/hooks.
+		if (!(await this.ctx.account.connect({ integrationIds: integrationIds, source: source }))) {
+			return false;
+		}
+
+		const connected = await this.syncCloudIntegrations(true);
+		this.ctx.hooks?.connection?.onCompleted?.(
+			{
+				integrationIds: integrationIds,
+				connectedIntegrationIds: connected != null ? [...connected.values()] : undefined,
+			},
+			source,
+		);
+
+		if (integrationIds != null) {
+			for (const integrationId of integrationIds) {
+				const integration = await this.get(integrationId);
+				if (integration == null) continue;
+
+				const connected = integration.maybeConnected ?? (await integration.isConnected());
+				if (connected && !connectedIntegrations.has(integrationId)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		return true;
+	}
+
+	get(id: GitCloudHostIntegrationId): Promise<GitHostIntegration>;
+	get(id: IssuesCloudHostIntegrationId): Promise<IssuesIntegration>;
+	get(
+		id: GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds,
+		domain?: string,
+	): Promise<GitHostIntegration | undefined>;
+	get(id: GitSelfManagedHostIntegrationId, domain: string): Promise<GitHostIntegration | undefined>;
+	get<T extends IntegrationIds>(id: T, domain?: string): Promise<IntegrationById<T> | undefined>;
+	async get<T extends IntegrationIds>(id: T, domain?: string): Promise<IntegrationById<T> | undefined> {
+		let integration = this.getCached(id, domain);
+		if (integration == null) {
+			switch (id) {
+				case GitCloudHostIntegrationId.GitHub:
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/github.js')
+					).GitHubIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case GitSelfManagedHostIntegrationId.CloudGitHubEnterprise:
+					if (domain == null) {
+						integration = this.findCachedById(id);
+						// return immediately in order to not to cache it after the "switch" block:
+						if (integration != null) return integration;
+
+						const configured = this.getConfigured(GitSelfManagedHostIntegrationId.CloudGitHubEnterprise);
+						if (configured.length) {
+							const { domain: configuredDomain } = configured[0];
+							if (configuredDomain == null) throw new Error(`Domain is required for '${id}' integration`);
+
+							integration = new (
+								await import(/* webpackChunkName: "integrations" */ './providers/github.js')
+							).GitHubEnterpriseIntegration(
+								this.ctx,
+								this.authenticationService,
+								this.getProvidersApi.bind(this),
+								this._onDidChangeIntegrationConnection,
+								configuredDomain,
+							) as GitHostIntegration as IntegrationById<T>;
+
+							// assign domain because it's part of caching key:
+							domain = configuredDomain;
+							break;
+						}
+
+						return undefined;
+					}
+
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/github.js')
+					).GitHubEnterpriseIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+						domain,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case GitCloudHostIntegrationId.GitLab:
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/gitlab.js')
+					).GitLabIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted:
+					if (domain == null) {
+						integration = this.findCachedById(id);
+						// return immediately in order to not to cache it after the "switch" block:
+						if (integration != null) return integration;
+
+						const configured = this.getConfigured(GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted);
+						if (configured.length) {
+							const { domain: configuredDomain } = configured[0];
+							if (configuredDomain == null) throw new Error(`Domain is required for '${id}' integration`);
+
+							integration = new (
+								await import(/* webpackChunkName: "integrations" */ './providers/gitlab.js')
+							).GitLabSelfHostedIntegration(
+								this.ctx,
+								this.authenticationService,
+								this.getProvidersApi.bind(this),
+								this._onDidChangeIntegrationConnection,
+								configuredDomain,
+							) as GitHostIntegration as IntegrationById<T>;
+
+							// assign domain because it's part of caching key:
+							domain = configuredDomain;
+							break;
+						}
+
+						return undefined;
+					}
+
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/gitlab.js')
+					).GitLabSelfHostedIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+						domain,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case GitCloudHostIntegrationId.Bitbucket:
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/bitbucket.js')
+					).BitbucketIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case GitSelfManagedHostIntegrationId.BitbucketServer:
+					if (domain == null) {
+						integration = this.findCachedById(id);
+						// return immediately in order to not to cache it after the "switch" block:
+						if (integration != null) return integration;
+
+						const configured = this.getConfigured(GitSelfManagedHostIntegrationId.BitbucketServer);
+						if (configured.length) {
+							const { domain: configuredDomain } = configured[0];
+							if (configuredDomain == null) throw new Error(`Domain is required for '${id}' integration`);
+
+							integration = new (
+								await import(/* webpackChunkName: "integrations" */ './providers/bitbucket-server.js')
+							).BitbucketServerIntegration(
+								this.ctx,
+								this.authenticationService,
+								this.getProvidersApi.bind(this),
+								this._onDidChangeIntegrationConnection,
+								configuredDomain,
+							) as GitHostIntegration as IntegrationById<T>;
+
+							// assign domain because it's part of caching key:
+							domain = configuredDomain;
+							break;
+						}
+
+						return undefined;
+					}
+
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/bitbucket-server.js')
+					).BitbucketServerIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+						domain,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case GitCloudHostIntegrationId.AzureDevOps:
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/azureDevOps.js')
+					).AzureDevOpsIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
+					if (domain == null) {
+						integration = this.findCachedById(id);
+						// return immediately in order to not to cache it after the "switch" block:
+						if (integration != null) return integration;
+
+						const configured = this.getConfigured(GitSelfManagedHostIntegrationId.AzureDevOpsServer);
+						if (configured.length) {
+							const { domain: configuredDomain } = configured[0];
+							if (configuredDomain == null) throw new Error(`Domain is required for '${id}' integration`);
+
+							integration = new (
+								await import(/* webpackChunkName: "integrations" */ './providers/azureDevOps.js')
+							).AzureDevOpsServerIntegration(
+								this.ctx,
+								this.authenticationService,
+								this.getProvidersApi.bind(this),
+								this._onDidChangeIntegrationConnection,
+								configuredDomain,
+							) as GitHostIntegration as IntegrationById<T>;
+
+							// assign domain because it's part of caching key:
+							domain = configuredDomain;
+							break;
+						}
+
+						return undefined;
+					}
+
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/azureDevOps.js')
+					).AzureDevOpsServerIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+						domain,
+					) as GitHostIntegration as IntegrationById<T>;
+					break;
+
+				case IssuesCloudHostIntegrationId.Jira:
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/jira.js')
+					).JiraIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+					) as IssuesIntegration as IntegrationById<T>;
+					break;
+
+				case IssuesCloudHostIntegrationId.Linear:
+					integration = new (
+						await import(/* webpackChunkName: "integrations" */ './providers/linear.js')
+					).LinearIntegration(
+						this.ctx,
+						this.authenticationService,
+						this.getProvidersApi.bind(this),
+						this._onDidChangeIntegrationConnection,
+					) as IssuesIntegration as IntegrationById<T>;
+					break;
+				default:
+					throw new Error(`Integration with '${id}' is not supported`);
+			}
+
+			this._integrations.set(this.getCacheKey(id, domain), integration);
+		}
+
+		return integration;
+	}
+
+	getConfigured(
+		id?: IntegrationIds,
+		options?: { cloud?: boolean; domain?: string },
+	): ConfiguredIntegrationDescriptor[] {
+		return this.configuredIntegrationService.getConfigured(id, options);
+	}
+
+	/**
+	 * Returns the connected integration for a `GitRemote`, if any.
+	 * Internal counterpart to the host's `getRemoteIntegration(remote)` helper.
+	 */
+	async getByRemote(remote: GitRemote): Promise<GitHostIntegration | undefined> {
+		if (remote?.provider == null) return undefined;
+
+		const integrationId = getIntegrationIdForRemote(remote.provider);
+		if (integrationId == null) return undefined;
+
+		const integration = await this.get(integrationId, remote.provider?.domain);
+		return integration?.type === 'git' ? integration : undefined;
+	}
+
+	@debug({
+		args: integrationIds => ({ integrationIds: integrationIds?.length ? integrationIds.join(',') : '<undefined>' }),
+	})
+	async getMyIssues(
+		integrationIds?: (GitCloudHostIntegrationId | IssuesCloudHostIntegrationId | GitSelfManagedHostIntegrationId)[],
+		options?: { openRepositoriesOnly?: boolean; cancellation?: AbortSignal },
+	): Promise<IssueShape[] | undefined> {
+		const integrations: Map<Integration, ResourceDescriptor[] | undefined> = new Map();
+		const hostingIntegrationIds = integrationIds?.filter(
+			id => id in GitCloudHostIntegrationId || id in GitSelfManagedHostIntegrationId,
+		) as GitCloudHostIntegrationId[];
+		const openRemotesByIntegrationId = new Map<IntegrationIds, ResourceDescriptor[]>();
+		let hasOpenAzureRepository = false;
+		for (const remote of await this.ctx.repositories.getOpenRemotes()) {
+			const remoteIntegration = await this.getByRemote(remote);
+			if (remoteIntegration == null) continue;
+
+			if (remoteIntegration.id === GitCloudHostIntegrationId.AzureDevOps) {
+				hasOpenAzureRepository = true;
+			}
+			for (const integrationId of hostingIntegrationIds?.length
+				? hostingIntegrationIds
+				: [...Object.values(GitCloudHostIntegrationId), ...Object.values(GitSelfManagedHostIntegrationId)]) {
+				if (
+					remoteIntegration.id === integrationId &&
+					remote.provider?.owner != null &&
+					remote.provider?.repoName != null
+				) {
+					const descriptor = {
+						key: `${remote.provider.owner}/${remote.provider.repoName}`,
+						owner: remote.provider.owner,
+						name: remote.provider.repoName,
+					};
+					if (openRemotesByIntegrationId.has(integrationId)) {
+						openRemotesByIntegrationId.get(integrationId)?.push(descriptor);
+					} else {
+						openRemotesByIntegrationId.set(integrationId, [descriptor]);
+					}
+				}
+			}
+		}
+		for (const integrationId of integrationIds?.length
+			? integrationIds
+			: [
+					...Object.values(GitCloudHostIntegrationId),
+					...Object.values(IssuesCloudHostIntegrationId),
+					...Object.values(GitSelfManagedHostIntegrationId),
+				]) {
+			const integration = await this.get(integrationId);
+			const isInvalidIntegration =
+				(options?.openRepositoriesOnly &&
+					integrationId !== GitCloudHostIntegrationId.AzureDevOps &&
+					(isGitCloudHostIntegrationId(integrationId) || isGitSelfManagedHostIntegrationId(integrationId)) &&
+					!openRemotesByIntegrationId.has(integrationId)) ||
+				(integrationId === GitCloudHostIntegrationId.AzureDevOps && !hasOpenAzureRepository);
+			if (integration == null || isInvalidIntegration) {
+				continue;
+			}
+
+			integrations.set(
+				integration,
+				options?.openRepositoriesOnly && !isInvalidIntegration
+					? openRemotesByIntegrationId.get(integrationId)
+					: undefined,
+			);
+		}
+		if (integrations.size === 0) return undefined;
+
+		return this.getMyIssuesCore(integrations, options?.cancellation);
+	}
+
+	private async getMyIssuesCore(
+		integrations: Map<Integration, ResourceDescriptor[] | undefined>,
+		cancellation?: AbortSignal,
+	): Promise<IssueShape[] | undefined> {
+		const promises: Promise<IssueShape[] | undefined>[] = [];
+		for (const [integration, repos] of integrations) {
+			if (integration == null) continue;
+
+			promises.push(integration.searchMyIssues(repos, cancellation));
+		}
+
+		const results = await Promise.allSettled(promises);
+		return [...flatten(filterMap(results, r => (r.status === 'fulfilled' ? r.value : undefined)))];
+	}
+
+	async getMyIssuesForRemotes(remote: GitRemote): Promise<IssueShape[] | undefined>;
+	async getMyIssuesForRemotes(remotes: GitRemote[]): Promise<IssueShape[] | undefined>;
+	@trace({
+		args: (remoteOrRemotes: GitRemote | GitRemote[]) => ({
+			remoteOrRemotes: Array.isArray(remoteOrRemotes) ? remoteOrRemotes.map(rp => rp.name) : remoteOrRemotes.name,
+		}),
+	})
+	async getMyIssuesForRemotes(remoteOrRemotes: GitRemote | GitRemote[]): Promise<IssueShape[] | undefined> {
+		if (!Array.isArray(remoteOrRemotes)) {
+			remoteOrRemotes = [remoteOrRemotes];
+		}
+
+		if (!remoteOrRemotes.length) return undefined;
+		if (remoteOrRemotes.length === 1) {
+			const [remote] = remoteOrRemotes;
+			if (remote?.provider == null) return undefined;
+
+			const integration = await this.getByRemote(remote);
+			return integration?.searchMyIssues(remote.provider.repoDesc);
+		}
+
+		const integrations = new Map<GitHostIntegration, ResourceDescriptor[]>();
+
+		for (const remote of remoteOrRemotes) {
+			if (remote?.provider == null) continue;
+
+			const integration = await this.getByRemote(remote);
+			if (integration == null) continue;
+
+			let repos = integrations.get(integration);
+			if (repos == null) {
+				repos = [];
+				integrations.set(integration, repos);
+			}
+			repos.push(remote.provider.repoDesc);
+		}
+
+		return this.getMyIssuesCore(integrations);
+	}
+
+	@debug({
+		args: integrationIds => ({ integrationIds: integrationIds?.length ? integrationIds.join(',') : '<undefined>' }),
+	})
+	async getMyCurrentAccounts(
+		integrationIds: (GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds)[],
+	): Promise<Map<GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds, Account>> {
+		const accounts = new Map<GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds, Account>();
+		await Promise.allSettled(
+			integrationIds.map(async integrationId => {
+				const integration = await this.get(integrationId);
+				if (integration == null) return;
+
+				const account = await integration.getCurrentAccount();
+				if (account) {
+					accounts.set(integrationId, account);
+				}
+			}),
+		);
+		return accounts;
+	}
+
+	@debug({
+		args: integrationIds => ({ integrationIds: integrationIds?.length ? integrationIds.join(',') : '<undefined>' }),
+	})
+	async getMyPullRequests(
+		integrationIds?: (GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds)[],
+		cancellation?: AbortSignal,
+		silent?: boolean,
+	): Promise<IntegrationResult<PullRequest[] | undefined>> {
+		const integrations: Map<GitHostIntegration, ResourceDescriptor[] | undefined> = new Map();
+		for (const integrationId of integrationIds?.length
+			? integrationIds
+			: Object.values(GitCloudHostIntegrationId)) {
+			let integration;
+			try {
+				integration = await this.get(integrationId);
+			} catch {}
+			if (integration == null) continue;
+
+			integrations.set(integration, undefined);
+		}
+		if (integrations.size === 0) return undefined;
+
+		return this.getMyPullRequestsCore(integrations, cancellation, silent);
+	}
+
+	private async getMyPullRequestsCore(
+		integrations: Map<GitHostIntegration, ResourceDescriptor[] | undefined>,
+		cancellation?: AbortSignal,
+		silent?: boolean,
+	): Promise<IntegrationResult<PullRequest[] | undefined>> {
+		const start = performance.now();
+
+		const promises: Promise<IntegrationResult<PullRequest[] | undefined>>[] = [];
+		for (const [integration, repos] of integrations) {
+			if (integration == null) continue;
+
+			promises.push(integration.searchMyPullRequests(repos, cancellation, silent));
+		}
+
+		const results = await Promise.allSettled(promises);
+		const successfulResults = [
+			...flatten(
+				filterMap(results, r =>
+					r.status === 'fulfilled' && r.value?.value != null ? r.value.value : undefined,
+				),
+			),
+		];
+		const errors = [
+			...filterMap(results, r =>
+				r.status === 'fulfilled' && r.value?.error != null ? r.value.error : undefined,
+			),
+		];
+
+		const error =
+			errors.length === 0
+				? undefined
+				: errors.length === 1
+					? errors[0]
+					: new AggregateError(errors, 'Failed to get some pull requests');
+
+		return {
+			value: successfulResults,
+			error: error,
+			duration: performance.now() - start,
+		};
+	}
+
+	async getMyPullRequestsForRemotes(remote: GitRemote): Promise<IntegrationResult<PullRequest[] | undefined>>;
+	async getMyPullRequestsForRemotes(remotes: GitRemote[]): Promise<IntegrationResult<PullRequest[] | undefined>>;
+	@trace({
+		args: (remoteOrRemotes: GitRemote | GitRemote[]) => ({
+			remoteOrRemotes: Array.isArray(remoteOrRemotes) ? remoteOrRemotes.map(rp => rp.name) : remoteOrRemotes.name,
+		}),
+	})
+	async getMyPullRequestsForRemotes(
+		remoteOrRemotes: GitRemote | GitRemote[],
+	): Promise<IntegrationResult<PullRequest[] | undefined>> {
+		if (!Array.isArray(remoteOrRemotes)) {
+			remoteOrRemotes = [remoteOrRemotes];
+		}
+
+		if (!remoteOrRemotes.length) return undefined;
+		if (remoteOrRemotes.length === 1) {
+			const [remote] = remoteOrRemotes;
+			if (remote?.provider == null) return undefined;
+
+			const integration = await this.getByRemote(remote);
+			return integration?.searchMyPullRequests(remote.provider.repoDesc);
+		}
+
+		const integrations = new Map<GitHostIntegration, ResourceDescriptor[]>();
+
+		for (const remote of remoteOrRemotes) {
+			if (remote?.provider == null) continue;
+
+			const integration = await this.getByRemote(remote);
+			if (integration == null) continue;
+
+			let repos = integrations.get(integration);
+			if (repos == null) {
+				repos = [];
+				integrations.set(integration, repos);
+			}
+			repos.push(remote.provider.repoDesc);
+		}
+
+		return this.getMyPullRequestsCore(integrations);
+	}
+
+	private _ignoreSSLErrors = new Map<string, boolean | 'force'>();
+	ignoreSSLErrors(integration: GitHostIntegration | { id: IntegrationIds; domain?: string }): boolean | 'force' {
+		if (this.ctx.http.isWeb) return false;
+
+		let ignoreSSLErrors = this._ignoreSSLErrors.get(integration.id);
+		if (ignoreSSLErrors === undefined) {
+			const cfg = this.ctx.config
+				.getRemoteConfigs()
+				.find(remote => remote.type.toLowerCase() === integration.id && remote.domain === integration.domain);
+			ignoreSSLErrors = cfg?.ignoreSSLErrors ?? false;
+			this._ignoreSSLErrors.set(integration.id, ignoreSSLErrors);
+		}
+
+		return ignoreSSLErrors;
+	}
+
+	@debug()
+	async manageCloudIntegrations(source: Source | undefined): Promise<void> {
+		this.ctx.hooks?.connection?.onManaged?.(source);
+
+		// The host owns the GK-Dev manage interaction (sign-in if needed, open settings, wait for the user
+		// to return); it resolves `true` once they're back, then we re-sync + report.
+		if (!(await this.ctx.account.openManagement(source))) return;
+
+		const connected = await this.syncCloudIntegrations(true);
+		this.ctx.hooks?.connection?.onCompleted?.(
+			{
+				integrationIds: undefined,
+				connectedIntegrationIds: connected != null ? [...connected.values()] : undefined,
+			},
+			source,
+		);
+	}
+
+	@debug()
+	async reset(): Promise<void> {
+		for (const integration of this._integrations.values()) {
+			await integration.reset();
+		}
+
+		await this.authenticationService.reset();
+		await this.ctx.storage.deleteWithPrefix('provider:authentication:skip');
+		queueMicrotask(() => void this.syncCloudIntegrations(true));
+	}
+
+	supports(remoteProviderId: RemoteProviderId): boolean {
+		return convertRemoteProviderIdToIntegrationId(remoteProviderId) != null;
+	}
+
+	private onAuthenticationSessionsChanged(e: AuthenticationSessionsChangeEvent) {
+		for (const integration of this._integrations.values()) {
+			if (e.provider.id === integration.authProvider.id) {
+				integration.refresh();
+			}
+		}
+	}
+
+	private onIntegrationConnectionChanged(e: {
+		integration: IntegrationBase;
+		key: string;
+		reason: 'connected' | 'disconnected';
+	}): void {
+		const { integration, key, reason } = e;
+
+		if (reason === 'connected') {
+			// Only fire events if the key is being connected for the first time
+			if (this._connectedCache.has(key)) return;
+
+			this._connectedCache.add(key);
+		} else {
+			// Probably shouldn't bother to fire the event if we don't already think we are connected, but better to be safe
+			// if (!_connectedCache.has(key)) return;
+
+			this._connectedCache.delete(key);
+		}
+
+		const connected = reason === 'connected';
+		if (integration.type === 'git') {
+			this.ctx.hooks?.connection?.onStateChanged?.({
+				id: integration.id,
+				key: key,
+				connected: connected,
+				kind: isSupportedCloudIntegrationId(integration.id) ? 'hosting' : 'remote',
+			});
+		} else {
+			this.ctx.hooks?.connection?.onStateChanged?.({
+				id: integration.id,
+				key: key,
+				connected: connected,
+				kind: 'issue',
+			});
+		}
+
+		setTimeout(() => this._onDidChangeConnectionState.fire({ key: key, reason: reason }), 250);
+	}
+
+	private async onSubscriptionChanged() {
+		// When the account goes away, disconnect all connected cloud integrations. Mirrors the host's
+		// historical `account == null` check (the host forwards `onDidChange` without a payload).
+		if ((await this.ctx.account.getAccount()) == null) {
+			void this.syncCloudIntegrations(false);
+		}
+	}
+
+	private onUserCheckedIn(e?: { force?: boolean }) {
+		void this.syncCloudIntegrations(Boolean(e?.force));
+	}
+
+	private _providersApi: Promise<ProvidersApi> | undefined;
+	private async getProvidersApi() {
+		if (this._providersApi == null) {
+			const authenticationService = this.authenticationService;
+			async function load() {
+				return new (
+					await import(/* webpackChunkName: "integrations" */ './providers/providersApi.js')
+				).ProvidersApi(authenticationService);
+			}
+
+			this._providersApi = load();
+		}
+
+		return this._providersApi;
+	}
+
+	private getCached<T extends IntegrationIds>(id: T, domain?: string): IntegrationById<T> | undefined {
+		return this._integrations.get(this.getCacheKey(id, domain)) as IntegrationById<T> | undefined;
+	}
+
+	private getCacheKey(
+		id: GitCloudHostIntegrationId | IssuesCloudHostIntegrationId | GitSelfManagedHostIntegrationId,
+		domain?: string,
+	): IntegrationKey {
+		return isGitSelfManagedHostIntegrationId(id) ? (`${id}:${domain}` as const) : id;
+	}
+
+	private async *getSupportedCloudIntegrations(domainsById: Map<IntegrationIds, string>): AsyncIterable<Integration> {
+		for (const id of getSupportedCloudIntegrationIds()) {
+			if (isCloudGitSelfManagedHostIntegrationId(id) && !domainsById.has(id)) {
+				// Try getting whatever we have now because we will need to disconnect
+				const integration = await this.get(id, undefined);
+				if (integration != null) {
+					yield integration;
+				}
+			} else {
+				const integration = await this.get(id, domainsById.get(id));
+				if (integration != null) {
+					yield integration;
+				}
+			}
+		}
+	}
+
+	private findCachedById<T extends IntegrationIds>(id: T): IntegrationById<T> | undefined {
+		const key = this.getCacheKey(id, '');
+		for (const [k, integration] of this._integrations) {
+			if (k.startsWith(key)) {
+				return integration as IntegrationById<T>;
+			}
+		}
+		return undefined;
+	}
+
+	@gate()
+	@trace()
+	private async syncCloudIntegrations(forceConnect: boolean) {
+		const scope = getScopedLogger();
+		const connectedIntegrations = new Set<IntegrationIds>();
+		const domainsById = new Map<IntegrationIds, string>();
+
+		const loggedIn = (await this.ctx.account.getAccount()) != null;
+		if (loggedIn) {
+			const connections = await this.authenticationService.cloudIntegrations.getConnections();
+			if (connections == null) return;
+
+			connections.map(p => {
+				const integrationId = toIntegrationId[p.provider];
+				// GKDev includes some integrations like "google" that we don't support
+				if (integrationId == null) return;
+
+				connectedIntegrations.add(toIntegrationId[p.provider]);
+				if (p.domain?.length > 0) {
+					try {
+						const host = new URL(p.domain).host;
+						domainsById.set(integrationId, host);
+					} catch {
+						scope?.warn(`Invalid domain for ${integrationId} integration: ${p.domain}. Ignoring.`);
+					}
+				}
+			});
+		}
+
+		for await (const integration of this.getSupportedCloudIntegrations(domainsById)) {
+			await integration.syncCloudConnection(
+				connectedIntegrations.has(integration.id) ? 'connected' : 'disconnected',
+				forceConnect,
+			);
+		}
+
+		this.ctx.hooks?.connection?.onConnectedChanged?.({
+			integrationIds: [...connectedIntegrations.values()],
+		});
+
+		return connectedIntegrations;
+	}
+}