SQL Operations Studio Public Preview 1 (0.23) release source code

src/vs/platform/extensionManagement/node/extensionGalleryService.ts

@@ -0,0 +1,642 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { tmpdir } from 'os';
+import * as path from 'path';
+import { TPromise } from 'vs/base/common/winjs.base';
+import * as uuid from 'vs/base/common/uuid';
+import { distinct } from 'vs/base/common/arrays';
+import { getErrorMessage, isPromiseCanceledError } from 'vs/base/common/errors';
+import { StatisticType, IGalleryExtension, IExtensionGalleryService, IGalleryExtensionAsset, IQueryOptions, SortBy, SortOrder, IExtensionManifest } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { getGalleryExtensionId, getGalleryExtensionTelemetryData, adoptToGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { assign, getOrDefault } from 'vs/base/common/objects';
+import { IRequestService } from 'vs/platform/request/node/request';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IPager } from 'vs/base/common/paging';
+import { IRequestOptions, IRequestContext, download, asJson, asText } from 'vs/base/node/request';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import pkg from 'vs/platform/node/package';
+import product from 'vs/platform/node/product';
+import { isVersionValid } from 'vs/platform/extensions/node/extensionValidator';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+
+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[];
+}
+
+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',
+};
+
+const PropertyType = {
+	Dependency: 'Microsoft.VisualStudio.Code.ExtensionDependencies',
+	Engine: 'Microsoft.VisualStudio.Code.Engine'
+};
+
+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(assign({}, this.state, { pageNumber, pageSize }));
+	}
+
+	withFilter(filterType: FilterType, ...values: string[]): Query {
+		const criteria = [
+			...this.state.criteria,
+			...values.map(value => ({ filterType, value }))
+		];
+
+		return new Query(assign({}, this.state, { criteria }));
+	}
+
+	withSortBy(sortBy: SortBy): Query {
+		return new Query(assign({}, this.state, { sortBy }));
+	}
+
+	withSortOrder(sortOrder: SortOrder): Query {
+		return new Query(assign({}, this.state, { sortOrder }));
+	}
+
+	withFlags(...flags: Flags[]): Query {
+		return new Query(assign({}, this.state, { flags: flags.reduce((r, f) => r | f, 0) }));
+	}
+
+	withAssetTypes(...assetTypes: string[]): Query {
+		return new Query(assign({}, 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 : '';
+	}
+}
+
+function getStatistic(statistics: IRawGalleryExtensionStatistics[], name: string): number {
+	const result = (statistics || []).filter(s => s.statisticName === name)[0];
+	return result ? result.value : 0;
+}
+
+function getVersionAsset(version: IRawGalleryExtensionVersion, type: string): IGalleryExtensionAsset {
+	const result = version.files.filter(f => f.assetType === type)[0];
+
+	if (!result) {
+		if (type === AssetType.Icon) {
+			const uri = require.toUrl('./media/defaultIcon.png');
+			return { uri, fallbackUri: uri };
+		}
+
+		return null;
+	}
+
+	if (type === AssetType.VSIX) {
+		return {
+			uri: `${version.fallbackAssetUri}/${type}?redirect=true&install=true`,
+			fallbackUri: `${version.fallbackAssetUri}/${type}?install=true`
+		};
+	}
+
+	return {
+		uri: `${version.assetUri}/${type}`,
+		fallbackUri: `${version.fallbackAssetUri}/${type}`
+	};
+}
+
+function getDependencies(version: IRawGalleryExtensionVersion): string[] {
+	const values = version.properties ? version.properties.filter(p => p.key === PropertyType.Dependency) : [];
+	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 toExtension(galleryExtension: IRawGalleryExtension, extensionsGalleryUrl: string, index: number, query: Query, querySource?: string): IGalleryExtension {
+	const [version] = galleryExtension.versions;
+	const assets = {
+		manifest: getVersionAsset(version, AssetType.Manifest),
+		readme: getVersionAsset(version, AssetType.Details),
+		changelog: getVersionAsset(version, AssetType.Changelog),
+		download: getVersionAsset(version, AssetType.VSIX),
+		icon: getVersionAsset(version, AssetType.Icon),
+		license: getVersionAsset(version, AssetType.License)
+	};
+
+	return {
+		uuid: galleryExtension.extensionId,
+		id: getGalleryExtensionId(galleryExtension.publisher.publisherName, galleryExtension.extensionName),
+		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'),
+		assets,
+		properties: {
+			dependencies: getDependencies(version),
+			engine: getEngine(version)
+		},
+		telemetryData: {
+			index: ((query.pageNumber - 1) * query.pageSize) + index,
+			searchText: query.searchText,
+			querySource
+		}
+	};
+}
+
+export class ExtensionGalleryService implements IExtensionGalleryService {
+
+	_serviceBrand: any;
+
+	private extensionsGalleryUrl: string;
+
+	private readonly commonHTTPHeaders: { [key: string]: string; };
+
+	constructor(
+		@IRequestService private requestService: IRequestService,
+		@IEnvironmentService private environmentService: IEnvironmentService,
+		@ITelemetryService private telemetryService: ITelemetryService,
+		@IConfigurationService private configurationService: IConfigurationService
+	) {
+		const config = product.extensionsGallery;
+		this.extensionsGalleryUrl = config && config.serviceUrl;
+		this.commonHTTPHeaders = {
+			'X-Market-Client-Id': `VSCode ${pkg.version}`,
+			'User-Agent': `VSCode ${pkg.version}`,
+			'X-Market-User-Id': this.environmentService.machineUUID
+		};
+	}
+
+	private api(path = ''): string {
+		return `${this.extensionsGalleryUrl}${path}`;
+	}
+
+	isEnabled(): boolean {
+		return !!this.extensionsGalleryUrl;
+	}
+
+	query(options: IQueryOptions = {}): TPromise<IPager<IGalleryExtension>> {
+		if (!this.isEnabled()) {
+			return TPromise.wrapError<IPager<IGalleryExtension>>(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);
+
+		this.telemetryService.publicLog('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')
+			.withFilter(FilterType.ExcludeWithFlags, flagsToString(Flags.Unpublished))
+			.withAssetTypes(AssetType.Icon, AssetType.License, AssetType.Details, AssetType.Manifest, AssetType.VSIX, AssetType.Changelog);
+
+		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 '';
+			});
+
+			text = text.trim();
+
+			if (text) {
+				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);
+		}
+
+		return this.queryGallery(query).then(({ galleryExtensions, total }) => {
+			const extensions = galleryExtensions.map((e, index) => toExtension(e, this.extensionsGalleryUrl, index, query, options.source));
+			const pageSize = query.pageSize;
+			const getPage = pageIndex => {
+				const nextPageQuery = query.withPage(pageIndex + 1);
+				return this.queryGallery(nextPageQuery)
+					.then(({ galleryExtensions }) => galleryExtensions.map((e, index) => toExtension(e, this.extensionsGalleryUrl, index, nextPageQuery, options.source)));
+			};
+
+			return { firstPage: extensions, total, pageSize, getPage };
+		});
+	}
+
+	private async queryGallery(query: Query): TPromise<{ galleryExtensions: IRawGalleryExtension[], total: number; }> {
+		const commonHeaders = await this.commonHTTPHeaders;
+		const data = JSON.stringify(query.raw);
+		const headers = assign({}, commonHeaders, {
+			'Content-Type': 'application/json',
+			'Accept': 'application/json;api-version=3.0-preview.1',
+			'Accept-Encoding': 'gzip',
+			'Content-Length': data.length
+		});
+
+		const context = await this.requestService.request({
+			type: 'POST',
+			url: this.api('/extensionquery'),
+			data,
+			headers
+		});
+
+		if (context.res.statusCode >= 400 && context.res.statusCode < 500) {
+			return { galleryExtensions: [], total: 0 };
+		}
+
+		const result = await asJson<IRawGalleryQueryResult>(context);
+		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 };
+	}
+
+	async reportStatistic(publisher: string, name: string, version: string, type: StatisticType): TPromise<void> {
+		if (!this.isEnabled()) {
+			return;
+		}
+
+		try {
+			const headers = {
+				...await this.commonHTTPHeaders,
+				Accept: '*/*;api-version=4.0-preview.1'
+			};
+
+			await this.requestService.request({
+				type: 'POST',
+				url: this.api(`/publishers/${publisher}/extensions/${name}/${version}/stats?statType=${type}`),
+				headers
+			});
+		} catch (err) {
+			// noop
+		}
+	}
+
+	download(extension: IGalleryExtension): TPromise<string> {
+		return this.loadCompatibleVersion(extension).then(extension => {
+			const zipPath = path.join(tmpdir(), uuid.generateUuid());
+			const data = getGalleryExtensionTelemetryData(extension);
+			const startTime = new Date().getTime();
+			const log = duration => this.telemetryService.publicLog('galleryService:downloadVSIX', assign(data, { duration }));
+
+			return this.getAsset(extension.assets.download)
+				.then(context => download(zipPath, context))
+				.then(() => log(new Date().getTime() - startTime))
+				.then(() => zipPath);
+		});
+	}
+
+	getReadme(extension: IGalleryExtension): TPromise<string> {
+		return this.getAsset(extension.assets.readme)
+			.then(asText);
+	}
+
+	getManifest(extension: IGalleryExtension): TPromise<IExtensionManifest> {
+		return this.getAsset(extension.assets.manifest)
+			.then(asText)
+			.then(JSON.parse);
+	}
+
+	getChangelog(extension: IGalleryExtension): TPromise<string> {
+		return this.getAsset(extension.assets.changelog)
+			.then(asText);
+	}
+
+	getAllDependencies(extension: IGalleryExtension): TPromise<IGalleryExtension[]> {
+		return this.loadCompatibleVersion(<IGalleryExtension>extension)
+			.then(compatible => this.getDependenciesReccursively(compatible.properties.dependencies, [], extension));
+	}
+
+	loadCompatibleVersion(extension: IGalleryExtension): TPromise<IGalleryExtension> {
+		if (extension.properties.engine && this.isEngineValid(extension.properties.engine)) {
+			return TPromise.wrap(extension);
+		}
+
+		const query = new Query()
+			.withFlags(Flags.IncludeVersions, Flags.IncludeFiles, Flags.IncludeVersionProperties)
+			.withPage(1, 1)
+			.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code')
+			.withFilter(FilterType.ExcludeWithFlags, flagsToString(Flags.Unpublished))
+			.withAssetTypes(AssetType.Manifest, AssetType.VSIX)
+			.withFilter(FilterType.ExtensionId, extension.uuid);
+
+		return this.queryGallery(query).then(({ galleryExtensions }) => {
+			const [rawExtension] = galleryExtensions;
+
+			if (!rawExtension) {
+				return TPromise.wrapError<IGalleryExtension>(new Error(localize('notFound', "Extension not found")));
+			}
+
+			return this.getLastValidExtensionVersion(rawExtension, rawExtension.versions)
+				.then(rawVersion => {
+					extension.properties.dependencies = getDependencies(rawVersion);
+					extension.properties.engine = getEngine(rawVersion);
+					extension.assets.download = getVersionAsset(rawVersion, AssetType.VSIX);
+					extension.version = rawVersion.version;
+					return extension;
+				});
+		});
+	}
+
+	private loadDependencies(extensionNames: string[]): TPromise<IGalleryExtension[]> {
+		if (!extensionNames || extensionNames.length === 0) {
+			return TPromise.as([]);
+		}
+
+		let query = new Query()
+			.withFlags(Flags.IncludeLatestVersionOnly, Flags.IncludeAssetUri, Flags.IncludeStatistics, Flags.IncludeFiles, Flags.IncludeVersionProperties)
+			.withPage(1, extensionNames.length)
+			.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code')
+			.withFilter(FilterType.ExcludeWithFlags, flagsToString(Flags.Unpublished))
+			.withAssetTypes(AssetType.Icon, AssetType.License, AssetType.Details, AssetType.Manifest, AssetType.VSIX)
+			.withFilter(FilterType.ExtensionName, ...extensionNames);
+
+		return this.queryGallery(query).then(result => {
+			const dependencies = [];
+			const ids = [];
+
+			for (let index = 0; index < result.galleryExtensions.length; index++) {
+				const rawExtension = result.galleryExtensions[index];
+				if (ids.indexOf(rawExtension.extensionId) === -1) {
+					dependencies.push(toExtension(rawExtension, this.extensionsGalleryUrl, index, query));
+					ids.push(rawExtension.extensionId);
+				}
+			}
+			return dependencies;
+		});
+	}
+
+	private getDependenciesReccursively(toGet: string[], result: IGalleryExtension[], root: IGalleryExtension): TPromise<IGalleryExtension[]> {
+		if (!toGet || !toGet.length) {
+			return TPromise.wrap(result);
+		}
+		if (toGet.indexOf(`${root.publisher}.${root.name}`) !== -1 && result.indexOf(root) === -1) {
+			result.push(root);
+		}
+		toGet = result.length ? toGet.filter(e => !ExtensionGalleryService.hasExtensionByName(result, e)) : toGet;
+		if (!toGet.length) {
+			return TPromise.wrap(result);
+		}
+
+		return this.loadDependencies(toGet)
+			.then(loadedDependencies => {
+				const dependenciesSet = new Set<string>();
+				for (const dep of loadedDependencies) {
+					if (dep.properties.dependencies) {
+						dep.properties.dependencies.forEach(d => dependenciesSet.add(d));
+					}
+				}
+				result = distinct(result.concat(loadedDependencies), d => d.uuid);
+				const dependencies: string[] = [];
+				dependenciesSet.forEach(d => !ExtensionGalleryService.hasExtensionByName(result, d) && dependencies.push(d));
+				return this.getDependenciesReccursively(dependencies, result, root);
+			});
+	}
+
+	private getAsset(asset: IGalleryExtensionAsset, options: IRequestOptions = {}): TPromise<IRequestContext> {
+		const baseOptions = { type: 'GET' };
+		const headers = assign({}, this.commonHTTPHeaders, options.headers || {});
+		options = assign({}, options, baseOptions, { headers });
+
+		const url = asset.uri;
+		const fallbackUrl = asset.fallbackUri;
+		const firstOptions = assign({}, options, { url });
+
+		return this.requestService.request(firstOptions)
+			.then(context => {
+				if (context.res.statusCode === 200) {
+					return TPromise.as(context);
+				}
+
+				return asText(context)
+					.then(message => TPromise.wrapError<IRequestContext>(new Error(`Expected 200, got back ${context.res.statusCode} instead.\n\n${message}`)));
+			})
+			.then(null, err => {
+				if (isPromiseCanceledError(err)) {
+					return TPromise.wrapError<IRequestContext>(err);
+				}
+
+				const message = getErrorMessage(err);
+				this.telemetryService.publicLog('galleryService:requestError', { url, cdn: true, message });
+				this.telemetryService.publicLog('galleryService:cdnFallback', { url, message });
+
+				const fallbackOptions = assign({}, options, { url: fallbackUrl });
+				return this.requestService.request(fallbackOptions).then(null, err => {
+					if (isPromiseCanceledError(err)) {
+						return TPromise.wrapError<IRequestContext>(err);
+					}
+
+					const message = getErrorMessage(err);
+					this.telemetryService.publicLog('galleryService:requestError', { url: fallbackUrl, cdn: false, message });
+					return TPromise.wrapError<IRequestContext>(err);
+				});
+			});
+	}
+
+	private getLastValidExtensionVersion(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): TPromise<IRawGalleryExtensionVersion> {
+		const version = this.getLastValidExtensionVersionFromProperties(extension, versions);
+		if (version) {
+			return version;
+		}
+		return this.getLastValidExtensionVersionReccursively(extension, versions);
+	}
+
+	private getLastValidExtensionVersionFromProperties(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): TPromise<IRawGalleryExtensionVersion> {
+		for (const version of versions) {
+			const engine = getEngine(version);
+			if (!engine) {
+				return null;
+			}
+			if (this.isEngineValid(engine)) {
+				return TPromise.wrap(version);
+			}
+		}
+		return null;
+	}
+
+	private getLastValidExtensionVersionReccursively(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): TPromise<IRawGalleryExtensionVersion> {
+		if (!versions.length) {
+			return TPromise.wrapError<IRawGalleryExtensionVersion>(new Error(localize('noCompatible', "Couldn't find a compatible version of {0} with this version of Code.", extension.displayName || extension.extensionName)));
+		}
+
+		const version = versions[0];
+		const asset = getVersionAsset(version, AssetType.Manifest);
+		const headers = { 'Accept-Encoding': 'gzip' };
+
+		return this.getAsset(asset, { headers })
+			.then(context => asJson<IExtensionManifest>(context))
+			.then(manifest => {
+				const engine = manifest.engines.vscode;
+
+				if (!this.isEngineValid(engine)) {
+					return this.getLastValidExtensionVersionReccursively(extension, versions.slice(1));
+				}
+
+				version.properties = version.properties || [];
+				version.properties.push({ key: PropertyType.Engine, value: manifest.engines.vscode });
+				return version;
+			});
+	}
+
+	private isEngineValid(engine: string): boolean {
+		// TODO@joao: discuss with alex '*' doesn't seem to be a valid engine version
+		return engine === '*' || isVersionValid(pkg.version, engine);
+	}
+
+	private static hasExtensionByName(extensions: IGalleryExtension[], name: string): boolean {
+		for (const extension of extensions) {
+			if (`${extension.publisher}.${extension.name}` === name) {
+				return true;
+			}
+		}
+		return false;
+	}
+}

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

@@ -0,0 +1,601 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import nls = require('vs/nls');
+import * as path from 'path';
+import * as pfs from 'vs/base/node/pfs';
+import * as errors from 'vs/base/common/errors';
+import { assign } from 'vs/base/common/objects';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { flatten, distinct } from 'vs/base/common/arrays';
+import { extract, buffer } from 'vs/base/node/zip';
+import { TPromise } from 'vs/base/common/winjs.base';
+import {
+	IExtensionManagementService, IExtensionGalleryService, ILocalExtension,
+	IGalleryExtension, IExtensionManifest, IGalleryMetadata,
+	InstallExtensionEvent, DidInstallExtensionEvent, DidUninstallExtensionEvent, LocalExtensionType,
+	StatisticType
+} from 'vs/platform/extensionManagement/common/extensionManagement';
+import { getLocalExtensionIdFromGallery, getLocalExtensionIdFromManifest, getGalleryExtensionIdFromLocal, getIdAndVersionFromLocalExtensionId, adoptToGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { localizeManifest } from '../common/extensionNls';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { Limiter } from 'vs/base/common/async';
+import Event, { Emitter } from 'vs/base/common/event';
+import * as semver from 'semver';
+import { groupBy, values } from 'vs/base/common/collections';
+import URI from 'vs/base/common/uri';
+import { IChoiceService, Severity } from 'vs/platform/message/common/message';
+
+const SystemExtensionsRoot = path.normalize(path.join(URI.parse(require.toUrl('')).fsPath, '..', 'extensions'));
+
+function parseManifest(raw: string): TPromise<{ manifest: IExtensionManifest; metadata: IGalleryMetadata; }> {
+	return new TPromise((c, e) => {
+		try {
+			const manifest = JSON.parse(raw);
+			const metadata = manifest.__metadata || null;
+			delete manifest.__metadata;
+			c({ manifest, metadata });
+		} catch (err) {
+			e(new Error(nls.localize('invalidManifest', "Extension invalid: package.json is not a JSON file.")));
+		}
+	});
+}
+
+function validate(zipPath: string): TPromise<IExtensionManifest> {
+	return buffer(zipPath, 'extension/package.json')
+		.then(buffer => parseManifest(buffer.toString('utf8')))
+		.then(({ manifest }) => TPromise.as(manifest));
+}
+
+function readManifest(extensionPath: string): TPromise<{ manifest: IExtensionManifest; metadata: IGalleryMetadata; }> {
+	const promises = [
+		pfs.readFile(path.join(extensionPath, 'package.json'), 'utf8')
+			.then(raw => parseManifest(raw)),
+		pfs.readFile(path.join(extensionPath, 'package.nls.json'), 'utf8')
+			.then(null, err => err.code !== 'ENOENT' ? TPromise.wrapError<string>(err) : '{}')
+			.then(raw => JSON.parse(raw))
+	];
+
+	return TPromise.join<any>(promises).then(([{ manifest, metadata }, translations]) => {
+		return {
+			manifest: localizeManifest(manifest, translations),
+			metadata
+		};
+	});
+}
+
+export class ExtensionManagementService implements IExtensionManagementService {
+
+	_serviceBrand: any;
+
+	private extensionsPath: string;
+	private obsoletePath: string;
+	private obsoleteFileLimiter: Limiter<void>;
+	private disposables: IDisposable[] = [];
+
+	private _onInstallExtension = new Emitter<InstallExtensionEvent>();
+	onInstallExtension: Event<InstallExtensionEvent> = this._onInstallExtension.event;
+
+	private _onDidInstallExtension = new Emitter<DidInstallExtensionEvent>();
+	onDidInstallExtension: Event<DidInstallExtensionEvent> = this._onDidInstallExtension.event;
+
+	private _onUninstallExtension = new Emitter<string>();
+	onUninstallExtension: Event<string> = this._onUninstallExtension.event;
+
+	private _onDidUninstallExtension = new Emitter<DidUninstallExtensionEvent>();
+	onDidUninstallExtension: Event<DidUninstallExtensionEvent> = this._onDidUninstallExtension.event;
+
+	constructor(
+		@IEnvironmentService private environmentService: IEnvironmentService,
+		@IChoiceService private choiceService: IChoiceService,
+		@IExtensionGalleryService private galleryService: IExtensionGalleryService
+	) {
+		this.extensionsPath = environmentService.extensionsPath;
+		this.obsoletePath = path.join(this.extensionsPath, '.obsolete');
+		this.obsoleteFileLimiter = new Limiter(1);
+	}
+
+	install(zipPath: string): TPromise<void> {
+		zipPath = path.resolve(zipPath);
+
+		return validate(zipPath).then<void>(manifest => {
+			const id = getLocalExtensionIdFromManifest(manifest);
+
+			return this.isObsolete(id).then(isObsolete => {
+				if (isObsolete) {
+					return TPromise.wrapError(new Error(nls.localize('restartCode', "Please restart Code before reinstalling {0}.", manifest.displayName || manifest.name)));
+				}
+
+				this._onInstallExtension.fire({ id, zipPath });
+
+				return this.installExtension(zipPath, id)
+					.then(
+					local => this._onDidInstallExtension.fire({ id, zipPath, local }),
+					error => { this._onDidInstallExtension.fire({ id, zipPath, error }); return TPromise.wrapError(error); }
+					);
+			});
+		});
+	}
+
+	installFromGallery(extension: IGalleryExtension, promptToInstallDependencies: boolean = true): TPromise<void> {
+		const id = getLocalExtensionIdFromGallery(extension, extension.version);
+
+		return this.isObsolete(id).then(isObsolete => {
+			if (isObsolete) {
+				return TPromise.wrapError<void>(new Error(nls.localize('restartCode', "Please restart Code before reinstalling {0}.", extension.displayName || extension.name)));
+			}
+			this._onInstallExtension.fire({ id, gallery: extension });
+			return this.installCompatibleVersion(extension, true, promptToInstallDependencies)
+				.then(
+				local => this._onDidInstallExtension.fire({ id, local, gallery: extension }),
+				error => {
+					this._onDidInstallExtension.fire({ id, gallery: extension, error });
+					return TPromise.wrapError(error);
+				}
+				);
+		});
+	}
+
+	private installCompatibleVersion(extension: IGalleryExtension, installDependencies: boolean, promptToInstallDependencies: boolean): TPromise<ILocalExtension> {
+		return this.galleryService.loadCompatibleVersion(extension)
+			.then(compatibleVersion => this.getDependenciesToInstall(extension, installDependencies)
+				.then(dependencies => {
+					if (!dependencies.length) {
+						return this.downloadAndInstall(compatibleVersion);
+					}
+					if (promptToInstallDependencies) {
+						const message = nls.localize('installDependeciesConfirmation', "Installing '{0}' also installs its dependencies. Would you like to continue?", extension.displayName);
+						const options = [
+							nls.localize('install', "Yes"),
+							nls.localize('doNotInstall', "No")
+						];
+						return this.choiceService.choose(Severity.Info, message, options, 1, true)
+							.then(value => {
+								if (value === 0) {
+									return this.installWithDependencies(compatibleVersion);
+								}
+								return TPromise.wrapError<ILocalExtension>(errors.canceled());
+							}, error => TPromise.wrapError<ILocalExtension>(errors.canceled()));
+					} else {
+						return this.installWithDependencies(compatibleVersion);
+					}
+				})
+			);
+	}
+
+	private getDependenciesToInstall(extension: IGalleryExtension, checkDependecies: boolean): TPromise<string[]> {
+		if (!checkDependecies) {
+			return TPromise.wrap([]);
+		}
+		// Filter out self
+		const dependencies = extension.properties.dependencies ? extension.properties.dependencies.filter(id => id !== extension.id) : [];
+		if (!dependencies.length) {
+			return TPromise.wrap([]);
+		}
+		// Filter out installed dependencies
+		return this.getInstalled().then(installed => {
+			return dependencies.filter(dep => installed.every(i => `${i.manifest.publisher}.${i.manifest.name}` !== dep));
+		});
+	}
+
+	private installWithDependencies(extension: IGalleryExtension): TPromise<ILocalExtension> {
+		return this.galleryService.getAllDependencies(extension)
+			.then(allDependencies => this.filterDependenciesToInstall(extension, allDependencies))
+			.then(toInstall => this.filterObsolete(...toInstall.map(i => getLocalExtensionIdFromGallery(i, i.version)))
+				.then((obsolete) => {
+					if (obsolete.length) {
+						return TPromise.wrapError<ILocalExtension>(new Error(nls.localize('restartCode', "Please restart Code before reinstalling {0}.", extension.displayName || extension.name)));
+					}
+					return this.bulkInstallWithDependencies(extension, toInstall);
+				})
+			);
+	}
+
+	private bulkInstallWithDependencies(extension: IGalleryExtension, dependecies: IGalleryExtension[]): TPromise<ILocalExtension> {
+		for (const dependency of dependecies) {
+			const id = getLocalExtensionIdFromGallery(dependency, dependency.version);
+			this._onInstallExtension.fire({ id, gallery: dependency });
+		}
+		return this.downloadAndInstall(extension)
+			.then(localExtension => {
+				return TPromise.join(dependecies.map((dep) => this.installCompatibleVersion(dep, false, false)))
+					.then(installedLocalExtensions => {
+						for (const installedLocalExtension of installedLocalExtensions) {
+							const gallery = this.getGalleryExtensionForLocalExtension(dependecies, installedLocalExtension);
+							this._onDidInstallExtension.fire({ id: installedLocalExtension.id, local: installedLocalExtension, gallery });
+						}
+						return localExtension;
+					}, error => {
+						return this.rollback(localExtension, dependecies).then(() => {
+							return TPromise.wrapError<ILocalExtension>(Array.isArray(error) ? error[error.length - 1] : error);
+						});
+					});
+			})
+			.then(localExtension => localExtension, error => {
+				for (const dependency of dependecies) {
+					this._onDidInstallExtension.fire({ id: getLocalExtensionIdFromGallery(dependency, dependency.version), gallery: dependency, error });
+				}
+				return TPromise.wrapError<ILocalExtension>(error);
+			});
+	}
+
+	private rollback(localExtension: ILocalExtension, dependecies: IGalleryExtension[]): TPromise<void> {
+		return this.doUninstall(localExtension)
+			.then(() => this.filterOutUninstalled(dependecies))
+			.then(installed => TPromise.join(installed.map((i) => this.doUninstall(i))))
+			.then(() => null);
+	}
+
+	private filterDependenciesToInstall(extension: IGalleryExtension, dependencies: IGalleryExtension[]): TPromise<IGalleryExtension[]> {
+		return this.getInstalled()
+			.then(local => {
+				return dependencies.filter(d => {
+					if (extension.uuid === d.uuid) {
+						return false;
+					}
+					const extensionId = getLocalExtensionIdFromGallery(d, d.version);
+					return local.every(local => local.id !== extensionId);
+				});
+			});
+	}
+
+	private filterOutUninstalled(extensions: IGalleryExtension[]): TPromise<ILocalExtension[]> {
+		return this.getInstalled()
+			.then(installed => installed.filter(local => !!this.getGalleryExtensionForLocalExtension(extensions, local)));
+	}
+
+	private getGalleryExtensionForLocalExtension(galleryExtensions: IGalleryExtension[], localExtension: ILocalExtension): IGalleryExtension {
+		const filtered = galleryExtensions.filter(galleryExtension => getLocalExtensionIdFromGallery(galleryExtension, galleryExtension.version) === localExtension.id);
+		return filtered.length ? filtered[0] : null;
+	}
+
+	private downloadAndInstall(extension: IGalleryExtension): TPromise<ILocalExtension> {
+		const id = getLocalExtensionIdFromGallery(extension, extension.version);
+		const metadata = {
+			id: extension.uuid,
+			publisherId: extension.publisherId,
+			publisherDisplayName: extension.publisherDisplayName,
+		};
+
+		return this.galleryService.download(extension)
+			.then(zipPath => validate(zipPath).then(() => zipPath))
+			.then(zipPath => this.installExtension(zipPath, id, metadata));
+	}
+
+	private installExtension(zipPath: string, id: string, metadata: IGalleryMetadata = null): TPromise<ILocalExtension> {
+		const extensionPath = path.join(this.extensionsPath, id);
+
+		return pfs.rimraf(extensionPath).then(() => {
+			return extract(zipPath, extensionPath, { sourcePath: 'extension', overwrite: true })
+				.then(() => readManifest(extensionPath))
+				.then(({ manifest }) => {
+					return pfs.readdir(extensionPath).then(children => {
+						const readme = children.filter(child => /^readme(\.txt|\.md|)$/i.test(child))[0];
+						const readmeUrl = readme ? URI.file(path.join(extensionPath, readme)).toString() : null;
+						const changelog = children.filter(child => /^changelog(\.txt|\.md|)$/i.test(child))[0];
+						const changelogUrl = changelog ? URI.file(path.join(extensionPath, changelog)).toString() : null;
+						const type = LocalExtensionType.User;
+
+						const local: ILocalExtension = { type, id, manifest, metadata, path: extensionPath, readmeUrl, changelogUrl };
+						const manifestPath = path.join(extensionPath, 'package.json');
+
+						return pfs.readFile(manifestPath, 'utf8')
+							.then(raw => parseManifest(raw))
+							.then(({ manifest }) => assign(manifest, { __metadata: metadata }))
+							.then(manifest => pfs.writeFile(manifestPath, JSON.stringify(manifest, null, '\t')))
+							.then(() => local);
+					});
+				});
+		});
+	}
+
+	uninstall(extension: ILocalExtension, force = false): TPromise<void> {
+		return this.removeOutdatedExtensions().then(() => {
+			return this.scanUserExtensions().then(installed => {
+				const promises = installed
+					.filter(e => e.manifest.publisher === extension.manifest.publisher && e.manifest.name === extension.manifest.name)
+					.map(e => this.checkForDependenciesAndUninstall(e, installed, force));
+				return TPromise.join(promises);
+			});
+		}).then(() => { /* drop resolved value */ });
+	}
+
+	private checkForDependenciesAndUninstall(extension: ILocalExtension, installed: ILocalExtension[], force: boolean): TPromise<void> {
+		return this.preUninstallExtension(extension)
+			.then(() => this.hasDependencies(extension, installed) ? this.promptForDependenciesAndUninstall(extension, installed, force) : this.promptAndUninstall(extension, installed, force))
+			.then(() => this.postUninstallExtension(extension),
+			error => {
+				this.postUninstallExtension(extension, error);
+				return TPromise.wrapError(error);
+			});
+	}
+
+	private hasDependencies(extension: ILocalExtension, installed: ILocalExtension[]): boolean {
+		if (extension.manifest.extensionDependencies && extension.manifest.extensionDependencies.length) {
+			return installed.some(i => extension.manifest.extensionDependencies.indexOf(getGalleryExtensionIdFromLocal(i)) !== -1);
+		}
+		return false;
+	}
+
+	private promptForDependenciesAndUninstall(extension: ILocalExtension, installed: ILocalExtension[], force: boolean): TPromise<void> {
+		if (force) {
+			const dependencies = distinct(this.getDependenciesToUninstallRecursively(extension, installed, [])).filter(e => e !== extension);
+			return this.uninstallWithDependencies(extension, dependencies, installed);
+		}
+
+		const message = nls.localize('uninstallDependeciesConfirmation', "Would you like to uninstall '{0}' only or its dependencies also?", extension.manifest.displayName || extension.manifest.name);
+		const options = [
+			nls.localize('uninstallOnly', "Only"),
+			nls.localize('uninstallAll', "All"),
+			nls.localize('cancel', "Cancel")
+		];
+		return this.choiceService.choose(Severity.Info, message, options, 2, true)
+			.then<void>(value => {
+				if (value === 0) {
+					return this.uninstallWithDependencies(extension, [], installed);
+				}
+				if (value === 1) {
+					const dependencies = distinct(this.getDependenciesToUninstallRecursively(extension, installed, [])).filter(e => e !== extension);
+					return this.uninstallWithDependencies(extension, dependencies, installed);
+				}
+				return TPromise.wrapError(errors.canceled());
+			}, error => TPromise.wrapError(errors.canceled()));
+	}
+
+	private promptAndUninstall(extension: ILocalExtension, installed: ILocalExtension[], force: boolean): TPromise<void> {
+		if (force) {
+			return this.uninstallWithDependencies(extension, [], installed);
+		}
+
+		const message = nls.localize('uninstallConfirmation', "Are you sure you want to uninstall '{0}'?", extension.manifest.displayName || extension.manifest.name);
+		const options = [
+			nls.localize('ok', "OK"),
+			nls.localize('cancel', "Cancel")
+		];
+		return this.choiceService.choose(Severity.Info, message, options, 1, true)
+			.then<void>(value => {
+				if (value === 0) {
+					return this.uninstallWithDependencies(extension, [], installed);
+				}
+				return TPromise.wrapError(errors.canceled());
+			}, error => TPromise.wrapError(errors.canceled()));
+	}
+
+	private uninstallWithDependencies(extension: ILocalExtension, dependencies: ILocalExtension[], installed: ILocalExtension[]): TPromise<void> {
+		const dependenciesToUninstall = this.filterDependents(extension, dependencies, installed);
+		let dependents = this.getDependents(extension, installed).filter(dependent => extension !== dependent && dependenciesToUninstall.indexOf(dependent) === -1);
+		if (dependents.length) {
+			return TPromise.wrapError<void>(new Error(this.getDependentsErrorMessage(extension, dependents)));
+		}
+		return TPromise.join([this.uninstallExtension(extension.id), ...dependenciesToUninstall.map(d => this.doUninstall(d))]).then(() => null);
+	}
+
+	private getDependentsErrorMessage(extension: ILocalExtension, dependents: ILocalExtension[]): string {
+		if (dependents.length === 1) {
+			return nls.localize('singleDependentError', "Cannot uninstall extension '{0}'. Extension '{1}' depends on this.",
+				extension.manifest.displayName || extension.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name);
+		}
+		if (dependents.length === 2) {
+			return nls.localize('twoDependentsError', "Cannot uninstall extension '{0}'. Extensions '{1}' and '{2}' depend on this.",
+				extension.manifest.displayName || extension.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name, dependents[1].manifest.displayName || dependents[1].manifest.name);
+		}
+		return nls.localize('multipleDependentsError', "Cannot uninstall extension '{0}'. Extensions '{1}', '{2}' and others depend on this.",
+			extension.manifest.displayName || extension.manifest.name, dependents[0].manifest.displayName || dependents[0].manifest.name, dependents[1].manifest.displayName || dependents[1].manifest.name);
+	}
+
+	private getDependenciesToUninstallRecursively(extension: ILocalExtension, installed: ILocalExtension[], checked: ILocalExtension[]): ILocalExtension[] {
+		if (checked.indexOf(extension) !== -1) {
+			return [];
+		}
+		checked.push(extension);
+		if (!extension.manifest.extensionDependencies || extension.manifest.extensionDependencies.length === 0) {
+			return [];
+		}
+		const dependenciesToUninstall = installed.filter(i => extension.manifest.extensionDependencies.indexOf(getGalleryExtensionIdFromLocal(i)) !== -1);
+		const depsOfDeps = [];
+		for (const dep of dependenciesToUninstall) {
+			depsOfDeps.push(...this.getDependenciesToUninstallRecursively(dep, installed, checked));
+		}
+		return [...dependenciesToUninstall, ...depsOfDeps];
+	}
+
+	private filterDependents(extension: ILocalExtension, dependencies: ILocalExtension[], installed: ILocalExtension[]): ILocalExtension[] {
+		installed = installed.filter(i => i !== extension && i.manifest.extensionDependencies && i.manifest.extensionDependencies.length > 0);
+		let result = dependencies.slice(0);
+		for (let i = 0; i < dependencies.length; i++) {
+			const dep = dependencies[i];
+			const dependents = this.getDependents(dep, installed).filter(e => dependencies.indexOf(e) === -1);
+			if (dependents.length) {
+				result.splice(i - (dependencies.length - result.length), 1);
+			}
+		}
+		return result;
+	}
+
+	private getDependents(extension: ILocalExtension, installed: ILocalExtension[]): ILocalExtension[] {
+		return installed.filter(e => e.manifest.extensionDependencies && e.manifest.extensionDependencies.indexOf(getGalleryExtensionIdFromLocal(extension)) !== -1);
+	}
+
+	private doUninstall(extension: ILocalExtension): TPromise<void> {
+		return this.preUninstallExtension(extension)
+			.then(() => this.uninstallExtension(extension.id))
+			.then(() => this.postUninstallExtension(extension),
+			error => {
+				this.postUninstallExtension(extension, error);
+				return TPromise.wrapError(error);
+			});
+	}
+
+	private preUninstallExtension(extension: ILocalExtension): TPromise<void> {
+		const extensionPath = path.join(this.extensionsPath, extension.id);
+		return pfs.exists(extensionPath)
+			.then(exists => exists ? null : TPromise.wrapError(new Error(nls.localize('notExists', "Could not find extension"))))
+			.then(() => this._onUninstallExtension.fire(extension.id));
+	}
+
+	private uninstallExtension(id: string): TPromise<void> {
+		const extensionPath = path.join(this.extensionsPath, id);
+		return this.setObsolete(id)
+			.then(() => pfs.rimraf(extensionPath))
+			.then(() => this.unsetObsolete(id));
+	}
+
+	private async postUninstallExtension(extension: ILocalExtension, error?: any): TPromise<void> {
+		if (!error) {
+			await this.galleryService.reportStatistic(extension.manifest.publisher, extension.manifest.name, extension.manifest.version, StatisticType.Uninstall);
+		}
+
+		this._onDidUninstallExtension.fire({ id: extension.id, error });
+	}
+
+	getInstalled(type: LocalExtensionType = null): TPromise<ILocalExtension[]> {
+		const promises = [];
+
+		if (type === null || type === LocalExtensionType.System) {
+			promises.push(this.scanSystemExtensions());
+		}
+
+		if (type === null || type === LocalExtensionType.User) {
+			promises.push(this.scanUserExtensions());
+		}
+
+		return TPromise.join<ILocalExtension[]>(promises).then(flatten);
+	}
+
+	private scanSystemExtensions(): TPromise<ILocalExtension[]> {
+		return this.scanExtensions(SystemExtensionsRoot, LocalExtensionType.System);
+	}
+
+	private scanUserExtensions(): TPromise<ILocalExtension[]> {
+		return this.scanExtensions(this.extensionsPath, LocalExtensionType.User).then(extensions => {
+			const byId = values(groupBy(extensions, p => getGalleryExtensionIdFromLocal(p)));
+			return byId.map(p => p.sort((a, b) => semver.rcompare(a.manifest.version, b.manifest.version))[0]);
+		});
+	}
+
+	private scanExtensions(root: string, type: LocalExtensionType): TPromise<ILocalExtension[]> {
+		const limiter = new Limiter(10);
+
+		return this.scanExtensionFolders(root)
+			.then(extensionIds => TPromise.join(extensionIds.map(id => {
+				const extensionPath = path.join(root, id);
+
+				const each = () => pfs.readdir(extensionPath).then(children => {
+					const readme = children.filter(child => /^readme(\.txt|\.md|)$/i.test(child))[0];
+					const readmeUrl = readme ? URI.file(path.join(extensionPath, readme)).toString() : null;
+					const changelog = children.filter(child => /^changelog(\.txt|\.md|)$/i.test(child))[0];
+					const changelogUrl = changelog ? URI.file(path.join(extensionPath, changelog)).toString() : null;
+
+					return readManifest(extensionPath)
+						.then<ILocalExtension>(({ manifest, metadata }) => {
+							if (manifest.extensionDependencies) {
+								manifest.extensionDependencies = manifest.extensionDependencies.map(id => adoptToGalleryExtensionId(id));
+							}
+							return { type, id, manifest, metadata, path: extensionPath, readmeUrl, changelogUrl };
+						});
+				}).then(null, () => null);
+
+				return limiter.queue(each);
+			})))
+			.then(result => result.filter(a => !!a));
+	}
+
+	private scanExtensionFolders(root: string): TPromise<string[]> {
+		return this.getObsoleteExtensions()
+			.then(obsolete => pfs.readdir(root).then(extensions => extensions.filter(id => !obsolete[id])));
+	}
+
+	removeDeprecatedExtensions(): TPromise<any> {
+		return TPromise.join([
+			this.removeOutdatedExtensions(),
+			this.removeObsoleteExtensions()
+		]);
+	}
+
+	private removeOutdatedExtensions(): TPromise<any> {
+		return this.getOutdatedExtensionIds()
+			.then(extensionIds => this.removeExtensions(extensionIds));
+	}
+
+	private removeObsoleteExtensions(): TPromise<any> {
+		return this.getObsoleteExtensions()
+			.then(obsolete => Object.keys(obsolete))
+			.then(extensionIds => this.removeExtensions(extensionIds));
+	}
+
+	private removeExtensions(extensionsIds: string[]): TPromise<any> {
+		return TPromise.join(extensionsIds.map(id => {
+			return pfs.rimraf(path.join(this.extensionsPath, id))
+				.then(() => this.withObsoleteExtensions(obsolete => delete obsolete[id]));
+		}));
+	}
+
+	private getOutdatedExtensionIds(): TPromise<string[]> {
+		return this.scanExtensionFolders(this.extensionsPath)
+			.then(folders => {
+				const galleryFolders = folders
+					.map(folder => (assign({ folder }, getIdAndVersionFromLocalExtensionId(folder))))
+					.filter(({ id, version }) => !!id && !!version);
+
+				const byId = values(groupBy(galleryFolders, p => p.id));
+
+				return flatten(byId.map(p => p.sort((a, b) => semver.rcompare(a.version, b.version)).slice(1)))
+					.map(a => a.folder);
+			});
+	}
+
+	private isObsolete(id: string): TPromise<boolean> {
+		return this.filterObsolete(id).then(obsolete => obsolete.length === 1);
+	}
+
+	private filterObsolete(...ids: string[]): TPromise<string[]> {
+		return this.withObsoleteExtensions(allObsolete => {
+			const obsolete = [];
+			for (const id of ids) {
+				if (!!allObsolete[id]) {
+					obsolete.push(id);
+				}
+			}
+			return obsolete;
+		});
+	}
+
+	private setObsolete(id: string): TPromise<void> {
+		return this.withObsoleteExtensions(obsolete => assign(obsolete, { [id]: true }));
+	}
+
+	private unsetObsolete(id: string): TPromise<void> {
+		return this.withObsoleteExtensions<void>(obsolete => delete obsolete[id]);
+	}
+
+	private getObsoleteExtensions(): TPromise<{ [id: string]: boolean; }> {
+		return this.withObsoleteExtensions(obsolete => obsolete);
+	}
+
+	private withObsoleteExtensions<T>(fn: (obsolete: { [id: string]: boolean; }) => T): TPromise<T> {
+		return this.obsoleteFileLimiter.queue(() => {
+			let result: T = null;
+			return pfs.readFile(this.obsoletePath, 'utf8')
+				.then(null, err => err.code === 'ENOENT' ? TPromise.as('{}') : TPromise.wrapError(err))
+				.then<{ [id: string]: boolean }>(raw => { try { return JSON.parse(raw); } catch (e) { return {}; } })
+				.then(obsolete => { result = fn(obsolete); return obsolete; })
+				.then(obsolete => {
+					if (Object.keys(obsolete).length === 0) {
+						return pfs.rimraf(this.obsoletePath);
+					} else {
+						const raw = JSON.stringify(obsolete);
+						return pfs.writeFile(this.obsoletePath, raw);
+					}
+				})
+				.then(() => result);
+		});
+	}
+
+	dispose() {
+		this.disposables = dispose(this.disposables);
+	}
+}