@theia/plugin-ext 1.23.0-next.2 → 1.23.0-next.26

package/src/plugin/authentication-ext.ts

@@ -28,8 +28,7 @@ import {
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { Emitter, Event } from '@theia/core/lib/common/event';
-import * as theia from '@theia/plugin';
-import { AuthenticationSession, AuthenticationSessionsChangeEvent } from '../common/plugin-api-rpc-model';
+import * as theia from '@theia/plugin/';
 
 export class AuthenticationExtImpl implements AuthenticationExt {
     private proxy: AuthenticationMain;
@@ -61,82 +60,88 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         return Object.freeze(this._providers.slice());
     }
 
-    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: string[],
-                     options: theia.AuthenticationGetSessionOptions & { createIfNone: true }): Promise<theia.AuthenticationSession>;
-    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: string[],
-                     options: theia.AuthenticationGetSessionOptions = {}): Promise<theia.AuthenticationSession | undefined> {
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions & ({ createIfNone: true } | { forceNewSession: true } | { forceNewSession: { detail: string } })):
+        Promise<theia.AuthenticationSession>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions & { forceNewSession: true }): Promise<theia.AuthenticationSession>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions & { forceNewSession: { detail: string } }): Promise<theia.AuthenticationSession>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions): Promise<theia.AuthenticationSession | undefined>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions = {}): Promise<theia.AuthenticationSession | undefined> {
         const extensionName = requestingExtension.model.displayName || requestingExtension.model.name;
         const extensionId = requestingExtension.model.id.toLowerCase();
-
         return this.proxy.$getSession(providerId, scopes, extensionId, extensionName, options);
     }
 
     async logout(providerId: string, sessionId: string): Promise<void> {
-        return this.proxy.$logout(providerId, sessionId);
+        return this.proxy.$removeSession(providerId, sessionId);
     }
 
-    registerAuthenticationProvider(provider: theia.AuthenticationProvider): theia.Disposable {
-        if (this.authenticationProviders.get(provider.id)) {
-            throw new Error(`An authentication provider with id '${provider.id}' is already registered.`);
+    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.`);
         }
 
-        this.authenticationProviders.set(provider.id, provider);
-        if (this._providerIds.indexOf(provider.id) === -1) {
-            this._providerIds.push(provider.id);
+        this.authenticationProviders.set(id, provider);
+        if (this._providerIds.indexOf(id) === -1) {
+            this._providerIds.push(id);
         }
 
-        if (!this._providers.find(p => p.id === provider.id)) {
+        if (!this._providers.find(p => p.id === id)) {
             this._providers.push({
-                id: provider.id,
-                label: provider.label
+                id,
+                label
             });
         }
 
         const listener = provider.onDidChangeSessions(e => {
-            this.proxy.$updateSessions(provider.id, e);
+            this.proxy.$sendDidChangeSessions(id, e);
         });
 
-        this.proxy.$registerAuthenticationProvider(provider.id, provider.label, provider.supportsMultipleAccounts);
+        this.proxy.$registerAuthenticationProvider(id, label, !!options?.supportsMultipleAccounts);
 
         return new Disposable(() => {
             listener.dispose();
-            this.authenticationProviders.delete(provider.id);
-            const index = this._providerIds.findIndex(id => id === provider.id);
+            this.authenticationProviders.delete(id);
+            const index = this._providerIds.findIndex(pid => id === pid);
             if (index > -1) {
                 this._providerIds.splice(index);
             }
 
-            const i = this._providers.findIndex(p => p.id === provider.id);
+            const i = this._providers.findIndex(p => p.id === id);
             if (i > -1) {
                 this._providers.splice(i);
             }
 
-            this.proxy.$unregisterAuthenticationProvider(provider.id);
+            this.proxy.$unregisterAuthenticationProvider(id);
         });
     }
 
-    $login(providerId: string, scopes: string[]): Promise<AuthenticationSession> {
+    $createSession(providerId: string, scopes: string[]): Promise<theia.AuthenticationSession> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            return Promise.resolve(authProvider.login(scopes));
+            return Promise.resolve(authProvider.createSession(scopes));
         }
 
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    $logout(providerId: string, sessionId: string): Promise<void> {
+    $removeSession(providerId: string, sessionId: string): Promise<void> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            return Promise.resolve(authProvider.logout(sessionId));
+            return Promise.resolve(authProvider.removeSession(sessionId));
         }
 
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    async $getSessions(providerId: string): Promise<ReadonlyArray<AuthenticationSession>> {
+    async $getSessions(providerId: string, scopes?: string[]): Promise<ReadonlyArray<theia.AuthenticationSession>> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            const sessions = await authProvider.getSessions();
+            const sessions = await authProvider.getSessions(scopes);
 
             /* 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:
@@ -158,12 +163,12 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    $onDidChangeAuthenticationSessions(id: string, label: string, event: AuthenticationSessionsChangeEvent): Promise<void> {
-        this.onDidChangeSessionsEmitter.fire({ provider: { id, label }, ...event });
+    $onDidChangeAuthenticationSessions(id: string, label: string): Promise<void> {
+        this.onDidChangeSessionsEmitter.fire({ provider: { id, label } });
         return Promise.resolve();
     }
 
-   async $onDidChangeAuthenticationProviders(added: theia.AuthenticationProviderInformation[], removed: theia.AuthenticationProviderInformation[]): Promise<void> {
+    async $onDidChangeAuthenticationProviders(added: theia.AuthenticationProviderInformation[], removed: theia.AuthenticationProviderInformation[]): Promise<void> {
         added.forEach(id => {
             if (this._providers.indexOf(id) === -1) {
                 this._providers.push(id);
@@ -179,4 +184,9 @@ export class AuthenticationExtImpl implements AuthenticationExt {
 
         this.onDidChangeAuthenticationProvidersEmitter.fire({ added, removed });
     }
+
+    $setProviders(providers: theia.AuthenticationProviderInformation[]): Promise<void> {
+        this._providers.push(...providers);
+        return Promise.resolve(undefined);
+    }
 }

package/src/plugin/node/debug/plugin-debug-adapter-starter.ts

@@ -18,7 +18,7 @@ import * as net from 'net';
 import { ChildProcess, spawn, fork, ForkOptions } from 'child_process';
 import { DebugAdapter } from '@theia/debug/lib/node/debug-model';
 import { DebugAdapterExecutable, DebugAdapterInlineImplementation, DebugAdapterNamedPipeServer, DebugAdapterServer } from '../../types-impl';
-import { InlineDebugAdapter } from '@theia/debug/lib/node/inline-debug-adapter';
+import { InlineDebugAdapter } from './plugin-inline-debug-adapter';
 import { ProcessDebugAdapter, SocketDebugAdapter } from '@theia/debug/lib/node/stream-debug-adapter';
 const isElectron = require('is-electron');
 

package/src/plugin/node/debug/plugin-inline-debug-adapter.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * Copyright (C) 2021 Red Hat, Inc. and others.
+ *
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import { DebugAdapter } from '@theia/debug/lib/node/debug-model';
+import * as theia from '@theia/plugin';
+
+/**
+ * A debug adapter for using the inline implementation from a plugin.
+ */
+export class InlineDebugAdapter implements DebugAdapter {
+    private messageReceivedEmitter = new Emitter<string>();
+    onMessageReceived: Event<string> = this.messageReceivedEmitter.event;
+    onError: Event<Error> = Event.None;
+    private closeEmitter = new Emitter<void>();
+    onClose: Event<void> = this.closeEmitter.event;
+
+    constructor(private debugAdapter: theia.DebugAdapter) {
+        this.debugAdapter.onDidSendMessage(msg => {
+            this.messageReceivedEmitter.fire(JSON.stringify(msg));
+        });
+    }
+
+    async start(): Promise<void> {
+    }
+
+    send(message: string): void {
+        this.debugAdapter.handleMessage(JSON.parse(message));
+    }
+
+    async stop(): Promise<void> {
+        this.debugAdapter.dispose();
+    }
+}

package/src/plugin/plugin-context.ts

@@ -173,6 +173,7 @@ import { TimelineExtImpl } from './timeline';
 import { ThemingExtImpl } from './theming';
 import { CommentsExtImpl } from './comments';
 import { CustomEditorsExtImpl } from './custom-editors';
+import { WebviewViewsExtImpl } from './webview-views';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -211,18 +212,36 @@ export function createAPIFactory(
     const themingExt = rpc.set(MAIN_RPC_CONTEXT.THEMING_EXT, new ThemingExtImpl(rpc));
     const commentsExt = rpc.set(MAIN_RPC_CONTEXT.COMMENTS_EXT, new CommentsExtImpl(rpc, commandRegistry, documents));
     const customEditorExt = rpc.set(MAIN_RPC_CONTEXT.CUSTOM_EDITORS_EXT, new CustomEditorsExtImpl(rpc, documents, webviewExt, workspaceExt));
+    const webviewViewsExt = rpc.set(MAIN_RPC_CONTEXT.WEBVIEW_VIEWS_EXT, new WebviewViewsExtImpl(rpc, webviewExt));
     rpc.set(MAIN_RPC_CONTEXT.DEBUG_EXT, debugExt);
 
     return function (plugin: InternalPlugin): typeof theia {
         const authentication: typeof theia.authentication = {
-            registerAuthenticationProvider(provider: theia.AuthenticationProvider): theia.Disposable {
-                return authenticationExt.registerAuthenticationProvider(provider);
+            // support older (< 1.53.0) and newer version of authentication provider registration
+            registerAuthenticationProvider(
+                id: string | theia.AuthenticationProvider, label?: string, provider?: theia.AuthenticationProvider, options?: theia.AuthenticationProviderOptions):
+                theia.Disposable {
+                // collect registration data based on registration type: new (all parameters given) vs old (data stored in provider)
+                const isNewRegistration = typeof id === 'string';
+                const regProvider = isNewRegistration ? provider! : id;
+                const regId = isNewRegistration ? id : regProvider.id;
+                const regLabel = isNewRegistration ? label! : regProvider.label;
+                const regOptions = isNewRegistration ? options : { supportsMultipleAccounts: regProvider.supportsMultipleAccounts };
+
+                // ensure that all methods of the new AuthenticationProvider are available or delegate otherwise
+                if (!regProvider['createSession']) {
+                    regProvider['createSession'] = (scopes: string[]) => regProvider.login(scopes);
+                }
+                if (!regProvider['removeSession']) {
+                    regProvider['removeSession'] = (sessionId: string) => regProvider.logout(sessionId);
+                }
+                return authenticationExt.registerAuthenticationProvider(regId, regLabel, regProvider, regOptions);
             },
             get onDidChangeAuthenticationProviders(): theia.Event<theia.AuthenticationProvidersChangeEvent> {
                 return authenticationExt.onDidChangeAuthenticationProviders;
             },
             getProviderIds(): Thenable<ReadonlyArray<string>> {
-                return authenticationExt.getProviderIds();
+                return Promise.resolve(authenticationExt.providerIds);
             },
             get providerIds(): string[] {
                 return authenticationExt.providerIds;
@@ -238,6 +257,10 @@ export function createAPIFactory(
             },
             get onDidChangeSessions(): theia.Event<theia.AuthenticationSessionsChangeEvent> {
                 return authenticationExt.onDidChangeSessions;
+            },
+            async hasSession(providerId: string, scopes: readonly string[]): Promise<boolean> {
+                const session = await authenticationExt.getSession(plugin, providerId, scopes, { silent: true });
+                return !!session;
             }
         };
         const commands: typeof theia.commands = {
@@ -410,6 +433,15 @@ export function createAPIFactory(
                 options: { webviewOptions?: theia.WebviewPanelOptions, supportsMultipleEditorsPerDocument?: boolean } = {}): theia.Disposable {
                 return customEditorExt.registerCustomEditorProvider(viewType, provider, options, plugin);
             },
+            registerWebviewViewProvider(viewType: string,
+                provider: theia.WebviewViewProvider,
+                options?: {
+                    webviewOptions?: {
+                        retainContextWhenHidden?: boolean
+                    }
+                }): theia.Disposable {
+                return webviewViewsExt.registerWebviewViewProvider(viewType, provider, plugin, options?.webviewOptions);
+            },
             get state(): theia.WindowState {
                 return windowStateExt.getWindowState();
             },
@@ -571,6 +603,15 @@ export function createAPIFactory(
             },
             registerTimelineProvider(scheme: string | string[], provider: theia.TimelineProvider): theia.Disposable {
                 return timelineExt.registerTimelineProvider(plugin, scheme, provider);
+            },
+            get isTrusted(): boolean {
+                return workspaceExt.trusted;
+            },
+            async requestWorkspaceTrust(options?: theia.WorkspaceTrustRequestOptions): Promise<boolean | undefined> {
+                return workspaceExt.requestWorkspaceTrust(options);
+            },
+            get onDidGrantWorkspaceTrust(): theia.Event<void> {
+                return workspaceExt.onDidGrantWorkspaceTrust;
             }
         };
 

package/src/plugin/plugin-manager.ts

@@ -91,7 +91,8 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
         'onWebviewPanel',
         'onFileSystem',
         'onCustomEditor',
-        'onStartupFinished'
+        'onStartupFinished',
+        'onAuthenticationRequest'
     ]);
 
     private configStorage: ConfigStorage | undefined;

package/src/plugin/webview-views.ts

@@ -0,0 +1,213 @@
+/********************************************************************************
+ * Copyright (C) 2021 SAP SE or an SAP affiliate company and others.
+ *
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+// some of the code is copied and modified from https://github.com/microsoft/vscode/blob/e1f0f8f51390dea5df9096718fb6b647ed5a9534/src/vs/workbench/api/common/extHostWebviewView.ts
+
+import { Disposable } from './types-impl';
+import { RPCProtocol } from '../common/rpc-protocol';
+import { PLUGIN_RPC_CONTEXT, WebviewViewsMain, WebviewViewsExt, Plugin } from '../common/plugin-api-rpc';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { WebviewImpl, WebviewsExtImpl } from './webviews';
+import { WebviewViewProvider } from '@theia/plugin';
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import * as theia from '@theia/plugin';
+
+export class WebviewViewsExtImpl implements WebviewViewsExt {
+
+    private readonly proxy: WebviewViewsMain;
+
+    protected readonly viewProviders = new Map<string, {
+        readonly provider: WebviewViewProvider;
+        readonly plugin: Plugin;
+    }>();
+    protected readonly webviewViews = new Map<string, WebviewViewExtImpl>();
+
+    constructor(rpc: RPCProtocol,
+        private readonly webviewsExt: WebviewsExtImpl) {
+        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.WEBVIEW_VIEWS_MAIN);
+    }
+
+    registerWebviewViewProvider(
+        viewType: string,
+        provider: WebviewViewProvider,
+        plugin: Plugin,
+        webviewOptions?: {
+            retainContextWhenHidden?: boolean
+        }
+    ): Disposable {
+        if (this.viewProviders.has(viewType)) {
+            throw new Error(`View provider for '${viewType}' already registered`);
+        }
+
+        this.viewProviders.set(viewType, { provider: provider, plugin: plugin });
+
+        this.proxy.$registerWebviewViewProvider(viewType, {
+            retainContextWhenHidden: webviewOptions?.retainContextWhenHidden,
+            serializeBuffersForPostMessage: false,
+        });
+
+        return new Disposable(() => {
+            this.viewProviders.delete(viewType);
+            this.proxy.$unregisterWebviewViewProvider(viewType);
+        });
+    }
+
+    async $resolveWebviewView(handle: string,
+        viewType: string,
+        title: string | undefined,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        state: any,
+        cancellation: CancellationToken
+    ): Promise<void> {
+        const entry = this.viewProviders.get(viewType);
+        if (!entry) {
+            throw new Error(`No view provider found for '${viewType}'`);
+        }
+
+        const { provider, plugin } = entry;
+
+        const webviewNoPanel = this.webviewsExt.createNewWebview({}, plugin, handle);
+        const revivedView = new WebviewViewExtImpl(handle, this.proxy, viewType, title, webviewNoPanel, true);
+        this.webviewViews.set(handle, revivedView);
+        await provider.resolveWebviewView(revivedView, { state }, cancellation);
+    }
+
+    async $onDidChangeWebviewViewVisibility(
+        handle: string,
+        visible: boolean
+    ): Promise<void> {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.setVisible(visible);
+        webviewView.onDidChangeVisibilityEmitter.fire(visible);
+    }
+
+    async $disposeWebviewView(handle: string): Promise<void> {
+        const webviewView = this.getWebviewView(handle);
+        this.webviewViews.delete(handle);
+        webviewView.dispose();
+
+        this.webviewsExt.deleteWebview(handle);
+    }
+
+    protected getWebviewView(handle: string): WebviewViewExtImpl {
+        const entry = this.webviewViews.get(handle);
+        if (!entry) {
+            throw new Error('No webview found');
+        }
+
+        return entry;
+    }
+}
+
+export class WebviewViewExtImpl implements theia.WebviewView {
+
+    readonly onDidChangeVisibilityEmitter = new Emitter<boolean>();
+    readonly onDidChangeVisibility = this.onDidChangeVisibilityEmitter.event;
+
+    readonly onDidDisposeEmitter = new Emitter<void>();
+    readonly onDidDispose = this.onDidDisposeEmitter.event;
+
+    readonly handle: string;
+    readonly proxy: WebviewViewsMain;
+
+    readonly _viewType: string;
+    readonly _webview: WebviewImpl;
+
+    _isDisposed = false;
+    _isVisible: boolean;
+    _title: string | undefined;
+    _description: string | undefined;
+
+    constructor(
+        handle: string,
+        proxy: WebviewViewsMain,
+        viewType: string,
+        title: string | undefined,
+        webview: WebviewImpl,
+        isVisible: boolean,
+    ) {
+        this._viewType = viewType;
+        this._title = title;
+        this.handle = handle;
+        this.proxy = proxy;
+        this._webview = webview;
+        this._isVisible = isVisible;
+    }
+    onDispose: Event<void>;
+
+    dispose(): void {
+        if (this._isDisposed) {
+            return;
+        }
+
+        this._isDisposed = true;
+        this.onDidDisposeEmitter.fire();
+    }
+
+    get title(): string | undefined {
+        this.assertNotDisposed();
+        return this._title;
+    }
+
+    set title(value: string | undefined) {
+        this.assertNotDisposed();
+        if (this.title !== value) {
+            this.title = value;
+            this.proxy.$setWebviewViewTitle(this.handle, value);
+        }
+    }
+
+    get description(): string | undefined {
+        this.assertNotDisposed();
+        return this._description;
+    }
+
+    set description(value: string | undefined) {
+        this.assertNotDisposed();
+        if (this._description !== value) {
+            this._description = value;
+            this.proxy.$setWebviewViewDescription(this.handle, value);
+        }
+    }
+
+    get visible(): boolean { return this._isVisible; }
+    get webview(): WebviewImpl { return this._webview; }
+    get viewType(): string { return this._viewType; }
+
+    setVisible(visible: boolean): void {
+        if (visible === this._isVisible || this._isDisposed) {
+            return;
+        }
+
+        this._isVisible = visible;
+        this.onDidChangeVisibilityEmitter.fire(this._isVisible);
+    }
+
+    show(preserveFocus?: boolean): void {
+        this.assertNotDisposed();
+        this.proxy.$show(this.handle, !!preserveFocus);
+    }
+
+    protected assertNotDisposed(): void {
+        if (this._isDisposed) {
+            throw new Error('Webview is disposed');
+        }
+    }
+}
+

package/src/plugin/webviews.ts

@@ -27,12 +27,16 @@ import { PluginIconPath } from './plugin-icon-path';
 export class WebviewsExtImpl implements WebviewsExt {
     private readonly proxy: WebviewsMain;
     private readonly webviewPanels = new Map<string, WebviewPanelImpl>();
+    private readonly webviews = new Map<string, WebviewImpl>();
     private readonly serializers = new Map<string, {
         serializer: theia.WebviewPanelSerializer,
         plugin: Plugin
     }>();
     private initData: WebviewInitData | undefined;
 
+    readonly onDidDisposeEmitter = new Emitter<void>();
+    readonly onDidDispose: Event<void> = this.onDidDisposeEmitter.event;
+
     constructor(
         rpc: RPCProtocol,
         private readonly workspace: WorkspaceExtImpl,
@@ -49,6 +53,11 @@ export class WebviewsExtImpl implements WebviewsExt {
         const panel = this.getWebviewPanel(handle);
         if (panel) {
             panel.webview.onMessageEmitter.fire(message);
+        } else {
+            const webview = this.getWebview(handle);
+            if (webview) {
+                webview.onMessageEmitter.fire(message);
+            }
         }
     }
     $onDidChangeWebviewPanelViewState(handle: string, newState: WebviewPanelViewState): void {
@@ -128,6 +137,19 @@ export class WebviewsExtImpl implements WebviewsExt {
         return panel;
     }
 
+    createNewWebview(
+        options: theia.WebviewPanelOptions & theia.WebviewOptions,
+        plugin: Plugin,
+        viewId: string
+    ): WebviewImpl {
+        if (!this.initData) {
+            throw new Error('Webviews are not initialized');
+        }
+        const webview = new WebviewImpl(viewId, this.proxy, options, this.initData, this.workspace, plugin);
+        this.webviews.set(viewId, webview);
+        return webview;
+    }
+
     registerWebviewPanelSerializer(
         viewType: string,
         serializer: theia.WebviewPanelSerializer,
@@ -152,6 +174,14 @@ export class WebviewsExtImpl implements WebviewsExt {
         }
         return undefined;
     }
+
+    public deleteWebview(handle: string): void {
+        this.webviews.delete(handle);
+    }
+
+    public getWebview(handle: string): WebviewImpl | undefined {
+        return this.webviews.get(handle);
+    }
 }
 
 export class WebviewImpl implements theia.Webview {

package/src/plugin/workspace.ts

@@ -56,6 +56,10 @@ export class WorkspaceExtImpl implements WorkspaceExt {
     private searchInWorkspaceEmitter: Emitter<{ result?: theia.TextSearchResult, searchId: number }> = new Emitter<{ result?: theia.TextSearchResult, searchId: number }>();
     protected workspaceSearchSequence: number = 0;
 
+    private _trusted?: boolean = undefined;
+    private didGrantWorkspaceTrustEmitter = new Emitter<void>();
+    public readonly onDidGrantWorkspaceTrust: Event<void> = this.didGrantWorkspaceTrustEmitter.event;
+
     constructor(rpc: RPCProtocol,
         private editorsAndDocuments: EditorsAndDocumentsExtImpl,
         private messageService: MessageRegistryExt) {
@@ -418,4 +422,23 @@ export class WorkspaceExtImpl implements WorkspaceExt {
             this.workspaceFileUri = URI.parse(workspace.resource.toString());
         }
     }
+
+    get trusted(): boolean {
+        if (this._trusted === undefined) {
+            this.requestWorkspaceTrust();
+        }
+        return !!this._trusted;
+    }
+
+    requestWorkspaceTrust(options?: theia.WorkspaceTrustRequestOptions): Promise<boolean | undefined> {
+        return this.proxy.$requestWorkspaceTrust(options);
+    }
+
+    $onWorkspaceTrustChanged(trust: boolean | undefined): void {
+        if (!this._trusted && trust) {
+            this._trusted = trust;
+            this.didGrantWorkspaceTrustEmitter.fire();
+        }
+    }
+
 }