@codingame/monaco-vscode-extension-gallery-service-override 31.0.0 → 32.0.0

package/index.js

@@ -14,9 +14,9 @@ import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/l
 import { getLocale } from '@codingame/monaco-vscode-api/vscode/vs/platform/languagePacks/common/languagePacks';
 import { IgnoredExtensionsManagementService } from './vscode/src/vs/platform/userDataSync/common/ignoredExtensions.js';
 import { IIgnoredExtensionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/ignoredExtensions.service';
-import { ExtensionRecommendationNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService';
-import { ExtensionRecommendationsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensionRecommendationsService';
-import { ExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensionsWorkbenchService';
+import { ExtensionRecommendationNotificationService } from './vscode/src/vs/workbench/contrib/extensions/browser/extensionRecommendationNotificationService.js';
+import { ExtensionRecommendationsService } from './vscode/src/vs/workbench/contrib/extensions/browser/extensionRecommendationsService.js';
+import { ExtensionsWorkbenchService } from './vscode/src/vs/workbench/contrib/extensions/browser/extensionsWorkbenchService.js';
 import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
 import { ExtensionEnablementService } from './vscode/src/vs/workbench/services/extensionManagement/browser/extensionEnablementService.js';
 import { WebExtensionGalleryManifestService } from './vscode/src/vs/workbench/services/extensionManagement/browser/extensionGalleryManifestService.js';
@@ -42,7 +42,7 @@ import { IRemoteUserDataProfilesService } from '@codingame/monaco-vscode-api/vsc
 import { registerAssets } from '@codingame/monaco-vscode-api/assets';
 import { isLocaleAvailable } from '@codingame/monaco-vscode-api/l10n';
 import { unsupported } from '@codingame/monaco-vscode-api/tools';
-import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensions.contribution';
+import './vscode/src/vs/workbench/contrib/extensions/browser/extensions.contribution.js';
 import './vscode/src/vs/workbench/contrib/extensions/browser/extensions.web.contribution.js';
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-extension-gallery-service-override",
-  "version": "31.0.0",
+  "version": "32.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - extension-gallery service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "31.0.0"
+    "@codingame/monaco-vscode-api": "32.0.0"
   },
   "main": "index.js",
   "module": "index.js",

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

@@ -36,7 +36,7 @@ let CommontExtensionManagementService = class CommontExtensionManagementService
         });
         if (allowedToInstall !== true) {
             return (new MarkdownString(localize(
-                1847,
+                1859,
                 "This extension cannot be installed because {0}",
                 allowedToInstall.value
             )));
@@ -44,12 +44,12 @@ let CommontExtensionManagementService = class CommontExtensionManagementService
         if (!(await this.isExtensionPlatformCompatible(extension))) {
             const learnLink = isWeb ? "https://aka.ms/vscode-web-extensions-guide" : "https://aka.ms/vscode-platform-specific-extensions";
             return (new MarkdownString(`${( localize(
-                1848,
+                1860,
                 "The '{0}' extension is not available in {1} for the {2} platform.",
                 extension.displayName ?? extension.identifier.id,
                 this.productService.nameLong,
                 TargetPlatformToString(await this.getTargetPlatform())
-            ))} [${( localize(1849, "Learn Why"))}](${learnLink})`));
+            ))} [${( localize(1861, "Learn Why"))}](${learnLink})`));
         }
         return true;
     }
@@ -146,7 +146,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
     }
     async installGalleryExtensions(extensions) {
         if (!this.galleryService.isEnabled()) {
-            throw ( new ExtensionManagementError(( localize(1850, "Marketplace is not enabled")), ExtensionManagementErrorCode.NotAllowed));
+            throw ( new ExtensionManagementError(( localize(1862, "Marketplace is not enabled")), ExtensionManagementErrorCode.NotAllowed));
         }
         const results = [];
         const installableExtensions = [];
@@ -302,21 +302,21 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                             ( options.profileLocation.toString())
                         );
                         existingInstallingExtension.waitingTasks.push(root);
-                        alreadyRequestedInstallations.push(
-                            Event.toPromise(Event.filter(this.onDidInstallExtensions, results => ( results.some(result => areSameExtensions(result.identifier, identifier))))).then(results => {
-                                this.logService.info(
-                                    "Finished waiting for already requested installing extension",
-                                    identifier.id,
-                                    root.identifier.id,
-                                    ( options.profileLocation.toString())
-                                );
-                                const result = results.find(result => areSameExtensions(result.identifier, identifier));
-                                if (!result?.local) {
-                                    throw ( new Error(`Extension ${identifier.id} is not installed`));
-                                }
-                                return result.local;
-                            })
-                        );
+                        const waitForInstallation = Event.toPromise(Event.filter(this.onDidInstallExtensions, results => ( results.some(result => areSameExtensions(result.identifier, identifier))))).then(results => {
+                            this.logService.info(
+                                "Finished waiting for already requested installing extension",
+                                identifier.id,
+                                root.identifier.id,
+                                ( options.profileLocation.toString())
+                            );
+                            const result = results.find(result => areSameExtensions(result.identifier, identifier));
+                            if (!result?.local) {
+                                throw ( new Error(`Extension ${identifier.id} is not installed`));
+                            }
+                            return result.local;
+                        });
+                        alreadyRequestedInstallations.push(waitForInstallation);
+                        waitForInstallation.catch(() => {});
                     }
                     return;
                 }
@@ -371,12 +371,37 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                     getInstallExtensionTaskKey(extension, installExtensionTaskOptions.profileLocation)
                 ) : undefined;
                 if (existingInstallExtensionTask) {
+                    const existingTask = existingInstallExtensionTask.task;
                     this.logService.info(
                         "Extension is already requested to install",
-                        existingInstallExtensionTask.task.identifier.id,
+                        existingTask.identifier.id,
                         ( installExtensionTaskOptions.profileLocation.toString())
                     );
-                    alreadyRequestedInstallations.push(existingInstallExtensionTask.task.waitUntilTaskIsFinished());
+                    const resultKey = `${existingTask.identifier.id.toLowerCase()}-${( installExtensionTaskOptions.profileLocation.toString())}`;
+                    const waitForInstallation = existingTask.waitUntilTaskIsFinished().then(local => {
+                        installExtensionResultsMap.set(resultKey, {
+                            local,
+                            identifier: existingTask.identifier,
+                            operation: existingTask.operation,
+                            source: existingTask.source,
+                            context: installExtensionTaskOptions.context,
+                            profileLocation: installExtensionTaskOptions.profileLocation,
+                            applicationScoped: local.isApplicationScoped
+                        });
+                        return local;
+                    }, error => {
+                        installExtensionResultsMap.set(resultKey, {
+                            error: toExtensionManagementError(error),
+                            identifier: existingTask.identifier,
+                            operation: existingTask.operation,
+                            source: existingTask.source,
+                            context: installExtensionTaskOptions.context,
+                            profileLocation: installExtensionTaskOptions.profileLocation
+                        });
+                        throw error;
+                    });
+                    alreadyRequestedInstallations.push(waitForInstallation);
+                    waitForInstallation.catch(() => {});
                 } else {
                     createInstallExtensionTask(manifest, extension, installExtensionTaskOptions, undefined);
                 }
@@ -808,7 +833,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         const extensionsControlManifest = await this.getExtensionsControlManifest();
         if (isMalicious(extension.identifier, extensionsControlManifest.malicious)) {
             throw ( new ExtensionManagementError(( localize(
-                1851,
+                1863,
                 "Can't install '{0}' extension since it was reported to be problematic.",
                 extension.identifier.id
             )), ExtensionManagementErrorCode.Malicious));
@@ -828,7 +853,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
             }, CancellationToken.None))[0];
             if (!compatibleExtension) {
                 throw ( new ExtensionManagementError(( localize(
-                    1852,
+                    1864,
                     "Can't install '{0}' extension since it was deprecated and the replacement extension '{1}' can't be found.",
                     extension.identifier.id,
                     deprecationInfo.extension.id
@@ -838,7 +863,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
             if ((await this.canInstall(extension)) !== true) {
                 const targetPlatform = await this.getTargetPlatform();
                 throw ( new ExtensionManagementError(( localize(
-                    1848,
+                    1860,
                     "The '{0}' extension is not available in {1} for the {2} platform.",
                     extension.identifier.id,
                     this.productService.nameLong,
@@ -853,7 +878,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                     incompatibleApiProposalsMessages
                 )) {
                     throw ( new ExtensionManagementError(( localize(
-                        1853,
+                        1865,
                         "Can't install '{0}' extension. {1}",
                         extension.displayName ?? extension.identifier.id,
                         incompatibleApiProposalsMessages[0]
@@ -861,13 +886,13 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                 }
                 if (!installPreRelease && extension.hasPreReleaseVersion && extension.properties.isPreReleaseVersion && (await this.galleryService.getExtensions([extension.identifier], CancellationToken.None))[0]) {
                     throw ( new ExtensionManagementError(( localize(
-                        1854,
+                        1866,
                         "Can't install release version of '{0}' extension because it has no release version.",
                         extension.displayName ?? extension.identifier.id
                     )), ExtensionManagementErrorCode.ReleaseVersionNotFound));
                 }
                 throw ( new ExtensionManagementError(( localize(
-                    1855,
+                    1867,
                     "Can't install '{0}' extension because it is not compatible with the current version of {1} (version {2}).",
                     extension.identifier.id,
                     this.productService.nameLong,
@@ -1187,7 +1212,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         if (extensionToUninstall === dependingExtension) {
             if (dependents.length === 1) {
                 return localize(
-                    1856,
+                    1868,
                     "Cannot uninstall '{0}' extension. '{1}' extension depends on this.",
                     extensionToUninstall.manifest.displayName || extensionToUninstall.manifest.name,
                     dependents[0].manifest.displayName || dependents[0].manifest.name
@@ -1195,7 +1220,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
             }
             if (dependents.length === 2) {
                 return localize(
-                    1857,
+                    1869,
                     "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,
@@ -1203,7 +1228,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
                 );
             }
             return localize(
-                1858,
+                1870,
                 "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,
@@ -1212,7 +1237,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         }
         if (dependents.length === 1) {
             return localize(
-                1859,
+                1871,
                 "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,
@@ -1221,7 +1246,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
         }
         if (dependents.length === 2) {
             return localize(
-                1860,
+                1872,
                 "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,
@@ -1230,7 +1255,7 @@ let AbstractExtensionManagementService = class AbstractExtensionManagementServic
             );
         }
         return localize(
-            1861,
+            1873,
             "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,

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

@@ -77,14 +77,14 @@ let AllowedExtensionsService = class AllowedExtensionsService extends Disposable
             query: `@id:${AllowedExtensionsConfigKey}`
         }).toString());
         const extensionValue = this._allowedExtensionsConfigValue[id];
-        const extensionReason = ( new MarkdownString(( localize(1862, "it is not in the [allowed list]({0})", settingsCommandLink))));
+        const extensionReason = ( new MarkdownString(( localize(1874, "it is not in the [allowed list]({0})", settingsCommandLink))));
         if (!isUndefined(extensionValue)) {
             if (isBoolean(extensionValue)) {
                 return extensionValue ? true : extensionReason;
             }
             if (extensionValue === "stable" && prerelease) {
                 return (new MarkdownString(localize(
-                    1863,
+                    1875,
                     "the pre-release versions of this extension are not in the [allowed list]({0})",
                     settingsCommandLink
                 )));
@@ -107,7 +107,7 @@ let AllowedExtensionsService = class AllowedExtensionsService extends Disposable
                 return false;
             }))) {
                 return (new MarkdownString(localize(
-                    1864,
+                    1876,
                     "the version {0} of this extension is not in the [allowed list]({1})",
                     version,
                     settingsCommandLink
@@ -120,7 +120,7 @@ let AllowedExtensionsService = class AllowedExtensionsService extends Disposable
         if (!isUndefined(publisherValue)) {
             if (isBoolean(publisherValue)) {
                 return publisherValue ? true : ( new MarkdownString(( localize(
-                    1865,
+                    1877,
                     "the extensions from this publisher are not in the [allowed list]({1})",
                     publisherKey,
                     settingsCommandLink
@@ -128,7 +128,7 @@ let AllowedExtensionsService = class AllowedExtensionsService extends Disposable
             }
             if (publisherValue === "stable" && prerelease) {
                 return (new MarkdownString(localize(
-                    1866,
+                    1878,
                     "the pre-release versions from this publisher are not in the [allowed list]({1})",
                     publisherKey,
                     settingsCommandLink

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

@@ -20,7 +20,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/nls';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/extensionRecommendations/common/extensionRecommendations';
+import '../../extensionRecommendations/common/extensionRecommendations.js';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 
 let ExtensionTipsService = class ExtensionTipsService extends Disposable {

package/vscode/src/vs/platform/extensionManagement/common/unsupportedExtensionsMigration.d.ts

@@ -0,0 +1,14 @@
+import { IGlobalExtensionEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { IExtensionManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { IExtensionGalleryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { IExtensionStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionStorage.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IUserDataProfile } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile";
+/**
+ * Migrates the installed unsupported nightly extension to a supported pre-release extension. It includes following:
+ * 	- Uninstall the Unsupported extension
+ * 	- Install (with optional storage migration) the Pre-release extension only if
+ * 		- the extension is not installed
+ * 		- or it is a release version and the unsupported extension is enabled.
+ */
+export declare function migrateUnsupportedExtensions(profile: IUserDataProfile | undefined, extensionManagementService: IExtensionManagementService, galleryService: IExtensionGalleryService, extensionStorageService: IExtensionStorageService, extensionEnablementService: IGlobalExtensionEnablementService, logService: ILogService): Promise<void>;

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

@@ -0,0 +1,145 @@
+
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT, InstallOperation } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions, getExtensionId } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { ExtensionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { semverExports } from '@codingame/monaco-vscode-api/_virtual/semver';
+
+async function migrateUnsupportedExtensions(
+    profile,
+    extensionManagementService,
+    galleryService,
+    extensionStorageService,
+    extensionEnablementService,
+    logService
+) {
+    try {
+        const extensionsControlManifest = await extensionManagementService.getExtensionsControlManifest();
+        if (!extensionsControlManifest.deprecated) {
+            return;
+        }
+        const installed = await extensionManagementService.getInstalled(ExtensionType.User, profile?.extensionsResource);
+        for (const [unsupportedExtensionId, deprecated] of Object.entries(extensionsControlManifest.deprecated)) {
+            if (!deprecated?.extension) {
+                continue;
+            }
+            const {
+                id: preReleaseExtensionId,
+                autoMigrate,
+                preRelease
+            } = deprecated.extension;
+            if (!autoMigrate) {
+                continue;
+            }
+            const unsupportedExtension = installed.find(i => areSameExtensions(i.identifier, {
+                id: unsupportedExtensionId
+            }));
+            if (!unsupportedExtension) {
+                continue;
+            }
+            const gallery = (await galleryService.getExtensions([{
+                id: preReleaseExtensionId,
+                preRelease
+            }], {
+                targetPlatform: await extensionManagementService.getTargetPlatform(),
+                compatible: true
+            }, CancellationToken.None))[0];
+            if (!gallery) {
+                logService.info(
+                    `Skipping migrating '${unsupportedExtension.identifier.id}' extension because, the comaptible target '${preReleaseExtensionId}' extension is not found`
+                );
+                continue;
+            }
+            try {
+                logService.info(
+                    `Migrating '${unsupportedExtension.identifier.id}' extension to '${preReleaseExtensionId}' extension...`
+                );
+                const isUnsupportedExtensionEnabled = !( extensionEnablementService.getDisabledExtensions().some(e => areSameExtensions(e, unsupportedExtension.identifier)));
+                await extensionManagementService.uninstall(unsupportedExtension, {
+                    profileLocation: profile?.extensionsResource
+                });
+                logService.info(
+                    `Uninstalled the unsupported extension '${unsupportedExtension.identifier.id}'`
+                );
+                let preReleaseExtension = installed.find(i => areSameExtensions(i.identifier, {
+                    id: preReleaseExtensionId
+                }));
+                if (!preReleaseExtension || (preReleaseExtension.isPreReleaseVersion !== !!preRelease && isUnsupportedExtensionEnabled)) {
+                    preReleaseExtension = await extensionManagementService.installFromGallery(gallery, {
+                        installPreReleaseVersion: preRelease,
+                        isMachineScoped: unsupportedExtension.isMachineScoped,
+                        operation: InstallOperation.Migrate,
+                        profileLocation: profile?.extensionsResource,
+                        context: {
+                            [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true
+                        }
+                    });
+                    logService.info(
+                        `Installed the pre-release extension '${preReleaseExtension.identifier.id}'`
+                    );
+                    if (!autoMigrate.donotDisable && !isUnsupportedExtensionEnabled) {
+                        await extensionEnablementService.disableExtension(preReleaseExtension.identifier);
+                        logService.info(
+                            `Disabled the pre-release extension '${preReleaseExtension.identifier.id}' because the unsupported extension '${unsupportedExtension.identifier.id}' is disabled`
+                        );
+                    }
+                    if (autoMigrate.storage) {
+                        extensionStorageService.addToMigrationList(getExtensionId(
+                            unsupportedExtension.manifest.publisher,
+                            unsupportedExtension.manifest.name
+                        ), getExtensionId(preReleaseExtension.manifest.publisher, preReleaseExtension.manifest.name));
+                        logService.info(`Added pre-release extension to the storage migration list`);
+                    }
+                }
+                logService.info(
+                    `Migrated '${unsupportedExtension.identifier.id}' extension to '${preReleaseExtensionId}' extension.`
+                );
+            } catch (error) {
+                logService.error(error);
+            }
+        }
+        if (extensionsControlManifest.autoUpdate) {
+            for (const [extensionId, version] of Object.entries(extensionsControlManifest.autoUpdate)) {
+                try {
+                    const extensionToAutoUpdate = installed.find(i => areSameExtensions(i.identifier, {
+                        id: extensionId
+                    }) && semverExports.lte(i.manifest.version, version));
+                    if (!extensionToAutoUpdate) {
+                        continue;
+                    }
+                    const gallery = (await galleryService.getExtensions([{
+                        id: extensionId,
+                        preRelease: extensionToAutoUpdate.preRelease
+                    }], {
+                        targetPlatform: await extensionManagementService.getTargetPlatform(),
+                        compatible: true
+                    }, CancellationToken.None))[0];
+                    if (!gallery) {
+                        logService.info(
+                            `Skipping updating '${extensionToAutoUpdate.identifier.id}' extension because, the compatible target '${extensionId}' extension is not found`
+                        );
+                        continue;
+                    }
+                    await extensionManagementService.installFromGallery(gallery, {
+                        installPreReleaseVersion: extensionToAutoUpdate.preRelease,
+                        isMachineScoped: extensionToAutoUpdate.isMachineScoped,
+                        operation: InstallOperation.Update,
+                        profileLocation: profile?.extensionsResource,
+                        context: {
+                            [EXTENSION_INSTALL_SKIP_PUBLISHER_TRUST_CONTEXT]: true
+                        }
+                    });
+                    logService.info(
+                        `Autoupdated '${extensionToAutoUpdate.identifier.id}' extension to '${gallery.version}' extension.`
+                    );
+                } catch (error) {
+                    logService.error(error);
+                }
+            }
+        }
+    } catch (error) {
+        logService.error(error);
+    }
+}
+
+export { migrateUnsupportedExtensions };

package/vscode/src/vs/platform/extensionRecommendations/common/extensionRecommendations.d.ts

@@ -0,0 +1,19 @@
+export declare enum RecommendationSource {
+    FILE = 1,
+    WORKSPACE = 2,
+    EXE = 3
+}
+export interface IExtensionRecommendations {
+    source: RecommendationSource;
+    extensions: string[];
+    name: string;
+    searchValue?: string;
+}
+export declare function RecommendationSourceToString(source: RecommendationSource): "file" | "workspace" | "exe";
+export declare enum RecommendationsNotificationResult {
+    Ignored = "ignored",
+    Cancelled = "cancelled",
+    TooMany = "toomany",
+    IncompatibleWindow = "incompatibleWindow",
+    Accepted = "reacted"
+}

package/vscode/src/vs/platform/extensionRecommendations/common/extensionRecommendations.js

@@ -0,0 +1,25 @@
+
+
+var RecommendationSource;
+(function (RecommendationSource) {
+    RecommendationSource[RecommendationSource["FILE"] = 1] = "FILE";
+    RecommendationSource[RecommendationSource["WORKSPACE"] = 2] = "WORKSPACE";
+    RecommendationSource[RecommendationSource["EXE"] = 3] = "EXE";
+})(RecommendationSource || (RecommendationSource = {}));
+function RecommendationSourceToString(source) {
+    switch (source) {
+        case RecommendationSource.FILE: return 'file';
+        case RecommendationSource.WORKSPACE: return 'workspace';
+        case RecommendationSource.EXE: return 'exe';
+    }
+}
+var RecommendationsNotificationResult;
+(function (RecommendationsNotificationResult) {
+    RecommendationsNotificationResult["Ignored"] = "ignored";
+    RecommendationsNotificationResult["Cancelled"] = "cancelled";
+    RecommendationsNotificationResult["TooMany"] = "toomany";
+    RecommendationsNotificationResult["IncompatibleWindow"] = "incompatibleWindow";
+    RecommendationsNotificationResult["Accepted"] = "reacted";
+})(RecommendationsNotificationResult || (RecommendationsNotificationResult = {}));
+
+export { RecommendationSource, RecommendationSourceToString, RecommendationsNotificationResult };

package/vscode/src/vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor.d.ts

@@ -0,0 +1,76 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { Action } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
+import { IClipboardService } from "@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { ExtensionIdentifier, IExtensionDescription } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService, ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IExtensionFeaturesManagementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures.service";
+import { IExtensionHostProfile, IExtensionsStatus } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IExtension } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions";
+import { IExtensionsWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service";
+interface IExtensionProfileInformation {
+    /**
+     * segment when the extension was running.
+     * 2*i = segment start time
+     * 2*i+1 = segment end time
+     */
+    segments: number[];
+    /**
+     * total time when the extension was running.
+     * (sum of all segment lengths).
+     */
+    totalTime: number;
+}
+export interface IRuntimeExtension {
+    originalIndex: number;
+    description: IExtensionDescription;
+    marketplaceInfo: IExtension | undefined;
+    status: IExtensionsStatus;
+    profileInfo?: IExtensionProfileInformation;
+    unresponsiveProfile?: IExtensionHostProfile;
+}
+export declare abstract class AbstractRuntimeExtensionsEditor extends EditorPane {
+    private readonly contextKeyService;
+    private readonly _extensionsWorkbenchService;
+    private readonly _extensionService;
+    private readonly _notificationService;
+    private readonly _contextMenuService;
+    protected readonly _instantiationService: IInstantiationService;
+    private readonly _labelService;
+    private readonly _environmentService;
+    private readonly _clipboardService;
+    private readonly _extensionFeaturesManagementService;
+    private readonly _hoverService;
+    private readonly _menuService;
+    static readonly ID: string;
+    private _list;
+    private _elements;
+    private _updateSoon;
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, contextKeyService: IContextKeyService, _extensionsWorkbenchService: IExtensionsWorkbenchService, _extensionService: IExtensionService, _notificationService: INotificationService, _contextMenuService: IContextMenuService, _instantiationService: IInstantiationService, storageService: IStorageService, _labelService: ILabelService, _environmentService: IWorkbenchEnvironmentService, _clipboardService: IClipboardService, _extensionFeaturesManagementService: IExtensionFeaturesManagementService, _hoverService: IHoverService, _menuService: IMenuService);
+    protected _updateExtensions(): Promise<void>;
+    private _resolveExtensions;
+    protected createEditor(parent: HTMLElement): void;
+    layout(dimension: Dimension): void;
+    protected abstract _getProfileInfo(): IExtensionHostProfile | null;
+    protected abstract _getUnresponsiveProfile(extensionId: ExtensionIdentifier): IExtensionHostProfile | undefined;
+    protected abstract _createSlowExtensionAction(element: IRuntimeExtension): Action | null;
+    protected abstract _createReportExtensionIssueAction(element: IRuntimeExtension): Action | null;
+}
+export declare class ShowRuntimeExtensionsAction extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}
+export {};