@gitkraken/core-gitlens 0.6.0 → 0.7.0

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

@@ -1,29 +0,0 @@
-import type { Issue } from '../../../git/models/issue.js';
-import type { ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
-import type { IntegrationCacheProvider } from '../context.js';
-
-export async function getCachedIssue(options: {
-	cache: IntegrationCacheProvider;
-	id: string;
-	resource: ResourceDescriptor;
-	integration: Parameters<IntegrationCacheProvider['getIssue']>[2];
-	load: () => Promise<Issue | undefined>;
-	cacheOptions: {
-		connectionId: string | undefined;
-		expiryOverride: boolean | number | undefined;
-		etag: string;
-	};
-}): Promise<Issue | undefined> {
-	return options.cache.getIssue(
-		options.id,
-		options.resource,
-		options.integration,
-		cacheable => ({
-			value: options.load().catch((ex: unknown) => {
-				cacheable.invalidate();
-				throw ex;
-			}),
-		}),
-		options.cacheOptions,
-	);
-}

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

@@ -1,152 +0,0 @@
-import type { CollectionMetadata } from '@gitkraken/provider-apis';
-import type { IssueShape, IssueSorting, IssueStateFilter } from '../../../git/models/issue.js';
-import type { IssueFilter } from '../providerFilters.js';
-
-/**
- * The result and option contracts of the integration layer's issue reads — the shapes a PROVIDER returns to the
- * facade, before the facade turns them into the paged/warning results a consumer sees.
- *
- * They live together, and apart from `IntegrationBase`, because they are pure data with one job: pinning what
- * each issue read promises. Reading them side by side is also the point — `ProviderIssueSearchPage` is
- * deliberately `AccountWideIssuesResult` plus a count, and that relationship is invisible when they sit at
- * opposite ends of a 1000-line class module.
- */
-
-/**
- * Account-wide issue read result. `truncated` is a provider-native incompleteness signal (GitHub's search
- * ceiling, an Azure per-project backstop); cursor-capable providers also expose `cursor`/`hasMore`/`page`.
- * `metadata` optionally carries structured per-scope failures from a fan-out (Azure across projects).
- */
-export type AccountWideIssuesResult = {
-	values: IssueShape[];
-	truncated: boolean;
-	metadata?: CollectionMetadata;
-	cursor?: string;
-	hasMore?: boolean;
-	page?: number;
-};
-
-/**
- * One page of the FILTERED issue search (`GitHostIntegration.searchIssuesPageResult`).
- *
- * Carries what {@link AccountWideIssuesResult} does, plus `totalCount`: the number of matches the provider
- * reported, which is what makes the result ceiling reportable as a figure ("N matched, at most M can be read")
- * rather than as a bare `truncated` flag. `undefined` means the provider reported no count, never zero matches.
- */
-export type ProviderIssueSearchPage = {
-	values: IssueShape[];
-	truncated: boolean;
-	cursor?: string;
-	hasMore: boolean;
-	page: number;
-	totalCount?: number;
-};
-
-/**
- * Options for an issue tracker's PROJECT-scoped read (`IssuesIntegration.getIssuesForProject*`), which is the
- * only issue surface a tracker has — its issues live under resource -> project, so there is no account-wide read
- * to pair this with.
- *
- * Named rather than repeated inline at each of the six declarations this shape appears in (the two public
- * `Result` methods, the two protected provider cores, and their Jira/Linear/Trello overrides), so a field added
- * here can't reach five of them and be forgotten in the sixth.
- */
-export type IssuesForProjectOptions = {
-	/** The account handle to scope to, resolved per resource by the caller. Omitted reads every assignee. */
-	user?: string;
-	/** Validated by the caller against `ProviderMetadata.supportedIssueFilters`; unsupported refuses the read. */
-	filters?: IssueFilter[];
-	/**
-	 * How the provider should order the project's issues, as `field:direction`.
-	 *
-	 * Validated against `ProviderMetadata.supportedIssueSorts` — a tracker reports there, not under the
-	 * account-wide table. Note the caller reads MANY projects and merges them, so it additionally refuses a key
-	 * no normalized issue carries; this option orders one project's query.
-	 */
-	sort?: IssueSorting;
-};
-
-export type ProjectIssuesDrain = {
-	values: IssueShape[];
-	metadata?: CollectionMetadata;
-} & (
-	| { truncated: false }
-	| {
-			truncated: true;
-			/**
-			 * `narrow-scope` means a smaller server-side scope avoids this truncation. `none` covers incomplete
-			 * results without that guarantee, including Linear's client-side assignee filtering.
-			 */
-			recovery: 'narrow-scope' | 'none';
-	  }
-);
-
-/**
- * Options for the REPO-scoped issue read (`GitHostIntegration.getMyIssuesForRepos*`), the git-host counterpart of
- * {@link IssuesForProjectOptions}.
- *
- * Named for the same reason that one is: the shape appears at three declarations — the public method, its
- * result-returning core, and the shapes-returning core that maps it — and was previously spelled out inline at
- * each, so `sort` had to be added three times and two of the copies grew a `See {@link getMyIssuesForRepos}`
- * breadcrumb to admit they were the same contract. One name means a field added here reaches all three.
- */
-export type MyIssuesForReposOptions = {
-	/** Validated by the caller against `ProviderMetadata.supportedIssueFilters`; unsupported refuses the read. */
-	filters?: IssueFilter[];
-	cursor?: string;
-	customUrl?: string;
-	page?: number;
-	pageSize?: number;
-	/** When true, don't constrain to the current user's assigned issues even if the Assignee filter is set. */
-	includeAllAssignees?: boolean;
-	/** Issue states to include; when omitted the provider returns its default (open only). */
-	state?: IssueStateFilter;
-	/**
-	 * How the provider should order the read. Forwarded to every query this read issues, so the ORDER WITHIN each
-	 * scope is the provider's; the union across scopes is not ordered here — the facade (`listIssuesPage`) owns
-	 * that, because it is also the layer that can refuse a key no merge can honor.
-	 */
-	sort?: IssueSorting;
-};
-
-/**
- * Options for the account-wide issue read. `includeAllAssignees` drops the "assigned to me" scoping so the
- * read broadens to issues assigned to anyone (the account-wide equivalent of the repo-scoped
- * `GitHostIntegration.getMyIssuesForReposResult`'s toggle). Authored/mentioned categories, where a
- * provider has them, stay user-relative — they're meaningless without a user.
- */
-export type SearchMyIssuesOptions = {
-	includeAllAssignees?: boolean;
-	/**
-	 * Narrows the account-wide read to the requested relationship(s) instead of the provider's own definition of
-	 * "my issues" (GitHub/GHE: authored ∪ assigned ∪ mentioned; Azure: assigned ∪ authored; GitLab:
-	 * assigned-to-me). Narrowing has to happen HERE, not on the returned page: the excluded items still counted
-	 * toward the provider's page/cursor, so a client-side filter desynchronizes `items` from `hasMore`.
-	 *
-	 * Only filters the provider can express server-side are accepted; the facade validates the set against
-	 * `ProviderMetadata.supportedAccountWideIssueFilters` (all-or-nothing) and refuses the read rather than
-	 * serving the unnarrowed union as if it had been filtered. Omitted keeps the provider's definition.
-	 */
-	filters?: IssueFilter[];
-	cursor?: string;
-	/**
-	 * Narrows the account-wide read to one org/account (Azure: the organization) and/or one project within it.
-	 * Only honored by a host with a project layer (Azure), whose account-wide read otherwise fans out over every
-	 * project of every org; the caller checks `supportsProjectDiscovery` before asking, so a host without a
-	 * project layer never silently returns an unscoped list as if it had been narrowed.
-	 */
-	org?: string;
-	project?: string;
-	/**
-	 * How the provider should order the read, as `field:direction`.
-	 *
-	 * Validated by the facade against `ProviderMetadata.supportedAccountWideIssueSorts` — a DIFFERENT table from
-	 * the repo-scoped one, because for GitLab the two reads are different APIs with different sort vocabularies —
-	 * and refused rather than downgraded when the provider can't express it.
-	 *
-	 * Supplied on every facade read, never omitted: an omitted sort leaves each provider's own default, which is
-	 * exactly the cross-provider incoherence this layer exists to remove. A provider that reaches this with
-	 * `undefined` was called directly, not through the facade, and keeps whatever order it had.
-	 */
-	sort?: IssueSorting;
-};

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

@@ -1,248 +0,0 @@
-import type { Account } from '../../../git/models/author.js';
-import type { Issue, IssueShape } from '../../../git/models/issue.js';
-import type { ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
-import { gate } from '../../../utils/decorators/gate.js';
-import { trace } from '../../../utils/decorators/log.js';
-import { getScopedLogger } from '../../../utils/logger.scoped.js';
-import type { ProviderAuthenticationSession } from '../authentication/models.js';
-import type { IntegrationIds } from '../constants.js';
-import { IntegrationReadUnavailableError, toError } from '../errors.js';
-import type { ProviderApiCollectionResult } from '../providers/models.js';
-import type { Integration, IntegrationResult, IntegrationType } from './integration.js';
-import { IntegrationBase } from './integration.js';
-import type { IssuesForProjectOptions, ProjectIssuesDrain } from './issueReads.js';
-
-export function isIssuesIntegration(integration: Integration): integration is IssuesIntegration {
-	return integration.type === 'issues';
-}
-
-export abstract class IssuesIntegration<
-	ID extends IntegrationIds = IntegrationIds,
-	T extends ResourceDescriptor = ResourceDescriptor,
-> extends IntegrationBase<ID> {
-	readonly type: IntegrationType = 'issues';
-
-	get supportsIssueLookupByResourceId(): boolean {
-		return this.getProviderIssueByResourceId != null;
-	}
-
-	getIssueByResourceIdResult(
-		resourceId: string,
-		id: string,
-		options?: { connectionId?: string; expiryOverride?: boolean | number; resourceUrl?: string },
-	): Promise<IntegrationResult<Issue | undefined>> {
-		const getProviderIssue = this.getProviderIssueByResourceId;
-		if (getProviderIssue == null) {
-			return Promise.resolve({
-				error: new IntegrationReadUnavailableError(
-					this.name,
-					'does not support direct issue reads by resource id',
-				),
-			});
-		}
-
-		const { resourceUrl, ...readOptions } = options ?? {};
-		const resource = { key: resourceId, resourceId: resourceId, resourceUrl: resourceUrl };
-		return this.getIssueResultCore(resource, id, readOptions, session =>
-			getProviderIssue.call(this, session, resourceId, id, resourceUrl),
-		);
-	}
-
-	protected getProviderIssueByResourceId?(
-		_session: ProviderAuthenticationSession,
-		_resourceId: string,
-		_id: string,
-		_resourceUrl: string | undefined,
-	): Promise<Issue | undefined>;
-
-	@trace()
-	async getAccountForResource(resource: T, connectionId?: string): Promise<Account | undefined> {
-		return (await this.getAccountForResourceResult(resource, connectionId))?.value;
-	}
-
-	/**
-	 * Result-returning core of {@link getAccountForResource}. Recovers a thrown error into `{ error }` so
-	 * callers can preserve its classification (e.g. a 401/403 → an `auth` warning that drives re-auth)
-	 * instead of collapsing every failure into an untyped `undefined`. Gated here (not on the wrapper) so
-	 * direct callers such as the ProviderBackend facade share the same dedup as `getAccountForResource`.
-	 */
-	@gate()
-	async getAccountForResourceResult(
-		resource: T,
-		connectionId?: string,
-	): Promise<IntegrationResult<Account | undefined>> {
-		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;
-
-		try {
-			const account = await this.getProviderAccountForResource(session, resource);
-			this.resetRequestExceptionCount('getAccountForResource');
-			return { value: account };
-		} catch (ex) {
-			this.handleProviderException('getAccountForResource', ex, { connectionId: connectionId });
-			return { error: toError(ex) };
-		}
-	}
-
-	protected abstract getProviderAccountForResource(
-		session: ProviderAuthenticationSession,
-		resource: T,
-	): Promise<Account | undefined>;
-
-	@trace()
-	async getResourcesForUser(connectionId?: string): Promise<T[] | undefined> {
-		return (await this.getResourcesForUserResult(connectionId))?.value;
-	}
-
-	/**
-	 * Result-returning core of {@link getResourcesForUser}. Recovers thrown errors into `{ error }` so callers
-	 * can surface them as warnings rather than silently swallowing them to `undefined`. Gated here (not on the
-	 * wrapper) so direct callers such as the ProviderBackend facade share the same dedup as `getResourcesForUser`.
-	 */
-	@gate()
-	async getResourcesForUserResult(connectionId?: string): Promise<IntegrationResult<T[] | undefined>> {
-		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;
-
-		try {
-			const resources = await this.getProviderResourcesForUser(session);
-			this.resetRequestExceptionCount('getResourcesForUser');
-			return { value: resources };
-		} catch (ex) {
-			this.handleProviderException('getResourcesForUser', ex, { connectionId: connectionId });
-			return { error: toError(ex) };
-		}
-	}
-
-	protected abstract getProviderResourcesForUser(session: ProviderAuthenticationSession): Promise<T[] | undefined>;
-
-	/**
-	 * Project discovery for a set of resources, returning the SDK collection `{ values, metadata }` (completeness
-	 * + per-resource failures) so callers can warn on failed resources and set `fetchFailed` without discarding
-	 * the resources that succeeded. Thrown errors are recovered into `{ error }` for the same reason: a caller
-	 * surfaces them as a warning rather than swallowing them to `undefined`.
-	 */
-	@trace()
-	async getProjectsForResourcesWithMetadataResult(
-		resources: T[],
-		connectionId?: string,
-	): Promise<IntegrationResult<ProviderApiCollectionResult<T> | undefined>> {
-		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;
-
-		try {
-			const projects = await this.getProviderProjectsForResourcesWithMetadata(session, resources);
-			this.resetRequestExceptionCount('getProjectsForResources');
-			return { value: projects };
-		} catch (ex) {
-			this.handleProviderException('getProjectsForResources', ex, { connectionId: connectionId });
-			return { error: toError(ex) };
-		}
-	}
-
-	/**
-	 * Metadata-aware provider project discovery. The default wraps the array-returning
-	 * {@link getProviderProjectsForResources} in `{ values }` with no metadata, so providers without a
-	 * fan-out completeness signal (Linear, Trello) need no change; Jira overrides it to preserve the SDK's
-	 * per-resource completeness/failures.
-	 */
-	protected async getProviderProjectsForResourcesWithMetadata(
-		session: ProviderAuthenticationSession,
-		resources: T[],
-	): Promise<ProviderApiCollectionResult<T>> {
-		const projects = await this.getProviderProjectsForResources(session, resources);
-		return { values: projects ?? [] };
-	}
-
-	protected abstract getProviderProjectsForResources(
-		session: ProviderAuthenticationSession,
-		resources: T[],
-	): Promise<T[] | undefined>;
-
-	@trace()
-	async getIssuesForProject(
-		project: T,
-		options?: IssuesForProjectOptions,
-		connectionId?: string,
-	): Promise<IssueShape[] | undefined> {
-		return (await this.getIssuesForProjectResult(project, options, connectionId))?.value;
-	}
-
-	/**
-	 * Result-returning core of {@link getIssuesForProject}. Recovers thrown errors into `{ error }` so callers
-	 * (e.g. the ProviderBackend facade) can surface a per-provider warning instead of a silent empty read —
-	 * important for providers that throw on unsupported operations (e.g. Linear's not-implemented issue read).
-	 */
-	async getIssuesForProjectResult(
-		project: T,
-		options?: IssuesForProjectOptions,
-		connectionId?: string,
-	): Promise<IntegrationResult<IssueShape[] | undefined>> {
-		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;
-
-		try {
-			const issues = await this.getProviderIssuesForProject(session, project, options);
-			this.resetRequestExceptionCount('getIssuesForProject');
-			return { value: issues };
-		} catch (ex) {
-			this.handleProviderException('getIssuesForProject', ex, { connectionId: connectionId });
-			return { error: toError(ex) };
-		}
-	}
-
-	/**
-	 * Truncation-aware variant of {@link getIssuesForProjectResult}. A provider that drains a project's issues
-	 * with an internal page backstop (Jira/Linear) overrides {@link getProviderIssuesForProjectWithTruncation}
-	 * to report when that backstop was hit, so the facade can surface an incomplete project read instead of
-	 * publishing it as complete. The default reports `truncated: false`.
-	 */
-	async getIssuesForProjectWithTruncationResult(
-		project: T,
-		options?: IssuesForProjectOptions,
-		connectionId?: string,
-	): Promise<IntegrationResult<ProjectIssuesDrain | undefined>> {
-		const scope = getScopedLogger();
-		const session = await this.resolveReadSession(connectionId, scope);
-		if (session == null) return undefined;
-
-		try {
-			const result = await this.getProviderIssuesForProjectWithTruncation(session, project, options);
-			this.resetRequestExceptionCount('getIssuesForProject');
-			return { value: result };
-		} catch (ex) {
-			this.handleProviderException('getIssuesForProject', ex, { connectionId: connectionId });
-			return { error: toError(ex) };
-		}
-	}
-
-	protected abstract getProviderIssuesForProject(
-		session: ProviderAuthenticationSession,
-		project: T,
-		options?: IssuesForProjectOptions,
-	): Promise<IssueShape[] | undefined>;
-
-	/**
-	 * Truncation-aware core of {@link getProviderIssuesForProject}. The default wraps the plain read and
-	 * reports `truncated: false`; a provider whose per-project drain is capped by a page backstop overrides
-	 * this to report incompleteness. Optional metadata lets providers surface structured per-project failures
-	 * (e.g. a page-level auth rejection) without discarding the already-fetched prefix.
-	 */
-	protected async getProviderIssuesForProjectWithTruncation(
-		session: ProviderAuthenticationSession,
-		project: T,
-		options?: IssuesForProjectOptions,
-	): Promise<ProjectIssuesDrain | undefined> {
-		const values = await this.getProviderIssuesForProject(session, project, options);
-		if (values == null) return undefined;
-		return { values: values, truncated: false };
-	}
-}

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

@@ -1,18 +0,0 @@
-import type { PullRequestShape } from '../../../git/models/pullRequest.js';
-
-/**
- * One provider page of the filtered pull-request search, before the facade turns it into a neutral
- * paged result with warnings.
- *
- * `totalCount` is the provider-reported pre-ceiling facet count, not the number of rows that remain reachable
- * after a provider limit. It stays optional because absence means "not reported", never zero. Together with
- * `truncated` it lets the facade distinguish GitHub's quantified ceiling from another unusable continuation.
- */
-export type ProviderPullRequestSearchPage = {
-	values: PullRequestShape[];
-	truncated: boolean;
-	cursor?: string;
-	hasMore: boolean;
-	page: number;
-	totalCount?: number;
-};

package/src/plus/integrations/providerFilters.ts

@@ -1,36 +0,0 @@
-export { PullRequestFilter } from '../../git/models/pullRequest.js';
-
-export enum IssueFilter {
-	Author = 'author',
-	Assignee = 'assignee',
-	Mention = 'mention',
-}
-
-/**
- * The filtered issue search's criteria model, re-exported from the git models so it can be reached from here
- * alongside the two filter enums above.
- *
- * It lives in `@gitkraken/core-gitlens/git` rather than in this package because the provider implementations that translate it
- * to a query — the GitHub API client among them — sit BELOW this package in the dependency graph and can't import
- * from it. {@link IssueSearchRelationship} is a superset of {@link IssueFilter}: it adds the two user-independent
- * relationships (`any-assignee`, `unassigned`) that the user-relative "my issues" filters have no way to name.
- */
-export type {
-	IssueSearchCapabilities,
-	IssueSearchCriteria,
-	IssueSearchRelationship,
-	IssueSortField,
-	IssueSorting,
-} from '../../git/models/issue.js';
-
-/**
- * The filtered pull-request search criteria and its capability table. These live in `@gitkraken/core-gitlens/git` for the
- * same dependency-direction reason as the issue-search model above: provider API clients translate them below
- * this package and cannot import this facade.
- */
-export type {
-	PullRequestSearchCapabilities,
-	PullRequestSearchCriteria,
-	PullRequestSortField,
-	PullRequestSorting,
-} from '../../git/models/pullRequest.js';

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

@@ -1,38 +0,0 @@
-import type { Account as ProviderAccount } from '@gitkraken/provider-apis';
-import type { IssueMember } from '../../../git/models/issue.js';
-import type { PullRequestMember } from '../../../git/models/pullRequest.js';
-
-export function toProviderAccount(account: PullRequestMember | IssueMember): ProviderAccount {
-	return {
-		// Stays the provider id because the categorizer matches the viewer to a pull request's people by `id`,
-		// and every provider but GitHub already agrees on that namespace. Re-keying to the login breaks Azure,
-		// whose account `username` is a display name while its members' is a UPN — different namespaces.
-		id: account.id ?? null,
-		avatarUrl: account.avatarUrl ?? null,
-		name: account.name ?? null,
-		url: account.url ?? null,
-		// TODO: Implement these in our own model
-		email: '',
-		username: account.name ?? null,
-	};
-}
-
-export function fromProviderAccount(account: ProviderAccount | null): PullRequestMember | IssueMember {
-	return {
-		id: account?.id ?? '',
-		// An absent name stays absent. `'unknown'` was a display fallback invented in the provider layer, and a
-		// consumer couldn't tell it apart from a member genuinely named that — so it couldn't be undone where a
-		// name-shaped placeholder is wrong (rendering an avatar-only chip, or building an AI prompt, where
-		// `Assignees: unknown` reads as a real assignee). It also disagreed with {@link toIssueShape}, which
-		// collapsed the same absent name to `''` — same facade method, two fallbacks. Both now emit `undefined`.
-		name: account?.name ?? undefined,
-		username: account?.username ?? undefined,
-		avatarUrl: account?.avatarUrl ?? undefined,
-		// `url` is optional, so an absent one must be `undefined`, not `''`. `''` passes a `!= null` presence
-		// check and renders as a link to nowhere, and it disagreed with {@link toIssueShape} — which already
-		// collapses to `undefined` — even though BOTH mappers feed `listIssuesPage` (the repo-scoped path goes
-		// through `toIssueShape`, Azure's account-wide path through {@link fromProviderIssue}). Same facade
-		// method, two shapes. Matches {@link toProviderRepositoryShape}, which collapses every absent optional.
-		url: account?.url ?? undefined,
-	};
-}

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

@@ -1,69 +0,0 @@
-import type { Disposable } from '../../../utils/disposable.js';
-import { getScopedLogger } from '../../../utils/logger.scoped.js';
-import type { IntegrationServiceContext } from '../context.js';
-import type { AzureDevOpsApi } from './azure/azure.js';
-import type { BitbucketApi } from './bitbucket/bitbucket.js';
-import type { GitHubApi } from './github/github.js';
-import type { GitLabApi } from './gitlab/gitlab.js';
-
-/**
- * The per-provider API clients, owned and built by the package. `GitLabApi`/`BitbucketApi`/`AzureDevOpsApi`
- * live in the package; `GitHubApi` comes from `@gitkraken/core-gitlens/plus/git-github` (shared with the host's GitHub git
- * provider, which reads the manager's memoized instance via `manager.github`). `undefined` is tolerated for
- * offline/limited runtimes.
- */
-export interface ApiClients {
-	readonly github: Promise<GitHubApi | undefined>;
-	readonly gitlab: Promise<GitLabApi | undefined>;
-	readonly bitbucket: Promise<BitbucketApi | undefined>;
-	readonly azure: Promise<AzureDevOpsApi | undefined>;
-}
-
-/**
- * Lazily constructs + memoizes the API clients from the runtime context, pushing each to `disposables` for
- * teardown. Mirrors the lazy-chunked construction the host's `Container` did before the package took
- * ownership (the host used to build these and inject them back through the context — a pure round-trip).
- */
-export function createApiClients(ctx: IntegrationServiceContext, disposables: Disposable[]): ApiClients {
-	let github: Promise<GitHubApi | undefined> | undefined;
-	let gitlab: Promise<GitLabApi | undefined> | undefined;
-	let bitbucket: Promise<BitbucketApi | undefined> | undefined;
-	let azure: Promise<AzureDevOpsApi | undefined> | undefined;
-
-	const build = async <T extends Disposable>(load: () => Promise<T>): Promise<T | undefined> => {
-		const scope = getScopedLogger();
-		try {
-			const api = await load();
-			disposables.push(api);
-			return api;
-		} catch (ex) {
-			scope?.error(ex, 'Failed to construct integration API client');
-			return undefined;
-		}
-	};
-
-	return {
-		get github() {
-			return (github ??= build(async () =>
-				(await import(/* webpackChunkName: "integrations" */ './github/github.js')).createGitHubApi(ctx),
-			));
-		},
-		get gitlab() {
-			return (gitlab ??= build(async () =>
-				(await import(/* webpackChunkName: "integrations" */ './gitlab/gitlab.js')).createGitLabApi(ctx),
-			));
-		},
-		get bitbucket() {
-			return (bitbucket ??= build(async () =>
-				(await import(/* webpackChunkName: "integrations" */ './bitbucket/bitbucket.js')).createBitbucketApi(
-					ctx,
-				),
-			));
-		},
-		get azure() {
-			return (azure ??= build(async () =>
-				(await import(/* webpackChunkName: "integrations" */ './azure/azure.js')).createAzureDevOpsApi(ctx),
-			));
-		},
-	};
-}

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

@@ -1,71 +0,0 @@
-import type { IntegrationServiceContext } from '../context.js';
-
-/**
- * VS Code-free configuration for the package-owned provider API clients
- * ({@link GitLabApi}, {@link BitbucketApi}, {@link AzureDevOpsApi}).
- *
- * Mirrors the role {@link import('../../git-github/api/config.js').GitHubApiConfig}
- * plays for `GitHubApi`: instead of taking the full {@link IntegrationServiceContext},
- * a client takes only the narrow HTTP + callback surface it actually uses. The
- * `createIntegrationManager` path wires this from `ctx` (see the `create*Api`
- * factories); a token-scoped consumer builds it from a `fetch` plus a
- * `wrapForForcedInsecureSSL` (a pass-through is fine when not toggling SSL).
- *
- * Every field beyond `fetch`/`wrapForForcedInsecureSSL` is optional — a client omits
- * the call when unset, so a minimal consumer only supplies the two required members.
- */
-export interface ProviderApiConfig {
-	/** The `fetch` implementation to use for HTTP requests. */
-	fetch(input: string | URL, init?: RequestInit): Promise<Response>;
-
-	/**
-	 * Wraps an async operation so that TLS certificate validation is disabled when the
-	 * provider's `getIgnoreSSLErrors()` returns `'force'`. On the browser it's a no-op.
-	 */
-	wrapForForcedInsecureSSL<T>(ignoreSSLErrors: boolean | 'force', fn: () => Promise<T> | PromiseLike<T>): Promise<T>;
-
-	/**
-	 * Fires when the HTTP proxy configuration changes, so the client can reset its HTTP caches.
-	 * The factory filters the underlying config-change event down to the keys the client cares about.
-	 */
-	onConfigChanged?(listener: () => void): { dispose(): void };
-
-	/**
-	 * Ask the consumer to confirm reauthentication after an auth/permission failure (401/403). Resolves to
-	 * the user's choice; the client performs the actual `provider.reauthenticate()` when this is truthy.
-	 * Only GitLab wires this today.
-	 */
-	onReauthenticationRequired?(message: string): Promise<boolean | undefined>;
-
-	/** A non-fatal error to surface (debug display / notification). */
-	onError?(message: string): void;
-
-	/** The provider API returned a server-side (500-level) error. */
-	onRequestFailed?(message: string): void;
-
-	/** The provider API request timed out; `providerName` names the integration for the message. */
-	onRequestTimedOut?(providerName: string): void;
-
-	/** Bitbucket's "Pull Requests for Commit" app isn't installed; `revLink` opens the install page. */
-	onBitbucketCommitLinksAppMissing?(revLink: string): void;
-}
-
-/**
- * The `ctx` → {@link ProviderApiConfig} mapping shared by every `create*Api` factory. Each provider
- * spreads this and layers on its own deltas (GitLab also resets on `remotes` + wires reauth/timeout;
- * Bitbucket adds the commit-links-app hook). Resets HTTP caches on HTTP proxy config changes.
- */
-export function baseProviderApiConfig(ctx: IntegrationServiceContext): ProviderApiConfig {
-	return {
-		fetch: ctx.http.fetch.bind(ctx.http),
-		wrapForForcedInsecureSSL: ctx.http.wrapForForcedInsecureSSL.bind(ctx.http),
-		onConfigChanged: listener =>
-			ctx.config.onDidChange(e => {
-				if (e.httpProxy) {
-					listener();
-				}
-			}),
-		onError: message => ctx.hooks?.ui?.onError?.(message),
-		onRequestFailed: message => ctx.hooks?.ui?.onRequestFailed?.(message),
-	};
-}