@gitkraken/core-gitlens 0.1.0 → 0.3.0

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

@@ -11,10 +11,16 @@ import {
 	RebaseError,
 	ResetError,
 	RevertError,
+	SigningError,
 } from '../../git/errors.js';
 import type { GitBranchReference, GitReference } from '../../git/models/reference.js';
+import type { SigningFormat } from '../../git/models/signature.js';
 import type { GitConflictFile } from '../../git/models/staging.js';
-import type { GitOperationResult, GitOperationsSubProvider } from '../../git/providers/operations.js';
+import type {
+	GitOperationResult,
+	GitOperationRunOptions,
+	GitOperationsSubProvider,
+} from '../../git/providers/operations.js';
 import { getBranchNameAndRemote, getBranchTrackingWithoutRemote } from '../../git/utils/branch.utils.js';
 import { isBranchReference } from '../../git/utils/reference.utils.js';
 import { debug } from '../../utils/decorators/log.js';
@@ -24,7 +30,14 @@ import { getScopedLogger } from '../../utils/logger.scoped.js';
 import { normalizePath, splitPath } from '../../utils/path.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { Git, PushForceOptions } from '../exec/git.js';
-import { getGitCommandError, gitConfigsPull, GitErrors } from '../exec/git.js';
+import {
+	classifySigningError,
+	getGitCommandError,
+	gitConfigsPull,
+	GitErrors,
+	inferSigningFormatFromError,
+	maxGitCliLength,
+} from '../exec/git.js';
 
 export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	constructor(
@@ -39,11 +52,12 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		ref: string,
 		options?: { createBranch?: string } | { path?: string },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
 		try {
-			await this.checkoutCore(repoPath, ref, options);
+			await this.checkoutCore(repoPath, ref, options, runOptions);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -56,6 +70,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		ref: string,
 		{ createBranch, path }: { createBranch?: string; path?: string } = {},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['checkout'];
 		if (createBranch) {
@@ -70,7 +85,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'checkout',
@@ -84,12 +99,101 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 	}
 
+	@debug()
+	async checkoutConflictedPath(
+		repoPath: string,
+		path: string,
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
+	): Promise<void> {
+		const scope = getScopedLogger();
+
+		[path, repoPath] = splitPath(path, repoPath, true);
+		const params = ['checkout', `--${side}`, '--', path];
+
+		try {
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
+			this.context.hooks?.cache?.onReset?.(repoPath, 'status');
+			this.context.hooks?.repository?.onChanged?.(repoPath, ['index']);
+		} catch (ex) {
+			scope?.error(ex);
+			throw getGitCommandError(
+				'checkout',
+				ex,
+				reason =>
+					new CheckoutError(
+						{ reason: reason ?? 'other', ref: side, gitCommand: { repoPath: repoPath, args: params } },
+						ex,
+					),
+			);
+		}
+	}
+
+	@debug()
+	async checkoutConflictedPaths(
+		repoPath: string,
+		paths: string[],
+		side: 'ours' | 'theirs',
+		runOptions?: GitOperationRunOptions,
+	): Promise<void> {
+		if (!paths.length) return;
+
+		const scope = getScopedLogger();
+		const normalized = paths.map(p => splitPath(p, repoPath, true)[0]);
+
+		// Build batches by accumulating the length of each path + a small per-arg overhead (separator +
+		// possible quoting), so a single long path — or just the overhead itself — can't push a batch
+		// past the CLI length limit. Always keep at least one path per batch, even if a lone path is
+		// longer than the limit (the OS may still accept it on some platforms).
+		const perArgOverhead = 3;
+		const batches: string[][] = [];
+		let current: string[] = [];
+		let currentLen = 0;
+		for (const p of normalized) {
+			const cost = p.length + perArgOverhead;
+			if (current.length > 0 && currentLen + cost > maxGitCliLength) {
+				batches.push(current);
+				current = [];
+				currentLen = 0;
+			}
+			current.push(p);
+			currentLen += cost;
+		}
+		if (current.length) {
+			batches.push(current);
+		}
+
+		try {
+			for (const batch of batches) {
+				await this.git.run({ cwd: repoPath, ...runOptions }, 'checkout', `--${side}`, '--', ...batch);
+			}
+			this.context.hooks?.cache?.onReset?.(repoPath, 'status');
+			this.context.hooks?.repository?.onChanged?.(repoPath, ['index']);
+		} catch (ex) {
+			scope?.error(ex);
+			throw getGitCommandError(
+				'checkout',
+				ex,
+				reason =>
+					new CheckoutError(
+						{
+							reason: reason ?? 'other',
+							ref: side,
+							gitCommand: { repoPath: repoPath, args: ['checkout', `--${side}`, '--', ...normalized] },
+						},
+						ex,
+					),
+			);
+		}
+	}
+
 	@sequentialize({ getQueueKey: rp => rp })
 	@debug()
 	async cherryPick(
 		repoPath: string,
 		revs: string[],
-		options?: { edit?: boolean; noCommit?: boolean },
+		options?: { edit?: boolean; noCommit?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -102,9 +206,10 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		if (revs.length > 1) {
-			// Sort commits in topological order (oldest ancestor first) so cherry-pick applies them correctly
+			// Sort commits in topological order (oldest ancestor first) so cherry-pick applies them correctly.
+			// This is a local read-only pre-flight, not the user-initiated op — don't subject it to caller env/timeout.
 			const revsSet = new Set(revs);
-			const result = await this.git.exec({ cwd: repoPath }, 'rev-list', '--topo-order', '--reverse', ...revs);
+			const result = await this.git.run({ cwd: repoPath }, 'rev-list', '--topo-order', '--reverse', ...revs);
 
 			const ordered: string[] = [];
 			for (const sha of result.stdout.trim().split('\n')) {
@@ -123,12 +228,13 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		args.push(...revs);
 
 		try {
-			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw', ...runOptions }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 			const mapped = getGitCommandError(
 				'cherry-pick',
 				ex,
@@ -157,7 +263,9 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			author?: string;
 			date?: string;
 			signoff?: boolean;
+			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -184,11 +292,15 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		params.push('-F', '-');
 
 		try {
-			await this.git.exec({ cwd: repoPath, stdin: message, stdinEncoding: 'utf8', errors: 'throw' }, ...params);
+			await this.git.run(
+				{ cwd: repoPath, stdin: message, stdinEncoding: 'utf8', errors: 'throw', ...runOptions },
+				...params,
+			);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, params, ex, options?.source);
 			throw getGitCommandError(
 				'commit',
 				ex,
@@ -206,6 +318,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async fetch(
 		repoPath: string,
 		options?: { all?: boolean; branch?: GitBranchReference; prune?: boolean; pull?: boolean; remote?: string },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -215,14 +328,18 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 				const [branchName, remoteName] = getBranchNameAndRemote(branch);
 				if (remoteName == null) return;
 
-				await this.fetchCore(repoPath, {
-					branch: branchName,
-					remote: remoteName,
-					upstream: getBranchTrackingWithoutRemote(branch)!,
-					pull: options?.pull,
-				});
+				await this.fetchCore(
+					repoPath,
+					{
+						branch: branchName,
+						remote: remoteName,
+						upstream: getBranchTrackingWithoutRemote(branch)!,
+						pull: options?.pull,
+					},
+					runOptions,
+				);
 			} else {
-				await this.fetchCore(repoPath, opts);
+				await this.fetchCore(repoPath, opts, runOptions);
 			}
 
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'tags');
@@ -245,6 +362,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 					remote: string;
 					upstream: string;
 			  },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['fetch'];
 
@@ -265,7 +383,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'fetch',
@@ -289,7 +407,8 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async merge(
 		repoPath: string,
 		ref: string,
-		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean },
+		options?: { fastForward?: boolean | 'only'; noCommit?: boolean; squash?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -312,9 +431,9 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		args.push(ref);
 
 		try {
-			await this.git.exec(
+			await this.git.run(
 				// Avoid a timeout since merges can take a long time (set to 0 to disable)
-				{ cwd: repoPath, errors: 'throw', timeout: 0 },
+				{ cwd: repoPath, errors: 'throw', timeout: 0, ...runOptions },
 				...args,
 			);
 
@@ -323,6 +442,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 			const mapped = getGitCommandError(
 				'merge',
 				ex,
@@ -343,7 +463,8 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	@debug()
 	async pull(
 		repoPath: string,
-		options?: { branch?: GitBranchReference; rebase?: boolean; tags?: boolean },
+		options?: { branch?: GitBranchReference; rebase?: boolean; tags?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -357,23 +478,33 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 				);
 				if (worktree != null) {
 					// Branch is checked out in a worktree — run git pull in that worktree's directory
-					await this.pullCore(normalizePath(worktree.uri.fsPath), {
-						rebase: options?.rebase,
-						tags: options?.tags,
-					});
+					await this.pullCore(
+						normalizePath(worktree.uri.fsPath),
+						{
+							rebase: options?.rebase,
+							tags: options?.tags,
+							source: options?.source,
+						},
+						runOptions,
+					);
 					this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status', 'tags');
 					this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'remotes', 'index']);
 				} else {
 					// Branch is not checked out anywhere — can only fetch (no working tree to merge into)
-					await this.fetch(repoPath, { branch: branch });
+					await this.fetch(repoPath, { branch: branch }, runOptions);
 				}
 				return;
 			}
 
-			await this.pullCore(repoPath, {
-				rebase: options?.rebase,
-				tags: options?.tags,
-			});
+			await this.pullCore(
+				repoPath,
+				{
+					rebase: options?.rebase,
+					tags: options?.tags,
+					source: options?.source,
+				},
+				runOptions,
+			);
 
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status', 'tags');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'remotes', 'index']);
@@ -383,7 +514,11 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 	}
 
-	private async pullCore(repoPath: string, options: { rebase?: boolean; tags?: boolean }): Promise<void> {
+	private async pullCore(
+		repoPath: string,
+		options: { rebase?: boolean; tags?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
+	): Promise<void> {
 		const params = ['pull'];
 
 		if (options.tags) {
@@ -395,8 +530,9 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath, configs: gitConfigsPull }, ...params);
+			await this.git.run({ cwd: repoPath, configs: gitConfigsPull, ...runOptions }, ...params);
 		} catch (ex) {
+			await this.throwIfSigningError(repoPath, params, ex, options.source);
 			throw getGitCommandError(
 				'pull',
 				ex,
@@ -411,6 +547,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 	async push(
 		repoPath: string,
 		options?: { reference?: GitReference; force?: boolean; publish?: { remote: string } },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -469,27 +606,40 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.pushCore(repoPath, {
-				branch: branchName,
-				remote: remoteName,
-				upstream: upstreamName,
-				force: forceOpts,
-				publish: options?.publish != null,
-			});
-
-			// Since Git can't setup upstream tracking when publishing a new branch to a specific commit, do it now
+			await this.pushCore(
+				repoPath,
+				{
+					branch: branchName,
+					remote: remoteName,
+					upstream: upstreamName,
+					force: forceOpts,
+					publish: options?.publish != null,
+				},
+				runOptions,
+			);
+
+			// Since Git can't setup upstream tracking when publishing a new branch to a specific commit, do it now.
+			// Soft-fail: the push already succeeded, so don't let a local upstream-tracking failure (cancellation
+			// arriving mid-spawn, transient git error) suppress the post-push hook fan-out below.
 			if (setUpstream != null) {
-				await this.git.exec(
-					{ cwd: repoPath },
-					'branch',
-					'--set-upstream-to',
-					`${setUpstream.remote}/${setUpstream.remoteBranch}`,
-					setUpstream.branch,
-				);
+				try {
+					await this.git.run(
+						{ cwd: repoPath, ...runOptions },
+						'branch',
+						'--set-upstream-to',
+						`${setUpstream.remote}/${setUpstream.remoteBranch}`,
+						setUpstream.branch,
+					);
+				} catch (ex) {
+					scope?.error(ex, 'Unable to set upstream tracking after publish');
+				}
 			}
 
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-			this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
+			this.context.hooks?.repository?.onChanged?.(
+				repoPath,
+				options?.publish != null ? ['config', 'heads', 'remotes'] : ['remotes'],
+			);
 		} catch (ex) {
 			scope?.error(ex);
 			throw ex;
@@ -506,6 +656,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			upstream?: string;
 			delete?: { remote: string; branch: string };
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['push'];
 
@@ -537,7 +688,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			const error = getGitCommandError(
 				'push',
@@ -609,7 +760,9 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			interactive?: boolean;
 			onto?: string;
 			updateRefs?: boolean;
+			source?: unknown;
 		},
+		runOptions?: GitOperationRunOptions,
 	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
@@ -643,9 +796,9 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 
 		try {
-			await this.git.exec(
+			await this.git.run(
 				// Avoid a timeout since rebases can take a long time (set to 0 to disable)
-				{ cwd: repoPath, errors: 'throw', configs: configs, timeout: 0 },
+				{ cwd: repoPath, errors: 'throw', configs: configs, timeout: 0, ...runOptions },
 				...args,
 			);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
@@ -653,6 +806,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 			const mapped = getGitCommandError(
 				'rebase',
 				ex,
@@ -678,11 +832,12 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		rev: string,
 		options?: { mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft' },
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const scope = getScopedLogger();
 
 		try {
-			await this.resetCore(repoPath, rev, options?.mode);
+			await this.resetCore(repoPath, rev, options?.mode, runOptions);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'branches', 'status');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['head', 'heads', 'index']);
 		} catch (ex) {
@@ -695,6 +850,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		repoPath: string,
 		rev: string,
 		mode?: 'hard' | 'keep' | 'merge' | 'mixed' | 'soft',
+		runOptions?: GitOperationRunOptions,
 	): Promise<void> {
 		const params = ['reset', '-q'];
 		if (mode) {
@@ -703,7 +859,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		params.push(rev, '--');
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...params);
+			await this.git.run({ cwd: repoPath, ...runOptions }, ...params);
 		} catch (ex) {
 			throw getGitCommandError(
 				'reset',
@@ -716,7 +872,12 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 
 	@sequentialize({ getQueueKey: rp => rp })
 	@debug()
-	async revert(repoPath: string, refs: string[], options?: { editMessage?: boolean }): Promise<GitOperationResult> {
+	async revert(
+		repoPath: string,
+		refs: string[],
+		options?: { editMessage?: boolean; source?: unknown },
+		runOptions?: GitOperationRunOptions,
+	): Promise<GitOperationResult> {
 		const scope = getScopedLogger();
 
 		const args = ['revert'];
@@ -730,9 +891,9 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		args.push(...refs);
 
 		try {
-			await this.git.exec(
+			await this.git.run(
 				// Avoid a timeout since reverts can take a long time (set to 0 to disable)
-				{ cwd: repoPath, errors: 'throw', timeout: 0 },
+				{ cwd: repoPath, errors: 'throw', timeout: 0, ...runOptions },
 				...args,
 			);
 
@@ -741,6 +902,7 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 			return { conflicted: false };
 		} catch (ex) {
 			scope?.error(ex);
+			await this.throwIfSigningError(repoPath, args, ex, options?.source);
 
 			const mapped = getGitCommandError(
 				'revert',
@@ -758,6 +920,40 @@ export class OperationsGitSubProvider implements GitOperationsSubProvider {
 		}
 	}
 
+	/**
+	 * Classifies `ex` as a signing failure; if so, fires the `commits.onSigningFailed`
+	 * hook and throws a typed {@link SigningError}. Callers should invoke this first
+	 * in their catch blocks, before falling through to command-specific error mapping
+	 * via {@link getGitCommandError}.
+	 *
+	 * `SigningFormat` is read opportunistically from `config.getSigningConfig`, with
+	 * {@link inferSigningFormatFromError} as a stderr-based fallback and `'gpg'` as
+	 * the final default.
+	 */
+	private async throwIfSigningError(
+		repoPath: string,
+		args: readonly (string | undefined)[],
+		ex: unknown,
+		source?: unknown,
+	): Promise<void> {
+		const reason = classifySigningError(ex);
+		if (reason == null) return;
+
+		let format: SigningFormat | undefined;
+		try {
+			format = (await this.provider.config.getSigningConfig?.(repoPath))?.format;
+		} catch {
+			// Fall through — config read failed; use stderr-inferred format or gpg default
+		}
+		format ??= inferSigningFormatFromError(ex) ?? 'gpg';
+
+		this.context.hooks?.commits?.onSigningFailed?.(reason, format, source);
+		throw new SigningError(
+			{ reason: reason, gitCommand: { repoPath: repoPath, args: args } },
+			ex instanceof Error ? ex : undefined,
+		);
+	}
+
 	private async createConflictResult(repoPath: string, command: GitConflictCommand): Promise<GitOperationResult> {
 		let conflicts: GitConflictFile[] | undefined;
 		try {