@gitkraken/core-gitlens 0.3.1 → 0.4.0

package/dist/plus/integrations/integrationService.js

@@ -0,0 +1,627 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { gate } from '../../utils/decorators/gate.js';
+import { debug, trace } from '../../utils/decorators/log.js';
+import { fromDisposables } from '../../utils/disposable.js';
+import { Emitter } from '../../utils/event.js';
+import { filterMap, flatten } from '../../utils/iterable.js';
+import { getScopedLogger } from '../../utils/logger.scoped.js';
+import { getSupportedCloudIntegrationIds, isSupportedCloudIntegrationId, toIntegrationId, } from './authentication/models.js';
+import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IssuesCloudHostIntegrationId, } from './constants.js';
+import { createApiClients } from './providers/apiClients.js';
+import { convertRemoteProviderIdToIntegrationId, getIntegrationIdForRemote, isCloudGitSelfManagedHostIntegrationId, isGitCloudHostIntegrationId, isGitSelfManagedHostIntegrationId, } from './utils/integration.utils.js';
+export class IntegrationService {
+    authenticationService;
+    configuredIntegrationService;
+    ctx;
+    get onDidChange() {
+        return this.configuredIntegrationService.onDidChange;
+    }
+    _onDidChangeConnectionState = new Emitter();
+    get onDidChangeConnectionState() {
+        return this._onDidChangeConnectionState.event;
+    }
+    _connectedCache = new Set();
+    _disposable;
+    _integrations = new Map();
+    _onDidChangeIntegrationConnection = new Emitter();
+    _apiDisposables = [];
+    _apis;
+    /** The package-built, memoized per-provider API clients (was injected via the now-removed `ctx.apis`). */
+    get apis() {
+        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() {
+        return this.apis.github;
+    }
+    constructor(authenticationService, configuredIntegrationService, ctx) {
+        this.authenticationService = authenticationService;
+        this.configuredIntegrationService = configuredIntegrationService;
+        this.ctx = ctx;
+        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() {
+        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());
+    }
+    async connectCloudIntegrations(connect, source) {
+        const scope = getScopedLogger();
+        const integrationIds = connect?.integrationIds;
+        this.ctx.hooks?.connection?.onStarted?.({ integrationIds: integrationIds }, source);
+        const connectedIntegrations = new Set();
+        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;
+    }
+    async get(id, domain) {
+        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);
+                    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);
+                            // 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);
+                    break;
+                case GitCloudHostIntegrationId.GitLab:
+                    integration = new (await import(/* webpackChunkName: "integrations" */ './providers/gitlab.js')).GitLabIntegration(this.ctx, this.authenticationService, this.getProvidersApi.bind(this), this._onDidChangeIntegrationConnection);
+                    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);
+                            // 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);
+                    break;
+                case GitCloudHostIntegrationId.Bitbucket:
+                    integration = new (await import(/* webpackChunkName: "integrations" */ './providers/bitbucket.js')).BitbucketIntegration(this.ctx, this.authenticationService, this.getProvidersApi.bind(this), this._onDidChangeIntegrationConnection);
+                    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);
+                            // 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);
+                    break;
+                case GitCloudHostIntegrationId.AzureDevOps:
+                    integration = new (await import(/* webpackChunkName: "integrations" */ './providers/azureDevOps.js')).AzureDevOpsIntegration(this.ctx, this.authenticationService, this.getProvidersApi.bind(this), this._onDidChangeIntegrationConnection);
+                    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);
+                            // 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);
+                    break;
+                case IssuesCloudHostIntegrationId.Jira:
+                    integration = new (await import(/* webpackChunkName: "integrations" */ './providers/jira.js')).JiraIntegration(this.ctx, this.authenticationService, this.getProvidersApi.bind(this), this._onDidChangeIntegrationConnection);
+                    break;
+                case IssuesCloudHostIntegrationId.Linear:
+                    integration = new (await import(/* webpackChunkName: "integrations" */ './providers/linear.js')).LinearIntegration(this.ctx, this.authenticationService, this.getProvidersApi.bind(this), this._onDidChangeIntegrationConnection);
+                    break;
+                default:
+                    throw new Error(`Integration with '${id}' is not supported`);
+            }
+            this._integrations.set(this.getCacheKey(id, domain), integration);
+        }
+        return integration;
+    }
+    getConfigured(id, options) {
+        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) {
+        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;
+    }
+    async getMyIssues(integrationIds, options) {
+        const integrations = new Map();
+        const hostingIntegrationIds = integrationIds?.filter(id => id in GitCloudHostIntegrationId || id in GitSelfManagedHostIntegrationId);
+        const openRemotesByIntegrationId = new Map();
+        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);
+    }
+    async getMyIssuesCore(integrations, cancellation) {
+        const promises = [];
+        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(remoteOrRemotes) {
+        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();
+        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);
+    }
+    async getMyCurrentAccounts(integrationIds) {
+        const accounts = new Map();
+        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;
+    }
+    async getMyPullRequests(integrationIds, cancellation, silent) {
+        const integrations = 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);
+    }
+    async getMyPullRequestsCore(integrations, cancellation, silent) {
+        const start = performance.now();
+        const promises = [];
+        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(remoteOrRemotes) {
+        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();
+        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);
+    }
+    _ignoreSSLErrors = new Map();
+    ignoreSSLErrors(integration) {
+        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;
+    }
+    async manageCloudIntegrations(source) {
+        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);
+    }
+    async reset() {
+        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) {
+        return convertRemoteProviderIdToIntegrationId(remoteProviderId) != null;
+    }
+    onAuthenticationSessionsChanged(e) {
+        for (const integration of this._integrations.values()) {
+            if (e.provider.id === integration.authProvider.id) {
+                integration.refresh();
+            }
+        }
+    }
+    onIntegrationConnectionChanged(e) {
+        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);
+    }
+    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);
+        }
+    }
+    onUserCheckedIn(e) {
+        void this.syncCloudIntegrations(Boolean(e?.force));
+    }
+    _providersApi;
+    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;
+    }
+    getCached(id, domain) {
+        return this._integrations.get(this.getCacheKey(id, domain));
+    }
+    getCacheKey(id, domain) {
+        return isGitSelfManagedHostIntegrationId(id) ? `${id}:${domain}` : id;
+    }
+    async *getSupportedCloudIntegrations(domainsById) {
+        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;
+                }
+            }
+        }
+    }
+    findCachedById(id) {
+        const key = this.getCacheKey(id, '');
+        for (const [k, integration] of this._integrations) {
+            if (k.startsWith(key)) {
+                return integration;
+            }
+        }
+        return undefined;
+    }
+    async syncCloudIntegrations(forceConnect) {
+        const scope = getScopedLogger();
+        const connectedIntegrations = new Set();
+        const domainsById = new Map();
+        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;
+    }
+}
+__decorate([
+    debug()
+], IntegrationService.prototype, "connectCloudIntegrations", null);
+__decorate([
+    debug({
+        args: integrationIds => ({ integrationIds: integrationIds?.length ? integrationIds.join(',') : '<undefined>' }),
+    })
+], IntegrationService.prototype, "getMyIssues", null);
+__decorate([
+    trace({
+        args: (remoteOrRemotes) => ({
+            remoteOrRemotes: Array.isArray(remoteOrRemotes) ? remoteOrRemotes.map(rp => rp.name) : remoteOrRemotes.name,
+        }),
+    })
+], IntegrationService.prototype, "getMyIssuesForRemotes", null);
+__decorate([
+    debug({
+        args: integrationIds => ({ integrationIds: integrationIds?.length ? integrationIds.join(',') : '<undefined>' }),
+    })
+], IntegrationService.prototype, "getMyCurrentAccounts", null);
+__decorate([
+    debug({
+        args: integrationIds => ({ integrationIds: integrationIds?.length ? integrationIds.join(',') : '<undefined>' }),
+    })
+], IntegrationService.prototype, "getMyPullRequests", null);
+__decorate([
+    trace({
+        args: (remoteOrRemotes) => ({
+            remoteOrRemotes: Array.isArray(remoteOrRemotes) ? remoteOrRemotes.map(rp => rp.name) : remoteOrRemotes.name,
+        }),
+    })
+], IntegrationService.prototype, "getMyPullRequestsForRemotes", null);
+__decorate([
+    debug()
+], IntegrationService.prototype, "manageCloudIntegrations", null);
+__decorate([
+    debug()
+], IntegrationService.prototype, "reset", null);
+__decorate([
+    gate(),
+    trace()
+], IntegrationService.prototype, "syncCloudIntegrations", null);
+//# sourceMappingURL=integrationService.js.map