@gitkraken/core-gitlens 0.5.115 → 0.6.0

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

@@ -7,11 +7,14 @@ import type { Provider } from '../../../../git/models/remoteProvider.js';
 import type { RepositoryMetadata } from '../../../../git/models/repositoryMetadata.js';
 import { base64 } from '../../../../utils/base64.js';
 import { CancellationError, isCancellationError } from '../../../../utils/cancellation.js';
+import { sha256 } from '../../../../utils/crypto.js';
 import { trace } from '../../../../utils/decorators/log.js';
 import type { Disposable } from '../../../../utils/disposable.js';
 import { Logger } from '../../../../utils/logger.js';
 import type { ScopedLogger } from '../../../../utils/logger.scoped.js';
 import { getScopedLogger } from '../../../../utils/logger.scoped.js';
+import type { CacheController } from '../../../../utils/promiseCache.js';
+import { PromiseCache } from '../../../../utils/promiseCache.js';
 import { maybeStopWatch } from '../../../../utils/stopwatch.js';
 import type { TokenWithInfo } from '../../authentication/models.js';
 import type { IntegrationServiceContext } from '../../context.js';
@@ -27,10 +30,13 @@ import {
 import type { ProviderApiConfig } from '../apiConfig.js';
 import { baseProviderApiConfig } from '../apiConfig.js';
 import type {
+	AzureForkRepositoryUrls,
 	AzureGitCommit,
 	AzureProjectDescriptor,
 	AzurePullRequest,
 	AzurePullRequestWithLinks,
+	AzureRepositoryReference,
+	AzureRepositoryUrls,
 	AzureRepositoryWithMetadata,
 	AzureWorkItemState,
 	AzureWorkItemStateCategory,
@@ -45,8 +51,21 @@ import {
 	isClosedAzurePullRequestStatus,
 	isClosedAzureWorkItemStateCategory,
 	normalizeAzureBranchName,
+	sanitizeAzureRepositoryUrl,
 } from './models.js';
 
+const forkRepositoryUrlCacheTtl = 5 * 60 * 1000;
+
+function parseAzureRepositoryDescriptor(repo: string): { projectName: string; repoName: string } {
+	const parts = repo.split('/');
+	const [projectName, segment, repoName] = parts;
+	if (parts.length !== 3 || segment !== '_git' || !projectName || !repoName) {
+		throw new Error(`Invalid Azure repository descriptor '${repo}'; expected '{project}/_git/{repoName}'.`);
+	}
+
+	return { projectName: projectName, repoName: repoName };
+}
+
 class WorkItemStates {
 	private readonly _categories = new Map<string, AzureWorkItemStateCategory>();
 	private readonly _types = new Map<string, AzureWorkItemState[]>();
@@ -99,6 +118,10 @@ class WorkItemStates {
 export class AzureDevOpsApi implements Disposable {
 	private readonly _disposable: Disposable | undefined;
 	private _workItemStates: WorkItemStates = new WorkItemStates();
+	private readonly _forkRepositoryUrls = new PromiseCache<string, AzureForkRepositoryUrls | undefined>({
+		capacity: 100,
+		createTTL: forkRepositoryUrlCacheTtl,
+	});
 
 	constructor(private readonly config: ProviderApiConfig) {
 		this._disposable = config.onConfigChanged?.(() => this.resetCaches());
@@ -110,6 +133,7 @@ export class AzureDevOpsApi implements Disposable {
 
 	private resetCaches(): void {
 		this._workItemStates.clear();
+		this._forkRepositoryUrls.clear();
 	}
 
 	@trace({
@@ -132,7 +156,7 @@ export class AzureDevOpsApi implements Disposable {
 		},
 	): Promise<PullRequest | undefined> {
 		const scope = getScopedLogger();
-		const [projectName, _, repoName] = repo.split('/');
+		const { projectName, repoName } = parseAzureRepositoryDescriptor(repo);
 
 		try {
 			const prResult = await this.request<{ value: AzurePullRequest[] }>(
@@ -167,7 +191,7 @@ export class AzureDevOpsApi implements Disposable {
 			const pr = sortedPRs?.[0];
 			if (pr == null) return undefined;
 
-			return fromAzurePullRequest(pr, provider, owner);
+			return await this.toPullRequest(pr, provider, token, owner, options.baseUrl, scope);
 		} catch (ex) {
 			scope?.error(ex);
 			return undefined;
@@ -197,7 +221,7 @@ export class AzureDevOpsApi implements Disposable {
 		cancellation?: AbortSignal,
 	): Promise<PullRequest | undefined> {
 		const scope = getScopedLogger();
-		const [projectName, _, repoName] = repo.split('/');
+		const { projectName, repoName } = parseAzureRepositoryDescriptor(repo);
 		try {
 			const prResult = await this.request<{ results: Record<string, AzurePullRequest[]>[] }>(
 				provider,
@@ -225,15 +249,15 @@ export class AzureDevOpsApi implements Disposable {
 			const pullRequest = await this.request<AzurePullRequestWithLinks>(
 				provider,
 				token,
-				undefined,
-				pr.url,
+				baseUrl,
+				`${owner}/${encodeURIComponent(pr.repository.project.id)}/_apis/git/repositories/${encodeURIComponent(pr.repository.id)}/pullRequests/${encodeURIComponent(pr.pullRequestId.toString())}`,
 				{ method: 'GET' },
 				scope,
 				cancellation,
 			);
 			if (pullRequest == null) return undefined;
 
-			return fromAzurePullRequest(pullRequest, provider, owner);
+			return await this.toPullRequest(pullRequest, provider, token, owner, baseUrl, scope, cancellation);
 		} catch (ex) {
 			scope?.error(ex);
 			return undefined;
@@ -261,7 +285,7 @@ export class AzureDevOpsApi implements Disposable {
 		},
 	): Promise<IssueOrPullRequest | undefined> {
 		const scope = getScopedLogger();
-		const [projectName, _, repoName] = repo.split('/');
+		const { projectName, repoName } = parseAzureRepositoryDescriptor(repo);
 
 		if (options?.type === undefined || options?.type === 'issue') {
 			try {
@@ -335,7 +359,7 @@ export class AzureDevOpsApi implements Disposable {
 						state: azurePullRequestStatusToState(prResult.status),
 						closed: isClosedAzurePullRequestStatus(prResult.status),
 						title: prResult.title,
-						url: getAzurePullRequestWebUrl(prResult),
+						url: getAzurePullRequestWebUrl(prResult, options.baseUrl, owner),
 					};
 				}
 
@@ -428,7 +452,7 @@ export class AzureDevOpsApi implements Disposable {
 		},
 	): Promise<UnidentifiedAuthor | undefined> {
 		const scope = getScopedLogger();
-		const [projectName, _, repoName] = repo.split('/');
+		const { projectName, repoName } = parseAzureRepositoryDescriptor(repo);
 
 		try {
 			// Try to get the Work item (wit) first with specific fields
@@ -687,12 +711,7 @@ export class AzureDevOpsApi implements Disposable {
 		scope: ScopedLogger | undefined,
 		cancellation?: AbortSignal,
 	): Promise<AzureRepositoryWithMetadata | undefined> {
-		const parts = repo.split('/');
-		const [projectName, segment, repoName] = parts;
-		// The descriptor must be exactly `"{project}/_git/{repoName}"`; bail before issuing a bogus request.
-		if (parts.length !== 3 || segment !== '_git' || !projectName || !repoName) {
-			throw new Error(`Invalid Azure repository descriptor '${repo}'; expected '{project}/_git/{repoName}'.`);
-		}
+		const { projectName, repoName } = parseAzureRepositoryDescriptor(repo);
 		return this.request<AzureRepositoryWithMetadata>(
 			provider,
 			token,
@@ -704,6 +723,118 @@ export class AzureDevOpsApi implements Disposable {
 		);
 	}
 
+	private async toPullRequest(
+		pr: AzurePullRequest,
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		baseUrl: string,
+		scope: ScopedLogger | undefined,
+		cancellation?: AbortSignal,
+	): Promise<PullRequest> {
+		const forkRepositoryUrls = await this.getForkRepositoryUrls(
+			provider,
+			token,
+			owner,
+			baseUrl,
+			pr.forkSource?.repository,
+			scope,
+			cancellation,
+		);
+		return fromAzurePullRequest(pr, provider, owner, baseUrl, forkRepositoryUrls);
+	}
+
+	/**
+	 * Resolves the web and HTTPS clone URLs of the fork a cross-repository pull request comes from. Every other
+	 * repository URL the model reports is rebuilt from the pull request payload; only a fork reference lacks the
+	 * project to do that, so only a fork costs a request.
+	 *
+	 * Best-effort by contract: a fork in a project the token cannot read, a deleted fork, or a throttled request
+	 * leaves the head ref without a URL. It must never cost the pull request itself, which is what makes swallowing
+	 * the failure here the right call rather than a shortcut.
+	 */
+	private async getForkRepositoryUrls(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		baseUrl: string,
+		repository: AzureRepositoryReference | undefined,
+		scope: ScopedLogger | undefined,
+		cancellation?: AbortSignal,
+	): Promise<AzureForkRepositoryUrls | undefined> {
+		if (repository == null) return undefined;
+
+		let tokenHash: string;
+		try {
+			tokenHash = await sha256(token.accessToken);
+		} catch {
+			return undefined;
+		}
+
+		const cacheKey = JSON.stringify([tokenHash, baseUrl, owner, repository.id]);
+		// The request is shared, so the factory is handed the cache's aggregate signal rather than this caller's: it
+		// aborts only once every caller waiting on the entry has cancelled.
+		return this._forkRepositoryUrls.getOrCreate(
+			cacheKey,
+			(cacheable, aggregate) =>
+				this.fetchForkRepositoryUrls(
+					provider,
+					token,
+					owner,
+					baseUrl,
+					repository.id,
+					cacheable,
+					scope,
+					aggregate,
+				),
+			{ cancellation: cancellation },
+		);
+	}
+
+	private async fetchForkRepositoryUrls(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		baseUrl: string,
+		repositoryId: string,
+		cacheable: CacheController,
+		scope: ScopedLogger | undefined,
+		cancellation?: AbortSignal,
+	): Promise<AzureForkRepositoryUrls | undefined> {
+		try {
+			const response = await this.request<AzureRepositoryUrls>(
+				provider,
+				token,
+				baseUrl,
+				`${owner}/_apis/git/repositories/${encodeURIComponent(repositoryId)}?api-version=4.1`,
+				{ method: 'GET' },
+				scope,
+				cancellation,
+			);
+			const webUrl = sanitizeAzureRepositoryUrl(response?.webUrl, baseUrl, owner);
+			const cloneHttps = sanitizeAzureRepositoryUrl(response?.remoteUrl, baseUrl, owner);
+
+			// The clone URL stands in for the web URL when the response omits it — an older `api-version` promises
+			// neither field, and naming the fork by the URL git would use beats naming it not at all.
+			const url = webUrl ?? cloneHttps;
+			if (url == null) {
+				cacheable.invalidate();
+				return undefined;
+			}
+
+			return { url: url, cloneHttps: cloneHttps };
+		} catch (ex) {
+			// Missing or inaccessible forks are cached briefly; transient failures retry on the next read.
+			if (!(ex instanceof RequestNotFoundError) && !(ex instanceof AuthenticationError)) {
+				cacheable.invalidate();
+			}
+
+			const status = ex instanceof ProviderFetchError ? ` (${ex.status})` : '';
+			scope?.warn(`Unable to resolve the fork repository URLs${status}`);
+			return undefined;
+		}
+	}
+
 	private async request<T>(
 		provider: Provider,
 		token: TokenWithInfo,
@@ -718,7 +849,7 @@ export class AzureDevOpsApi implements Disposable {
 
 		let rsp: Response;
 		try {
-			const sw = maybeStopWatch(`[AZURE] ${options?.method ?? 'GET'} ${url}`, { log: { onlyExit: true } });
+			const sw = maybeStopWatch(`[AZURE] ${options?.method ?? 'GET'} request`, { log: { onlyExit: true } });
 
 			try {
 				if (cancellation?.aborted) throw new CancellationError();

package/src/plus/integrations/providers/azure/models.ts

@@ -17,6 +17,7 @@ export interface AzureRepositoryDescriptor extends ResourceDescriptor {
 	owner: string;
 	name: string;
 	project?: string;
+	virtualDirectory?: string;
 }
 
 export interface AzureOrganizationDescriptor extends ResourceDescriptor {
@@ -190,10 +191,14 @@ export interface AzureProject {
 	lastUpdateTime: string;
 }
 
-export interface AzureRepository {
+export interface AzureRepositoryReference {
 	id: string;
 	name: string;
 	url: string;
+	remoteUrl?: string;
+}
+
+export interface AzureRepository extends AzureRepositoryReference {
 	project: AzureProject;
 	size: number;
 	remoteUrl: string;
@@ -203,6 +208,13 @@ export interface AzureRepository {
 	isInMaintenance: boolean;
 }
 
+export interface AzurePullRequestRepository extends AzureRepositoryReference {
+	project: Pick<AzureProject, 'id' | 'name'>;
+}
+
+/** The URL fields of a repository response — all the fork lookup reads, and all an older `api-version` promises. */
+export type AzureRepositoryUrls = Partial<Pick<AzureRepository, 'webUrl' | 'remoteUrl'>>;
+
 /** The `GET .../_apis/git/repositories/{repositoryId or name}` response, adding fork/default-branch fields to {@link AzureRepository}. */
 export interface AzureRepositoryWithMetadata extends AzureRepository {
 	/** Fully-qualified ref, e.g. `refs/heads/main`. */
@@ -290,7 +302,7 @@ export interface AzureGitForkRef {
 	name: string;
 	objectId: string;
 	peeledObjectId: string;
-	repository: AzureRepository;
+	repository: AzureRepositoryReference;
 	statuses: AzureGitStatus[];
 	url: string;
 }
@@ -317,7 +329,7 @@ export type AzurePullRequestAsyncStatus =
 	| 'succeeded';
 
 export interface AzurePullRequest {
-	repository: AzureRepository;
+	repository: AzurePullRequestRepository;
 	pullRequestId: number;
 	codeReviewId: number;
 	status: AzurePullRequestStatus;
@@ -368,70 +380,128 @@ export interface AzurePullRequestWithLinks extends AzurePullRequest {
 	workItemRefs?: AzureResourceRef[];
 }
 
-export function getVSTSOwner(url: URL): string {
-	return url.hostname.split('.')[0];
-}
 export function getAzureDevOpsOwner(url: URL): string {
 	return url.pathname.split('/')[1];
 }
-export function getAzureOwner(url: URL): string {
-	const isVSTS = url.hostname.endsWith(vstsHostnameSuffix);
-	return isVSTS ? getVSTSOwner(url) : getAzureDevOpsOwner(url);
-}
 export function isVsts(domain: string): boolean {
 	return domain.endsWith(vstsHostnameSuffix);
 }
 
-export function getAzureRepo(pr: AzurePullRequest): string {
-	return `${pr.repository.project.name}/_git/${pr.repository.name}`;
-}
-
-// Example: https://bbbchiv.visualstudio.com/MyFirstProject/_git/test
-const azureProjectRepoRegex = /([^/]+)\/_git\/([^/]+)/;
-function parseVstsHttpsUrl(url: URL): [owner: string, project: string, repo: string] {
-	const owner = getVSTSOwner(url);
-	const match = azureProjectRepoRegex.exec(url.pathname);
-	if (match == null) {
-		throw new Error(`Invalid VSTS URL: ${url.toString()}`);
-	}
-
-	const [, project, repo] = match;
-	return [owner, project, repo];
-}
-
-// Example https://bbbchiv2@dev.azure.com/bbbchiv2/MyFirstProject/_git/test
-const azureHttpsUrlRegex = /([^/]+)\/([^/]+)\/_git\/([^/]+)/;
-function parseAzureNewStyleUrl(url: URL): [owner: string, project: string, repo: string] {
-	const match = azureHttpsUrlRegex.exec(url.pathname);
-	if (match == null) {
-		throw new Error(`Invalid Azure URL: ${url.toString()}`);
+/**
+ * `baseUrl` and `owner` are the authoritative prefix used for the API request. The payload URL cannot supply that
+ * prefix safely because it may address the repository by id or name an untrusted host.
+ */
+function getAzureRepositoryWebUrl(baseUrl: string, owner: string, projectName: string, repoName: string): string {
+	const repoPath = `${encodeURIComponent(owner)}/${encodeURIComponent(projectName)}/_git/${encodeURIComponent(repoName)}`;
+	return `${baseUrl.replace(/\/+$/, '')}/${repoPath}`;
+}
+
+export function getAzurePullRequestWebUrl(pr: AzurePullRequest, baseUrl: string, owner: string): string {
+	const repoUrl = getAzureRepositoryWebUrl(baseUrl, owner, pr.repository.project.name, pr.repository.name);
+	return `${repoUrl}/pullrequest/${pr.pullRequestId}`;
+}
+
+/**
+ * Whether `url` and `expected` are the two cloud spellings of one organization: a cloud organization answers on both
+ * `dev.azure.com/{owner}` and the legacy `{owner}.visualstudio.com`, so those name the same host. Anything else is
+ * somewhere we didn't ask.
+ */
+function isSameAzureCloudOrganization(url: URL, expected: URL, expectedOwner: string): boolean {
+	if (url.protocol !== expected.protocol) return false;
+
+	const owner = expectedOwner.toLowerCase();
+	if (expected.hostname !== 'dev.azure.com' && !isVsts(expected.hostname)) return false;
+
+	if (url.hostname === 'dev.azure.com') return getAzureDevOpsOwner(url).toLowerCase() === owner;
+
+	return url.hostname === `${owner}${vstsHostnameSuffix}`;
+}
+
+/**
+ * Whether `url` sits under the collection the integration is configured to talk to — `{expectedUrl}/{expectedOwner}`.
+ * A matching origin says nothing on its own: Azure organizations and self-hosted collections are path segments.
+ */
+function isUnderAzureCollection(url: URL, expected: URL, expectedOwner: string): boolean {
+	const base = expected.pathname.replace(/\/+$/, '');
+	const prefix = `${base}/${encodeURIComponent(expectedOwner)}/`.toLowerCase();
+	return `${url.pathname}/`.toLowerCase().startsWith(prefix);
+}
+
+/**
+ * Restricts a provider-supplied repository URL to the integration's collection and removes credentials, query, and
+ * fragment before a consumer can use it as a git remote. Takes the value as the payloads carry it — every one of
+ * these URLs is optional — so a caller never has to spell the absent case itself.
+ */
+export function sanitizeAzureRepositoryUrl(
+	value: string | undefined,
+	expectedUrl: string,
+	expectedOwner: string,
+): string | undefined {
+	if (value == null) return undefined;
+
+	let expected: URL;
+	let url: URL;
+	try {
+		expected = new URL(expectedUrl);
+		url = new URL(value);
+	} catch {
+		return undefined;
 	}
 
-	const [, owner, project, repo] = match;
-	return [owner, project, repo];
-}
+	if (expected.protocol !== 'https:' && expected.protocol !== 'http:') return undefined;
+	if (!expectedOwner) return undefined;
 
-export function parseAzureHttpsUrl(url: string): [owner: string, project: string, repo: string];
-export function parseAzureHttpsUrl(urlObj: URL): [owner: string, project: string, repo: string];
-export function parseAzureHttpsUrl(arg: URL | string): [owner: string, project: string, repo: string] {
-	const url = typeof arg === 'string' ? new URL(arg) : arg;
-	if (url.hostname.endsWith(vstsHostnameSuffix)) {
-		return parseVstsHttpsUrl(url);
+	if (url.origin === expected.origin) {
+		if (!isUnderAzureCollection(url, expected, expectedOwner)) return undefined;
+	} else if (!isSameAzureCloudOrganization(url, expected, expectedOwner)) {
+		return undefined;
 	}
-	return parseAzureNewStyleUrl(url);
-}
 
-export function getAzurePullRequestWebUrl(pr: AzurePullRequest): string {
-	const url = new URL(pr.url);
-	const baseUrl = new URL(url.origin).toString();
-	const repoPath = getAzureRepo(pr);
-	const isVSTS = url.hostname.endsWith(vstsHostnameSuffix);
-	if (isVSTS) {
-		return `${baseUrl}/${repoPath}/pullrequest/${pr.pullRequestId}`;
+	url.username = '';
+	url.password = '';
+	url.search = '';
+	url.hash = '';
+	return url.toString();
+}
+
+/**
+ * The clone URL the payload carries for a repository, restricted to the integration's collection and then
+ * cross-checked against the repository that payload names.
+ *
+ * The collection check alone is not enough for a URL that is READ rather than built. Every other repository URL the
+ * model reports is built from the authoritative prefix, so the payload cannot move it; this one cannot be built,
+ * because Azure spells a repository for git the same way it spells it for the web only by convention. A URL under
+ * the right collection may still name a DIFFERENT repository in it, which would leave `cloneHttps` describing one
+ * repository while `url` describes another.
+ *
+ * Azure ends a clone URL with `_git/{repo}` on every host style — including the short `{owner}/_git/{repo}` form it
+ * uses when a repository carries its project's name, and the legacy `{owner}.visualstudio.com` spelling that has no
+ * organization segment at all — so the repository name is the one part comparable across all of them. A same-named
+ * repository in another project of the same organization is the single substitution this cannot catch.
+ */
+function getAzureRepositoryCloneUrl(
+	repository: AzureRepositoryReference,
+	baseUrl: string,
+	owner: string,
+): string | undefined {
+	const sanitized = sanitizeAzureRepositoryUrl(repository.remoteUrl, baseUrl, owner);
+	if (sanitized == null) return undefined;
+
+	// Safe to parse: `sanitizeAzureRepositoryUrl` returns what it already parsed.
+	const segments = new URL(sanitized).pathname.split('/').filter(s => s.length > 0);
+	const name = segments.pop();
+	if (name == null || segments.pop() !== '_git') return undefined;
+
+	let decoded: string;
+	try {
+		decoded = decodeURIComponent(name);
+	} catch {
+		return undefined;
 	}
 
-	const owner = getAzureDevOpsOwner(url);
-	return `${baseUrl}/${owner}/${repoPath}/pullrequest/${pr.pullRequestId}`;
+	// Azure resolves project and repository names case-insensitively, so comparing them any other way would refuse a
+	// URL the provider considers the same one.
+	return decoded.toLowerCase() === repository.name.toLowerCase() ? sanitized : undefined;
 }
 
 export function fromAzurePullRequestMergeStatusToMergeableState(
@@ -527,17 +597,47 @@ function fromAzureUserToMember(user: AzureUser, _type: 'issue' | 'pullRequest'):
 	};
 }
 
-export function fromAzurePullRequest(pr: AzurePullRequest, provider: Provider, orgName: string): PullRequest {
-	const url = new URL(pr.url);
+/**
+ * The URLs of a cross-repository pull request's fork, resolved by a lookup because the pull request payload embeds
+ * only an abbreviated reference to it: `url` is the URL the head ref reports — the fork's web URL, or its clone URL
+ * when the response carries no web URL — and `cloneHttps` its HTTPS clone URL.
+ *
+ * A fork that resolves neither is reported as no fork at all rather than as an object with nothing in it, so `url`
+ * is always present here; `cloneHttps` alone is best-effort, and is absent when the response omits it or its URL
+ * sits outside the integration's collection.
+ */
+export interface AzureForkRepositoryUrls {
+	url: string;
+	cloneHttps: string | undefined;
+}
+
+/**
+ * `baseUrl` and `owner` are the prefix the pull request was read through; every URL the model reports is built from
+ * them. The required `forkRepositoryUrls` argument makes each call site resolve the best-effort fork URLs explicitly.
+ */
+export function fromAzurePullRequest(
+	pr: AzurePullRequest,
+	provider: Provider,
+	owner: string,
+	baseUrl: string,
+	forkRepositoryUrls: AzureForkRepositoryUrls | undefined,
+): PullRequest {
+	const baseRepositoryUrl = getAzureRepositoryWebUrl(baseUrl, owner, pr.repository.project.name, pr.repository.name);
+	const baseCloneHttps = getAzureRepositoryCloneUrl(pr.repository, baseUrl, owner);
+
+	const forkRepository = pr.forkSource?.repository;
+	const headRepositoryUrl = forkRepository == null ? baseRepositoryUrl : forkRepositoryUrls?.url;
+	const headCloneHttps = forkRepository == null ? baseCloneHttps : forkRepositoryUrls?.cloneHttps;
+
 	return new PullRequest(
 		provider,
 		fromAzureUserToMember(pr.createdBy, 'pullRequest'),
 		pr.pullRequestId.toString(),
 		pr.pullRequestId.toString(),
 		pr.title,
-		getAzurePullRequestWebUrl(pr),
+		getAzurePullRequestWebUrl(pr, baseUrl, owner),
 		{
-			owner: getAzureOwner(url),
+			owner: owner,
 			repo: pr.repository.name,
 			id: pr.repository.id,
 			// TODO: Remove this assumption once actual access level is available
@@ -555,17 +655,19 @@ export function fromAzurePullRequest(pr: AzurePullRequest, provider: Provider, o
 				branch: pr.targetRefName ? normalizeAzureBranchName(pr.targetRefName) : '',
 				sha: pr.lastMergeTargetCommit?.commitId ?? '',
 				repo: pr.repository.name,
-				owner: getAzureOwner(url),
+				owner: owner,
 				exists: pr.targetRefName != null,
-				url: pr.repository.webUrl,
+				url: baseRepositoryUrl,
+				cloneHttps: baseCloneHttps,
 			},
 			head: {
 				branch: pr.sourceRefName ? normalizeAzureBranchName(pr.sourceRefName) : '',
 				sha: pr.lastMergeSourceCommit?.commitId ?? '',
-				repo: pr.forkSource?.repository != null ? pr.forkSource.repository.name : pr.repository.name,
-				owner: getAzureOwner(url),
+				repo: forkRepository?.name ?? pr.repository.name,
+				owner: owner,
 				exists: pr.sourceRefName != null,
-				url: pr.forkSource?.repository != null ? pr.forkSource.repository.webUrl : pr.repository.webUrl,
+				url: headRepositoryUrl,
+				cloneHttps: headCloneHttps,
 			},
 			isCrossRepository: pr.forkSource != null,
 		},
@@ -583,7 +685,7 @@ export function fromAzurePullRequest(pr: AzurePullRequest, provider: Provider, o
 			id: pr.repository?.project?.id,
 			name: pr.repository.project.name,
 			resourceId: '', // TODO: This is a workaround until we can get the org id here.
-			resourceName: orgName,
+			resourceName: owner,
 		},
 	);
 }