folderRepositoryManager.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import * as nodePath from 'path';
import { bulkhead } from 'cockatiel';
import * as vscode from 'vscode';
import { OctokitCommon } from './common';
import { ConflictModel } from './conflictGuide';
import { ConflictResolutionCoordinator } from './conflictResolutionCoordinator';
import { Conflict, ConflictResolutionModel } from './conflictResolutionModel';
import { CredentialStore } from './credentials';
import { CopilotWorkingStatus, GitHubRepository, isRateLimitError, ItemsData, PULL_REQUEST_PAGE_SIZE, PullRequestChangeEvent, PullRequestData, TeamReviewerRefreshKind, ViewerPermission } from './githubRepository';
import { PullRequestState } from './graphql';
import { IAccount, ILabel, IMilestone, IProject, IPullRequestsPagingOptions, Issue, ITeam, MergeMethod, PRType, PullRequestMergeability, RepoAccessAndMergeMethods, User } from './interface';
import { IssueModel } from './issueModel';
import { PullRequestGitHelper, PullRequestMetadata } from './pullRequestGitHelper';
import { IResolvedPullRequestModel, PullRequestModel } from './pullRequestModel';
import {
	convertRESTIssueToRawPullRequest,
	convertRESTPullRequestToRawPullRequest,
	getOverrideBranch,
	getPRFetchQuery,
	getStateFromQuery,
	loginComparator,
	teamComparator,
	variableSubstitution,
} from './utils';
import type { Branch, Commit, Repository, UpstreamRef } from '../api/api';
import { GitApiImpl, GitErrorCodes } from '../api/api1';
import { GitHubManager } from '../authentication/githubServer';
import { AuthProvider, GitHubServerType } from '../common/authentication';
import { commands, contexts } from '../common/executeCommands';
import { InMemFileChange, SlimFileChange } from '../common/file';
import { findLocalRepoRemoteFromGitHubRef } from '../common/githubRef';
import { stripCoAuthoredByTrailers, unwrapCommitMessageBody } from '../common/gitUtils';
import { Disposable, disposeAll } from '../common/lifecycle';
import Logger from '../common/logger';
import { Protocol, ProtocolType } from '../common/protocol';
import { GitHubRemote, parseRemote, parseRepositoryRemotesAsync, Remote } from '../common/remote';
import {
	ALLOW_FETCH,
	AUTO_STASH,
	CHAT_SETTINGS_NAMESPACE,
	CHECKOUT_DEFAULT_BRANCH,
	CHECKOUT_PULL_REQUEST_BASE_BRANCH,
	DEFAULT_DELETION_METHOD,
	DISABLE_AI_FEATURES,
	GIT,
	POST_DONE,
	PR_SETTINGS_NAMESPACE,
	PULL_BEFORE_CHECKOUT,
	PULL_BRANCH,
	REMOTES,
	SELECT_WORKTREE,
	UPSTREAM_REMOTE,
} from '../common/settingKeys';
import { ITelemetry } from '../common/telemetry';
import { EventType } from '../common/timelineEvent';
import { Schemes } from '../common/uri';
import { AsyncPredicate, batchPromiseAll, compareIgnoreCase, formatError, Predicate } from '../common/utils';
import { PULL_REQUEST_OVERVIEW_VIEW_TYPE } from '../common/webview';
import { BRANCHES_ASSOCIATED_WITH_PRS, LAST_USED_EMAIL, NEVER_SHOW_PULL_NOTIFICATION, REPO_KEYS, ReposState } from '../extensionState';
import { git } from '../gitProviders/gitCommands';
import { IThemeWatcher } from '../themeWatcher';
import { CreatePullRequestHelper } from '../view/createPullRequestHelper';

async function createConflictResolutionModel(pullRequest: PullRequestModel): Promise<ConflictResolutionModel | undefined> {
	const head = pullRequest.head;
	if (!head) {
		throw new Error('No head found for pull request');
	}
	const baseCommitSha = await pullRequest.getLatestBaseCommitSha();
	const prBaseOwner = pullRequest.base.owner;
	const prHeadOwner = head.owner;
	const prHeadRef = head.ref;
	const repositoryName = (await pullRequest.githubRepository.ensure()).remote.repositoryName;
	const potentialMergeConflicts: Conflict[] = [];
	if (pullRequest.item.mergeable === PullRequestMergeability.Conflict) {
		const mergeBaseIntoPrCompareData = await pullRequest.compareBaseBranchForMerge(prHeadOwner, prHeadRef, prBaseOwner, baseCommitSha);
		if ((pullRequest.item.mergeable === PullRequestMergeability.Conflict) && (mergeBaseIntoPrCompareData.length >= 300)) {
			// API limitation: it only returns the first 300 files
			return undefined;
		}

		const previousFilenames: Map<string, SlimFileChange | InMemFileChange> = new Map();
		// We must also check all the previous file names of the files in the PR. Assemble a map with this info
		for (const fileChange of pullRequest.fileChanges.values()) {
			if (fileChange.previousFileName) {
				previousFilenames.set(fileChange.previousFileName, fileChange);
			}
		}
		const knownConflicts = new Set<string>(pullRequest.conflicts);
		for (const mergeFile of mergeBaseIntoPrCompareData) {
			const fileChange = pullRequest.fileChanges.get(mergeFile.filename) ?? previousFilenames.get(mergeFile.filename);
			if (fileChange && (knownConflicts.size === 0 || knownConflicts.has(fileChange.fileName))) {
				const prHeadFilePath = fileChange.fileName;
				let contentsConflict = false;
				let filePathConflict = false;
				let modeConflict = false;
				if (mergeFile.status === 'modified') {
					contentsConflict = true;
				}
				if (mergeFile.previous_filename || fileChange.previousFileName) {
					filePathConflict = true;
				}
				potentialMergeConflicts.push({ prHeadFilePath, contentsConflict, filePathConflict, modeConflict });
			}
		}
	}
	return new ConflictResolutionModel(potentialMergeConflicts, repositoryName, prBaseOwner, baseCommitSha, prHeadOwner, prHeadRef,
		pullRequest.base.ref, pullRequest.mergeBase!);
}

interface PageInformation {
	pullRequestPage: number;
	hasMorePages: boolean | null;
}

export interface ItemsResponseResult<T> {
	items: T[];
	hasMorePages: boolean;
	hasUnsearchedRepositories: boolean;
	totalCount?: number;
}

export class NoGitHubReposError extends Error {
	constructor(public readonly repository: Repository) {
		super();
	}

	override get message() {
		return vscode.l10n.t('{0} has no GitHub remotes', this.repository.rootUri.toString());
	}
}

export class DetachedHeadError extends Error {
	constructor(public readonly repository: Repository) {
		super();
	}

	override get message() {
		return vscode.l10n.t('{0} has a detached HEAD (create a branch first)', this.repository.rootUri.toString());
	}
}

export class BadUpstreamError extends Error {
	constructor(public readonly branchName: string, public readonly upstreamRef: UpstreamRef, public readonly problem: string) {
		super();
	}

	override get message() {
		const {
			upstreamRef: { remote, name },
			branchName,
			problem,
		} = this;
		return vscode.l10n.t('The upstream ref {0} for branch {1} {2}.', `${remote}/${name}`, branchName, problem);
	}
}

export const ReposManagerStateContext: string = 'ReposManagerStateContext';

export enum ReposManagerState {
	Initializing = 'Initializing',
	NeedsAuthentication = 'NeedsAuthentication',
	RepositoriesLoaded = 'RepositoriesLoaded',
}

export interface PullRequestDefaults {
	owner: string;
	repo: string;
	base: string;
}

enum PagedDataType {
	PullRequest,
	IssueSearch,
}

const CACHED_TEMPLATE_BODY = 'templateBody';

export class FolderRepositoryManager extends Disposable {
	static ID = 'FolderRepositoryManager';

	private _state: ReposManagerState = ReposManagerState.Initializing;
	private _activePullRequest?: PullRequestModel;
	private _activeIssue?: IssueModel;
	private _githubRepositories: GitHubRepository[];
	private _allGitHubRemotes: GitHubRemote[] = [];
	private _mentionableUsers?: { [key: string]: IAccount[] };
	private _fetchMentionableUsersPromise?: Promise<{ [key: string]: IAccount[] }>;
	private _assignableUsers?: { [key: string]: IAccount[] };
	private _teamReviewers?: { [key: string]: ITeam[] };
	private _fetchAssignableUsersPromise?: Promise<{ [key: string]: IAccount[] }>;
	private _fetchTeamReviewersPromise?: Promise<{ [key: string]: ITeam[] }>;
	private _gitBlameCache: { [key: string]: string } = {};
	private _githubManager: GitHubManager;
	private _repositoryPageInformation: Map<string, PageInformation> = new Map<string, PageInformation>();
	private _addedUpstreamCount: number = 0;

	private _onDidChangeActivePullRequest = this._register(new vscode.EventEmitter<{ new: PullRequestModel | undefined, old: PullRequestModel | undefined }>());
	readonly onDidChangeActivePullRequest: vscode.Event<{ new: PullRequestModel | undefined, old: PullRequestModel | undefined }> = this._onDidChangeActivePullRequest.event;
	private _onDidChangeActiveIssue = this._register(new vscode.EventEmitter<void>());
	readonly onDidChangeActiveIssue: vscode.Event<void> = this._onDidChangeActiveIssue.event;

	private _onDidLoadRepositories = this._register(new vscode.EventEmitter<ReposManagerState>());
	readonly onDidLoadRepositories: vscode.Event<ReposManagerState> = this._onDidLoadRepositories.event;

	private _onDidChangeRepositories = this._register(new vscode.EventEmitter<{ added: boolean }>());
	readonly onDidChangeRepositories: vscode.Event<{ added: boolean }> = this._onDidChangeRepositories.event;

	private _onDidChangeAssignableUsers = this._register(new vscode.EventEmitter<IAccount[]>());
	readonly onDidChangeAssignableUsers: vscode.Event<IAccount[]> = this._onDidChangeAssignableUsers.event;

	private _onDidChangeGithubRepositories = this._register(new vscode.EventEmitter<GitHubRepository[]>());
	readonly onDidChangeGithubRepositories: vscode.Event<GitHubRepository[]> = this._onDidChangeGithubRepositories.event;

	private _onDidChangePullRequestsEvents: vscode.Disposable[] = [];
	private readonly _onDidChangeAnyPullRequests = this._register(new vscode.EventEmitter<PullRequestChangeEvent[]>());
	readonly onDidChangeAnyPullRequests: vscode.Event<PullRequestChangeEvent[]> = this._onDidChangeAnyPullRequests.event;
	private readonly _onDidAddPullRequest = this._register(new vscode.EventEmitter<IssueModel>());
	readonly onDidAddPullRequest: vscode.Event<IssueModel> = this._onDidAddPullRequest.event;

	private _onDidDispose = this._register(new vscode.EventEmitter<void>());
	readonly onDidDispose: vscode.Event<void> = this._onDidDispose.event;

	private _sessionIgnoredRemoteNames: Set<string> = new Set();
	private _inaccessibleRepos: Set<string> = new Set();

	constructor(
		private readonly _id: number,
		public readonly context: vscode.ExtensionContext,
		private _repository: Repository,
		public readonly telemetry: ITelemetry,
		private readonly _git: GitApiImpl,
		private readonly _credentialStore: CredentialStore,
		public readonly createPullRequestHelper: CreatePullRequestHelper,
		public readonly themeWatcher: IThemeWatcher
	) {
		super();
		this._githubRepositories = [];
		this._githubManager = new GitHubManager(this.telemetry);

		this._register(
			vscode.workspace.onDidChangeConfiguration(async e => {
				if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${REMOTES}`)) {
					await this.updateRepositories();
				}
			}),
		);

		this._register(_credentialStore.onDidInitialize(() => this.updateRepositories()));
		this._register({ dispose: () => disposeAll(this._onDidChangePullRequestsEvents) });

		this.cleanStoredRepoState();
	}

	private cleanStoredRepoState() {
		const deleteDate: number = new Date().valueOf() - 30 /*days*/ * 86400000 /*milliseconds in a day*/;
		const reposState = this.context.globalState.get<ReposState>(REPO_KEYS);
		if (reposState?.repos) {
			let keysChanged = false;
			Object.keys(reposState.repos).forEach(repo => {
				const repoState = reposState.repos[repo];
				if ((repoState.stateModifiedTime ?? 0) < deleteDate) {
					keysChanged = true;
					delete reposState.repos[repo];
				}
			});
			if (keysChanged) {
				this.context.globalState.update(REPO_KEYS, reposState);
			}
		}
	}

	private get id(): string {
		return `${FolderRepositoryManager.ID}+${this._id}`;
	}

	get gitHubRepositories(): GitHubRepository[] {
		return this._githubRepositories;
	}

	public async computeAllUnknownRemotes(): Promise<Remote[]> {
		const remotes = await parseRepositoryRemotesAsync(this.repository);
		const potentialRemotes = remotes.filter(remote => remote.host);
		const serverTypes = await Promise.all(
			potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),
		).catch(e => {
			Logger.error(`Resolving GitHub remotes failed: ${e}`, this.id);
			vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));
			return [];
		});
		const unknownRemotes: Remote[] = [];
		let i = 0;
		for (const potentialRemote of potentialRemotes) {
			if (serverTypes[i] === GitHubServerType.None) {
				unknownRemotes.push(potentialRemote);
			}
			i++;
		}
		return unknownRemotes;
	}

	public async computeAllGitHubRemotes(): Promise<GitHubRemote[]> {
		const remotes = await parseRepositoryRemotesAsync(this.repository);
		const potentialRemotes = remotes.filter(remote => remote.host);
		const serverTypes = await Promise.all(
			potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),
		).catch(e => {
			Logger.error(`Resolving GitHub remotes failed: ${e}`, this.id);
			vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));
			return [];
		});
		const githubRemotes: GitHubRemote[] = [];
		let i = 0;
		for (const potentialRemote of potentialRemotes) {
			if (serverTypes[i] !== GitHubServerType.None) {
				githubRemotes.push(GitHubRemote.remoteAsGitHub(potentialRemote, serverTypes[i]));
			}
			i++;
		}
		return githubRemotes;
	}

	public async getActiveGitHubRemotes(allGitHubRemotes: GitHubRemote[]): Promise<GitHubRemote[]> {
		const remotesSetting = vscode.workspace.getConfiguration(PR_SETTINGS_NAMESPACE).get<string[]>(REMOTES);

		if (!remotesSetting) {
			Logger.error(`Unable to read remotes setting`, this.id);
			return Promise.resolve([]);
		}

		const missingRemotes = remotesSetting.filter(remote => {
			return !allGitHubRemotes.some(repo => repo.remoteName === remote);
		});

		if (missingRemotes.length === remotesSetting.length) {
			Logger.warn(`No remotes found. The following remotes are missing: ${missingRemotes.join(', ')}`);
		} else {
			Logger.debug(`Not all remotes found. The following remotes are missing: ${missingRemotes.join(', ')}`, this.id);
		}

		Logger.debug(`Displaying configured remotes: ${remotesSetting.join(', ')}`, this.id);

		return remotesSetting
			.map(remote => allGitHubRemotes.find(repo => repo.remoteName === remote))
			.filter((repo: GitHubRemote | undefined): repo is GitHubRemote => !!repo && !this._sessionIgnoredRemoteNames.has(repo.remoteName));
	}

	get activeIssue(): IssueModel | undefined {
		return this._activeIssue;
	}

	set activeIssue(issue: IssueModel | undefined) {
		this._activeIssue = issue;
		this._onDidChangeActiveIssue.fire();
	}

	get activePullRequest(): PullRequestModel | undefined {
		return this._activePullRequest;
	}

	set activePullRequest(pullRequest: PullRequestModel | undefined) {
		if (pullRequest === this._activePullRequest) {
			return;
		}
		const oldPR = this._activePullRequest;
		if (this._activePullRequest) {
			this._activePullRequest.isActive = false;
		}

		if (pullRequest) {
			pullRequest.isActive = true;
			pullRequest.githubRepository.commentsHandler?.unregisterCommentController(pullRequest.number);
		}

		this._activePullRequest = pullRequest;
		this._onDidChangeActivePullRequest.fire({ old: oldPR, new: pullRequest });
	}

	get repository(): Repository {
		return this._repository;
	}

	set repository(repository: Repository) {
		this._repository = repository;
	}

	get credentialStore(): CredentialStore {
		return this._credentialStore;
	}

	/**
	 * Using these contexts is fragile in a multi-root workspace where multiple PRs are checked out.
	 * If you have two active PRs that have the same file path relative to their rootdir, then these context can get confused.
	 */
	public setFileViewedContext() {
		const states = this.activePullRequest?.getViewedFileStates();
		if (states) {
			commands.setContext(contexts.VIEWED_FILES, Array.from(states.viewed));
			commands.setContext(contexts.UNVIEWED_FILES, Array.from(states.unviewed));
		} else {
			this.clearFileViewedContext();
		}
	}

	private clearFileViewedContext() {
		commands.setContext(contexts.VIEWED_FILES, []);
		commands.setContext(contexts.UNVIEWED_FILES, []);
	}

	public async loginAndUpdate() {
		if (!this._credentialStore.isAnyAuthenticated()) {
			const waitForRepos = new Promise<void>(c => {
				const onReposChange = this.onDidChangeRepositories(() => {
					onReposChange.dispose();
					c();
				});
			});
			await this._credentialStore.login(AuthProvider.github);
			await waitForRepos;
		}
	}

	private async getActiveRemotes(): Promise<GitHubRemote[]> {
		this._allGitHubRemotes = await this.computeAllGitHubRemotes();
		const activeRemotes = await this.getActiveGitHubRemotes(this._allGitHubRemotes);

		if (activeRemotes.length) {
			await vscode.commands.executeCommand('setContext', 'github:hasGitHubRemotes', true);
			Logger.appendLine(`Found GitHub remote for folder ${this.repository.rootUri.fsPath}`, this.id);
			if (this._allGitHubRemotes.length > 1) {
				await vscode.commands.executeCommand('setContext', 'github:hasMultipleGitHubRemotes', true);
			}
		} else {
			Logger.appendLine(`No GitHub remotes found for folder ${this.repository.rootUri.fsPath}`, this.id);
		}

		return activeRemotes;
	}

	private _updatingRepositories: Promise<boolean> | undefined;
	async updateRepositories(silent: boolean = false): Promise<boolean> {
		if (this._updatingRepositories) {
			await this._updatingRepositories;
		}
		this._updatingRepositories = this.doUpdateRepositories(silent);
		return this._updatingRepositories;
	}

	private checkForAuthMatch(activeRemotes: GitHubRemote[]): boolean {
		// Check that our auth matches the remote.
		let dotComCount = 0;
		let enterpriseCount = 0;
		for (const remote of activeRemotes) {
			if (remote.githubServerType === GitHubServerType.GitHubDotCom) {
				dotComCount++;
			} else if (remote.githubServerType === GitHubServerType.Enterprise) {
				enterpriseCount++;
			}
		}

		let isAuthenticated = this._credentialStore.isAuthenticated(AuthProvider.github) || this._credentialStore.isAuthenticated(AuthProvider.githubEnterprise);
		if ((dotComCount > 0) && this._credentialStore.isAuthenticated(AuthProvider.github)) {
			// good
		} else if ((enterpriseCount > 0) && this._credentialStore.isAuthenticated(AuthProvider.githubEnterprise)) {
			// also good
		} else if (isAuthenticated && ((dotComCount > 0) || (enterpriseCount > 0))) {
			// Not good. We have a mismatch between auth type and server type.
			isAuthenticated = false;
		}
		vscode.commands.executeCommand('setContext', 'github:authenticated', isAuthenticated);
		return isAuthenticated;
	}

	get state(): ReposManagerState {
		return this._state;
	}

	private set state(state: ReposManagerState) {
		if (state !== this._state) {
			this._state = state;
			this._onDidLoadRepositories.fire(state);
		}
	}

	private async doUpdateRepositories(silent: boolean): Promise<boolean> {
		if (this._git.state === 'uninitialized') {
			Logger.appendLine('Cannot updates repositories as git is uninitialized', this.id);

			return false;
		}

		const activeRemotes = await this.getActiveRemotes();
		const isAuthenticated = this.checkForAuthMatch(activeRemotes);
		if (this.credentialStore.isAnyAuthenticated() && (activeRemotes.length === 0)) {
			const allUnknownRemotes = await this.computeAllUnknownRemotes();
			const areAllNeverGitHub = allUnknownRemotes.every(remote => GitHubManager.isNeverGitHub(vscode.Uri.parse(remote.normalizedHost).authority));
			if ((allUnknownRemotes.length > 0) && areAllNeverGitHub) {
				Logger.appendLine('No GitHub remotes found and all remotes are marked as never GitHub.', this.id);
				this.state = ReposManagerState.RepositoriesLoaded;
				return true;
			}
		}
		const repositories: GitHubRepository[] = [];
		const resolveRemotePromises: Promise<boolean>[] = [];
		const oldRepositories: GitHubRepository[] = [];
		this._githubRepositories.forEach(repo => oldRepositories.push(repo));

		const authenticatedRemotes = activeRemotes.filter(remote => this._credentialStore.isAuthenticated(remote.authProviderId));
		for (const remote of authenticatedRemotes) {
			const repository = await this.createGitHubRepository(remote, this._credentialStore);
			resolveRemotePromises.push(repository.resolveRemote());
			repositories.push(repository);
		}

		const cleanUpMissingSaml = async (missingSaml: GitHubRepository[]) => {
			for (const missing of missingSaml) {
				this._sessionIgnoredRemoteNames.add(missing.remote.remoteName);
				this.removeGitHubRepository(missing.remote);
				const index = repositories.indexOf(missing);
				if (index > -1) {
					repositories.splice(index, 1);
				}
			}
		};

		return Promise.all(resolveRemotePromises).then(async (remoteResults: boolean[]) => {
			const missingSaml: GitHubRepository[] = [];
			for (let i = 0; i < remoteResults.length; i++) {
				if (!remoteResults[i]) {
					missingSaml.push(repositories[i]);
				}
			}
			if (missingSaml.length > 0) {
				const result = await this._credentialStore.showSamlMessageAndAuth(missingSaml.map(repo => repo.remote.owner));
				// Make a test call to see if the user has SAML enabled.
				const samlTest = result.canceled ? [] : await Promise.all(missingSaml.map(repo => repo.resolveRemote()));
				const stillMissing = result.canceled ? missingSaml : samlTest.map((result, index) => !result ? missingSaml[index] : undefined).filter((repo): repo is GitHubRepository => !!repo);
				// Make a test call to see if the user has SAML enabled.
				if (stillMissing.length > 0) {
					if (stillMissing.length === repositories.length) {
						await vscode.window.showErrorMessage(vscode.l10n.t('SAML access was not provided. GitHub Pull Requests will not work.'), { modal: true });
						this.dispose();
						return true;
					}
					await vscode.window.showErrorMessage(vscode.l10n.t('SAML access was not provided. Some GitHub repositories will not be available.'), { modal: true });
					cleanUpMissingSaml(stillMissing);
				}
			}

			disposeAll(this._onDidChangePullRequestsEvents);
			this._githubRepositories = repositories;
			for (const repo of this._githubRepositories) {
				this._onDidChangePullRequestsEvents.push(repo.onDidChangePullRequests(e => this._onDidChangeAnyPullRequests.fire(e)));
				this._onDidChangePullRequestsEvents.push(repo.onDidAddPullRequest(e => this._onDidAddPullRequest.fire(e)));
			}
			oldRepositories.filter(old => this._githubRepositories.indexOf(old) < 0).forEach(repo => repo.dispose());

			const repositoriesAdded =
				oldRepositories.length !== this._githubRepositories.length ?
					this.gitHubRepositories.filter(repo =>
						!oldRepositories.some(oldRepo => oldRepo.remote.equals(repo.remote)),
					) : [];

			if (repositoriesAdded.length > 0) {
				this._onDidChangeGithubRepositories.fire(this._githubRepositories);
			}

			if (this._githubRepositories.length && repositoriesAdded.length > 0) {
				if (await this.checkIfMissingUpstream()) {
					this.updateRepositories(silent);
					return true;
				}
			}

			if (this.activePullRequest) {
				this.getMentionableUsers(repositoriesAdded.length > 0);
			}

			this.getAssignableUsers(repositoriesAdded.length > 0);
			if (isAuthenticated && activeRemotes.length) {
				this.state = ReposManagerState.RepositoriesLoaded;
				// On first activation, associate local branches with PRs
				// Do this asynchronously to not block the main flow
				this.associateLocalBranchesWithPRsOnFirstActivation().catch(e => {
					Logger.error(`Failed to associate branches with PRs: ${e}`, this.id);
				});
			} else if (!isAuthenticated) {
				this.state = ReposManagerState.NeedsAuthentication;
			}
			if (!silent) {
				this._onDidChangeRepositories.fire({ added: repositoriesAdded.length > 0 });
			}
			return true;
		});
	}

	private async checkIfMissingUpstream(): Promise<boolean> {
		try {
			const origin = await this.getOrigin();
			const metadata = await origin.getMetadata();
			const configuration = vscode.workspace.getConfiguration(PR_SETTINGS_NAMESPACE);
			if (metadata.fork && metadata.parent && (configuration.get<'add' | 'never'>(UPSTREAM_REMOTE, 'add') === 'add')) {
				const parentUrl = new Protocol(metadata.parent.git_url);
				const missingParentRemote = !this._githubRepositories.some(
					repo =>
						(compareIgnoreCase(repo.remote.owner, parentUrl.owner) === 0) &&
						(compareIgnoreCase(repo.remote.repositoryName, parentUrl.repositoryName) === 0),
				);

				if (missingParentRemote) {
					const upstreamAvailable = !this.repository.state.remotes.some(remote => remote.name === 'upstream');
					const remoteName = upstreamAvailable ? 'upstream' : metadata.parent.owner?.login;
					if (remoteName) {
						// check the remotes to see what protocol is being used
						const isSSH = this.gitHubRepositories[0].remote.gitProtocol.type === ProtocolType.SSH;
						if (isSSH) {
							await this.repository.addRemote(remoteName, metadata.parent.ssh_url);
						} else {
							await this.repository.addRemote(remoteName, metadata.parent.clone_url);
						}
						this._addedUpstreamCount++;
						if (this._addedUpstreamCount > 1) {
							// We've already added this remote, which means the user likely removed it. Let the user know they can disable this feature.
							const neverOption = vscode.l10n.t('Set to `never`');
							vscode.window.showInformationMessage(vscode.l10n.t('An `upstream` remote has been added for this repository. You can disable this feature by setting `githubPullRequests.upstreamRemote` to `never`.'), neverOption)
								.then(choice => {
									if (choice === neverOption) {
										configuration.update(UPSTREAM_REMOTE, 'never', vscode.ConfigurationTarget.Global);
									}
								});
						}
						return true;
					}
				}
			}
		} catch (e) {
			Logger.appendLine(`Missing upstream check failed: ${e}`, this.id);
			// ignore
		}
		return false;
	}

	getAllAssignableUsers(): IAccount[] | undefined {
		if (this._assignableUsers) {
			const allAssignableUsers: IAccount[] = [];
			Object.keys(this._assignableUsers).forEach(k => {
				allAssignableUsers.push(...this._assignableUsers![k]);
			});

			return allAssignableUsers;
		}

		return undefined;
	}

	private async getCachedFromGlobalState<T>(userKind: 'assignableUsers' | 'teamReviewers' | 'mentionableUsers' | 'orgProjects'): Promise<{ [key: string]: T[] } | undefined> {
		Logger.appendLine(`Trying to use globalState for ${userKind}.`, this.id);

		const usersCacheLocation = vscode.Uri.joinPath(this.context.globalStorageUri, userKind);
		let usersCacheExists;
		try {
			usersCacheExists = await vscode.workspace.fs.stat(usersCacheLocation);
		} catch (e) {
			// file doesn't exit
		}
		if (!usersCacheExists) {
			Logger.appendLine(`GlobalState does not exist for ${userKind}.`, this.id);
			return undefined;
		}

		const cache: { [key: string]: T[] } = {};
		const hasAllRepos = (await Promise.all(this._githubRepositories.map(async (repo) => {
			const key = `${repo.remote.owner}/${repo.remote.repositoryName}.json`;
			const repoSpecificFile = vscode.Uri.joinPath(usersCacheLocation, key);
			let repoSpecificCache;
			let cacheAsJson;
			try {
				repoSpecificCache = await vscode.workspace.fs.readFile(repoSpecificFile);
				cacheAsJson = JSON.parse(repoSpecificCache.toString());
			} catch (e) {
				if (e instanceof Error && e.message.includes('Unexpected non-whitespace character after JSON')) {
					Logger.error(`Error parsing ${userKind} cache for ${repo.remote.remoteName}.`, this.id);
				}
				// file doesn't exist
			}
			if (repoSpecificCache && repoSpecificCache.toString()) {
				cache[repo.remote.remoteName] = cacheAsJson ?? [];
				return true;
			}
		}))).every(value => value);
		if (hasAllRepos) {
			Logger.appendLine(`Using globalState ${userKind} for ${Object.keys(cache).length}.`, this.id);
			return cache;
		}

		Logger.appendLine(`No globalState for ${userKind}.`, this.id);
		return undefined;
	}

	private async saveInGlobalState<T>(userKind: 'assignableUsers' | 'teamReviewers' | 'mentionableUsers' | 'orgProjects', cache: { [key: string]: T[] }): Promise<void> {
		const cacheLocation = vscode.Uri.joinPath(this.context.globalStorageUri, userKind);
		await Promise.all(this._githubRepositories.map(async (repo) => {
			const key = `${repo.remote.owner}/${repo.remote.repositoryName}.json`;
			const repoSpecificFile = vscode.Uri.joinPath(cacheLocation, key);
			await vscode.workspace.fs.writeFile(repoSpecificFile, new TextEncoder().encode(JSON.stringify(cache[repo.remote.remoteName])));
		}));
	}

	private createFetchMentionableUsersPromise(): Promise<{ [key: string]: IAccount[] }> {
		const cache: { [key: string]: IAccount[] } = {};
		return new Promise<{ [key: string]: IAccount[] }>(resolve => {
			const promises = this._githubRepositories.map(async githubRepository => {
				const data = await githubRepository.getMentionableUsers();
				cache[githubRepository.remote.remoteName] = data;
				return;
			});

			Promise.all(promises).then(() => {
				this._mentionableUsers = cache;
				this._fetchMentionableUsersPromise = undefined;
				this.saveInGlobalState('mentionableUsers', cache)
					.then(() => resolve(cache));
			});
		});
	}

	async getMentionableUsers(clearCache?: boolean): Promise<{ [key: string]: IAccount[] }> {
		if (clearCache) {
			delete this._mentionableUsers;
		}

		if (this._mentionableUsers) {
			Logger.appendLine('Using in-memory cached mentionable users.', this.id);
			return this._mentionableUsers;
		}

		const globalStateMentionableUsers = await this.getCachedFromGlobalState<IAccount>('mentionableUsers');

		if (!this._fetchMentionableUsersPromise) {
			this._fetchMentionableUsersPromise = this.createFetchMentionableUsersPromise();
			return globalStateMentionableUsers ?? this._fetchMentionableUsersPromise;
		}

		return globalStateMentionableUsers ?? this._fetchMentionableUsersPromise;
	}

	async getAssignableUsers(clearCache?: boolean): Promise<{ [key: string]: IAccount[] }> {
		if (clearCache) {
			delete this._assignableUsers;
		}

		if (this._assignableUsers) {
			Logger.appendLine('Using in-memory cached assignable users.', this.id);
			return this._assignableUsers;
		}

		const globalStateAssignableUsers = await this.getCachedFromGlobalState<IAccount>('assignableUsers');

		if (!this._fetchAssignableUsersPromise) {
			const cache: { [key: string]: IAccount[] } = {};
			const allAssignableUsers: IAccount[] = [];
			this._fetchAssignableUsersPromise = new Promise(resolve => {
				const promises = this._githubRepositories.map(async githubRepository => {
					const data = await githubRepository.getAssignableUsers();
					cache[githubRepository.remote.remoteName] = data.sort(loginComparator);
					allAssignableUsers.push(...data);
					return;
				});

				Promise.all(promises).then(() => {
					this._assignableUsers = cache;
					this._fetchAssignableUsersPromise = undefined;
					this.saveInGlobalState('assignableUsers', cache);
					resolve(cache);
					this._onDidChangeAssignableUsers.fire(allAssignableUsers);
				});
			});
			return globalStateAssignableUsers ?? this._fetchAssignableUsersPromise;
		}

		return globalStateAssignableUsers ?? this._fetchAssignableUsersPromise;
	}

	async getTeamReviewers(refreshKind: TeamReviewerRefreshKind): Promise<{ [key: string]: ITeam[] }> {
		if (refreshKind === TeamReviewerRefreshKind.Force) {
			delete this._teamReviewers;
		}

		if (this._teamReviewers) {
			Logger.appendLine('Using in-memory cached team reviewers.', this.id);
			return this._teamReviewers;
		}

		const globalStateTeamReviewers = (refreshKind === TeamReviewerRefreshKind.Force) ? undefined : await this.getCachedFromGlobalState<ITeam>('teamReviewers');
		if (globalStateTeamReviewers) {
			this._teamReviewers = globalStateTeamReviewers;
			return globalStateTeamReviewers || {};
		}

		if (!this._fetchTeamReviewersPromise) {
			const cache: { [key: string]: ITeam[] } = {};
			return (this._fetchTeamReviewersPromise = new Promise(async (resolve) => {
				// Keep track of the org teams we have already gotten so we don't make duplicate calls
				const orgTeams: Map<string, (ITeam & { repositoryNames: string[] })[]> = new Map();
				// Go through one github repo at a time so that we don't make overlapping auth calls
				for (const githubRepository of this._githubRepositories) {
					if (!orgTeams.has(githubRepository.remote.owner)) {
						try {
							const data = await githubRepository.getOrgTeams(refreshKind);
							orgTeams.set(githubRepository.remote.owner, data);
						} catch (e) {
							break;
						}
					}
					const allTeamsForOrg = orgTeams.get(githubRepository.remote.owner) ?? [];
					cache[githubRepository.remote.remoteName] = allTeamsForOrg.filter(team => team.repositoryNames.includes(githubRepository.remote.repositoryName)).sort(teamComparator);
				}

				this._teamReviewers = cache;
				this._fetchTeamReviewersPromise = undefined;
				this.saveInGlobalState('teamReviewers', cache);
				resolve(cache);
			}));
		}

		return this._fetchTeamReviewersPromise;
	}

	private createFetchOrgProjectsPromise(): Promise<{ [key: string]: IProject[] }> {
		const cache: { [key: string]: IProject[] } = {};
		return new Promise<{ [key: string]: IProject[] }>(async resolve => {
			// Keep track of the org teams we have already gotten so we don't make duplicate calls
			const orgProjects: Map<string, IProject[]> = new Map();
			// Go through one github repo at a time so that we don't make overlapping auth calls
			for (const githubRepository of this._githubRepositories) {
				if (!orgProjects.has(githubRepository.remote.owner)) {
					try {
						const data = await githubRepository.getOrgProjects();
						orgProjects.set(githubRepository.remote.owner, data);
					} catch (e) {
						break;
					}
				}
				cache[githubRepository.remote.remoteName] = orgProjects.get(githubRepository.remote.owner) ?? [];
			}

			await this.saveInGlobalState('orgProjects', cache);
			resolve(cache);
		});
	}

	async getOrgProjects(clearCache?: boolean): Promise<{ [key: string]: IProject[] }> {
		if (clearCache) {
			return this.createFetchOrgProjectsPromise();
		}

		const globalStateProjects = await this.getCachedFromGlobalState<IProject>('orgProjects');
		return globalStateProjects ?? this.createFetchOrgProjectsPromise();
	}

	async getAllProjects(githubRepository: GitHubRepository, clearOrgCache?: boolean): Promise<IProject[]> {
		const isInOrganization = !!(await githubRepository.getMetadata()).organization;
		const [repoProjects, orgProjects] = (await Promise.all([githubRepository.getProjects(), (isInOrganization ? this.getOrgProjects(clearOrgCache) : undefined)]));
		return [...(repoProjects ?? []), ...(orgProjects ? orgProjects[githubRepository.remote.remoteName] : [])];
	}

	async getOrgTeamsCount(repository: GitHubRepository): Promise<number> {
		if ((await repository.getMetadata()).organization) {
			return repository.getOrgTeamsCount();
		}
		return 0;
	}

	async getPullRequestParticipants(githubRepository: GitHubRepository, pullRequestNumber: number): Promise<{ participants: IAccount[], viewer: IAccount }> {
		return {
			participants: await githubRepository.getPullRequestParticipants(pullRequestNumber),
			viewer: await this.getCurrentUser(githubRepository)
		};
	}

	/**
	 * Returns the remotes that are currently active, which is those that are important by convention (origin, upstream),
	 * or the remotes configured by the setting githubPullRequests.remotes
	 */
	async getGitHubRemotes(): Promise<GitHubRemote[]> {
		const githubRepositories = this._githubRepositories;

		if (!githubRepositories || !githubRepositories.length) {
			return [];
		}

		const remotes = githubRepositories.map(repo => repo.remote).flat();

		const serverTypes = await Promise.all(
			remotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),
		).catch(e => {
			Logger.error(`Resolving GitHub remotes failed: ${e}`, this.id);
			vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));
			return [];
		});

		const githubRemotes = remotes.map((remote, index) => GitHubRemote.remoteAsGitHub(remote, serverTypes[index]));
		if (this.checkForAuthMatch(githubRemotes)) {
			return githubRemotes;
		}
		return [];
	}

	/**
	 * Returns all remotes from the repository.
	 */
	async getAllGitHubRemotes(): Promise<GitHubRemote[]> {
		return await this.computeAllGitHubRemotes();
	}

	async getLocalPullRequests(): Promise<PullRequestModel[]> {
		const githubRepositories = this._githubRepositories;

		if (!githubRepositories || !githubRepositories.length || !this.repository.getRefs) {
			return [];
		}

		const localBranches = (await this.repository.getRefs({ pattern: 'refs/heads/' }))
			.filter(r => r.name !== undefined)
			.map(r => r.name!);

		// Chunk localBranches into chunks of 100 to avoid hitting the GitHub API rate limit
		const chunkedLocalBranches: string[][] = [];
		const chunkSize = 100;
		for (let i = 0; i < localBranches.length; i += chunkSize) {
			const chunk = localBranches.slice(i, i + chunkSize);
			chunkedLocalBranches.push(chunk);
		}

		const models: (PullRequestModel | undefined)[] = [];
		for (const chunk of chunkedLocalBranches) {
			models.push(...await Promise.all(chunk.map(async localBranchName => {
				const matchingPRMetadata = await PullRequestGitHelper.getMatchingPullRequestMetadataForBranch(
					this.repository,
					localBranchName,
				);

				if (matchingPRMetadata) {
					const { owner, prNumber } = matchingPRMetadata;
					const githubRepo = githubRepositories.find(
						repo => repo.remote.owner.toLocaleLowerCase() === owner.toLocaleLowerCase(),
					);

					if (githubRepo) {
						const pullRequest: PullRequestModel | undefined = await githubRepo.getPullRequest(prNumber, 'FolderRepositoryManager.getLocalPullRequests');

						if (pullRequest) {
							pullRequest.localBranchName = localBranchName;
							return pullRequest;
						}
					}
				}
			})));
		}

		return models.filter(value => value !== undefined) as PullRequestModel[];
	}

	/**
	 * On first activation, iterate through local branches and associate them with PRs if they match.
	 * This helps discover PRs that were created before the extension was installed or in other ways.
	 */
	private async associateLocalBranchesWithPRsOnFirstActivation(): Promise<void> {
		const stateKey = `${BRANCHES_ASSOCIATED_WITH_PRS}.${this.repository.rootUri.fsPath}`;
		const hasRun = this.context.globalState.get<boolean>(stateKey, false);

		if (hasRun) {
			Logger.debug('Branch association has already run for this workspace folder', this.id);
			return;
		}

		Logger.appendLine('First activation: associating local branches with PRs', this.id);

		const githubRepositories = this._githubRepositories;
		if (!githubRepositories || !githubRepositories.length || !this.repository.getRefs) {
			Logger.debug('No GitHub repositories or getRefs not available, skipping branch association', this.id);
			await this.context.globalState.update(stateKey, true);
			return;
		}

		try {
			// Only check the 3 most recently used branches to minimize API calls
			const localBranches = (await this.repository.getRefs({
				pattern: 'refs/heads/',
				sort: 'committerdate',
				count: 10
			}))
				.filter(r => r.name !== undefined)
				.map(r => r.name!);