Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/src/vs/platform/extensionManagement/common/configRemotes.ts

@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+
+const SshProtocolMatcher = /^([^@:]+@)?([^:]+):/;
+const SshUrlMatcher = /^([^@:]+@)?([^:]+):(.+)$/;
+const AuthorityMatcher = /^([^@]+@)?([^:]+)(:\d+)?$/;
+const SecondLevelDomainMatcher = /([^@:.]+\.[^@:.]+)(:\d+)?$/;
+const RemoteMatcher = /^\s*url\s*=\s*(.+\S)\s*$/mg;
+const AnyButDot = /[^.]/g;
+
+export const AllowedSecondLevelDomains = [
+	'github.com',
+	'bitbucket.org',
+	'visualstudio.com',
+	'gitlab.com',
+	'heroku.com',
+	'azurewebsites.net',
+	'ibm.com',
+	'amazon.com',
+	'amazonaws.com',
+	'cloudapp.net',
+	'rhcloud.com',
+	'google.com',
+	'azure.com'
+];
+
+function stripLowLevelDomains(domain: string): string | null {
+	const match = domain.match(SecondLevelDomainMatcher);
+	return match ? match[1] : null;
+}
+
+function extractDomain(url: string): string | null {
+	if (url.indexOf('://') === -1) {
+		const match = url.match(SshProtocolMatcher);
+		if (match) {
+			return stripLowLevelDomains(match[2]);
+		} else {
+			return null;
+		}
+	}
+	try {
+		const uri = URI.parse(url);
+		if (uri.authority) {
+			return stripLowLevelDomains(uri.authority);
+		}
+	} catch (e) {
+		// ignore invalid URIs
+	}
+	return null;
+}
+
+export function getDomainsOfRemotes(text: string, allowedDomains: readonly string[]): string[] {
+	const domains = new Set<string>();
+	let match: RegExpExecArray | null;
+	while (match = RemoteMatcher.exec(text)) {
+		const domain = extractDomain(match[1]);
+		if (domain) {
+			domains.add(domain);
+		}
+	}
+
+	const allowedDomainsSet = new Set(allowedDomains);
+	return Array.from(domains)
+		.map(key => allowedDomainsSet.has(key) ? key : key.replace(AnyButDot, 'a'));
+}
+
+function stripPort(authority: string): string | null {
+	const match = authority.match(AuthorityMatcher);
+	return match ? match[2] : null;
+}
+
+function normalizeRemote(host: string | null, path: string, stripEndingDotGit: boolean): string | null {
+	if (host && path) {
+		if (stripEndingDotGit && path.endsWith('.git')) {
+			path = path.substr(0, path.length - 4);
+		}
+		return (path.indexOf('/') === 0) ? `${host}${path}` : `${host}/${path}`;
+	}
+	return null;
+}
+
+function extractRemote(url: string, stripEndingDotGit: boolean): string | null {
+	if (url.indexOf('://') === -1) {
+		const match = url.match(SshUrlMatcher);
+		if (match) {
+			return normalizeRemote(match[2], match[3], stripEndingDotGit);
+		}
+	}
+	try {
+		const uri = URI.parse(url);
+		if (uri.authority) {
+			return normalizeRemote(stripPort(uri.authority), uri.path, stripEndingDotGit);
+		}
+	} catch (e) {
+		// ignore invalid URIs
+	}
+	return null;
+}
+
+export function getRemotes(text: string, stripEndingDotGit: boolean = false): string[] {
+	const remotes: string[] = [];
+	let match: RegExpExecArray | null;
+	while (match = RemoteMatcher.exec(text)) {
+		const remote = extractRemote(match[1], stripEndingDotGit);
+		if (remote) {
+			remotes.push(remote);
+		}
+	}
+	return remotes;
+}

lib/vscode/src/vs/platform/extensionManagement/common/extensionEnablementService.ts

@@ -0,0 +1,159 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Event, Emitter } from 'vs/base/common/event';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IExtensionIdentifier, IGlobalExtensionEnablementService, DISABLED_EXTENSIONS_STORAGE_PATH } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IStorageService, StorageScope, IWorkspaceStorageChangeEvent } from 'vs/platform/storage/common/storage';
+import { isUndefinedOrNull } from 'vs/base/common/types';
+
+export class GlobalExtensionEnablementService extends Disposable implements IGlobalExtensionEnablementService {
+
+	declare readonly _serviceBrand: undefined;
+
+	private _onDidChangeEnablement = new Emitter<{ readonly extensions: IExtensionIdentifier[], readonly source?: string }>();
+	readonly onDidChangeEnablement: Event<{ readonly extensions: IExtensionIdentifier[], readonly source?: string }> = this._onDidChangeEnablement.event;
+	private readonly storageManger: StorageManager;
+
+	constructor(
+		@IStorageService storageService: IStorageService,
+	) {
+		super();
+		this.storageManger = this._register(new StorageManager(storageService));
+		this._register(this.storageManger.onDidChange(extensions => this._onDidChangeEnablement.fire({ extensions, source: 'storage' })));
+	}
+
+	async enableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean> {
+		if (this._removeFromDisabledExtensions(extension)) {
+			this._onDidChangeEnablement.fire({ extensions: [extension], source });
+			return true;
+		}
+		return false;
+	}
+
+	async disableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean> {
+		if (this._addToDisabledExtensions(extension)) {
+			this._onDidChangeEnablement.fire({ extensions: [extension], source });
+			return true;
+		}
+		return false;
+	}
+
+	getDisabledExtensions(): IExtensionIdentifier[] {
+		return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH);
+	}
+
+	async getDisabledExtensionsAsync(): Promise<IExtensionIdentifier[]> {
+		return this.getDisabledExtensions();
+	}
+
+	private _addToDisabledExtensions(identifier: IExtensionIdentifier): boolean {
+		let disabledExtensions = this.getDisabledExtensions();
+		if (disabledExtensions.every(e => !areSameExtensions(e, identifier))) {
+			disabledExtensions.push(identifier);
+			this._setDisabledExtensions(disabledExtensions);
+			return true;
+		}
+		return false;
+	}
+
+	private _removeFromDisabledExtensions(identifier: IExtensionIdentifier): boolean {
+		let disabledExtensions = this.getDisabledExtensions();
+		for (let index = 0; index < disabledExtensions.length; index++) {
+			const disabledExtension = disabledExtensions[index];
+			if (areSameExtensions(disabledExtension, identifier)) {
+				disabledExtensions.splice(index, 1);
+				this._setDisabledExtensions(disabledExtensions);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private _setDisabledExtensions(disabledExtensions: IExtensionIdentifier[]): void {
+		this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions);
+	}
+
+	private _getExtensions(storageId: string): IExtensionIdentifier[] {
+		return this.storageManger.get(storageId, StorageScope.GLOBAL);
+	}
+
+	private _setExtensions(storageId: string, extensions: IExtensionIdentifier[]): void {
+		this.storageManger.set(storageId, extensions, StorageScope.GLOBAL);
+	}
+
+}
+
+export class StorageManager extends Disposable {
+
+	private storage: { [key: string]: string } = Object.create(null);
+
+	private _onDidChange: Emitter<IExtensionIdentifier[]> = this._register(new Emitter<IExtensionIdentifier[]>());
+	readonly onDidChange: Event<IExtensionIdentifier[]> = this._onDidChange.event;
+
+	constructor(private storageService: IStorageService) {
+		super();
+		this._register(storageService.onDidChangeStorage(e => this.onDidStorageChange(e)));
+	}
+
+	get(key: string, scope: StorageScope): IExtensionIdentifier[] {
+		let value: string;
+		if (scope === StorageScope.GLOBAL) {
+			if (isUndefinedOrNull(this.storage[key])) {
+				this.storage[key] = this._get(key, scope);
+			}
+			value = this.storage[key];
+		} else {
+			value = this._get(key, scope);
+		}
+		return JSON.parse(value);
+	}
+
+	set(key: string, value: IExtensionIdentifier[], scope: StorageScope): void {
+		let newValue: string = JSON.stringify(value.map(({ id, uuid }) => (<IExtensionIdentifier>{ id, uuid })));
+		const oldValue = this._get(key, scope);
+		if (oldValue !== newValue) {
+			if (scope === StorageScope.GLOBAL) {
+				if (value.length) {
+					this.storage[key] = newValue;
+				} else {
+					delete this.storage[key];
+				}
+			}
+			this._set(key, value.length ? newValue : undefined, scope);
+		}
+	}
+
+	private onDidStorageChange(workspaceStorageChangeEvent: IWorkspaceStorageChangeEvent): void {
+		if (workspaceStorageChangeEvent.scope === StorageScope.GLOBAL) {
+			if (!isUndefinedOrNull(this.storage[workspaceStorageChangeEvent.key])) {
+				const newValue = this._get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
+				if (newValue !== this.storage[workspaceStorageChangeEvent.key]) {
+					const oldValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
+					delete this.storage[workspaceStorageChangeEvent.key];
+					const newValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
+					const added = oldValues.filter(oldValue => !newValues.some(newValue => areSameExtensions(oldValue, newValue)));
+					const removed = newValues.filter(newValue => !oldValues.some(oldValue => areSameExtensions(oldValue, newValue)));
+					if (added.length || removed.length) {
+						this._onDidChange.fire([...added, ...removed]);
+					}
+				}
+			}
+		}
+	}
+
+	private _get(key: string, scope: StorageScope): string {
+		return this.storageService.get(key, scope, '[]');
+	}
+
+	private _set(key: string, value: string | undefined, scope: StorageScope): void {
+		if (value) {
+			this.storageService.store(key, value, scope);
+		} else {
+			this.storageService.remove(key, scope);
+		}
+	}
+}

lib/vscode/src/vs/platform/extensionManagement/common/extensionGalleryService.ts

@@ -0,0 +1,815 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { getErrorMessage, isPromiseCanceledError, canceled } from 'vs/base/common/errors';
+import { StatisticType, IGalleryExtension, IExtensionGalleryService, IGalleryExtensionAsset, IQueryOptions, SortBy, SortOrder, IExtensionIdentifier, IReportedExtension, InstallOperation, ITranslation, IGalleryExtensionVersion, IGalleryExtensionAssets, isIExtensionIdentifier, DefaultIconPath } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { getGalleryExtensionId, getGalleryExtensionTelemetryData, adoptToGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { getOrDefault } from 'vs/base/common/objects';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IPager } from 'vs/base/common/paging';
+import { IRequestService, asJson, asText } from 'vs/platform/request/common/request';
+import { IRequestOptions, IRequestContext, IHeaders } from 'vs/base/parts/request/common/request';
+import { isEngineValid } from 'vs/platform/extensions/common/extensionValidator';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IExtensionManifest } from 'vs/platform/extensions/common/extensions';
+import { IFileService } from 'vs/platform/files/common/files';
+import { URI } from 'vs/base/common/uri';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { getServiceMachineId } from 'vs/platform/serviceMachineId/common/serviceMachineId';
+import { optional } from 'vs/platform/instantiation/common/instantiation';
+import { joinPath } from 'vs/base/common/resources';
+
+interface IRawGalleryExtensionFile {
+	assetType: string;
+	source: string;
+}
+
+interface IRawGalleryExtensionProperty {
+	key: string;
+	value: string;
+}
+
+interface IRawGalleryExtensionVersion {
+	version: string;
+	lastUpdated: string;
+	assetUri: string;
+	fallbackAssetUri: string;
+	files: IRawGalleryExtensionFile[];
+	properties?: IRawGalleryExtensionProperty[];
+}
+
+interface IRawGalleryExtensionStatistics {
+	statisticName: string;
+	value: number;
+}
+
+interface IRawGalleryExtension {
+	extensionId: string;
+	extensionName: string;
+	displayName: string;
+	shortDescription: string;
+	publisher: { displayName: string, publisherId: string, publisherName: string; };
+	versions: IRawGalleryExtensionVersion[];
+	statistics: IRawGalleryExtensionStatistics[];
+	flags: string;
+}
+
+interface IRawGalleryQueryResult {
+	results: {
+		extensions: IRawGalleryExtension[];
+		resultMetadata: {
+			metadataType: string;
+			metadataItems: {
+				name: string;
+				count: number;
+			}[];
+		}[]
+	}[];
+}
+
+enum Flags {
+	None = 0x0,
+	IncludeVersions = 0x1,
+	IncludeFiles = 0x2,
+	IncludeCategoryAndTags = 0x4,
+	IncludeSharedAccounts = 0x8,
+	IncludeVersionProperties = 0x10,
+	ExcludeNonValidated = 0x20,
+	IncludeInstallationTargets = 0x40,
+	IncludeAssetUri = 0x80,
+	IncludeStatistics = 0x100,
+	IncludeLatestVersionOnly = 0x200,
+	Unpublished = 0x1000
+}
+
+function flagsToString(...flags: Flags[]): string {
+	return String(flags.reduce((r, f) => r | f, 0));
+}
+
+enum FilterType {
+	Tag = 1,
+	ExtensionId = 4,
+	Category = 5,
+	ExtensionName = 7,
+	Target = 8,
+	Featured = 9,
+	SearchText = 10,
+	ExcludeWithFlags = 12
+}
+
+const AssetType = {
+	Icon: 'Microsoft.VisualStudio.Services.Icons.Default',
+	Details: 'Microsoft.VisualStudio.Services.Content.Details',
+	Changelog: 'Microsoft.VisualStudio.Services.Content.Changelog',
+	Manifest: 'Microsoft.VisualStudio.Code.Manifest',
+	VSIX: 'Microsoft.VisualStudio.Services.VSIXPackage',
+	License: 'Microsoft.VisualStudio.Services.Content.License',
+	Repository: 'Microsoft.VisualStudio.Services.Links.Source'
+};
+
+const PropertyType = {
+	Dependency: 'Microsoft.VisualStudio.Code.ExtensionDependencies',
+	ExtensionPack: 'Microsoft.VisualStudio.Code.ExtensionPack',
+	Engine: 'Microsoft.VisualStudio.Code.Engine',
+	LocalizedLanguages: 'Microsoft.VisualStudio.Code.LocalizedLanguages',
+	WebExtension: 'Microsoft.VisualStudio.Code.WebExtension'
+};
+
+interface ICriterium {
+	filterType: FilterType;
+	value?: string;
+}
+
+const DefaultPageSize = 10;
+
+interface IQueryState {
+	pageNumber: number;
+	pageSize: number;
+	sortBy: SortBy;
+	sortOrder: SortOrder;
+	flags: Flags;
+	criteria: ICriterium[];
+	assetTypes: string[];
+}
+
+const DefaultQueryState: IQueryState = {
+	pageNumber: 1,
+	pageSize: DefaultPageSize,
+	sortBy: SortBy.NoneOrRelevance,
+	sortOrder: SortOrder.Default,
+	flags: Flags.None,
+	criteria: [],
+	assetTypes: []
+};
+
+class Query {
+
+	constructor(private state = DefaultQueryState) { }
+
+	get pageNumber(): number { return this.state.pageNumber; }
+	get pageSize(): number { return this.state.pageSize; }
+	get sortBy(): number { return this.state.sortBy; }
+	get sortOrder(): number { return this.state.sortOrder; }
+	get flags(): number { return this.state.flags; }
+
+	withPage(pageNumber: number, pageSize: number = this.state.pageSize): Query {
+		return new Query({ ...this.state, pageNumber, pageSize });
+	}
+
+	withFilter(filterType: FilterType, ...values: string[]): Query {
+		const criteria = [
+			...this.state.criteria,
+			...values.length ? values.map(value => ({ filterType, value })) : [{ filterType }]
+		];
+
+		return new Query({ ...this.state, criteria });
+	}
+
+	withSortBy(sortBy: SortBy): Query {
+		return new Query({ ...this.state, sortBy });
+	}
+
+	withSortOrder(sortOrder: SortOrder): Query {
+		return new Query({ ...this.state, sortOrder });
+	}
+
+	withFlags(...flags: Flags[]): Query {
+		return new Query({ ...this.state, flags: flags.reduce<number>((r, f) => r | f, 0) });
+	}
+
+	withAssetTypes(...assetTypes: string[]): Query {
+		return new Query({ ...this.state, assetTypes });
+	}
+
+	get raw(): any {
+		const { criteria, pageNumber, pageSize, sortBy, sortOrder, flags, assetTypes } = this.state;
+		const filters = [{ criteria, pageNumber, pageSize, sortBy, sortOrder }];
+		return { filters, assetTypes, flags };
+	}
+
+	get searchText(): string {
+		const criterium = this.state.criteria.filter(criterium => criterium.filterType === FilterType.SearchText)[0];
+		return criterium && criterium.value ? criterium.value : '';
+	}
+}
+
+function getStatistic(statistics: IRawGalleryExtensionStatistics[], name: string): number {
+	const result = (statistics || []).filter(s => s.statisticName === name)[0];
+	return result ? result.value : 0;
+}
+
+function getCoreTranslationAssets(version: IRawGalleryExtensionVersion): [string, IGalleryExtensionAsset][] {
+	const coreTranslationAssetPrefix = 'Microsoft.VisualStudio.Code.Translation.';
+	const result = version.files.filter(f => f.assetType.indexOf(coreTranslationAssetPrefix) === 0);
+	return result.reduce<[string, IGalleryExtensionAsset][]>((result, file) => {
+		const asset = getVersionAsset(version, file.assetType);
+		if (asset) {
+			result.push([file.assetType.substring(coreTranslationAssetPrefix.length), asset]);
+		}
+		return result;
+	}, []);
+}
+
+function getRepositoryAsset(version: IRawGalleryExtensionVersion): IGalleryExtensionAsset | null {
+	if (version.properties) {
+		const results = version.properties.filter(p => p.key === AssetType.Repository);
+		const gitRegExp = new RegExp('((git|ssh|http(s)?)|(git@[\w.]+))(:(//)?)([\w.@\:/\-~]+)(.git)(/)?');
+
+		const uri = results.filter(r => gitRegExp.test(r.value))[0];
+		return uri ? { uri: uri.value, fallbackUri: uri.value } : null;
+	}
+	return getVersionAsset(version, AssetType.Repository);
+}
+
+function getDownloadAsset(version: IRawGalleryExtensionVersion): IGalleryExtensionAsset {
+	return {
+		uri: `${version.fallbackAssetUri}/${AssetType.VSIX}?redirect=true`,
+		fallbackUri: `${version.fallbackAssetUri}/${AssetType.VSIX}`
+	};
+}
+
+function getIconAsset(version: IRawGalleryExtensionVersion): IGalleryExtensionAsset {
+	const asset = getVersionAsset(version, AssetType.Icon);
+	if (asset) {
+		return asset;
+	}
+	const uri = DefaultIconPath;
+	return { uri, fallbackUri: uri };
+}
+
+function getVersionAsset(version: IRawGalleryExtensionVersion, type: string): IGalleryExtensionAsset | null {
+	const result = version.files.filter(f => f.assetType === type)[0];
+	return result ? { uri: `${version.assetUri}/${type}`, fallbackUri: `${version.fallbackAssetUri}/${type}` } : null;
+}
+
+function getExtensions(version: IRawGalleryExtensionVersion, property: string): string[] {
+	const values = version.properties ? version.properties.filter(p => p.key === property) : [];
+	const value = values.length > 0 && values[0].value;
+	return value ? value.split(',').map(v => adoptToGalleryExtensionId(v)) : [];
+}
+
+function getEngine(version: IRawGalleryExtensionVersion): string {
+	const values = version.properties ? version.properties.filter(p => p.key === PropertyType.Engine) : [];
+	return (values.length > 0 && values[0].value) || '';
+}
+
+function getLocalizedLanguages(version: IRawGalleryExtensionVersion): string[] {
+	const values = version.properties ? version.properties.filter(p => p.key === PropertyType.LocalizedLanguages) : [];
+	const value = (values.length > 0 && values[0].value) || '';
+	return value ? value.split(',') : [];
+}
+
+function getIsPreview(flags: string): boolean {
+	return flags.indexOf('preview') !== -1;
+}
+
+function getIsWebExtension(version: IRawGalleryExtensionVersion): boolean {
+	const webExtensionProperty = version.properties ? version.properties.find(p => p.key === PropertyType.WebExtension) : undefined;
+	return !!webExtensionProperty && webExtensionProperty.value === 'true';
+}
+
+function getWebResource(version: IRawGalleryExtensionVersion): URI | undefined {
+	return version.files.some(f => f.assetType.startsWith('Microsoft.VisualStudio.Code.WebResources'))
+		? joinPath(URI.parse(version.assetUri), 'Microsoft.VisualStudio.Code.WebResources', 'extension')
+		: undefined;
+}
+
+function toExtension(galleryExtension: IRawGalleryExtension, version: IRawGalleryExtensionVersion, index: number, query: Query, querySource?: string): IGalleryExtension {
+	const assets = <IGalleryExtensionAssets>{
+		manifest: getVersionAsset(version, AssetType.Manifest),
+		readme: getVersionAsset(version, AssetType.Details),
+		changelog: getVersionAsset(version, AssetType.Changelog),
+		license: getVersionAsset(version, AssetType.License),
+		repository: getRepositoryAsset(version),
+		download: getDownloadAsset(version),
+		icon: getIconAsset(version),
+		coreTranslations: getCoreTranslationAssets(version)
+	};
+
+	return {
+		identifier: {
+			id: getGalleryExtensionId(galleryExtension.publisher.publisherName, galleryExtension.extensionName),
+			uuid: galleryExtension.extensionId
+		},
+		name: galleryExtension.extensionName,
+		version: version.version,
+		date: version.lastUpdated,
+		displayName: galleryExtension.displayName,
+		publisherId: galleryExtension.publisher.publisherId,
+		publisher: galleryExtension.publisher.publisherName,
+		publisherDisplayName: galleryExtension.publisher.displayName,
+		description: galleryExtension.shortDescription || '',
+		installCount: getStatistic(galleryExtension.statistics, 'install'),
+		rating: getStatistic(galleryExtension.statistics, 'averagerating'),
+		ratingCount: getStatistic(galleryExtension.statistics, 'ratingcount'),
+		assetUri: URI.parse(version.assetUri),
+		webResource: getWebResource(version),
+		assetTypes: version.files.map(({ assetType }) => assetType),
+		assets,
+		properties: {
+			dependencies: getExtensions(version, PropertyType.Dependency),
+			extensionPack: getExtensions(version, PropertyType.ExtensionPack),
+			engine: getEngine(version),
+			localizedLanguages: getLocalizedLanguages(version),
+			webExtension: getIsWebExtension(version)
+		},
+		/* __GDPR__FRAGMENT__
+			"GalleryExtensionTelemetryData2" : {
+				"index" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
+				"searchText": { "classification": "CustomerContent", "purpose": "FeatureInsight" },
+				"querySource": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		*/
+		telemetryData: {
+			index: ((query.pageNumber - 1) * query.pageSize) + index,
+			searchText: query.searchText,
+			querySource
+		},
+		preview: getIsPreview(galleryExtension.flags)
+	};
+}
+
+interface IRawExtensionsReport {
+	malicious: string[];
+	slow: string[];
+}
+
+export class ExtensionGalleryService implements IExtensionGalleryService {
+
+	declare readonly _serviceBrand: undefined;
+
+	private extensionsGalleryUrl: string | undefined;
+	private extensionsControlUrl: string | undefined;
+
+	private readonly commonHeadersPromise: Promise<{ [key: string]: string; }>;
+
+	constructor(
+		@IRequestService private readonly requestService: IRequestService,
+		@ILogService private readonly logService: ILogService,
+		@IEnvironmentService private readonly environmentService: IEnvironmentService,
+		@ITelemetryService private readonly telemetryService: ITelemetryService,
+		@IFileService private readonly fileService: IFileService,
+		@IProductService private readonly productService: IProductService,
+		@optional(IStorageService) storageService: IStorageService,
+	) {
+		const config = productService.extensionsGallery;
+		this.extensionsGalleryUrl = config && config.serviceUrl;
+		this.extensionsControlUrl = config && config.controlUrl;
+		this.commonHeadersPromise = resolveMarketplaceHeaders(productService.version, this.environmentService, this.fileService, storageService);
+	}
+
+	private api(path = ''): string {
+		return `${this.extensionsGalleryUrl}${path}`;
+	}
+
+	isEnabled(): boolean {
+		return !!this.extensionsGalleryUrl;
+	}
+
+	async getExtensions(names: string[], token: CancellationToken): Promise<IGalleryExtension[]> {
+		const result: IGalleryExtension[] = [];
+		let { total, firstPage: pageResult, getPage } = await this.query({ names, pageSize: names.length }, token);
+		result.push(...pageResult);
+		for (let pageIndex = 1; result.length < total; pageIndex++) {
+			pageResult = await getPage(pageIndex, token);
+			if (pageResult.length) {
+				result.push(...pageResult);
+			} else {
+				break;
+			}
+		}
+		return result;
+	}
+
+	async getCompatibleExtension(arg1: IExtensionIdentifier | IGalleryExtension, version?: string): Promise<IGalleryExtension | null> {
+		const extension = await this.getCompatibleExtensionByEngine(arg1, version);
+
+		if (extension?.properties.webExtension) {
+			return extension.webResource ? extension : null;
+		} else {
+			return extension;
+		}
+	}
+
+	private async getCompatibleExtensionByEngine(arg1: IExtensionIdentifier | IGalleryExtension, version?: string): Promise<IGalleryExtension | null> {
+		const extension: IGalleryExtension | null = isIExtensionIdentifier(arg1) ? null : arg1;
+		if (extension && extension.properties.engine && isEngineValid(extension.properties.engine, this.productService.version)) {
+			return extension;
+		}
+		const { id, uuid } = extension ? extension.identifier : <IExtensionIdentifier>arg1;
+		let query = new Query()
+			.withFlags(Flags.IncludeAssetUri, Flags.IncludeStatistics, Flags.IncludeFiles, Flags.IncludeVersionProperties)
+			.withPage(1, 1)
+			.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code');
+
+		if (uuid) {
+			query = query.withFilter(FilterType.ExtensionId, uuid);
+		} else {
+			query = query.withFilter(FilterType.ExtensionName, id);
+		}
+
+		const { galleryExtensions } = await this.queryGallery(query, CancellationToken.None);
+		const [rawExtension] = galleryExtensions;
+		if (!rawExtension || !rawExtension.versions.length) {
+			return null;
+		}
+
+		if (version) {
+			const versionAsset = rawExtension.versions.filter(v => v.version === version)[0];
+			if (versionAsset) {
+				const extension = toExtension(rawExtension, versionAsset, 0, query);
+				if (extension.properties.engine && isEngineValid(extension.properties.engine, this.productService.version)) {
+					return extension;
+				}
+			}
+			return null;
+		}
+
+		const rawVersion = await this.getLastValidExtensionVersion(rawExtension, rawExtension.versions);
+		if (rawVersion) {
+			return toExtension(rawExtension, rawVersion, 0, query);
+		}
+		return null;
+	}
+
+	query(token: CancellationToken): Promise<IPager<IGalleryExtension>>;
+	query(options: IQueryOptions, token: CancellationToken): Promise<IPager<IGalleryExtension>>;
+	async query(arg1: any, arg2?: any): Promise<IPager<IGalleryExtension>> {
+		const options: IQueryOptions = CancellationToken.isCancellationToken(arg1) ? {} : arg1;
+		const token: CancellationToken = CancellationToken.isCancellationToken(arg1) ? arg1 : arg2;
+
+		if (!this.isEnabled()) {
+			throw new Error('No extension gallery service configured.');
+		}
+
+		const type = options.names ? 'ids' : (options.text ? 'text' : 'all');
+		let text = options.text || '';
+		const pageSize = getOrDefault(options, o => o.pageSize, 50);
+
+		type GalleryServiceQueryClassification = {
+			type: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+			text: { classification: 'CustomerContent', purpose: 'FeatureInsight' };
+		};
+		type GalleryServiceQueryEvent = {
+			type: string;
+			text: string;
+		};
+		this.telemetryService.publicLog2<GalleryServiceQueryEvent, GalleryServiceQueryClassification>('galleryService:query', { type, text });
+
+		let query = new Query()
+			.withFlags(Flags.IncludeLatestVersionOnly, Flags.IncludeAssetUri, Flags.IncludeStatistics, Flags.IncludeFiles, Flags.IncludeVersionProperties)
+			.withPage(1, pageSize)
+			.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code');
+
+		if (text) {
+			// Use category filter instead of "category:themes"
+			text = text.replace(/\bcategory:("([^"]*)"|([^"]\S*))(\s+|\b|$)/g, (_, quotedCategory, category) => {
+				query = query.withFilter(FilterType.Category, category || quotedCategory);
+				return '';
+			});
+
+			// Use tag filter instead of "tag:debuggers"
+			text = text.replace(/\btag:("([^"]*)"|([^"]\S*))(\s+|\b|$)/g, (_, quotedTag, tag) => {
+				query = query.withFilter(FilterType.Tag, tag || quotedTag);
+				return '';
+			});
+
+			// Use featured filter
+			text = text.replace(/\bfeatured(\s+|\b|$)/g, () => {
+				query = query.withFilter(FilterType.Featured);
+				return '';
+			});
+
+			text = text.trim();
+
+			if (text) {
+				text = text.length < 200 ? text : text.substring(0, 200);
+				query = query.withFilter(FilterType.SearchText, text);
+			}
+
+			query = query.withSortBy(SortBy.NoneOrRelevance);
+		} else if (options.ids) {
+			query = query.withFilter(FilterType.ExtensionId, ...options.ids);
+		} else if (options.names) {
+			query = query.withFilter(FilterType.ExtensionName, ...options.names);
+		} else {
+			query = query.withSortBy(SortBy.InstallCount);
+		}
+
+		if (typeof options.sortBy === 'number') {
+			query = query.withSortBy(options.sortBy);
+		}
+
+		if (typeof options.sortOrder === 'number') {
+			query = query.withSortOrder(options.sortOrder);
+		}
+
+		const { galleryExtensions, total } = await this.queryGallery(query, token);
+		const extensions = galleryExtensions.map((e, index) => toExtension(e, e.versions[0], index, query, options.source));
+		const getPage = async (pageIndex: number, ct: CancellationToken) => {
+			if (ct.isCancellationRequested) {
+				throw canceled();
+			}
+			const nextPageQuery = query.withPage(pageIndex + 1);
+			const { galleryExtensions } = await this.queryGallery(nextPageQuery, ct);
+			return galleryExtensions.map((e, index) => toExtension(e, e.versions[0], index, nextPageQuery, options.source));
+		};
+
+		return { firstPage: extensions, total, pageSize: query.pageSize, getPage } as IPager<IGalleryExtension>;
+	}
+
+	private async queryGallery(query: Query, token: CancellationToken): Promise<{ galleryExtensions: IRawGalleryExtension[], total: number; }> {
+		if (!this.isEnabled()) {
+			throw new Error('No extension gallery service configured.');
+		}
+
+		// Always exclude non validated and unpublished extensions
+		query = query
+			.withFlags(query.flags, Flags.ExcludeNonValidated)
+			.withFilter(FilterType.ExcludeWithFlags, flagsToString(Flags.Unpublished));
+
+		const commonHeaders = await this.commonHeadersPromise;
+		const data = JSON.stringify(query.raw);
+		const headers = {
+			...commonHeaders,
+			'Content-Type': 'application/json',
+			'Accept': 'application/json;api-version=3.0-preview.1',
+			'Accept-Encoding': 'gzip',
+			'Content-Length': String(data.length)
+		};
+
+		const context = await this.requestService.request({
+			type: 'POST',
+			url: this.api('/extensionquery'),
+			data,
+			headers
+		}, token);
+
+		if (context.res.statusCode && context.res.statusCode >= 400 && context.res.statusCode < 500) {
+			return { galleryExtensions: [], total: 0 };
+		}
+
+		const result = await asJson<IRawGalleryQueryResult>(context);
+		if (result) {
+			const r = result.results[0];
+			const galleryExtensions = r.extensions;
+			const resultCount = r.resultMetadata && r.resultMetadata.filter(m => m.metadataType === 'ResultCount')[0];
+			const total = resultCount && resultCount.metadataItems.filter(i => i.name === 'TotalCount')[0].count || 0;
+
+			return { galleryExtensions, total };
+		}
+		return { galleryExtensions: [], total: 0 };
+	}
+
+	async reportStatistic(publisher: string, name: string, version: string, type: StatisticType): Promise<void> {
+		if (!this.isEnabled()) {
+			return undefined;
+		}
+
+		const commonHeaders = await this.commonHeadersPromise;
+		const headers = { ...commonHeaders, Accept: '*/*;api-version=4.0-preview.1' };
+		try {
+			await this.requestService.request({
+				type: 'POST',
+				url: this.api(`/publishers/${publisher}/extensions/${name}/${version}/stats?statType=${type}`),
+				headers
+			}, CancellationToken.None);
+		} catch (error) { /* Ignore */ }
+	}
+
+	async download(extension: IGalleryExtension, location: URI, operation: InstallOperation): Promise<void> {
+		this.logService.trace('ExtensionGalleryService#download', extension.identifier.id);
+		const data = getGalleryExtensionTelemetryData(extension);
+		const startTime = new Date().getTime();
+		/* __GDPR__
+			"galleryService:downloadVSIX" : {
+				"duration": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
+				"${include}": [
+					"${GalleryExtensionTelemetryData}"
+				]
+			}
+		*/
+		const log = (duration: number) => this.telemetryService.publicLog('galleryService:downloadVSIX', { ...data, duration });
+
+		const operationParam = operation === InstallOperation.Install ? 'install' : operation === InstallOperation.Update ? 'update' : '';
+		const downloadAsset = operationParam ? {
+			uri: `${extension.assets.download.uri}&${operationParam}=true`,
+			fallbackUri: `${extension.assets.download.fallbackUri}?${operationParam}=true`
+		} : extension.assets.download;
+
+		const context = await this.getAsset(downloadAsset);
+		await this.fileService.writeFile(location, context.stream);
+		log(new Date().getTime() - startTime);
+	}
+
+	async getReadme(extension: IGalleryExtension, token: CancellationToken): Promise<string> {
+		if (extension.assets.readme) {
+			const context = await this.getAsset(extension.assets.readme, {}, token);
+			const content = await asText(context);
+			return content || '';
+		}
+		return '';
+	}
+
+	async getManifest(extension: IGalleryExtension, token: CancellationToken): Promise<IExtensionManifest | null> {
+		if (extension.assets.manifest) {
+			const context = await this.getAsset(extension.assets.manifest, {}, token);
+			const text = await asText(context);
+			return text ? JSON.parse(text) : null;
+		}
+		return null;
+	}
+
+	async getCoreTranslation(extension: IGalleryExtension, languageId: string): Promise<ITranslation | null> {
+		const asset = extension.assets.coreTranslations.filter(t => t[0] === languageId.toUpperCase())[0];
+		if (asset) {
+			const context = await this.getAsset(asset[1]);
+			const text = await asText(context);
+			return text ? JSON.parse(text) : null;
+		}
+		return null;
+	}
+
+	async getChangelog(extension: IGalleryExtension, token: CancellationToken): Promise<string> {
+		if (extension.assets.changelog) {
+			const context = await this.getAsset(extension.assets.changelog, {}, token);
+			const content = await asText(context);
+			return content || '';
+		}
+		return '';
+	}
+
+	async getAllVersions(extension: IGalleryExtension, compatible: boolean): Promise<IGalleryExtensionVersion[]> {
+		let query = new Query()
+			.withFlags(Flags.IncludeVersions, Flags.IncludeFiles, Flags.IncludeVersionProperties)
+			.withPage(1, 1)
+			.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code');
+
+		if (extension.identifier.uuid) {
+			query = query.withFilter(FilterType.ExtensionId, extension.identifier.uuid);
+		} else {
+			query = query.withFilter(FilterType.ExtensionName, extension.identifier.id);
+		}
+
+		const result: IGalleryExtensionVersion[] = [];
+		const { galleryExtensions } = await this.queryGallery(query, CancellationToken.None);
+		if (galleryExtensions.length) {
+			if (compatible) {
+				await Promise.all(galleryExtensions[0].versions.map(async v => {
+					let engine: string | undefined;
+					try {
+						engine = await this.getEngine(v);
+					} catch (error) { /* Ignore error and skip version */ }
+					if (engine && isEngineValid(engine, this.productService.version)) {
+						result.push({ version: v!.version, date: v!.lastUpdated });
+					}
+				}));
+			} else {
+				result.push(...galleryExtensions[0].versions.map(v => ({ version: v.version, date: v.lastUpdated })));
+			}
+		}
+		return result;
+	}
+
+	private async getAsset(asset: IGalleryExtensionAsset, options: IRequestOptions = {}, token: CancellationToken = CancellationToken.None): Promise<IRequestContext> {
+		const commonHeaders = await this.commonHeadersPromise;
+		const baseOptions = { type: 'GET' };
+		const headers = { ...commonHeaders, ...(options.headers || {}) };
+		options = { ...options, ...baseOptions, headers };
+
+		const url = asset.uri;
+		const fallbackUrl = asset.fallbackUri;
+		const firstOptions = { ...options, url };
+
+		try {
+			const context = await this.requestService.request(firstOptions, token);
+			if (context.res.statusCode === 200) {
+				return context;
+			}
+			const message = await asText(context);
+			throw new Error(`Expected 200, got back ${context.res.statusCode} instead.\n\n${message}`);
+		} catch (err) {
+			if (isPromiseCanceledError(err)) {
+				throw err;
+			}
+
+			const message = getErrorMessage(err);
+			type GalleryServiceCDNFallbackClassification = {
+				url: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+				message: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
+			};
+			type GalleryServiceCDNFallbackEvent = {
+				url: string;
+				message: string;
+			};
+			this.telemetryService.publicLog2<GalleryServiceCDNFallbackEvent, GalleryServiceCDNFallbackClassification>('galleryService:cdnFallback', { url, message });
+
+			const fallbackOptions = { ...options, url: fallbackUrl };
+			return this.requestService.request(fallbackOptions, token);
+		}
+	}
+
+	private async getLastValidExtensionVersion(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): Promise<IRawGalleryExtensionVersion | null> {
+		const version = this.getLastValidExtensionVersionFromProperties(extension, versions);
+		if (version) {
+			return version;
+		}
+		return this.getLastValidExtensionVersionRecursively(extension, versions);
+	}
+
+	private getLastValidExtensionVersionFromProperties(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): IRawGalleryExtensionVersion | null {
+		for (const version of versions) {
+			const engine = getEngine(version);
+			if (!engine) {
+				return null;
+			}
+			if (isEngineValid(engine, this.productService.version)) {
+				return version;
+			}
+		}
+		return null;
+	}
+
+	private async getEngine(version: IRawGalleryExtensionVersion): Promise<string> {
+		const engine = getEngine(version);
+		if (engine) {
+			return engine;
+		}
+
+		const manifestAsset = getVersionAsset(version, AssetType.Manifest);
+		if (!manifestAsset) {
+			throw new Error('Manifest was not found');
+		}
+
+		const headers = { 'Accept-Encoding': 'gzip' };
+		const context = await this.getAsset(manifestAsset, { headers });
+		const manifest = await asJson<IExtensionManifest>(context);
+		if (manifest) {
+			return manifest.engines.vscode;
+		}
+
+		throw new Error('Error while reading manifest');
+	}
+
+	private async getLastValidExtensionVersionRecursively(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): Promise<IRawGalleryExtensionVersion | null> {
+		if (!versions.length) {
+			return null;
+		}
+
+		const version = versions[0];
+		const engine = await this.getEngine(version);
+		if (!isEngineValid(engine, this.productService.version)) {
+			return this.getLastValidExtensionVersionRecursively(extension, versions.slice(1));
+		}
+
+		version.properties = version.properties || [];
+		version.properties.push({ key: PropertyType.Engine, value: engine });
+		return version;
+	}
+
+	async getExtensionsReport(): Promise<IReportedExtension[]> {
+		if (!this.isEnabled()) {
+			throw new Error('No extension gallery service configured.');
+		}
+
+		if (!this.extensionsControlUrl) {
+			return [];
+		}
+
+		const context = await this.requestService.request({ type: 'GET', url: this.extensionsControlUrl }, CancellationToken.None);
+		if (context.res.statusCode !== 200) {
+			throw new Error('Could not get extensions report.');
+		}
+
+		const result = await asJson<IRawExtensionsReport>(context);
+		const map = new Map<string, IReportedExtension>();
+
+		if (result) {
+			for (const id of result.malicious) {
+				const ext = map.get(id) || { id: { id }, malicious: true, slow: false };
+				ext.malicious = true;
+				map.set(id, ext);
+			}
+		}
+
+		return [...map.values()];
+	}
+}
+
+export async function resolveMarketplaceHeaders(version: string, environmentService: IEnvironmentService, fileService: IFileService, storageService: {
+	get: (key: string, scope: StorageScope) => string | undefined,
+	store: (key: string, value: string, scope: StorageScope) => void
+} | undefined): Promise<{ [key: string]: string; }> {
+	const headers: IHeaders = {
+		'X-Market-Client-Id': `VSCode ${version}`,
+		'User-Agent': `VSCode ${version}`
+	};
+	const uuid = await getServiceMachineId(environmentService, fileService, storageService);
+	headers['X-Market-User-Id'] = uuid;
+	return headers;
+}

lib/vscode/src/vs/platform/extensionManagement/common/extensionManagement.ts

@@ -0,0 +1,279 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { Event } from 'vs/base/common/event';
+import { IPager } from 'vs/base/common/paging';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { URI } from 'vs/base/common/uri';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { IExtensionManifest, IExtension, ExtensionType } from 'vs/platform/extensions/common/extensions';
+import { FileAccess } from 'vs/base/common/network';
+
+export const EXTENSION_IDENTIFIER_PATTERN = '^([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$';
+export const EXTENSION_IDENTIFIER_REGEX = new RegExp(EXTENSION_IDENTIFIER_PATTERN);
+
+export interface IGalleryExtensionProperties {
+	dependencies?: string[];
+	extensionPack?: string[];
+	engine?: string;
+	localizedLanguages?: string[];
+	webExtension?: boolean;
+}
+
+export interface IGalleryExtensionAsset {
+	uri: string;
+	fallbackUri: string;
+}
+
+export interface IGalleryExtensionAssets {
+	manifest: IGalleryExtensionAsset | null;
+	readme: IGalleryExtensionAsset | null;
+	changelog: IGalleryExtensionAsset | null;
+	license: IGalleryExtensionAsset | null;
+	repository: IGalleryExtensionAsset | null;
+	download: IGalleryExtensionAsset;
+	icon: IGalleryExtensionAsset;
+	coreTranslations: [string, IGalleryExtensionAsset][];
+}
+
+export function isIExtensionIdentifier(thing: any): thing is IExtensionIdentifier {
+	return thing
+		&& typeof thing === 'object'
+		&& typeof thing.id === 'string'
+		&& (!thing.uuid || typeof thing.uuid === 'string');
+}
+
+/* __GDPR__FRAGMENT__
+	"ExtensionIdentifier" : {
+		"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"uuid": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+	}
+ */
+export interface IExtensionIdentifier {
+	id: string;
+	uuid?: string;
+}
+
+export interface IExtensionIdentifierWithVersion extends IExtensionIdentifier {
+	id: string;
+	uuid?: string;
+	version: string;
+}
+
+export interface IGalleryExtensionIdentifier extends IExtensionIdentifier {
+	uuid: string;
+}
+
+export interface IGalleryExtensionVersion {
+	version: string;
+	date: string;
+}
+
+export interface IGalleryExtension {
+	name: string;
+	identifier: IGalleryExtensionIdentifier;
+	version: string;
+	date: string;
+	displayName: string;
+	publisherId: string;
+	publisher: string;
+	publisherDisplayName: string;
+	description: string;
+	installCount: number;
+	rating: number;
+	ratingCount: number;
+	assetUri: URI;
+	assetTypes: string[];
+	assets: IGalleryExtensionAssets;
+	properties: IGalleryExtensionProperties;
+	telemetryData: any;
+	preview: boolean;
+	webResource?: URI;
+}
+
+export interface IGalleryMetadata {
+	id: string;
+	publisherId: string;
+	publisherDisplayName: string;
+}
+
+export interface ILocalExtension extends IExtension {
+	isMachineScoped: boolean;
+	publisherId: string | null;
+	publisherDisplayName: string | null;
+}
+
+export const enum SortBy {
+	NoneOrRelevance = 0,
+	LastUpdatedDate = 1,
+	Title = 2,
+	PublisherName = 3,
+	InstallCount = 4,
+	PublishedDate = 5,
+	AverageRating = 6,
+	WeightedRating = 12
+}
+
+export const enum SortOrder {
+	Default = 0,
+	Ascending = 1,
+	Descending = 2
+}
+
+export interface IQueryOptions {
+	text?: string;
+	ids?: string[];
+	names?: string[];
+	pageSize?: number;
+	sortBy?: SortBy;
+	sortOrder?: SortOrder;
+	source?: string;
+}
+
+export const enum StatisticType {
+	Uninstall = 'uninstall'
+}
+
+export interface IReportedExtension {
+	id: IExtensionIdentifier;
+	malicious: boolean;
+}
+
+export const enum InstallOperation {
+	None = 0,
+	Install,
+	Update
+}
+
+export interface ITranslation {
+	contents: { [key: string]: {} };
+}
+
+export const IExtensionGalleryService = createDecorator<IExtensionGalleryService>('extensionGalleryService');
+export interface IExtensionGalleryService {
+	readonly _serviceBrand: undefined;
+	isEnabled(): boolean;
+	query(token: CancellationToken): Promise<IPager<IGalleryExtension>>;
+	query(options: IQueryOptions, token: CancellationToken): Promise<IPager<IGalleryExtension>>;
+	getExtensions(ids: string[], token: CancellationToken): Promise<IGalleryExtension[]>;
+	download(extension: IGalleryExtension, location: URI, operation: InstallOperation): Promise<void>;
+	reportStatistic(publisher: string, name: string, version: string, type: StatisticType): Promise<void>;
+	getReadme(extension: IGalleryExtension, token: CancellationToken): Promise<string>;
+	getManifest(extension: IGalleryExtension, token: CancellationToken): Promise<IExtensionManifest | null>;
+	getChangelog(extension: IGalleryExtension, token: CancellationToken): Promise<string>;
+	getCoreTranslation(extension: IGalleryExtension, languageId: string): Promise<ITranslation | null>;
+	getAllVersions(extension: IGalleryExtension, compatible: boolean): Promise<IGalleryExtensionVersion[]>;
+	getExtensionsReport(): Promise<IReportedExtension[]>;
+	getCompatibleExtension(extension: IGalleryExtension): Promise<IGalleryExtension | null>;
+	getCompatibleExtension(id: IExtensionIdentifier, version?: string): Promise<IGalleryExtension | null>;
+}
+
+export interface InstallExtensionEvent {
+	identifier: IExtensionIdentifier;
+	zipPath?: string;
+	gallery?: IGalleryExtension;
+}
+
+export interface DidInstallExtensionEvent {
+	identifier: IExtensionIdentifier;
+	operation: InstallOperation;
+	zipPath?: string;
+	gallery?: IGalleryExtension;
+	local?: ILocalExtension;
+	error?: string;
+}
+
+export interface DidUninstallExtensionEvent {
+	identifier: IExtensionIdentifier;
+	error?: string;
+}
+
+export const INSTALL_ERROR_NOT_SUPPORTED = 'notsupported';
+export const INSTALL_ERROR_MALICIOUS = 'malicious';
+export const INSTALL_ERROR_INCOMPATIBLE = 'incompatible';
+
+export class ExtensionManagementError extends Error {
+	constructor(message: string, readonly code: string) {
+		super(message);
+	}
+}
+
+export type InstallOptions = { isBuiltin?: boolean, isMachineScoped?: boolean };
+
+export const IExtensionManagementService = createDecorator<IExtensionManagementService>('extensionManagementService');
+export interface IExtensionManagementService {
+	readonly _serviceBrand: undefined;
+
+	onInstallExtension: Event<InstallExtensionEvent>;
+	onDidInstallExtension: Event<DidInstallExtensionEvent>;
+	onUninstallExtension: Event<IExtensionIdentifier>;
+	onDidUninstallExtension: Event<DidUninstallExtensionEvent>;
+
+	zip(extension: ILocalExtension): Promise<URI>;
+	unzip(zipLocation: URI): Promise<IExtensionIdentifier>;
+	getManifest(vsix: URI): Promise<IExtensionManifest>;
+	install(vsix: URI, options?: InstallOptions): Promise<ILocalExtension>;
+	canInstall(extension: IGalleryExtension): Promise<boolean>;
+	installFromGallery(extension: IGalleryExtension, options?: InstallOptions): Promise<ILocalExtension>;
+	uninstall(extension: ILocalExtension, force?: boolean): Promise<void>;
+	reinstallFromGallery(extension: ILocalExtension): Promise<void>;
+	getInstalled(type?: ExtensionType): Promise<ILocalExtension[]>;
+	getExtensionsReport(): Promise<IReportedExtension[]>;
+
+	updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension>;
+	updateExtensionScope(local: ILocalExtension, isMachineScoped: boolean): Promise<ILocalExtension>;
+}
+
+export const DISABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/disabled';
+export const ENABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/enabled';
+export const IGlobalExtensionEnablementService = createDecorator<IGlobalExtensionEnablementService>('IGlobalExtensionEnablementService');
+
+export interface IGlobalExtensionEnablementService {
+	readonly _serviceBrand: undefined;
+	readonly onDidChangeEnablement: Event<{ readonly extensions: IExtensionIdentifier[], readonly source?: string }>;
+
+	getDisabledExtensions(): IExtensionIdentifier[];
+	enableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean>;
+	disableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean>;
+
+}
+
+export type IConfigBasedExtensionTip = {
+	readonly extensionId: string,
+	readonly extensionName: string,
+	readonly isExtensionPack: boolean,
+	readonly configName: string,
+	readonly important: boolean,
+};
+
+export type IExecutableBasedExtensionTip = {
+	readonly extensionId: string,
+	readonly extensionName: string,
+	readonly isExtensionPack: boolean,
+	readonly exeName: string,
+	readonly exeFriendlyName: string,
+	readonly windowsPath?: string,
+};
+
+export type IWorkspaceTips = { readonly remoteSet: string[]; readonly recommendations: string[]; };
+
+export const IExtensionTipsService = createDecorator<IExtensionTipsService>('IExtensionTipsService');
+export interface IExtensionTipsService {
+	readonly _serviceBrand: undefined;
+
+	getConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]>;
+	getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]>;
+	getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]>;
+	getAllWorkspacesTips(): Promise<IWorkspaceTips[]>;
+}
+
+
+export const DefaultIconPath = FileAccess.asBrowserUri('./media/defaultIcon.png', require).toString(true);
+export const ExtensionsLabel = localize('extensions', "Extensions");
+export const ExtensionsLocalizedLabel = { value: ExtensionsLabel, original: 'Extensions' };
+export const ExtensionsChannelId = 'extensions';
+export const PreferencesLabel = localize('preferences', "Preferences");
+export const PreferencesLocalizedLabel = { value: PreferencesLabel, original: 'Preferences' };

lib/vscode/src/vs/platform/extensionManagement/common/extensionManagementIpc.ts

@@ -0,0 +1,164 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
+import { IExtensionManagementService, ILocalExtension, InstallExtensionEvent, DidInstallExtensionEvent, IGalleryExtension, DidUninstallExtensionEvent, IExtensionIdentifier, IGalleryMetadata, IReportedExtension, IExtensionTipsService, InstallOptions } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { Event } from 'vs/base/common/event';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { IURITransformer, DefaultURITransformer, transformAndReviveIncomingURIs } from 'vs/base/common/uriIpc';
+import { cloneAndChange } from 'vs/base/common/objects';
+import { ExtensionType, IExtensionManifest } from 'vs/platform/extensions/common/extensions';
+
+function transformIncomingURI(uri: UriComponents, transformer: IURITransformer | null): URI {
+	return URI.revive(transformer ? transformer.transformIncoming(uri) : uri);
+}
+
+function transformOutgoingURI(uri: URI, transformer: IURITransformer | null): URI {
+	return transformer ? transformer.transformOutgoingURI(uri) : uri;
+}
+
+function transformIncomingExtension(extension: ILocalExtension, transformer: IURITransformer | null): ILocalExtension {
+	transformer = transformer ? transformer : DefaultURITransformer;
+	const manifest = extension.manifest;
+	const transformed = transformAndReviveIncomingURIs({ ...extension, ...{ manifest: undefined } }, transformer);
+	return { ...transformed, ...{ manifest } };
+}
+
+function transformOutgoingExtension(extension: ILocalExtension, transformer: IURITransformer | null): ILocalExtension {
+	return transformer ? cloneAndChange(extension, value => value instanceof URI ? transformer.transformOutgoingURI(value) : undefined) : extension;
+}
+
+export class ExtensionManagementChannel implements IServerChannel {
+
+	onInstallExtension: Event<InstallExtensionEvent>;
+	onDidInstallExtension: Event<DidInstallExtensionEvent>;
+	onUninstallExtension: Event<IExtensionIdentifier>;
+	onDidUninstallExtension: Event<DidUninstallExtensionEvent>;
+
+	constructor(private service: IExtensionManagementService, private getUriTransformer: (requestContext: any) => IURITransformer | null) {
+		this.onInstallExtension = Event.buffer(service.onInstallExtension, true);
+		this.onDidInstallExtension = Event.buffer(service.onDidInstallExtension, true);
+		this.onUninstallExtension = Event.buffer(service.onUninstallExtension, true);
+		this.onDidUninstallExtension = Event.buffer(service.onDidUninstallExtension, true);
+	}
+
+	listen(context: any, event: string): Event<any> {
+		const uriTransformer = this.getUriTransformer(context);
+		switch (event) {
+			case 'onInstallExtension': return this.onInstallExtension;
+			case 'onDidInstallExtension': return Event.map(this.onDidInstallExtension, i => ({ ...i, local: i.local ? transformOutgoingExtension(i.local, uriTransformer) : i.local }));
+			case 'onUninstallExtension': return this.onUninstallExtension;
+			case 'onDidUninstallExtension': return this.onDidUninstallExtension;
+		}
+
+		throw new Error('Invalid listen');
+	}
+
+	call(context: any, command: string, args?: any): Promise<any> {
+		const uriTransformer: IURITransformer | null = this.getUriTransformer(context);
+		switch (command) {
+			case 'zip': return this.service.zip(transformIncomingExtension(args[0], uriTransformer)).then(uri => transformOutgoingURI(uri, uriTransformer));
+			case 'unzip': return this.service.unzip(transformIncomingURI(args[0], uriTransformer));
+			case 'install': return this.service.install(transformIncomingURI(args[0], uriTransformer));
+			case 'getManifest': return this.service.getManifest(transformIncomingURI(args[0], uriTransformer));
+			case 'canInstall': return this.service.canInstall(args[0]);
+			case 'installFromGallery': return this.service.installFromGallery(args[0], args[1]);
+			case 'uninstall': return this.service.uninstall(transformIncomingExtension(args[0], uriTransformer), args[1]);
+			case 'reinstallFromGallery': return this.service.reinstallFromGallery(transformIncomingExtension(args[0], uriTransformer));
+			case 'getInstalled': return this.service.getInstalled(args[0]).then(extensions => extensions.map(e => transformOutgoingExtension(e, uriTransformer)));
+			case 'updateMetadata': return this.service.updateMetadata(transformIncomingExtension(args[0], uriTransformer), args[1]).then(e => transformOutgoingExtension(e, uriTransformer));
+			case 'updateExtensionScope': return this.service.updateExtensionScope(transformIncomingExtension(args[0], uriTransformer), args[1]).then(e => transformOutgoingExtension(e, uriTransformer));
+			case 'getExtensionsReport': return this.service.getExtensionsReport();
+		}
+
+		throw new Error('Invalid call');
+	}
+}
+
+export class ExtensionManagementChannelClient implements IExtensionManagementService {
+
+	declare readonly _serviceBrand: undefined;
+
+	constructor(
+		private readonly channel: IChannel,
+	) { }
+
+	get onInstallExtension(): Event<InstallExtensionEvent> { return this.channel.listen('onInstallExtension'); }
+	get onDidInstallExtension(): Event<DidInstallExtensionEvent> { return Event.map(this.channel.listen<DidInstallExtensionEvent>('onDidInstallExtension'), i => ({ ...i, local: i.local ? transformIncomingExtension(i.local, null) : i.local })); }
+	get onUninstallExtension(): Event<IExtensionIdentifier> { return this.channel.listen('onUninstallExtension'); }
+	get onDidUninstallExtension(): Event<DidUninstallExtensionEvent> { return this.channel.listen('onDidUninstallExtension'); }
+
+	zip(extension: ILocalExtension): Promise<URI> {
+		return Promise.resolve(this.channel.call('zip', [extension]).then(result => URI.revive(<UriComponents>result)));
+	}
+
+	unzip(zipLocation: URI): Promise<IExtensionIdentifier> {
+		return Promise.resolve(this.channel.call('unzip', [zipLocation]));
+	}
+
+	install(vsix: URI): Promise<ILocalExtension> {
+		return Promise.resolve(this.channel.call<ILocalExtension>('install', [vsix])).then(local => transformIncomingExtension(local, null));
+	}
+
+	getManifest(vsix: URI): Promise<IExtensionManifest> {
+		return Promise.resolve(this.channel.call<IExtensionManifest>('getManifest', [vsix]));
+	}
+
+	async canInstall(extension: IGalleryExtension): Promise<boolean> {
+		return true;
+	}
+
+	installFromGallery(extension: IGalleryExtension, installOptions?: InstallOptions): Promise<ILocalExtension> {
+		return Promise.resolve(this.channel.call<ILocalExtension>('installFromGallery', [extension, installOptions])).then(local => transformIncomingExtension(local, null));
+	}
+
+	uninstall(extension: ILocalExtension, force = false): Promise<void> {
+		return Promise.resolve(this.channel.call('uninstall', [extension!, force]));
+	}
+
+	reinstallFromGallery(extension: ILocalExtension): Promise<void> {
+		return Promise.resolve(this.channel.call('reinstallFromGallery', [extension]));
+	}
+
+	getInstalled(type: ExtensionType | null = null): Promise<ILocalExtension[]> {
+		return Promise.resolve(this.channel.call<ILocalExtension[]>('getInstalled', [type]))
+			.then(extensions => extensions.map(extension => transformIncomingExtension(extension, null)));
+	}
+
+	updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension> {
+		return Promise.resolve(this.channel.call<ILocalExtension>('updateMetadata', [local, metadata]))
+			.then(extension => transformIncomingExtension(extension, null));
+	}
+
+	updateExtensionScope(local: ILocalExtension, isMachineScoped: boolean): Promise<ILocalExtension> {
+		return Promise.resolve(this.channel.call<ILocalExtension>('updateExtensionScope', [local, isMachineScoped]))
+			.then(extension => transformIncomingExtension(extension, null));
+	}
+
+	getExtensionsReport(): Promise<IReportedExtension[]> {
+		return Promise.resolve(this.channel.call('getExtensionsReport'));
+	}
+}
+
+export class ExtensionTipsChannel implements IServerChannel {
+
+	constructor(private service: IExtensionTipsService) {
+	}
+
+	listen(context: any, event: string): Event<any> {
+		throw new Error('Invalid listen');
+	}
+
+	call(context: any, command: string, args?: any): Promise<any> {
+		switch (command) {
+			case 'getConfigBasedTips': return this.service.getConfigBasedTips(URI.revive(args[0]));
+			case 'getImportantExecutableBasedTips': return this.service.getImportantExecutableBasedTips();
+			case 'getOtherExecutableBasedTips': return this.service.getOtherExecutableBasedTips();
+			case 'getAllWorkspacesTips': return this.service.getAllWorkspacesTips();
+		}
+
+		throw new Error('Invalid call');
+	}
+}

lib/vscode/src/vs/platform/extensionManagement/common/extensionManagementUtil.ts

@@ -0,0 +1,126 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ILocalExtension, IGalleryExtension, IExtensionIdentifier, IReportedExtension, IExtensionIdentifierWithVersion } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { compareIgnoreCase } from 'vs/base/common/strings';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+
+export function areSameExtensions(a: IExtensionIdentifier, b: IExtensionIdentifier): boolean {
+	if (a.uuid && b.uuid) {
+		return a.uuid === b.uuid;
+	}
+	if (a.id === b.id) {
+		return true;
+	}
+	return compareIgnoreCase(a.id, b.id) === 0;
+}
+
+export class ExtensionIdentifierWithVersion implements IExtensionIdentifierWithVersion {
+
+	readonly id: string;
+	readonly uuid?: string;
+
+	constructor(
+		identifier: IExtensionIdentifier,
+		readonly version: string
+	) {
+		this.id = identifier.id;
+		this.uuid = identifier.uuid;
+	}
+
+	key(): string {
+		return `${this.id}-${this.version}`;
+	}
+
+	equals(o: any): boolean {
+		if (!(o instanceof ExtensionIdentifierWithVersion)) {
+			return false;
+		}
+		return areSameExtensions(this, o) && this.version === o.version;
+	}
+}
+
+export function adoptToGalleryExtensionId(id: string): string {
+	return id.toLocaleLowerCase();
+}
+
+export function getGalleryExtensionId(publisher: string, name: string): string {
+	return `${publisher.toLocaleLowerCase()}.${name.toLocaleLowerCase()}`;
+}
+
+export function groupByExtension<T>(extensions: T[], getExtensionIdentifier: (t: T) => IExtensionIdentifier): T[][] {
+	const byExtension: T[][] = [];
+	const findGroup = (extension: T) => {
+		for (const group of byExtension) {
+			if (group.some(e => areSameExtensions(getExtensionIdentifier(e), getExtensionIdentifier(extension)))) {
+				return group;
+			}
+		}
+		return null;
+	};
+	for (const extension of extensions) {
+		const group = findGroup(extension);
+		if (group) {
+			group.push(extension);
+		} else {
+			byExtension.push([extension]);
+		}
+	}
+	return byExtension;
+}
+
+export function getLocalExtensionTelemetryData(extension: ILocalExtension): any {
+	return {
+		id: extension.identifier.id,
+		name: extension.manifest.name,
+		galleryId: null,
+		publisherId: extension.publisherId,
+		publisherName: extension.manifest.publisher,
+		publisherDisplayName: extension.publisherDisplayName,
+		dependencies: extension.manifest.extensionDependencies && extension.manifest.extensionDependencies.length > 0
+	};
+}
+
+
+/* __GDPR__FRAGMENT__
+	"GalleryExtensionTelemetryData" : {
+		"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"name": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"galleryId": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"publisherId": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"publisherName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"publisherDisplayName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+		"dependencies": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
+		"${include}": [
+			"${GalleryExtensionTelemetryData2}"
+		]
+	}
+*/
+export function getGalleryExtensionTelemetryData(extension: IGalleryExtension): any {
+	return {
+		id: extension.identifier.id,
+		name: extension.name,
+		galleryId: extension.identifier.uuid,
+		publisherId: extension.publisherId,
+		publisherName: extension.publisher,
+		publisherDisplayName: extension.publisherDisplayName,
+		dependencies: !!(extension.properties.dependencies && extension.properties.dependencies.length > 0),
+		...extension.telemetryData
+	};
+}
+
+export const BetterMergeId = new ExtensionIdentifier('pprice.better-merge');
+
+export function getMaliciousExtensionsSet(report: IReportedExtension[]): Set<string> {
+	const result = new Set<string>();
+
+	for (const extension of report) {
+		if (extension.malicious) {
+			result.add(extension.id.id);
+		}
+	}
+
+	return result;
+}

lib/vscode/src/vs/platform/extensionManagement/common/extensionNls.ts

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { cloneAndChange } from 'vs/base/common/objects';
+import { IExtensionManifest } from 'vs/platform/extensions/common/extensions';
+
+const nlsRegex = /^%([\w\d.-]+)%$/i;
+
+export interface ITranslations {
+	[key: string]: string;
+}
+
+export function localizeManifest(manifest: IExtensionManifest, translations: ITranslations): IExtensionManifest {
+	const patcher = (value: string) => {
+		if (typeof value !== 'string') {
+			return undefined;
+		}
+
+		const match = nlsRegex.exec(value);
+
+		if (!match) {
+			return undefined;
+		}
+
+		return translations[match[1]] || value;
+	};
+
+	return cloneAndChange(manifest, patcher);
+}

lib/vscode/src/vs/platform/extensionManagement/common/extensionTipsService.ts

@@ -0,0 +1,113 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+import { IProductService, IConfigBasedExtensionTip as IRawConfigBasedExtensionTip } from 'vs/platform/product/common/productService';
+import { IFileService } from 'vs/platform/files/common/files';
+import { isNonEmptyArray } from 'vs/base/common/arrays';
+import { IExtensionTipsService, IExecutableBasedExtensionTip, IWorkspaceTips, IConfigBasedExtensionTip } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { forEach } from 'vs/base/common/collections';
+import { IRequestService, asJson } from 'vs/platform/request/common/request';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { ILogService } from 'vs/platform/log/common/log';
+import { joinPath } from 'vs/base/common/resources';
+import { getDomainsOfRemotes } from 'vs/platform/extensionManagement/common/configRemotes';
+import { Disposable } from 'vs/base/common/lifecycle';
+
+export class ExtensionTipsService extends Disposable implements IExtensionTipsService {
+
+	_serviceBrand: any;
+
+	private readonly allConfigBasedTips: Map<string, IRawConfigBasedExtensionTip> = new Map<string, IRawConfigBasedExtensionTip>();
+
+	constructor(
+		@IFileService protected readonly fileService: IFileService,
+		@IProductService private readonly productService: IProductService,
+		@IRequestService private readonly requestService: IRequestService,
+		@ILogService private readonly logService: ILogService,
+	) {
+		super();
+		if (this.productService.configBasedExtensionTips) {
+			forEach(this.productService.configBasedExtensionTips, ({ value }) => this.allConfigBasedTips.set(value.configPath, value));
+		}
+	}
+
+	getConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]> {
+		return this.getValidConfigBasedTips(folder);
+	}
+
+	getAllWorkspacesTips(): Promise<IWorkspaceTips[]> {
+		return this.fetchWorkspacesTips();
+	}
+
+	async getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
+		return [];
+	}
+
+	async getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
+		return [];
+	}
+
+	private async getValidConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]> {
+		const result: IConfigBasedExtensionTip[] = [];
+		for (const [configPath, tip] of this.allConfigBasedTips) {
+			try {
+				const content = await this.fileService.readFile(joinPath(folder, configPath));
+				const recommendationByRemote: Map<string, IConfigBasedExtensionTip> = new Map<string, IConfigBasedExtensionTip>();
+				forEach(tip.recommendations, ({ key, value }) => {
+					if (isNonEmptyArray(value.remotes)) {
+						for (const remote of value.remotes) {
+							recommendationByRemote.set(remote, {
+								extensionId: key,
+								extensionName: value.name,
+								configName: tip.configName,
+								important: !!value.important,
+								isExtensionPack: !!value.isExtensionPack
+							});
+						}
+					} else {
+						result.push({
+							extensionId: key,
+							extensionName: value.name,
+							configName: tip.configName,
+							important: !!value.important,
+							isExtensionPack: !!value.isExtensionPack
+						});
+					}
+				});
+				const domains = getDomainsOfRemotes(content.value.toString(), [...recommendationByRemote.keys()]);
+				for (const domain of domains) {
+					const remote = recommendationByRemote.get(domain);
+					if (remote) {
+						result.push(remote);
+					}
+				}
+			} catch (error) { /* Ignore */ }
+		}
+		return result;
+	}
+
+
+	private async fetchWorkspacesTips(): Promise<IWorkspaceTips[]> {
+		if (!this.productService.extensionsGallery?.recommendationsUrl) {
+			return [];
+		}
+		try {
+			const context = await this.requestService.request({ type: 'GET', url: this.productService.extensionsGallery?.recommendationsUrl }, CancellationToken.None);
+			if (context.res.statusCode !== 200) {
+				return [];
+			}
+			const result = await asJson<{ workspaceRecommendations?: IWorkspaceTips[] }>(context);
+			if (!result) {
+				return [];
+			}
+			return result.workspaceRecommendations || [];
+		} catch (error) {
+			this.logService.error(error);
+			return [];
+		}
+	}
+
+}

lib/vscode/src/vs/platform/extensionManagement/electron-sandbox/extensionTipsService.ts

@@ -0,0 +1,319 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI } from 'vs/base/common/uri';
+import { basename, join, } from 'vs/base/common/path';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { process } from 'vs/base/parts/sandbox/electron-sandbox/globals';
+import { IFileService } from 'vs/platform/files/common/files';
+import { isWindows } from 'vs/base/common/platform';
+import { isNonEmptyArray } from 'vs/base/common/arrays';
+import { IExecutableBasedExtensionTip, IExtensionManagementService, ILocalExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { forEach, IStringDictionary } from 'vs/base/common/collections';
+import { IRequestService } from 'vs/platform/request/common/request';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ExtensionTipsService as BaseExtensionTipsService } from 'vs/platform/extensionManagement/common/extensionTipsService';
+import { disposableTimeout, timeout } from 'vs/base/common/async';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IExtensionRecommendationNotificationService, RecommendationsNotificationResult, RecommendationSource } from 'vs/platform/extensionRecommendations/common/extensionRecommendations';
+import { localize } from 'vs/nls';
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+
+type ExeExtensionRecommendationsClassification = {
+	extensionId: { classification: 'PublicNonPersonalData', purpose: 'FeatureInsight' };
+	exeName: { classification: 'PublicNonPersonalData', purpose: 'FeatureInsight' };
+};
+
+type IExeBasedExtensionTips = {
+	readonly exeFriendlyName: string,
+	readonly windowsPath?: string,
+	readonly recommendations: { extensionId: string, extensionName: string, isExtensionPack: boolean }[];
+};
+
+const promptedExecutableTipsStorageKey = 'extensionTips/promptedExecutableTips';
+const lastPromptedMediumImpExeTimeStorageKey = 'extensionTips/lastPromptedMediumImpExeTime';
+
+export class ExtensionTipsService extends BaseExtensionTipsService {
+
+	_serviceBrand: any;
+
+	private readonly highImportanceExecutableTips: Map<string, IExeBasedExtensionTips> = new Map<string, IExeBasedExtensionTips>();
+	private readonly mediumImportanceExecutableTips: Map<string, IExeBasedExtensionTips> = new Map<string, IExeBasedExtensionTips>();
+	private readonly allOtherExecutableTips: Map<string, IExeBasedExtensionTips> = new Map<string, IExeBasedExtensionTips>();
+
+	private highImportanceTipsByExe = new Map<string, IExecutableBasedExtensionTip[]>();
+	private mediumImportanceTipsByExe = new Map<string, IExecutableBasedExtensionTip[]>();
+
+	constructor(
+		@INativeEnvironmentService private readonly environmentService: INativeEnvironmentService,
+		@ITelemetryService private readonly telemetryService: ITelemetryService,
+		@IExtensionManagementService private readonly extensionManagementService: IExtensionManagementService,
+		@IStorageService private readonly storageService: IStorageService,
+		@IExtensionRecommendationNotificationService private readonly extensionRecommendationNotificationService: IExtensionRecommendationNotificationService,
+		@IFileService fileService: IFileService,
+		@IProductService productService: IProductService,
+		@IRequestService requestService: IRequestService,
+		@ILogService logService: ILogService,
+	) {
+		super(fileService, productService, requestService, logService);
+		if (productService.exeBasedExtensionTips) {
+			forEach(productService.exeBasedExtensionTips, ({ key, value: exeBasedExtensionTip }) => {
+				const highImportanceRecommendations: { extensionId: string, extensionName: string, isExtensionPack: boolean }[] = [];
+				const mediumImportanceRecommendations: { extensionId: string, extensionName: string, isExtensionPack: boolean }[] = [];
+				const otherRecommendations: { extensionId: string, extensionName: string, isExtensionPack: boolean }[] = [];
+				forEach(exeBasedExtensionTip.recommendations, ({ key: extensionId, value }) => {
+					if (value.important) {
+						if (exeBasedExtensionTip.important) {
+							highImportanceRecommendations.push({ extensionId, extensionName: value.name, isExtensionPack: !!value.isExtensionPack });
+						} else {
+							mediumImportanceRecommendations.push({ extensionId, extensionName: value.name, isExtensionPack: !!value.isExtensionPack });
+						}
+					} else {
+						otherRecommendations.push({ extensionId, extensionName: value.name, isExtensionPack: !!value.isExtensionPack });
+					}
+				});
+				if (highImportanceRecommendations.length) {
+					this.highImportanceExecutableTips.set(key, { exeFriendlyName: exeBasedExtensionTip.friendlyName, windowsPath: exeBasedExtensionTip.windowsPath, recommendations: highImportanceRecommendations });
+				}
+				if (mediumImportanceRecommendations.length) {
+					this.mediumImportanceExecutableTips.set(key, { exeFriendlyName: exeBasedExtensionTip.friendlyName, windowsPath: exeBasedExtensionTip.windowsPath, recommendations: mediumImportanceRecommendations });
+				}
+				if (otherRecommendations.length) {
+					this.allOtherExecutableTips.set(key, { exeFriendlyName: exeBasedExtensionTip.friendlyName, windowsPath: exeBasedExtensionTip.windowsPath, recommendations: otherRecommendations });
+				}
+			});
+		}
+
+		/*
+			3s has come out to be the good number to fetch and prompt important exe based recommendations
+			Also fetch important exe based recommendations for reporting telemetry
+		*/
+		timeout(3000).then(async () => {
+			await this.collectTips();
+			this.promptHighImportanceExeBasedTip();
+			this.promptMediumImportanceExeBasedTip();
+		});
+	}
+
+	async getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
+		const highImportanceExeTips = await this.getValidExecutableBasedExtensionTips(this.highImportanceExecutableTips);
+		const mediumImportanceExeTips = await this.getValidExecutableBasedExtensionTips(this.mediumImportanceExecutableTips);
+		return [...highImportanceExeTips, ...mediumImportanceExeTips];
+	}
+
+	getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
+		return this.getValidExecutableBasedExtensionTips(this.allOtherExecutableTips);
+	}
+
+	private async collectTips(): Promise<void> {
+		const highImportanceExeTips = await this.getValidExecutableBasedExtensionTips(this.highImportanceExecutableTips);
+		const mediumImportanceExeTips = await this.getValidExecutableBasedExtensionTips(this.mediumImportanceExecutableTips);
+		const local = await this.extensionManagementService.getInstalled();
+
+		this.highImportanceTipsByExe = this.groupImportantTipsByExe(highImportanceExeTips, local);
+		this.mediumImportanceTipsByExe = this.groupImportantTipsByExe(mediumImportanceExeTips, local);
+	}
+
+	private groupImportantTipsByExe(importantExeBasedTips: IExecutableBasedExtensionTip[], local: ILocalExtension[]): Map<string, IExecutableBasedExtensionTip[]> {
+		const importantExeBasedRecommendations = new Map<string, IExecutableBasedExtensionTip>();
+		importantExeBasedTips.forEach(tip => importantExeBasedRecommendations.set(tip.extensionId.toLowerCase(), tip));
+
+		const { installed, uninstalled: recommendations } = this.groupByInstalled([...importantExeBasedRecommendations.keys()], local);
+
+		/* Log installed and uninstalled exe based recommendations */
+		for (const extensionId of installed) {
+			const tip = importantExeBasedRecommendations.get(extensionId);
+			if (tip) {
+				this.telemetryService.publicLog2<{ exeName: string, extensionId: string }, ExeExtensionRecommendationsClassification>('exeExtensionRecommendations:alreadyInstalled', { extensionId, exeName: basename(tip.windowsPath!) });
+			}
+		}
+		for (const extensionId of recommendations) {
+			const tip = importantExeBasedRecommendations.get(extensionId);
+			if (tip) {
+				this.telemetryService.publicLog2<{ exeName: string, extensionId: string }, ExeExtensionRecommendationsClassification>('exeExtensionRecommendations:notInstalled', { extensionId, exeName: basename(tip.windowsPath!) });
+			}
+		}
+
+		const promptedExecutableTips = this.getPromptedExecutableTips();
+		const tipsByExe = new Map<string, IExecutableBasedExtensionTip[]>();
+		for (const extensionId of recommendations) {
+			const tip = importantExeBasedRecommendations.get(extensionId);
+			if (tip && (!promptedExecutableTips[tip.exeName] || !promptedExecutableTips[tip.exeName].includes(tip.extensionId))) {
+				let tips = tipsByExe.get(tip.exeName);
+				if (!tips) {
+					tips = [];
+					tipsByExe.set(tip.exeName, tips);
+				}
+				tips.push(tip);
+			}
+		}
+
+		return tipsByExe;
+	}
+
+	/**
+	 * High importance tips are prompted once per restart session
+	 */
+	private promptHighImportanceExeBasedTip(): void {
+		if (this.highImportanceTipsByExe.size === 0) {
+			return;
+		}
+
+		const [exeName, tips] = [...this.highImportanceTipsByExe.entries()][0];
+		this.promptExeRecommendations(tips)
+			.then(result => {
+				switch (result) {
+					case RecommendationsNotificationResult.Accepted:
+						this.addToRecommendedExecutables(tips[0].exeName, tips);
+						break;
+					case RecommendationsNotificationResult.Ignored:
+						this.highImportanceTipsByExe.delete(exeName);
+						break;
+					case RecommendationsNotificationResult.TooMany:
+						// Too many notifications. Schedule the prompt after one hour
+						const disposable = this._register(disposableTimeout(() => { disposable.dispose(); this.promptHighImportanceExeBasedTip(); }, 60 * 60 * 1000 /* 1 hour */));
+						break;
+				}
+			});
+	}
+
+	/**
+	 * Medium importance tips are prompted once per 7 days
+	 */
+	private promptMediumImportanceExeBasedTip(): void {
+		if (this.mediumImportanceTipsByExe.size === 0) {
+			return;
+		}
+
+		const lastPromptedMediumExeTime = this.getLastPromptedMediumExeTime();
+		const timeSinceLastPrompt = Date.now() - lastPromptedMediumExeTime;
+		const promptInterval = 7 * 24 * 60 * 60 * 1000; // 7 Days
+		if (timeSinceLastPrompt < promptInterval) {
+			// Wait until interval and prompt
+			const disposable = this._register(disposableTimeout(() => { disposable.dispose(); this.promptMediumImportanceExeBasedTip(); }, promptInterval - timeSinceLastPrompt));
+			return;
+		}
+
+		const [exeName, tips] = [...this.mediumImportanceTipsByExe.entries()][0];
+		this.promptExeRecommendations(tips)
+			.then(result => {
+				switch (result) {
+					case RecommendationsNotificationResult.Accepted:
+						// Accepted: Update the last prompted time and caches.
+						this.updateLastPromptedMediumExeTime(Date.now());
+						this.mediumImportanceTipsByExe.delete(exeName);
+						this.addToRecommendedExecutables(tips[0].exeName, tips);
+
+						// Schedule the next recommendation for next internval
+						const disposable1 = this._register(disposableTimeout(() => { disposable1.dispose(); this.promptMediumImportanceExeBasedTip(); }, promptInterval));
+						break;
+
+					case RecommendationsNotificationResult.Ignored:
+						// Ignored: Remove from the cache and prompt next recommendation
+						this.mediumImportanceTipsByExe.delete(exeName);
+						this.promptMediumImportanceExeBasedTip();
+						break;
+
+					case RecommendationsNotificationResult.TooMany:
+						// Too many notifications. Schedule the prompt after one hour
+						const disposable2 = this._register(disposableTimeout(() => { disposable2.dispose(); this.promptMediumImportanceExeBasedTip(); }, 60 * 60 * 1000 /* 1 hour */));
+						break;
+				}
+			});
+	}
+
+	private promptExeRecommendations(tips: IExecutableBasedExtensionTip[]): Promise<RecommendationsNotificationResult> {
+		const extensionIds = tips.map(({ extensionId }) => extensionId.toLowerCase());
+		const message = localize({ key: 'exeRecommended', comment: ['Placeholder string is the name of the software that is installed.'] }, "You have {0} installed on your system. Do you want to install the recommended extensions for it?", tips[0].exeFriendlyName);
+		return this.extensionRecommendationNotificationService.promptImportantExtensionsInstallNotification(extensionIds, message, `@exe:"${tips[0].exeName}"`, RecommendationSource.EXE);
+	}
+
+	private getLastPromptedMediumExeTime(): number {
+		let value = this.storageService.getNumber(lastPromptedMediumImpExeTimeStorageKey, StorageScope.GLOBAL);
+		if (!value) {
+			value = Date.now();
+			this.updateLastPromptedMediumExeTime(value);
+		}
+		return value;
+	}
+
+	private updateLastPromptedMediumExeTime(value: number): void {
+		this.storageService.store(lastPromptedMediumImpExeTimeStorageKey, value, StorageScope.GLOBAL);
+	}
+
+	private getPromptedExecutableTips(): IStringDictionary<string[]> {
+		return JSON.parse(this.storageService.get(promptedExecutableTipsStorageKey, StorageScope.GLOBAL, '{}'));
+	}
+
+	private addToRecommendedExecutables(exeName: string, tips: IExecutableBasedExtensionTip[]) {
+		const promptedExecutableTips = this.getPromptedExecutableTips();
+		promptedExecutableTips[exeName] = tips.map(({ extensionId }) => extensionId.toLowerCase());
+		this.storageService.store(promptedExecutableTipsStorageKey, JSON.stringify(promptedExecutableTips), StorageScope.GLOBAL);
+	}
+
+	private groupByInstalled(recommendationsToSuggest: string[], local: ILocalExtension[]): { installed: string[], uninstalled: string[] } {
+		const installed: string[] = [], uninstalled: string[] = [];
+		const installedExtensionsIds = local.reduce((result, i) => { result.add(i.identifier.id.toLowerCase()); return result; }, new Set<string>());
+		recommendationsToSuggest.forEach(id => {
+			if (installedExtensionsIds.has(id.toLowerCase())) {
+				installed.push(id);
+			} else {
+				uninstalled.push(id);
+			}
+		});
+		return { installed, uninstalled };
+	}
+
+	private async getValidExecutableBasedExtensionTips(executableTips: Map<string, IExeBasedExtensionTips>): Promise<IExecutableBasedExtensionTip[]> {
+		const result: IExecutableBasedExtensionTip[] = [];
+
+		const checkedExecutables: Map<string, boolean> = new Map<string, boolean>();
+		for (const exeName of executableTips.keys()) {
+			const extensionTip = executableTips.get(exeName);
+			if (!extensionTip || !isNonEmptyArray(extensionTip.recommendations)) {
+				continue;
+			}
+
+			const exePaths: string[] = [];
+			if (isWindows) {
+				if (extensionTip.windowsPath) {
+					exePaths.push(extensionTip.windowsPath.replace('%USERPROFILE%', process.env['USERPROFILE']!)
+						.replace('%ProgramFiles(x86)%', process.env['ProgramFiles(x86)']!)
+						.replace('%ProgramFiles%', process.env['ProgramFiles']!)
+						.replace('%APPDATA%', process.env['APPDATA']!)
+						.replace('%WINDIR%', process.env['WINDIR']!));
+				}
+			} else {
+				exePaths.push(join('/usr/local/bin', exeName));
+				exePaths.push(join('/usr/bin', exeName));
+				exePaths.push(join(this.environmentService.userHome.fsPath, exeName));
+			}
+
+			for (const exePath of exePaths) {
+				let exists = checkedExecutables.get(exePath);
+				if (exists === undefined) {
+					exists = await this.fileService.exists(URI.file(exePath));
+					checkedExecutables.set(exePath, exists);
+				}
+				if (exists) {
+					for (const { extensionId, extensionName, isExtensionPack } of extensionTip.recommendations) {
+						result.push({
+							extensionId,
+							extensionName,
+							isExtensionPack,
+							exeName,
+							exeFriendlyName: extensionTip.exeFriendlyName,
+							windowsPath: extensionTip.windowsPath,
+						});
+					}
+				}
+			}
+		}
+
+		return result;
+	}
+
+}

lib/vscode/src/vs/platform/extensionManagement/node/extensionDownloader.ts

@@ -0,0 +1,97 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IFileService, IFileStatWithMetadata } from 'vs/platform/files/common/files';
+import { IExtensionGalleryService, IGalleryExtension, InstallOperation } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { URI } from 'vs/base/common/uri';
+import { joinPath } from 'vs/base/common/resources';
+import { ExtensionIdentifierWithVersion, groupByExtension } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { ILogService } from 'vs/platform/log/common/log';
+import { generateUuid } from 'vs/base/common/uuid';
+import * as semver from 'vs/base/common/semver/semver';
+
+const ExtensionIdVersionRegex = /^([^.]+\..+)-(\d+\.\d+\.\d+)$/;
+
+export class ExtensionsDownloader extends Disposable {
+
+	private readonly extensionsDownloadDir: URI;
+	private readonly cache: number;
+	private readonly cleanUpPromise: Promise<void>;
+
+	constructor(
+		@INativeEnvironmentService environmentService: INativeEnvironmentService,
+		@IFileService private readonly fileService: IFileService,
+		@IExtensionGalleryService private readonly extensionGalleryService: IExtensionGalleryService,
+		@ILogService private readonly logService: ILogService,
+	) {
+		super();
+		this.extensionsDownloadDir = URI.file(environmentService.extensionsDownloadPath);
+		this.cache = 20; // Cache 20 downloads
+		this.cleanUpPromise = this.cleanUp();
+	}
+
+	async downloadExtension(extension: IGalleryExtension, operation: InstallOperation): Promise<URI> {
+		await this.cleanUpPromise;
+		const location = joinPath(this.extensionsDownloadDir, this.getName(extension));
+		await this.download(extension, location, operation);
+		return location;
+	}
+
+	async delete(location: URI): Promise<void> {
+		// noop as caching is enabled always
+	}
+
+	private async download(extension: IGalleryExtension, location: URI, operation: InstallOperation): Promise<void> {
+		if (!await this.fileService.exists(location)) {
+			await this.extensionGalleryService.download(extension, location, operation);
+		}
+	}
+
+	private async cleanUp(): Promise<void> {
+		try {
+			if (!(await this.fileService.exists(this.extensionsDownloadDir))) {
+				this.logService.trace('Extension VSIX downlads cache dir does not exist');
+				return;
+			}
+			const folderStat = await this.fileService.resolve(this.extensionsDownloadDir, { resolveMetadata: true });
+			if (folderStat.children) {
+				const toDelete: URI[] = [];
+				const all: [ExtensionIdentifierWithVersion, IFileStatWithMetadata][] = [];
+				for (const stat of folderStat.children) {
+					const extension = this.parse(stat.name);
+					if (extension) {
+						all.push([extension, stat]);
+					}
+				}
+				const byExtension = groupByExtension(all, ([extension]) => extension);
+				const distinct: IFileStatWithMetadata[] = [];
+				for (const p of byExtension) {
+					p.sort((a, b) => semver.rcompare(a[0].version, b[0].version));
+					toDelete.push(...p.slice(1).map(e => e[1].resource)); // Delete outdated extensions
+					distinct.push(p[0][1]);
+				}
+				distinct.sort((a, b) => a.mtime - b.mtime); // sort by modified time
+				toDelete.push(...distinct.slice(0, Math.max(0, distinct.length - this.cache)).map(s => s.resource)); // Retain minimum cacheSize and delete the rest
+				await Promise.all(toDelete.map(resource => {
+					this.logService.trace('Deleting vsix from cache', resource.path);
+					return this.fileService.del(resource);
+				}));
+			}
+		} catch (e) {
+			this.logService.error(e);
+		}
+	}
+
+	private getName(extension: IGalleryExtension): string {
+		return this.cache ? new ExtensionIdentifierWithVersion(extension.identifier, extension.version).key().toLowerCase() : generateUuid();
+	}
+
+	private parse(name: string): ExtensionIdentifierWithVersion | null {
+		const matches = ExtensionIdVersionRegex.exec(name);
+		return matches && matches[1] && matches[2] ? new ExtensionIdentifierWithVersion({ id: matches[1] }, matches[2]) : null;
+	}
+}

lib/vscode/src/vs/platform/extensionManagement/node/extensionLifecycle.ts

@@ -0,0 +1,135 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { ILocalExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { ILogService } from 'vs/platform/log/common/log';
+import { fork, ChildProcess } from 'child_process';
+import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { join } from 'vs/base/common/path';
+import { Limiter } from 'vs/base/common/async';
+import { Event } from 'vs/base/common/event';
+import { Schemas } from 'vs/base/common/network';
+import { rimraf } from 'vs/base/node/pfs';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+
+export class ExtensionsLifecycle extends Disposable {
+
+	private processesLimiter: Limiter<void> = new Limiter(5); // Run max 5 processes in parallel
+
+	constructor(
+		@IEnvironmentService private environmentService: IEnvironmentService,
+		@ILogService private readonly logService: ILogService
+	) {
+		super();
+	}
+
+	async postUninstall(extension: ILocalExtension): Promise<void> {
+		const script = this.parseScript(extension, 'uninstall');
+		if (script) {
+			this.logService.info(extension.identifier.id, extension.manifest.version, `Running post uninstall script`);
+			await this.processesLimiter.queue(() =>
+				this.runLifecycleHook(script.script, 'uninstall', script.args, true, extension)
+					.then(() => this.logService.info(extension.identifier.id, extension.manifest.version, `Finished running post uninstall script`), err => this.logService.error(extension.identifier.id, extension.manifest.version, `Failed to run post uninstall script: ${err}`)));
+		}
+		return rimraf(this.getExtensionStoragePath(extension)).then(undefined, e => this.logService.error('Error while removing extension storage path', e));
+	}
+
+	private parseScript(extension: ILocalExtension, type: string): { script: string, args: string[] } | null {
+		const scriptKey = `vscode:${type}`;
+		if (extension.location.scheme === Schemas.file && extension.manifest && extension.manifest['scripts'] && typeof extension.manifest['scripts'][scriptKey] === 'string') {
+			const script = (<string>extension.manifest['scripts'][scriptKey]).split(' ');
+			if (script.length < 2 || script[0] !== 'node' || !script[1]) {
+				this.logService.warn(extension.identifier.id, extension.manifest.version, `${scriptKey} should be a node script`);
+				return null;
+			}
+			return { script: join(extension.location.fsPath, script[1]), args: script.slice(2) || [] };
+		}
+		return null;
+	}
+
+	private runLifecycleHook(lifecycleHook: string, lifecycleType: string, args: string[], timeout: boolean, extension: ILocalExtension): Promise<void> {
+		return new Promise<void>((c, e) => {
+
+			const extensionLifecycleProcess = this.start(lifecycleHook, lifecycleType, args, extension);
+			let timeoutHandler: any;
+
+			const onexit = (error?: string) => {
+				if (timeoutHandler) {
+					clearTimeout(timeoutHandler);
+					timeoutHandler = null;
+				}
+				if (error) {
+					e(error);
+				} else {
+					c(undefined);
+				}
+			};
+
+			// on error
+			extensionLifecycleProcess.on('error', (err) => {
+				onexit(toErrorMessage(err) || 'Unknown');
+			});
+
+			// on exit
+			extensionLifecycleProcess.on('exit', (code: number, signal: string) => {
+				onexit(code ? `post-${lifecycleType} process exited with code ${code}` : undefined);
+			});
+
+			if (timeout) {
+				// timeout: kill process after waiting for 5s
+				timeoutHandler = setTimeout(() => {
+					timeoutHandler = null;
+					extensionLifecycleProcess.kill();
+					e('timed out');
+				}, 5000);
+			}
+		});
+	}
+
+	private start(uninstallHook: string, lifecycleType: string, args: string[], extension: ILocalExtension): ChildProcess {
+		const opts = {
+			silent: true,
+			execArgv: undefined
+		};
+		const extensionUninstallProcess = fork(uninstallHook, [`--type=extension-post-${lifecycleType}`, ...args], opts);
+
+		// Catch all output coming from the process
+		type Output = { data: string, format: string[] };
+		extensionUninstallProcess.stdout!.setEncoding('utf8');
+		extensionUninstallProcess.stderr!.setEncoding('utf8');
+
+		const onStdout = Event.fromNodeEventEmitter<string>(extensionUninstallProcess.stdout!, 'data');
+		const onStderr = Event.fromNodeEventEmitter<string>(extensionUninstallProcess.stderr!, 'data');
+
+		// Log output
+		onStdout(data => this.logService.info(extension.identifier.id, extension.manifest.version, `post-${lifecycleType}`, data));
+		onStderr(data => this.logService.error(extension.identifier.id, extension.manifest.version, `post-${lifecycleType}`, data));
+
+		const onOutput = Event.any(
+			Event.map(onStdout, o => ({ data: `%c${o}`, format: [''] })),
+			Event.map(onStderr, o => ({ data: `%c${o}`, format: ['color: red'] }))
+		);
+		// Debounce all output, so we can render it in the Chrome console as a group
+		const onDebouncedOutput = Event.debounce<Output>(onOutput, (r, o) => {
+			return r
+				? { data: r.data + o.data, format: [...r.format, ...o.format] }
+				: { data: o.data, format: o.format };
+		}, 100);
+
+		// Print out output
+		onDebouncedOutput(data => {
+			console.group(extension.identifier.id);
+			console.log(data.data, ...data.format);
+			console.groupEnd();
+		});
+
+		return extensionUninstallProcess;
+	}
+
+	private getExtensionStoragePath(extension: ILocalExtension): string {
+		return join(this.environmentService.globalStorageHome.fsPath, extension.identifier.id.toLowerCase());
+	}
+}

lib/vscode/src/vs/platform/extensionManagement/node/extensionManagementService.ts

@@ -0,0 +1,766 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import * as path from 'vs/base/common/path';
+import * as pfs from 'vs/base/node/pfs';
+import { toDisposable, Disposable } from 'vs/base/common/lifecycle';
+import { isNonEmptyArray } from 'vs/base/common/arrays';
+import { zip, IFile } from 'vs/base/node/zip';
+import {
+	IExtensionManagementService, IExtensionGalleryService, ILocalExtension,
+	IGalleryExtension, IGalleryMetadata,
+	InstallExtensionEvent, DidInstallExtensionEvent, DidUninstallExtensionEvent,
+	StatisticType,
+	IExtensionIdentifier,
+	IReportedExtension,
+	InstallOperation,
+	INSTALL_ERROR_MALICIOUS,
+	INSTALL_ERROR_INCOMPATIBLE,
+	ExtensionManagementError,
+	InstallOptions
+} from 'vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions, getGalleryExtensionId, getMaliciousExtensionsSet, getGalleryExtensionTelemetryData, getLocalExtensionTelemetryData, ExtensionIdentifierWithVersion } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { createCancelablePromise, CancelablePromise } from 'vs/base/common/async';
+import { Event, Emitter } from 'vs/base/common/event';
+import * as semver from 'vs/base/common/semver/semver';
+import { URI } from 'vs/base/common/uri';
+import product from 'vs/platform/product/common/product';
+import { isMacintosh } from 'vs/base/common/platform';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ExtensionsManifestCache } from 'vs/platform/extensionManagement/node/extensionsManifestCache';
+import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { isEngineValid } from 'vs/platform/extensions/common/extensionValidator';
+import { joinPath } from 'vs/base/common/resources';
+import { generateUuid } from 'vs/base/common/uuid';
+import { IDownloadService } from 'vs/platform/download/common/download';
+import { optional, IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { Schemas } from 'vs/base/common/network';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { getManifest } from 'vs/platform/extensionManagement/node/extensionManagementUtil';
+import { IExtensionManifest, ExtensionType } from 'vs/platform/extensions/common/extensions';
+import { ExtensionsDownloader } from 'vs/platform/extensionManagement/node/extensionDownloader';
+import { ExtensionsScanner, ILocalExtensionManifest, IMetadata } from 'vs/platform/extensionManagement/node/extensionsScanner';
+import { ExtensionsLifecycle } from 'vs/platform/extensionManagement/node/extensionLifecycle';
+
+const INSTALL_ERROR_UNSET_UNINSTALLED = 'unsetUninstalled';
+const INSTALL_ERROR_DOWNLOADING = 'downloading';
+const INSTALL_ERROR_VALIDATING = 'validating';
+const INSTALL_ERROR_LOCAL = 'local';
+const ERROR_UNKNOWN = 'unknown';
+
+interface InstallableExtension {
+	zipPath: string;
+	identifierWithVersion: ExtensionIdentifierWithVersion;
+	metadata?: IMetadata;
+}
+
+export class ExtensionManagementService extends Disposable implements IExtensionManagementService {
+
+	declare readonly _serviceBrand: undefined;
+
+	private readonly extensionsScanner: ExtensionsScanner;
+	private reportedExtensions: Promise<IReportedExtension[]> | undefined;
+	private lastReportTimestamp = 0;
+	private readonly installingExtensions = new Map<string, CancelablePromise<ILocalExtension>>();
+	private readonly uninstallingExtensions: Map<string, CancelablePromise<void>> = new Map<string, CancelablePromise<void>>();
+	private readonly manifestCache: ExtensionsManifestCache;
+	private readonly extensionsDownloader: ExtensionsDownloader;
+
+	private readonly _onInstallExtension = this._register(new Emitter<InstallExtensionEvent>());
+	readonly onInstallExtension: Event<InstallExtensionEvent> = this._onInstallExtension.event;
+
+	private readonly _onDidInstallExtension = this._register(new Emitter<DidInstallExtensionEvent>());
+	readonly onDidInstallExtension: Event<DidInstallExtensionEvent> = this._onDidInstallExtension.event;
+
+	private readonly _onUninstallExtension = this._register(new Emitter<IExtensionIdentifier>());
+	readonly onUninstallExtension: Event<IExtensionIdentifier> = this._onUninstallExtension.event;
+
+	private _onDidUninstallExtension = this._register(new Emitter<DidUninstallExtensionEvent>());
+	onDidUninstallExtension: Event<DidUninstallExtensionEvent> = this._onDidUninstallExtension.event;
+
+	constructor(
+		@INativeEnvironmentService private readonly environmentService: INativeEnvironmentService,
+		@IExtensionGalleryService private readonly galleryService: IExtensionGalleryService,
+		@ILogService private readonly logService: ILogService,
+		@optional(IDownloadService) private downloadService: IDownloadService,
+		@ITelemetryService private readonly telemetryService: ITelemetryService,
+		@IInstantiationService instantiationService: IInstantiationService,
+	) {
+		super();
+		const extensionLifecycle = this._register(instantiationService.createInstance(ExtensionsLifecycle));
+		this.extensionsScanner = this._register(instantiationService.createInstance(ExtensionsScanner, extension => extensionLifecycle.postUninstall(extension)));
+		this.manifestCache = this._register(new ExtensionsManifestCache(environmentService, this));
+		this.extensionsDownloader = this._register(instantiationService.createInstance(ExtensionsDownloader));
+
+		this._register(toDisposable(() => {
+			this.installingExtensions.forEach(promise => promise.cancel());
+			this.uninstallingExtensions.forEach(promise => promise.cancel());
+			this.installingExtensions.clear();
+			this.uninstallingExtensions.clear();
+		}));
+	}
+
+	async zip(extension: ILocalExtension): Promise<URI> {
+		this.logService.trace('ExtensionManagementService#zip', extension.identifier.id);
+		const files = await this.collectFiles(extension);
+		const location = await zip(joinPath(this.environmentService.tmpDir, generateUuid()).fsPath, files);
+		return URI.file(location);
+	}
+
+	async unzip(zipLocation: URI): Promise<IExtensionIdentifier> {
+		this.logService.trace('ExtensionManagementService#unzip', zipLocation.toString());
+		const local = await this.install(zipLocation);
+		return local.identifier;
+	}
+
+	async getManifest(vsix: URI): Promise<IExtensionManifest> {
+		const downloadLocation = await this.downloadVsix(vsix);
+		const zipPath = path.resolve(downloadLocation.fsPath);
+		return getManifest(zipPath);
+	}
+
+	private async collectFiles(extension: ILocalExtension): Promise<IFile[]> {
+
+		const collectFilesFromDirectory = async (dir: string): Promise<string[]> => {
+			let entries = await pfs.readdir(dir);
+			entries = entries.map(e => path.join(dir, e));
+			const stats = await Promise.all(entries.map(e => pfs.stat(e)));
+			let promise: Promise<string[]> = Promise.resolve([]);
+			stats.forEach((stat, index) => {
+				const entry = entries[index];
+				if (stat.isFile()) {
+					promise = promise.then(result => ([...result, entry]));
+				}
+				if (stat.isDirectory()) {
+					promise = promise
+						.then(result => collectFilesFromDirectory(entry)
+							.then(files => ([...result, ...files])));
+				}
+			});
+			return promise;
+		};
+
+		const files = await collectFilesFromDirectory(extension.location.fsPath);
+		return files.map(f => (<IFile>{ path: `extension/${path.relative(extension.location.fsPath, f)}`, localPath: f }));
+	}
+
+	async install(vsix: URI, options: InstallOptions = {}): Promise<ILocalExtension> {
+		this.logService.trace('ExtensionManagementService#install', vsix.toString());
+		return createCancelablePromise(async token => {
+
+			const downloadLocation = await this.downloadVsix(vsix);
+			const zipPath = path.resolve(downloadLocation.fsPath);
+
+			const manifest = await getManifest(zipPath);
+			const identifier = { id: getGalleryExtensionId(manifest.publisher, manifest.name) };
+			let operation: InstallOperation = InstallOperation.Install;
+			if (manifest.engines && manifest.engines.vscode && !isEngineValid(manifest.engines.vscode, product.version)) {
+				throw new Error(nls.localize('incompatible', "Unable to install extension '{0}' as it is not compatible with VS Code '{1}'.", identifier.id, product.version));
+			}
+
+			const identifierWithVersion = new ExtensionIdentifierWithVersion(identifier, manifest.version);
+			const installedExtensions = await this.getInstalled(ExtensionType.User);
+			const existing = installedExtensions.find(i => areSameExtensions(identifier, i.identifier));
+			if (existing) {
+				options.isMachineScoped = options.isMachineScoped || existing.isMachineScoped;
+				options.isBuiltin = options.isBuiltin || existing.isBuiltin;
+				operation = InstallOperation.Update;
+				if (identifierWithVersion.equals(new ExtensionIdentifierWithVersion(existing.identifier, existing.manifest.version))) {
+					try {
+						await this.extensionsScanner.removeExtension(existing, 'existing');
+					} catch (e) {
+						throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", manifest.displayName || manifest.name));
+					}
+				} else if (semver.gt(existing.manifest.version, manifest.version)) {
+					await this.uninstallExtension(existing);
+				}
+			} else {
+				// Remove the extension with same version if it is already uninstalled.
+				// Installing a VSIX extension shall replace the existing extension always.
+				const existing = await this.unsetUninstalledAndGetLocal(identifierWithVersion);
+				if (existing) {
+					try {
+						await this.extensionsScanner.removeExtension(existing, 'existing');
+					} catch (e) {
+						throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", manifest.displayName || manifest.name));
+					}
+				}
+			}
+
+			this.logService.info('Installing the extension:', identifier.id);
+			this._onInstallExtension.fire({ identifier, zipPath });
+
+			let metadata: IGalleryMetadata | undefined;
+			try {
+				metadata = await this.getGalleryMetadata(getGalleryExtensionId(manifest.publisher, manifest.name));
+			} catch (e) { /* Ignore */ }
+
+			try {
+				const local = await this.installFromZipPath(identifierWithVersion, zipPath, { ...(metadata || {}), ...options }, options, operation, token);
+				this.logService.info('Successfully installed the extension:', identifier.id);
+				return local;
+			} catch (e) {
+				this.logService.error('Failed to install the extension:', identifier.id, e.message);
+				throw e;
+			}
+		});
+	}
+
+	private async downloadVsix(vsix: URI): Promise<URI> {
+		if (vsix.scheme === Schemas.file) {
+			return vsix;
+		}
+		if (!this.downloadService) {
+			throw new Error('Download service is not available');
+		}
+
+		const downloadedLocation = joinPath(this.environmentService.tmpDir, generateUuid());
+		await this.downloadService.download(vsix, downloadedLocation);
+		return downloadedLocation;
+	}
+
+	private async installFromZipPath(identifierWithVersion: ExtensionIdentifierWithVersion, zipPath: string, metadata: IMetadata | undefined, options: InstallOptions, operation: InstallOperation, token: CancellationToken): Promise<ILocalExtension> {
+		try {
+			const local = await this.installExtension({ zipPath, identifierWithVersion, metadata }, token);
+			try {
+				await this.installDependenciesAndPackExtensions(local, undefined, options);
+			} catch (error) {
+				if (isNonEmptyArray(local.manifest.extensionDependencies)) {
+					this.logService.warn(`Cannot install dependencies of extension:`, local.identifier.id, error.message);
+				}
+				if (isNonEmptyArray(local.manifest.extensionPack)) {
+					this.logService.warn(`Cannot install packed extensions of extension:`, local.identifier.id, error.message);
+				}
+			}
+			this._onDidInstallExtension.fire({ identifier: identifierWithVersion, zipPath, local, operation });
+			return local;
+		} catch (error) {
+			this._onDidInstallExtension.fire({ identifier: identifierWithVersion, zipPath, operation, error });
+			throw error;
+		}
+	}
+
+	async canInstall(extension: IGalleryExtension): Promise<boolean> {
+		return true;
+	}
+
+	async installFromGallery(extension: IGalleryExtension, options: InstallOptions = {}): Promise<ILocalExtension> {
+		if (!this.galleryService.isEnabled()) {
+			throw new Error(nls.localize('MarketPlaceDisabled', "Marketplace is not enabled"));
+		}
+
+		try {
+			extension = await this.checkAndGetCompatibleVersion(extension);
+		} catch (error) {
+			const errorCode = error && (<ExtensionManagementError>error).code ? (<ExtensionManagementError>error).code : ERROR_UNKNOWN;
+			this.logService.error(`Failed to install extension:`, extension.identifier.id, error ? error.message : errorCode);
+			this.reportTelemetry(this.getTelemetryEvent(InstallOperation.Install), getGalleryExtensionTelemetryData(extension), undefined, error);
+			if (error instanceof Error) {
+				error.name = errorCode;
+			}
+			throw error;
+		}
+
+		const key = new ExtensionIdentifierWithVersion(extension.identifier, extension.version).key();
+		let cancellablePromise = this.installingExtensions.get(key);
+		if (!cancellablePromise) {
+			cancellablePromise = createCancelablePromise(token => this.doInstallFromGallery(extension, options, token));
+			this.installingExtensions.set(key, cancellablePromise);
+			cancellablePromise.finally(() => this.installingExtensions.delete(key));
+		}
+
+		return cancellablePromise;
+	}
+
+	private async doInstallFromGallery(extension: IGalleryExtension, options: InstallOptions, token: CancellationToken): Promise<ILocalExtension> {
+		const startTime = new Date().getTime();
+		let operation: InstallOperation = InstallOperation.Install;
+		this.logService.info('Installing extension:', extension.identifier.id);
+		this._onInstallExtension.fire({ identifier: extension.identifier, gallery: extension });
+
+		try {
+			const installed = await this.getInstalled(ExtensionType.User);
+			const existingExtension = installed.find(i => areSameExtensions(i.identifier, extension.identifier));
+			if (existingExtension) {
+				operation = InstallOperation.Update;
+			}
+
+			const installableExtension = await this.downloadInstallableExtension(extension, operation);
+			installableExtension.metadata.isMachineScoped = options.isMachineScoped || existingExtension?.isMachineScoped;
+			installableExtension.metadata.isBuiltin = options.isBuiltin || existingExtension?.isBuiltin;
+			const local = await this.installExtension(installableExtension, token);
+
+			try { await this.extensionsDownloader.delete(URI.file(installableExtension.zipPath)); } catch (error) { /* Ignore */ }
+
+			try {
+				await this.installDependenciesAndPackExtensions(local, existingExtension, options);
+			} catch (error) {
+				try { await this.uninstall(local); } catch (error) { /* Ignore */ }
+				throw error;
+			}
+
+			if (existingExtension && semver.neq(existingExtension.manifest.version, extension.version)) {
+				await this.setUninstalled(existingExtension);
+			}
+
+			this.logService.info(`Extensions installed successfully:`, extension.identifier.id);
+			this._onDidInstallExtension.fire({ identifier: extension.identifier, gallery: extension, local, operation });
+			this.reportTelemetry(this.getTelemetryEvent(operation), getGalleryExtensionTelemetryData(extension), new Date().getTime() - startTime, undefined);
+			return local;
+
+		} catch (error) {
+			const errorCode = error && (<ExtensionManagementError>error).code ? (<ExtensionManagementError>error).code : ERROR_UNKNOWN;
+			this.logService.error(`Failed to install extension:`, extension.identifier.id, error ? error.message : errorCode);
+			this._onDidInstallExtension.fire({ identifier: extension.identifier, gallery: extension, operation, error: errorCode });
+			this.reportTelemetry(this.getTelemetryEvent(operation), getGalleryExtensionTelemetryData(extension), new Date().getTime() - startTime, error);
+			if (error instanceof Error) {
+				error.name = errorCode;
+			}
+			throw error;
+		}
+	}
+
+	private async checkAndGetCompatibleVersion(extension: IGalleryExtension): Promise<IGalleryExtension> {
+		if (await this.isMalicious(extension)) {
+			throw new ExtensionManagementError(nls.localize('malicious extension', "Can't install extension since it was reported to be problematic."), INSTALL_ERROR_MALICIOUS);
+		}
+
+		const compatibleExtension = await this.galleryService.getCompatibleExtension(extension);
+		if (!compatibleExtension) {
+			throw new ExtensionManagementError(nls.localize('notFoundCompatibleDependency', "Unable to install '{0}' extension because it is not compatible with the current version of VS Code (version {1}).", extension.identifier.id, product.version), INSTALL_ERROR_INCOMPATIBLE);
+		}
+
+		return compatibleExtension;
+	}
+
+	async reinstallFromGallery(extension: ILocalExtension): Promise<void> {
+		this.logService.trace('ExtensionManagementService#reinstallFromGallery', extension.identifier.id);
+		if (!this.galleryService.isEnabled()) {
+			throw new Error(nls.localize('MarketPlaceDisabled', "Marketplace is not enabled"));
+		}
+
+		const galleryExtension = await this.findGalleryExtension(extension);
+		if (!galleryExtension) {
+			throw new Error(nls.localize('Not a Marketplace extension', "Only Marketplace Extensions can be reinstalled"));
+		}
+
+		await this.setUninstalled(extension);
+		try {
+			await this.extensionsScanner.removeUninstalledExtension(extension);
+		} catch (e) {
+			throw new Error(nls.localize('removeError', "Error while removing the extension: {0}. Please Quit and Start VS Code before trying again.", toErrorMessage(e)));
+		}
+
+		await this.installFromGallery(galleryExtension);
+	}
+
+	private getTelemetryEvent(operation: InstallOperation): string {
+		return operation === InstallOperation.Update ? 'extensionGallery:update' : 'extensionGallery:install';
+	}
+
+	private async isMalicious(extension: IGalleryExtension): Promise<boolean> {
+		const report = await this.getExtensionsReport();
+		return getMaliciousExtensionsSet(report).has(extension.identifier.id);
+	}
+
+	private async downloadInstallableExtension(extension: IGalleryExtension, operation: InstallOperation): Promise<Required<InstallableExtension>> {
+		const metadata = <IGalleryMetadata>{
+			id: extension.identifier.uuid,
+			publisherId: extension.publisherId,
+			publisherDisplayName: extension.publisherDisplayName,
+		};
+
+		let zipPath;
+		try {
+			this.logService.trace('Started downloading extension:', extension.identifier.id);
+			const zip = await this.extensionsDownloader.downloadExtension(extension, operation);
+			this.logService.info('Downloaded extension:', extension.identifier.id, zipPath);
+			zipPath = zip.fsPath;
+		} catch (error) {
+			throw new ExtensionManagementError(this.joinErrors(error).message, INSTALL_ERROR_DOWNLOADING);
+		}
+
+		try {
+			const manifest = await getManifest(zipPath);
+			return (<Required<InstallableExtension>>{ zipPath, identifierWithVersion: new ExtensionIdentifierWithVersion(extension.identifier, manifest.version), metadata });
+		} catch (error) {
+			throw new ExtensionManagementError(this.joinErrors(error).message, INSTALL_ERROR_VALIDATING);
+		}
+	}
+
+	private async installExtension(installableExtension: InstallableExtension, token: CancellationToken): Promise<ILocalExtension> {
+		try {
+			const local = await this.unsetUninstalledAndGetLocal(installableExtension.identifierWithVersion);
+			if (local) {
+				return installableExtension.metadata ? this.extensionsScanner.saveMetadataForLocalExtension(local, installableExtension.metadata) : local;
+			}
+		} catch (e) {
+			if (isMacintosh) {
+				throw new ExtensionManagementError(nls.localize('quitCode', "Unable to install the extension. Please Quit and Start VS Code before reinstalling."), INSTALL_ERROR_UNSET_UNINSTALLED);
+			} else {
+				throw new ExtensionManagementError(nls.localize('exitCode', "Unable to install the extension. Please Exit and Start VS Code before reinstalling."), INSTALL_ERROR_UNSET_UNINSTALLED);
+			}
+		}
+		return this.extractAndInstall(installableExtension, token);
+	}
+
+	private async unsetUninstalledAndGetLocal(identifierWithVersion: ExtensionIdentifierWithVersion): Promise<ILocalExtension | null> {
+		const isUninstalled = await this.isUninstalled(identifierWithVersion);
+		if (!isUninstalled) {
+			return null;
+		}
+
+		this.logService.trace('Removing the extension from uninstalled list:', identifierWithVersion.id);
+		// If the same version of extension is marked as uninstalled, remove it from there and return the local.
+		await this.unsetUninstalled(identifierWithVersion);
+		this.logService.info('Removed the extension from uninstalled list:', identifierWithVersion.id);
+
+		const installed = await this.getInstalled(ExtensionType.User);
+		return installed.find(i => new ExtensionIdentifierWithVersion(i.identifier, i.manifest.version).equals(identifierWithVersion)) || null;
+	}
+
+	private async extractAndInstall({ zipPath, identifierWithVersion, metadata }: InstallableExtension, token: CancellationToken): Promise<ILocalExtension> {
+		let local = await this.extensionsScanner.extractUserExtension(identifierWithVersion, zipPath, token);
+		this.logService.info('Installation completed.', identifierWithVersion.id);
+		if (metadata) {
+			local = await this.extensionsScanner.saveMetadataForLocalExtension(local, metadata);
+		}
+		return local;
+	}
+
+	private async installDependenciesAndPackExtensions(installed: ILocalExtension, existing: ILocalExtension | undefined, options: InstallOptions): Promise<void> {
+		if (!this.galleryService.isEnabled()) {
+			return;
+		}
+		const dependenciesAndPackExtensions: string[] = installed.manifest.extensionDependencies || [];
+		if (installed.manifest.extensionPack) {
+			for (const extension of installed.manifest.extensionPack) {
+				// add only those extensions which are new in currently installed extension
+				if (!(existing && existing.manifest.extensionPack && existing.manifest.extensionPack.some(old => areSameExtensions({ id: old }, { id: extension })))) {
+					if (dependenciesAndPackExtensions.every(e => !areSameExtensions({ id: e }, { id: extension }))) {
+						dependenciesAndPackExtensions.push(extension);
+					}
+				}
+			}
+		}
+		if (dependenciesAndPackExtensions.length) {
+			const installed = await this.getInstalled();
+			// filter out installed extensions
+			const names = dependenciesAndPackExtensions.filter(id => installed.every(({ identifier: galleryIdentifier }) => !areSameExtensions(galleryIdentifier, { id })));
+			if (names.length) {
+				const galleryResult = await this.galleryService.query({ names, pageSize: dependenciesAndPackExtensions.length }, CancellationToken.None);
+				const extensionsToInstall = galleryResult.firstPage;
+				try {
+					await Promise.all(extensionsToInstall.map(e => this.installFromGallery(e, options)));
+				} catch (error) {
+					try { await this.rollback(extensionsToInstall); } catch (e) { /* ignore */ }
+					throw error;
+				}
+			}
+		}
+	}
+
+	private async rollback(extensions: IGalleryExtension[]): Promise<void> {
+		const installed = await this.getInstalled(ExtensionType.User);
+		const extensionsToUninstall = installed.filter(local => extensions.some(galleryExtension => new ExtensionIdentifierWithVersion(local.identifier, local.manifest.version).equals(new ExtensionIdentifierWithVersion(galleryExtension.identifier, galleryExtension.version)))); // Check with version because we want to rollback the exact version
+		await Promise.all(extensionsToUninstall.map(local => this.uninstall(local)));
+	}
+
+	async uninstall(extension: ILocalExtension): Promise<void> {
+		this.logService.trace('ExtensionManagementService#uninstall', extension.identifier.id);
+		const installed = await this.getInstalled(ExtensionType.User);
+		const extensionToUninstall = installed.find(e => areSameExtensions(e.identifier, extension.identifier));
+		if (!extensionToUninstall) {
+			throw new Error(nls.localize('notInstalled', "Extension '{0}' is not installed.", extension.manifest.displayName || extension.manifest.name));
+		}
+
+		try {
+			await this.checkForDependenciesAndUninstall(extensionToUninstall, installed);
+		} catch (error) {
+			throw this.joinErrors(error);
+		}
+	}
+
+	async updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension> {
+		this.logService.trace('ExtensionManagementService#updateMetadata', local.identifier.id);
+		local = await this.extensionsScanner.saveMetadataForLocalExtension(local, { ...((<ILocalExtensionManifest>local.manifest).__metadata || {}), ...metadata });
+		this.manifestCache.invalidate();
+		return local;
+	}
+
+	async updateExtensionScope(local: ILocalExtension, isMachineScoped: boolean): Promise<ILocalExtension> {
+		this.logService.trace('ExtensionManagementService#updateExtensionScope', local.identifier.id);
+		local = await this.extensionsScanner.saveMetadataForLocalExtension(local, { ...((<ILocalExtensionManifest>local.manifest).__metadata || {}), isMachineScoped });
+		this.manifestCache.invalidate();
+		return local;
+	}
+
+	private async getGalleryMetadata(extensionName: string): Promise<IGalleryMetadata | undefined> {
+		const galleryExtension = await this.findGalleryExtensionByName(extensionName);
+		return galleryExtension ? <IGalleryMetadata>{ id: galleryExtension.identifier.uuid, publisherDisplayName: galleryExtension.publisherDisplayName, publisherId: galleryExtension.publisherId } : undefined;
+	}
+
+	private async findGalleryExtension(local: ILocalExtension): Promise<IGalleryExtension> {
+		if (local.identifier.uuid) {
+			const galleryExtension = await this.findGalleryExtensionById(local.identifier.uuid);
+			return galleryExtension ? galleryExtension : this.findGalleryExtensionByName(local.identifier.id);
+		}
+		return this.findGalleryExtensionByName(local.identifier.id);
+	}
+
+	private async findGalleryExtensionById(uuid: string): Promise<IGalleryExtension> {
+		const galleryResult = await this.galleryService.query({ ids: [uuid], pageSize: 1 }, CancellationToken.None);
+		return galleryResult.firstPage[0];
+	}
+
+	private async findGalleryExtensionByName(name: string): Promise<IGalleryExtension> {
+		const galleryResult = await this.galleryService.query({ names: [name], pageSize: 1 }, CancellationToken.None);
+		return galleryResult.firstPage[0];
+	}
+
+	private joinErrors(errorOrErrors: (Error | string) | (Array<Error | string>)): Error {
+		const errors = Array.isArray(errorOrErrors) ? errorOrErrors : [errorOrErrors];
+		if (errors.length === 1) {
+			return errors[0] instanceof Error ? <Error>errors[0] : new Error(<string>errors[0]);
+		}
+		return errors.reduce<Error>((previousValue: Error, currentValue: Error | string) => {
+			return new Error(`${previousValue.message}${previousValue.message ? ',' : ''}${currentValue instanceof Error ? currentValue.message : currentValue}`);
+		}, new Error(''));
+	}
+
+	private async checkForDependenciesAndUninstall(extension: ILocalExtension, installed: ILocalExtension[]): Promise<void> {
+		try {
+			await this.preUninstallExtension(extension);
+			const packedExtensions = this.getAllPackExtensionsToUninstall(extension, installed);
+			if (packedExtensions.length) {
+				await this.uninstallExtensions(extension, packedExtensions, installed);
+			} else {
+				await this.uninstallExtensions(extension, [], installed);
+			}
+		} catch (error) {
+			await this.postUninstallExtension(extension, new ExtensionManagementError(error instanceof Error ? error.message : error, INSTALL_ERROR_LOCAL));
+			throw error;
+		}
+		await this.postUninstallExtension(extension);
+	}
+
+	private async uninstallExtensions(extension: ILocalExtension, otherExtensionsToUninstall: ILocalExtension[], installed: ILocalExtension[]): Promise<void> {
+		const extensionsToUninstall = [extension, ...otherExtensionsToUninstall];
+		for (const e of extensionsToUninstall) {
+			this.checkForDependents(e, extensionsToUninstall, installed, extension);
+		}
+		await Promise.all([this.uninstallExtension(extension), ...otherExtensionsToUninstall.map(d => this.doUninstall(d))]);
+	}
+
+	private checkForDependents(extension: ILocalExtension, extensionsToUninstall: ILocalExtension[], installed: ILocalExtension[], extensionToUninstall: ILocalExtension): void {
+		const dependents = this.getDependents(extension, installed);
+		if (dependents.length) {
+			const remainingDependents = dependents.filter(dependent => extensionsToUninstall.indexOf(dependent) === -1);
+			if (remainingDependents.length) {
+				throw new Error(this.getDependentsErrorMessage(extension, remainingDependents, extensionToUninstall));
+			}
+		}
+	}
+
+	private getDependentsErrorMessage(dependingExtension: ILocalExtension, dependents: ILocalExtension[], extensionToUninstall: ILocalExtension): string {
+		if (extensionToUninstall === dependingExtension) {
+			if (dependents.length === 1) {
+				return nls.localize('singleDependentError', "Cannot uninstall '{0}' extension. '{1}' extension depends on this.",
+					extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name);
+			}
+			if (dependents.length === 2) {
+				return nls.localize('twoDependentsError', "Cannot uninstall '{0}' extension. '{1}' and '{2}' extensions depend on this.",
+					extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name, dependents[1].manifest.displayName || dependents[1].manifest.name);
+			}
+			return nls.localize('multipleDependentsError', "Cannot uninstall '{0}' extension. '{1}', '{2}' and other extension depend on this.",
+				extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name, dependents[1].manifest.displayName || dependents[1].manifest.name);
+		}
+		if (dependents.length === 1) {
+			return nls.localize('singleIndirectDependentError', "Cannot uninstall '{0}' extension . It includes uninstalling '{1}' extension and '{2}' extension depends on this.",
+				extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name, dependingExtension.manifest.displayName
+			|| dependingExtension.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name);
+		}
+		if (dependents.length === 2) {
+			return nls.localize('twoIndirectDependentsError', "Cannot uninstall '{0}' extension. It includes uninstalling '{1}' extension and '{2}' and '{3}' extensions depend on this.",
+				extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name, dependingExtension.manifest.displayName
+			|| dependingExtension.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name, dependents[1].manifest.displayName || dependents[1].manifest.name);
+		}
+		return nls.localize('multipleIndirectDependentsError', "Cannot uninstall '{0}' extension. It includes uninstalling '{1}' extension and '{2}', '{3}' and other extensions depend on this.",
+			extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name, dependingExtension.manifest.displayName
+		|| dependingExtension.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name, dependents[1].manifest.displayName || dependents[1].manifest.name);
+
+	}
+
+	private getAllPackExtensionsToUninstall(extension: ILocalExtension, installed: ILocalExtension[], checked: ILocalExtension[] = []): ILocalExtension[] {
+		if (checked.indexOf(extension) !== -1) {
+			return [];
+		}
+		checked.push(extension);
+		const extensionsPack = extension.manifest.extensionPack ? extension.manifest.extensionPack : [];
+		if (extensionsPack.length) {
+			const packedExtensions = installed.filter(i => !i.isBuiltin && extensionsPack.some(id => areSameExtensions({ id }, i.identifier)));
+			const packOfPackedExtensions: ILocalExtension[] = [];
+			for (const packedExtension of packedExtensions) {
+				packOfPackedExtensions.push(...this.getAllPackExtensionsToUninstall(packedExtension, installed, checked));
+			}
+			return [...packedExtensions, ...packOfPackedExtensions];
+		}
+		return [];
+	}
+
+	private getDependents(extension: ILocalExtension, installed: ILocalExtension[]): ILocalExtension[] {
+		return installed.filter(e => e.manifest.extensionDependencies && e.manifest.extensionDependencies.some(id => areSameExtensions({ id }, extension.identifier)));
+	}
+
+	private async doUninstall(extension: ILocalExtension): Promise<void> {
+		try {
+			await this.preUninstallExtension(extension);
+			await this.uninstallExtension(extension);
+		} catch (error) {
+			await this.postUninstallExtension(extension, new ExtensionManagementError(error instanceof Error ? error.message : error, INSTALL_ERROR_LOCAL));
+			throw error;
+		}
+		await this.postUninstallExtension(extension);
+	}
+
+	private async preUninstallExtension(extension: ILocalExtension): Promise<void> {
+		const exists = await pfs.exists(extension.location.fsPath);
+		if (!exists) {
+			throw new Error(nls.localize('notExists', "Could not find extension"));
+		}
+		this.logService.info('Uninstalling extension:', extension.identifier.id);
+		this._onUninstallExtension.fire(extension.identifier);
+	}
+
+	private async uninstallExtension(local: ILocalExtension): Promise<void> {
+		let promise = this.uninstallingExtensions.get(local.identifier.id);
+		if (!promise) {
+			// Set all versions of the extension as uninstalled
+			promise = createCancelablePromise(async () => {
+				const userExtensions = await this.extensionsScanner.scanUserExtensions(false);
+				await this.setUninstalled(...userExtensions.filter(u => areSameExtensions(u.identifier, local.identifier)));
+			});
+			this.uninstallingExtensions.set(local.identifier.id, promise);
+			promise.finally(() => this.uninstallingExtensions.delete(local.identifier.id));
+		}
+		return promise;
+	}
+
+	private async postUninstallExtension(extension: ILocalExtension, error?: Error): Promise<void> {
+		if (error) {
+			this.logService.error('Failed to uninstall extension:', extension.identifier.id, error.message);
+		} else {
+			this.logService.info('Successfully uninstalled extension:', extension.identifier.id);
+			// only report if extension has a mapped gallery extension. UUID identifies the gallery extension.
+			if (extension.identifier.uuid) {
+				try {
+					await this.galleryService.reportStatistic(extension.manifest.publisher, extension.manifest.name, extension.manifest.version, StatisticType.Uninstall);
+				} catch (error) { /* ignore */ }
+			}
+		}
+		this.reportTelemetry('extensionGallery:uninstall', getLocalExtensionTelemetryData(extension), undefined, error);
+		const errorcode = error ? error instanceof ExtensionManagementError ? error.code : ERROR_UNKNOWN : undefined;
+		this._onDidUninstallExtension.fire({ identifier: extension.identifier, error: errorcode });
+	}
+
+	getInstalled(type: ExtensionType | null = null): Promise<ILocalExtension[]> {
+		return this.extensionsScanner.scanExtensions(type);
+	}
+
+	removeDeprecatedExtensions(): Promise<void> {
+		return this.extensionsScanner.cleanUp();
+	}
+
+	private async isUninstalled(identifier: ExtensionIdentifierWithVersion): Promise<boolean> {
+		const uninstalled = await this.filterUninstalled(identifier);
+		return uninstalled.length === 1;
+	}
+
+	private filterUninstalled(...identifiers: ExtensionIdentifierWithVersion[]): Promise<string[]> {
+		return this.extensionsScanner.withUninstalledExtensions(allUninstalled => {
+			const uninstalled: string[] = [];
+			for (const identifier of identifiers) {
+				if (!!allUninstalled[identifier.key()]) {
+					uninstalled.push(identifier.key());
+				}
+			}
+			return uninstalled;
+		});
+	}
+
+	private setUninstalled(...extensions: ILocalExtension[]): Promise<{ [id: string]: boolean }> {
+		const ids: ExtensionIdentifierWithVersion[] = extensions.map(e => new ExtensionIdentifierWithVersion(e.identifier, e.manifest.version));
+		return this.extensionsScanner.withUninstalledExtensions(uninstalled => {
+			ids.forEach(id => uninstalled[id.key()] = true);
+			return uninstalled;
+		});
+	}
+
+	private unsetUninstalled(extensionIdentifier: ExtensionIdentifierWithVersion): Promise<void> {
+		return this.extensionsScanner.withUninstalledExtensions<void>(uninstalled => delete uninstalled[extensionIdentifier.key()]);
+	}
+
+	getExtensionsReport(): Promise<IReportedExtension[]> {
+		const now = new Date().getTime();
+
+		if (!this.reportedExtensions || now - this.lastReportTimestamp > 1000 * 60 * 5) { // 5 minute cache freshness
+			this.reportedExtensions = this.updateReportCache();
+			this.lastReportTimestamp = now;
+		}
+
+		return this.reportedExtensions;
+	}
+
+	private async updateReportCache(): Promise<IReportedExtension[]> {
+		try {
+			this.logService.trace('ExtensionManagementService.refreshReportedCache');
+			const result = await this.galleryService.getExtensionsReport();
+			this.logService.trace(`ExtensionManagementService.refreshReportedCache - got ${result.length} reported extensions from service`);
+			return result;
+		} catch (err) {
+			this.logService.trace('ExtensionManagementService.refreshReportedCache - failed to get extension report');
+			return [];
+		}
+	}
+
+	private reportTelemetry(eventName: string, extensionData: any, duration?: number, error?: Error): void {
+		const errorcode = error ? error instanceof ExtensionManagementError ? error.code : ERROR_UNKNOWN : undefined;
+		/* __GDPR__
+			"extensionGallery:install" : {
+				"success": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
+				"duration" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
+				"errorcode": { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
+				"recommendationReason": { "retiredFromVersion": "1.23.0", "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
+				"${include}": [
+					"${GalleryExtensionTelemetryData}"
+				]
+			}
+		*/
+		/* __GDPR__
+			"extensionGallery:uninstall" : {
+				"success": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
+				"duration" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
+				"errorcode": { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
+				"${include}": [
+					"${GalleryExtensionTelemetryData}"
+				]
+			}
+		*/
+		/* __GDPR__
+			"extensionGallery:update" : {
+				"success": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
+				"duration" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
+				"errorcode": { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
+				"${include}": [
+					"${GalleryExtensionTelemetryData}"
+				]
+			}
+		*/
+		this.telemetryService.publicLogError(eventName, { ...extensionData, success: !error, duration, errorcode });
+	}
+}

lib/vscode/src/vs/platform/extensionManagement/node/extensionManagementUtil.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { buffer } from 'vs/base/node/zip';
+import { localize } from 'vs/nls';
+import { IExtensionManifest } from 'vs/platform/extensions/common/extensions';
+
+export function getManifest(vsix: string): Promise<IExtensionManifest> {
+	return buffer(vsix, 'extension/package.json')
+		.then(buffer => {
+			try {
+				return JSON.parse(buffer.toString('utf8'));
+			} catch (err) {
+				throw new Error(localize('invalidManifest', "VSIX invalid: package.json is not a JSON file."));
+			}
+		});
+}

lib/vscode/src/vs/platform/extensionManagement/node/extensionsManifestCache.ts

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { join } from 'vs/base/common/path';
+import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IExtensionManagementService, DidInstallExtensionEvent, DidUninstallExtensionEvent } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { MANIFEST_CACHE_FOLDER, USER_MANIFEST_CACHE_FILE } from 'vs/platform/extensions/common/extensions';
+import * as pfs from 'vs/base/node/pfs';
+
+export class ExtensionsManifestCache extends Disposable {
+
+	private extensionsManifestCache = join(this.environmentService.userDataPath, MANIFEST_CACHE_FOLDER, USER_MANIFEST_CACHE_FILE);
+
+	constructor(
+		private readonly environmentService: INativeEnvironmentService,
+		extensionsManagementService: IExtensionManagementService
+	) {
+		super();
+		this._register(extensionsManagementService.onDidInstallExtension(e => this.onDidInstallExtension(e)));
+		this._register(extensionsManagementService.onDidUninstallExtension(e => this.onDidUnInstallExtension(e)));
+	}
+
+	private onDidInstallExtension(e: DidInstallExtensionEvent): void {
+		if (!e.error) {
+			this.invalidate();
+		}
+	}
+
+	private onDidUnInstallExtension(e: DidUninstallExtensionEvent): void {
+		if (!e.error) {
+			this.invalidate();
+		}
+	}
+
+	invalidate(): void {
+		pfs.rimraf(this.extensionsManifestCache, pfs.RimRafMode.MOVE).then(() => { }, () => { });
+	}
+}

lib/vscode/src/vs/platform/extensionManagement/node/extensionsScanner.ts

@@ -0,0 +1,373 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as semver from 'vs/base/common/semver/semver';
+import { Disposable } from 'vs/base/common/lifecycle';
+import * as pfs from 'vs/base/node/pfs';
+import * as path from 'vs/base/common/path';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ILocalExtension, IGalleryMetadata, ExtensionManagementError } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { ExtensionType, IExtensionManifest, IExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { areSameExtensions, ExtensionIdentifierWithVersion, groupByExtension, getGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { Limiter, Queue } from 'vs/base/common/async';
+import { URI } from 'vs/base/common/uri';
+import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { localizeManifest } from 'vs/platform/extensionManagement/common/extensionNls';
+import { localize } from 'vs/nls';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { CancellationToken } from 'vscode';
+import { extract, ExtractError } from 'vs/base/node/zip';
+import { isWindows } from 'vs/base/common/platform';
+import { flatten } from 'vs/base/common/arrays';
+import { IStringDictionary } from 'vs/base/common/collections';
+import { FileAccess } from 'vs/base/common/network';
+
+const ERROR_SCANNING_SYS_EXTENSIONS = 'scanningSystem';
+const ERROR_SCANNING_USER_EXTENSIONS = 'scanningUser';
+const INSTALL_ERROR_EXTRACTING = 'extracting';
+const INSTALL_ERROR_DELETING = 'deleting';
+const INSTALL_ERROR_RENAMING = 'renaming';
+
+export type IMetadata = Partial<IGalleryMetadata & { isMachineScoped: boolean; isBuiltin: boolean }>;
+export type ILocalExtensionManifest = IExtensionManifest & { __metadata?: IMetadata };
+type IRelaxedLocalExtension = Omit<ILocalExtension, 'isBuiltin'> & { isBuiltin: boolean };
+
+export class ExtensionsScanner extends Disposable {
+
+	private readonly systemExtensionsPath: string;
+	private readonly extensionsPath: string;
+	private readonly uninstalledPath: string;
+	private readonly uninstalledFileLimiter: Queue<any>;
+
+	constructor(
+		private readonly beforeRemovingExtension: (e: ILocalExtension) => Promise<void>,
+		@ILogService private readonly logService: ILogService,
+		@INativeEnvironmentService private readonly environmentService: INativeEnvironmentService,
+		@IProductService private readonly productService: IProductService,
+	) {
+		super();
+		this.systemExtensionsPath = environmentService.builtinExtensionsPath;
+		this.extensionsPath = environmentService.extensionsPath!;
+		this.uninstalledPath = path.join(this.extensionsPath, '.obsolete');
+		this.uninstalledFileLimiter = new Queue();
+	}
+
+	async cleanUp(): Promise<void> {
+		await this.removeUninstalledExtensions();
+		await this.removeOutdatedExtensions();
+	}
+
+	async scanExtensions(type: ExtensionType | null): Promise<ILocalExtension[]> {
+		const promises: Promise<ILocalExtension[]>[] = [];
+
+		if (type === null || type === ExtensionType.System) {
+			promises.push(this.scanSystemExtensions().then(null, e => Promise.reject(new ExtensionManagementError(this.joinErrors(e).message, ERROR_SCANNING_SYS_EXTENSIONS))));
+		}
+
+		if (type === null || type === ExtensionType.User) {
+			promises.push(this.scanUserExtensions(true).then(null, e => Promise.reject(new ExtensionManagementError(this.joinErrors(e).message, ERROR_SCANNING_USER_EXTENSIONS))));
+		}
+
+		try {
+			const result = await Promise.all(promises);
+			return flatten(result);
+		} catch (error) {
+			throw this.joinErrors(error);
+		}
+	}
+
+	async scanUserExtensions(excludeOutdated: boolean): Promise<ILocalExtension[]> {
+		this.logService.trace('Started scanning user extensions');
+		let [uninstalled, extensions] = await Promise.all([this.getUninstalledExtensions(), this.scanAllUserExtensions()]);
+		extensions = extensions.filter(e => !uninstalled[new ExtensionIdentifierWithVersion(e.identifier, e.manifest.version).key()]);
+		if (excludeOutdated) {
+			const byExtension: ILocalExtension[][] = groupByExtension(extensions, e => e.identifier);
+			extensions = byExtension.map(p => p.sort((a, b) => semver.rcompare(a.manifest.version, b.manifest.version))[0]);
+		}
+		this.logService.trace('Scanned user extensions:', extensions.length);
+		return extensions;
+	}
+
+	async scanAllUserExtensions(): Promise<ILocalExtension[]> {
+		return this.scanExtensionsInDir(this.extensionsPath, ExtensionType.User);
+	}
+
+	async extractUserExtension(identifierWithVersion: ExtensionIdentifierWithVersion, zipPath: string, token: CancellationToken): Promise<ILocalExtension> {
+		const folderName = identifierWithVersion.key();
+		const tempPath = path.join(this.extensionsPath, `.${folderName}`);
+		const extensionPath = path.join(this.extensionsPath, folderName);
+
+		try {
+			await pfs.rimraf(extensionPath);
+		} catch (error) {
+			try {
+				await pfs.rimraf(extensionPath);
+			} catch (e) { /* ignore */ }
+			throw new ExtensionManagementError(localize('errorDeleting', "Unable to delete the existing folder '{0}' while installing the extension '{1}'. Please delete the folder manually and try again", extensionPath, identifierWithVersion.id), INSTALL_ERROR_DELETING);
+		}
+
+		await this.extractAtLocation(identifierWithVersion, zipPath, tempPath, token);
+		try {
+			await this.rename(identifierWithVersion, tempPath, extensionPath, Date.now() + (2 * 60 * 1000) /* Retry for 2 minutes */);
+			this.logService.info('Renamed to', extensionPath);
+		} catch (error) {
+			this.logService.info('Rename failed. Deleting from extracted location', tempPath);
+			try {
+				pfs.rimraf(tempPath);
+			} catch (e) { /* ignore */ }
+			throw error;
+		}
+
+		let local: ILocalExtension | null = null;
+		try {
+			local = await this.scanExtension(folderName, this.extensionsPath, ExtensionType.User);
+		} catch (e) { /*ignore */ }
+
+		if (local) {
+			return local;
+		}
+		throw new Error(localize('cannot read', "Cannot read the extension from {0}", this.extensionsPath));
+	}
+
+	async saveMetadataForLocalExtension(local: ILocalExtension, metadata: IMetadata): Promise<ILocalExtension> {
+		this.setMetadata(local, metadata);
+
+		// unset if false
+		metadata.isMachineScoped = metadata.isMachineScoped || undefined;
+		metadata.isBuiltin = metadata.isBuiltin || undefined;
+		const manifestPath = path.join(local.location.fsPath, 'package.json');
+		const raw = await pfs.readFile(manifestPath, 'utf8');
+		const { manifest } = await this.parseManifest(raw);
+		(manifest as ILocalExtensionManifest).__metadata = metadata;
+		await pfs.writeFile(manifestPath, JSON.stringify(manifest, null, '\t'));
+		return local;
+	}
+
+	getUninstalledExtensions(): Promise<{ [id: string]: boolean; }> {
+		return this.withUninstalledExtensions(uninstalled => uninstalled);
+	}
+
+	async withUninstalledExtensions<T>(fn: (uninstalled: IStringDictionary<boolean>) => T): Promise<T> {
+		return this.uninstalledFileLimiter.queue(async () => {
+			let raw: string | undefined;
+			try {
+				raw = await pfs.readFile(this.uninstalledPath, 'utf8');
+			} catch (err) {
+				if (err.code !== 'ENOENT') {
+					throw err;
+				}
+			}
+
+			let uninstalled = {};
+			if (raw) {
+				try {
+					uninstalled = JSON.parse(raw);
+				} catch (e) { /* ignore */ }
+			}
+
+			const result = fn(uninstalled);
+
+			if (Object.keys(uninstalled).length) {
+				await pfs.writeFile(this.uninstalledPath, JSON.stringify(uninstalled));
+			} else {
+				await pfs.rimraf(this.uninstalledPath);
+			}
+
+			return result;
+		});
+	}
+
+	async removeExtension(extension: ILocalExtension, type: string): Promise<void> {
+		this.logService.trace(`Deleting ${type} extension from disk`, extension.identifier.id, extension.location.fsPath);
+		await pfs.rimraf(extension.location.fsPath);
+		this.logService.info('Deleted from disk', extension.identifier.id, extension.location.fsPath);
+	}
+
+	async removeUninstalledExtension(extension: ILocalExtension): Promise<void> {
+		await this.removeExtension(extension, 'uninstalled');
+		await this.withUninstalledExtensions(uninstalled => delete uninstalled[new ExtensionIdentifierWithVersion(extension.identifier, extension.manifest.version).key()]);
+	}
+
+	private async extractAtLocation(identifier: IExtensionIdentifier, zipPath: string, location: string, token: CancellationToken): Promise<void> {
+		this.logService.trace(`Started extracting the extension from ${zipPath} to ${location}`);
+
+		// Clean the location
+		try {
+			await pfs.rimraf(location);
+		} catch (e) {
+			throw new ExtensionManagementError(this.joinErrors(e).message, INSTALL_ERROR_DELETING);
+		}
+
+		try {
+			await extract(zipPath, location, { sourcePath: 'extension', overwrite: true }, token);
+			this.logService.info(`Extracted extension to ${location}:`, identifier.id);
+		} catch (e) {
+			try { await pfs.rimraf(location); } catch (e) { /* Ignore */ }
+			throw new ExtensionManagementError(e.message, e instanceof ExtractError && e.type ? e.type : INSTALL_ERROR_EXTRACTING);
+		}
+	}
+
+	private async rename(identifier: IExtensionIdentifier, extractPath: string, renamePath: string, retryUntil: number): Promise<void> {
+		try {
+			await pfs.rename(extractPath, renamePath);
+		} catch (error) {
+			if (isWindows && error && error.code === 'EPERM' && Date.now() < retryUntil) {
+				this.logService.info(`Failed renaming ${extractPath} to ${renamePath} with 'EPERM' error. Trying again...`, identifier.id);
+				return this.rename(identifier, extractPath, renamePath, retryUntil);
+			}
+			throw new ExtensionManagementError(error.message || localize('renameError', "Unknown error while renaming {0} to {1}", extractPath, renamePath), error.code || INSTALL_ERROR_RENAMING);
+		}
+	}
+
+	private async scanSystemExtensions(): Promise<ILocalExtension[]> {
+		this.logService.trace('Started scanning system extensions');
+		const systemExtensionsPromise = this.scanDefaultSystemExtensions();
+		if (this.environmentService.isBuilt) {
+			return systemExtensionsPromise;
+		}
+
+		// Scan other system extensions during development
+		const devSystemExtensionsPromise = this.scanDevSystemExtensions();
+		const [systemExtensions, devSystemExtensions] = await Promise.all([systemExtensionsPromise, devSystemExtensionsPromise]);
+		return [...systemExtensions, ...devSystemExtensions];
+	}
+
+	private async scanExtensionsInDir(dir: string, type: ExtensionType): Promise<ILocalExtension[]> {
+		const limiter = new Limiter<any>(10);
+		const extensionsFolders = await pfs.readdir(dir);
+		const extensions = await Promise.all<ILocalExtension>(extensionsFolders.map(extensionFolder => limiter.queue(() => this.scanExtension(extensionFolder, dir, type))));
+		return extensions.filter(e => e && e.identifier);
+	}
+
+	private async scanExtension(folderName: string, root: string, type: ExtensionType): Promise<ILocalExtension | null> {
+		if (type === ExtensionType.User && folderName.indexOf('.') === 0) { // Do not consider user extension folder starting with `.`
+			return null;
+		}
+		const extensionPath = path.join(root, folderName);
+		try {
+			const children = await pfs.readdir(extensionPath);
+			const { manifest, metadata } = await this.readManifest(extensionPath);
+			const readme = children.filter(child => /^readme(\.txt|\.md|)$/i.test(child))[0];
+			const readmeUrl = readme ? URI.file(path.join(extensionPath, readme)) : undefined;
+			const changelog = children.filter(child => /^changelog(\.txt|\.md|)$/i.test(child))[0];
+			const changelogUrl = changelog ? URI.file(path.join(extensionPath, changelog)) : undefined;
+			const identifier = { id: getGalleryExtensionId(manifest.publisher, manifest.name) };
+			const local = <ILocalExtension>{ type, identifier, manifest, location: URI.file(extensionPath), readmeUrl, changelogUrl, publisherDisplayName: null, publisherId: null, isMachineScoped: false, isBuiltin: type === ExtensionType.System };
+			if (metadata) {
+				this.setMetadata(local, metadata);
+			}
+			return local;
+		} catch (e) {
+			this.logService.trace(e);
+			return null;
+		}
+	}
+
+	private async scanDefaultSystemExtensions(): Promise<ILocalExtension[]> {
+		const result = await this.scanExtensionsInDir(this.systemExtensionsPath, ExtensionType.System);
+		this.logService.trace('Scanned system extensions:', result.length);
+		return result;
+	}
+
+	private async scanDevSystemExtensions(): Promise<ILocalExtension[]> {
+		const devSystemExtensionsList = this.getDevSystemExtensionsList();
+		if (devSystemExtensionsList.length) {
+			const result = await this.scanExtensionsInDir(this.devSystemExtensionsPath, ExtensionType.System);
+			this.logService.trace('Scanned dev system extensions:', result.length);
+			return result.filter(r => devSystemExtensionsList.some(id => areSameExtensions(r.identifier, { id })));
+		} else {
+			return [];
+		}
+	}
+
+	private setMetadata(local: IRelaxedLocalExtension, metadata: IMetadata): void {
+		local.publisherDisplayName = metadata.publisherDisplayName || null;
+		local.publisherId = metadata.publisherId || null;
+		local.identifier.uuid = metadata.id;
+		local.isMachineScoped = !!metadata.isMachineScoped;
+		local.isBuiltin = local.type === ExtensionType.System || !!metadata.isBuiltin;
+	}
+
+	private async removeUninstalledExtensions(): Promise<void> {
+		const uninstalled = await this.getUninstalledExtensions();
+		const extensions = await this.scanAllUserExtensions(); // All user extensions
+		const installed: Set<string> = new Set<string>();
+		for (const e of extensions) {
+			if (!uninstalled[new ExtensionIdentifierWithVersion(e.identifier, e.manifest.version).key()]) {
+				installed.add(e.identifier.id.toLowerCase());
+			}
+		}
+		const byExtension: ILocalExtension[][] = groupByExtension(extensions, e => e.identifier);
+		await Promise.all(byExtension.map(async e => {
+			const latest = e.sort((a, b) => semver.rcompare(a.manifest.version, b.manifest.version))[0];
+			if (!installed.has(latest.identifier.id.toLowerCase())) {
+				await this.beforeRemovingExtension(latest);
+			}
+		}));
+		const toRemove: ILocalExtension[] = extensions.filter(e => uninstalled[new ExtensionIdentifierWithVersion(e.identifier, e.manifest.version).key()]);
+		await Promise.all(toRemove.map(e => this.removeUninstalledExtension(e)));
+	}
+
+	private async removeOutdatedExtensions(): Promise<void> {
+		const extensions = await this.scanAllUserExtensions();
+		const toRemove: ILocalExtension[] = [];
+
+		// Outdated extensions
+		const byExtension: ILocalExtension[][] = groupByExtension(extensions, e => e.identifier);
+		toRemove.push(...flatten(byExtension.map(p => p.sort((a, b) => semver.rcompare(a.manifest.version, b.manifest.version)).slice(1))));
+
+		await Promise.all(toRemove.map(extension => this.removeExtension(extension, 'outdated')));
+	}
+
+	private getDevSystemExtensionsList(): string[] {
+		return (this.productService.builtInExtensions || []).map(e => e.name);
+	}
+
+	private joinErrors(errorOrErrors: (Error | string) | (Array<Error | string>)): Error {
+		const errors = Array.isArray(errorOrErrors) ? errorOrErrors : [errorOrErrors];
+		if (errors.length === 1) {
+			return errors[0] instanceof Error ? <Error>errors[0] : new Error(<string>errors[0]);
+		}
+		return errors.reduce<Error>((previousValue: Error, currentValue: Error | string) => {
+			return new Error(`${previousValue.message}${previousValue.message ? ',' : ''}${currentValue instanceof Error ? currentValue.message : currentValue}`);
+		}, new Error(''));
+	}
+
+	private _devSystemExtensionsPath: string | null = null;
+	private get devSystemExtensionsPath(): string {
+		if (!this._devSystemExtensionsPath) {
+			this._devSystemExtensionsPath = path.normalize(path.join(FileAccess.asFileUri('', require).fsPath, '..', '.build', 'builtInExtensions'));
+		}
+		return this._devSystemExtensionsPath;
+	}
+
+	private async readManifest(extensionPath: string): Promise<{ manifest: IExtensionManifest; metadata: IMetadata | null; }> {
+		const promises = [
+			pfs.readFile(path.join(extensionPath, 'package.json'), 'utf8')
+				.then(raw => this.parseManifest(raw)),
+			pfs.readFile(path.join(extensionPath, 'package.nls.json'), 'utf8')
+				.then(undefined, err => err.code !== 'ENOENT' ? Promise.reject<string>(err) : '{}')
+				.then(raw => JSON.parse(raw))
+		];
+
+		const [{ manifest, metadata }, translations] = await Promise.all(promises);
+		return {
+			manifest: localizeManifest(manifest, translations),
+			metadata
+		};
+	}
+
+	private parseManifest(raw: string): Promise<{ manifest: IExtensionManifest; metadata: IMetadata | null; }> {
+		return new Promise((c, e) => {
+			try {
+				const manifest = JSON.parse(raw);
+				const metadata = manifest.__metadata || null;
+				c({ manifest, metadata });
+			} catch (err) {
+				e(new Error(localize('invalidManifest', "Extension invalid: package.json is not a JSON file.")));
+			}
+		});
+	}
+}

lib/vscode/src/vs/platform/extensionManagement/test/common/configRemotes.test.ts

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { getDomainsOfRemotes, getRemotes } from 'vs/platform/extensionManagement/common/configRemotes';
+
+suite('Config Remotes', () => {
+
+	const allowedDomains = [
+		'github.com',
+		'github2.com',
+		'github3.com',
+		'example.com',
+		'example2.com',
+		'example3.com',
+		'server.org',
+		'server2.org',
+	];
+
+	test('HTTPS remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://github.com/microsoft/vscode.git'), allowedDomains), ['github.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://git.example.com/gitproject.git'), allowedDomains), ['example.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://username@github2.com/username/repository.git'), allowedDomains), ['github2.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://username:password@github3.com/username/repository.git'), allowedDomains), ['github3.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://username:password@example2.com:1234/username/repository.git'), allowedDomains), ['example2.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('https://example3.com:1234/username/repository.git'), allowedDomains), ['example3.com']);
+	});
+
+	test('SSH remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('ssh://user@git.server.org/project.git'), allowedDomains), ['server.org']);
+	});
+
+	test('SCP-like remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('git@github.com:microsoft/vscode.git'), allowedDomains), ['github.com']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('user@git.server.org:project.git'), allowedDomains), ['server.org']);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('git.server2.org:project.git'), allowedDomains), ['server2.org']);
+	});
+
+	test('Local remotes', function () {
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('/opt/git/project.git'), allowedDomains), []);
+		assert.deepStrictEqual(getDomainsOfRemotes(remote('file:///opt/git/project.git'), allowedDomains), []);
+	});
+
+	test('Multiple remotes', function () {
+		const config = ['https://github.com/microsoft/vscode.git', 'https://git.example.com/gitproject.git'].map(remote).join('');
+		assert.deepStrictEqual(getDomainsOfRemotes(config, allowedDomains).sort(), ['example.com', 'github.com']);
+	});
+
+	test('Non allowed domains are anonymized', () => {
+		const config = ['https://github.com/microsoft/vscode.git', 'https://git.foobar.com/gitproject.git'].map(remote).join('');
+		assert.deepStrictEqual(getDomainsOfRemotes(config, allowedDomains).sort(), ['aaaaaa.aaa', 'github.com']);
+	});
+
+	test('HTTPS remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('https://github.com/microsoft/vscode.git')), ['github.com/microsoft/vscode.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://git.example.com/gitproject.git')), ['git.example.com/gitproject.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://username@github2.com/username/repository.git')), ['github2.com/username/repository.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@github3.com/username/repository.git')), ['github3.com/username/repository.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@example2.com:1234/username/repository.git')), ['example2.com/username/repository.git']);
+		assert.deepStrictEqual(getRemotes(remote('https://example3.com:1234/username/repository.git')), ['example3.com/username/repository.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(remote('https://github.com/microsoft/vscode.git'), true), ['github.com/microsoft/vscode']);
+		assert.deepStrictEqual(getRemotes(remote('https://git.example.com/gitproject.git'), true), ['git.example.com/gitproject']);
+		assert.deepStrictEqual(getRemotes(remote('https://username@github2.com/username/repository.git'), true), ['github2.com/username/repository']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@github3.com/username/repository.git'), true), ['github3.com/username/repository']);
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@example2.com:1234/username/repository.git'), true), ['example2.com/username/repository']);
+		assert.deepStrictEqual(getRemotes(remote('https://example3.com:1234/username/repository.git'), true), ['example3.com/username/repository']);
+
+		// Compare Striped .git with no .git
+		assert.deepStrictEqual(getRemotes(remote('https://github.com/microsoft/vscode.git'), true), getRemotes(remote('https://github.com/microsoft/vscode')));
+		assert.deepStrictEqual(getRemotes(remote('https://git.example.com/gitproject.git'), true), getRemotes(remote('https://git.example.com/gitproject')));
+		assert.deepStrictEqual(getRemotes(remote('https://username@github2.com/username/repository.git'), true), getRemotes(remote('https://username@github2.com/username/repository')));
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@github3.com/username/repository.git'), true), getRemotes(remote('https://username:password@github3.com/username/repository')));
+		assert.deepStrictEqual(getRemotes(remote('https://username:password@example2.com:1234/username/repository.git'), true), getRemotes(remote('https://username:password@example2.com:1234/username/repository')));
+		assert.deepStrictEqual(getRemotes(remote('https://example3.com:1234/username/repository.git'), true), getRemotes(remote('https://example3.com:1234/username/repository')));
+	});
+
+	test('SSH remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('ssh://user@git.server.org/project.git')), ['git.server.org/project.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(remote('ssh://user@git.server.org/project.git'), true), ['git.server.org/project']);
+
+		// Compare Striped .git with no .git
+		assert.deepStrictEqual(getRemotes(remote('ssh://user@git.server.org/project.git'), true), getRemotes(remote('ssh://user@git.server.org/project')));
+	});
+
+	test('SCP-like remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('git@github.com:microsoft/vscode.git')), ['github.com/microsoft/vscode.git']);
+		assert.deepStrictEqual(getRemotes(remote('user@git.server.org:project.git')), ['git.server.org/project.git']);
+		assert.deepStrictEqual(getRemotes(remote('git.server2.org:project.git')), ['git.server2.org/project.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(remote('git@github.com:microsoft/vscode.git'), true), ['github.com/microsoft/vscode']);
+		assert.deepStrictEqual(getRemotes(remote('user@git.server.org:project.git'), true), ['git.server.org/project']);
+		assert.deepStrictEqual(getRemotes(remote('git.server2.org:project.git'), true), ['git.server2.org/project']);
+
+		// Compare Striped .git with no .git
+		assert.deepStrictEqual(getRemotes(remote('git@github.com:microsoft/vscode.git'), true), getRemotes(remote('git@github.com:microsoft/vscode')));
+		assert.deepStrictEqual(getRemotes(remote('user@git.server.org:project.git'), true), getRemotes(remote('user@git.server.org:project')));
+		assert.deepStrictEqual(getRemotes(remote('git.server2.org:project.git'), true), getRemotes(remote('git.server2.org:project')));
+	});
+
+	test('Local remotes to be hashed', function () {
+		assert.deepStrictEqual(getRemotes(remote('/opt/git/project.git')), []);
+		assert.deepStrictEqual(getRemotes(remote('file:///opt/git/project.git')), []);
+	});
+
+	test('Multiple remotes to be hashed', function () {
+		const config = ['https://github.com/microsoft/vscode.git', 'https://git.example.com/gitproject.git'].map(remote).join(' ');
+		assert.deepStrictEqual(getRemotes(config), ['github.com/microsoft/vscode.git', 'git.example.com/gitproject.git']);
+
+		// Strip .git
+		assert.deepStrictEqual(getRemotes(config, true), ['github.com/microsoft/vscode', 'git.example.com/gitproject']);
+
+		// Compare Striped .git with no .git
+		const noDotGitConfig = ['https://github.com/microsoft/vscode', 'https://git.example.com/gitproject'].map(remote).join(' ');
+		assert.deepStrictEqual(getRemotes(config, true), getRemotes(noDotGitConfig));
+	});
+
+	function remote(url: string): string {
+		return `[remote "origin"]
+	url = ${url}
+	fetch = +refs/heads/*:refs/remotes/origin/*
+`;
+	}
+});

lib/vscode/src/vs/platform/extensionManagement/test/common/extensionManagement.test.ts

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as assert from 'assert';
+import { EXTENSION_IDENTIFIER_PATTERN } from 'vs/platform/extensionManagement/common/extensionManagement';
+
+suite('Extension Identifier Pattern', () => {
+
+	test('extension identifier pattern', () => {
+		const regEx = new RegExp(EXTENSION_IDENTIFIER_PATTERN);
+		assert.equal(true, regEx.test('publisher.name'));
+		assert.equal(true, regEx.test('publiSher.name'));
+		assert.equal(true, regEx.test('publisher.Name'));
+		assert.equal(true, regEx.test('PUBLISHER.NAME'));
+		assert.equal(true, regEx.test('PUBLISHEr.NAMe'));
+		assert.equal(true, regEx.test('PUBLISHEr.N-AMe'));
+		assert.equal(true, regEx.test('PUB-LISHEr.NAMe'));
+		assert.equal(true, regEx.test('PUB-LISHEr.N-AMe'));
+		assert.equal(true, regEx.test('PUBLISH12Er90.N-A54Me123'));
+		assert.equal(true, regEx.test('111PUBLISH12Er90.N-1111A54Me123'));
+		assert.equal(false, regEx.test('publishername'));
+		assert.equal(false, regEx.test('-publisher.name'));
+		assert.equal(false, regEx.test('publisher.-name'));
+		assert.equal(false, regEx.test('-publisher.-name'));
+		assert.equal(false, regEx.test('publ_isher.name'));
+		assert.equal(false, regEx.test('publisher._name'));
+	});
+});

lib/vscode/src/vs/platform/extensionManagement/test/node/extensionGalleryService.test.ts

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as os from 'os';
+import { NativeEnvironmentService } from 'vs/platform/environment/node/environmentService';
+import { parseArgs, OPTIONS } from 'vs/platform/environment/node/argv';
+import { getRandomTestPath } from 'vs/base/test/node/testUtils';
+import { join } from 'vs/base/common/path';
+import { mkdirp, RimRafMode, rimraf } from 'vs/base/node/pfs';
+import { resolveMarketplaceHeaders } from 'vs/platform/extensionManagement/common/extensionGalleryService';
+import { isUUID } from 'vs/base/common/uuid';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { IFileService } from 'vs/platform/files/common/files';
+import { FileService } from 'vs/platform/files/common/fileService';
+import { NullLogService } from 'vs/platform/log/common/log';
+import { DiskFileSystemProvider } from 'vs/platform/files/node/diskFileSystemProvider';
+import { Schemas } from 'vs/base/common/network';
+import product from 'vs/platform/product/common/product';
+import { TestStorageService } from 'vs/workbench/test/common/workbenchTestServices';
+import { IStorageService } from 'vs/platform/storage/common/storage';
+
+suite('Extension Gallery Service', () => {
+	const parentDir = getRandomTestPath(os.tmpdir(), 'vsctests', 'extensiongalleryservice');
+	const marketplaceHome = join(parentDir, 'Marketplace');
+	let fileService: IFileService;
+	let disposables: DisposableStore;
+
+	setup(done => {
+
+		disposables = new DisposableStore();
+		fileService = new FileService(new NullLogService());
+		disposables.add(fileService);
+
+		const diskFileSystemProvider = new DiskFileSystemProvider(new NullLogService());
+		disposables.add(diskFileSystemProvider);
+		fileService.registerProvider(Schemas.file, diskFileSystemProvider);
+
+		// Delete any existing backups completely and then re-create it.
+		rimraf(marketplaceHome, RimRafMode.MOVE).then(() => {
+			mkdirp(marketplaceHome).then(() => {
+				done();
+			}, error => done(error));
+		}, error => done(error));
+	});
+
+	teardown(done => {
+		disposables.clear();
+		rimraf(marketplaceHome, RimRafMode.MOVE).then(done, done);
+	});
+
+	test('marketplace machine id', () => {
+		const args = ['--user-data-dir', marketplaceHome];
+		const environmentService = new NativeEnvironmentService(parseArgs(args, OPTIONS));
+		const storageService: IStorageService = new TestStorageService();
+
+		return resolveMarketplaceHeaders(product.version, environmentService, fileService, storageService).then(headers => {
+			assert.ok(isUUID(headers['X-Market-User-Id']));
+
+			return resolveMarketplaceHeaders(product.version, environmentService, fileService, storageService).then(headers2 => {
+				assert.equal(headers['X-Market-User-Id'], headers2['X-Market-User-Id']);
+			});
+		});
+	});
+});