@theia/plugin-ext 1.40.1 → 1.41.0

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

@@ -69,6 +69,7 @@ import { LanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/
 import { Measurement, Stopwatch } from '@theia/core/lib/common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '@theia/core/lib/common/message-rpc/uint8-array-message-buffer';
 import { BasicChannel } from '@theia/core/lib/common/message-rpc/channel';
+import { NotebookTypeRegistry, NotebookService } from '@theia/notebook/lib/browser';
 
 export type PluginHost = 'frontend' | string;
 export type DebugActivationEvent = 'onDebugResolve' | 'onDebugInitialConfigurations' | 'onDebugAdapterProtocolTracker' | 'onDebugDynamicConfigurations';
@@ -114,6 +115,9 @@ export class HostedPluginSupport {
     @inject(WorkspaceService)
     protected readonly workspaceService: WorkspaceService;
 
+    @inject(NotebookService)
+    protected readonly notebookService: NotebookService;
+
     @inject(CommandRegistry)
     protected readonly commands: CommandRegistry;
 
@@ -132,6 +136,9 @@ export class HostedPluginSupport {
     @inject(FrontendApplicationStateService)
     protected readonly appState: FrontendApplicationStateService;
 
+    @inject(NotebookTypeRegistry)
+    protected readonly notebookTypeRegistry: NotebookTypeRegistry;
+
     @inject(PluginViewRegistry)
     protected readonly viewRegistry: PluginViewRegistry;
 
@@ -216,6 +223,7 @@ export class HostedPluginSupport {
         this.taskResolverRegistry.onWillProvideTaskResolver(event => this.ensureTaskActivation(event));
         this.fileService.onWillActivateFileSystemProvider(event => this.ensureFileSystemActivation(event));
         this.customEditorRegistry.onWillOpenCustomEditor(event => this.activateByCustomEditor(event));
+        this.notebookService.onWillOpenNotebook(async event => this.activateByNotebook(event));
 
         this.widgets.onDidCreateWidget(({ factoryId, widget }) => {
             if ((factoryId === WebviewWidget.FACTORY_ID || factoryId === CustomEditorWidget.FACTORY_ID) && widget instanceof WebviewWidget) {
@@ -304,8 +312,6 @@ export class HostedPluginSupport {
         await this.startPlugins(contributionsByHost, toDisconnect);
 
         this.deferredDidStart.resolve();
-
-        this.restoreWebviews();
     }
 
     /**
@@ -623,6 +629,10 @@ export class HostedPluginSupport {
         await this.activateByEvent(`onCustomEditor:${viewType}`);
     }
 
+    async activateByNotebook(viewType: string): Promise<void> {
+        await this.activateByEvent(`onNotebook:${viewType}`);
+    }
+
     activateByFileSystem(event: FileSystemProviderActivationEvent): Promise<void> {
         return this.activateByEvent(`onFileSystem:${event.scheme}`);
     }
@@ -757,7 +767,7 @@ export class HostedPluginSupport {
         return `${plugins} plugin${plugins === 1 ? '' : 's'}`;
     }
 
-    protected readonly webviewsToRestore = new Set<WebviewWidget>();
+    protected readonly webviewsToRestore = new Map<string, WebviewWidget>();
     protected readonly webviewRevivers = new Map<string, (webview: WebviewWidget) => Promise<void>>();
 
     registerWebviewReviver(viewType: string, reviver: (webview: WebviewWidget) => Promise<void>): void {
@@ -765,6 +775,10 @@ export class HostedPluginSupport {
             throw new Error(`Reviver for ${viewType} already registered`);
         }
         this.webviewRevivers.set(viewType, reviver);
+
+        if (this.webviewsToRestore.has(viewType)) {
+            this.restoreWebview(this.webviewsToRestore.get(viewType) as WebviewWidget);
+        }
     }
 
     unregisterWebviewReviver(viewType: string): void {
@@ -785,21 +799,14 @@ export class HostedPluginSupport {
     }
 
     protected preserveWebview(webview: WebviewWidget): void {
-        if (!this.webviewsToRestore.has(webview)) {
-            this.webviewsToRestore.add(webview);
-            webview.disposed.connect(() => this.webviewsToRestore.delete(webview));
-        }
-    }
-
-    protected restoreWebviews(): void {
-        for (const webview of this.webviewsToRestore) {
-            this.restoreWebview(webview);
+        if (!this.webviewsToRestore.has(webview.viewType)) {
+            this.activateByEvent(`onWebviewPanel:${webview.viewType}`);
+            this.webviewsToRestore.set(webview.viewType, webview);
+            webview.disposed.connect(() => this.webviewsToRestore.delete(webview.viewType));
         }
-        this.webviewsToRestore.clear();
     }
 
     protected async restoreWebview(webview: WebviewWidget): Promise<void> {
-        await this.activateByEvent(`onWebviewPanel:${webview.viewType}`);
         const restore = this.webviewRevivers.get(webview.viewType);
         if (restore) {
             try {

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

@@ -173,7 +173,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
 
             const { type } = entry;
             const deployed: DeployedPlugin = { metadata, type };
-            deployed.contributes = this.reader.readContribution(manifest);
+            deployed.contributes = await this.reader.readContribution(manifest);
             await this.localizationService.deployLocalizations(deployed);
             deployedPlugins.set(id, deployed);
             deployPlugin.debug(`Deployed ${entryPoint} plugin "${id}" from "${metadata.model.entryPoint[entryPoint] || pluginPath}"`);

package/src/hosted/node/plugin-reader.ts

@@ -118,7 +118,7 @@ export class HostedPluginReader implements BackendApplicationContribution {
         return pluginMetadata;
     }
 
-    readContribution(plugin: PluginPackage): PluginContribution | undefined {
+    async readContribution(plugin: PluginPackage): Promise<PluginContribution | undefined> {
         const scanner = this.scanner.getScanner(plugin);
         return scanner.getContribution(plugin);
     }

package/src/hosted/node/scanners/grammars-reader.ts

@@ -22,10 +22,10 @@ import * as fs from '@theia/core/shared/fs-extra';
 @injectable()
 export class GrammarsReader {
 
-    readGrammars(rawGrammars: PluginPackageGrammarsContribution[], pluginPath: string): GrammarsContribution[] {
+    async readGrammars(rawGrammars: PluginPackageGrammarsContribution[], pluginPath: string): Promise<GrammarsContribution[]> {
         const result = new Array<GrammarsContribution>();
         for (const rawGrammar of rawGrammars) {
-            const grammar = this.readGrammar(rawGrammar, pluginPath);
+            const grammar = await this.readGrammar(rawGrammar, pluginPath);
             if (grammar) {
                 result.push(grammar);
             }
@@ -34,13 +34,14 @@ export class GrammarsReader {
         return result;
     }
 
-    private readGrammar(rawGrammar: PluginPackageGrammarsContribution, pluginPath: string): GrammarsContribution | undefined {
+    private async readGrammar(rawGrammar: PluginPackageGrammarsContribution, pluginPath: string): Promise<GrammarsContribution | undefined> {
         // TODO: validate inputs
         let grammar: string | object;
+
         if (rawGrammar.path.endsWith('json')) {
-            grammar = fs.readJSONSync(path.resolve(pluginPath, rawGrammar.path));
+            grammar = await fs.readJSON(path.resolve(pluginPath, rawGrammar.path));
         } else {
-            grammar = fs.readFileSync(path.resolve(pluginPath, rawGrammar.path), 'utf8');
+            grammar = await fs.readFile(path.resolve(pluginPath, rawGrammar.path), 'utf8');
         }
         return {
             language: rawGrammar.language,

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

@@ -62,11 +62,12 @@ import {
     PluginIdentifiers,
     TerminalProfile
 } from '../../../common/plugin-protocol';
-import * as fs from 'fs';
+import { promises as fs } from 'fs';
 import * as path from 'path';
 import { isObject, isStringArray, RecursivePartial } from '@theia/core/lib/common/types';
 import { GrammarsReader } from './grammars-reader';
 import { CharacterPair } from '../../../common/plugin-api-rpc';
+import { isENOENT } from '../../../common/errors';
 import * as jsoncparser from 'jsonc-parser';
 import { IJSONSchema } from '@theia/core/lib/common/json-schema';
 import { deepClone } from '@theia/core/lib/common/objects';
@@ -144,7 +145,7 @@ export class TheiaPluginScanner implements PluginScanner {
         return undefined;
     }
 
-    getContribution(rawPlugin: PluginPackage): PluginContribution | undefined {
+    async getContribution(rawPlugin: PluginPackage): Promise<PluginContribution | undefined> {
         if (!rawPlugin.contributes && !rawPlugin.activationEvents) {
             return undefined;
         }
@@ -175,15 +176,6 @@ export class TheiaPluginScanner implements PluginScanner {
         const configurationDefaults = rawPlugin.contributes.configurationDefaults;
         contributions.configurationDefaults = PreferenceSchemaProperties.is(configurationDefaults) ? configurationDefaults : undefined;
 
-        try {
-            if (rawPlugin.contributes.languages) {
-                const languages = this.readLanguages(rawPlugin.contributes.languages, rawPlugin.packagePath);
-                contributions.languages = languages;
-            }
-        } catch (err) {
-            console.error(`Could not read '${rawPlugin.name}' contribution 'languages'.`, rawPlugin.contributes.languages, err);
-        }
-
         try {
             if (rawPlugin.contributes.submenus) {
                 contributions.submenus = this.readSubmenus(rawPlugin.contributes.submenus, rawPlugin);
@@ -192,15 +184,6 @@ export class TheiaPluginScanner implements PluginScanner {
             console.error(`Could not read '${rawPlugin.name}' contribution 'submenus'.`, rawPlugin.contributes.submenus, err);
         }
 
-        try {
-            if (rawPlugin.contributes.grammars) {
-                const grammars = this.grammarsReader.readGrammars(rawPlugin.contributes.grammars, rawPlugin.packagePath);
-                contributions.grammars = grammars;
-            }
-        } catch (err) {
-            console.error(`Could not read '${rawPlugin.name}' contribution 'grammars'.`, rawPlugin.contributes.grammars, err);
-        }
-
         try {
             if (rawPlugin.contributes.customEditors) {
                 const customEditors = this.readCustomEditors(rawPlugin.contributes.customEditors);
@@ -330,6 +313,12 @@ export class TheiaPluginScanner implements PluginScanner {
             console.error(`Could not read '${rawPlugin.name}' contribution 'notebooks'.`, rawPlugin.contributes.authentication, err);
         }
 
+        try {
+            contributions.notebookRenderer = rawPlugin.contributes.notebookRenderer;
+        } catch (err) {
+            console.error(`Could not read '${rawPlugin.name}' contribution 'notebooks'.`, rawPlugin.contributes.authentication, err);
+        }
+
         try {
             contributions.snippets = this.readSnippets(rawPlugin);
         } catch (err) {
@@ -354,18 +343,40 @@ export class TheiaPluginScanner implements PluginScanner {
             console.error(`Could not read '${rawPlugin.name}' contribution 'colors'.`, rawPlugin.contributes.colors, err);
         }
 
-        try {
-            contributions.localizations = this.readLocalizations(rawPlugin);
-        } catch (err) {
-            console.error(`Could not read '${rawPlugin.name}' contribution 'localizations'.`, rawPlugin.contributes.colors, err);
-        }
-
         try {
             contributions.terminalProfiles = this.readTerminals(rawPlugin);
         } catch (err) {
             console.error(`Could not read '${rawPlugin.name}' contribution 'terminals'.`, rawPlugin.contributes.terminal, err);
         }
 
+        const [localizationsResult, languagesResult, grammarsResult] = await Promise.allSettled([
+            this.readLocalizations(rawPlugin),
+            rawPlugin.contributes.languages ? this.readLanguages(rawPlugin.contributes.languages, rawPlugin.packagePath) : undefined,
+            rawPlugin.contributes.grammars ? this.grammarsReader.readGrammars(rawPlugin.contributes.grammars, rawPlugin.packagePath) : undefined
+        ]);
+
+        if (localizationsResult.status === 'fulfilled') {
+            contributions.localizations = localizationsResult.value;
+        } else {
+            console.error(`Could not read '${rawPlugin.name}' contribution 'localizations'.`, rawPlugin.contributes.localizations, localizationsResult.reason);
+        }
+
+        if (rawPlugin.contributes.languages) {
+            if (languagesResult.status === 'fulfilled') {
+                contributions.languages = languagesResult.value;
+            } else {
+                console.error(`Could not read '${rawPlugin.name}' contribution 'languages'.`, rawPlugin.contributes.languages, languagesResult.reason);
+            }
+        }
+
+        if (rawPlugin.contributes.grammars) {
+            if (grammarsResult.status === 'fulfilled') {
+                contributions.grammars = grammarsResult.value;
+            } else {
+                console.error(`Could not read '${rawPlugin.name}' contribution 'grammars'.`, rawPlugin.contributes.grammars, grammarsResult.reason);
+            }
+        }
+
         return contributions;
     }
 
@@ -376,26 +387,26 @@ export class TheiaPluginScanner implements PluginScanner {
         return pck.contributes.terminal.profiles.filter(profile => profile.id && profile.title);
     }
 
-    protected readLocalizations(pck: PluginPackage): Localization[] | undefined {
+    protected async readLocalizations(pck: PluginPackage): Promise<Localization[] | undefined> {
         if (!pck.contributes || !pck.contributes.localizations) {
             return undefined;
         }
-        return pck.contributes.localizations.map(e => this.readLocalization(e, pck.packagePath));
+        return Promise.all(pck.contributes.localizations.map(e => this.readLocalization(e, pck.packagePath)));
     }
 
-    protected readLocalization({ languageId, languageName, localizedLanguageName, translations }: PluginPackageLocalization, pluginPath: string): Localization {
+    protected async readLocalization({ languageId, languageName, localizedLanguageName, translations }: PluginPackageLocalization, pluginPath: string): Promise<Localization> {
         const local: Localization = {
             languageId,
             languageName,
             localizedLanguageName,
             translations: []
         };
-        local.translations = translations.map(e => this.readTranslation(e, pluginPath));
+        local.translations = await Promise.all(translations.map(e => this.readTranslation(e, pluginPath)));
         return local;
     }
 
-    protected readTranslation(packageTranslation: PluginPackageTranslation, pluginPath: string): Translation {
-        const translation = this.readJson<Translation>(path.resolve(pluginPath, packageTranslation.path));
+    protected async readTranslation(packageTranslation: PluginPackageTranslation, pluginPath: string): Promise<Translation> {
+        const translation = await this.readJson<Translation>(path.resolve(pluginPath, packageTranslation.path));
         if (!translation) {
             throw new Error(`Could not read json file '${packageTranslation.path}'.`);
         }
@@ -529,15 +540,18 @@ export class TheiaPluginScanner implements PluginScanner {
         return result;
     }
 
-    protected readJson<T>(filePath: string): T | undefined {
-        const content = this.readFileSync(filePath);
+    protected async readJson<T>(filePath: string): Promise<T | undefined> {
+        const content = await this.readFile(filePath);
         return content ? jsoncparser.parse(content, undefined, { disallowComments: false }) : undefined;
     }
-    protected readFileSync(filePath: string): string {
+    protected async readFile(filePath: string): Promise<string> {
         try {
-            return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+            const content = await fs.readFile(filePath, { encoding: 'utf8' });
+            return content;
         } catch (e) {
-            console.error(e);
+            if (!isENOENT(e)) {
+                console.error(e);
+            }
             return '';
         }
     }
@@ -644,8 +658,8 @@ export class TheiaPluginScanner implements PluginScanner {
         return result;
     }
 
-    private readLanguages(rawLanguages: PluginPackageLanguageContribution[], pluginPath: string): LanguageContribution[] {
-        return rawLanguages.map(language => this.readLanguage(language, pluginPath));
+    private async readLanguages(rawLanguages: PluginPackageLanguageContribution[], pluginPath: string): Promise<LanguageContribution[]> {
+        return Promise.all(rawLanguages.map(language => this.readLanguage(language, pluginPath)));
     }
 
     private readSubmenus(rawSubmenus: PluginPackageSubmenu[], plugin: PluginPackage): Submenu[] {
@@ -662,7 +676,7 @@ export class TheiaPluginScanner implements PluginScanner {
 
     }
 
-    private readLanguage(rawLang: PluginPackageLanguageContribution, pluginPath: string): LanguageContribution {
+    private async readLanguage(rawLang: PluginPackageLanguageContribution, pluginPath: string): Promise<LanguageContribution> {
         // TODO: add validation to all parameters
         const result: LanguageContribution = {
             id: rawLang.id,
@@ -674,7 +688,7 @@ export class TheiaPluginScanner implements PluginScanner {
             mimetypes: rawLang.mimetypes
         };
         if (rawLang.configuration) {
-            const rawConfiguration = this.readJson<PluginPackageLanguageContributionConfiguration>(path.resolve(pluginPath, rawLang.configuration));
+            const rawConfiguration = await this.readJson<PluginPackageLanguageContributionConfiguration>(path.resolve(pluginPath, rawLang.configuration));
             if (rawConfiguration) {
                 const configuration: LanguageConfiguration = {
                     brackets: rawConfiguration.brackets,

package/src/main/browser/custom-editors/custom-editor-widget.ts

@@ -21,7 +21,7 @@ import { ApplicationShell, NavigatableWidget, Saveable, SaveableSource, SaveOpti
 import { SaveResourceService } from '@theia/core/lib/browser/save-resource-service';
 import { Reference } from '@theia/core/lib/common/reference';
 import { WebviewWidget } from '../webview/webview';
-import { UndoRedoService } from './undo-redo-service';
+import { UndoRedoService } from '@theia/editor/lib/browser/undo-redo-service';
 import { CustomEditorModel } from './custom-editors-main';
 
 @injectable()

package/src/main/browser/custom-editors/custom-editors-main.ts

@@ -36,7 +36,7 @@ import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model
 import { EditorModelService } from '../text-editor-model-service';
 import { CustomEditorService } from './custom-editor-service';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { UndoRedoService } from './undo-redo-service';
+import { UndoRedoService } from '@theia/editor/lib/browser/undo-redo-service';
 import { WebviewsMainImpl } from '../webviews-main';
 import { WidgetManager } from '@theia/core/lib/browser/widget-manager';
 import { ApplicationShell, DefaultUriLabelProviderContribution, Saveable, SaveOptions, WidgetOpenerOptions } from '@theia/core/lib/browser';

package/src/main/browser/editors-and-documents-main.ts

@@ -139,6 +139,7 @@ export class EditorsAndDocumentsMain implements Disposable {
             uri: model.textEditorModel.uri,
             versionId: model.textEditorModel.getVersionId(),
             lines: model.textEditorModel.getLinesContent(),
+            languageId: model.getLanguageId(),
             EOL: model.textEditorModel.getEOL(),
             modeId: model.languageId,
             isDirty: model.dirty

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

@@ -32,6 +32,7 @@ import {
     LanguagesExt,
     WorkspaceEditDto,
     WorkspaceTextEditDto,
+    WorkspaceFileEditDto,
     PluginInfo,
     LanguageStatus as LanguageStatusDTO,
     InlayHintDto,
@@ -1418,13 +1419,15 @@ export function toMonacoWorkspaceEdit(data: WorkspaceEditDto | undefined): monac
                     metadata: edit.metadata
                 };
             } else {
+                const fileEdit = edit as WorkspaceFileEditDto;
                 return <monaco.languages.IWorkspaceFileEdit>{
-                    newResource: monaco.Uri.revive(edit.newResource),
-                    oldResource: monaco.Uri.revive(edit.oldResource),
-                    options: edit.options,
-                    metadata: edit.metadata
+                    newResource: monaco.Uri.revive(fileEdit.newResource),
+                    oldResource: monaco.Uri.revive(fileEdit.oldResource),
+                    options: fileEdit.options,
+                    metadata: fileEdit.metadata
                 };
             }
+            // TODO implement WorkspaceNotebookCellEditDto
         })
     };
 }

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

@@ -59,7 +59,15 @@ import { MonacoLanguages } from '@theia/monaco/lib/browser/monaco-languages';
 import { UntitledResourceResolver } from '@theia/core/lib/common/resource';
 import { ThemeService } from '@theia/core/lib/browser/theming';
 import { TabsMainImpl } from './tabs/tabs-main';
+import { NotebooksMainImpl } from './notebooks/notebooks-main';
+import { NotebookService } from '@theia/notebook/lib/browser';
 import { LocalizationMainImpl } from './localization-main';
+import { NotebookRenderersMainImpl } from './notebooks/notebook-renderers-main';
+import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
+import { NotebookEditorsMainImpl } from './notebooks/notebook-editors-main';
+import { NotebookDocumentsMainImpl } from './notebooks/notebook-documents-main';
+import { NotebookKernelsMainImpl } from './notebooks/notebook-kernels-main';
+import { NotebooksAndEditorsMain } from './notebooks/notebook-documents-and-editors-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const authenticationMain = new AuthenticationMainImpl(rpc, container);
@@ -94,6 +102,17 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const documentsMain = new DocumentsMainImpl(editorsAndDocuments, modelService, rpc, editorManager, openerService, shell, untitledResourceResolver, languageService);
     rpc.set(PLUGIN_RPC_CONTEXT.DOCUMENTS_MAIN, documentsMain);
 
+    const notebookService = container.get(NotebookService);
+    const pluginSupport = container.get(HostedPluginSupport);
+    rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOKS_MAIN, new NotebooksMainImpl(rpc, notebookService, pluginSupport));
+    rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOK_RENDERERS_MAIN, new NotebookRenderersMainImpl(rpc, container));
+    const notebookEditorsMain = new NotebookEditorsMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOK_EDITORS_MAIN, notebookEditorsMain);
+    const notebookDocumentsMain = new NotebookDocumentsMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOK_DOCUMENTS_MAIN, notebookDocumentsMain);
+    rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOK_DOCUMENTS_AND_EDITORS_MAIN, new NotebooksAndEditorsMain(rpc, container, notebookDocumentsMain, notebookEditorsMain));
+    rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOK_KERNELS_MAIN, new NotebookKernelsMainImpl(rpc, container));
+
     const bulkEditService = container.get(MonacoBulkEditService);
     const monacoEditorService = container.get(MonacoEditorService);
     const editorsMain = new TextEditorsMainImpl(editorsAndDocuments, documentsMain, rpc, bulkEditService, monacoEditorService);

package/src/main/browser/menus/menus-contribution-handler.ts

@@ -17,12 +17,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { inject, injectable, optional } from '@theia/core/shared/inversify';
-import { MenuPath, CommandRegistry, Disposable, DisposableCollection, ActionMenuNode, MenuCommandAdapterRegistry, Emitter } from '@theia/core';
+import { MenuPath, CommandRegistry, Disposable, DisposableCollection, ActionMenuNode, MenuCommandAdapterRegistry, Emitter, nls } from '@theia/core';
 import { MenuModelRegistry } from '@theia/core/lib/common';
 import { TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
 import { DeployedPlugin, IconUrl, Menu } from '../../../common';
 import { ScmWidget } from '@theia/scm/lib/browser/scm-widget';
-import { PluginViewWidget } from '../view/plugin-view-widget';
 import { QuickCommandService } from '@theia/core/lib/browser';
 import {
     CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint,
@@ -56,9 +55,13 @@ export class MenusContributionPointHandler {
         this.initialized = true;
         this.commandAdapterRegistry.registerAdapter(this.commandAdapter);
         this.tabBarToolbar.registerMenuDelegate(PLUGIN_EDITOR_TITLE_MENU, widget => this.codeEditorWidgetUtil.is(widget));
-        this.tabBarToolbar.registerMenuDelegate(PLUGIN_EDITOR_TITLE_RUN_MENU, widget => this.codeEditorWidgetUtil.is(widget));
+        this.tabBarToolbar.registerItem({
+            id: this.tabBarToolbar.toElementId(PLUGIN_EDITOR_TITLE_RUN_MENU), menuPath: PLUGIN_EDITOR_TITLE_RUN_MENU,
+            icon: 'debug-alt', text: nls.localizeByDefault('Run or Debug...'),
+            command: '', group: 'navigation', isVisible: widget => this.codeEditorWidgetUtil.is(widget)
+        });
         this.tabBarToolbar.registerMenuDelegate(PLUGIN_SCM_TITLE_MENU, widget => widget instanceof ScmWidget);
-        this.tabBarToolbar.registerMenuDelegate(PLUGIN_VIEW_TITLE_MENU, widget => widget instanceof PluginViewWidget);
+        this.tabBarToolbar.registerMenuDelegate(PLUGIN_VIEW_TITLE_MENU, widget => !this.codeEditorWidgetUtil.is(widget));
         this.tabBarToolbar.registerItem({ id: 'plugin-menu-contribution-title-contribution', command: '_never_', onDidChange: this.onDidChangeTitleContributionEmitter.event });
         this.contextKeyService.onDidChange(event => {
             if (event.affects(this.titleContributionContextKeys)) {