Merge remote-tracking branch 'origin/main' into alexd/popular-krill

Author: alexdima

extensions/git/package.json

@@ -3372,22 +3372,22 @@
       {
         "view": "scm",
         "contents": "%view.workbench.scm.missing%",
-        "when": "config.git.enabled && git.missing"
+        "when": "config.git.enabled && git.missing && remoteName != ''"
       },
       {
         "view": "scm",
         "contents": "%view.workbench.scm.missing.mac%",
-        "when": "config.git.enabled && git.missing && isMac"
+        "when": "config.git.enabled && git.missing && remoteName == '' && isMac"
       },
       {
         "view": "scm",
         "contents": "%view.workbench.scm.missing.windows%",
-        "when": "config.git.enabled && git.missing && isWindows"
+        "when": "config.git.enabled && git.missing && remoteName == '' && isWindows"
       },
       {
         "view": "scm",
         "contents": "%view.workbench.scm.missing.linux%",
-        "when": "config.git.enabled && git.missing && isLinux"
+        "when": "config.git.enabled && git.missing && remoteName == '' && isLinux"
       },
       {
         "view": "scm",

extensions/git/src/api/api1.ts

@@ -72,7 +72,6 @@ export class ApiRepositoryUIState implements RepositoryUIState {
 }
 
 export class ApiRepository implements Repository {
-
 	#repository: BaseRepository;
 
 	readonly rootUri: Uri;
@@ -311,9 +310,19 @@ export class ApiRepository implements Repository {
 export class ApiGit implements Git {
 	#model: Model;
 
+	private _env: { [key: string]: string } | undefined;
+
 	constructor(model: Model) { this.#model = model; }
 
 	get path(): string { return this.#model.git.path; }
+
+	get env(): { [key: string]: string } {
+		if (this._env === undefined) {
+			this._env = Object.freeze(this.#model.git.env);
+		}
+
+		return this._env;
+	}
 }
 
 export class ApiImpl implements API {

extensions/git/src/commands.ts

@@ -309,7 +309,7 @@ async function categorizeResourceByResolution(resources: Resource[]): Promise<{
 	const isBothAddedOrModified = (s: Resource) => s.type === Status.BOTH_MODIFIED || s.type === Status.BOTH_ADDED;
 	const isAnyDeleted = (s: Resource) => s.type === Status.DELETED_BY_THEM || s.type === Status.DELETED_BY_US;
 	const possibleUnresolved = merge.filter(isBothAddedOrModified);
-	const promises = possibleUnresolved.map(s => grep(s.resourceUri.fsPath, /^<{7}|^={7}|^>{7}/));
+	const promises = possibleUnresolved.map(s => grep(s.resourceUri.fsPath, /^<{7}\s|^={7}$|^>{7}\s/));
 	const unresolvedBothModified = await Promise.all<boolean>(promises);
 	const resolved = possibleUnresolved.filter((_s, i) => !unresolvedBothModified[i]);
 	const deletionConflicts = merge.filter(s => isAnyDeleted(s));

extensions/git/src/fileSystemProvider.ts

@@ -192,7 +192,8 @@ export class GitFileSystemProvider implements FileSystemProvider {
 		try {
 			return await repository.buffer(sanitizeRef(ref, path, repository), path);
 		} catch (err) {
-			return new Uint8Array(0);
+			// File does not exist in git (ex: git ignored)
+			throw FileSystemError.FileNotFound();
 		}
 	}
 

extensions/git/src/git.ts

@@ -315,7 +315,7 @@ export interface IGitOptions {
 	gitPath: string;
 	userAgent: string;
 	version: string;
-	env?: any;
+	env?: { [key: string]: string };
 }
 
 function getGitErrorCode(stderr: string): string | undefined {
@@ -369,7 +369,8 @@ export class Git {
 	readonly path: string;
 	readonly userAgent: string;
 	readonly version: string;
-	private env: any;
+	readonly env: { [key: string]: string };
+
 	private commandsToLog: string[] = [];
 
 	private _onOutput = new EventEmitter();
@@ -1657,9 +1658,9 @@ export class Repository {
 		await this.exec(args);
 	}
 
-	async stage(path: string, data: string): Promise<void> {
+	async stage(path: string, data: string, encoding: string): Promise<void> {
 		const child = this.stream(['hash-object', '--stdin', '-w', '--path', sanitizePath(path)], { stdio: [null, null, null] });
-		child.stdin!.end(data, 'utf8');
+		child.stdin!.end(iconv.encode(data, encoding));
 
 		const { exitCode, stdout } = await exec(child);
 		const hash = stdout.toString('utf8');

extensions/git/src/repository.ts

@@ -7,6 +7,7 @@ import TelemetryReporter from '@vscode/extension-telemetry';
 import * as fs from 'fs';
 import * as path from 'path';
 import picomatch from 'picomatch';
+import * as iconv from '@vscode/iconv-lite-umd';
 import { CancellationError, CancellationToken, CancellationTokenSource, Command, commands, Disposable, Event, EventEmitter, FileDecoration, l10n, LogLevel, LogOutputChannel, Memento, ProgressLocation, ProgressOptions, QuickDiffProvider, RelativePattern, scm, SourceControl, SourceControlInputBox, SourceControlInputBoxValidation, SourceControlInputBoxValidationType, SourceControlResourceDecorations, SourceControlResourceGroup, SourceControlResourceState, TabInputNotebookDiff, TabInputTextDiff, TabInputTextMultiDiff, ThemeColor, Uri, window, workspace, WorkspaceEdit } from 'vscode';
 import { ActionButton } from './actionButton';
 import { ApiRepository } from './api/api1';
@@ -24,6 +25,7 @@ import { StatusBarCommands } from './statusbar';
 import { toGitUri } from './uri';
 import { anyEvent, combinedDisposable, debounceEvent, dispose, EmptyDisposable, eventToPromise, filterEvent, find, IDisposable, isDescendant, onceEvent, pathEquals, relativePath } from './util';
 import { IFileWatcher, watch } from './watch';
+import { detectEncoding } from './encoding';
 
 const timeout = (millis: number) => new Promise(c => setTimeout(c, millis));
 
@@ -1215,7 +1217,17 @@ export class Repository implements Disposable {
 	async stage(resource: Uri, contents: string): Promise<void> {
 		const path = relativePath(this.repository.root, resource.fsPath).replace(/\\/g, '/');
 		await this.run(Operation.Stage, async () => {
-			await this.repository.stage(path, contents);
+			const configFiles = workspace.getConfiguration('files', Uri.file(resource.fsPath));
+			let encoding = configFiles.get<string>('encoding') ?? 'utf8';
+			const autoGuessEncoding = configFiles.get<boolean>('autoGuessEncoding') === true;
+			const candidateGuessEncodings = configFiles.get<string[]>('candidateGuessEncodings') ?? [];
+
+			if (autoGuessEncoding) {
+				encoding = detectEncoding(Buffer.from(contents), candidateGuessEncodings) ?? encoding;
+			}
+
+			encoding = iconv.encodingExists(encoding) ? encoding : 'utf8';
+			await this.repository.stage(path, contents, encoding);
 
 			this._onDidChangeOriginalResource.fire(resource);
 			this.closeDiffEditors([], [...resource.fsPath]);

extensions/microsoft-authentication/src/node/authProvider.ts

@@ -2,7 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { AccountInfo, AuthenticationResult, ServerError } from '@azure/msal-node';
+import { AccountInfo, AuthenticationResult, ClientAuthError, ClientAuthErrorCodes, ServerError } from '@azure/msal-node';
 import { AuthenticationGetSessionOptions, AuthenticationProvider, AuthenticationProviderAuthenticationSessionsChangeEvent, AuthenticationProviderSessionOptions, AuthenticationSession, AuthenticationSessionAccountInformation, CancellationError, env, EventEmitter, ExtensionContext, l10n, LogOutputChannel, Uri, window } from 'vscode';
 import { Environment } from '@azure/ms-rest-azure-env';
 import { CachedPublicClientApplicationManager } from './publicClientCache';
@@ -229,6 +229,12 @@ export class MsalAuthProvider implements AuthenticationProvider {
 				throw e;
 			}
 
+			// The user closed the modal window
+			if ((e as ClientAuthError).errorCode === ClientAuthErrorCodes.userCanceled) {
+				this._telemetryReporter.sendLoginFailedEvent();
+				throw e;
+			}
+
 			// The user wants to try the loopback client or we got an error likely due to spinning up the server
 			const loopbackClient = new UriHandlerLoopbackClient(this._uriHandler, redirectUri, this._logger);
 			try {

extensions/microsoft-authentication/src/node/cachedPublicClientApplication.ts

@@ -102,9 +102,19 @@ export class CachedPublicClientApplication implements ICachedPublicClientApplica
 			);
 			if (fiveMinutesBefore < new Date()) {
 				this._logger.debug(`[acquireTokenSilent] [${this._clientId}] [${this._authority}] [${request.scopes.join(' ')}] [${request.account.username}] id token is expired or about to expire. Forcing refresh...`);
-				result = await this._sequencer.queue(() => this._pca.acquireTokenSilent({ ...request, forceRefresh: true }));
+				const newRequest = this._isBrokerAvailable
+					// HACK: Broker doesn't support forceRefresh so we need to pass in claims which will force a refresh
+					? { ...request, claims: '{ "id_token": {}}' }
+					: { ...request, forceRefresh: true };
+				result = await this._sequencer.queue(() => this._pca.acquireTokenSilent(newRequest));
 				this._logger.debug(`[acquireTokenSilent] [${this._clientId}] [${this._authority}] [${request.scopes.join(' ')}] [${request.account.username}] got refreshed result`);
 			}
+			const newIdTokenExpirationInSecs = (result.idTokenClaims as { exp?: number }).exp;
+			if (newIdTokenExpirationInSecs) {
+				if (new Date(newIdTokenExpirationInSecs * 1000) < new Date()) {
+					this._logger.error(`[acquireTokenSilent] [${this._clientId}] [${this._authority}] [${request.scopes.join(' ')}] [${request.account.username}] id token is still expired.`);
+				}
+			}
 		}
 
 		// this._setupRefresh(result);

extensions/npm/src/preferred-pm.ts

@@ -28,6 +28,10 @@ async function isBunPreferred(pkgPath: string): Promise<PreferredProperties> {
 		return { isPreferred: true, hasLockfile: true };
 	}
 
+	if (await pathExists(path.join(pkgPath, 'bun.lock'))) {
+		return { isPreferred: true, hasLockfile: true };
+	}
+
 	return { isPreferred: false, hasLockfile: false };
 }
 

extensions/terminal-suggest/src/terminalSuggestMain.ts

@@ -12,14 +12,14 @@ import codeCompletionSpec from './completions/code';
 import cdSpec from './completions/cd';
 
 let cachedAvailableCommands: Set<string> | undefined;
-let cachedBuiltinCommands: Map<string, string[]> | undefined;
+const cachedBuiltinCommands: Map<string, string[] | undefined> = new Map();
 
 export const availableSpecs = [codeCompletionSpec, codeInsidersCompletionSpec, cdSpec];
 
 function getBuiltinCommands(shell: string): string[] | undefined {
 	try {
 		const shellType = path.basename(shell, path.extname(shell));
-		const cachedCommands = cachedBuiltinCommands?.get(shellType);
+		const cachedCommands = cachedBuiltinCommands.get(shellType);
 		if (cachedCommands) {
 			return cachedCommands;
 		}
@@ -38,32 +38,27 @@ function getBuiltinCommands(shell: string): string[] | undefined {
 				break;
 			}
 			case 'fish': {
-				// TODO: ghost text in the command line prevents
-				// completions from working ATM for fish
+				// TODO: Ghost text in the command line prevents completions from working ATM for fish
 				const fishOutput = execSync('functions -n', options);
 				commands = fishOutput.split(', ').filter(filter);
 				break;
 			}
 			case 'pwsh': {
-				const output = execSync('Get-Command | Select-Object Name, CommandType, DisplayName | ConvertTo-Json', options);
+				// TODO: Select `CommandType, DisplayName` and map to a rich type with kind and detail
+				const output = execSync('Get-Command -All | Select-Object Name | ConvertTo-Json', options);
 				let json: any;
 				try {
 					json = JSON.parse(output);
 				} catch (e) {
 					console.error('Error parsing pwsh output:', e);
 					return [];
 				}
-				// TODO: Return a rich type with kind and detail
 				commands = (json as any[]).map(e => e.Name);
 				break;
 			}
 		}
-		// TODO: Cache failure results too
-		if (commands?.length) {
-			cachedBuiltinCommands?.set(shellType, commands);
-			return commands;
-		}
-		return;
+		cachedBuiltinCommands.set(shellType, commands);
+		return commands;
 
 	} catch (error) {
 		console.error('Error fetching builtin commands:', error);