Merge from vscode 1ce89e2cb720d69c496c2815c4696ee4fd4429a6 (#6779)

* Merge from vscode 1ce89e2cb720d69c496c2815c4696ee4fd4429a6

* redisable accounts because of issues

src/vs/workbench/services/credentials/browser/credentialsService.ts

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ICredentialsService } from 'vs/workbench/services/credentials/common/credentials';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+
+export interface ICredentialsProvider {
+	getPassword(service: string, account: string): Promise<string | null>;
+	setPassword(service: string, account: string, password: string): Promise<void>;
+	deletePassword(service: string, account: string): Promise<boolean>;
+	findPassword(service: string): Promise<string | null>;
+}
+
+export class BrowserCredentialsService implements ICredentialsService {
+
+	_serviceBrand!: ServiceIdentifier<any>;
+
+	private credentialsProvider: ICredentialsProvider;
+
+	constructor(@IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService) {
+		if (environmentService.options && environmentService.options.credentialsProvider) {
+			this.credentialsProvider = environmentService.options.credentialsProvider;
+		} else {
+			this.credentialsProvider = new LocalStorageCredentialsProvider();
+		}
+	}
+
+	async getPassword(service: string, account: string): Promise<string | null> {
+		return this.credentialsProvider.getPassword(service, account);
+	}
+
+	async setPassword(service: string, account: string, password: string): Promise<void> {
+		return this.credentialsProvider.setPassword(service, account, password);
+	}
+
+	async deletePassword(service: string, account: string): Promise<boolean> {
+		return this.credentialsProvider.deletePassword(service, account);
+	}
+
+	async findPassword(service: string): Promise<string | null> {
+		return this.credentialsProvider.findPassword(service);
+	}
+}
+
+interface ICredential {
+	service: string;
+	account: string;
+	password: string;
+}
+
+class LocalStorageCredentialsProvider implements ICredentialsProvider {
+
+	static readonly CREDENTIALS_OPENED_KEY = 'credentials.provider';
+
+	private _credentials: ICredential[];
+	private get credentials(): ICredential[] {
+		if (!this._credentials) {
+			try {
+				const serializedCredentials = window.localStorage.getItem(LocalStorageCredentialsProvider.CREDENTIALS_OPENED_KEY);
+				if (serializedCredentials) {
+					this._credentials = JSON.parse(serializedCredentials);
+				}
+			} catch (error) {
+				// ignore
+			}
+
+			if (!Array.isArray(this._credentials)) {
+				this._credentials = [];
+			}
+		}
+
+		return this._credentials;
+	}
+
+	private save(): void {
+		window.localStorage.setItem(LocalStorageCredentialsProvider.CREDENTIALS_OPENED_KEY, JSON.stringify(this.credentials));
+	}
+
+	async getPassword(service: string, account: string): Promise<string | null> {
+		return this.doGetPassword(service, account);
+	}
+
+	private async doGetPassword(service: string, account?: string): Promise<string | null> {
+		for (const credential of this.credentials) {
+			if (credential.service === service) {
+				if (typeof account !== 'string' || account === credential.account) {
+					return credential.password;
+				}
+			}
+		}
+
+		return null;
+	}
+
+	async setPassword(service: string, account: string, password: string): Promise<void> {
+		this.deletePassword(service, account);
+
+		this.credentials.push({ service, account, password });
+
+		this.save();
+	}
+
+	async deletePassword(service: string, account: string): Promise<boolean> {
+		let found = false;
+
+		this._credentials = this.credentials.filter(credential => {
+			if (credential.service === service && credential.account === account) {
+				found = true;
+
+				return false;
+			}
+
+			return true;
+		});
+
+		if (found) {
+			this.save();
+		}
+
+		return found;
+	}
+
+	async findPassword(service: string): Promise<string | null> {
+		return this.doGetPassword(service);
+	}
+}
+
+registerSingleton(ICredentialsService, BrowserCredentialsService, true);

src/vs/workbench/services/credentials/common/credentials.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator, ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
+
+export const ICredentialsService = createDecorator<ICredentialsService>('ICredentialsService');
+
+export interface ICredentialsService {
+
+	_serviceBrand: ServiceIdentifier<any>;
+
+	getPassword(service: string, account: string): Promise<string | null>;
+	setPassword(service: string, account: string, password: string): Promise<void>;
+	deletePassword(service: string, account: string): Promise<boolean>;
+	findPassword(service: string): Promise<string | null>;
+}

src/vs/workbench/services/credentials/node/credentialsService.ts

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ICredentialsService } from 'vs/workbench/services/credentials/common/credentials';
+import { IdleValue } from 'vs/base/common/async';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
+
+type KeytarModule = {
+	getPassword(service: string, account: string): Promise<string | null>;
+	setPassword(service: string, account: string, password: string): Promise<void>;
+	deletePassword(service: string, account: string): Promise<boolean>;
+	findPassword(service: string): Promise<string | null>;
+};
+
+export class KeytarCredentialsService implements ICredentialsService {
+
+	_serviceBrand!: ServiceIdentifier<any>;
+
+	private readonly _keytar = new IdleValue<Promise<KeytarModule>>(() => import('keytar'));
+
+	async getPassword(service: string, account: string): Promise<string | null> {
+		const keytar = await this._keytar.getValue();
+		return keytar.getPassword(service, account);
+	}
+
+	async setPassword(service: string, account: string, password: string): Promise<void> {
+		const keytar = await this._keytar.getValue();
+		return keytar.setPassword(service, account, password);
+	}
+
+	async deletePassword(service: string, account: string): Promise<boolean> {
+		const keytar = await this._keytar.getValue();
+		return keytar.deletePassword(service, account);
+	}
+
+	async findPassword(service: string): Promise<string | null> {
+		const keytar = await this._keytar.getValue();
+		return keytar.findPassword(service);
+	}
+}
+
+registerSingleton(ICredentialsService, KeytarCredentialsService, true);

src/vs/workbench/services/environment/browser/environmentService.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IWindowConfiguration, IPath, IPathsToWaitFor } from 'vs/platform/windows/common/windows';
-import { IEnvironmentService, IExtensionHostDebugParams, IDebugParams, BACKUPS } from 'vs/platform/environment/common/environment';
+import { IExtensionHostDebugParams, IDebugParams, BACKUPS } from 'vs/platform/environment/common/environment';
 import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
 import { URI } from 'vs/base/common/uri';
 import { IProcessEnvironment } from 'vs/base/common/platform';
@@ -13,6 +13,8 @@ import { ExportData } from 'vs/base/common/performance';
 import { LogLevel } from 'vs/platform/log/common/log';
 import { joinPath } from 'vs/base/common/resources';
 import { Schemas } from 'vs/base/common/network';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+import { IWorkbenchConstructionOptions } from 'vs/workbench/workbench.web.api';
 
 export class BrowserWindowConfiguration implements IWindowConfiguration {
 
@@ -66,26 +68,26 @@ export interface IBrowserWindowConfiguration {
 	connectionToken?: string;
 }
 
-export class BrowserWorkbenchEnvironmentService implements IEnvironmentService {
+export class BrowserWorkbenchEnvironmentService implements IWorkbenchEnvironmentService {
 
-	_serviceBrand!: ServiceIdentifier<IEnvironmentService>;
+	_serviceBrand!: ServiceIdentifier<IWorkbenchEnvironmentService>;
 
 	readonly configuration: IWindowConfiguration = new BrowserWindowConfiguration();
 
-	constructor(configuration: IBrowserWindowConfiguration) {
+	constructor(workspaceId: string, public readonly options: IWorkbenchConstructionOptions) {
 		this.args = { _: [] };
 		this.appRoot = '/web/';
 		this.appNameLong = 'Visual Studio Code - Web';
 
-		this.configuration.remoteAuthority = configuration.remoteAuthority;
+		this.configuration.remoteAuthority = options.remoteAuthority;
 		this.userRoamingDataHome = URI.file('/User').with({ scheme: Schemas.userData });
 		this.settingsResource = joinPath(this.userRoamingDataHome, 'settings.json');
 		this.keybindingsResource = joinPath(this.userRoamingDataHome, 'keybindings.json');
 		this.keyboardLayoutResource = joinPath(this.userRoamingDataHome, 'keyboardLayout.json');
 		this.localeResource = joinPath(this.userRoamingDataHome, 'locale.json');
 		this.backupHome = joinPath(this.userRoamingDataHome, BACKUPS);
-		this.configuration.backupWorkspaceResource = joinPath(this.backupHome, configuration.workspaceId);
-		this.configuration.connectionToken = configuration.connectionToken || this.getConnectionTokenFromLocation();
+		this.configuration.backupWorkspaceResource = joinPath(this.backupHome, workspaceId);
+		this.configuration.connectionToken = options.connectionToken || this.getConnectionTokenFromLocation();
 
 		this.logsPath = '/web/logs';
 
@@ -94,7 +96,7 @@ export class BrowserWorkbenchEnvironmentService implements IEnvironmentService {
 			break: false
 		};
 
-		this.webviewEndpoint = configuration.webviewEndpoint;
+		this.webviewEndpoint = options.webviewEndpoint;
 		this.untitledWorkspacesHome = URI.from({ scheme: Schemas.untitled, path: 'Workspaces' });
 
 		if (document && document.location && document.location.search) {
@@ -201,7 +203,7 @@ export class BrowserWorkbenchEnvironmentService implements IEnvironmentService {
 	}
 
 	private getConnectionToken(str: string): string | undefined {
-		const m = str.match(/[#&]tkn=([^&]+)/);
+		const m = str.match(/[#&?]tkn=([^&]+)/);
 		return m ? m[1] : undefined;
 	}
 }

src/vs/workbench/services/environment/common/environmentService.ts

@@ -6,6 +6,7 @@
 import { createDecorator, ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
 import { IWindowConfiguration } from 'vs/platform/windows/common/windows';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IWorkbenchConstructionOptions } from 'vs/workbench/workbench.web.api';
 
 export const IWorkbenchEnvironmentService = createDecorator<IWorkbenchEnvironmentService>('environmentService');
 
@@ -14,4 +15,6 @@ export interface IWorkbenchEnvironmentService extends IEnvironmentService {
 	_serviceBrand: ServiceIdentifier<IEnvironmentService>;
 
 	readonly configuration: IWindowConfiguration;
+
+	readonly options?: IWorkbenchConstructionOptions;
 }

src/vs/workbench/services/extensionManagement/test/electron-browser/extensionEnablementService.test.ts

@@ -16,12 +16,12 @@ import { IExtensionContributions, ExtensionType, IExtension } from 'vs/platform/
 import { isUndefinedOrNull } from 'vs/base/common/types';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { ProductService } from 'vs/platform/product/node/productService';
 import { URI } from 'vs/base/common/uri';
 import { Schemas } from 'vs/base/common/network';
 import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
 import { assign } from 'vs/base/common/objects';
 import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService';
+import { productService } from 'vs/workbench/test/workbenchTestServices';
 
 function storageService(instantiationService: TestInstantiationService): IStorageService {
 	let service = instantiationService.get(IStorageService);
@@ -46,7 +46,7 @@ export class TestExtensionEnablementService extends ExtensionEnablementService {
 			instantiationService.get(IExtensionManagementService) || instantiationService.stub(IExtensionManagementService,
 				{ onDidInstallExtension: new Emitter<DidInstallExtensionEvent>().event, onDidUninstallExtension: new Emitter<DidUninstallExtensionEvent>().event } as IExtensionManagementService),
 			instantiationService.get(IConfigurationService), instantiationService.get(IExtensionManagementServerService),
-			new ProductService()
+			productService
 		);
 	}
 

src/vs/workbench/services/extensions/browser/webWorkerExtensionHostStarter.ts

@@ -117,16 +117,16 @@ export class WebWorkerExtensionHostStarter implements IExtensionHostStarter {
 		const [telemetryInfo, extensionDescriptions] = await Promise.all([this._telemetryService.getTelemetryInfo(), this._extensions]);
 		const workspace = this._contextService.getWorkspace();
 		return {
-			commit: this._productService.productConfiguration.commit,
-			version: this._productService.productConfiguration.version,
-			vscodeVersion: this._productService.productConfiguration.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
+			commit: this._productService.commit,
+			version: this._productService.version,
+			vscodeVersion: this._productService.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
 			parentPid: -1,
 			environment: {
 				isExtensionDevelopmentDebug: false,
 				appRoot: this._environmentService.appRoot ? URI.file(this._environmentService.appRoot) : undefined,
 				appSettingsHome: this._environmentService.appSettingsHome ? this._environmentService.appSettingsHome : undefined,
-				appName: this._productService.productConfiguration.nameLong,
-				appUriScheme: this._productService.productConfiguration.urlProtocol,
+				appName: this._productService.nameLong,
+				appUriScheme: this._productService.urlProtocol,
 				appLanguage: platform.language,
 				extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 				extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,

src/vs/workbench/services/extensions/common/abstractExtensionService.ts

@@ -462,12 +462,12 @@ class ProposedApiController {
 		}
 
 		this.enableProposedApiForAll = !environmentService.isBuilt ||
-			(!!environmentService.extensionDevelopmentLocationURI && productService.productConfiguration.nameLong !== 'Visual Studio Code') ||
+			(!!environmentService.extensionDevelopmentLocationURI && productService.nameLong !== 'Visual Studio Code') ||
 			(this.enableProposedApiFor.length === 0 && 'enable-proposed-api' in environmentService.args);
 
 		this.productAllowProposedApi = new Set<string>();
-		if (isNonEmptyArray(productService.productConfiguration.extensionAllowedProposedApi)) {
-			productService.productConfiguration.extensionAllowedProposedApi.forEach((id) => this.productAllowProposedApi.add(ExtensionIdentifier.toKey(id)));
+		if (isNonEmptyArray(productService.extensionAllowedProposedApi)) {
+			productService.extensionAllowedProposedApi.forEach((id) => this.productAllowProposedApi.add(ExtensionIdentifier.toKey(id)));
 		}
 	}
 

src/vs/workbench/services/extensions/common/extensionsUtil.ts

@@ -24,7 +24,7 @@ export function isUIExtension(manifest: IExtensionManifest, productService: IPro
 		case 'workspace': return false;
 		default: {
 			// Tagged as UI extension in product
-			if (isNonEmptyArray(productService.productConfiguration.uiExtensions) && productService.productConfiguration.uiExtensions.some(id => areSameExtensions({ id }, { id: extensionId }))) {
+			if (isNonEmptyArray(productService.uiExtensions) && productService.uiExtensions.some(id => areSameExtensions({ id }, { id: extensionId }))) {
 				return true;
 			}
 			// Not an UI extension if it has main

src/vs/workbench/services/extensions/common/remoteExtensionHostClient.ts

@@ -71,7 +71,7 @@ export class RemoteExtensionHostClient extends Disposable implements IExtensionH
 
 	public start(): Promise<IMessagePassingProtocol> {
 		const options: IConnectionOptions = {
-			commit: this._productService.productConfiguration.commit,
+			commit: this._productService.commit,
 			socketFactory: this._socketFactory,
 			addressProvider: {
 				getAddress: async () => {
@@ -181,16 +181,16 @@ export class RemoteExtensionHostClient extends Disposable implements IExtensionH
 			const hostExtensions = allExtensions.filter(extension => extension.main && extension.api === 'none').map(extension => extension.identifier);
 			const workspace = this._contextService.getWorkspace();
 			const r: IInitData = {
-				commit: this._productService.productConfiguration.commit,
-				version: this._productService.productConfiguration.version,
-				vscodeVersion: this._productService.productConfiguration.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
+				commit: this._productService.commit,
+				version: this._productService.version,
+				vscodeVersion: this._productService.vscodeVersion, // {{SQL CARBON EDIT}} add vscode version
 				parentPid: remoteExtensionHostData.pid,
 				environment: {
 					isExtensionDevelopmentDebug,
 					appRoot: remoteExtensionHostData.appRoot,
 					appSettingsHome: remoteExtensionHostData.appSettingsHome,
-					appName: this._productService.productConfiguration.nameLong,
-					appUriScheme: this._productService.productConfiguration.urlProtocol,
+					appName: this._productService.nameLong,
+					appUriScheme: this._productService.urlProtocol,
 					appLanguage: platform.language,
 					extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
 					extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,

src/vs/workbench/services/extensions/electron-browser/remoteExtensionManagementIpc.ts

@@ -69,7 +69,7 @@ export class RemoteExtensionManagementChannelClient extends ExtensionManagementC
 		const installed = await this.getInstalled(ExtensionType.User);
 		const compatible = await this.galleryService.getCompatibleExtension(extension);
 		if (!compatible) {
-			return Promise.reject(new Error(localize('incompatible', "Unable to install extension '{0}' as it is not compatible with VS Code '{1}'.", extension.identifier.id, this.productService.productConfiguration.version)));
+			return Promise.reject(new Error(localize('incompatible', "Unable to install extension '{0}' as it is not compatible with VS Code '{1}'.", extension.identifier.id, this.productService.version)));
 		}
 		const manifest = await this.galleryService.getManifest(compatible, CancellationToken.None);
 		if (manifest) {

src/vs/workbench/services/extensions/node/proxyResolver.ts

@@ -469,24 +469,26 @@ async function readCaCertificates() {
 }
 
 async function readWindowsCaCertificates() {
-	const winCA = await import('vscode-windows-ca-certs');
+	// Not using await to work around minifier bug (https://github.com/microsoft/vscode/issues/79044).
+	return import('vscode-windows-ca-certs')
+		.then(winCA => {
+			let ders: any[] = [];
+			const store = winCA();
+			try {
+				let der: any;
+				while (der = store.next()) {
+					ders.push(der);
+				}
+			} finally {
+				store.done();
+			}
 
-	let ders: any[] = [];
-	const store = winCA();
-	try {
-		let der: any;
-		while (der = store.next()) {
-			ders.push(der);
-		}
-	} finally {
-		store.done();
-	}
-
-	const certs = new Set(ders.map(derToPem));
-	return {
-		certs: Array.from(certs),
-		append: true
-	};
+			const certs = new Set(ders.map(derToPem));
+			return {
+				certs: Array.from(certs),
+				append: true
+			};
+		});
 }
 
 async function readMacCaCertificates() {

src/vs/workbench/services/integrity/browser/integrityService.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IIntegrityService, IntegrityTestResult } from 'vs/workbench/services/integrity/common/integrity';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
+
+export class BrowserIntegrityServiceImpl implements IIntegrityService {
+
+	_serviceBrand!: ServiceIdentifier<any>;
+
+	async isPure(): Promise<IntegrityTestResult> {
+		return { isPure: true, proof: [] };
+	}
+}
+
+registerSingleton(IIntegrityService, BrowserIntegrityServiceImpl, true);

src/vs/workbench/services/integrity/node/integrityService.ts

@@ -14,6 +14,7 @@ import product from 'vs/platform/product/node/product';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
 
 interface IStorageData {
 	dontShowPrompt: boolean;
@@ -55,7 +56,7 @@ class IntegrityStorage {
 
 export class IntegrityServiceImpl implements IIntegrityService {
 
-	_serviceBrand: any;
+	_serviceBrand!: ServiceIdentifier<any>;
 
 	private _storage: IntegrityStorage;
 	private _isPurePromise: Promise<IntegrityTestResult>;
@@ -159,4 +160,4 @@ export class IntegrityServiceImpl implements IIntegrityService {
 	}
 }
 
-registerSingleton(IIntegrityService, IntegrityServiceImpl, true);
+registerSingleton(IIntegrityService, IntegrityServiceImpl, true);

src/vs/workbench/services/remote/browser/remoteAgentServiceImpl.ts

@@ -28,7 +28,7 @@ export class RemoteAgentService extends AbstractRemoteAgentService implements IR
 		super(environmentService);
 
 		this.socketFactory = new BrowserSocketFactory(webSocketFactory);
-		this._connection = this._register(new RemoteAgentConnection(environmentService.configuration.remoteAuthority!, productService.productConfiguration.commit, this.socketFactory, remoteAuthorityResolverService, signService));
+		this._connection = this._register(new RemoteAgentConnection(environmentService.configuration.remoteAuthority!, productService.commit, this.socketFactory, remoteAuthorityResolverService, signService));
 	}
 
 	getConnection(): IRemoteAgentConnection | null {

src/vs/workbench/services/remote/common/abstractRemoteAgentService.ts

@@ -17,7 +17,7 @@ import { IWorkbenchContribution, IWorkbenchContributionsRegistry, Extensions } f
 import { Registry } from 'vs/platform/registry/common/platform';
 import { RemoteExtensionEnvironmentChannelClient } from 'vs/workbench/services/remote/common/remoteAgentEnvironmentChannel';
 import { INotificationService } from 'vs/platform/notification/common/notification';
-import { IDiagnosticInfoOptions, IDiagnosticInfo } from 'vs/platform/diagnostics/common/diagnosticsService';
+import { IDiagnosticInfoOptions, IDiagnosticInfo } from 'vs/platform/diagnostics/common/diagnostics';
 import { Emitter } from 'vs/base/common/event';
 import { ISignService } from 'vs/platform/sign/common/sign';
 

src/vs/workbench/services/remote/common/remoteAgentEnvironmentChannel.ts

@@ -8,7 +8,8 @@ import { URI, UriComponents } from 'vs/base/common/uri';
 import { IChannel } from 'vs/base/parts/ipc/common/ipc';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
-import { IDiagnosticInfoOptions, IDiagnosticInfo } from 'vs/platform/diagnostics/common/diagnosticsService';
+import { IDiagnosticInfoOptions, IDiagnosticInfo } from 'vs/platform/diagnostics/common/diagnostics';
+import { RemoteAuthorities } from 'vs/base/common/network';
 
 export interface IGetEnvironmentDataArguments {
 	language: string;
@@ -18,6 +19,7 @@ export interface IGetEnvironmentDataArguments {
 
 export interface IRemoteAgentEnvironmentDTO {
 	pid: number;
+	connectionToken: string;
 	appRoot: UriComponents;
 	appSettingsHome: UriComponents;
 	settingsPath: UriComponents;
@@ -43,8 +45,11 @@ export class RemoteExtensionEnvironmentChannelClient {
 
 		const data = await this.channel.call<IRemoteAgentEnvironmentDTO>('getEnvironmentData', args);
 
+		RemoteAuthorities.setConnectionToken(remoteAuthority, data.connectionToken);
+
 		return {
 			pid: data.pid,
+			connectionToken: data.connectionToken,
 			appRoot: URI.revive(data.appRoot),
 			appSettingsHome: URI.revive(data.appSettingsHome),
 			settingsPath: URI.revive(data.settingsPath),

src/vs/workbench/services/remote/common/remoteAgentService.ts

@@ -6,7 +6,7 @@
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { RemoteAgentConnectionContext, IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
 import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
-import { IDiagnosticInfoOptions, IDiagnosticInfo } from 'vs/platform/diagnostics/common/diagnosticsService';
+import { IDiagnosticInfoOptions, IDiagnosticInfo } from 'vs/platform/diagnostics/common/diagnostics';
 import { Event } from 'vs/base/common/event';
 import { PersistenConnectionEvent as PersistentConnectionEvent, ISocketFactory } from 'vs/platform/remote/common/remoteAgentConnection';
 

src/vs/workbench/services/telemetry/browser/telemetryService.ts

@@ -79,11 +79,11 @@ export class TelemetryService extends Disposable implements ITelemetryService {
 	) {
 		super();
 
-		const aiKey = productService.productConfiguration.aiConfig && productService.productConfiguration.aiConfig.asimovKey;
-		if (!environmentService.isExtensionDevelopment && !environmentService.args['disable-telemetry'] && !!productService.productConfiguration.enableTelemetry && !!aiKey) {
+		const aiKey = productService.aiConfig && productService.aiConfig.asimovKey;
+		if (!environmentService.isExtensionDevelopment && !environmentService.args['disable-telemetry'] && !!productService.enableTelemetry && !!aiKey) {
 			const config: ITelemetryServiceConfig = {
 				appender: combinedAppender(new WebTelemetryAppender(aiKey, logService), new LogAppender(logService)),
-				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.productConfiguration.commit, productService.productConfiguration.version, environmentService.configuration.machineId, environmentService.configuration.remoteAuthority),
+				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.commit, productService.version, environmentService.configuration.machineId, environmentService.configuration.remoteAuthority),
 				piiPaths: [environmentService.appRoot]
 			};
 

src/vs/workbench/services/telemetry/electron-browser/telemetryService.ts

@@ -34,11 +34,11 @@ export class TelemetryService extends Disposable implements ITelemetryService {
 	) {
 		super();
 
-		if (!environmentService.isExtensionDevelopment && !environmentService.args['disable-telemetry'] && !!productService.productConfiguration.enableTelemetry) {
+		if (!environmentService.isExtensionDevelopment && !environmentService.args['disable-telemetry'] && !!productService.enableTelemetry) {
 			const channel = sharedProcessService.getChannel('telemetryAppender');
 			const config: ITelemetryServiceConfig = {
 				appender: combinedAppender(new TelemetryAppenderClient(channel), new LogAppender(logService)),
-				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.productConfiguration.commit, productService.productConfiguration.version, environmentService.configuration.machineId, environmentService.installSourcePath, environmentService.configuration.remoteAuthority),
+				commonProperties: resolveWorkbenchCommonProperties(storageService, productService.commit, productService.version, environmentService.configuration.machineId, environmentService.installSourcePath, environmentService.configuration.remoteAuthority),
 				piiPaths: environmentService.extensionsPath ? [environmentService.appRoot, environmentService.extensionsPath] : [environmentService.appRoot]
 			};
 

src/vs/workbench/services/userData/test/electron-browser/fileUserDataProvider.test.ts

@@ -47,7 +47,7 @@ suite('FileUserDataProvider', () => {
 		userDataResource = URI.file(userDataPath).with({ scheme: Schemas.userData });
 		await Promise.all([pfs.mkdirp(userDataPath), pfs.mkdirp(backupsPath)]);
 
-		const environmentService = new BrowserWorkbenchEnvironmentService({ workspaceId: 'workspaceId' });
+		const environmentService = new BrowserWorkbenchEnvironmentService('workspaceId', { remoteAuthority: 'remote' });
 		environmentService.userRoamingDataHome = userDataResource;
 
 		const userDataFileSystemProvider = new FileUserDataProvider(URI.file(userDataPath), URI.file(backupsPath), diskFileSystemProvider, environmentService);
@@ -321,7 +321,7 @@ suite('FileUserDataProvider - Watching', () => {
 		localUserDataResource = URI.file(userDataPath);
 		userDataResource = localUserDataResource.with({ scheme: Schemas.userData });
 
-		const environmentService = new BrowserWorkbenchEnvironmentService({ workspaceId: 'workspaceId' });
+		const environmentService = new BrowserWorkbenchEnvironmentService('workspaceId', { remoteAuthority: 'remote' });
 		environmentService.userRoamingDataHome = userDataResource;
 
 		const userDataFileSystemProvider = new FileUserDataProvider(localUserDataResource, localBackupsResource, new TestFileSystemProvider(fileEventEmitter.event), environmentService);
@@ -475,4 +475,4 @@ suite('FileUserDataProvider - Watching', () => {
 			type: FileChangeType.DELETED
 		}]);
 	});
-});
+});