@gitkraken/core-gitlens 0.1.0 → 0.3.0

package/src/git-cli/providers/patch.ts

@@ -11,7 +11,7 @@ import { getSettledValue } from '../../utils/promise.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import { RunError } from '../exec/exec.errors.js';
 import type { Git } from '../exec/git.js';
-import { gitConfigsLog, GitError } from '../exec/git.js';
+import { classifySigningError, gitConfigsLog, GitError } from '../exec/git.js';
 
 export class PatchGitSubProvider implements GitPatchSubProvider {
 	constructor(
@@ -27,7 +27,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 		if (options?.threeWay) {
 			args.push('--3way');
 		}
-		await this.git.exec({ cwd: repoPath, stdin: patch }, ...args);
+		await this.git.run({ cwd: repoPath, stdin: patch }, ...args);
 	}
 
 	@debug()
@@ -113,6 +113,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			}
 		} catch (ex) {
 			if (ex instanceof ApplyPatchCommitError) throw ex;
+
 			scope?.error(ex);
 
 			if (CherryPickError.is(ex, 'wouldOverwriteChanges')) {
@@ -209,7 +210,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			const [signingConfigResult, applyResult] = await Promise.allSettled([
 				this.provider.config.getSigningConfig?.(repoPath),
 				// Apply the patch to our temp index, without touching the working directory
-				this.git.exec(
+				this.git.run(
 					{ cwd: repoPath, configs: gitConfigsLog, env: env, stdin: patch },
 					'apply',
 					'--cached',
@@ -224,7 +225,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			_signingFormat = signingConfig?.format ?? 'gpg';
 
 			// Create a new tree from our patched index
-			let result = await this.git.exec({ cwd: repoPath, env: env }, 'write-tree');
+			let result = await this.git.run({ cwd: repoPath, env: env }, 'write-tree');
 			const tree = result.stdout.trim();
 
 			// Set the author if provided
@@ -247,7 +248,7 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			args.push('-m', message);
 
 			// Create new commit from the tree
-			result = await this.git.exec({ cwd: repoPath, env: finalEnv }, ...args);
+			result = await this.git.run({ cwd: repoPath, env: finalEnv }, ...args);
 			const sha = result.stdout.trim();
 
 			if (shouldSign) {
@@ -260,33 +261,11 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 
 			// Handle signing-specific errors
 			if (shouldSign && ex instanceof Error) {
-				const errorMessage = ex.message.toLowerCase();
-				const gitCommand: GitCommandContext = { repoPath: repoPath, args: ['commit-tree'] };
-				let signingError: SigningError | undefined;
-
-				if (errorMessage.includes('gpg failed to sign') || errorMessage.includes('error: gpg')) {
-					signingError = new SigningError({ reason: 'passphraseFailed', gitCommand: gitCommand }, ex);
-				} else if (
-					errorMessage.includes('secret key not available') ||
-					errorMessage.includes('no secret key') ||
-					errorMessage.includes('no signing key')
-				) {
-					signingError = new SigningError({ reason: 'noKey', gitCommand: gitCommand }, ex);
-				} else if (
-					errorMessage.includes('gpg: command not found') ||
-					(errorMessage.includes('gpg') && errorMessage.includes('not found'))
-				) {
-					signingError = new SigningError({ reason: 'gpgNotFound', gitCommand: gitCommand }, ex);
-				} else if (errorMessage.includes('ssh-keygen') && errorMessage.includes('not found')) {
-					signingError = new SigningError({ reason: 'sshNotFound', gitCommand: gitCommand }, ex);
-				}
-
-				if (signingError != null) {
-					this.context.hooks?.commits?.onSigningFailed?.(
-						signingError.details.reason ?? 'unknown',
-						_signingFormat,
-						options?.source,
-					);
+				const reason = classifySigningError(ex);
+				if (reason != null) {
+					const gitCommand: GitCommandContext = { repoPath: repoPath, args: ['commit-tree'] };
+					const signingError = new SigningError({ reason: reason, gitCommand: gitCommand }, ex);
+					this.context.hooks?.commits?.onSigningFailed?.(reason, _signingFormat, options?.source);
 					throw signingError;
 				}
 			}
@@ -296,19 +275,19 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 	}
 
 	async createEmptyInitialCommit(repoPath: string): Promise<string> {
-		const emptyTree = await this.git.exec({ cwd: repoPath, stdin: '' }, 'hash-object', '-t', 'tree', '--stdin');
-		const result = await this.git.exec({ cwd: repoPath }, 'commit-tree', emptyTree.stdout.trim(), '-m', 'temp');
+		const emptyTree = await this.git.run({ cwd: repoPath, stdin: '' }, 'hash-object', '-t', 'tree', '--stdin');
+		const result = await this.git.run({ cwd: repoPath }, 'commit-tree', emptyTree.stdout.trim(), '-m', 'temp');
 		// create refs/heads/main and point to it
-		await this.git.exec({ cwd: repoPath }, 'update-ref', 'refs/heads/main', result.stdout.trim());
+		await this.git.run({ cwd: repoPath }, 'update-ref', 'refs/heads/main', result.stdout.trim());
 		// point HEAD to the branch
-		await this.git.exec({ cwd: repoPath }, 'symbolic-ref', 'HEAD', 'refs/heads/main');
+		await this.git.run({ cwd: repoPath }, 'symbolic-ref', 'HEAD', 'refs/heads/main');
 		return result.stdout.trim();
 	}
 
 	@debug({ args: repoPath => ({ repoPath: repoPath }) })
 	async validatePatch(repoPath: string | undefined, contents: string): Promise<boolean> {
 		try {
-			await this.git.exec({ cwd: repoPath, configs: gitConfigsLog, stdin: contents }, 'apply', '--check', '-');
+			await this.git.run({ cwd: repoPath, configs: gitConfigsLog, stdin: contents }, 'apply', '--check', '-');
 			return true;
 		} catch (ex) {
 			if (ex instanceof RunError || ex instanceof GitError) {

package/src/git-cli/providers/pausedOperations.ts

@@ -43,10 +43,18 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 	@debug()
 	getPausedOperationStatus(
 		repoPath: string,
+		options?: { force?: boolean },
 		cancellation?: AbortSignal,
 	): Promise<GitPausedOperationStatus | undefined> {
 		const scope = getScopedLogger();
 
+		// Self-heal callers (WIP refresh) bypass the cache so a missed `'pausedOp'` FS-watcher
+		// event (CLI-driven completion, torn-down secondary-worktree watcher) can't leave the
+		// status stuck — the readdir-based detection is cheap enough to repeat on every tick.
+		if (options?.force) {
+			this.cache.pausedOperationStatus.delete(repoPath);
+		}
+
 		const status = this.cache.pausedOperationStatus.getOrCreate(repoPath, async _cancellable => {
 			const gitDir = await this.provider.config.getGitDir(repoPath);
 
@@ -109,7 +117,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 			const operation = sortedOperations[0];
 			switch (operation) {
 				case 'cherry-pick': {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 						'rev-parse',
 						'--quiet',
@@ -145,7 +153,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 					} satisfies GitCherryPickStatus;
 				}
 				case 'merge': {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 						'rev-parse',
 						'--quiet',
@@ -197,7 +205,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 					} satisfies GitMergeStatus;
 				}
 				case 'revert': {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 						'rev-parse',
 						'--quiet',
@@ -249,7 +257,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 						stepsMessageResult,
 						isInteractiveResult,
 					] = await Promise.allSettled([
-						this.git.exec(
+						this.git.run(
 							{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 							'rev-parse',
 							'--quiet',
@@ -479,7 +487,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 		const args = [status.type, options?.quit ? '--quit' : '--abort'];
 
 		try {
-			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -514,7 +522,7 @@ export class PausedOperationsGitSubProvider implements GitPausedOperationsSubPro
 		const args = [status.type, options?.skip ? '--skip' : '--continue'];
 
 		try {
-			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {

package/src/git-cli/providers/refs.ts

@@ -1,19 +1,27 @@
 import type { Cache } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import type { GitBranch } from '../../git/models/branch.js';
-import type { GitReference } from '../../git/models/reference.js';
+import type { GitReference, GitRefTip, RefRecord } from '../../git/models/reference.js';
 import { deletedOrMissing } from '../../git/models/revision.js';
 import type { GitTag } from '../../git/models/tag.js';
 import type { GitRefsSubProvider } from '../../git/providers/refs.js';
+import type { GitCommandPriority } from '../../git/run.types.js';
+import { isRemoteHEAD } from '../../git/utils/branch.utils.js';
 import { createReference } from '../../git/utils/reference.utils.js';
-import { isShaWithOptionalRevisionSuffix, isUncommitted } from '../../git/utils/revision.utils.js';
-import { isCancellationError } from '../../utils/cancellation.js';
+import { isSha, isShaWithOptionalRevisionSuffix, isUncommitted } from '../../git/utils/revision.utils.js';
+import { compareRefTips } from '../../git/utils/sorting.js';
+import { CancellationError, isCancellationError } from '../../utils/cancellation.js';
 import { debug, trace } from '../../utils/decorators/log.js';
+import { createDisposable } from '../../utils/disposable.js';
 import { getScopedLogger } from '../../utils/logger.scoped.js';
+import { maybeStopWatch } from '../../utils/stopwatch.js';
+import { iterateAsyncByDelimiter } from '../../utils/string.js';
 import type { Uri } from '../../utils/uri.js';
 import { toFsPath } from '../../utils/uri.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { Git } from '../exec/git.js';
+import { gitConfigsBranch } from '../exec/git.js';
+import { getRefParser } from '../parsers/refParser.js';
 
 export class RefsGitSubProvider implements GitRefsSubProvider {
 	constructor(
@@ -26,29 +34,266 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	@debug()
 	async checkIfCouldBeValidBranchOrTagName(repoPath: string, ref: string): Promise<boolean> {
 		try {
-			const result = await this.git.exec({ cwd: repoPath, errors: 'throw' }, 'check-ref-format', '--branch', ref);
+			const result = await this.git.run({ cwd: repoPath, errors: 'throw' }, 'check-ref-format', '--branch', ref);
 			return Boolean(result.stdout.trim());
 		} catch {
 			return false;
 		}
 	}
 
+	/**
+	 * Raw `git for-each-ref` records covering branches, remotes, and tags in a single pass.
+	 * CLI-internal — siblings call via `this.provider.refs.getRefs(...)`. The `RefRecord` shape
+	 * is `for-each-ref`-specific and intentionally absent from the public `GitRefsSubProvider`
+	 * interface.
+	 */
+	@debug()
+	async getRefs(repoPath: string, cancellation?: AbortSignal): Promise<RefRecord[]> {
+		if (!repoPath) return [];
+
+		const scope = getScopedLogger();
+
+		return this.cache.getRefs(
+			repoPath,
+			async (commonPath, cacheable, signal) => {
+				try {
+					const supported = await this.git.supported('git:for-each-ref');
+					const parser = getRefParser(supported);
+					const result = await this.git.run(
+						{ cwd: commonPath, cancellation: signal, configs: gitConfigsBranch, errors: 'ignore' },
+						'for-each-ref',
+						...parser.arguments,
+						'refs/heads/',
+						'refs/remotes/',
+						'refs/tags/',
+					);
+					if (!result?.stdout) return [];
+
+					using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
+
+					const records = [...parser.parse(result.stdout)];
+
+					sw?.stop({ suffix: ` parsed ${records.length} ref records` });
+
+					return records;
+				} catch (ex) {
+					cacheable?.invalidate();
+					if (isCancellationError(ex)) throw ex;
+
+					scope?.error(ex);
+					return [];
+				}
+			},
+			cancellation,
+		);
+	}
+
+	@debug()
+	async getRefTips(
+		repoPath: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<GitRefTip[]> {
+		if (!repoPath) return [];
+
+		const scope = getScopedLogger();
+
+		// Cache always holds the full set; subset filtering is applied on read so callers asking
+		// for different subsets share one cache entry.
+		const all = await this.cache.getRefTips(
+			repoPath,
+			async (_commonPath, _cacheable, signal) => {
+				const records = await this.getRefs(repoPath, signal);
+
+				using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
+
+				const tips: GitRefTip[] = [];
+				for (const record of records) {
+					const fullName = record.name;
+					if (!fullName) continue;
+					// Skip refs/remotes/<remote>/HEAD — symbolic, not a real tip.
+					if (isRemoteHEAD(fullName)) continue;
+
+					let type: GitRefTip['type'];
+					let name: string;
+					if (fullName.startsWith('refs/heads/')) {
+						type = 'branch';
+						name = fullName.substring(11);
+					} else if (fullName.startsWith('refs/remotes/')) {
+						type = 'remote';
+						name = fullName.substring(13);
+					} else if (fullName.startsWith('refs/tags/')) {
+						type = 'tag';
+						name = fullName.substring(10);
+					} else {
+						continue;
+					}
+
+					// Annotated tags: peeledObjectname is the commit SHA; objectname is the tag-object SHA.
+					// Lightweight tags / branches: peeledObjectname is empty; objectname is already the commit SHA.
+					const sha = record.peeledObjectname || record.objectname;
+
+					tips.push({ type: type, name: name, fullName: fullName, sha: sha });
+				}
+
+				sw?.stop({ suffix: ` projected ${tips.length} ref tips` });
+
+				return tips;
+			},
+			cancellation,
+		);
+
+		const include = options?.include;
+		if (include == null || (include.includes('heads') && include.includes('remotes') && include.includes('tags'))) {
+			return all;
+		}
+
+		return all.filter(r => {
+			switch (r.type) {
+				case 'branch':
+					return include.includes('heads');
+				case 'remote':
+					return include.includes('remotes');
+				case 'tag':
+					return include.includes('tags');
+			}
+		});
+	}
+
+	@debug()
+	async getRefsContainingShas(
+		repoPath: string,
+		shas: ReadonlySet<string> | readonly string[],
+		oldestSha: string,
+		options?: { include?: ReadonlyArray<'heads' | 'remotes' | 'tags'> },
+		cancellation?: AbortSignal,
+	): Promise<Map<string, GitRefTip[]>> {
+		const targetShas = shas instanceof Set ? shas : new Set(shas);
+		if (!targetShas.size || !oldestSha) return new Map();
+
+		const scope = getScopedLogger();
+
+		const tips = await this.getRefTips(repoPath, options, cancellation);
+		if (cancellation?.aborted) throw new CancellationError();
+		if (!tips.length) return new Map();
+
+		// Index tips by full ref name (for projection back to GitRefTip later) and seed the
+		// propagation map by tip SHA. Multiple refs sharing a tip (e.g. local + remote-tracking)
+		// collapse into one Set entry whose union covers all of them.
+		const tipsByName = new Map<string, GitRefTip>();
+		const propMap = new Map<string, Set<string>>();
+		for (const tip of tips) {
+			tipsByName.set(tip.fullName, tip);
+			let names = propMap.get(tip.sha);
+			if (names == null) {
+				names = new Set();
+				propMap.set(tip.sha, names);
+			}
+			names.add(tip.fullName);
+		}
+
+		using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
+
+		// `^<oldestSha>^@` excludes the parents of <oldestSha> and everything older. When <oldestSha>
+		// is a root commit, `^@` resolves to nothing and the walk is naturally unbounded — git
+		// doesn't error in that case (no negative refs to apply).
+		const stream = this.git.stream(
+			{ cwd: repoPath, cancellation: cancellation, configs: gitConfigsBranch },
+			'rev-list',
+			'--topo-order',
+			'--parents',
+			'--all',
+			`^${oldestSha}^@`,
+		);
+		using _streamDisposer = createDisposable(() => void stream.return?.(undefined));
+
+		// Topological propagation: `--topo-order` emits all children of X before X's own line, so
+		// by the time we process "X P1 P2..." every child has already merged its set into X. We
+		// then forward X's accumulated set to each parent — one-pass and correct.
+		try {
+			for await (const line of iterateAsyncByDelimiter(stream, '\n')) {
+				if (cancellation?.aborted) throw new CancellationError();
+				if (!line) continue;
+
+				const firstSpace = line.indexOf(' ');
+				const sha = firstSpace === -1 ? line : line.substring(0, firstSpace);
+				if (!sha) continue;
+
+				const refs = propMap.get(sha);
+				if (!refs?.size) continue;
+
+				if (firstSpace === -1) continue; // No parents — nothing to propagate to
+
+				// Walk parent SHAs by index without splitting the whole line.
+				let start = firstSpace + 1;
+				while (start < line.length) {
+					const next = line.indexOf(' ', start);
+					const parentSha = next === -1 ? line.substring(start) : line.substring(start, next);
+					if (parentSha) {
+						let parentRefs = propMap.get(parentSha);
+						if (parentRefs == null) {
+							parentRefs = new Set(refs);
+							propMap.set(parentSha, parentRefs);
+						} else {
+							for (const name of refs) {
+								parentRefs.add(name);
+							}
+						}
+					}
+					if (next === -1) break;
+
+					start = next + 1;
+				}
+			}
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+
+			scope?.error(ex);
+			return new Map();
+		}
+
+		// Project to targets, materialize GitRefTip[], sort.
+		const result = new Map<string, GitRefTip[]>();
+		for (const sha of targetShas) {
+			const names = propMap.get(sha);
+			if (!names?.size) continue;
+
+			const refs: GitRefTip[] = [];
+			for (const name of names) {
+				const tip = tipsByName.get(name);
+				if (tip != null) {
+					refs.push(tip);
+				}
+			}
+			refs.sort(compareRefTips);
+			result.set(sha, refs);
+		}
+
+		sw?.stop({ suffix: ` resolved ${result.size}/${targetShas.size} target shas` });
+
+		return result;
+	}
+
 	@debug()
 	async getMergeBase(
 		repoPath: string,
 		ref1: string,
 		ref2: string,
-		options?: { forkPoint?: boolean },
+		options?: { forkPoint?: boolean; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		const scope = getScopedLogger();
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{
 					cwd: repoPath,
 					cancellation: cancellation,
+					// Why: ref1/ref2 are usually branch names; correctness relies on the gitResults cache being
+					// cleared on 'heads'/'remotes' events when refs move. Web (no fs watcher) sees up to
+					// `accessTTL` of staleness — acceptable trade-off for the perf win on graph/branch reads.
 					caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
+					...(options?.priority != null ? { priority: options.priority } : undefined),
 				},
 				'merge-base',
 				options?.forkPoint ? '--fork-point' : undefined,
@@ -101,12 +346,22 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 	async getSymbolicReferenceName(
 		repoPath: string,
 		ref: string,
+		options?: { priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
 
-		const result = await this.git.exec(
-			{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
+		const result = await this.git.run(
+			{
+				cwd: repoPath,
+				cancellation: cancellation,
+				errors: 'ignore',
+				// Why: a fixed ref name's symbolic name is itself stable; only HEAD is mutable, and the
+				// gitResults cache is cleared on 'head' events. 60s TTL is the failsafe for watcher
+				// latency / web — matches the other "resolve symbolic state" calls in commits.ts.
+				caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
+				...(options?.priority != null ? { priority: options.priority } : undefined),
+			},
 			'rev-parse',
 			'--verify',
 			'--quiet',
@@ -164,12 +419,20 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 
 		const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
 
-		const result = await this.git.exec(
+		// Why: a SHA-only validation (no path suffix) is effectively immutable — 5-min TTL is safe.
+		// Otherwise the resolved SHA can shift on ref move (or working-tree change for path-scoped
+		// validation); rely on gitResults being cleared on 'head'/'heads'/'remotes' events, with 60s
+		// TTL as the failsafe for watcher latency / web.
+		const stable = relativePath == null && isSha(ref);
+		const result = await this.git.run(
 			{
 				cwd: repoPath,
 				cancellation: cancellation,
 				errors: 'ignore',
-				caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: stable ? 5 * 60 * 1000 : 60 * 1000 },
+				},
 			},
 			'rev-parse',
 			'--verify',
@@ -184,7 +447,7 @@ export class RefsGitSubProvider implements GitRefsSubProvider {
 		const scope = getScopedLogger();
 
 		try {
-			await this.git.exec({ cwd: repoPath, cancellation: cancellation }, 'update-ref', ref, newRef);
+			await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'update-ref', ref, newRef);
 		} catch (ex) {
 			scope?.error(ex);
 			if (isCancellationError(ex)) throw ex;

package/src/git-cli/providers/remotes.ts

@@ -41,7 +41,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 				const remoteProviderMatcher = createRemoteProviderMatcher(configs, this.context.remotes);
 
 				try {
-					const result = await this.git.exec(
+					const result = await this.git.run(
 						{
 							cwd: repoPath,
 							cancellation: signal,
@@ -79,7 +79,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 	@gate()
 	@debug()
 	async addRemote(repoPath: string, name: string, url: string, options?: { fetch?: boolean }): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'remote', 'add', options?.fetch ? '-f' : undefined, name, url);
+		await this.git.run({ cwd: repoPath }, 'remote', 'add', options?.fetch ? '-f' : undefined, name, url);
 		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes');
 		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
 	}
@@ -100,7 +100,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 	@gate()
 	@debug()
 	async pruneRemote(repoPath: string, name: string): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'remote', 'prune', name);
+		await this.git.run({ cwd: repoPath }, 'remote', 'prune', name);
 		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes', 'branches');
 		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
 	}
@@ -108,7 +108,7 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 	@gate()
 	@debug()
 	async removeRemote(repoPath: string, name: string): Promise<void> {
-		await this.git.exec({ cwd: repoPath }, 'remote', 'remove', name);
+		await this.git.run({ cwd: repoPath }, 'remote', 'remove', name);
 		this.context.hooks?.cache?.onReset?.(repoPath, 'remotes');
 		this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
 	}