@theia/plugin-ext 1.43.1 → 1.45.0

package/src/common/test-types.ts

@@ -84,6 +84,7 @@ export interface TestMessageDTO {
     readonly actual?: string;
     readonly location?: Location;
     readonly message: string | MarkdownString;
+    readonly contextValue?: string;
 }
 
 export interface TestItemDTO {
@@ -131,3 +132,22 @@ export namespace TestItemReference {
     }
 }
 
+export interface TestMessageArg {
+    testItemReference: TestItemReference | undefined,
+    testMessage: TestMessageDTO
+}
+
+export namespace TestMessageArg {
+    export function is(arg: unknown): arg is TestMessageArg {
+        return isObject<TestMessageArg>(arg)
+            && isObject<TestMessageDTO>(arg.testMessage)
+            && (MarkdownString.is(arg.testMessage.message) || typeof arg.testMessage.message === 'string');
+    }
+
+    export function create(testItemReference: TestItemReference | undefined, testMessageDTO: TestMessageDTO): TestMessageArg {
+        return {
+            testItemReference: testItemReference,
+            testMessage: testMessageDTO
+        };
+    }
+}

package/src/hosted/browser/hosted-plugin.ts

@@ -80,6 +80,30 @@ export const ALL_ACTIVATION_EVENT = '*';
 @injectable()
 export class HostedPluginSupport {
 
+    protected static ADDITIONAL_ACTIVATION_EVENTS_ENV = 'ADDITIONAL_ACTIVATION_EVENTS';
+    protected static BUILTIN_ACTIVATION_EVENTS = [
+        '*',
+        'onLanguage',
+        'onCommand',
+        'onDebug',
+        'onDebugInitialConfigurations',
+        'onDebugResolve',
+        'onDebugAdapterProtocolTracker',
+        'onDebugDynamicConfigurations',
+        'onTaskType',
+        'workspaceContains',
+        'onView',
+        'onUri',
+        'onTerminalProfile',
+        'onWebviewPanel',
+        'onFileSystem',
+        'onCustomEditor',
+        'onStartupFinished',
+        'onAuthenticationRequest',
+        'onNotebook',
+        'onNotebookSerializer'
+    ];
+
     protected readonly clientId = UUID.uuid4();
 
     protected container: interfaces.Container;
@@ -377,8 +401,12 @@ export class HostedPluginSupport {
                 waitPluginsMeasurement.error('Backend deployment failed.');
             }
         }
-
-        syncPluginsMeasurement?.log(`Sync of ${this.getPluginCount(initialized)}`);
+        if (initialized > 0) {
+            // Only log sync measurement if there are were plugins to sync.
+            syncPluginsMeasurement?.log(`Sync of ${this.getPluginCount(initialized)}`);
+        } else {
+            syncPluginsMeasurement.stop();
+        }
     }
 
     /**
@@ -416,8 +444,12 @@ export class HostedPluginSupport {
                 }));
             }
         }
-
-        loadPluginsMeasurement.log(`Load contributions of ${this.getPluginCount(loaded)}`);
+        if (loaded > 0) {
+            // Only log load measurement if there are were plugins to load.
+            loadPluginsMeasurement?.log(`Load contributions of ${this.getPluginCount(loaded)}`);
+        } else {
+            loadPluginsMeasurement.stop();
+        }
 
         return hostContributions;
     }
@@ -488,7 +520,11 @@ export class HostedPluginSupport {
             return;
         }
 
-        startPluginsMeasurement.log(`Start of ${this.getPluginCount(started)}`);
+        if (started > 0) {
+            startPluginsMeasurement.log(`Start of ${this.getPluginCount(started)}`);
+        } else {
+            startPluginsMeasurement.stop();
+        }
     }
 
     protected async obtainManager(host: string, hostContributions: PluginContributions[], toDisconnect: DisposableCollection): Promise<PluginManagerExt | undefined> {
@@ -519,6 +555,13 @@ export class HostedPluginSupport {
             }
 
             const isElectron = environment.electron.is();
+
+            const supportedActivationEvents = [...HostedPluginSupport.BUILTIN_ACTIVATION_EVENTS];
+            const additionalActivationEvents = await this.envServer.getValue(HostedPluginSupport.ADDITIONAL_ACTIVATION_EVENTS_ENV);
+            if (additionalActivationEvents && additionalActivationEvents.value) {
+                additionalActivationEvents.value.split(',').forEach(event => supportedActivationEvents.push(event));
+            }
+
             await manager.$init({
                 preferences: getPreferences(this.preferenceProviderProvider, this.workspaceService.tryGetRoots()),
                 globalState,
@@ -536,11 +579,13 @@ export class HostedPluginSupport {
                     webviewResourceRoot,
                     webviewCspSource
                 },
-                jsonValidation
+                jsonValidation,
+                supportedActivationEvents
             });
             if (toDisconnect.disposed) {
                 return undefined;
             }
+            this.activationEvents.forEach(event => manager!.$activateByEvent(event));
         }
         return manager;
     }

package/src/hosted/node/hosted-plugin-deployer-handler.ts

@@ -76,6 +76,13 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         return Array.from(this.deployedBackendPlugins.keys());
     }
 
+    async getDeployedBackendPlugins(): Promise<DeployedPlugin[]> {
+        // await first deploy
+        await this.backendPluginsMetadataDeferred.promise;
+        // fetch the last deployed state
+        return Array.from(this.deployedBackendPlugins.values());
+    }
+
     getDeployedPluginsById(pluginId: string): DeployedPlugin[] {
         const matches: DeployedPlugin[] = [];
         const handle = (plugins: Iterable<DeployedPlugin>): void => {

package/src/hosted/node/plugin-activation-events.ts

@@ -20,6 +20,7 @@ import {
     PluginPackage,
     PluginPackageAuthenticationProvider,
     PluginPackageCommand,
+    PluginPackageContribution,
     PluginPackageCustomEditor,
     PluginPackageLanguageContribution,
     PluginPackageNotebook,
@@ -31,7 +32,7 @@ import {
  * This function will update the manifest based on the plugin contributions.
  */
 export function updateActivationEvents(manifest: PluginPackage): void {
-    if (!isObject(manifest) || !isObject(manifest.contributes) || !manifest.contributes) {
+    if (!isObject<PluginPackage>(manifest) || !isObject<PluginPackageContribution>(manifest.contributes) || !manifest.contributes) {
         return;
     }
 
@@ -42,8 +43,8 @@ export function updateActivationEvents(manifest: PluginPackage): void {
         const commands = Array.isArray(value) ? value : [value];
         updateCommandsContributions(commands, activationEvents);
     }
-    if (Array.isArray(manifest.contributes.views)) {
-        const views = flatten(Object.values(manifest.contributes.views)) as PluginPackageView[];
+    if (isObject(manifest.contributes.views)) {
+        const views = flatten(Object.values(manifest.contributes.views));
         updateViewsContribution(views, activationEvents);
     }
     if (Array.isArray(manifest.contributes.customEditors)) {
@@ -64,7 +65,7 @@ export function updateActivationEvents(manifest: PluginPackage): void {
 
 function updateViewsContribution(views: PluginPackageView[], activationEvents: Set<string>): void {
     for (const view of views) {
-        if (isObject(view) && typeof view.id === 'string') {
+        if (isObject<PluginPackageView>(view) && typeof view.id === 'string') {
             activationEvents.add(`onView:${view.id}`);
         }
     }
@@ -72,7 +73,7 @@ function updateViewsContribution(views: PluginPackageView[], activationEvents: S
 
 function updateCustomEditorsContribution(customEditors: PluginPackageCustomEditor[], activationEvents: Set<string>): void {
     for (const customEditor of customEditors) {
-        if (isObject(customEditor) && typeof customEditor.viewType === 'string') {
+        if (isObject<PluginPackageCustomEditor>(customEditor) && typeof customEditor.viewType === 'string') {
             activationEvents.add(`onCustomEditor:${customEditor.viewType}`);
         }
     }
@@ -80,7 +81,7 @@ function updateCustomEditorsContribution(customEditors: PluginPackageCustomEdito
 
 function updateCommandsContributions(commands: PluginPackageCommand[], activationEvents: Set<string>): void {
     for (const command of commands) {
-        if (isObject(command) && typeof command.command === 'string') {
+        if (isObject<PluginPackageCommand>(command) && typeof command.command === 'string') {
             activationEvents.add(`onCommand:${command.command}`);
         }
     }
@@ -88,7 +89,7 @@ function updateCommandsContributions(commands: PluginPackageCommand[], activatio
 
 function updateAuthenticationProviderContributions(authProviders: PluginPackageAuthenticationProvider[], activationEvents: Set<string>): void {
     for (const authProvider of authProviders) {
-        if (isObject(authProvider) && typeof authProvider.id === 'string') {
+        if (isObject<PluginPackageAuthenticationProvider>(authProvider) && typeof authProvider.id === 'string') {
             activationEvents.add(`onAuthenticationRequest:${authProvider.id}`);
         }
     }
@@ -96,7 +97,7 @@ function updateAuthenticationProviderContributions(authProviders: PluginPackageA
 
 function updateLanguageContributions(languages: PluginPackageLanguageContribution[], activationEvents: Set<string>): void {
     for (const language of languages) {
-        if (isObject(language) && typeof language.id === 'string') {
+        if (isObject<PluginPackageLanguageContribution>(language) && typeof language.id === 'string') {
             activationEvents.add(`onLanguage:${language.id}`);
         }
     }
@@ -104,7 +105,7 @@ function updateLanguageContributions(languages: PluginPackageLanguageContributio
 
 function updateNotebookContributions(notebooks: PluginPackageNotebook[], activationEvents: Set<string>): void {
     for (const notebook of notebooks) {
-        if (isObject(notebook) && typeof notebook.type === 'string') {
+        if (isObject<PluginPackageNotebook>(notebook) && typeof notebook.type === 'string') {
             activationEvents.add(`onNotebookSerializer:${notebook.type}`);
         }
     }

package/src/hosted/node/scanners/scanner-theia.ts

@@ -79,18 +79,6 @@ import { ColorDefinition } from '@theia/core/lib/common/color';
 import { CSSIcon } from '@theia/core/lib/common/markdown-rendering/icon-utilities';
 import { PluginUriFactory } from './plugin-uri-factory';
 
-namespace nls {
-    export function localize(key: string, _default: string): string {
-        return _default;
-    }
-}
-
-const INTERNAL_CONSOLE_OPTIONS_SCHEMA = {
-    enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart'],
-    default: 'openOnFirstSessionStart',
-    description: nls.localize('internalConsoleOptions', 'Controls when the internal debug console should open.')
-};
-
 const colorIdPattern = '^\\w+[.\\w+]*$';
 const iconIdPattern = `^${CSSIcon.iconNameSegment}(-${CSSIcon.iconNameSegment})+$`;
 
@@ -371,7 +359,7 @@ export class TheiaPluginScanner implements PluginScanner {
         }
 
         const [languagesResult, grammarsResult] = await Promise.allSettled([
-            rawPlugin.contributes.languages ? this.readLanguages(rawPlugin.contributes.languages, rawPlugin.packagePath) : undefined,
+            rawPlugin.contributes.languages ? this.readLanguages(rawPlugin.contributes.languages, rawPlugin) : undefined,
             rawPlugin.contributes.grammars ? this.grammarsReader.readGrammars(rawPlugin.contributes.grammars, rawPlugin.packagePath) : undefined
         ]);
 
@@ -723,8 +711,8 @@ export class TheiaPluginScanner implements PluginScanner {
         return result;
     }
 
-    private async readLanguages(rawLanguages: PluginPackageLanguageContribution[], pluginPath: string): Promise<LanguageContribution[]> {
-        return Promise.all(rawLanguages.map(language => this.readLanguage(language, pluginPath)));
+    private async readLanguages(rawLanguages: PluginPackageLanguageContribution[], plugin: PluginPackage): Promise<LanguageContribution[]> {
+        return Promise.all(rawLanguages.map(language => this.readLanguage(language, plugin)));
     }
 
     private readSubmenus(rawSubmenus: PluginPackageSubmenu[], plugin: PluginPackage): Submenu[] {
@@ -741,8 +729,9 @@ export class TheiaPluginScanner implements PluginScanner {
 
     }
 
-    private async readLanguage(rawLang: PluginPackageLanguageContribution, pluginPath: string): Promise<LanguageContribution> {
+    private async readLanguage(rawLang: PluginPackageLanguageContribution, plugin: PluginPackage): Promise<LanguageContribution> {
         // TODO: add validation to all parameters
+        const icon = this.transformIconUrl(plugin, rawLang.icon);
         const result: LanguageContribution = {
             id: rawLang.id,
             aliases: rawLang.aliases,
@@ -750,10 +739,11 @@ export class TheiaPluginScanner implements PluginScanner {
             filenamePatterns: rawLang.filenamePatterns,
             filenames: rawLang.filenames,
             firstLine: rawLang.firstLine,
-            mimetypes: rawLang.mimetypes
+            mimetypes: rawLang.mimetypes,
+            icon: icon?.iconUrl ?? icon?.themeIcon
         };
         if (rawLang.configuration) {
-            const rawConfiguration = await this.readJson<PluginPackageLanguageContributionConfiguration>(path.resolve(pluginPath, rawLang.configuration));
+            const rawConfiguration = await this.readJson<PluginPackageLanguageContributionConfiguration>(path.resolve(plugin.packagePath, rawLang.configuration));
             if (rawConfiguration) {
                 const configuration: LanguageConfiguration = {
                     brackets: rawConfiguration.brackets,
@@ -793,12 +783,10 @@ export class TheiaPluginScanner implements PluginScanner {
             program: rawDebugger.program,
             args: rawDebugger.args,
             runtime: rawDebugger.runtime,
-            runtimeArgs: rawDebugger.runtimeArgs
+            runtimeArgs: rawDebugger.runtimeArgs,
+            configurationAttributes: rawDebugger.configurationAttributes
         };
 
-        result.configurationAttributes = rawDebugger.configurationAttributes
-            && this.resolveSchemaAttributes(rawDebugger.type, rawDebugger.configurationAttributes);
-
         return result;
     }
 
@@ -827,85 +815,6 @@ export class TheiaPluginScanner implements PluginScanner {
         return schema;
     }
 
-    protected resolveSchemaAttributes(type: string, configurationAttributes: { [request: string]: IJSONSchema }): IJSONSchema[] {
-        const taskSchema = {};
-        return Object.keys(configurationAttributes).map(request => {
-            const attributes: IJSONSchema = deepClone(configurationAttributes[request]);
-            const defaultRequired = ['name', 'type', 'request'];
-            attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
-            attributes.additionalProperties = false;
-            attributes.type = 'object';
-            if (!attributes.properties) {
-                attributes.properties = {};
-            }
-            const properties = attributes.properties;
-            properties['type'] = {
-                enum: [type],
-                description: nls.localize('debugType', 'Type of configuration.'),
-                pattern: '^(?!node2)',
-                errorMessage: nls.localize('debugTypeNotRecognised',
-                    'The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled.'),
-                patternErrorMessage: nls.localize('node2NotSupported',
-                    '"node2" is no longer supported, use "node" instead and set the "protocol" attribute to "inspector".')
-            };
-            properties['name'] = {
-                type: 'string',
-                description: nls.localize('debugName', 'Name of configuration; appears in the launch configuration drop down menu.'),
-                default: 'Launch'
-            };
-            properties['request'] = {
-                enum: [request],
-                description: nls.localize('debugRequest', 'Request type of configuration. Can be "launch" or "attach".'),
-            };
-            properties['debugServer'] = {
-                type: 'number',
-                description: nls.localize('debugServer',
-                    'For debug extension development only: if a port is specified VS Code tries to connect to a debug adapter running in server mode'),
-                default: 4711
-            };
-            properties['preLaunchTask'] = {
-                anyOf: [taskSchema, {
-                    type: ['string'],
-                }],
-                default: '',
-                description: nls.localize('debugPrelaunchTask', 'Task to run before debug session starts.')
-            };
-            properties['postDebugTask'] = {
-                anyOf: [taskSchema, {
-                    type: ['string'],
-                }],
-                default: '',
-                description: nls.localize('debugPostDebugTask', 'Task to run after debug session ends.')
-            };
-            properties['internalConsoleOptions'] = INTERNAL_CONSOLE_OPTIONS_SCHEMA;
-
-            const osProperties = Object.assign({}, properties);
-            properties['windows'] = {
-                type: 'object',
-                description: nls.localize('debugWindowsConfiguration', 'Windows specific launch configuration attributes.'),
-                properties: osProperties
-            };
-            properties['osx'] = {
-                type: 'object',
-                description: nls.localize('debugOSXConfiguration', 'OS X specific launch configuration attributes.'),
-                properties: osProperties
-            };
-            properties['linux'] = {
-                type: 'object',
-                description: nls.localize('debugLinuxConfiguration', 'Linux specific launch configuration attributes.'),
-                properties: osProperties
-            };
-            Object.keys(attributes.properties).forEach(name => {
-                // Use schema allOf property to get independent error reporting #21113
-                attributes!.properties![name].pattern = attributes!.properties![name].pattern || '^(?!.*\\$\\{(env|config|command)\\.)';
-                attributes!.properties![name].patternErrorMessage = attributes!.properties![name].patternErrorMessage ||
-                    nls.localize('deprecatedVariables', "'env.', 'config.' and 'command.' are deprecated, use 'env:', 'config:' and 'command:' instead.");
-            });
-
-            return attributes;
-        });
-    }
-
     private extractValidAutoClosingPairs(langId: string, configuration: PluginPackageLanguageContributionConfiguration): AutoClosingPairConditional[] | undefined {
         const source = configuration.autoClosingPairs;
         if (typeof source === 'undefined') {

package/src/main/browser/debug/plugin-debug-service.ts

@@ -16,7 +16,7 @@
 
 import { DebuggerDescription, DebugPath, DebugService } from '@theia/debug/lib/common/debug-service';
 import debounce = require('@theia/core/shared/lodash.debounce');
-import { Emitter, Event } from '@theia/core';
+import { deepClone, Emitter, Event, nls } from '@theia/core';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { DebugConfiguration } from '@theia/debug/lib/common/debug-configuration';
 import { IJSONSchema, IJSONSchemaSnippet } from '@theia/core/lib/common/json-schema';
@@ -97,6 +97,13 @@ export class PluginDebugService implements DebugService {
     }, 100);
 
     registerDebugConfigurationProvider(provider: PluginDebugConfigurationProvider): Disposable {
+        if (this.configurationProviders.has(provider.handle)) {
+            const configuration = this.configurationProviders.get(provider.handle);
+            if (configuration && configuration.type !== provider.type) {
+                console.warn(`Different debug configuration provider with type '${configuration.type}' already registered.`);
+                provider.handle = this.configurationProviders.size;
+            }
+        }
         const handle = provider.handle;
         this.configurationProviders.set(handle, provider);
         this.fireOnDidConfigurationProvidersChanged();
@@ -293,12 +300,94 @@ export class PluginDebugService implements DebugService {
         for (const contribution of this.debuggers) {
             if (contribution.configurationAttributes &&
                 (contribution.type === debugType || contribution.type === '*' || debugType === '*')) {
-                schemas = schemas.concat(contribution.configurationAttributes);
+                schemas = schemas.concat(this.resolveSchemaAttributes(contribution.type, contribution.configurationAttributes));
             }
         }
         return schemas;
     }
 
+    protected resolveSchemaAttributes(type: string, configurationAttributes: { [request: string]: IJSONSchema }): IJSONSchema[] {
+        const taskSchema = {};
+        return Object.keys(configurationAttributes).map(request => {
+            const attributes: IJSONSchema = deepClone(configurationAttributes[request]);
+            const defaultRequired = ['name', 'type', 'request'];
+            attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
+            attributes.additionalProperties = false;
+            attributes.type = 'object';
+            if (!attributes.properties) {
+                attributes.properties = {};
+            }
+            const properties = attributes.properties;
+            properties['type'] = {
+                enum: [type],
+                description: nls.localizeByDefault('Type of configuration.'),
+                pattern: '^(?!node2)',
+                errorMessage: nls.localizeByDefault('The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled.'),
+                patternErrorMessage: nls.localizeByDefault('"node2" is no longer supported, use "node" instead and set the "protocol" attribute to "inspector".')
+            };
+            properties['name'] = {
+                type: 'string',
+                description: nls.localizeByDefault('Name of configuration; appears in the launch configuration dropdown menu.'),
+                default: 'Launch'
+            };
+            properties['request'] = {
+                enum: [request],
+                description: nls.localizeByDefault('Request type of configuration. Can be "launch" or "attach".'),
+            };
+            properties['debugServer'] = {
+                type: 'number',
+                description: nls.localizeByDefault(
+                    'For debug extension development only: if a port is specified VS Code tries to connect to a debug adapter running in server mode'
+                ),
+                default: 4711
+            };
+            properties['preLaunchTask'] = {
+                anyOf: [taskSchema, {
+                    type: ['string'],
+                }],
+                default: '',
+                description: nls.localizeByDefault('Task to run before debug session starts.')
+            };
+            properties['postDebugTask'] = {
+                anyOf: [taskSchema, {
+                    type: ['string'],
+                }],
+                default: '',
+                description: nls.localizeByDefault('Task to run after debug session ends.')
+            };
+            properties['internalConsoleOptions'] = {
+                enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart'],
+                default: 'openOnFirstSessionStart',
+                description: nls.localizeByDefault('Controls when the internal Debug Console should open.')
+            };
+
+            const osProperties = Object.assign({}, properties);
+            properties['windows'] = {
+                type: 'object',
+                description: nls.localizeByDefault('Windows specific launch configuration attributes.'),
+                properties: osProperties
+            };
+            properties['osx'] = {
+                type: 'object',
+                description: nls.localizeByDefault('OS X specific launch configuration attributes.'),
+                properties: osProperties
+            };
+            properties['linux'] = {
+                type: 'object',
+                description: nls.localizeByDefault('Linux specific launch configuration attributes.'),
+                properties: osProperties
+            };
+            Object.keys(attributes.properties).forEach(name => {
+                // Use schema allOf property to get independent error reporting #21113
+                attributes!.properties![name].pattern = attributes!.properties![name].pattern || '^(?!.*\\$\\{(env|config|command)\\.)';
+                attributes!.properties![name].patternErrorMessage = attributes!.properties![name].patternErrorMessage ||
+                    nls.localizeByDefault("'env.', 'config.' and 'command.' are deprecated, use 'env:', 'config:' and 'command:' instead.");
+            });
+
+            return attributes;
+        });
+    }
+
     async getConfigurationSnippets(): Promise<IJSONSchemaSnippet[]> {
         let snippets = await this.delegated.getConfigurationSnippets();
 

package/src/main/browser/languages-main.ts

@@ -167,6 +167,7 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
             wordPattern: reviveRegExp(configuration.wordPattern),
             indentationRules: reviveIndentationRule(configuration.indentationRules),
             onEnterRules: reviveOnEnterRules(configuration.onEnterRules),
+            autoClosingPairs: configuration.autoClosingPairs
         };
 
         this.register(handle, monaco.languages.setLanguageConfiguration(languageId, config));

package/src/main/browser/menus/plugin-menu-command-adapter.ts

@@ -23,10 +23,13 @@ import { ScmRepository } from '@theia/scm/lib/browser/scm-repository';
 import { ScmService } from '@theia/scm/lib/browser/scm-service';
 import { TimelineItem } from '@theia/timeline/lib/common/timeline-model';
 import { ScmCommandArg, TimelineCommandArg, TreeViewItemReference } from '../../../common';
+import { TestItemReference, TestMessageArg } from '../../../common/test-types';
 import { PluginScmProvider, PluginScmResource, PluginScmResourceGroup } from '../scm-main';
 import { TreeViewWidget } from '../view/tree-view-widget';
 import { CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint } from './vscode-theia-menu-mappings';
 import { TAB_BAR_TOOLBAR_CONTEXT_MENU } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+import { TestItem, TestMessage } from '@theia/test/lib/browser/test-service';
+import { fromLocation } from '../hierarchy/hierarchy-types-converters';
 
 export type ArgumentAdapter = (...args: unknown[]) => unknown[];
 
@@ -79,6 +82,7 @@ export class PluginMenuCommandAdapter implements MenuCommandAdapter {
     @postConstruct()
     protected init(): void {
         const toCommentArgs: ArgumentAdapter = (...args) => this.toCommentArgs(...args);
+        const toTestMessageArgs: ArgumentAdapter = (...args) => this.toTestMessageArgs(...args);
         const firstArgOnly: ArgumentAdapter = (...args) => [args[0]];
         const noArgs: ArgumentAdapter = () => [];
         const toScmArgs: ArgumentAdapter = (...args) => this.toScmArgs(...args);
@@ -100,9 +104,11 @@ export class PluginMenuCommandAdapter implements MenuCommandAdapter {
             ['scm/resourceGroup/context', toScmArgs],
             ['scm/resourceState/context', toScmArgs],
             ['scm/title', () => [this.toScmArg(this.scmService.selectedRepository)]],
+            ['testing/message/context', toTestMessageArgs],
             ['timeline/item/context', (...args) => this.toTimelineArgs(...args)],
             ['view/item/context', (...args) => this.toTreeArgs(...args)],
             ['view/title', noArgs],
+            ['webview/context', noArgs]
         ]).forEach(([contributionPoint, adapter]) => {
             if (adapter) {
                 const paths = codeToTheiaMappings.get(contributionPoint);
@@ -229,6 +235,30 @@ export class PluginMenuCommandAdapter implements MenuCommandAdapter {
         return timelineArgs;
     }
 
+    protected toTestMessageArgs(...args: any[]): any[] {
+        let testItem: TestItem | undefined;
+        let testMessage: TestMessage | undefined;
+        for (const arg of args) {
+            if (TestItem.is(arg)) {
+                testItem = arg;
+            } else if (Array.isArray(arg) && TestMessage.is(arg[0])) {
+                testMessage = arg[0];
+            }
+        }
+        if (testMessage) {
+            const testItemReference = (testItem && testItem.controller) ? TestItemReference.create(testItem.controller.id, testItem.path) : undefined;
+            const testMessageDTO = {
+                message: testMessage.message,
+                actual: testMessage.actual,
+                expected: testMessage.expected,
+                contextValue: testMessage.contextValue,
+                location: testMessage.location ? fromLocation(testMessage.location) : undefined
+            };
+            return [TestMessageArg.create(testItemReference, testMessageDTO)];
+        }
+        return [];
+    }
+
     protected toTimelineArg(arg: TimelineItem): TimelineCommandArg {
         return {
             timelineHandle: arg.handle,

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -29,9 +29,10 @@ import { ScmTreeWidget } from '@theia/scm/lib/browser/scm-tree-widget';
 import { TIMELINE_ITEM_CONTEXT_MENU } from '@theia/timeline/lib/browser/timeline-tree-widget';
 import { COMMENT_CONTEXT, COMMENT_THREAD_CONTEXT, COMMENT_TITLE } from '../comments/comment-thread-widget';
 import { VIEW_ITEM_CONTEXT_MENU } from '../view/tree-view-widget';
-import { WebviewWidget } from '../webview/webview';
+import { WEBVIEW_CONTEXT_MENU, WebviewWidget } from '../webview/webview';
 import { EDITOR_LINENUMBER_CONTEXT_MENU } from '@theia/editor/lib/browser/editor-linenumber-contribution';
 import { TEST_VIEW_CONTEXT_MENU } from '@theia/test/lib/browser/view/test-view-contribution';
+import { TEST_RUNS_CONTEXT_MENU } from '@theia/test/lib/browser/view/test-run-view-contribution';
 
 export const PLUGIN_EDITOR_TITLE_MENU = ['plugin_editor/title'];
 export const PLUGIN_EDITOR_TITLE_RUN_MENU = ['plugin_editor/title/run'];
@@ -57,8 +58,10 @@ export const implementedVSCodeContributionPoints = [
     'scm/title',
     'timeline/item/context',
     'testing/item/context',
+    'testing/message/context',
     'view/item/context',
-    'view/title'
+    'view/title',
+    'webview/context'
 ] as const;
 
 export type ContributionPoint = (typeof implementedVSCodeContributionPoints)[number];
@@ -82,9 +85,11 @@ export const codeToTheiaMappings = new Map<ContributionPoint, MenuPath[]>([
     ['scm/resourceState/context', [ScmTreeWidget.RESOURCE_CONTEXT_MENU]],
     ['scm/title', [PLUGIN_SCM_TITLE_MENU]],
     ['testing/item/context', [TEST_VIEW_CONTEXT_MENU]],
+    ['testing/message/context', [TEST_RUNS_CONTEXT_MENU]],
     ['timeline/item/context', [TIMELINE_ITEM_CONTEXT_MENU]],
     ['view/item/context', [VIEW_ITEM_CONTEXT_MENU]],
     ['view/title', [PLUGIN_VIEW_TITLE_MENU]],
+    ['webview/context', [WEBVIEW_CONTEXT_MENU]]
 ]);
 
 type CodeEditorWidget = EditorWidget | WebviewWidget;