Add Sort Order Option setting to address #27759

extensions/git/package.json

@@ -1665,6 +1665,18 @@
           "scope": "resource",
           "default": true,
           "description": "%config.showCommitInput%"
+        },
+        "git.terminalAuthentication": {
+          "type": "boolean",
+          "scope": "resource",
+          "default": true,
+          "description": "%config.terminalAuthentication%"
+        },
+        "git.githubAuthentication": {
+          "type": "boolean",
+          "scope": "resource",
+          "default": true,
+          "description": "%config.githubAuthentication%"
         }
       }
     },
@@ -1777,6 +1789,7 @@
           "ignore"
         ],
         "filenames": [
+          ".gitignore_global",
           ".gitignore"
         ],
         "configuration": "./languages/ignore.language-configuration.json"

extensions/git/package.nls.json

@@ -144,6 +144,8 @@
 	"config.untrackedChanges.separate": "Untracked changes appear separately in the Source Control view. They are also excluded from several actions.",
 	"config.untrackedChanges.hidden": "Untracked changes are hidden and excluded from several actions.",
 	"config.showCommitInput": "Controls whether to show the commit input in the Git source control panel.",
+	"config.terminalAuthentication": "Controls whether to enable VS Code to be the authentication handler for git processes spawned in the integrated terminal.",
+	"config.githubAuthentication": "Controls whether to enable automatic GitHub authentication for git commands within VS Code.",
 	"colors.added": "Color for added resources.",
 	"colors.modified": "Color for modified resources.",
 	"colors.deleted": "Color for deleted resources.",

extensions/git/src/api/api1.ts

@@ -5,7 +5,7 @@
 
 import { Model } from '../model';
 import { Repository as BaseRepository, Resource } from '../repository';
-import { InputBox, Git, API, Repository, Remote, RepositoryState, Branch, Ref, Submodule, Commit, Change, RepositoryUIState, Status, LogOptions, APIState, CommitOptions, GitExtension, RefType, RemoteSourceProvider } from './git';
+import { InputBox, Git, API, Repository, Remote, RepositoryState, Branch, Ref, Submodule, Commit, Change, RepositoryUIState, Status, LogOptions, APIState, CommitOptions, GitExtension, RefType, RemoteSourceProvider, CredentialsProvider } from './git';
 import { Event, SourceControlInputBox, Uri, SourceControl, Disposable, commands } from 'vscode';
 import { mapEvent } from '../util';
 import { toGitUri } from '../uri';
@@ -263,6 +263,10 @@ export class ApiImpl implements API {
 		return this._model.registerRemoteSourceProvider(provider);
 	}
 
+	registerCredentialsProvider(provider: CredentialsProvider): Disposable {
+		return this._model.registerCredentialsProvider(provider);
+	}
+
 	constructor(private _model: Model) { }
 }
 

extensions/git/src/api/git.d.ts

@@ -204,6 +204,15 @@ export interface RemoteSourceProvider {
 	getRemoteSources(query?: string): ProviderResult<RemoteSource[]>;
 }
 
+export interface Credentials {
+	readonly username: string;
+	readonly password: string;
+}
+
+export interface CredentialsProvider {
+	getCredentials(host: Uri): ProviderResult<Credentials>;
+}
+
 export type APIState = 'uninitialized' | 'initialized';
 
 export interface API {
@@ -217,7 +226,9 @@ export interface API {
 	toGitUri(uri: Uri, ref: string): Uri;
 	getRepository(uri: Uri): Repository | null;
 	init(root: Uri): Promise<Repository | null>;
+
 	registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable;
+	registerCredentialsProvider(provider: CredentialsProvider): Disposable;
 }
 
 export interface GitExtension {

extensions/git/src/askpass.sh

@@ -1,5 +1,5 @@
 #!/bin/sh
 VSCODE_GIT_ASKPASS_PIPE=`mktemp`
-VSCODE_GIT_ASKPASS_PIPE="$VSCODE_GIT_ASKPASS_PIPE" "$VSCODE_GIT_ASKPASS_NODE" "$VSCODE_GIT_ASKPASS_MAIN" $*
+ELECTRON_RUN_AS_NODE="1" VSCODE_GIT_ASKPASS_PIPE="$VSCODE_GIT_ASKPASS_PIPE" "$VSCODE_GIT_ASKPASS_NODE" "$VSCODE_GIT_ASKPASS_MAIN" $*
 cat $VSCODE_GIT_ASKPASS_PIPE
-rm $VSCODE_GIT_ASKPASS_PIPE
+rm $VSCODE_GIT_ASKPASS_PIPE

extensions/git/src/askpass.ts

@@ -3,36 +3,60 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { window, InputBoxOptions } from 'vscode';
-import { IDisposable } from './util';
+import { window, InputBoxOptions, Uri, OutputChannel, Disposable } from 'vscode';
+import { IDisposable, EmptyDisposable, toDisposable } from './util';
 import * as path from 'path';
-import { IIPCHandler, IIPCServer } from './ipc/ipcServer';
-
-export interface AskpassEnvironment {
-	GIT_ASKPASS: string;
-	ELECTRON_RUN_AS_NODE?: string;
-	VSCODE_GIT_ASKPASS_NODE?: string;
-	VSCODE_GIT_ASKPASS_MAIN?: string;
-	VSCODE_GIT_ASKPASS_HANDLE?: string;
-}
+import { IIPCHandler, IIPCServer, createIPCServer } from './ipc/ipcServer';
+import { CredentialsProvider, Credentials } from './api/git';
 
 export class Askpass implements IIPCHandler {
 
-	private disposable: IDisposable;
+	private disposable: IDisposable = EmptyDisposable;
+	private cache = new Map<string, Credentials>();
+	private credentialsProviders = new Set<CredentialsProvider>();
 
-	static getDisabledEnv(): AskpassEnvironment {
-		return {
-			GIT_ASKPASS: path.join(__dirname, 'askpass-empty.sh')
-		};
+	static async create(outputChannel: OutputChannel, context?: string): Promise<Askpass> {
+		try {
+			return new Askpass(await createIPCServer(context));
+		} catch (err) {
+			outputChannel.appendLine(`[error] Failed to create git askpass IPC: ${err}`);
+			return new Askpass();
+		}
 	}
 
-	constructor(ipc: IIPCServer) {
-		this.disposable = ipc.registerHandler('askpass', this);
+	private constructor(private ipc?: IIPCServer) {
+		if (ipc) {
+			this.disposable = ipc.registerHandler('askpass', this);
+		}
 	}
 
 	async handle({ request, host }: { request: string, host: string }): Promise<string> {
+		const uri = Uri.parse(host);
+		const authority = uri.authority.replace(/^.*@/, '');
+		const password = /password/i.test(request);
+		const cached = this.cache.get(authority);
+
+		if (cached && password) {
+			this.cache.delete(authority);
+			return cached.password;
+		}
+
+		if (!password) {
+			for (const credentialsProvider of this.credentialsProviders) {
+				try {
+					const credentials = await credentialsProvider.getCredentials(uri);
+
+					if (credentials) {
+						this.cache.set(authority, credentials);
+						setTimeout(() => this.cache.delete(authority), 60_000);
+						return credentials.username;
+					}
+				} catch { }
+			}
+		}
+
 		const options: InputBoxOptions = {
-			password: /password/i.test(request),
+			password,
 			placeHolder: request,
 			prompt: `Git: ${host}`,
 			ignoreFocusOut: true
@@ -41,15 +65,26 @@ export class Askpass implements IIPCHandler {
 		return await window.showInputBox(options) || '';
 	}
 
-	getEnv(): AskpassEnvironment {
+	getEnv(): { [key: string]: string; } {
+		if (!this.ipc) {
+			return {
+				GIT_ASKPASS: path.join(__dirname, 'askpass-empty.sh')
+			};
+		}
+
 		return {
-			ELECTRON_RUN_AS_NODE: '1',
+			...this.ipc.getEnv(),
 			GIT_ASKPASS: path.join(__dirname, 'askpass.sh'),
 			VSCODE_GIT_ASKPASS_NODE: process.execPath,
 			VSCODE_GIT_ASKPASS_MAIN: path.join(__dirname, 'askpass-main.js')
 		};
 	}
 
+	registerCredentialsProvider(provider: CredentialsProvider): Disposable {
+		this.credentialsProviders.add(provider);
+		return toDisposable(() => this.credentialsProviders.delete(provider));
+	}
+
 	dispose(): void {
 		this.disposable.dispose();
 	}

extensions/git/src/commands.ts

@@ -2560,6 +2560,14 @@ export class CommandCenter {
 						type = 'warning';
 						options.modal = false;
 						break;
+					case GitErrorCodes.AuthenticationFailed:
+						const regex = /Authentication failed for '(.*)'/i;
+						const match = regex.exec(err.stderr || String(err));
+
+						message = match
+							? localize('auth failed specific', "Failed to authenticate to git remote:\n\n{0}", match[1])
+							: localize('auth failed', "Failed to authenticate to git remote.");
+						break;
 					case GitErrorCodes.NoUserNameConfigured:
 					case GitErrorCodes.NoUserEmailConfigured:
 						message = localize('missing user info', "Make sure you configure your 'user.name' and 'user.email' in git.");

extensions/git/src/git.ts

@@ -306,7 +306,7 @@ export interface IGitOptions {
 function getGitErrorCode(stderr: string): string | undefined {
 	if (/Another git process seems to be running in this repository|If no other git process is currently running/.test(stderr)) {
 		return GitErrorCodes.RepositoryIsLocked;
-	} else if (/Authentication failed/.test(stderr)) {
+	} else if (/Authentication failed/i.test(stderr)) {
 		return GitErrorCodes.AuthenticationFailed;
 	} else if (/Not a git repository/i.test(stderr)) {
 		return GitErrorCodes.NotAGitRepository;

extensions/git/src/github.ts

@@ -0,0 +1,66 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CredentialsProvider, Credentials } from './api/git';
+import { IDisposable, filterEvent, EmptyDisposable } from './util';
+import { workspace, Uri, AuthenticationSession, authentication } from 'vscode';
+import { Askpass } from './askpass';
+
+export class GitHubCredentialProvider implements CredentialsProvider {
+
+	async getCredentials(host: Uri): Promise<Credentials | undefined> {
+		if (!/github\.com/i.test(host.authority)) {
+			return;
+		}
+
+		const session = await this.getSession();
+		return { username: session.account.id, password: await session.getAccessToken() };
+	}
+
+	private async getSession(): Promise<AuthenticationSession> {
+		const authenticationSessions = await authentication.getSessions('github', ['repo']);
+
+		if (authenticationSessions.length) {
+			return await authenticationSessions[0];
+		} else {
+			return await authentication.login('github', ['repo']);
+		}
+	}
+}
+
+export class GithubCredentialProviderManager {
+
+	private providerDisposable: IDisposable = EmptyDisposable;
+	private readonly disposable: IDisposable;
+
+	private _enabled = false;
+	private set enabled(enabled: boolean) {
+		if (this._enabled === enabled) {
+			return;
+		}
+
+		this._enabled = enabled;
+
+		if (enabled) {
+			this.providerDisposable = this.askpass.registerCredentialsProvider(new GitHubCredentialProvider());
+		} else {
+			this.providerDisposable.dispose();
+		}
+	}
+
+	constructor(private readonly askpass: Askpass) {
+		this.disposable = filterEvent(workspace.onDidChangeConfiguration, e => e.affectsConfiguration('git'))(this.refresh, this);
+		this.refresh();
+	}
+
+	private refresh(): void {
+		this.enabled = workspace.getConfiguration('git', null).get('githubAuthentication', true);
+	}
+
+	dispose(): void {
+		this.enabled = false;
+		this.disposable.dispose();
+	}
+}

extensions/git/src/ipc/ipcServer.ts

@@ -11,27 +11,42 @@ import * as os from 'os';
 import * as fs from 'fs';
 import * as crypto from 'crypto';
 
-function getIPCHandlePath(nonce: string): string {
+function getIPCHandlePath(id: string): string {
 	if (process.platform === 'win32') {
-		return `\\\\.\\pipe\\vscode-git-ipc-${nonce}-sock`;
+		return `\\\\.\\pipe\\vscode-git-${id}-sock`;
 	}
 
 	if (process.env['XDG_RUNTIME_DIR']) {
-		return path.join(process.env['XDG_RUNTIME_DIR'] as string, `vscode-git-ipc-${nonce}.sock`);
+		return path.join(process.env['XDG_RUNTIME_DIR'] as string, `vscode-git-${id}.sock`);
 	}
 
-	return path.join(os.tmpdir(), `vscode-git-ipc-${nonce}.sock`);
+	return path.join(os.tmpdir(), `vscode-git-${id}.sock`);
 }
 
 export interface IIPCHandler {
 	handle(request: any): Promise<any>;
 }
 
-export async function createIPCServer(): Promise<IIPCServer> {
+export async function createIPCServer(context?: string): Promise<IIPCServer> {
 	const server = http.createServer();
-	const buffer = await new Promise<Buffer>((c, e) => crypto.randomBytes(20, (err, buf) => err ? e(err) : c(buf)));
-	const nonce = buffer.toString('hex');
-	const ipcHandlePath = getIPCHandlePath(nonce);
+	const hash = crypto.createHash('sha1');
+
+	if (!context) {
+		const buffer = await new Promise<Buffer>((c, e) => crypto.randomBytes(20, (err, buf) => err ? e(err) : c(buf)));
+		hash.update(buffer);
+	} else {
+		hash.update(context);
+	}
+
+	const ipcHandlePath = getIPCHandlePath(hash.digest('hex').substr(0, 10));
+
+	if (process.platform !== 'win32') {
+		try {
+			await fs.promises.unlink(ipcHandlePath);
+		} catch {
+			// noop
+		}
+	}
 
 	return new Promise((c, e) => {
 		try {
@@ -46,7 +61,7 @@ export async function createIPCServer(): Promise<IIPCServer> {
 
 export interface IIPCServer extends Disposable {
 	readonly ipcHandlePath: string | undefined;
-	getEnv(): any;
+	getEnv(): { [key: string]: string; };
 	registerHandler(name: string, handler: IIPCHandler): Disposable;
 }
 
@@ -91,7 +106,7 @@ class IPCServer implements IIPCServer, Disposable {
 		});
 	}
 
-	getEnv(): any {
+	getEnv(): { [key: string]: string; } {
 		return { VSCODE_GIT_IPC_HANDLE: this.ipcHandlePath };
 	}