Ensures Git streams are closed eagerly

 - Prevents resource leaks and potential `SIGPIPE` errors by explicitly calling `return()` on stream generators
 - Adds detailed start and complete logging for Git stream commands

Author: eamodio

src/env/node/git/git.ts

@@ -169,6 +169,7 @@ function defaultExceptionHandler(ex: Error, cwd: string | undefined, start?: [nu
 }
 
 const uniqueCounterForStdin = getScopedCounter();
+const uniqueCounterForStream = getScopedCounter();
 
 type ExitCodeOnlyGitCommandOptions = GitCommandOptions & { exitCodeOnly: true };
 export type PushForceOptions = { withLease: true; ifIncludes?: boolean } | { withLease: false; ifIncludes?: never };
@@ -392,14 +393,15 @@ export class Git implements Disposable {
 			exception = undefined;
 			return { stdout: '' as T, stderr: result?.stderr as T | undefined, exitCode: result?.exitCode ?? 0 };
 		} finally {
-			this.logGitCommand(gitCommand, exception, getDurationMilliseconds(start), waiting);
+			this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), waiting);
 		}
 	}
 
 	async *stream(options: GitSpawnOptions, ...args: readonly (string | undefined)[]): AsyncGenerator<string> {
 		if (!workspace.isTrusted) throw new WorkspaceUntrustedError();
 
 		const start = hrtime();
+		const streamId = uniqueCounterForStream.next();
 
 		const { cancellation, configs, stdin, stdinEncoding, ...opts } = options;
 		const runArgs = args.filter(a => a != null);
@@ -457,6 +459,7 @@ export class Git implements Disposable {
 
 		const command = await this.path();
 		const proc = spawn(command, runArgs, spawnOpts);
+
 		if (stdin) {
 			proc.stdin?.end(stdin, (stdinEncoding ?? 'utf8') as BufferEncoding);
 		}
@@ -524,7 +527,23 @@ export class Git implements Disposable {
 			});
 		});
 
+		let cleanedUp = false;
+		const cleanup = () => {
+			if (cleanedUp) return;
+			cleanedUp = true;
+
+			try {
+				disposable?.dispose();
+			} catch {}
+			try {
+				proc.removeAllListeners();
+			} catch {}
+			this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), false, streamId);
+		};
+
 		try {
+			this.logGitCommandStart(gitCommand, streamId);
+
 			try {
 				if (proc.stdout) {
 					proc.stdout.setEncoding('utf8');
@@ -544,11 +563,14 @@ export class Git implements Disposable {
 			exception = ex;
 			throw ex;
 		} finally {
-			disposable?.dispose();
-			proc.removeAllListeners();
-
-			this.logGitCommand(gitCommand, exception, getDurationMilliseconds(start), false);
+			cleanup();
 		}
+
+		// Ensure cleanup happens immediately when the generator is explicitly closed (e.g., via break or return)
+		// This is called by JavaScript when the generator is abandoned, ensuring logGitCommand is called
+		// synchronously rather than waiting for garbage collection.
+		// eslint-disable-next-line @typescript-eslint/no-meaningless-void-operator
+		return void cleanup();
 	}
 
 	private _gitLocation: GitLocation | undefined;
@@ -1685,14 +1707,25 @@ export class Git implements Disposable {
 		terminal.sendText(text, options?.execute ?? false);
 	}
 
-	private logGitCommand(command: string, ex: Error | undefined, duration: number, waiting: boolean): void {
+	private logGitCommandStart(command: string, id: number): void {
+		Logger.log(`${getLoggableScopeBlockOverride(`GIT:→${id}`)} ${command} ${GlyphChars.Dot} starting...`);
+		this.logCore(`${getLoggableScopeBlockOverride(`→${id}`, '')} ${command} ${GlyphChars.Dot} starting...`);
+	}
+
+	private logGitCommandComplete(
+		command: string,
+		ex: Error | undefined,
+		duration: number,
+		waiting: boolean,
+		id?: number,
+	): void {
 		const slow = duration > slowCallWarningThreshold;
 		const status = slow && waiting ? ' (slow, waiting)' : waiting ? ' (waiting)' : slow ? ' (slow)' : '';
 
 		if (ex != null) {
 			Logger.error(
 				undefined,
-				`${getLoggableScopeBlockOverride('GIT')} ${command} ${GlyphChars.Dot} ${
+				`${getLoggableScopeBlockOverride(id ? `GIT:←${id}` : 'GIT')} ${command} ${GlyphChars.Dot} ${
 					isCancellationError(ex)
 						? 'cancelled'
 						: (ex.message || String(ex) || '')
@@ -1703,13 +1736,18 @@ export class Git implements Disposable {
 			);
 		} else if (slow) {
 			Logger.warn(
-				`${getLoggableScopeBlockOverride('GIT', `*${duration}ms`)} ${command} [*${duration}ms]${status}`,
+				`${getLoggableScopeBlockOverride(id ? `GIT:←${id}` : 'GIT', `*${duration}ms`)} ${command} [*${duration}ms]${status}`,
 			);
 		} else {
-			Logger.log(`${getLoggableScopeBlockOverride('GIT', `${duration}ms`)} ${command} [${duration}ms]${status}`);
+			Logger.log(
+				`${getLoggableScopeBlockOverride(id ? `GIT:←${id}` : 'GIT', `${duration}ms`)} ${command} [${duration}ms]${status}`,
+			);
 		}
 
-		this.logCore(`${getLoggableScopeBlockOverride(slow ? '*' : '', `${duration}ms`)} ${command}${status}`, ex);
+		this.logCore(
+			`${getLoggableScopeBlockOverride(`${id ? `←${id}` : ''}${slow ? '*' : ''}`, `${duration}ms`)} ${command}${status}`,
+			ex,
+		);
 	}
 
 	private _gitOutput: OutputChannel | undefined;

src/env/node/git/sub-providers/commits.ts

@@ -58,6 +58,7 @@ import { wait } from '../../../../system/promise';
 import type { Cancellable } from '../../../../system/promiseCache';
 import { PromiseCache } from '../../../../system/promiseCache';
 import { maybeStopWatch } from '../../../../system/stopwatch';
+import { createDisposable } from '../../../../system/unifiedDisposable';
 import type { CachedLog, TrackedGitDocument } from '../../../../trackers/trackedDocument';
 import { GitDocumentState } from '../../../../trackers/trackedDocument';
 import type { Git, GitResult } from '../git';
@@ -1427,6 +1428,8 @@ async function parseCommits(
 		return { commits: commits, count: count, countStashChildCommits: countStashChildCommits };
 	}
 
+	using _streamDisposer = createDisposable(() => void resultOrStream.return?.(undefined));
+
 	if (stashes?.size) {
 		const allowFilteredFiles = searchFilters?.files ?? false;
 		const stashesOnly = searchFilters?.type === 'stash';

src/env/node/git/sub-providers/contributors.ts

@@ -16,6 +16,7 @@ import { getLogScope } from '../../../../system/logger.scope';
 import { normalizePath } from '../../../../system/path';
 import type { Cancellable } from '../../../../system/promiseCache';
 import { PromiseCache } from '../../../../system/promiseCache';
+import { createDisposable } from '../../../../system/unifiedDisposable';
 import type { Git } from '../git';
 import { gitConfigsLog } from '../git';
 import type { LocalGitProvider } from '../localGitProvider';
@@ -91,6 +92,7 @@ export class ContributorsGitSubProvider implements GitContributorsSubProvider {
 					'log',
 					...args,
 				);
+				using _streamDisposer = createDisposable(() => void stream.return?.(undefined));
 
 				for await (const c of parser.parseAsync(stream)) {
 					if (signal?.aborted || cancellation?.isCancellationRequested) {

src/env/node/git/sub-providers/graph.ts

@@ -51,7 +51,7 @@ import { find, first, join, last } from '../../../../system/iterable';
 import { Logger } from '../../../../system/logger';
 import { getLogScope } from '../../../../system/logger.scope';
 import { getSettledValue } from '../../../../system/promise';
-import { mixinDisposable } from '../../../../system/unifiedDisposable';
+import { createDisposable, mixinDisposable } from '../../../../system/unifiedDisposable';
 import { serializeWebviewItemContext } from '../../../../system/webview';
 import type {
 	GraphBranchContextValue,
@@ -181,6 +181,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 					cursor?.skip ? `--skip=${cursor.skip}` : undefined,
 					'--',
 				);
+				using _streamDisposer = createDisposable(() => void stream.return?.(undefined));
 
 				const rows: GitGraphRow[] = [];
 
@@ -725,6 +726,7 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 						'--',
 						...files,
 					);
+					using _streamDisposer = createDisposable(() => void stream.return?.(undefined));
 
 					let count = 0;
 					let hasMore = false;

src/env/node/git/sub-providers/status.ts

@@ -19,6 +19,7 @@ import { Logger } from '../../../../system/logger';
 import { getLogScope, setLogScopeExit } from '../../../../system/logger.scope';
 import { stripFolderGlob } from '../../../../system/path';
 import { iterateByDelimiter } from '../../../../system/string';
+import { createDisposable } from '../../../../system/unifiedDisposable';
 import type { Git } from '../git';
 import type { LocalGitProvider } from '../localGitProvider';
 
@@ -226,6 +227,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 	async hasConflictingFiles(repoPath: string, cancellation?: CancellationToken): Promise<boolean> {
 		try {
 			const stream = this.git.stream({ cwd: repoPath, cancellation: cancellation }, 'ls-files', '--unmerged');
+			using _streamDisposer = createDisposable(() => void stream.return?.(undefined));
 
 			// Early exit on first chunk - breaking causes SIGPIPE, killing git process
 			for await (const _chunk of stream) {
@@ -282,6 +284,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 				'--others',
 				'--exclude-standard',
 			);
+			using _streamDisposer = createDisposable(() => void stream.return?.(undefined));
 
 			// Early exit on first chunk - breaking causes SIGPIPE, killing git process
 			for await (const _chunk of stream) {