@gitkraken/core-gitlens 0.3.0 → 0.4.0

package/src/plus/integrations/authentication/integrationAuthenticationService.ts

@@ -0,0 +1,144 @@
+import type { GitRemote } from '../../../git/models/remote.js';
+import { gate } from '../../../utils/decorators/gate.js';
+import { debug } from '../../../utils/decorators/log.js';
+import type { Disposable } from '../../../utils/disposable.js';
+import type { IntegrationIds, SupportedCloudIntegrationIds } from '../constants.js';
+import {
+	GitCloudHostIntegrationId,
+	GitSelfManagedHostIntegrationId,
+	IssuesCloudHostIntegrationId,
+} from '../constants.js';
+import type { IntegrationServiceContext } from '../context.js';
+import type { IntegrationService } from '../integrationService.js';
+import type { GitHostIntegration } from '../models/gitHostIntegration.js';
+import type { ApiClients } from '../providers/apiClients.js';
+import type { Source } from '../telemetry.js';
+import { supportedIntegrationIds } from '../utils/integration.utils.js';
+import type { CloudIntegrationService } from './cloudIntegrationService.js';
+import type { ConfiguredIntegrationService } from './configuredIntegrationService.js';
+import type { IntegrationAuthenticationProvider } from './integrationAuthenticationProvider.js';
+import { CloudIntegrationAuthenticationProvider } from './integrationAuthenticationProvider.js';
+
+export class IntegrationAuthenticationService implements Disposable {
+	private readonly providers = new Map<IntegrationIds, IntegrationAuthenticationProvider>();
+
+	constructor(
+		private readonly configuredIntegrationService: ConfiguredIntegrationService,
+		readonly ctx: IntegrationServiceContext,
+		/**
+		 * Lazy accessor for the owning {@link IntegrationService}. Injected by the composition root
+		 * ({@link createIntegrationManager}) to break the auth↔service construction cycle without a
+		 * mutable setter or a host round-trip; only resolved at runtime (long after construction).
+		 */
+		private readonly getIntegrationService: () => IntegrationService,
+		/** The package's cloud token-exchange client, constructed by the composition root. */
+		readonly cloudIntegrations: CloudIntegrationService,
+	) {}
+
+	dispose(): void {
+		this.providers.forEach(p => p.dispose());
+		this.providers.clear();
+	}
+
+	/**
+	 * Initiates the cloud-integration connect flow on the owning service. Cloud auth providers call
+	 * this when they need a session that doesn't exist yet (see
+	 * {@link CloudIntegrationAuthenticationProvider}).
+	 */
+	connectCloudIntegrations(
+		connect: { integrationIds: SupportedCloudIntegrationIds[]; skipIfConnected?: boolean; skipPreSync?: boolean },
+		source?: Source,
+	): Promise<boolean> {
+		return this.getIntegrationService().connectCloudIntegrations(connect, source);
+	}
+
+	/**
+	 * Resolves the connected git-host integration for a `GitRemote`, via the owning service. Lets
+	 * package-internal callers (e.g. the Bitbucket provider) resolve a remote's integration without a
+	 * host round-trip.
+	 */
+	getByRemote(remote: GitRemote): Promise<GitHostIntegration | undefined> {
+		return this.getIntegrationService().getByRemote(remote);
+	}
+
+	/** Resolves the per-integration `ignoreSSLErrors` flag via the owning service (host-config-backed). */
+	ignoreSSLErrors(integration: GitHostIntegration | { id: IntegrationIds; domain?: string }): boolean | 'force' {
+		return this.getIntegrationService().ignoreSSLErrors(integration);
+	}
+
+	/** The package-built per-provider API clients, via the owning service (built once + memoized there). */
+	get apis(): ApiClients {
+		return this.getIntegrationService().apis;
+	}
+
+	async get(providerId: IntegrationIds): Promise<IntegrationAuthenticationProvider> {
+		return this.ensureProvider(providerId);
+	}
+
+	@debug()
+	async reset(): Promise<void> {
+		// TODO: This really isn't ideal, since it will only work for "cloud" providers as we won't have any more specific descriptors
+		await Promise.allSettled(
+			supportedIntegrationIds.map(async providerId =>
+				(await this.ensureProvider(providerId)).deleteAllSessions(),
+			),
+		);
+	}
+
+	supports(providerId: string): boolean {
+		switch (providerId) {
+			case GitCloudHostIntegrationId.AzureDevOps:
+			case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
+			case GitCloudHostIntegrationId.Bitbucket:
+			case GitCloudHostIntegrationId.GitLab:
+			case IssuesCloudHostIntegrationId.Jira:
+			case GitCloudHostIntegrationId.GitHub:
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	@gate()
+	private async ensureProvider(providerId: IntegrationIds): Promise<IntegrationAuthenticationProvider> {
+		let provider = this.providers.get(providerId);
+		if (provider != null) return provider;
+
+		// Optional consumer override for custom auth (e.g. a manual-token provider). GitLens omits it —
+		// the package constructs its own cloud providers below (so GitLens's cloud auth needs no host hook).
+		const hostProvider = await this.ctx.hooks?.createAuthenticationProvider?.({
+			id: providerId,
+			auth: this,
+			configured: this.configuredIntegrationService,
+		});
+		if (hostProvider != null) {
+			this.providers.set(providerId, hostProvider);
+			return hostProvider;
+		}
+
+		// Every cloud integration shares one provider, parameterized by id (cloud-only).
+		switch (providerId) {
+			case GitCloudHostIntegrationId.GitHub:
+			case GitSelfManagedHostIntegrationId.CloudGitHubEnterprise:
+			case GitCloudHostIntegrationId.GitLab:
+			case GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted:
+			case GitCloudHostIntegrationId.AzureDevOps:
+			case GitSelfManagedHostIntegrationId.AzureDevOpsServer:
+			case GitCloudHostIntegrationId.Bitbucket:
+			case GitSelfManagedHostIntegrationId.BitbucketServer:
+			case IssuesCloudHostIntegrationId.Jira:
+			case IssuesCloudHostIntegrationId.Linear:
+				provider = new CloudIntegrationAuthenticationProvider(
+					this,
+					this.configuredIntegrationService,
+					providerId,
+				);
+				break;
+			default:
+				throw new Error(`No authentication provider registered for integration '${providerId}'`);
+		}
+
+		this.providers.set(providerId, provider);
+		return provider;
+	}
+}

package/src/plus/integrations/authentication/manualTokenProvider.ts

@@ -0,0 +1,72 @@
+// Convenience for "manual token" auth — when a consumer already has an access
+// token (CLI flag, env var, secret manager) and just wants the package to use
+// it without an OAuth dance. Wire it into the manager via the
+// `createAuthenticationProvider` hook:
+//
+//   const manager = createIntegrationManager({
+//       ...runtime,
+//       hooks: {
+//           createAuthenticationProvider: async ({ id }) =>
+//               id === GitCloudHostIntegrationId.GitHub
+//                   ? createManualTokenAuthProvider({
+//                         id: id,
+//                         token: process.env.GITHUB_TOKEN!,
+//                         account: { id: 'me', label: 'CLI Token' },
+//                     })
+//                   : undefined,
+//       },
+//   });
+//
+// The provider is intentionally minimal — sessions are non-cancellable, never
+// expire, and persist for the lifetime of the manager. For OAuth flows or
+// refreshable tokens, implement `IntegrationAuthenticationProvider` yourself.
+
+import type { Event } from '../../../utils/event.js';
+import { Emitter } from '../../../utils/event.js';
+import type { IntegrationIds } from '../constants.js';
+import type {
+	IntegrationAuthenticationProvider,
+	IntegrationAuthenticationSessionDescriptor,
+} from './integrationAuthenticationProvider.js';
+import type { ProviderAuthenticationSession } from './models.js';
+
+export interface ManualTokenAuthProviderOptions {
+	readonly id: IntegrationIds;
+	readonly token: string;
+	readonly account: { readonly id: string; readonly label: string };
+	readonly scopes?: readonly string[];
+	readonly domain?: string;
+	readonly cloud?: boolean;
+}
+
+export function createManualTokenAuthProvider(
+	options: ManualTokenAuthProviderOptions,
+): IntegrationAuthenticationProvider {
+	const onDidChange = new Emitter<void>();
+	const session: ProviderAuthenticationSession = {
+		id: `manual:${options.id}`,
+		accessToken: options.token,
+		account: options.account,
+		scopes: options.scopes ?? [],
+		cloud: options.cloud ?? true,
+		type: undefined,
+		domain: options.domain ?? '',
+	};
+
+	return {
+		get onDidChange(): Event<void> {
+			return onDidChange.event;
+		},
+		getSession: (
+			_descriptor: IntegrationAuthenticationSessionDescriptor,
+			options?: Parameters<IntegrationAuthenticationProvider['getSession']>[1],
+		) =>
+			// A manual token can't be refreshed; on a forced new session, fail safe by returning undefined
+			// rather than handing back the same (likely-rejected) token, which would loop a caller's
+			// reauthenticate-on-failure flow.
+			Promise.resolve(options?.forceNewSession ? undefined : session),
+		deleteSession: () => Promise.resolve(),
+		deleteAllSessions: () => Promise.resolve(),
+		dispose: () => onDidChange.dispose(),
+	};
+}

package/src/plus/integrations/authentication/models.ts

@@ -0,0 +1,168 @@
+import { microhash } from '../../../utils/hash.js';
+import type { IntegrationIds, SupportedCloudIntegrationIds } from '../constants.js';
+import {
+	GitCloudHostIntegrationId,
+	GitSelfManagedHostIntegrationId,
+	IssuesCloudHostIntegrationId,
+	supportedOrderedCloudIntegrationIds,
+} from '../constants.js';
+
+/**
+ * Mirrors the shape of `vscode.AuthenticationSession` so the integrations
+ * package can stay vscode-free. Host adapters bridge VS Code sessions to
+ * this shape via {@link AuthenticationProvider}.
+ */
+export interface AuthenticationSessionLike {
+	readonly id: string;
+	readonly accessToken: string;
+	readonly account: { readonly id: string; readonly label: string };
+	readonly scopes: readonly string[];
+}
+
+export interface ProviderAuthenticationSession extends AuthenticationSessionLike {
+	readonly cloud: boolean;
+	readonly type: CloudIntegrationAuthType | undefined;
+	readonly expiresAt?: Date;
+	readonly domain: string;
+	readonly protocol?: string;
+}
+
+export interface TokenInfo<T extends IntegrationIds | 'gitkraken' = IntegrationIds | 'gitkraken'> {
+	readonly providerId: T;
+	/**
+	 * The first 3 characters of the md5 hash of the token.
+	 * It's a very obfuscated representation of the token that we can use in logs
+	 * to see whether the token survives refreshing or gets updated.
+	 */
+	readonly microHash: string | undefined;
+	readonly cloud: boolean;
+	readonly type: CloudIntegrationAuthType | undefined;
+	readonly scopes: readonly string[] | undefined;
+	readonly expiresAt?: Date;
+}
+
+export interface TokenWithInfo<T extends IntegrationIds = IntegrationIds> extends TokenInfo<T> {
+	readonly accessToken: string;
+}
+
+export function toTokenInfo<T extends IntegrationIds | 'gitkraken'>(
+	providerId: T,
+	accessToken: string | undefined,
+	info: { cloud: boolean; type: CloudIntegrationAuthType | undefined; scopes?: readonly string[]; expiresAt?: Date },
+): TokenInfo<T> {
+	return {
+		providerId: providerId,
+		microHash: microhash(accessToken, 3),
+		cloud: info.cloud,
+		type: info.type,
+		scopes: info.scopes,
+		expiresAt: info.expiresAt,
+	};
+}
+
+export function toTokenWithInfo<T extends IntegrationIds>(
+	providerId: T,
+	session: ProviderAuthenticationSession,
+	altToken?: string,
+): TokenWithInfo<T> {
+	const { accessToken: sessionToken, ...sessionInfo } = session;
+	const accessToken = altToken ?? session.accessToken;
+	return {
+		// pass original token info to form the correlated microhash
+		...toTokenInfo(providerId, sessionToken, sessionInfo),
+		// use the actual token used for the request
+		accessToken: accessToken,
+	};
+}
+
+export type TokenOptInfo<T extends IntegrationIds = IntegrationIds> =
+	| TokenWithInfo<T>
+	| { providerId: T; accessToken?: undefined };
+
+export interface ConfiguredIntegrationDescriptor {
+	readonly cloud: boolean;
+	readonly integrationId: IntegrationIds;
+	readonly scopes: string;
+	readonly domain?: string;
+	readonly expiresAt?: string | Date;
+}
+
+export interface CloudIntegrationAuthenticationSession {
+	type: CloudIntegrationAuthType;
+	accessToken: string;
+	domain: string;
+	expiresIn: number;
+	scopes: string;
+}
+
+export interface CloudIntegrationAuthorization {
+	url: string;
+}
+
+export interface CloudIntegrationConnection {
+	type: CloudIntegrationAuthType;
+	provider: CloudIntegrationType;
+	domain: string;
+}
+
+export type CloudIntegrationType =
+	| 'jira'
+	| 'linear'
+	| 'trello'
+	| 'gitlab'
+	| 'github'
+	| 'bitbucket'
+	| 'bitbucketServer'
+	| 'azure'
+	| 'azureDevopsServer'
+	| 'githubEnterprise'
+	| 'gitlabSelfHosted';
+
+export type CloudIntegrationAuthType = 'oauth' | 'pat';
+
+export const CloudIntegrationAuthenticationUriPathPrefix = 'did-authenticate-cloud-integration';
+
+/** Returns all supported cloud integration ids. */
+export function getSupportedCloudIntegrationIds(): readonly SupportedCloudIntegrationIds[] {
+	// Return the shared const directly (readonly so callers can't mutate it) — this runs on hot,
+	// per-integration membership paths, so avoid allocating a fresh array per call.
+	return supportedOrderedCloudIntegrationIds;
+}
+
+/** Whether `id` is a supported cloud integration id. */
+export function isSupportedCloudIntegrationId(id: string): id is SupportedCloudIntegrationIds {
+	return getSupportedCloudIntegrationIds().includes(id as SupportedCloudIntegrationIds);
+}
+
+export function isIssueCloudIntegrationId(id: string): id is IssuesCloudHostIntegrationId {
+	const issueIds: string[] = Object.values(IssuesCloudHostIntegrationId);
+	return issueIds.includes(id);
+}
+
+export const toIntegrationId: { [key in CloudIntegrationType]: IntegrationIds } = {
+	jira: IssuesCloudHostIntegrationId.Jira,
+	linear: IssuesCloudHostIntegrationId.Linear,
+	trello: IssuesCloudHostIntegrationId.Trello,
+	gitlab: GitCloudHostIntegrationId.GitLab,
+	github: GitCloudHostIntegrationId.GitHub,
+	githubEnterprise: GitSelfManagedHostIntegrationId.CloudGitHubEnterprise,
+	gitlabSelfHosted: GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted,
+	bitbucket: GitCloudHostIntegrationId.Bitbucket,
+	bitbucketServer: GitSelfManagedHostIntegrationId.BitbucketServer,
+	azure: GitCloudHostIntegrationId.AzureDevOps,
+	azureDevopsServer: GitSelfManagedHostIntegrationId.AzureDevOpsServer,
+};
+
+export const toCloudIntegrationType: { [key in IntegrationIds]: CloudIntegrationType | undefined } = {
+	[IssuesCloudHostIntegrationId.Jira]: 'jira',
+	[IssuesCloudHostIntegrationId.Linear]: 'linear',
+	[IssuesCloudHostIntegrationId.Trello]: 'trello',
+	[GitCloudHostIntegrationId.GitLab]: 'gitlab',
+	[GitCloudHostIntegrationId.GitHub]: 'github',
+	[GitCloudHostIntegrationId.Bitbucket]: 'bitbucket',
+	[GitCloudHostIntegrationId.AzureDevOps]: 'azure',
+	[GitSelfManagedHostIntegrationId.AzureDevOpsServer]: 'azureDevopsServer',
+	[GitSelfManagedHostIntegrationId.CloudGitHubEnterprise]: 'githubEnterprise',
+	[GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted]: 'gitlabSelfHosted',
+	[GitSelfManagedHostIntegrationId.BitbucketServer]: 'bitbucketServer',
+};

package/src/plus/integrations/constants.ts

@@ -0,0 +1,169 @@
+export enum GitCloudHostIntegrationId {
+	GitHub = 'github',
+	GitLab = 'gitlab',
+	Bitbucket = 'bitbucket',
+	AzureDevOps = 'azureDevOps',
+}
+
+export enum GitSelfManagedHostIntegrationId {
+	BitbucketServer = 'bitbucket-server',
+	CloudGitHubEnterprise = 'cloud-github-enterprise',
+	CloudGitLabSelfHosted = 'cloud-gitlab-self-hosted',
+	AzureDevOpsServer = 'azure-devops-server',
+}
+
+export enum IssuesCloudHostIntegrationId {
+	Jira = 'jira',
+	Linear = 'linear',
+	Trello = 'trello',
+}
+
+export type CloudGitSelfManagedHostIntegrationIds =
+	| GitSelfManagedHostIntegrationId.CloudGitHubEnterprise
+	| GitSelfManagedHostIntegrationId.BitbucketServer
+	| GitSelfManagedHostIntegrationId.AzureDevOpsServer
+	| GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted;
+
+export type GitHostIntegrationIds = GitCloudHostIntegrationId | GitSelfManagedHostIntegrationId;
+export type IssuesHostIntegrationIds = IssuesCloudHostIntegrationId;
+
+export type IntegrationIds = GitHostIntegrationIds | IssuesHostIntegrationIds;
+
+export const supportedOrderedCloudIssuesIntegrationIds = [
+	IssuesCloudHostIntegrationId.Jira,
+	IssuesCloudHostIntegrationId.Linear,
+];
+export const supportedOrderedCloudIntegrationIds = [
+	GitCloudHostIntegrationId.GitHub,
+	GitSelfManagedHostIntegrationId.CloudGitHubEnterprise,
+	GitCloudHostIntegrationId.GitLab,
+	GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted,
+	GitCloudHostIntegrationId.AzureDevOps,
+	GitSelfManagedHostIntegrationId.AzureDevOpsServer,
+	GitCloudHostIntegrationId.Bitbucket,
+	GitSelfManagedHostIntegrationId.BitbucketServer,
+	IssuesCloudHostIntegrationId.Jira,
+	IssuesCloudHostIntegrationId.Linear,
+];
+
+export const integrationIds = [
+	GitCloudHostIntegrationId.GitHub,
+	GitCloudHostIntegrationId.GitLab,
+	GitCloudHostIntegrationId.Bitbucket,
+	GitCloudHostIntegrationId.AzureDevOps,
+	GitSelfManagedHostIntegrationId.AzureDevOpsServer,
+	GitSelfManagedHostIntegrationId.BitbucketServer,
+	GitSelfManagedHostIntegrationId.CloudGitHubEnterprise,
+	GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted,
+	IssuesCloudHostIntegrationId.Jira,
+	IssuesCloudHostIntegrationId.Linear,
+	IssuesCloudHostIntegrationId.Trello,
+];
+
+export type SupportedCloudIntegrationIds = (typeof supportedOrderedCloudIntegrationIds)[number];
+
+export function isSupportedCloudIntegrationId(id: IntegrationIds): id is SupportedCloudIntegrationIds {
+	return supportedOrderedCloudIntegrationIds.includes(id);
+}
+
+export function isIntegrationId(id: string): id is IntegrationIds {
+	return integrationIds.includes(id as IntegrationIds);
+}
+
+export type IntegrationFeatures = 'prs' | 'issues';
+
+export interface IntegrationDescriptor {
+	id: SupportedCloudIntegrationIds;
+	name: string;
+	icon: string;
+	supports: IntegrationFeatures[];
+	requiresPro: boolean;
+}
+
+/** Stored shape of a configured-integration descriptor in workspace state. */
+export interface StoredConfiguredIntegrationDescriptor {
+	cloud: boolean;
+	integrationId: IntegrationIds;
+	domain?: string;
+	expiresAt?: string;
+	scopes: string;
+}
+
+/** Stored shape of the `integrations:configured` storage key. */
+export type StoredIntegrationConfigurations = Record<
+	IntegrationIds,
+	StoredConfiguredIntegrationDescriptor[] | undefined
+>;
+
+export const supportedCloudIntegrationDescriptors: IntegrationDescriptor[] = [
+	{
+		id: GitCloudHostIntegrationId.GitHub,
+		name: 'GitHub',
+		icon: 'gl-provider-github',
+		supports: ['prs', 'issues'],
+		requiresPro: false,
+	},
+	{
+		id: GitSelfManagedHostIntegrationId.CloudGitHubEnterprise,
+		name: 'GitHub Enterprise',
+		icon: 'gl-provider-github',
+		supports: ['prs', 'issues'],
+		requiresPro: true,
+	},
+	{
+		id: GitCloudHostIntegrationId.GitLab,
+		name: 'GitLab',
+		icon: 'gl-provider-gitlab',
+		supports: ['prs', 'issues'],
+		requiresPro: false,
+	},
+	{
+		id: GitSelfManagedHostIntegrationId.CloudGitLabSelfHosted,
+		name: 'GitLab Self-Hosted',
+		icon: 'gl-provider-gitlab',
+		supports: ['prs', 'issues'],
+		requiresPro: true,
+	},
+	{
+		id: GitCloudHostIntegrationId.AzureDevOps,
+		name: 'Azure DevOps',
+		icon: 'gl-provider-azdo',
+		supports: ['prs', 'issues'],
+		requiresPro: true,
+	},
+	{
+		id: GitSelfManagedHostIntegrationId.AzureDevOpsServer,
+		name: 'Azure DevOps Server',
+		icon: 'gl-provider-azdo',
+		supports: ['prs', 'issues'],
+		requiresPro: true,
+	},
+	{
+		id: GitCloudHostIntegrationId.Bitbucket,
+		name: 'Bitbucket',
+		icon: 'gl-provider-bitbucket',
+		supports: ['prs', 'issues'],
+		requiresPro: false,
+	},
+	{
+		id: GitSelfManagedHostIntegrationId.BitbucketServer,
+		name: 'Bitbucket Data Center',
+		icon: 'gl-provider-bitbucket',
+		supports: ['prs'],
+		requiresPro: true,
+	},
+	{
+		id: IssuesCloudHostIntegrationId.Jira,
+		name: 'Jira',
+		icon: 'gl-provider-jira',
+		supports: ['issues'],
+		requiresPro: true,
+	},
+	{
+		id: IssuesCloudHostIntegrationId.Linear,
+		name: 'Linear',
+		icon: 'gl-provider-linear',
+		supports: ['issues'],
+		requiresPro: true,
+	},
+];