@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,539 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $, addDisposableListener, clearNode } from '../../../../base/browser/dom.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
+import { renderLabelWithIcons } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { Action, Separator } from '../../../../base/common/actions.js';
+import { isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { fromNow } from '../../../../base/common/date.js';
+import { memoize } from '../../../../base/common/decorators.js';
+import { dispose } from '../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../base/common/network.js';
+import './media/runtimeExtensionsEditor.css.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
+import { Action2, MenuId } from '../../../../platform/actions/common/actions.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+import { IContextKeyService, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { ExtensionIdentifierMap } from '../../../../platform/extensions/common/extensions.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { WorkbenchList } from '../../../../platform/list/browser/listService.js';
+import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorBackground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
+import { errorIcon, warningIcon } from './extensionsIcons.js';
+import { IExtensionsWorkbenchService } from '../common/extensions.js';
+import { RuntimeExtensionsInput } from '../common/runtimeExtensionsInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { Extensions, IExtensionFeaturesManagementService } from '../../../services/extensionManagement/common/extensionFeatures.js';
+import { getDefaultIconPath } from '../../../services/extensionManagement/common/extensionManagement.js';
+import { LocalWebWorkerRunningLocation } from '../../../services/extensions/common/extensionRunningLocation.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+var AbstractRuntimeExtensionsEditor_1;
+let AbstractRuntimeExtensionsEditor = class AbstractRuntimeExtensionsEditor extends EditorPane {
+    static { AbstractRuntimeExtensionsEditor_1 = this; }
+    static { this.ID = 'workbench.editor.runtimeExtensions'; }
+    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;
+        this._contextMenuService = _contextMenuService;
+        this._instantiationService = _instantiationService;
+        this._labelService = _labelService;
+        this._environmentService = _environmentService;
+        this._clipboardService = _clipboardService;
+        this._extensionFeaturesManagementService = _extensionFeaturesManagementService;
+        this._list = null;
+        this._elements = null;
+        this._updateSoon = this._register(( new RunOnceScheduler(() => this._updateExtensions(), 200)));
+        this._register(this._extensionService.onDidChangeExtensionsStatus(() => this._updateSoon.schedule()));
+        this._register(this._extensionFeaturesManagementService.onDidChangeAccessData(() => this._updateSoon.schedule()));
+        this._updateExtensions();
+    }
+    async _updateExtensions() {
+        this._elements = await this._resolveExtensions();
+        this._list?.splice(0, this._list.length, this._elements);
+    }
+    async _resolveExtensions() {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const extensionsDescriptions = this._extensionService.extensions.filter((extension) => {
+            return Boolean(extension.main) || Boolean(extension.browser);
+        });
+        const marketplaceMap = ( new ExtensionIdentifierMap());
+        const marketPlaceExtensions = await this._extensionsWorkbenchService.queryLocal();
+        for (const extension of marketPlaceExtensions) {
+            marketplaceMap.set(extension.identifier.id, extension);
+        }
+        const statusMap = this._extensionService.getExtensionsStatus();
+        const segments = ( new ExtensionIdentifierMap());
+        const profileInfo = this._getProfileInfo();
+        if (profileInfo) {
+            let currentStartTime = profileInfo.startTime;
+            for (let i = 0, len = profileInfo.deltas.length; i < len; i++) {
+                const id = profileInfo.ids[i];
+                const delta = profileInfo.deltas[i];
+                let extensionSegments = segments.get(id);
+                if (!extensionSegments) {
+                    extensionSegments = [];
+                    segments.set(id, extensionSegments);
+                }
+                extensionSegments.push(currentStartTime);
+                currentStartTime = currentStartTime + delta;
+                extensionSegments.push(currentStartTime);
+            }
+        }
+        let result = [];
+        for (let i = 0, len = extensionsDescriptions.length; i < len; i++) {
+            const extensionDescription = extensionsDescriptions[i];
+            let extProfileInfo = null;
+            if (profileInfo) {
+                const extensionSegments = segments.get(extensionDescription.identifier) || [];
+                let extensionTotalTime = 0;
+                for (let j = 0, lenJ = extensionSegments.length / 2; j < lenJ; j++) {
+                    const startTime = extensionSegments[2 * j];
+                    const endTime = extensionSegments[2 * j + 1];
+                    extensionTotalTime += (endTime - startTime);
+                }
+                extProfileInfo = {
+                    segments: extensionSegments,
+                    totalTime: extensionTotalTime
+                };
+            }
+            result[i] = {
+                originalIndex: i,
+                description: extensionDescription,
+                marketplaceInfo: marketplaceMap.get(extensionDescription.identifier),
+                status: statusMap[extensionDescription.identifier.value],
+                profileInfo: extProfileInfo || undefined,
+                unresponsiveProfile: this._getUnresponsiveProfile(extensionDescription.identifier)
+            };
+        }
+        result = result.filter(element => element.status.activationStarted);
+        const isUnresponsive = (extension) => extension.unresponsiveProfile === profileInfo;
+        const profileTime = (extension) => extension.profileInfo?.totalTime ?? 0;
+        const activationTime = (extension) => (extension.status.activationTimes?.codeLoadingTime ?? 0) +
+            (extension.status.activationTimes?.activateCallTime ?? 0);
+        result = result.sort((a, b) => {
+            if (isUnresponsive(a) || isUnresponsive(b)) {
+                return +isUnresponsive(b) - +isUnresponsive(a);
+            }
+            else if (profileTime(a) || profileTime(b)) {
+                return profileTime(b) - profileTime(a);
+            }
+            else if (activationTime(a) || activationTime(b)) {
+                return activationTime(b) - activationTime(a);
+            }
+            return a.originalIndex - b.originalIndex;
+        });
+        return result;
+    }
+    createEditor(parent) {
+        parent.classList.add('runtime-extensions-editor');
+        const TEMPLATE_ID = 'runtimeExtensionElementTemplate';
+        const delegate = new class {
+            getHeight(element) {
+                return 70;
+            }
+            getTemplateId(element) {
+                return TEMPLATE_ID;
+            }
+        };
+        const renderer = {
+            templateId: TEMPLATE_ID,
+            renderTemplate: (root) => {
+                const element = append(root, $('.extension'));
+                const iconContainer = append(element, $('.icon-container'));
+                const icon = append(iconContainer, $('img.icon'));
+                const desc = append(element, $('div.desc'));
+                const headerContainer = append(desc, $('.header-container'));
+                const header = append(headerContainer, $('.header'));
+                const name = append(header, $('div.name'));
+                const version = append(header, $('span.version'));
+                const msgContainer = append(desc, $('div.msg'));
+                const actionbar = ( new ActionBar(desc));
+                actionbar.onDidRun(({ error }) => error && this._notificationService.error(error));
+                const timeContainer = append(element, $('.time'));
+                const activationTime = append(timeContainer, $('div.activation-time'));
+                const profileTime = append(timeContainer, $('div.profile-time'));
+                const disposables = [actionbar];
+                return {
+                    root,
+                    element,
+                    icon,
+                    name,
+                    version,
+                    actionbar,
+                    activationTime,
+                    profileTime,
+                    msgContainer,
+                    disposables,
+                    elementDisposables: [],
+                };
+            },
+            renderElement: (element, index, data) => {
+                data.elementDisposables = dispose(data.elementDisposables);
+                data.root.classList.toggle('odd', index % 2 === 1);
+                data.elementDisposables.push(addDisposableListener(data.icon, 'error', () => data.icon.src = element.marketplaceInfo?.iconUrlFallback || getDefaultIconPath(), { once: true }));
+                data.icon.src = element.marketplaceInfo?.iconUrl || getDefaultIconPath();
+                if (!data.icon.complete) {
+                    data.icon.style.visibility = 'hidden';
+                    data.icon.onload = () => data.icon.style.visibility = 'inherit';
+                }
+                else {
+                    data.icon.style.visibility = 'inherit';
+                }
+                data.name.textContent = (element.marketplaceInfo?.displayName || element.description.identifier.value).substr(0, 50);
+                data.version.textContent = element.description.version;
+                const activationTimes = element.status.activationTimes;
+                if (activationTimes) {
+                    const syncTime = activationTimes.codeLoadingTime + activationTimes.activateCallTime;
+                    data.activationTime.textContent = activationTimes.activationReason.startup ? `Startup Activation: ${syncTime}ms` : `Activation: ${syncTime}ms`;
+                }
+                else {
+                    data.activationTime.textContent = `Activating...`;
+                }
+                data.actionbar.clear();
+                const slowExtensionAction = this._createSlowExtensionAction(element);
+                if (slowExtensionAction) {
+                    data.actionbar.push(slowExtensionAction, { icon: false, label: true });
+                }
+                if (isNonEmptyArray(element.status.runtimeErrors)) {
+                    const reportExtensionIssueAction = this._createReportExtensionIssueAction(element);
+                    if (reportExtensionIssueAction) {
+                        data.actionbar.push(reportExtensionIssueAction, { icon: false, label: true });
+                    }
+                }
+                let title;
+                if (activationTimes) {
+                    const activationId = activationTimes.activationReason.extensionId.value;
+                    const activationEvent = activationTimes.activationReason.activationEvent;
+                    if (activationEvent === '*') {
+                        title = ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                            {
+                                key: 'starActivation',
+                                comment: [
+                                    '{0} will be an extension identifier'
+                                ]
+                            },
+                            "Activated by {0} on start-up",
+                            activationId
+                        ));
+                    }
+                    else if (/^workspaceContains:/.test(activationEvent)) {
+                        const fileNameOrGlob = activationEvent.substr('workspaceContains:'.length);
+                        if (fileNameOrGlob.indexOf('*') >= 0 || fileNameOrGlob.indexOf('?') >= 0) {
+                            title = ( localizeWithPath(
+                                'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                                {
+                                    key: 'workspaceContainsGlobActivation',
+                                    comment: [
+                                        '{0} will be a glob pattern',
+                                        '{1} will be an extension identifier'
+                                    ]
+                                },
+                                "Activated by {1} because a file matching {0} exists in your workspace",
+                                fileNameOrGlob,
+                                activationId
+                            ));
+                        }
+                        else {
+                            title = ( localizeWithPath(
+                                'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                                {
+                                    key: 'workspaceContainsFileActivation',
+                                    comment: [
+                                        '{0} will be a file name',
+                                        '{1} will be an extension identifier'
+                                    ]
+                                },
+                                "Activated by {1} because file {0} exists in your workspace",
+                                fileNameOrGlob,
+                                activationId
+                            ));
+                        }
+                    }
+                    else if (/^workspaceContainsTimeout:/.test(activationEvent)) {
+                        const glob = activationEvent.substr('workspaceContainsTimeout:'.length);
+                        title = ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                            {
+                                key: 'workspaceContainsTimeout',
+                                comment: [
+                                    '{0} will be a glob pattern',
+                                    '{1} will be an extension identifier'
+                                ]
+                            },
+                            "Activated by {1} because searching for {0} took too long",
+                            glob,
+                            activationId
+                        ));
+                    }
+                    else if (activationEvent === 'onStartupFinished') {
+                        title = ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                            {
+                                key: 'startupFinishedActivation',
+                                comment: [
+                                    'This refers to an extension. {0} will be an activation event.'
+                                ]
+                            },
+                            "Activated by {0} after start-up finished",
+                            activationId
+                        ));
+                    }
+                    else if (/^onLanguage:/.test(activationEvent)) {
+                        const language = activationEvent.substr('onLanguage:'.length);
+                        title = ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                            'languageActivation',
+                            "Activated by {1} because you opened a {0} file",
+                            language,
+                            activationId
+                        ));
+                    }
+                    else {
+                        title = ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                            {
+                                key: 'workspaceGenericActivation',
+                                comment: [
+                                    '{0} will be an activation event, like e.g. \'language:typescript\', \'debug\', etc.',
+                                    '{1} will be an extension identifier'
+                                ]
+                            },
+                            "Activated by {1} on {0}",
+                            activationEvent,
+                            activationId
+                        ));
+                    }
+                }
+                else {
+                    title = ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                        'extensionActivating',
+                        "Extension is activating..."
+                    ));
+                }
+                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`));
+                    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)) {
+                    const el = $('span', undefined, ...renderLabelWithIcons(`$(bug) ${( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                        'errors',
+                        "{0} uncaught errors",
+                        element.status.runtimeErrors.length
+                    ))}`));
+                    data.msgContainer.appendChild(el);
+                }
+                if (element.status.messages && element.status.messages.length > 0) {
+                    const el = $('span', undefined, ...renderLabelWithIcons(`$(alert) ${element.status.messages[0].message}`));
+                    data.msgContainer.appendChild(el);
+                }
+                let extraLabel = null;
+                if (element.status.runningLocation && element.status.runningLocation.equals(( new LocalWebWorkerRunningLocation(0)))) {
+                    extraLabel = `$(globe) web worker`;
+                }
+                else if (element.description.extensionLocation.scheme === Schemas.vscodeRemote) {
+                    const hostLabel = this._labelService.getHostLabel(Schemas.vscodeRemote, this._environmentService.remoteAuthority);
+                    if (hostLabel) {
+                        extraLabel = `$(remote) ${hostLabel}`;
+                    }
+                    else {
+                        extraLabel = `$(remote) ${element.description.extensionLocation.authority}`;
+                    }
+                }
+                else if (element.status.runningLocation && element.status.runningLocation.affinity > 0) {
+                    extraLabel = element.status.runningLocation instanceof LocalWebWorkerRunningLocation
+                        ? `$(globe) web worker ${element.status.runningLocation.affinity + 1}`
+                        : `$(server-process) local process ${element.status.runningLocation.affinity + 1}`;
+                }
+                if (extraLabel) {
+                    const el = $('span', undefined, ...renderLabelWithIcons(extraLabel));
+                    data.msgContainer.appendChild(el);
+                }
+                const features = ( Registry.as(Extensions.ExtensionFeaturesRegistry)).getExtensionFeatures();
+                for (const feature of features) {
+                    const accessData = this._extensionFeaturesManagementService.getAccessData(element.description.identifier, feature.id);
+                    if (accessData) {
+                        const status = accessData?.current?.status;
+                        if (status) {
+                            data.msgContainer.appendChild($('span', undefined, `${feature.label}: `));
+                            data.msgContainer.appendChild($('span', undefined, ...renderLabelWithIcons(`$(${status.severity === Severity.Error ? errorIcon.id : warningIcon.id}) ${status.message}`)));
+                        }
+                        if (accessData?.current) {
+                            const element = $('span', undefined, ( localizeWithPath(
+                                'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                                'requests count',
+                                "{0} Requests: {1} (Session)",
+                                feature.label,
+                                accessData.current.count
+                            )));
+                            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);
+                        }
+                    }
+                }
+                if (element.profileInfo) {
+                    data.profileTime.textContent = `Profile: ${(element.profileInfo.totalTime / 1000).toFixed(2)}ms`;
+                }
+                else {
+                    data.profileTime.textContent = '';
+                }
+            },
+            disposeTemplate: (data) => {
+                data.disposables = dispose(data.disposables);
+            }
+        };
+        this._list = this._instantiationService.createInstance(WorkbenchList, 'RuntimeExtensions', parent, delegate, [renderer], {
+            multipleSelectionSupport: false,
+            setRowLineHeight: false,
+            horizontalScrolling: false,
+            overrideStyles: {
+                listBackground: editorBackground
+            },
+            accessibilityProvider: new (class {
+                getWidgetAriaLabel() {
+                    return ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                        'runtimeExtensions',
+                        "Runtime Extensions"
+                    ));
+                }
+                getAriaLabel(element) {
+                    return element.description.name;
+                }
+            })
+        });
+        this._list.splice(0, this._list.length, this._elements || undefined);
+        this._list.onContextMenu((e) => {
+            if (!e.element) {
+                return;
+            }
+            const actions = [];
+            actions.push(( new Action('runtimeExtensionsEditor.action.copyId', ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                'copy id',
+                "Copy id ({0})",
+                e.element.description.identifier.value
+            )), undefined, true, () => {
+                this._clipboardService.writeText(e.element.description.identifier.value);
+            })));
+            const reportExtensionIssueAction = this._createReportExtensionIssueAction(e.element);
+            if (reportExtensionIssueAction) {
+                actions.push(reportExtensionIssueAction);
+            }
+            actions.push(( new Separator()));
+            if (e.element.marketplaceInfo) {
+                actions.push(( new Action('runtimeExtensionsEditor.action.disableWorkspace', ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                    'disable workspace',
+                    "Disable (Workspace)"
+                )), undefined, true, () => this._extensionsWorkbenchService.setEnablement(e.element.marketplaceInfo, 7 ))));
+                actions.push(( new Action('runtimeExtensionsEditor.action.disable', ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                    'disable',
+                    "Disable"
+                )), undefined, true, () => this._extensionsWorkbenchService.setEnablement(e.element.marketplaceInfo, 6 ))));
+            }
+            actions.push(( new Separator()));
+            const profileAction = this._createProfileAction();
+            if (profileAction) {
+                actions.push(profileAction);
+            }
+            const saveExtensionHostProfileAction = this.saveExtensionHostProfileAction;
+            if (saveExtensionHostProfileAction) {
+                actions.push(saveExtensionHostProfileAction);
+            }
+            this._contextMenuService.showContextMenu({
+                getAnchor: () => e.anchor,
+                getActions: () => actions
+            });
+        });
+    }
+    get saveExtensionHostProfileAction() {
+        return this._createSaveExtensionHostProfileAction();
+    }
+    layout(dimension) {
+        this._list?.layout(dimension.height);
+    }
+};
+AbstractRuntimeExtensionsEditor.__decorator = ( __decorate([
+    memoize
+], AbstractRuntimeExtensionsEditor.prototype, "saveExtensionHostProfileAction", null));
+AbstractRuntimeExtensionsEditor = AbstractRuntimeExtensionsEditor_1 = ( __decorate([
+    ( __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() {
+        super({
+            id: 'workbench.action.showRuntimeExtensions',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/extensions/browser/abstractRuntimeExtensionsEditor',
+                'showRuntimeExtensions',
+                "Show Running Extensions"
+            )),
+            category: Categories.Developer,
+            f1: true,
+            menu: {
+                id: MenuId.ViewContainerTitle,
+                when: ( ContextKeyExpr.equals('viewContainer', 'workbench.view.extensions')),
+                group: '2_enablement',
+                order: 3
+            }
+        });
+    }
+    async run(accessor) {
+        await accessor.get(IEditorService).openEditor(RuntimeExtensionsInput.instance, { pinned: true });
+    }
+}
+export { AbstractRuntimeExtensionsEditor, ShowRuntimeExtensionsAction };

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

@@ -0,0 +1,26 @@
+import { AbstractRuntimeExtensionsEditor } from './abstractRuntimeExtensionsEditor.js';
+import { ReportExtensionIssueAction } from '../common/reportExtensionIssueAction.js';
+class RuntimeExtensionsEditor extends AbstractRuntimeExtensionsEditor {
+    _getProfileInfo() {
+        return null;
+    }
+    _getUnresponsiveProfile(extensionId) {
+        return undefined;
+    }
+    _createSlowExtensionAction(element) {
+        return null;
+    }
+    _createReportExtensionIssueAction(element) {
+        if (element.marketplaceInfo) {
+            return this._instantiationService.createInstance(ReportExtensionIssueAction, element.description);
+        }
+        return null;
+    }
+    _createSaveExtensionHostProfileAction() {
+        return null;
+    }
+    _createProfileAction() {
+        return null;
+    }
+}
+export { RuntimeExtensionsEditor };

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

@@ -0,0 +1,76 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IExtensionTipsService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { ExtensionRecommendations } from './extensionRecommendations.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { Emitter } from '../../../../base/common/event.js';
+let ConfigBasedRecommendations = class ConfigBasedRecommendations extends ExtensionRecommendations {
+    get otherRecommendations() { return this._otherRecommendations; }
+    get importantRecommendations() { return this._importantRecommendations; }
+    get recommendations() { return [...this.importantRecommendations, ...this.otherRecommendations]; }
+    constructor(extensionTipsService, workspaceContextService) {
+        super();
+        this.extensionTipsService = extensionTipsService;
+        this.workspaceContextService = workspaceContextService;
+        this.importantTips = [];
+        this.otherTips = [];
+        this._onDidChangeRecommendations = this._register(( new Emitter()));
+        this.onDidChangeRecommendations = this._onDidChangeRecommendations.event;
+        this._otherRecommendations = [];
+        this._importantRecommendations = [];
+    }
+    async doActivate() {
+        await this.fetch();
+        this._register(this.workspaceContextService.onDidChangeWorkspaceFolders(e => this.onWorkspaceFoldersChanged(e)));
+    }
+    async fetch() {
+        const workspace = this.workspaceContextService.getWorkspace();
+        const importantTips = ( new Map());
+        const otherTips = ( new Map());
+        for (const folder of workspace.folders) {
+            const configBasedTips = await this.extensionTipsService.getConfigBasedTips(folder.uri);
+            for (const tip of configBasedTips) {
+                if (tip.important) {
+                    importantTips.set(tip.extensionId, tip);
+                }
+                else {
+                    otherTips.set(tip.extensionId, tip);
+                }
+            }
+        }
+        this.importantTips = [...( importantTips.values())];
+        this.otherTips = [...( otherTips.values())].filter(tip => !( importantTips.has(tip.extensionId)));
+        this._otherRecommendations = ( this.otherTips.map(tip => this.toExtensionRecommendation(tip)));
+        this._importantRecommendations = ( this.importantTips.map(tip => this.toExtensionRecommendation(tip)));
+    }
+    async onWorkspaceFoldersChanged(event) {
+        if (event.added.length) {
+            const oldImportantRecommended = this.importantTips;
+            await this.fetch();
+            if (( this.importantTips.some(
+                current => oldImportantRecommended.every(old => current.extensionId !== old.extensionId)
+            ))) {
+                this._onDidChangeRecommendations.fire();
+            }
+        }
+    }
+    toExtensionRecommendation(tip) {
+        return {
+            extension: tip.extensionId,
+            reason: {
+                reasonId: 3 ,
+                reasonText: ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/configBasedRecommendations',
+                    'exeBasedRecommendation',
+                    "This extension is recommended because of the current workspace configuration"
+                ))
+            },
+            whenNotInstalled: tip.whenNotInstalled
+        };
+    }
+};
+ConfigBasedRecommendations = ( __decorate([
+    ( __param(0, IExtensionTipsService)),
+    ( __param(1, IWorkspaceContextService))
+], ConfigBasedRecommendations));
+export { ConfigBasedRecommendations };