@gitkraken/core-gitlens 0.9.9 → 0.10.0

package/dist/git/providers/status.d.ts

@@ -11,6 +11,7 @@ export interface GitWorkingChangesState {
   untracked: boolean;
 }
 export interface GitStatusSubProvider {
+  /** Rejects when git fails; resolves `undefined` only for an undefined `repoPath` */
   getStatus(repoPath: string | undefined, options?: {
     priority?: GitCommandPriority;
     force?: boolean;
@@ -25,16 +26,20 @@ export interface GitStatusSubProvider {
   getStatusForPath?(repoPath: string, pathOrUri: string | Uri, options?: {
     renames?: boolean;
   }, cancellation?: AbortSignal): Promise<GitStatusFile[] | undefined>;
+  /** Rejects when git fails, rather than answering `false` */
   hasWorkingChanges(repoPath: string, options?: {
     staged?: boolean;
     unstaged?: boolean;
     untracked?: boolean;
-    throwOnError?: boolean;
     priority?: GitCommandPriority;
   }, cancellation?: AbortSignal): Promise<boolean>;
+  /** Rejects when git fails, rather than answering all `false` */
   getWorkingChangesState(repoPath: string, cancellation?: AbortSignal): Promise<GitWorkingChangesState>;
+  /** Rejects when git fails, rather than answering `false` */
   hasConflictingFiles(repoPath: string, cancellation?: AbortSignal): Promise<boolean>;
+  /** Rejects when git fails, rather than answering empty */
   getConflictingFiles(repoPath: string, cancellation?: AbortSignal): Promise<GitConflictFile[]>;
+  /** Rejects when git fails, rather than answering empty */
   getUntrackedFiles(repoPath: string, cancellation?: AbortSignal): Promise<GitFile[]>;
 }
 //#endregion

package/dist/git/run.types.d.ts

@@ -1,15 +1,15 @@
 import { CacheController } from "../utils/promiseCache.js";
 import { GitWarningKey } from "./errors.js";
 import { RepositoryChange } from "./models/repository.js";
+import { CancellationReason } from "../utils/cancellation.js";
 import { GitHealthSlownessCategory } from "./gitHealth.js";
 //#region ../git/src/run.types.d.ts
 export type GitErrorHandling = 'throw' | 'ignore';
 /**
- * Why a run was aborted. DIAGNOSTIC ONLY — log it, never branch control flow on it. A timeout kill and a
- * caller abort both terminate the process with SIGTERM and surface as the same error, so this is derived
- * from a duration heuristic and can be wrong near the timeout boundary.
+ * Why a run was cancelled. Exact, read from how the process ended: a caller abort, the run's own `timeout`, or a
+ * SIGTERM from outside (`unknown`).
  */
-export type GitRunCancellation = 'aborted' | 'timeout' | 'unknown';
+export type GitRunCancellation = CancellationReason;
 /**
  * Why a run produced no answer. Every value is structurally distinguishable, so these are safe to branch on.
  *
@@ -91,6 +91,11 @@ export interface GitRunOptions {
   configs?: readonly string[];
   readonly correlationKey?: string;
   errors?: GitErrorHandling;
+  /**
+   * Non-zero exit codes that are answers rather than failures (e.g. `1` from `diff --quiet`, "has differences");
+   * a listed code resolves as `exited` with that `exitCode` in every `errors` mode.
+   */
+  expectedExitCodes?: readonly number[];
   /** Priority level for queue ordering. If not specified, will be inferred from the command type. */
   priority?: GitCommandPriority;
   /** Specifies that this command should always be executed locally if possible (for live share sessions) */

package/dist/git-cli/exec/git.js

@@ -5,7 +5,7 @@ import { Logger as _logger } from "../../utils/logger.js";
 import { formatLoggableScopeBlock } from "../../utils/logger.scoped.js";
 import { defer } from "../../utils/promise.js";
 import { arePathsEqual, dirname as dirname$1, isAbsolute as isAbsolute$1, isDescendant, joinPaths, normalizePath } from "../../utils/path.js";
-import { GitWarnings, WorkspaceUntrustedError } from "../../git/errors.js";
+import { GitWarnings, WorkspaceUntrustedError, getGitWarning } from "../../git/errors.js";
 import { gitFeaturesByVersion } from "../../git/features.js";
 import { CancelledRunError, RunError, endStdin, fsExists, runSpawn } from "../../utils/env/node/exec.js";
 import { compare, fromString } from "../../utils/version.js";
@@ -616,7 +616,7 @@ var Git = class {
 		const start = hrtime();
 		const startEpochMs = Date.now();
 		gitCommand = `[${options.cwd}] ${gitCommand}`;
-		const { cancellation, configs, correlationKey, errors: errorHandling, encoding, runLocally: _, selfMaintenance, slownessCategory, ...opts } = options;
+		const { cancellation, configs, correlationKey, errors: errorHandling, encoding, expectedExitCodes, runLocally: _, selfMaintenance, slownessCategory, ...opts } = options;
 		const defaultTimeout = this.options.gitTimeout ?? 6e4;
 		const runOpts = {
 			...opts,
@@ -660,7 +660,7 @@ var Git = class {
 		try {
 			result = await promise;
 			if (result.exitCode == null) {
-				if (result.signal === "SIGTERM") throw new CancelledRunError(gitCommand, true, void 0, result.signal);
+				if (result.signal === "SIGTERM") throw new CancelledRunError(gitCommand, true, void 0, result.signal, result.killed ? "timeout" : "unknown");
 				return {
 					stdout: result.stdout,
 					stderr: result.stderr,
@@ -681,12 +681,24 @@ var Git = class {
 				}
 			};
 		} catch (ex) {
+			if (expectedExitCodes?.length && ex instanceof RunError && !(ex instanceof CancelledRunError)) {
+				const code = toExitCode(ex.code);
+				if (code != null && expectedExitCodes.includes(code)) return {
+					stdout: ex.stdout,
+					stderr: ex.stderr,
+					exitCode: code,
+					completion: {
+						status: "exited",
+						code
+					}
+				};
+			}
 			let cancellationReason = "unknown";
 			if (ex instanceof CancelledRunError) {
 				const duration = getDurationMilliseconds(start);
 				const timeout = runOpts.timeout ?? 0;
-				const reason = timeout > 0 && duration >= timeout - 100 ? "timeout" : cancellation?.aborted ? "cancellation" : "unknown";
-				cancellationReason = reason === "cancellation" ? "aborted" : reason;
+				cancellationReason = ex.reason !== "unknown" ? ex.reason : cancellation?.aborted ? "aborted" : "unknown";
+				const reason = cancellationReason === "aborted" ? "cancellation" : cancellationReason;
 				const loopDelayAnnotation = this.formatEventLoopDelayAnnotation(startEpochMs);
 				const loopDelayText = loopDelayAnnotation != null ? ` \u00b7 ${loopDelayAnnotation}` : "";
 				_logger.warn(`${formatLoggableScopeBlock("GIT")} ${gitCommand} \u00b7 ABORTED after ${duration}ms (${reason})${loopDelayText}`);
@@ -699,17 +711,16 @@ var Git = class {
 			}
 			if (errorHandling === "ignore") {
 				if (ex instanceof RunError) {
-					const code = typeof ex.code === "number" ? ex.code : ex.code != null ? parseInt(ex.code, 10) : NaN;
-					const exited = Number.isInteger(code);
+					const code = toExitCode(ex.code);
 					return {
 						stdout: ex.stdout,
 						stderr: ex.stderr,
-						...exited ? { exitCode: code } : {},
+						...code != null ? { exitCode: code } : {},
 						completion: ex instanceof CancelledRunError ? {
 							status: "cancelled",
 							reason: cancellationReason,
 							error: ex
-						} : exited ? {
+						} : code != null ? {
 							status: "exited",
 							code
 						} : {
@@ -729,17 +740,17 @@ var Git = class {
 					}
 				};
 			}
-			if (ex instanceof CancelledRunError || !(ex instanceof RunError) && cancellation?.aborted) exception = new CancellationError(ex instanceof Error ? ex : void 0);
+			if (ex instanceof CancelledRunError) exception = new CancellationError(ex, cancellationReason);
+			else if (!(ex instanceof RunError) && cancellation?.aborted) exception = new CancellationError(ex instanceof Error ? ex : void 0, "aborted");
 			else exception = new GitError(ex);
 			if (errorHandling === "throw") throw exception;
 			const swallowed = exception;
 			const warning = defaultExceptionHandler(exception, options.cwd, start);
 			exception = void 0;
-			const rawCode = swallowed instanceof GitError ? swallowed.exitCode : void 0;
-			const code = typeof rawCode === "number" ? rawCode : rawCode != null ? parseInt(rawCode, 10) : NaN;
+			const code = toExitCode(swallowed instanceof GitError ? swallowed.exitCode : void 0);
 			return {
 				stdout: "",
-				...Number.isInteger(code) ? { exitCode: code } : {},
+				...code != null ? { exitCode: code } : {},
 				completion: {
 					status: "warned",
 					warning,
@@ -792,7 +803,7 @@ var Git = class {
 				}
 				if (signal === "SIGTERM") {
 					if (cancellation?.aborted) resolve();
-					else reject(new CancelledRunError(proc.spawnargs.join(" "), true, code ?? void 0, signal));
+					else reject(new CancelledRunError(proc.spawnargs.join(" "), true, code ?? void 0, signal, "unknown"));
 					return;
 				}
 				if (signal === "SIGPIPE" || code === 141 || code === 128 && stderrChunks.some((c) => c.includes("Connection reset by peer"))) {
@@ -961,6 +972,14 @@ var Git = class {
 	}
 };
 /**
+* The exit code in a run error's `code`, or `undefined` when the process never exited normally: a numeric string
+* is a real exit code, but an errno (`'ENOENT'`) means the spawn itself failed, and `undefined` means it was killed.
+*/
+function toExitCode(code) {
+	const exitCode = typeof code === "number" ? code : code != null ? parseInt(code, 10) : NaN;
+	return Number.isInteger(exitCode) ? exitCode : void 0;
+}
+/**
 * Swallows an error whose message matches a known-benign {@link GitWarnings} pattern, returning WHICH one
 * matched so the caller can record it — the distinction matters, since `noCommits` is a real answer while
 * `notARepository` is a failed read. Rethrows anything else.
@@ -969,10 +988,11 @@ function defaultExceptionHandler(ex, cwd, start) {
 	if (isCancellationError(ex)) throw ex;
 	const msg = ex.message || ex.toString();
 	if (msg) {
-		for (const [key, warning] of Object.entries(GitWarnings)) if (warning.test(msg)) {
+		const warning = getGitWarning(ex);
+		if (warning != null) {
 			const duration = start !== void 0 ? ` [${getDurationMilliseconds(start)}ms]` : "";
 			_logger.warn(`[${cwd}] Git ${msg.trim().replace(/fatal:\s*/g, "").replace(/\r?\n|\r/g, " · ")}${duration}`);
-			return key;
+			return warning;
 		}
 		const match = GitErrors.badRevision.exec(msg);
 		if (match != null) {