@codingame/monaco-vscode-extension-gallery-service-override 3.2.3 → 4.0.0

package/extensionGallery.js

@@ -24,6 +24,10 @@ import { ExtensionEnablementService } from './vscode/src/vs/workbench/services/e
 import { IExtensionUrlHandler, ExtensionUrlHandler } from 'vscode/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
 import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IExtensionsScannerService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionsScannerService';
+import { ExtensionsScannerService } from './vscode/src/vs/workbench/services/extensions/browser/extensionsScannerService.js';
+import { ExtensionsProfileScannerService } from './vscode/src/vs/workbench/services/extensionManagement/browser/extensionsProfileScannerService.js';
+import { IExtensionsProfileScannerService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionsProfileScannerService';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
 import { IExtensionFeaturesManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
 import { ExtensionFeaturesManagementService } from './vscode/src/vs/workbench/services/extensionManagement/common/extensionFeaturesManagemetService.js';
@@ -90,7 +94,9 @@ function getServiceOverride(options = { webOnly: false }) {
         [( IRemoteUserDataProfilesService.toString())]: new SyncDescriptor(RemoteUserDataProfilesService, [], true),
         [( IWorkbenchExtensionEnablementService.toString())]: new SyncDescriptor(ExtensionEnablementService, [], true),
         [( IExtensionUrlHandler.toString())]: new SyncDescriptor(ExtensionUrlHandler, [], true),
-        [( IExtensionFeaturesManagementService.toString())]: new SyncDescriptor(ExtensionFeaturesManagementService, [], true)
+        [( IExtensionFeaturesManagementService.toString())]: new SyncDescriptor(ExtensionFeaturesManagementService, [], true),
+        [( IExtensionsScannerService.toString())]: new SyncDescriptor(ExtensionsScannerService, [], true),
+        [( IExtensionsProfileScannerService.toString())]: new SyncDescriptor(ExtensionsProfileScannerService, [], true)
     };
 }
 

package/override/vs/platform/dialogs/common/dialogs.js

@@ -1,3 +1,5 @@
+export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
 var ConfirmResult;
 ( (function(ConfirmResult) {
     ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extension-gallery-service-override",
-  "version": "3.2.3",
+  "version": "4.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,13 +18,13 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@3.2.3",
-    "@codingame/monaco-vscode-files-service-override": "3.2.3",
-    "@codingame/monaco-vscode-quickaccess-service-override": "3.2.3",
-    "@codingame/monaco-vscode-extensions-service-override": "3.2.3",
-    "@codingame/monaco-vscode-environment-service-override": "3.2.3",
-    "@codingame/monaco-vscode-layout-service-override": "3.2.3",
-    "@codingame/monaco-vscode-host-service-override": "3.2.3",
-    "@codingame/monaco-vscode-base-service-override": "3.2.3"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.0.0",
+    "@codingame/monaco-vscode-files-service-override": "4.0.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "4.0.0",
+    "@codingame/monaco-vscode-extensions-service-override": "4.0.0",
+    "@codingame/monaco-vscode-environment-service-override": "4.0.0",
+    "@codingame/monaco-vscode-layout-service-override": "4.0.0",
+    "@codingame/monaco-vscode-host-service-override": "4.0.0",
+    "@codingame/monaco-vscode-base-service-override": "4.0.0"
   }
 }

package/vscode/src/vs/platform/extensionManagement/common/abstractExtensionManagementService.js

@@ -78,7 +78,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         const installableExtensions = [];
         await Promise.allSettled(( extensions.map(async ({ extension, options }) => {
             try {
-                const compatible = await this.checkAndGetCompatibleVersion(extension, !!options?.installGivenVersion, !!options?.installPreReleaseVersion);
+                const compatible = await this.checkAndGetCompatibleVersion(extension, !!options?.installGivenVersion, !!options?.installPreReleaseVersion, options.productVersion ?? { version: this.productService.version, date: this.productService.date });
                 installableExtensions.push({ ...compatible, options });
             }
             catch (error) {
@@ -164,9 +164,10 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                 const isApplicationScoped = options.isApplicationScoped || options.isBuiltin || isApplicationScopedExtension(manifest);
                 const installExtensionTaskOptions = {
                     ...options,
-                    installOnlyNewlyAddedFromExtensionPack: URI.isUri(extension) ? options.installOnlyNewlyAddedFromExtensionPack : true,
+                    installOnlyNewlyAddedFromExtensionPack: options.installOnlyNewlyAddedFromExtensionPack ?? !URI.isUri(extension) ,
                     isApplicationScoped,
-                    profileLocation: isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : options.profileLocation ?? this.getCurrentExtensionsManifestLocation()
+                    profileLocation: isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : options.profileLocation ?? this.getCurrentExtensionsManifestLocation(),
+                    productVersion: options.productVersion ?? { version: this.productService.version, date: this.productService.date }
                 };
                 const existingInstallExtensionTask = !URI.isUri(extension) ? this.installingExtensions.get(getInstallExtensionTaskKey(extension, installExtensionTaskOptions.profileLocation)) : undefined;
                 if (existingInstallExtensionTask) {
@@ -183,8 +184,8 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                 }
                 else {
                     try {
-                        const allDepsAndPackExtensionsToInstall = await this.getAllDepsAndPackExtensions(task.identifier, manifest, !!task.options.installOnlyNewlyAddedFromExtensionPack, !!task.options.installPreReleaseVersion, task.options.profileLocation);
-                        const installed = await this.getInstalled(undefined, task.options.profileLocation);
+                        const allDepsAndPackExtensionsToInstall = await this.getAllDepsAndPackExtensions(task.identifier, manifest, !!task.options.installOnlyNewlyAddedFromExtensionPack, !!task.options.installPreReleaseVersion, task.options.profileLocation, task.options.productVersion);
+                        const installed = await this.getInstalled(undefined, task.options.profileLocation, task.options.productVersion);
                         const options = { ...task.options, donotIncludePackAndDependencies: true, context: { ...task.options.context, [EXTENSION_INSTALL_DEP_PACK_CONTEXT]: true } };
                         for (const { gallery, manifest } of distinct(allDepsAndPackExtensionsToInstall, ({ gallery }) => gallery.identifier.id)) {
                             if (( installingExtensionsMap.has(`${gallery.identifier.id.toLowerCase()}-${( options.profileLocation.toString())}`))) {
@@ -267,6 +268,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         }
         catch (error) {
             if (successResults.length) {
+                this.logService.info('Rollback: Uninstalling installed extensions', getErrorMessage(error));
                 await Promise.allSettled(( successResults.map(async ({ local, profileLocation }) => {
                     try {
                         await this.createUninstallExtensionTask(local, { versionOnly: true, profileLocation }).run();
@@ -327,11 +329,11 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         }
         return results;
     }
-    async getAllDepsAndPackExtensions(extensionIdentifier, manifest, getOnlyNewlyAddedFromExtensionPack, installPreRelease, profile) {
+    async getAllDepsAndPackExtensions(extensionIdentifier, manifest, getOnlyNewlyAddedFromExtensionPack, installPreRelease, profile, productVersion) {
         if (!this.galleryService.isEnabled()) {
             return [];
         }
-        const installed = await this.getInstalled(undefined, profile);
+        const installed = await this.getInstalled(undefined, profile, productVersion);
         const knownIdentifiers = [];
         const allDependenciesAndPacks = [];
         const collectDependenciesAndPackExtensionsToInstall = async (extensionIdentifier, manifest) => {
@@ -359,7 +361,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                         const isDependency = ( dependecies.some(id => areSameExtensions({ id }, galleryExtension.identifier)));
                         let compatible;
                         try {
-                            compatible = await this.checkAndGetCompatibleVersion(galleryExtension, false, installPreRelease);
+                            compatible = await this.checkAndGetCompatibleVersion(galleryExtension, false, installPreRelease, productVersion);
                         }
                         catch (error) {
                             if (!isDependency) {
@@ -379,7 +381,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         await collectDependenciesAndPackExtensionsToInstall(extensionIdentifier, manifest);
         return allDependenciesAndPacks;
     }
-    async checkAndGetCompatibleVersion(extension, sameVersion, installPreRelease) {
+    async checkAndGetCompatibleVersion(extension, sameVersion, installPreRelease, productVersion) {
         let compatibleExtension;
         const extensionsControlManifest = await this.getExtensionsControlManifest();
         if (( extensionsControlManifest.malicious.some(identifier => areSameExtensions(extension.identifier, identifier)))) {
@@ -388,7 +390,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         const deprecationInfo = extensionsControlManifest.deprecated[extension.identifier.id.toLowerCase()];
         if (deprecationInfo?.extension?.autoMigrate) {
             this.logService.info(`The '${extension.identifier.id}' extension is deprecated, fetching the compatible '${deprecationInfo.extension.id}' extension instead.`);
-            compatibleExtension = (await this.galleryService.getExtensions([{ id: deprecationInfo.extension.id, preRelease: deprecationInfo.extension.preRelease }], { targetPlatform: await this.getTargetPlatform(), compatible: true }, CancellationToken.None))[0];
+            compatibleExtension = (await this.galleryService.getExtensions([{ id: deprecationInfo.extension.id, preRelease: deprecationInfo.extension.preRelease }], { targetPlatform: await this.getTargetPlatform(), compatible: true, productVersion }, CancellationToken.None))[0];
             if (!compatibleExtension) {
                 throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundDeprecatedReplacementExtension', "Can't install '{0}' extension since it was deprecated and the replacement extension '{1}' can't be found.", extension.identifier.id, deprecationInfo.extension.id), ExtensionManagementErrorCode.Deprecated);
             }
@@ -398,7 +400,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                 const targetPlatform = await this.getTargetPlatform();
                 throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'incompatible platform', "The '{0}' extension is not available in {1} for {2}.", extension.identifier.id, this.productService.nameLong, TargetPlatformToString(targetPlatform)), ExtensionManagementErrorCode.IncompatibleTargetPlatform);
             }
-            compatibleExtension = await this.getCompatibleVersion(extension, sameVersion, installPreRelease);
+            compatibleExtension = await this.getCompatibleVersion(extension, sameVersion, installPreRelease, productVersion);
             if (!compatibleExtension) {
                 if (!installPreRelease && extension.properties.isPreReleaseVersion && (await this.galleryService.getExtensions([extension.identifier], CancellationToken.None))[0]) {
                     throw new ExtensionManagementError(localizeWithPath('vs/platform/extensionManagement/common/abstractExtensionManagementService', 'notFoundReleaseExtension', "Can't install release version of '{0}' extension because it has no release version.", extension.displayName ?? extension.identifier.id), ExtensionManagementErrorCode.ReleaseVersionNotFound);
@@ -416,21 +418,21 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         }
         return { extension: compatibleExtension, manifest };
     }
-    async getCompatibleVersion(extension, sameVersion, includePreRelease) {
+    async getCompatibleVersion(extension, sameVersion, includePreRelease, productVersion) {
         const targetPlatform = await this.getTargetPlatform();
         let compatibleExtension = null;
         if (!sameVersion && extension.hasPreReleaseVersion && extension.properties.isPreReleaseVersion !== includePreRelease) {
-            compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, preRelease: includePreRelease }], { targetPlatform, compatible: true }, CancellationToken.None))[0] || null;
+            compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, preRelease: includePreRelease }], { targetPlatform, compatible: true, productVersion }, CancellationToken.None))[0] || null;
         }
-        if (!compatibleExtension && (await this.galleryService.isExtensionCompatible(extension, includePreRelease, targetPlatform))) {
+        if (!compatibleExtension && (await this.galleryService.isExtensionCompatible(extension, includePreRelease, targetPlatform, productVersion))) {
             compatibleExtension = extension;
         }
         if (!compatibleExtension) {
             if (sameVersion) {
-                compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, version: extension.version }], { targetPlatform, compatible: true }, CancellationToken.None))[0] || null;
+                compatibleExtension = (await this.galleryService.getExtensions([{ ...extension.identifier, version: extension.version }], { targetPlatform, compatible: true, productVersion }, CancellationToken.None))[0] || null;
             }
             else {
-                compatibleExtension = await this.galleryService.getCompatibleExtension(extension, includePreRelease, targetPlatform);
+                compatibleExtension = await this.galleryService.getCompatibleExtension(extension, includePreRelease, targetPlatform, productVersion);
             }
         }
         return compatibleExtension;

package/vscode/src/vs/platform/extensionManagement/common/extensionGalleryService.js

@@ -353,13 +353,13 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
         if (options.source) {
             query = query.withSource(options.source);
         }
-        const { extensions } = await this.queryGalleryExtensions(query, { targetPlatform: options.targetPlatform ?? CURRENT_TARGET_PLATFORM, includePreRelease: includePreReleases, versions, compatible: !!options.compatible }, token);
+        const { extensions } = await this.queryGalleryExtensions(query, { targetPlatform: options.targetPlatform ?? CURRENT_TARGET_PLATFORM, includePreRelease: includePreReleases, versions, compatible: !!options.compatible, productVersion: options.productVersion ?? { version: this.productService.version, date: this.productService.date } }, token);
         if (options.source) {
             extensions.forEach((e, index) => setTelemetry(e, index, options.source));
         }
         return extensions;
     }
-    async getCompatibleExtension(extension, includePreRelease, targetPlatform) {
+    async getCompatibleExtension(extension, includePreRelease, targetPlatform, productVersion = { version: this.productService.version, date: this.productService.date }) {
         if (isNotWebExtensionInWebTargetPlatform(extension.allTargetPlatforms, targetPlatform)) {
             return null;
         }
@@ -370,10 +370,10 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
             .withFlags(Flags.IncludeVersions)
             .withPage(1, 1)
             .withFilter(FilterType.ExtensionId, extension.identifier.uuid);
-        const { extensions } = await this.queryGalleryExtensions(query, { targetPlatform, compatible: true, includePreRelease }, CancellationToken.None);
+        const { extensions } = await this.queryGalleryExtensions(query, { targetPlatform, compatible: true, includePreRelease, productVersion }, CancellationToken.None);
         return extensions[0] || null;
     }
-    async isExtensionCompatible(extension, includePreRelease, targetPlatform) {
+    async isExtensionCompatible(extension, includePreRelease, targetPlatform, productVersion = { version: this.productService.version, date: this.productService.date }) {
         if (!isTargetPlatformCompatible(extension.properties.targetPlatform, extension.allTargetPlatforms, targetPlatform)) {
             return false;
         }
@@ -388,9 +388,9 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
             }
             engine = manifest.engines.vscode;
         }
-        return isEngineValid(engine, this.productService.version, this.productService.date);
+        return isEngineValid(engine, productVersion.version, productVersion.date);
     }
-    async isValidVersion(rawGalleryExtensionVersion, versionType, compatible, allTargetPlatforms, targetPlatform) {
+    async isValidVersion(extension, rawGalleryExtensionVersion, versionType, compatible, allTargetPlatforms, targetPlatform, productVersion = { version: this.productService.version, date: this.productService.date }) {
         if (!isTargetPlatformCompatible(getTargetPlatformForExtensionVersion(rawGalleryExtensionVersion), allTargetPlatforms, targetPlatform)) {
             return false;
         }
@@ -399,8 +399,8 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
         }
         if (compatible) {
             try {
-                const engine = await this.getEngine(rawGalleryExtensionVersion);
-                if (!isEngineValid(engine, this.productService.version, this.productService.date)) {
+                const engine = await this.getEngine(extension, rawGalleryExtensionVersion);
+                if (!isEngineValid(engine, productVersion.version, productVersion.date)) {
                     return false;
                 }
             }
@@ -455,7 +455,7 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
             query = query.withSource(options.source);
         }
         const runQuery = async (query, token) => {
-            const { extensions, total } = await this.queryGalleryExtensions(query, { targetPlatform: CURRENT_TARGET_PLATFORM, compatible: false, includePreRelease: !!options.includePreRelease }, token);
+            const { extensions, total } = await this.queryGalleryExtensions(query, { targetPlatform: CURRENT_TARGET_PLATFORM, compatible: false, includePreRelease: !!options.includePreRelease, productVersion: options.productVersion ?? { version: this.productService.version, date: this.productService.date } }, token);
             extensions.forEach((e, index) => setTelemetry(e, ((query.pageNumber - 1) * query.pageSize) + index, options.source));
             return { extensions, total };
         };
@@ -544,7 +544,7 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
             if (version && rawGalleryExtensionVersion.version !== version) {
                 continue;
             }
-            if (await this.isValidVersion(rawGalleryExtensionVersion, includePreRelease ? 'any' : 'release', criteria.compatible, allTargetPlatforms, criteria.targetPlatform)) {
+            if (await this.isValidVersion(getGalleryExtensionId(rawGalleryExtension.publisher.publisherName, rawGalleryExtension.extensionName), rawGalleryExtensionVersion, includePreRelease ? 'any' : 'release', criteria.compatible, allTargetPlatforms, criteria.targetPlatform, criteria.productVersion)) {
                 return toExtension(rawGalleryExtension, rawGalleryExtensionVersion, allTargetPlatforms, queryContext);
             }
             if (version && rawGalleryExtensionVersion.version === version) {
@@ -647,7 +647,7 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
             fallbackUri: `${extension.assets.download.fallbackUri}${( URI.parse(extension.assets.download.fallbackUri)).query ? '&' : '?'}${operationParam}=true`
         } : extension.assets.download;
         const headers = extension.queryContext?.[ACTIVITY_HEADER_NAME] ? { [ACTIVITY_HEADER_NAME]: extension.queryContext[ACTIVITY_HEADER_NAME] } : undefined;
-        const context = await this.getAsset(downloadAsset, headers ? { headers } : undefined);
+        const context = await this.getAsset(extension.identifier.id, downloadAsset, AssetType.VSIX, headers ? { headers } : undefined);
         await this.fileService.writeFile(location, context.stream);
         log(( new Date()).getTime() - startTime);
     }
@@ -656,12 +656,12 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
             throw new Error('No signature asset found');
         }
         this.logService.trace('ExtensionGalleryService#downloadSignatureArchive', extension.identifier.id);
-        const context = await this.getAsset(extension.assets.signature);
+        const context = await this.getAsset(extension.identifier.id, extension.assets.signature, AssetType.Signature);
         await this.fileService.writeFile(location, context.stream);
     }
     async getReadme(extension, token) {
         if (extension.assets.readme) {
-            const context = await this.getAsset(extension.assets.readme, {}, token);
+            const context = await this.getAsset(extension.identifier.id, extension.assets.readme, AssetType.Details, {}, token);
             const content = await asTextOrError(context);
             return content || '';
         }
@@ -669,25 +669,25 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
     }
     async getManifest(extension, token) {
         if (extension.assets.manifest) {
-            const context = await this.getAsset(extension.assets.manifest, {}, token);
+            const context = await this.getAsset(extension.identifier.id, extension.assets.manifest, AssetType.Manifest, {}, token);
             const text = await asTextOrError(context);
             return text ? JSON.parse(text) : null;
         }
         return null;
     }
-    async getManifestFromRawExtensionVersion(rawExtensionVersion, token) {
+    async getManifestFromRawExtensionVersion(extension, rawExtensionVersion, token) {
         const manifestAsset = getVersionAsset(rawExtensionVersion, AssetType.Manifest);
         if (!manifestAsset) {
             throw new Error('Manifest was not found');
         }
         const headers = { 'Accept-Encoding': 'gzip' };
-        const context = await this.getAsset(manifestAsset, { headers });
+        const context = await this.getAsset(extension, manifestAsset, AssetType.Manifest, { headers });
         return await asJson(context);
     }
     async getCoreTranslation(extension, languageId) {
         const asset = extension.assets.coreTranslations.filter(t => t[0] === languageId.toUpperCase())[0];
         if (asset) {
-            const context = await this.getAsset(asset[1]);
+            const context = await this.getAsset(extension.identifier.id, asset[1], asset[0]);
             const text = await asTextOrError(context);
             return text ? JSON.parse(text) : null;
         }
@@ -695,7 +695,7 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
     }
     async getChangelog(extension, token) {
         if (extension.assets.changelog) {
-            const context = await this.getAsset(extension.assets.changelog, {}, token);
+            const context = await this.getAsset(extension.identifier.id, extension.assets.changelog, AssetType.Changelog, {}, token);
             const content = await asTextOrError(context);
             return content || '';
         }
@@ -722,7 +722,7 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
         const validVersions = [];
         await Promise.all(( galleryExtensions[0].versions.map(async (version) => {
             try {
-                if (await this.isValidVersion(version, includePreRelease ? 'any' : 'release', true, allTargetPlatforms, targetPlatform)) {
+                if (await this.isValidVersion(extension.identifier.id, version, includePreRelease ? 'any' : 'release', true, allTargetPlatforms, targetPlatform)) {
                     validVersions.push(version);
                 }
             }
@@ -738,7 +738,7 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
         }
         return result;
     }
-    async getAsset(asset, options = {}, token = CancellationToken.None) {
+    async getAsset(extension, asset, assetType, options = {}, token = CancellationToken.None) {
         const commonHeaders = await this.commonHeadersPromise;
         const baseOptions = { type: 'GET' };
         const headers = { ...commonHeaders, ...(options.headers || {}) };
@@ -759,15 +759,16 @@ let AbstractExtensionGalleryService = class AbstractExtensionGalleryService {
                 throw err;
             }
             const message = getErrorMessage(err);
-            this.telemetryService.publicLog2('galleryService:cdnFallback', { url, message });
+            this.telemetryService.publicLog2('galleryService:cdnFallback', { extension, assetType, message });
             const fallbackOptions = { ...options, url: fallbackUrl };
             return this.requestService.request(fallbackOptions, token);
         }
     }
-    async getEngine(rawExtensionVersion) {
+    async getEngine(extension, rawExtensionVersion) {
         let engine = getEngine(rawExtensionVersion);
         if (!engine) {
-            const manifest = await this.getManifestFromRawExtensionVersion(rawExtensionVersion, CancellationToken.None);
+            this.telemetryService.publicLog2('galleryService:engineFallback', { extension, version: rawExtensionVersion.version });
+            const manifest = await this.getManifestFromRawExtensionVersion(extension, rawExtensionVersion, CancellationToken.None);
             if (!manifest) {
                 throw new Error('Manifest was not found');
             }

package/vscode/src/vs/platform/extensionManagement/common/extensionManagementIpc.js

@@ -83,13 +83,16 @@ class ExtensionManagementChannelClient extends Disposable {
         ));
     }
     uninstall(extension, options) {
+        if (extension.isWorkspaceScoped) {
+            throw new Error('Cannot uninstall a workspace extension');
+        }
         return Promise.resolve(this.channel.call('uninstall', [extension, options]));
     }
     reinstallFromGallery(extension) {
         return Promise.resolve(this.channel.call('reinstallFromGallery', [extension])).then(local => transformIncomingExtension(local, null));
     }
-    getInstalled(type = null, extensionsProfileResource) {
-        return Promise.resolve(this.channel.call('getInstalled', [type, extensionsProfileResource]))
+    getInstalled(type = null, extensionsProfileResource, productVersion) {
+        return Promise.resolve(this.channel.call('getInstalled', [type, extensionsProfileResource, productVersion]))
             .then(extensions => ( extensions.map(extension => transformIncomingExtension(extension, null))));
     }
     updateMetadata(local, metadata, extensionsProfileResource) {

package/vscode/src/vs/platform/extensionManagement/common/extensionTipsService.js

@@ -1,8 +1,18 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import 'vscode/vscode/vs/base/common/arrays';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
+import 'vscode/vscode/vs/base/common/path';
+import 'vscode/vscode/vs/base/common/platform';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import 'vscode/vscode/vs/base/common/async';
+import 'vscode/vscode/vs/base/common/event';
+import 'vscode/vscode/vs/base/common/process';
+import 'vscode/vscode/vs/base/common/strings';
+import 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import 'vscode/vscode/vs/base/common/network';
 
 let ExtensionTipsService = class ExtensionTipsService extends Disposable {
     constructor(fileService, productService) {

package/vscode/src/vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor.js

@@ -1,6 +1,8 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { append, $, addDisposableListener, clearNode } from 'vscode/vscode/vs/base/browser/dom';
 import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { setupCustomHover } from 'vscode/vscode/vs/base/browser/ui/hover/updatableHoverWidget';
 import { renderLabelWithIcons } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabels';
 import { Action, Separator } from 'vscode/vscode/vs/base/common/actions';
 import { isNonEmptyArray } from 'vscode/vscode/vs/base/common/arrays';
@@ -24,7 +26,17 @@ import { Severity, INotificationService } from 'vscode/vscode/vs/platform/notifi
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { editorBackground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorBackground } from 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
 import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
 import { errorIcon, warningIcon } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
@@ -41,8 +53,8 @@ var AbstractRuntimeExtensionsEditor_1;
 let AbstractRuntimeExtensionsEditor = class AbstractRuntimeExtensionsEditor extends EditorPane {
     static { AbstractRuntimeExtensionsEditor_1 = this; }
     static { this.ID = 'workbench.editor.runtimeExtensions'; }
-    constructor(telemetryService, themeService, contextKeyService, _extensionsWorkbenchService, _extensionService, _notificationService, _contextMenuService, _instantiationService, storageService, _labelService, _environmentService, _clipboardService, _extensionFeaturesManagementService) {
-        super(AbstractRuntimeExtensionsEditor_1.ID, telemetryService, themeService, storageService);
+    constructor(group, telemetryService, themeService, contextKeyService, _extensionsWorkbenchService, _extensionService, _notificationService, _contextMenuService, _instantiationService, storageService, _labelService, _environmentService, _clipboardService, _extensionFeaturesManagementService) {
+        super(AbstractRuntimeExtensionsEditor_1.ID, group, telemetryService, themeService, storageService);
         this._extensionsWorkbenchService = _extensionsWorkbenchService;
         this._extensionService = _extensionService;
         this._notificationService = _notificationService;
@@ -324,15 +336,16 @@ let AbstractRuntimeExtensionsEditor = class AbstractRuntimeExtensionsEditor exte
                         "Extension is activating..."
                     ));
                 }
-                data.activationTime.title = title;
+                data.elementDisposables.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.activationTime, title));
                 clearNode(data.msgContainer);
                 if (this._getUnresponsiveProfile(element.description.identifier)) {
                     const el = $('span', undefined, ...renderLabelWithIcons(` $(alert) Unresponsive`));
-                    el.title = ( localizeWithPath(
+                    const extensionHostFreezTitle = ( localizeWithPath(
                         'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
                         'unresponsive.title',
                         "Extension has caused the extension host to freeze."
                     ));
+                    data.elementDisposables.push(setupCustomHover(getDefaultHoverDelegate('mouse'), el, extensionHostFreezTitle));
                     data.msgContainer.appendChild(el);
                 }
                 if (isNonEmptyArray(element.status.runtimeErrors)) {
@@ -387,13 +400,14 @@ let AbstractRuntimeExtensionsEditor = class AbstractRuntimeExtensionsEditor exte
                                 feature.label,
                                 accessData.current.count
                             )));
-                            element.title = ( localizeWithPath(
+                            const title = ( localizeWithPath(
                                 'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
                                 'requests count title',
                                 "Last request was {0}. Overall Requests: {1}",
                                 fromNow(accessData.current.lastAccessed, true, true),
                                 accessData.totalCount
                             ));
+                            data.elementDisposables.push(setupCustomHover(getDefaultHoverDelegate('mouse'), element, title));
                             data.msgContainer.appendChild(element);
                         }
                     }
@@ -486,19 +500,19 @@ AbstractRuntimeExtensionsEditor.__decorator = ( __decorate([
     memoize
 ], AbstractRuntimeExtensionsEditor.prototype, "saveExtensionHostProfileAction", null));
 AbstractRuntimeExtensionsEditor = AbstractRuntimeExtensionsEditor_1 = ( __decorate([
-    ( __param(0, ITelemetryService)),
-    ( __param(1, IThemeService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IExtensionsWorkbenchService)),
-    ( __param(4, IExtensionService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IStorageService)),
-    ( __param(9, ILabelService)),
-    ( __param(10, IWorkbenchEnvironmentService)),
-    ( __param(11, IClipboardService)),
-    ( __param(12, IExtensionFeaturesManagementService))
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IExtensionsWorkbenchService)),
+    ( __param(5, IExtensionService)),
+    ( __param(6, INotificationService)),
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IStorageService)),
+    ( __param(10, ILabelService)),
+    ( __param(11, IWorkbenchEnvironmentService)),
+    ( __param(12, IClipboardService)),
+    ( __param(13, IExtensionFeaturesManagementService))
 ], AbstractRuntimeExtensionsEditor));
 class ShowRuntimeExtensionsAction extends Action2 {
     constructor() {

package/vscode/src/vs/workbench/contrib/extensions/browser/configBasedRecommendations.js

@@ -57,7 +57,7 @@ let ConfigBasedRecommendations = class ConfigBasedRecommendations extends Extens
     }
     toExtensionRecommendation(tip) {
         return {
-            extensionId: tip.extensionId,
+            extension: tip.extensionId,
             reason: {
                 reasonId: 3 ,
                 reasonText: ( localizeWithPath(

package/vscode/src/vs/workbench/contrib/extensions/browser/deprecatedExtensionsChecker.js

@@ -9,11 +9,13 @@ import { distinct } from 'vscode/vscode/vs/base/common/arrays';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
 import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
 
 let DeprecatedExtensionsChecker = class DeprecatedExtensionsChecker extends Disposable {
-    constructor(extensionsWorkbenchService, extensionManagementService, storageService, notificationService, instantiationService) {
+    constructor(extensionsWorkbenchService, extensionManagementService, extensionEnablementService, storageService, notificationService, instantiationService) {
         super();
         this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.extensionEnablementService = extensionEnablementService;
         this.storageService = storageService;
         this.notificationService = notificationService;
         this.instantiationService = instantiationService;
@@ -36,7 +38,7 @@ let DeprecatedExtensionsChecker = class DeprecatedExtensionsChecker extends Disp
         }
         const local = await this.extensionsWorkbenchService.queryLocal();
         const previouslyNotified = this.getNotifiedDeprecatedExtensions();
-        const toNotify = local.filter(e => !!e.deprecationInfo).filter(e => !previouslyNotified.includes(e.identifier.id.toLowerCase()));
+        const toNotify = local.filter(e => !!e.deprecationInfo && e.local && this.extensionEnablementService.isEnabled(e.local)).filter(e => !previouslyNotified.includes(e.identifier.id.toLowerCase()));
         if (toNotify.length) {
             this.notificationService.prompt(Severity.Warning, ( localizeWithPath(
                 'vs/workbench/contrib/extensions/browser/deprecatedExtensionsChecker',
@@ -79,9 +81,10 @@ let DeprecatedExtensionsChecker = class DeprecatedExtensionsChecker extends Disp
 DeprecatedExtensionsChecker = ( __decorate([
     ( __param(0, IExtensionsWorkbenchService)),
     ( __param(1, IExtensionManagementService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IInstantiationService))
+    ( __param(2, IWorkbenchExtensionEnablementService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IInstantiationService))
 ], DeprecatedExtensionsChecker));
 
 export { DeprecatedExtensionsChecker };

package/vscode/src/vs/workbench/contrib/extensions/browser/exeBasedRecommendations.js

@@ -40,7 +40,7 @@ let ExeBasedRecommendations = class ExeBasedRecommendations extends ExtensionRec
     }
     toExtensionRecommendation(tip) {
         return {
-            extensionId: tip.extensionId.toLowerCase(),
+            extension: tip.extensionId.toLowerCase(),
             reason: {
                 reasonId: 2 ,
                 reasonText: ( localizeWithPath(