@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/plus/integrations/models/integration.js

@@ -1,724 +1,579 @@
-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 { isCancellationError } from "../../../utils/cancellation.js";
+import { Logger as _logger } from "../../../utils/logger.js";
+import { getScopedLogger } from "../../../utils/logger.scoped.js";
+import { debug, trace } from "../../../utils/decorators/log.js";
+import __decorate from "../../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { AuthenticationError, RequestClientError } from "../../../git/errors.js";
+import { Emitter } from "../../../utils/event.js";
+import { fnv1aHash64 } from "../../../utils/hash.js";
+import { gate } from "../../../utils/decorators/gate.js";
+import { toError } from "../errors.js";
+import "../constants.js";
+import { isSelfManagedHostIntegrationId } from "../utils/integration.utils.js";
+import { providersMetadata } from "../providers/models.js";
+import { areDomainsOnSameHost } from "../utils/domain.utils.js";
+import { RejectedTokenTracker } from "../authentication/rejectedTokenTracker.js";
+import { getCachedIssue } from "./issueCache.js";
+//#region ../plus/integrations/src/models/integration.ts
+var IntegrationBase = class IntegrationBase {
+	ctx;
+	authenticationService;
+	getProvidersApi;
+	didChangeConnection;
+	_onDidChange = new Emitter();
+	get onDidChange() {
+		return this._onDidChange.event;
+	}
+	constructor(ctx, authenticationService, getProvidersApi, didChangeConnection) {
+		this.ctx = ctx;
+		this.authenticationService = authenticationService;
+		this.getProvidersApi = getProvidersApi;
+		this.didChangeConnection = didChangeConnection;
+	}
+	dispose() {
+		this._onDidChange.dispose();
+	}
+	get authProviderDescriptor() {
+		return {
+			domain: this.domain,
+			scopes: this.authProvider.scopes
+		};
+	}
+	/**
+	* The `gl-provider-<key>` glicon key for this provider, which is NOT always its id.
+	*
+	* `providersMetadata.iconKey` is the field that says which glyph a provider draws with, and a
+	* self-managed variant reuses its cloud family's — Jira Data Center draws with Jira's, because it is the
+	* same product and the id only selects an icon. Returning the id instead named a glyph the registry has
+	* no entry for, so a consumer rendering a `gl-provider-` glicon from `issue.provider.icon` requested a
+	* glyph that does not exist.
+	*/
+	get icon() {
+		return providersMetadata[this.id]?.iconKey ?? this.id;
+	}
+	access() {
+		return this.ctx.account.isTrialOrPaid();
+	}
+	autolinks() {
+		return [];
+	}
+	get connectedKey() {
+		return `connected:${this.key}`;
+	}
+	get maybeConnected() {
+		return this._session === void 0 ? void 0 : this._session !== null;
+	}
+	/** Hash of the current session's access token. Changes on any token change (account switch or refresh). */
+	_sessionFingerprint;
+	get sessionFingerprint() {
+		if (this._session == null) return void 0;
+		if (this._sessionFingerprint?.session !== this._session) this._sessionFingerprint = {
+			session: this._session,
+			hash: this.getSessionFingerprint(this._session)
+		};
+		return this._sessionFingerprint.hash;
+	}
+	getSessionFingerprint(session) {
+		return fnv1aHash64(session.accessToken);
+	}
+	get connectionExpired() {
+		if (this._session?.expiresAt == null) return void 0;
+		return new Date(this._session.expiresAt) < /* @__PURE__ */ new Date();
+	}
+	_session;
+	getSession(source) {
+		if (this._session === void 0) return this.ensureSession({
+			createIfNeeded: false,
+			source
+		});
+		return this._session != null && this.isSessionForIntegrationHost(this._session) ? this._session : void 0;
+	}
+	isSessionForIntegrationHost(session) {
+		if (!isSelfManagedHostIntegrationId(this.id)) return true;
+		return areDomainsOnSameHost(this.domain, session.domain);
+	}
+	/**
+	* Resolves the session to read as, for a per-connection (multi-account) read. When `connectionId` is
+	* omitted this is the integration's primary session, resolved exactly like the existing read flow
+	* (ensure-connected + refresh-if-expired). When set, it resolves THAT connection's session directly
+	* from the auth provider — refreshing it if expired — WITHOUT disturbing the cached primary
+	* `_session`. Returns undefined when the requested session can't be resolved (e.g. the connection is
+	* gone or the provider isn't connected), so callers degrade to "no results".
+	*/
+	async resolveReadSession(connectionId, scope, source) {
+		if (this.ctx.config.isIntegrationsEnabled?.() === false || this.ctx.storage.getWorkspace(this.connectedKey) === false) return;
+		if (connectionId) {
+			const refreshRejectedToken = this._rejectedTokens.claimRefresh(connectionId);
+			try {
+				const session = await (await this.authenticationService.get(this.authProvider.id)).getSession({
+					...this.authProviderDescriptor,
+					connectionId,
+					cloud: true
+				}, {
+					source,
+					refreshRejectedToken
+				});
+				return session != null && this.isSessionForIntegrationHost(session) ? session : void 0;
+			} catch (ex) {
+				scope?.error(ex);
+				return;
+			}
+		}
+		if (!(this.maybeConnected ?? await this.isConnected())) return void 0;
+		await this.refreshSessionIfExpired(scope);
+		return this._session != null && this.isSessionForIntegrationHost(this._session) ? this._session : void 0;
+	}
+	async connect(source) {
+		try {
+			return Boolean(await this.ensureSession({
+				createIfNeeded: true,
+				source
+			}));
+		} catch (_ex) {
+			return false;
+		}
+	}
+	async disconnect(options) {
+		if (options?.currentSessionOnly && this._session === null) return;
+		const connected = this._session != null;
+		let signOut = !options?.currentSessionOnly;
+		if (connected && !options?.currentSessionOnly && !options?.silent) {
+			const decision = await this.ctx.hooks?.onConfirmDisconnect?.({
+				integrationName: this.name,
+				offerSignOut: this.authenticationService.supports(this.authProvider.id)
+			});
+			if (decision == null) return;
+			signOut = decision.signOut;
+		}
+		if (signOut) await (await this.authenticationService.get(this.authProvider.id)).deleteAllSessions(this.authProviderDescriptor);
+		this.resetRequestExceptionCount("all");
+		this._session = null;
+		if (connected) {
+			if (!options?.currentSessionOnly && !options?.silent) this.ctx.storage.storeWorkspace(this.connectedKey, false).catch();
+			this._onDidChange.fire();
+			if (!options?.currentSessionOnly) this.didChangeConnection?.fire({
+				integration: this,
+				key: this.key,
+				reason: "disconnected"
+			});
+		}
+		await this.providerOnDisconnect?.();
+	}
+	async reauthenticate() {
+		this.onStoredTokensReplaced();
+		if (this._session === void 0) return;
+		this._session = void 0;
+		await this.ensureSession({
+			createIfNeeded: true,
+			forceNewSession: true
+		});
+	}
+	refresh() {
+		this.ensureSession({ createIfNeeded: false });
+	}
+	_syncRequestsPerFailedUsecase = /* @__PURE__ */ new Set();
+	hasSessionSyncRequests() {
+		return this._syncRequestsPerFailedUsecase.size > 0;
+	}
+	requestSessionSyncForUsecase(syncReqUsecase) {
+		this._syncRequestsPerFailedUsecase.add(syncReqUsecase);
+	}
+	/**
+	* The per-connection counterpart of the primary session's expire-and-resync recovery: a token the
+	* provider refused is refreshed once through the GK cloud, which exchanges the refresh token server-side
+	* (the client never holds one). Armed by {@link handleProviderException} and consumed by
+	* {@link resolveReadSession}; a rejection it declines belongs to {@link trackRequestException} instead.
+	*/
+	_rejectedTokens = new RejectedTokenTracker();
+	/**
+	* Called by every path that replaces or removes the stored tokens — a disconnect, a forced re-sync, a
+	* reauthentication, or the connection set changing. A rejection names a specific credential, so once that
+	* credential is gone the rejection describes nothing and must not force a refresh (or, for a deleted
+	* connection, outlive it).
+	*
+	* Deliberately NOT conditioned on `_session`. A per-connection read resolves through the auth provider and
+	* never populates the cached primary session, so the connections this recovery exists for are exactly the
+	* ones with no `_session` to inspect — the same blind spot the recovery itself was added to fix. Callers
+	* that guard on `_session` therefore invoke this ahead of that guard.
+	*/
+	onStoredTokensReplaced() {
+		this._rejectedTokens.clear();
+	}
+	static requestExceptionLimit = 5;
+	requestExceptionCount = 0;
+	resetRequestExceptionCount(syncReqUsecase) {
+		this.requestExceptionCount = 0;
+		if (syncReqUsecase === "all") {
+			this._syncRequestsPerFailedUsecase.clear();
+			this.onStoredTokensReplaced();
+		} else this._syncRequestsPerFailedUsecase.delete(syncReqUsecase);
+	}
+	/**
+	* Resets request exceptions without resetting the amount of syncs
+	*/
+	smoothifyRequestExceptionCount() {
+		this.requestExceptionCount = 0;
+	}
+	async reset() {
+		await this.disconnect({ silent: true });
+		await this.ctx.storage.deleteWorkspace(this.connectedKey);
+	}
+	/**
+	* Drops the in-memory session so the next access re-resolves it from storage. Used when the primary
+	* connection changed underneath a warm integration (e.g. after `setPrimaryConnection`/
+	* `deleteConnection`). Unlike {@link reset}/{@link disconnect}, it deletes nothing from storage.
+	*/
+	switchConnection() {
+		this.onStoredTokensReplaced();
+		if (this._session === void 0) return;
+		const wasConnected = this._session != null;
+		this._session = void 0;
+		this._onDidChange.fire();
+		this.refreshAfterSwitch(wasConnected);
+	}
+	async refreshAfterSwitch(wasConnected) {
+		if (await this.ensureSession({ createIfNeeded: false }) != null || !wasConnected) return;
+		this._onDidChange.fire();
+		this.didChangeConnection?.fire({
+			integration: this,
+			key: this.key,
+			reason: "disconnected"
+		});
+		await this.providerOnDisconnect?.();
+	}
+	skippedNonCloudReported = false;
+	async syncCloudConnection(state, forceSync) {
+		const scope = getScopedLogger();
+		if (this._session?.cloud === false && state !== "connected") {
+			if (this.id !== "github" && !this.skippedNonCloudReported) {
+				this.ctx.hooks?.session?.onRefreshSkipped?.({
+					id: this.id,
+					reason: "skip-non-cloud",
+					cloud: false
+				});
+				this.skippedNonCloudReported = true;
+			}
+			return;
+		}
+		switch (state) {
+			case "connected": {
+				const oldSession = this._session;
+				let resyncing = false;
+				if (forceSync) {
+					await (await this.authenticationService.get(this.authProvider.id)).deleteSession(this.authProviderDescriptor);
+					this.onStoredTokensReplaced();
+					this._session = void 0;
+					await this.ctx.storage.deleteWorkspace(this.connectedKey);
+					resyncing = true;
+				} else {
+					if (this._session != null || this.requestExceptionCount > 0 || this.ctx.storage.getWorkspace(this.connectedKey) === false) return;
+					forceSync = true;
+				}
+				let newSession;
+				let refetchFailed = false;
+				try {
+					newSession = await this.ensureSession({ sync: forceSync });
+				} catch (ex) {
+					if (!isCancellationError(ex)) scope?.error(ex);
+					refetchFailed = true;
+				}
+				if (oldSession && newSession && newSession.accessToken !== oldSession.accessToken) this.resetRequestExceptionCount("all");
+				if (resyncing && newSession == null && !refetchFailed) await (await this.authenticationService.get(this.authProvider.id)).deleteSession(this.authProviderDescriptor, { preserveConfigured: false });
+				break;
+			}
+			case "disconnected": await this.disconnect({ silent: true });
+		}
+	}
+	handleProviderException(syncReqUsecase, ex, options) {
+		if (isCancellationError(ex)) return;
+		if (options?.scope != null) options.scope.error(ex);
+		else _logger.error(ex);
+		if (ex instanceof AuthenticationError && options?.connectionId) {
+			if (!this._rejectedTokens.recordRejection(options.connectionId)) this.trackRequestException(options);
+			return;
+		}
+		if (ex instanceof AuthenticationError && this._session?.cloud) {
+			if (!this.hasSessionSyncRequests()) {
+				this.requestSessionSyncForUsecase(syncReqUsecase);
+				this._session = {
+					...this._session,
+					expiresAt: /* @__PURE__ */ new Date(Date.now() - 1)
+				};
+			} else this.trackRequestException(options);
+		} else if (ex instanceof AuthenticationError || ex instanceof RequestClientError) this.trackRequestException(options);
+	}
+	missingExpirityReported = false;
+	async refreshSessionIfExpired(scope) {
+		if (this._session?.expiresAt != null && this._session.expiresAt < /* @__PURE__ */ new Date()) try {
+			await this.syncCloudConnection("connected", true);
+		} catch (ex) {
+			scope?.error(ex);
+		}
+		else if (this._session?.expiresAt == null && this.id !== "github" && !this.missingExpirityReported) {
+			this.ctx.hooks?.session?.onRefreshSkipped?.({
+				id: this.id,
+				reason: "missing-expiry",
+				cloud: this._session?.cloud
+			});
+			this.missingExpirityReported = true;
+		}
+	}
+	trackRequestException(options) {
+		this.requestExceptionCount++;
+		if (this.requestExceptionCount >= IntegrationBase.requestExceptionLimit && this._session !== null) {
+			if (!options?.silent) this.ctx.hooks?.ui?.onDisconnectedAfterTooManyFailures?.(this.name);
+			this.disconnect({ currentSessionOnly: true });
+		}
+	}
+	async isConnected() {
+		return await this.getSession("integrations") != null;
+	}
+	async ensureSession(options) {
+		const scope = getScopedLogger();
+		const { createIfNeeded, forceNewSession, source, sync } = options;
+		if (this._session != null) {
+			if (this.isSessionForIntegrationHost(this._session)) return this._session;
+			this._session = null;
+		}
+		if (this.ctx.config.isIntegrationsEnabled?.() === false) return void 0;
+		if (createIfNeeded || sync) await this.ctx.storage.deleteWorkspace(this.connectedKey);
+		else if (this.ctx.storage.getWorkspace(this.connectedKey) === false) return;
+		let session;
+		try {
+			session = await (await this.authenticationService.get(this.authProvider.id)).getSession(this.authProviderDescriptor, sync ? {
+				sync,
+				source
+			} : {
+				createIfNeeded,
+				forceNewSession,
+				source
+			});
+			if (session?.expiresAt != null && session.expiresAt < /* @__PURE__ */ new Date()) session = null;
+			if (session != null && !this.isSessionForIntegrationHost(session)) session = void 0;
+		} catch (ex) {
+			await this.ctx.storage.deleteWorkspace(this.connectedKey);
+			if (!sync && ex instanceof Error && ex.message.includes("User did not consent")) return;
+			if (sync) {
+				this.smoothifyRequestExceptionCount();
+				throw ex;
+			}
+			session = null;
+		}
+		if (session === void 0 && !createIfNeeded && !sync) await this.ctx.storage.deleteWorkspace(this.connectedKey);
+		this._session = session ?? null;
+		this.smoothifyRequestExceptionCount();
+		if (session != null) {
+			await this.ctx.storage.storeWorkspace(this.connectedKey, true);
+			queueMicrotask(() => {
+				this._onDidChange.fire();
+				this.didChangeConnection?.fire({
+					integration: this,
+					key: this.key,
+					reason: "connected"
+				});
+				(async () => {
+					try {
+						await this.providerOnConnect?.();
+					} catch (ex) {
+						scope?.warn(`Failed to run providerOnConnect for ${this.key}: ${ex instanceof Error ? ex.message : String(ex)}`);
+					}
+				})();
+			});
+		}
+		return session ?? void 0;
+	}
+	getIgnoreSSLErrors() {
+		return this.authenticationService.ignoreSSLErrors(this);
+	}
+	async searchMyIssues(resources, cancellation, connectionId) {
+		return (await this.searchMyIssuesResult(resources, cancellation, connectionId))?.value;
+	}
+	/**
+	* Result-returning core of {@link searchMyIssues}. Recovers thrown errors into `{ error }` so callers
+	* (e.g. the ProviderBackend account-wide issues read) can surface a per-provider warning instead of a
+	* silent empty result. Returns the normalized {@link IssueShape} (there is no raw account-wide issue read).
+	*/
+	async searchMyIssuesResult(resources, cancellation, connectionId) {
+		const scope = getScopedLogger();
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null) return void 0;
+		const start = performance.now();
+		try {
+			const issues = await this.searchProviderMyIssues(session, resources != null ? Array.isArray(resources) ? resources : [resources] : void 0, cancellation);
+			this.resetRequestExceptionCount("searchMyIssues");
+			return {
+				value: issues,
+				duration: performance.now() - start
+			};
+		} catch (ex) {
+			this.handleProviderException("searchMyIssues", ex, {
+				scope,
+				connectionId
+			});
+			return {
+				error: toError(ex),
+				duration: performance.now() - start
+			};
+		}
+	}
+	/**
+	* Paging/truncation-aware variant of {@link searchProviderMyIssues}. The default wraps the normalized read
+	* as a complete single page; providers with native cursors or fan-out metadata override it.
+	*/
+	async searchProviderMyIssuesWithTruncation(session, resources, cancellation, _options) {
+		const values = await this.searchProviderMyIssues(session, resources, cancellation);
+		if (values == null) return void 0;
+		return {
+			values,
+			truncated: false
+		};
+	}
+	/**
+	* Result-returning, truncation-aware account-wide issue read. Recovers thrown errors into `{ error }` and
+	* carries the `truncated` flag so the ProviderBackend facade can report an incomplete read honestly.
+	*/
+	async searchMyIssuesWithTruncationResult(resources, cancellation, connectionId, options) {
+		const scope = getScopedLogger();
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null) return void 0;
+		try {
+			const result = await this.searchProviderMyIssuesWithTruncation(session, resources != null ? Array.isArray(resources) ? resources : [resources] : void 0, cancellation, options);
+			this.resetRequestExceptionCount("searchMyIssues");
+			return { value: result };
+		} catch (ex) {
+			this.handleProviderException("searchMyIssues", ex, {
+				scope,
+				connectionId
+			});
+			return { error: toError(ex) };
+		}
+	}
+	async getLinkedIssueOrPullRequest(resource, link, options) {
+		const scope = getScopedLogger();
+		if (!(this.maybeConnected ?? await this.isConnected())) return void 0;
+		await this.refreshSessionIfExpired(scope);
+		return this.ctx.cache.getIssueOrPullRequest(link.key, options?.type, resource, this, () => ({ value: (async () => {
+			try {
+				const result = await this.getProviderLinkedIssueOrPullRequest(this._session, resource, link, options?.type);
+				this.resetRequestExceptionCount("getIssueOrPullRequest");
+				return result;
+			} catch (ex) {
+				this.handleProviderException("getIssueOrPullRequest", ex, { scope });
+				return;
+			}
+		})() }), options);
+	}
+	async getIssue(resource, id, options) {
+		return (await this.getIssueResult(resource, id, options))?.value;
+	}
+	getIssueResult(resource, id, options) {
+		return this.getIssueResultCore(resource, id, options, (session) => this.getProviderIssue(session, resource, id));
+	}
+	async getIssueResultCore(resource, id, options, getProviderIssue) {
+		const scope = getScopedLogger();
+		const { connectionId: requestedConnectionId, expiryOverride } = options ?? {};
+		const connectionId = requestedConnectionId || void 0;
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null) return void 0;
+		try {
+			return { value: await getCachedIssue({
+				cache: this.ctx.cache,
+				id,
+				resource,
+				integration: this,
+				load: async () => {
+					try {
+						const issue = await getProviderIssue(session);
+						this.resetRequestExceptionCount("getIssue");
+						return issue;
+					} catch (ex) {
+						if (!isCancellationError(ex)) this.handleProviderException("getIssue", toError(ex), {
+							scope,
+							connectionId
+						});
+						throw ex;
+					}
+				},
+				cacheOptions: {
+					connectionId,
+					expiryOverride,
+					etag: `${this.id}:${this.maybeConnected ?? false}:${this.getSessionFingerprint(session)}`
+				}
+			}) };
+		} catch (ex) {
+			return { error: toError(ex) };
+		}
+	}
+	async getCurrentAccount(options) {
+		const scope = getScopedLogger();
+		const { connectionId: requestedConnectionId, expiryOverride, ...opts } = options ?? {};
+		const connectionId = requestedConnectionId || void 0;
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null) return void 0;
+		const sessionFingerprint = this.getSessionFingerprint(session);
+		return await this.ctx.cache.getCurrentAccount(this, (cacheable) => ({ value: (async () => {
+			try {
+				const account = await this.getProviderCurrentAccount?.(session, opts);
+				this.resetRequestExceptionCount("getCurrentAccount");
+				return account;
+			} catch (ex) {
+				if (isCancellationError(ex)) {
+					cacheable.invalidate();
+					return;
+				}
+				this.handleProviderException("getCurrentAccount", ex, {
+					scope,
+					connectionId
+				});
+				if (!(ex instanceof AuthenticationError)) cacheable.invalidate();
+				throw ex;
+			}
+		})() }), {
+			connectionId,
+			expiryOverride,
+			expireOnError: false,
+			etag: `${this.id}:${this.maybeConnected ?? false}:${sessionFingerprint}`
+		});
+	}
+	/**
+	* Resolves the account for a specific session/token — including connections other than the current
+	* primary (multi-account) — using this integration's provider API base URL and auth type. Returns
+	* undefined when the provider doesn't support account lookup. Uncached (callers cache per connection).
+	*/
+	getProviderAccountForSession(session) {
+		return this.getProviderCurrentAccount?.(session) ?? Promise.resolve(void 0);
+	}
+	async getPullRequest(resource, id, options) {
+		const scope = getScopedLogger();
+		if (!(this.maybeConnected ?? await this.isConnected())) return void 0;
+		await this.refreshSessionIfExpired(scope);
+		return await this.ctx.cache.getPullRequest(id, resource, this, (cacheable) => ({ value: (async () => {
+			try {
+				const result = await this.getProviderPullRequest?.(this._session, resource, id);
+				this.resetRequestExceptionCount("getPullRequest");
+				return result;
+			} catch (ex) {
+				cacheable.invalidate();
+				this.handleProviderException("getPullRequest", ex, { scope });
+				if (options?.throwOnError) throw ex;
+				return;
+			}
+		})() }), { expiryOverride: options?.expiryOverride });
+	}
 };
-import { isCancellationError } from '../../../utils/cancellation.js';
-import { gate } from '../../../utils/decorators/gate.js';
-import { debug, trace } from '../../../utils/decorators/log.js';
-import { Emitter } from '../../../utils/event.js';
-import { fnv1aHash64 } from '../../../utils/hash.js';
-import { Logger } from '../../../utils/logger.js';
-import { getScopedLogger } from '../../../utils/logger.scoped.js';
-import { RejectedTokenTracker } from '../authentication/rejectedTokenTracker.js';
-import { GitCloudHostIntegrationId } from '../constants.js';
-import { AuthenticationError, RequestClientError, toError } from '../errors.js';
-import { areDomainsOnSameHost } from '../utils/domain.utils.js';
-import { isGitSelfManagedHostIntegrationId } from '../utils/integration.utils.js';
-import { getCachedIssue } from './issueCache.js';
-export class IntegrationBase {
-    ctx;
-    authenticationService;
-    getProvidersApi;
-    didChangeConnection;
-    _onDidChange = new Emitter();
-    get onDidChange() {
-        return this._onDidChange.event;
-    }
-    constructor(ctx, authenticationService, getProvidersApi, didChangeConnection) {
-        this.ctx = ctx;
-        this.authenticationService = authenticationService;
-        this.getProvidersApi = getProvidersApi;
-        this.didChangeConnection = didChangeConnection;
-    }
-    dispose() {
-        this._onDidChange.dispose();
-    }
-    get authProviderDescriptor() {
-        return { domain: this.domain, scopes: this.authProvider.scopes };
-    }
-    get icon() {
-        return this.id;
-    }
-    access() {
-        return this.ctx.account.isTrialOrPaid();
-    }
-    autolinks() {
-        return [];
-    }
-    get connectedKey() {
-        return `connected:${this.key}`;
-    }
-    get maybeConnected() {
-        return this._session === undefined ? undefined : this._session !== null;
-    }
-    /** Hash of the current session's access token. Changes on any token change (account switch or refresh). */
-    _sessionFingerprint;
-    get sessionFingerprint() {
-        if (this._session == null)
-            return undefined;
-        if (this._sessionFingerprint?.session !== this._session) {
-            this._sessionFingerprint = { session: this._session, hash: this.getSessionFingerprint(this._session) };
-        }
-        return this._sessionFingerprint.hash;
-    }
-    getSessionFingerprint(session) {
-        return fnv1aHash64(session.accessToken);
-    }
-    get connectionExpired() {
-        if (this._session?.expiresAt == null)
-            return undefined;
-        return new Date(this._session.expiresAt) < new Date();
-    }
-    _session;
-    getSession(source) {
-        if (this._session === undefined) {
-            return this.ensureSession({ createIfNeeded: false, source: source });
-        }
-        return this._session != null && this.isSessionForIntegrationHost(this._session) ? this._session : undefined;
-    }
-    isSessionForIntegrationHost(session) {
-        if (!isGitSelfManagedHostIntegrationId(this.id))
-            return true;
-        return areDomainsOnSameHost(this.domain, session.domain);
-    }
-    /**
-     * Resolves the session to read as, for a per-connection (multi-account) read. When `connectionId` is
-     * omitted this is the integration's primary session, resolved exactly like the existing read flow
-     * (ensure-connected + refresh-if-expired). When set, it resolves THAT connection's session directly
-     * from the auth provider — refreshing it if expired — WITHOUT disturbing the cached primary
-     * `_session`. Returns undefined when the requested session can't be resolved (e.g. the connection is
-     * gone or the provider isn't connected), so callers degrade to "no results".
-     */
-    async resolveReadSession(connectionId, scope, source) {
-        if (this.ctx.config.isIntegrationsEnabled?.() === false ||
-            this.ctx.storage.getWorkspace(this.connectedKey) === false) {
-            return undefined;
-        }
-        // A truthy connectionId targets a specific account; an empty string is not a real target, so it falls
-        // through to the primary path below.
-        if (connectionId) {
-            // A read of this connection previously failed with an AuthenticationError, so the token in
-            // storage is known-refused. Ask for a refresh through the GK cloud before reading again, which
-            // is this branch's equivalent of the primary path's `refreshSessionIfExpired`. Claimed here so
-            // the forced refresh runs at most once per rejection.
-            const refreshRejectedToken = this._rejectedTokens.claimRefresh(connectionId);
-            // Degrade to "no results" on failure, matching the primary path (whose ensureSession/
-            // refreshSessionIfExpired swallow errors) so read methods keep their never-throws contract.
-            try {
-                const authProvider = await this.authenticationService.get(this.authProvider.id);
-                const session = await authProvider.getSession({ ...this.authProviderDescriptor, connectionId: connectionId, cloud: true }, { source: source, refreshRejectedToken: refreshRejectedToken });
-                return session != null && this.isSessionForIntegrationHost(session) ? session : undefined;
-            }
-            catch (ex) {
-                scope?.error(ex);
-                return undefined;
-            }
-        }
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected)
-            return undefined;
-        await this.refreshSessionIfExpired(scope);
-        return this._session != null && this.isSessionForIntegrationHost(this._session) ? this._session : undefined;
-    }
-    async connect(source) {
-        try {
-            return Boolean(await this.ensureSession({ createIfNeeded: true, source: source }));
-        }
-        catch (_ex) {
-            return false;
-        }
-    }
-    async disconnect(options) {
-        if (options?.currentSessionOnly && this._session === null)
-            return;
-        const connected = this._session != null;
-        let signOut = !options?.currentSessionOnly;
-        if (connected && !options?.currentSessionOnly && !options?.silent) {
-            const decision = await this.ctx.hooks?.onConfirmDisconnect?.({
-                integrationName: this.name,
-                offerSignOut: this.authenticationService.supports(this.authProvider.id),
-            });
-            if (decision == null)
-                return;
-            signOut = decision.signOut;
-        }
-        if (signOut) {
-            // Disconnecting a provider signs out of ALL its connected accounts (multi-account), not just the
-            // primary — otherwise secondary connections' secrets/config would be orphaned. Removing a single
-            // account is done via IntegrationService.deleteConnection instead. Pass this instance's descriptor
-            // so self-managed disconnects stay scoped to this host: those group every host under one provider
-            // id, so an unscoped clear would sign the user out of unrelated hosts. deleteAllSessions derives an
-            // undefined domain for cloud providers, so they still clear every account as intended.
-            const authProvider = await this.authenticationService.get(this.authProvider.id);
-            // Awaited, not fire-and-forget: a caller that awaits `disconnect()` has to be able to rely on the
-            // secrets and descriptors actually being gone when it resumes. Left floating, the only thing that
-            // ever made this land in time was incidental scheduling slack — `syncCloudIntegrations` used to
-            // await each provider in turn, so a later iteration's suspension let the previous provider's delete
-            // finish. Syncing providers concurrently removes that slack and the clear was observably still
-            // pending when the sync returned.
-            await authProvider.deleteAllSessions(this.authProviderDescriptor);
-        }
-        this.resetRequestExceptionCount('all');
-        this._session = null;
-        if (connected) {
-            // Don't store the disconnected flag if silently disconnecting or disconnecting this only for
-            // this current VS Code session (will be re-connected on next restart)
-            if (!options?.currentSessionOnly && !options?.silent) {
-                void this.ctx.storage.storeWorkspace(this.connectedKey, false).catch();
-            }
-            this._onDidChange.fire();
-            if (!options?.currentSessionOnly) {
-                this.didChangeConnection?.fire({ integration: this, key: this.key, reason: 'disconnected' });
-            }
-        }
-        await this.providerOnDisconnect?.();
-    }
-    async reauthenticate() {
-        // `forceNewSession` below deletes the stored secrets to reconnect. Ahead of the guard — see
-        // `onStoredTokensReplaced`.
-        this.onStoredTokensReplaced();
-        if (this._session === undefined)
-            return;
-        this._session = undefined;
-        void (await this.ensureSession({ createIfNeeded: true, forceNewSession: true }));
-    }
-    refresh() {
-        void this.ensureSession({ createIfNeeded: false });
-    }
-    _syncRequestsPerFailedUsecase = new Set();
-    hasSessionSyncRequests() {
-        return this._syncRequestsPerFailedUsecase.size > 0;
-    }
-    requestSessionSyncForUsecase(syncReqUsecase) {
-        this._syncRequestsPerFailedUsecase.add(syncReqUsecase);
-    }
-    /**
-     * The per-connection counterpart of the primary session's expire-and-resync recovery: a token the
-     * provider refused is refreshed once through the GK cloud, which exchanges the refresh token server-side
-     * (the client never holds one). Armed by {@link handleProviderException} and consumed by
-     * {@link resolveReadSession}; a rejection it declines belongs to {@link trackRequestException} instead.
-     */
-    _rejectedTokens = new RejectedTokenTracker();
-    /**
-     * Called by every path that replaces or removes the stored tokens — a disconnect, a forced re-sync, a
-     * reauthentication, or the connection set changing. A rejection names a specific credential, so once that
-     * credential is gone the rejection describes nothing and must not force a refresh (or, for a deleted
-     * connection, outlive it).
-     *
-     * Deliberately NOT conditioned on `_session`. A per-connection read resolves through the auth provider and
-     * never populates the cached primary session, so the connections this recovery exists for are exactly the
-     * ones with no `_session` to inspect — the same blind spot the recovery itself was added to fix. Callers
-     * that guard on `_session` therefore invoke this ahead of that guard.
-     */
-    onStoredTokensReplaced() {
-        this._rejectedTokens.clear();
-    }
-    static requestExceptionLimit = 5;
-    requestExceptionCount = 0;
-    resetRequestExceptionCount(syncReqUsecase) {
-        this.requestExceptionCount = 0;
-        if (syncReqUsecase === 'all') {
-            this._syncRequestsPerFailedUsecase.clear();
-            // 'all' is the whole-integration reset: a disconnect, or a re-sync that produced a new access token.
-            this.onStoredTokensReplaced();
-        }
-        else {
-            this._syncRequestsPerFailedUsecase.delete(syncReqUsecase);
-        }
-    }
-    /**
-     * Resets request exceptions without resetting the amount of syncs
-     */
-    smoothifyRequestExceptionCount() {
-        // On resync we reset exception count only to avoid infinitive syncs on failure
-        this.requestExceptionCount = 0;
-    }
-    async reset() {
-        await this.disconnect({ silent: true });
-        await this.ctx.storage.deleteWorkspace(this.connectedKey);
-    }
-    /**
-     * Drops the in-memory session so the next access re-resolves it from storage. Used when the primary
-     * connection changed underneath a warm integration (e.g. after `setPrimaryConnection`/
-     * `deleteConnection`). Unlike {@link reset}/{@link disconnect}, it deletes nothing from storage.
-     */
-    switchConnection() {
-        // A connection was deleted, or a different one became primary. Ahead of the guard — see
-        // `onStoredTokensReplaced`.
-        this.onStoredTokensReplaced();
-        if (this._session === undefined)
-            return;
-        const wasConnected = this._session != null;
-        this._session = undefined;
-        this._onDidChange.fire();
-        void this.refreshAfterSwitch(wasConnected);
-    }
-    async refreshAfterSwitch(wasConnected) {
-        const session = await this.ensureSession({ createIfNeeded: false });
-        if (session != null || !wasConnected)
-            return;
-        this._onDidChange.fire();
-        this.didChangeConnection?.fire({ integration: this, key: this.key, reason: 'disconnected' });
-        await this.providerOnDisconnect?.();
-    }
-    skippedNonCloudReported = false;
-    async syncCloudConnection(state, forceSync) {
-        const scope = getScopedLogger();
-        // Initially the condition on `this._session.cloud` has been added here: https://github.com/gitkraken/vscode-gitlens/commit/e95e70c430bd162924cc3bd5c1e8ab90e6293449#diff-4213141a45cccaab7aa2e40028b155a87eb913b07388485831403e60ce5555e4R237
-        // I'm not sure about reasons, but it seems we want to replace it with the cloud session if it's connected.
-        // Gradually we'll stop having non-cloud sessions.
-        // However this is needed to be tested with PATs, e.g. with a GitLab PAT.
-        if (this._session?.cloud === false && state !== 'connected') {
-            if (this.id !== GitCloudHostIntegrationId.GitHub && !this.skippedNonCloudReported) {
-                this.ctx.hooks?.session?.onRefreshSkipped?.({
-                    id: this.id,
-                    reason: 'skip-non-cloud',
-                    cloud: false,
-                });
-                this.skippedNonCloudReported = true;
-            }
-            return;
-        }
-        switch (state) {
-            case 'connected': {
-                const oldSession = this._session;
-                let resyncing = false;
-                if (forceSync) {
-                    // Reset our stored session so that we get a new one from the cloud
-                    const authProvider = await this.authenticationService.get(this.authProvider.id);
-                    await authProvider.deleteSession(this.authProviderDescriptor);
-                    // The stored token was just deleted. Not left to the token-changed check below, which needs
-                    // an `oldSession` — see `onStoredTokensReplaced`.
-                    this.onStoredTokensReplaced();
-                    // Reset the session and clear our "stay disconnected" flag
-                    this._session = undefined;
-                    await this.ctx.storage.deleteWorkspace(this.connectedKey);
-                    resyncing = true;
-                }
-                else {
-                    // Only sync if we're not connected and not disabled and don't have pending errors
-                    if (this._session != null ||
-                        this.requestExceptionCount > 0 ||
-                        this.ctx.storage.getWorkspace(this.connectedKey) === false) {
-                        return;
-                    }
-                    forceSync = true;
-                }
-                // sync option, rather than createIfNeeded, makes sure we don't call connectCloudIntegrations and open a gkdev window
-                // if there was no session or some problem fetching/refreshing the existing session from the cloud api
-                let newSession;
-                let refetchFailed = false;
-                try {
-                    newSession = await this.ensureSession({ sync: forceSync });
-                }
-                catch (ex) {
-                    // Not evidence the connection is gone (#5569). Also leaves `_session` as-is rather than
-                    // latching null, so the next access can re-resolve it.
-                    if (!isCancellationError(ex)) {
-                        scope?.error(ex);
-                    }
-                    refetchFailed = true;
-                }
-                if (oldSession && newSession && newSession.accessToken !== oldSession.accessToken) {
-                    this.resetRequestExceptionCount('all');
-                }
-                // The forced re-sync above deleted the cloud secret but kept the descriptor to avoid UI churn.
-                // Drop it only when the replacement fetch came back definitively empty, so a connection whose
-                // token is really gone is cleanly disconnected (#5497) while a healthy one survives a blip (#5569).
-                if (resyncing && newSession == null && !refetchFailed) {
-                    const authProvider = await this.authenticationService.get(this.authProvider.id);
-                    await authProvider.deleteSession(this.authProviderDescriptor, { preserveConfigured: false });
-                }
-                break;
-            }
-            case 'disconnected':
-                await this.disconnect({ silent: true });
-                break;
-        }
-    }
-    handleProviderException(syncReqUsecase, ex, options) {
-        if (isCancellationError(ex))
-            return;
-        if (options?.scope != null) {
-            options.scope.error(ex);
-        }
-        else {
-            Logger.error(ex);
-        }
-        // A per-connection (multi-account) read resolved its session through `resolveReadSession`'s
-        // `connectionId` branch, which deliberately never touches the cached primary `_session`. So the
-        // primary-session recovery below cannot apply to it: expiring `_session` would mark a session this
-        // read never used, while the rejected connection kept its stored token and re-sent it on every
-        // later read — a token the provider has already refused (expired scopes, a revoked grant, an
-        // uninstalled app) is not self-healing, so the read failed identically until the user reconnected
-        // by hand. Record the rejection against the connection instead; `resolveReadSession` consumes it
-        // and forces the cloud `/refresh` on the next read of that connection. When there is nothing to
-        // recover, fall through to the shared failure budget, which disconnects after
-        // `requestExceptionLimit` and surfaces the reconnect prompt.
-        if (ex instanceof AuthenticationError && options?.connectionId) {
-            if (!this._rejectedTokens.recordRejection(options.connectionId)) {
-                this.trackRequestException(options);
-            }
-            return;
-        }
-        if (ex instanceof AuthenticationError && this._session?.cloud) {
-            if (!this.hasSessionSyncRequests()) {
-                this.requestSessionSyncForUsecase(syncReqUsecase);
-                this._session = {
-                    ...this._session,
-                    expiresAt: new Date(Date.now() - 1),
-                };
-            }
-            else {
-                this.trackRequestException(options);
-            }
-        }
-        else if (ex instanceof AuthenticationError || ex instanceof RequestClientError) {
-            this.trackRequestException(options);
-        }
-    }
-    missingExpirityReported = false;
-    async refreshSessionIfExpired(scope) {
-        if (this._session?.expiresAt != null && this._session.expiresAt < new Date()) {
-            // The current session is expired, so get the latest from the cloud and refresh if needed
-            try {
-                await this.syncCloudConnection('connected', true);
-            }
-            catch (ex) {
-                scope?.error(ex);
-            }
-        }
-        else if (this._session?.expiresAt == null &&
-            this.id !== GitCloudHostIntegrationId.GitHub &&
-            !this.missingExpirityReported) {
-            this.ctx.hooks?.session?.onRefreshSkipped?.({
-                id: this.id,
-                reason: 'missing-expiry',
-                cloud: this._session?.cloud,
-            });
-            this.missingExpirityReported = true;
-        }
-    }
-    trackRequestException(options) {
-        this.requestExceptionCount++;
-        if (this.requestExceptionCount >= IntegrationBase.requestExceptionLimit && this._session !== null) {
-            if (!options?.silent) {
-                this.ctx.hooks?.ui?.onDisconnectedAfterTooManyFailures?.(this.name);
-            }
-            void this.disconnect({ currentSessionOnly: true });
-        }
-    }
-    async isConnected() {
-        return (await this.getSession('integrations')) != null;
-    }
-    async ensureSession(options) {
-        const scope = getScopedLogger();
-        const { createIfNeeded, forceNewSession, source, sync } = options;
-        if (this._session != null) {
-            if (this.isSessionForIntegrationHost(this._session))
-                return this._session;
-            this._session = null;
-        }
-        if (this.ctx.config.isIntegrationsEnabled?.() === false)
-            return undefined;
-        if (createIfNeeded || sync) {
-            await this.ctx.storage.deleteWorkspace(this.connectedKey);
-        }
-        else if (this.ctx.storage.getWorkspace(this.connectedKey) === false) {
-            return undefined;
-        }
-        let session;
-        try {
-            const authProvider = await this.authenticationService.get(this.authProvider.id);
-            session = await authProvider.getSession(this.authProviderDescriptor, sync
-                ? { sync: sync, source: source }
-                : {
-                    createIfNeeded: createIfNeeded,
-                    forceNewSession: forceNewSession,
-                    source: source,
-                });
-            if (session?.expiresAt != null && session.expiresAt < new Date()) {
-                session = null;
-            }
-            if (session != null && !this.isSessionForIntegrationHost(session)) {
-                session = undefined;
-            }
-        }
-        catch (ex) {
-            await this.ctx.storage.deleteWorkspace(this.connectedKey);
-            // Only interactive paths can prompt for consent, so a sync failure must reach the rethrow below.
-            if (!sync && ex instanceof Error && ex.message.includes('User did not consent')) {
-                return undefined;
-            }
-            // On a forced re-sync, propagate so syncCloudConnection can tell a failure from a definitive empty
-            // result (#5569); other callers keep swallowing to null so reads never throw.
-            if (sync) {
-                // Throwing skips the reset below, and a lingering count blocks the next non-forced sync.
-                this.smoothifyRequestExceptionCount();
-                throw ex;
-            }
-            session = null;
-        }
-        if (session === undefined && !createIfNeeded && !sync) {
-            await this.ctx.storage.deleteWorkspace(this.connectedKey);
-        }
-        this._session = session ?? null;
-        this.smoothifyRequestExceptionCount();
-        if (session != null) {
-            await this.ctx.storage.storeWorkspace(this.connectedKey, true);
-            queueMicrotask(() => {
-                this._onDidChange.fire();
-                this.didChangeConnection?.fire({ integration: this, key: this.key, reason: 'connected' });
-                // Fired detached, so there is no caller left to catch anything: every implementor is async, and
-                // a rejection would surface as a process-level unhandled rejection in the host. It is a
-                // best-effort warm-up, so swallow the failure with a warning instead.
-                void (async () => {
-                    try {
-                        await this.providerOnConnect?.();
-                    }
-                    catch (ex) {
-                        scope?.warn(`Failed to run providerOnConnect for ${this.key}: ${ex instanceof Error ? ex.message : String(ex)}`);
-                    }
-                })();
-            });
-        }
-        return session ?? undefined;
-    }
-    getIgnoreSSLErrors() {
-        return this.authenticationService.ignoreSSLErrors(this);
-    }
-    async searchMyIssues(resources, cancellation, connectionId) {
-        return (await this.searchMyIssuesResult(resources, cancellation, connectionId))?.value;
-    }
-    /**
-     * Result-returning core of {@link searchMyIssues}. Recovers thrown errors into `{ error }` so callers
-     * (e.g. the ProviderBackend account-wide issues read) can surface a per-provider warning instead of a
-     * silent empty result. Returns the normalized {@link IssueShape} (there is no raw account-wide issue read).
-     */
-    async searchMyIssuesResult(resources, cancellation, connectionId) {
-        const scope = getScopedLogger();
-        // `connectionId` targets a specific account (multi-account); omitted reads the primary.
-        const session = await this.resolveReadSession(connectionId, scope);
-        if (session == null)
-            return undefined;
-        const start = performance.now();
-        try {
-            const issues = await this.searchProviderMyIssues(session, resources != null ? (Array.isArray(resources) ? resources : [resources]) : undefined, cancellation);
-            this.resetRequestExceptionCount('searchMyIssues');
-            return { value: issues, duration: performance.now() - start };
-        }
-        catch (ex) {
-            this.handleProviderException('searchMyIssues', ex, { scope: scope, connectionId: connectionId });
-            return { error: toError(ex), duration: performance.now() - start };
-        }
-    }
-    /**
-     * Paging/truncation-aware variant of {@link searchProviderMyIssues}. The default wraps the normalized read
-     * as a complete single page; providers with native cursors or fan-out metadata override it.
-     */
-    async searchProviderMyIssuesWithTruncation(session, resources, cancellation, _options) {
-        // The default read has no assignee scoping to broaden, so `_options` is inert here; a provider whose
-        // account-wide read is user-scoped (GitHub/GitLab/Azure) overrides this and honors `includeAllAssignees`.
-        const values = await this.searchProviderMyIssues(session, resources, cancellation);
-        if (values == null)
-            return undefined;
-        return { values: values, truncated: false };
-    }
-    /**
-     * Result-returning, truncation-aware account-wide issue read. Recovers thrown errors into `{ error }` and
-     * carries the `truncated` flag so the ProviderBackend facade can report an incomplete read honestly.
-     */
-    async searchMyIssuesWithTruncationResult(resources, cancellation, connectionId, options) {
-        const scope = getScopedLogger();
-        const session = await this.resolveReadSession(connectionId, scope);
-        if (session == null)
-            return undefined;
-        try {
-            const result = await this.searchProviderMyIssuesWithTruncation(session, resources != null ? (Array.isArray(resources) ? resources : [resources]) : undefined, cancellation, options);
-            this.resetRequestExceptionCount('searchMyIssues');
-            return { value: result };
-        }
-        catch (ex) {
-            this.handleProviderException('searchMyIssues', ex, { scope: scope, connectionId: connectionId });
-            return { error: toError(ex) };
-        }
-    }
-    async getLinkedIssueOrPullRequest(resource, link, options) {
-        const scope = getScopedLogger();
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected)
-            return undefined;
-        await this.refreshSessionIfExpired(scope);
-        const issueOrPR = this.ctx.cache.getIssueOrPullRequest(link.key, options?.type, resource, this, () => ({
-            value: (async () => {
-                try {
-                    const result = await this.getProviderLinkedIssueOrPullRequest(this._session, resource, link, options?.type);
-                    this.resetRequestExceptionCount('getIssueOrPullRequest');
-                    return result;
-                }
-                catch (ex) {
-                    this.handleProviderException('getIssueOrPullRequest', ex, { scope: scope });
-                    return undefined;
-                }
-            })(),
-        }), options);
-        return issueOrPR;
-    }
-    async getIssue(resource, id, options) {
-        return (await this.getIssueResult(resource, id, options))?.value;
-    }
-    getIssueResult(resource, id, options) {
-        return this.getIssueResultCore(resource, id, options, session => this.getProviderIssue(session, resource, id));
-    }
-    async getIssueResultCore(resource, id, options, getProviderIssue) {
-        const scope = getScopedLogger();
-        const { connectionId: requestedConnectionId, expiryOverride } = options ?? {};
-        const connectionId = requestedConnectionId || undefined;
-        const session = await this.resolveReadSession(connectionId, scope);
-        if (session == null)
-            return undefined;
-        try {
-            const issue = await getCachedIssue({
-                cache: this.ctx.cache,
-                id: id,
-                resource: resource,
-                integration: this,
-                load: async () => {
-                    try {
-                        const issue = await getProviderIssue(session);
-                        this.resetRequestExceptionCount('getIssue');
-                        return issue;
-                    }
-                    catch (ex) {
-                        if (!isCancellationError(ex)) {
-                            this.handleProviderException('getIssue', toError(ex), {
-                                scope: scope,
-                                connectionId: connectionId,
-                            });
-                        }
-                        throw ex;
-                    }
-                },
-                cacheOptions: {
-                    connectionId: connectionId,
-                    expiryOverride: expiryOverride,
-                    etag: `${this.id}:${this.maybeConnected ?? false}:${this.getSessionFingerprint(session)}`,
-                },
-            });
-            return { value: issue };
-        }
-        catch (ex) {
-            return { error: toError(ex) };
-        }
-    }
-    async getCurrentAccount(options) {
-        const scope = getScopedLogger();
-        const { connectionId: requestedConnectionId, expiryOverride, ...opts } = options ?? {};
-        const connectionId = requestedConnectionId || undefined;
-        const session = await this.resolveReadSession(connectionId, scope);
-        if (session == null)
-            return undefined;
-        const sessionFingerprint = this.getSessionFingerprint(session);
-        const currentAccount = await this.ctx.cache.getCurrentAccount(this, (cacheable) => ({
-            value: (async () => {
-                try {
-                    const account = await this.getProviderCurrentAccount?.(session, opts);
-                    this.resetRequestExceptionCount('getCurrentAccount');
-                    return account;
-                }
-                catch (ex) {
-                    if (isCancellationError(ex)) {
-                        cacheable.invalidate();
-                        return undefined;
-                    }
-                    this.handleProviderException('getCurrentAccount', ex, {
-                        scope: scope,
-                        connectionId: connectionId,
-                    });
-                    // Invalidate the cache on error, except for auth errors
-                    if (!(ex instanceof AuthenticationError)) {
-                        cacheable.invalidate();
-                    }
-                    // Re-throw to the caller
-                    throw ex;
-                }
-            })(),
-        }), {
-            connectionId: connectionId,
-            expiryOverride: expiryOverride,
-            expireOnError: false,
-            etag: `${this.id}:${this.maybeConnected ?? false}:${sessionFingerprint}`,
-        });
-        return currentAccount;
-    }
-    /**
-     * Resolves the account for a specific session/token — including connections other than the current
-     * primary (multi-account) — using this integration's provider API base URL and auth type. Returns
-     * undefined when the provider doesn't support account lookup. Uncached (callers cache per connection).
-     */
-    getProviderAccountForSession(session) {
-        return this.getProviderCurrentAccount?.(session) ?? Promise.resolve(undefined);
-    }
-    async getPullRequest(resource, id, options) {
-        const scope = getScopedLogger();
-        const connected = this.maybeConnected ?? (await this.isConnected());
-        if (!connected)
-            return undefined;
-        await this.refreshSessionIfExpired(scope);
-        const pr = await this.ctx.cache.getPullRequest(id, resource, this, () => ({
-            value: (async () => {
-                try {
-                    const result = await this.getProviderPullRequest?.(this._session, resource, id);
-                    this.resetRequestExceptionCount('getPullRequest');
-                    return result;
-                }
-                catch (ex) {
-                    this.handleProviderException('getPullRequest', ex, { scope: scope });
-                    return undefined;
-                }
-            })(),
-        }), { expiryOverride: options?.expiryOverride });
-        return pr;
-    }
-}
-__decorate([
-    debug()
-], IntegrationBase.prototype, "connect", null);
-__decorate([
-    gate(),
-    debug()
-], IntegrationBase.prototype, "disconnect", null);
-__decorate([
-    debug()
-], IntegrationBase.prototype, "reauthenticate", null);
-__decorate([
-    debug()
-], IntegrationBase.prototype, "syncCloudConnection", null);
-__decorate([
-    gate()
-], IntegrationBase.prototype, "refreshSessionIfExpired", null);
-__decorate([
-    trace()
-], IntegrationBase.prototype, "trackRequestException", null);
-__decorate([
-    gate(),
-    trace({ exit: true })
-], IntegrationBase.prototype, "isConnected", null);
-__decorate([
-    gate()
-], IntegrationBase.prototype, "ensureSession", null);
-__decorate([
-    trace()
-], IntegrationBase.prototype, "searchMyIssues", null);
-__decorate([
-    trace()
-], IntegrationBase.prototype, "getLinkedIssueOrPullRequest", null);
-__decorate([
-    trace()
-], IntegrationBase.prototype, "getIssueResultCore", null);
-__decorate([
-    trace()
-], IntegrationBase.prototype, "getPullRequest", null);
+__decorate([debug()], IntegrationBase.prototype, "connect", null);
+__decorate([gate(), debug()], IntegrationBase.prototype, "disconnect", null);
+__decorate([debug()], IntegrationBase.prototype, "reauthenticate", null);
+__decorate([debug()], IntegrationBase.prototype, "syncCloudConnection", null);
+__decorate([gate()], IntegrationBase.prototype, "refreshSessionIfExpired", null);
+__decorate([trace()], IntegrationBase.prototype, "trackRequestException", null);
+__decorate([gate(), trace({ exit: true })], IntegrationBase.prototype, "isConnected", null);
+__decorate([gate()], IntegrationBase.prototype, "ensureSession", null);
+__decorate([trace()], IntegrationBase.prototype, "searchMyIssues", null);
+__decorate([trace()], IntegrationBase.prototype, "getLinkedIssueOrPullRequest", null);
+__decorate([trace()], IntegrationBase.prototype, "getIssueResultCore", null);
+__decorate([trace()], IntegrationBase.prototype, "getPullRequest", null);
+//#endregion
+export { IntegrationBase };
+
 //# sourceMappingURL=integration.js.map