@theia/plugin-ext 1.53.0-next.6 → 1.53.0-next.64

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

@@ -21,7 +21,7 @@
 import { Disposable, DisposableCollection } from '@theia/core';
 import { interfaces } from '@theia/core/shared/inversify';
 import { UriComponents } from '@theia/core/lib/common/uri';
-import { NotebookEditorWidget, NotebookService, NotebookEditorWidgetService } from '@theia/notebook/lib/browser';
+import { NotebookEditorWidget, NotebookService, NotebookEditorWidgetService, NotebookCellEditorService } from '@theia/notebook/lib/browser';
 import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
 import { MAIN_RPC_CONTEXT, NotebookDocumentsAndEditorsDelta, NotebookDocumentsAndEditorsMain, NotebookEditorAddData, NotebookModelAddedData, NotebooksExt } from '../../../common';
 import { RPCProtocol } from '../../../common/rpc-protocol';
@@ -105,6 +105,9 @@ export class NotebooksAndEditorsMain implements NotebookDocumentsAndEditorsMain
         this.notebookService = container.get(NotebookService);
         this.notebookEditorService = container.get(NotebookEditorWidgetService);
         this.WidgetManager = container.get(WidgetManager);
+        const notebookCellEditorService = container.get(NotebookCellEditorService);
+
+        notebookCellEditorService.onDidChangeFocusedCellEditor(editor => this.proxy.$acceptActiveCellEditorChange(editor?.uri.toString() ?? null), this, this.disposables);
 
         this.notebookService.onDidAddNotebookDocument(async () => this.updateState(), this, this.disposables);
         this.notebookService.onDidRemoveNotebookDocument(async () => this.updateState(), this, this.disposables);
@@ -242,7 +245,7 @@ export class NotebooksAndEditorsMain implements NotebookDocumentsAndEditorsMain
         return {
             id: notebookEditor.id,
             documentUri: uri.toComponents(),
-            selections: [],
+            selections: [{ start: 0, end: 0 }],
             visibleRanges: []
         };
     }

package/src/main/browser/notebooks/notebook-documents-main.ts

@@ -21,7 +21,7 @@ import { NotebookModelResolverService } from '@theia/notebook/lib/browser';
 import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
 import { NotebookCellsChangeType } from '@theia/notebook/lib/common';
 import { NotebookMonacoTextModelService } from '@theia/notebook/lib/browser/service/notebook-monaco-text-model-service';
-import { MAIN_RPC_CONTEXT, NotebookCellsChangedEventDto, NotebookDataDto, NotebookDocumentsExt, NotebookDocumentsMain } from '../../../common';
+import { MAIN_RPC_CONTEXT, NotebookCellsChangedEventDto, NotebookDataDto, NotebookDocumentsExt, NotebookDocumentsMain, NotebookRawContentEventDto } from '../../../common';
 import { RPCProtocol } from '../../../common/rpc-protocol';
 import { NotebookDto } from './notebook-dto';
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
@@ -156,19 +156,39 @@ export class NotebookDocumentsMainImpl implements NotebookDocumentsMain {
         //     ref.dispose();
         // });
 
+        const uriComponents = ref.uri.toComponents();
         // untitled notebooks are dirty by default
-        this.proxy.$acceptDirtyStateChanged(ref.uri.toComponents(), true);
+        this.proxy.$acceptDirtyStateChanged(uriComponents, true);
 
-        // apply content changes... slightly HACKY -> this triggers a change event
+        // apply content changes...
         if (options.content) {
             const data = NotebookDto.fromNotebookDataDto(options.content);
             ref.setData(data);
+
+            // Create and send a change events
+            const rawEvents: NotebookRawContentEventDto[] = [];
+            if (options.content.cells && options.content.cells.length > 0) {
+                rawEvents.push({
+                    kind: NotebookCellsChangeType.ModelChange,
+                    changes: [{ start: 0, deleteCount: 0, newItems: ref.cells.map(NotebookDto.toNotebookCellDto) }]
+                });
+            }
+            if (options.content.metadata) {
+                rawEvents.push({
+                    kind: NotebookCellsChangeType.ChangeDocumentMetadata,
+                    metadata: options.content.metadata
+                });
+            }
+            if (rawEvents.length > 0) {
+                this.proxy.$acceptModelChanged(uriComponents, { versionId: 1, rawEvents }, true);
+            }
         }
-        return ref.uri.toComponents();
+        return uriComponents;
     }
 
     async $tryOpenNotebook(uriComponents: UriComponents): Promise<UriComponents> {
         const uri = URI.fromComponents(uriComponents);
+        await this.notebookModelResolverService.resolve(uri);
         return uri.toComponents();
     }
 

package/src/main/browser/notebooks/notebook-editors-main.ts

@@ -54,12 +54,25 @@ export class NotebookEditorsMainImpl implements NotebookEditorsMain {
         throw new Error('Method not implemented.');
     }
     $trySetSelections(id: string, range: CellRange[]): void {
-        throw new Error('Method not implemented.');
+        if (!this.mainThreadEditors.has(id)) {
+            throw new Error('Editor not found');
+        }
+        const editor = this.mainThreadEditors.get(id);
+        editor?.model?.setSelectedCell(editor.model.cells[range[0].start]);
     }
 
-    handleEditorsAdded(editors: readonly NotebookEditorWidget[]): void {
+    async handleEditorsAdded(editors: readonly NotebookEditorWidget[]): Promise<void> {
         for (const editor of editors) {
             this.mainThreadEditors.set(editor.id, editor);
+            const model = await editor.ready;
+            model.onDidChangeSelectedCell(e => {
+                const newCellIndex = e.cell ? model.cells.indexOf(e.cell) : -1;
+                this.proxy.$acceptEditorPropertiesChanged(editor.id, {
+                    selections: {
+                        selections: newCellIndex >= 0 ? [{ start: newCellIndex, end: newCellIndex }] : []
+                    }
+                });
+            });
         }
     }
 

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -21,10 +21,10 @@ import '../../../src/main/browser/style/comments.css';
 import { ContainerModule } from '@theia/core/shared/inversify';
 import {
     FrontendApplicationContribution, WidgetFactory, bindViewContribution,
-    ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeWidget, LabelProviderContribution,
-    UndoRedoHandler
+    ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeWidget, LabelProviderContribution, LabelProvider,
+    UndoRedoHandler, DiffUris, Navigatable, SplitWidget
 } from '@theia/core/lib/browser';
-import { MaybePromise, CommandContribution, ResourceResolver, bindContributionProvider } from '@theia/core/lib/common';
+import { MaybePromise, CommandContribution, ResourceResolver, bindContributionProvider, URI, generateUuid } from '@theia/core/lib/common';
 import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging';
 import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
 import { HostedPluginWatcher } from '../../hosted/browser/hosted-plugin-watcher';
@@ -200,6 +200,25 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(CustomEditorUndoRedoHandler).toSelf().inSingletonScope();
     bind(UndoRedoHandler).toService(CustomEditorUndoRedoHandler);
 
+    bind(WidgetFactory).toDynamicValue(ctx => ({
+        id: CustomEditorWidget.SIDE_BY_SIDE_FACTORY_ID,
+        createWidget: (arg: { uri: string, viewType: string }) => {
+            const uri = new URI(arg.uri);
+            const [leftUri, rightUri] = DiffUris.decode(uri);
+            const navigatable: Navigatable = {
+                getResourceUri: () => rightUri,
+                createMoveToUri: resourceUri => DiffUris.encode(leftUri, rightUri.withPath(resourceUri.path))
+            };
+            const widget = new SplitWidget({ navigatable });
+            widget.id = arg.viewType + '.side-by-side:' + generateUuid();
+            const labelProvider = ctx.container.get(LabelProvider);
+            widget.title.label = labelProvider.getName(uri);
+            widget.title.iconClass = labelProvider.getIcon(uri);
+            widget.title.closable = true;
+            return widget;
+        }
+    })).inSingletonScope();
+
     bind(PluginViewWidget).toSelf();
     bind(WidgetFactory).toDynamicValue(({ container }) => ({
         id: PLUGIN_VIEW_FACTORY_ID,
@@ -267,6 +286,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(CellOutputWebviewFactory).toFactory(ctx => async (cell: NotebookCellModel, notebook: NotebookModel) =>
         createCellOutputWebviewContainer(ctx.container, cell, notebook).getAsync(CellOutputWebviewImpl)
     );
-
     bindContributionProvider(bind, ArgumentProcessorContribution);
+
 });

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

@@ -231,9 +231,13 @@ export class TabsMainImpl implements TabsMain, Disposable {
         return { kind: TabInputKind.UnknownInput };
     }
 
-    protected connectToSignal<T>(disposableList: DisposableCollection, signal: { connect(listener: T, context: unknown): void, disconnect(listener: T): void }, listener: T): void {
+    protected connectToSignal<T>(disposableList: DisposableCollection,
+        signal: {
+            connect(listener: T, context: unknown): void,
+            disconnect(listener: T, context: unknown): void
+        }, listener: T): void {
         signal.connect(listener, this);
-        disposableList.push(Disposable.create(() => signal.disconnect(listener)));
+        disposableList.push(Disposable.create(() => signal.disconnect(listener, this)));
     }
 
     protected tabDtosEqual(a: TabDto, b: TabDto): boolean {

package/src/main/browser/text-editor-main.ts

@@ -33,11 +33,14 @@ import { Range } from '../../common/plugin-api-rpc-model';
 import { Emitter, Event } from '@theia/core';
 import { TextEditorCursorStyle, cursorStyleToString } from '../../common/editor-options';
 import { TextEditorLineNumbersStyle, EndOfLine } from '../../plugin/types-impl';
+import { SimpleMonacoEditor } from '@theia/monaco/lib/browser/simple-monaco-editor';
+import { EndOfLineSequence, ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { EditorOption, RenderLineNumbersType } from '@theia/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
 
 export class TextEditorMain implements Disposable {
 
     private properties: TextEditorPropertiesMain | undefined;
-    private editor: MonacoEditor | undefined;
+    private editor: MonacoEditor | SimpleMonacoEditor | undefined;
 
     private readonly onPropertiesChangedEmitter = new Emitter<EditorChangedPropertiesData>();
 
@@ -48,8 +51,8 @@ export class TextEditorMain implements Disposable {
 
     constructor(
         private id: string,
-        private model: monaco.editor.IModel,
-        editor: MonacoEditor
+        private model: monaco.editor.IModel | ITextModel,
+        editor: MonacoEditor | SimpleMonacoEditor
     ) {
         this.toDispose.push(this.model.onDidChangeOptions(() =>
             this.updateProperties(undefined)
@@ -76,7 +79,7 @@ export class TextEditorMain implements Disposable {
 
     protected readonly toDisposeOnEditor = new DisposableCollection();
 
-    private setEditor(editor?: MonacoEditor): void {
+    private setEditor(editor?: MonacoEditor | SimpleMonacoEditor): void {
         if (this.editor === editor) {
             return;
         }
@@ -115,7 +118,7 @@ export class TextEditorMain implements Disposable {
         return this.id;
     }
 
-    getModel(): monaco.editor.IModel {
+    getModel(): monaco.editor.IModel | ITextModel {
         return this.model;
     }
 
@@ -208,7 +211,7 @@ export class TextEditorMain implements Disposable {
     }
 
     revealRange(range: monaco.Range, revealType: TextEditorRevealType): void {
-        if (!this.editor) {
+        if (!this.editor || this.editor instanceof SimpleMonacoEditor) {
             return;
         }
         switch (revealType) {
@@ -240,10 +243,14 @@ export class TextEditorMain implements Disposable {
             return false;
         }
 
-        if (opts.setEndOfLine === EndOfLine.CRLF) {
+        if (opts.setEndOfLine === EndOfLine.CRLF && !this.isSimpleWidget(this.model)) {
             this.model.setEOL(monaco.editor.EndOfLineSequence.CRLF);
-        } else if (opts.setEndOfLine === EndOfLine.LF) {
+        } else if (opts.setEndOfLine === EndOfLine.LF && !this.isSimpleWidget(this.model)) {
             this.model.setEOL(monaco.editor.EndOfLineSequence.LF);
+        } else if (opts.setEndOfLine === EndOfLine.CRLF && this.isSimpleWidget(this.model)) {
+            this.model.setEOL(EndOfLineSequence.CRLF);
+        } else if (opts.setEndOfLine === EndOfLine.LF && this.isSimpleWidget(this.model)) {
+            this.model.setEOL(EndOfLineSequence.CRLF);
         }
 
         const editOperations: monaco.editor.IIdentifiedSingleEditOperation[] = [];
@@ -311,6 +318,10 @@ export class TextEditorMain implements Disposable {
     private static toMonacoSelections(selection: Selection): monaco.Selection {
         return new monaco.Selection(selection.selectionStartLineNumber, selection.selectionStartColumn, selection.positionLineNumber, selection.positionColumn);
     }
+
+    private isSimpleWidget(model: monaco.editor.IModel | ITextModel): model is ITextModel {
+        return !!(model as ITextModel).isForSimpleWidget;
+    }
 }
 
 // TODO move to monaco typings!
@@ -362,17 +373,26 @@ export class TextEditorPropertiesMain {
         return undefined;
     }
 
-    static readFromEditor(prevProperties: TextEditorPropertiesMain | undefined, model: monaco.editor.IModel, editor: MonacoEditor): TextEditorPropertiesMain {
+    static readFromEditor(prevProperties: TextEditorPropertiesMain | undefined,
+        model: monaco.editor.IModel | ITextModel,
+        editor: MonacoEditor | SimpleMonacoEditor): TextEditorPropertiesMain {
+
         const selections = TextEditorPropertiesMain.getSelectionsFromEditor(prevProperties, editor);
         const options = TextEditorPropertiesMain.getOptionsFromEditor(prevProperties, model, editor);
         const visibleRanges = TextEditorPropertiesMain.getVisibleRangesFromEditor(prevProperties, editor);
         return new TextEditorPropertiesMain(selections, options, visibleRanges);
     }
 
-    private static getSelectionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor): monaco.Selection[] {
+    private static getSelectionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor | SimpleMonacoEditor): monaco.Selection[] {
         let result: monaco.Selection[] | undefined = undefined;
-        if (editor) {
+        if (editor && editor instanceof MonacoEditor) {
             result = editor.getControl().getSelections() || undefined;
+        } else if (editor && editor instanceof SimpleMonacoEditor) {
+            result = editor.getControl().getSelections()?.map(selection => new monaco.Selection(
+                selection.startLineNumber,
+                selection.startColumn,
+                selection.positionLineNumber,
+                selection.positionColumn));
         }
 
         if (!result && prevProperties) {
@@ -385,14 +405,16 @@ export class TextEditorPropertiesMain {
         return result;
     }
 
-    private static getOptionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined, model: monaco.editor.IModel, editor: MonacoEditor): TextEditorConfiguration {
+    private static getOptionsFromEditor(prevProperties: TextEditorPropertiesMain | undefined,
+        model: monaco.editor.IModel | ITextModel,
+        editor: MonacoEditor | SimpleMonacoEditor): TextEditorConfiguration {
         if (model.isDisposed()) {
             return prevProperties!.options;
         }
 
         let cursorStyle: TextEditorCursorStyle;
         let lineNumbers: TextEditorLineNumbersStyle;
-        if (editor) {
+        if (editor && editor instanceof MonacoEditor) {
             const editorOptions = editor.getControl().getOptions();
             const lineNumbersOpts = editorOptions.get(monaco.editor.EditorOption.lineNumbers);
             cursorStyle = editorOptions.get(monaco.editor.EditorOption.cursorStyle);
@@ -410,6 +432,25 @@ export class TextEditorPropertiesMain {
                     lineNumbers = TextEditorLineNumbersStyle.On;
                     break;
             }
+        } else if (editor && editor instanceof SimpleMonacoEditor) {
+            const editorOptions = editor.getControl().getOptions();
+            const lineNumbersOpts = editorOptions.get(EditorOption.lineNumbers);
+            cursorStyle = editorOptions.get(EditorOption.cursorStyle);
+            switch (lineNumbersOpts.renderType) {
+                case RenderLineNumbersType.Off:
+                    lineNumbers = TextEditorLineNumbersStyle.Off;
+                    break;
+                case RenderLineNumbersType.Relative:
+                    lineNumbers = TextEditorLineNumbersStyle.Relative;
+                    break;
+                case RenderLineNumbersType.Interval:
+                    lineNumbers = TextEditorLineNumbersStyle.Interval;
+                    break;
+                default:
+                    lineNumbers = TextEditorLineNumbersStyle.On;
+                    break;
+            }
+
         } else if (prevProperties) {
             cursorStyle = prevProperties.options.cursorStyle;
             lineNumbers = prevProperties.options.lineNumbers;
@@ -428,7 +469,7 @@ export class TextEditorPropertiesMain {
         };
     }
 
-    private static getVisibleRangesFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor): monaco.Range[] {
+    private static getVisibleRangesFromEditor(prevProperties: TextEditorPropertiesMain | undefined, editor: MonacoEditor | SimpleMonacoEditor): monaco.Range[] {
         if (editor) {
             return editor.getControl().getVisibleRanges();
         }

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

@@ -0,0 +1,72 @@
+// *****************************************************************************
+// Copyright (C) 2024 STMicroelectronics.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Disposable, URI } from '@theia/core';
+import { MAIN_RPC_CONTEXT, UriExt, UriMain } from '../../common';
+import { RPCProtocol } from '../../common/rpc-protocol';
+import { interfaces } from '@theia/core/shared/inversify';
+import { OpenHandler, OpenerOptions, OpenerService } from '@theia/core/lib/browser';
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
+
+export class UriMainImpl implements UriMain, Disposable {
+    private readonly proxy: UriExt;
+    private handlers = new Set<string>();
+    private readonly openerService: OpenerService;
+    private readonly pluginSupport: HostedPluginSupport;
+    private readonly openHandler: OpenHandler;
+
+    constructor(rpc: RPCProtocol, container: interfaces.Container) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.URI_EXT);
+        this.openerService = container.get(OpenerService);
+        this.pluginSupport = container.get(HostedPluginSupport);
+
+        this.openHandler = {
+            id: 'theia-plugin-open-handler',
+            canHandle: async (uri: URI, options?: OpenerOptions | undefined): Promise<number> => {
+                if (uri.scheme !== FrontendApplicationConfigProvider.get().electron.uriScheme) {
+                    return 0;
+                }
+                await this.pluginSupport.activateByUri(uri.scheme, uri.authority);
+                if (this.handlers.has(uri.authority)) {
+                    return 500;
+                }
+                return 0;
+            },
+            open: async (uri: URI, options?: OpenerOptions | undefined): Promise<undefined> => {
+                if (!this.handlers.has(uri.authority)) {
+                    throw new Error(`No plugin to handle this uri: : '${uri}'`);
+                }
+                this.proxy.$handleExternalUri(uri.toComponents());
+            }
+        };
+
+        this.openerService.addHandler?.(this.openHandler);
+    }
+
+    dispose(): void {
+        this.openerService.removeHandler?.(this.openHandler);
+        this.handlers.clear();
+    }
+
+    async $registerUriHandler(pluginId: string, extensionDisplayName: string): Promise<void> {
+        this.handlers.add(pluginId);
+    }
+
+    async $unregisterUriHandler(pluginId: string): Promise<void> {
+        this.handlers.delete(pluginId);
+    }
+}

package/src/main/browser/webview/pre/service-worker.js

@@ -226,7 +226,8 @@ async function processResourceRequest(event, requestUrl, resourceRoot) {
 
     parentClient.postMessage({
         channel: 'load-resource',
-        path: resourcePath
+        path: resourcePath,
+        query: requestUrl.search.replace(/^\?/, '')
     });
 
     return resourceRequestStore.create(webviewId, resourcePath)

package/src/main/browser/webview/webview.ts

@@ -48,7 +48,6 @@ import { isFirefox } from '@theia/core/lib/browser/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { FileOperationError, FileOperationResult } from '@theia/filesystem/lib/common/files';
 import { BinaryBufferReadableStream } from '@theia/core/lib/common/buffer';
-import { ViewColumn } from '../../../plugin/types-impl';
 import { ExtractableWidget } from '@theia/core/lib/browser/widgets/extractable-widget';
 import { BadgeWidget } from '@theia/core/lib/browser/view-container';
 import { MenuPath } from '@theia/core';
@@ -185,7 +184,6 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget, Extract
     }
 
     viewType: string;
-    viewColumn: ViewColumn;
     options: WebviewPanelOptions = {};
 
     protected ready = new Deferred<void>();
@@ -352,7 +350,7 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget, Extract
             /* no-op: webview loses focus only if another element gains focus in the main window */
         }));
         this.toHide.push(this.on(WebviewMessageChannels.doReload, () => this.reload()));
-        this.toHide.push(this.on(WebviewMessageChannels.loadResource, (entry: any) => this.loadResource(entry.path)));
+        this.toHide.push(this.on(WebviewMessageChannels.loadResource, (entry: any) => this.loadResource(entry.path, entry.query)));
         this.toHide.push(this.on(WebviewMessageChannels.loadLocalhost, (entry: any) =>
             this.loadLocalhost(entry.origin)
         ));
@@ -544,10 +542,11 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget, Extract
         return undefined;
     }
 
-    protected async loadResource(requestPath: string): Promise<void> {
-        const normalizedUri = this.normalizeRequestUri(requestPath);
+    protected async loadResource(requestPath: string, requestQuery: string = ''): Promise<void> {
+        const normalizedUri = this.normalizeRequestUri(requestPath).withQuery(decodeURIComponent(requestQuery));
         // browser cache does not support file scheme, normalize to current endpoint scheme and host
-        const cacheUrl = new Endpoint({ path: normalizedUri.path.toString() }).getRestUrl().toString();
+        // use requestPath rather than normalizedUri.path to preserve the scheme of the requested resource as a path segment
+        const cacheUrl = new Endpoint({ path: requestPath }).getRestUrl().withQuery(decodeURIComponent(requestQuery)).toString();
 
         try {
             if (this.contentOptions.localResourceRoots) {

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

@@ -191,7 +191,12 @@ export class WebviewsMainImpl implements WebviewsMain, Disposable {
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async $postMessage(handle: string, value: any): Promise<boolean> {
-        const webview = await this.getWebview(handle);
+        // Due to async nature of $postMessage, the webview may have been disposed in the meantime.
+        // Therefore, don't throw an error if the webview is not found, but return false in this case.
+        const webview = await this.tryGetWebview(handle);
+        if (!webview) {
+            return false;
+        }
         webview.sendMessage(value);
         return true;
     }

package/src/plugin/authentication-ext.ts

@@ -57,6 +57,10 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         return this.proxy.$getSession(providerId, scopes, extensionId, extensionName, options);
     }
 
+    getAccounts(providerId: string): Thenable<readonly theia.AuthenticationSessionAccountInformation[]> {
+        return this.proxy.$getAccounts(providerId);
+    }
+
     registerAuthenticationProvider(id: string, label: string, provider: theia.AuthenticationProvider, options?: theia.AuthenticationProviderOptions): theia.Disposable {
         if (this.authenticationProviders.get(id)) {
             throw new Error(`An authentication provider with id '${id}' is already registered.`);
@@ -64,7 +68,7 @@ export class AuthenticationExtImpl implements AuthenticationExt {
 
         this.authenticationProviders.set(id, provider);
 
-        provider.getSessions().then(sessions => { // sessions might have been restored from secret storage
+        provider.getSessions(undefined, {}).then(sessions => { // sessions might have been restored from secret storage
             if (sessions.length > 0) {
                 this.proxy.$onDidChangeSessions(id, {
                     added: sessions,
@@ -87,10 +91,10 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         });
     }
 
-    $createSession(providerId: string, scopes: string[]): Promise<theia.AuthenticationSession> {
+    $createSession(providerId: string, scopes: string[], options: theia.AuthenticationProviderSessionOptions): Promise<theia.AuthenticationSession> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            return Promise.resolve(authProvider.createSession(scopes));
+            return Promise.resolve(authProvider.createSession(scopes, options));
         }
 
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
@@ -105,10 +109,10 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    async $getSessions(providerId: string, scopes?: string[]): Promise<ReadonlyArray<theia.AuthenticationSession>> {
+    async $getSessions(providerId: string, scopes: string[] | undefined, options: theia.AuthenticationProviderSessionOptions): Promise<ReadonlyArray<theia.AuthenticationSession>> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            const sessions = await authProvider.getSessions(scopes);
+            const sessions = await authProvider.getSessions(scopes, options);
 
             /* Wrap the session object received from the plugin to prevent serialization mismatches
             e.g. if the plugin object is constructed with the help of getters they won't be serialized:

package/src/plugin/custom-editors.ts

@@ -25,11 +25,11 @@ import { RPCProtocol } from '../common/rpc-protocol';
 import { Disposable, URI } from './types-impl';
 import { UriComponents } from '../common/uri-components';
 import { DocumentsExtImpl } from './documents';
-import { WebviewImpl, WebviewsExtImpl } from './webviews';
+import { WebviewsExtImpl } from './webviews';
 import { CancellationToken, CancellationTokenSource } from '@theia/core/lib/common/cancellation';
 import { DisposableCollection } from '@theia/core/lib/common/disposable';
-import { WorkspaceExtImpl } from './workspace';
 import { Cache } from '../common/cache';
+import * as Converters from './type-converters';
 
 export class CustomEditorsExtImpl implements CustomEditorsExt {
     private readonly proxy: CustomEditorsMain;
@@ -38,8 +38,7 @@ export class CustomEditorsExtImpl implements CustomEditorsExt {
 
     constructor(rpc: RPCProtocol,
         private readonly documentExt: DocumentsExtImpl,
-        private readonly webviewExt: WebviewsExtImpl,
-        private readonly workspace: WorkspaceExtImpl) {
+        private readonly webviewExt: WebviewsExtImpl) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.CUSTOM_EDITORS_MAIN);
     }
 
@@ -116,22 +115,21 @@ export class CustomEditorsExtImpl implements CustomEditorsExt {
         document.dispose();
     }
 
-    async $resolveWebviewEditor<T>(
+    async $resolveWebviewEditor(
         resource: UriComponents,
         handler: string,
         viewType: string,
         title: string,
-        widgetOpenerOptions: object | undefined,
-        options: theia.WebviewPanelOptions & theia.WebviewOptions,
+        position: number,
+        options: theia.WebviewPanelOptions,
         cancellation: CancellationToken
     ): Promise<void> {
         const entry = this.editorProviders.get(viewType);
         if (!entry) {
             throw new Error(`No provider found for '${viewType}'`);
         }
-        const panel = this.webviewExt.createWebviewPanel(viewType, title, {}, options, entry.plugin, handler, false);
-        const webviewOptions = WebviewImpl.toWebviewOptions(options, this.workspace, entry.plugin);
-        await this.proxy.$createCustomEditorPanel(handler, title, widgetOpenerOptions, webviewOptions);
+        const viewColumn = Converters.toViewColumn(position);
+        const panel = this.webviewExt.createWebviewPanel(viewType, title, { viewColumn }, options, entry.plugin, handler, false);
 
         const revivedResource = URI.revive(resource);
 

package/src/plugin/env.ts

@@ -35,6 +35,7 @@ export abstract class EnvExtImpl {
     private envSessionId: string;
     private host: string;
     private applicationRoot: string;
+    private appUriScheme: string;
     private _remoteName: string | undefined;
 
     constructor() {
@@ -89,6 +90,10 @@ export abstract class EnvExtImpl {
         this.applicationRoot = appRoot;
     }
 
+    setAppUriScheme(uriScheme: string): void {
+        this.appUriScheme = uriScheme;
+    }
+
     getClientOperatingSystem(): Promise<theia.OperatingSystem> {
         return this.proxy.$getClientOperatingSystem();
     }
@@ -121,7 +126,7 @@ export abstract class EnvExtImpl {
         return this.envSessionId;
     }
     get uriScheme(): string {
-        return 'theia';
+        return this.appUriScheme;
     }
     get uiKind(): theia.UIKind {
         return this.ui;

package/src/plugin/known-commands.ts

@@ -297,6 +297,7 @@ export namespace KnownCommands {
     mappings['vscode.executeFormatDocumentProvider'] = ['vscode.executeFormatDocumentProvider', CONVERT_VSCODE_TO_MONACO, CONVERT_MONACO_TO_VSCODE];
     mappings['vscode.executeFormatRangeProvider'] = ['vscode.executeFormatRangeProvider', CONVERT_VSCODE_TO_MONACO, CONVERT_MONACO_TO_VSCODE];
     mappings['vscode.executeFormatOnTypeProvider'] = ['vscode.executeFormatOnTypeProvider', CONVERT_VSCODE_TO_MONACO, CONVERT_MONACO_TO_VSCODE];
+    mappings['vscode.executeCodeActionProvider'] = ['vscode.executeCodeActionProvider', CONVERT_VSCODE_TO_MONACO, CONVERT_MONACO_TO_VSCODE];
     mappings['vscode.prepareCallHierarchy'] = ['vscode.prepareCallHierarchy', CONVERT_VSCODE_TO_MONACO, CONVERT_MONACO_TO_VSCODE];
     mappings['vscode.provideIncomingCalls'] = ['vscode.provideIncomingCalls', CONVERT_VSCODE_TO_MONACO, CONVERT_MONACO_TO_VSCODE];
     mappings['vscode.provideOutgoingCalls'] = ['vscode.provideOutgoingCalls', CONVERT_VSCODE_TO_MONACO, CONVERT_MONACO_TO_VSCODE];