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

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

@@ -0,0 +1,71 @@
+/********************************************************************************
+ * Copyright (C) 2022 EclipseSource 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 { AuthenticationProvider, AuthenticationService, AuthenticationServiceImpl, AuthenticationSession } from '@theia/core/lib/browser/authentication-service';
+import { inject } from '@theia/core/shared/inversify';
+import { Deferred, timeoutReject } from '@theia/core/lib/common/promise-util';
+import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
+
+export function getAuthenticationProviderActivationEvent(id: string): string { return `onAuthenticationRequest:${id}`; }
+
+/**
+ * Plugin authentiction service that aims to activate additional plugins if sessions are created or queried.
+ */
+export class PluginAuthenticationServiceImpl extends AuthenticationServiceImpl implements AuthenticationService {
+    @inject(HostedPluginSupport) protected readonly pluginService: HostedPluginSupport;
+
+    async getSessions(id: string, scopes?: string[]): Promise<ReadonlyArray<AuthenticationSession>> {
+        await this.tryActivateProvider(id);
+        return super.getSessions(id, scopes);
+    }
+
+    async login(id: string, scopes: string[]): Promise<AuthenticationSession> {
+        await this.tryActivateProvider(id);
+        return super.login(id, scopes);
+    }
+
+    protected async tryActivateProvider(providerId: string): Promise<AuthenticationProvider> {
+        this.pluginService.activateByEvent(getAuthenticationProviderActivationEvent(providerId));
+
+        const provider = this.authenticationProviders.get(providerId);
+        if (provider) {
+            return provider;
+        }
+
+        // When activate has completed, the extension has made the call to `registerAuthenticationProvider`.
+        // However, activate cannot block on this, so the renderer may not have gotten the event yet.
+        return Promise.race([
+            this.waitForProviderRegistration(providerId),
+            timeoutReject<AuthenticationProvider>(5000, 'Timed out waiting for authentication provider to register')
+        ]);
+    }
+
+    protected async waitForProviderRegistration(providerId: string): Promise<AuthenticationProvider> {
+        const waitForRegistration = new Deferred<AuthenticationProvider>();
+        const registration = this.onDidRegisterAuthenticationProvider(info => {
+            if (info.id === providerId) {
+                registration.dispose();
+                const provider = this.authenticationProviders.get(providerId);
+                if (provider) {
+                    waitForRegistration.resolve(provider);
+                } else {
+                    waitForRegistration.reject(new Error(`No authentication provider '${providerId}' is currently registered.`));
+                }
+            }
+        });
+        return waitForRegistration.promise;
+    }
+}

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

@@ -21,7 +21,7 @@ import '../../../src/main/browser/style/comments.css';
 import { ContainerModule } from '@theia/core/shared/inversify';
 import {
     FrontendApplicationContribution, WidgetFactory, bindViewContribution,
-    ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeImpl, TreeWidget, TreeModelImpl, LabelProviderContribution
+    ViewContainerIdentifier, ViewContainer, createTreeContainer, TreeWidget, LabelProviderContribution
 } from '@theia/core/lib/browser';
 import { MaybePromise, CommandContribution, ResourceResolver, bindContributionProvider } from '@theia/core/lib/common';
 import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging';
@@ -76,6 +76,8 @@ import { CustomEditorWidget } from './custom-editors/custom-editor-widget';
 import { CustomEditorService } from './custom-editors/custom-editor-service';
 import { UndoRedoService } from './custom-editors/undo-redo-service';
 import { WebviewFrontendSecurityWarnings } from './webview/webview-frontend-security-warnings';
+import { PluginAuthenticationServiceImpl } from './plugin-authentication-service';
+import { AuthenticationService } from '@theia/core/lib/browser/authentication-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -145,21 +147,21 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(WidgetFactory).toDynamicValue(({ container }) => ({
         id: PLUGIN_VIEW_DATA_FACTORY_ID,
         createWidget: (identifier: TreeViewWidgetIdentifier) => {
-            const child = createTreeContainer(container, {
+            const props = {
                 contextMenuPath: VIEW_ITEM_CONTEXT_MENU,
                 expandOnlyOnExpansionToggleClick: true,
                 expansionTogglePadding: 22,
                 globalSelection: true,
                 leftPadding: 8,
                 search: true
+            };
+            const child = createTreeContainer(container, {
+                props,
+                tree: PluginTree,
+                model: PluginTreeModel,
+                widget: TreeViewWidget,
             });
             child.bind(TreeViewWidgetIdentifier).toConstantValue(identifier);
-            child.bind(PluginTree).toSelf();
-            child.rebind(TreeImpl).toService(PluginTree);
-            child.bind(PluginTreeModel).toSelf();
-            child.rebind(TreeModelImpl).toService(PluginTreeModel);
-            child.bind(TreeViewWidget).toSelf();
-            child.rebind(TreeWidget).toService(TreeViewWidget);
             return child.get(TreeWidget);
         }
     })).inSingletonScope();
@@ -234,4 +236,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bind(WebviewFrontendSecurityWarnings).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(WebviewFrontendSecurityWarnings);
+
+    bind(PluginAuthenticationServiceImpl).toSelf().inSingletonScope();
+    rebind(AuthenticationService).toService(PluginAuthenticationServiceImpl);
 });

package/src/main/browser/view/plugin-view-registry.ts

@@ -20,7 +20,7 @@ import {
     ViewContainerIdentifier, ViewContainerTitleOptions, Widget, FrontendApplicationContribution,
     StatefulWidget, CommonMenus, BaseWidget, TreeViewWelcomeWidget, codicon, ViewContainerPart
 } from '@theia/core/lib/browser';
-import { ViewContainer, View, ViewWelcome } from '../../../common';
+import { ViewContainer, View, ViewWelcome, PluginViewType } from '../../../common';
 import { PluginSharedStyle } from '../plugin-shared-style';
 import { DebugWidget } from '@theia/debug/lib/browser/view/debug-widget';
 import { PluginViewWidget, PluginViewWidgetIdentifier } from './plugin-view-widget';
@@ -31,7 +31,7 @@ import { DebugFrontendApplicationContribution } from '@theia/debug/lib/browser/d
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { CommandRegistry } from '@theia/core/lib/common/command';
 import { MenuModelRegistry } from '@theia/core/lib/common/menu';
-import { Emitter } from '@theia/core/lib/common/event';
+import { Emitter, Event } from '@theia/core/lib/common/event';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 import { ViewContextKeyService } from './view-context-key-service';
 import { PROBLEMS_WIDGET_ID } from '@theia/markers/lib/browser/problem/problem-widget';
@@ -41,6 +41,11 @@ import { TERMINAL_WIDGET_FACTORY_ID } from '@theia/terminal/lib/browser/terminal
 import { TreeViewWidget } from './tree-view-widget';
 import { SEARCH_VIEW_CONTAINER_ID } from '@theia/search-in-workspace/lib/browser/search-in-workspace-factory';
 
+import { WebviewView, WebviewViewResolver } from '../webview-views/webview-views';
+import { WebviewWidget, WebviewWidgetIdentifier } from '../webview/webview';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { v4 } from 'uuid';
+
 export const PLUGIN_VIEW_FACTORY_ID = 'plugin-view';
 export const PLUGIN_VIEW_CONTAINER_FACTORY_ID = 'plugin-view-container';
 export const PLUGIN_VIEW_DATA_FACTORY_ID = 'plugin-view-data';
@@ -95,6 +100,8 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
     private readonly viewDataProviders = new Map<string, ViewDataProvider>();
     private readonly viewDataState = new Map<string, object>();
 
+    private readonly webviewViewResolvers = new Map<string, WebviewViewResolver>();
+
     @postConstruct()
     protected init(): void {
         // VS Code Viewlets
@@ -333,6 +340,63 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return toDispose;
     }
 
+    async registerWebviewView(viewId: string, resolver: WebviewViewResolver): Promise<Disposable> {
+        if (this.webviewViewResolvers.has(viewId)) {
+            throw new Error(`View resolver already registered for ${viewId}`);
+        }
+        this.webviewViewResolvers.set(viewId, resolver);
+
+        const webviewView = await this.createNewWebviewView();
+        const token = CancellationToken.None;
+        this.getView(viewId).then(async view => {
+            if (view) {
+                if (view.isVisible) {
+                    await this.prepareView(view, webviewView.webview.identifier.id);
+                } else {
+                    const toDisposeOnDidExpandView = new DisposableCollection(this.onDidExpandView(async id => {
+                        if (id === viewId) {
+                            dispose();
+                            await this.prepareView(view, webviewView.webview.identifier.id);
+                        }
+                    }));
+                    const dispose = () => toDisposeOnDidExpandView.dispose();
+                    view.disposed.connect(dispose);
+                    toDisposeOnDidExpandView.push(Disposable.create(() => view.disposed.disconnect(dispose)));
+                }
+            }
+        });
+
+        resolver.resolve(webviewView, token);
+
+        return Disposable.create(() => {
+            this.webviewViewResolvers.delete(viewId);
+        });
+    }
+
+    async createNewWebviewView(): Promise<WebviewView> {
+        const webview = await this.widgetManager.getOrCreateWidget<WebviewWidget>(
+            WebviewWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: v4() });
+        webview.setContentOptions({ allowScripts: true });
+
+        let _description: string | undefined;
+
+        return {
+            webview,
+
+            get onDidChangeVisibility(): Event<boolean> { return webview.onDidChangeVisibility; },
+            get onDidDispose(): Event<void> { return webview.onDidDispose; },
+
+            get title(): string | undefined { return webview.title.label; },
+            set title(value: string | undefined) { webview.title.label = value || ''; },
+
+            get description(): string | undefined { return _description; },
+            set description(value: string | undefined) { _description = value; },
+
+            dispose: webview.dispose,
+            show: webview.show
+        };
+    }
+
     registerViewWelcome(viewWelcome: ViewWelcome): Disposable {
         const toDispose = new DisposableCollection();
 
@@ -409,7 +473,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return this.getView(viewId);
     }
 
-    protected async prepareView(widget: PluginViewWidget): Promise<void> {
+    protected async prepareView(widget: PluginViewWidget, webviewId?: string): Promise<void> {
         const data = this.views.get(widget.options.viewId);
         if (!data) {
             return;
@@ -419,7 +483,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             widget.title.label = view.name;
         }
         const currentDataWidget = widget.widgets[0];
-        const viewDataWidget = await this.createViewDataWidget(view.id);
+        const viewDataWidget = await this.createViewDataWidget(view.id, webviewId);
         if (widget.isDisposed) {
             // eslint-disable-next-line no-unused-expressions
             viewDataWidget?.dispose();
@@ -701,8 +765,12 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return toDispose;
     }
 
-    protected async createViewDataWidget(viewId: string): Promise<Widget | undefined> {
+    protected async createViewDataWidget(viewId: string, webviewId?: string): Promise<Widget | undefined> {
         const view = this.views.get(viewId);
+        if (view?.[1]?.type === PluginViewType.Webview) {
+            const webviewWidget = this.widgetManager.getWidget(WebviewWidget.FACTORY_ID, <WebviewWidgetIdentifier>{ id: webviewId });
+            return webviewWidget;
+        }
         const provider = this.viewDataProviders.get(viewId);
         if (!view || !provider) {
             return undefined;

package/src/main/browser/view-column-service.ts

@@ -32,7 +32,7 @@ export class ViewColumnService {
     ) {
         let oldColumnValues = new Map<string, number>();
         const update = async () => {
-            await new Promise((resolve => setTimeout(() => resolve())));
+            await new Promise<void>((resolve => setTimeout(resolve)));
             this.updateViewColumns();
             this.viewColumnIds.forEach((ids: string[], viewColumn: number) => {
                 ids.forEach((id: string) => {

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

@@ -0,0 +1,142 @@
+/********************************************************************************
+ * 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 code copied and modified from https://github.com/microsoft/vscode/blob/e1f0f8f51390dea5df9096718fb6b647ed5a9534/src/vs/workbench/api/browser/mainThreadWebviewViews.ts
+
+import { inject, interfaces } from '@theia/core/shared/inversify';
+import { WebviewViewsMain, MAIN_RPC_CONTEXT, WebviewViewsExt } from '../../../common/plugin-api-rpc';
+import { RPCProtocol } from '../../../common/rpc-protocol';
+import { Disposable, DisposableCollection, ILogger } from '@theia/core';
+import { WebviewView } from './webview-views';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { WebviewsMainImpl } from '../webviews-main';
+import { Widget, WidgetManager } from '@theia/core/lib/browser';
+import { PluginViewRegistry } from '../view/plugin-view-registry';
+
+export class WebviewViewsMainImpl implements WebviewViewsMain, Disposable {
+
+    protected readonly proxy: WebviewViewsExt;
+    protected readonly toDispose = new DisposableCollection(
+        Disposable.create(() => { /* mark as not disposed */ })
+    );
+
+    protected readonly webviewViews = new Map<string, WebviewView>();
+    protected readonly webviewViewProviders = new Map<string, Disposable>();
+    protected readonly widgetManager: WidgetManager;
+    protected readonly pluginViewRegistry: PluginViewRegistry;
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    constructor(rpc: RPCProtocol,
+        container: interfaces.Container,
+        readonly webviewsMain: WebviewsMainImpl
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.WEBVIEW_VIEWS_EXT);
+        this.widgetManager = container.get(WidgetManager);
+        this.pluginViewRegistry = container.get(PluginViewRegistry);
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    async $registerWebviewViewProvider(viewType: string, options: { retainContextWhenHidden?: boolean, serializeBuffersForPostMessage: boolean }): Promise<void> {
+
+        if (this.webviewViewProviders.has(viewType)) {
+            throw new Error(`View provider for ${viewType} already registered`);
+        }
+
+        const registration = await this.pluginViewRegistry.registerWebviewView(viewType, {
+            resolve: async (webviewView: WebviewView, cancellation: CancellationToken) => {
+                const handle = webviewView.webview.identifier.id;
+                this.webviewViews.set(handle, webviewView);
+                this.webviewsMain.hookWebview(webviewView.webview);
+
+                let state: string | undefined;
+                if (webviewView.webview.state) {
+                    try {
+                        state = JSON.parse(webviewView.webview.state);
+                        console.log(state);
+                    } catch (e) {
+                        console.error('Could not load webview state', e, webviewView.webview.state);
+                    }
+                }
+                if (options) {
+                    webviewView.webview.options = options;
+                }
+
+                webviewView.onDidChangeVisibility(visible => {
+                    this.proxy.$onDidChangeWebviewViewVisibility(handle, visible);
+                });
+
+                webviewView.onDidDispose(() => {
+                    this.proxy.$disposeWebviewView(handle);
+                    this.webviewViews.delete(handle);
+                });
+
+                try {
+                    this.proxy.$resolveWebviewView(handle, viewType, webviewView.title, state, cancellation);
+                } catch (error) {
+                    this.logger.error(`Error resolving webview view '${viewType}': ${error}`);
+                    webviewView.webview.setHTML('failed to load plugin webview view');
+                }
+            }
+        });
+
+        this.webviewViewProviders.set(viewType, registration);
+    }
+
+    protected getWebview(handle: string): Widget | undefined {
+        return this.widgetManager.tryGetWidget(handle);
+    }
+
+    $unregisterWebviewViewProvider(viewType: string): void {
+        const provider = this.webviewViewProviders.get(viewType);
+        if (!provider) {
+            throw new Error(`No view provider for ${viewType} registered`);
+        }
+        provider.dispose();
+        this.webviewViewProviders.delete(viewType);
+    }
+
+    $setWebviewViewTitle(handle: string, value: string | undefined): void {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.title = value;
+    }
+
+    $setWebviewViewDescription(handle: string, value: string | undefined): void {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.description = value;
+    }
+
+    $show(handle: string, preserveFocus: boolean): void {
+        const webviewView = this.getWebviewView(handle);
+        webviewView.show(preserveFocus);
+    }
+
+    protected getWebviewView(handle: string): WebviewView {
+        const webviewView = this.webviewViews.get(handle);
+        if (!webviewView) {
+            throw new Error(`No webview view registered for handle '${handle}'`);
+        }
+        return webviewView;
+    }
+
+}

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

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * 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.
+*--------------------------------------------------------------------------------------------*/
+// copied and modified from https://github.com/microsoft/vscode/blob/a4a4cf5ace4472bc4f5176396bb290cafa15c518/src/vs/workbench/contrib/webviewView/browser/webviewViewService.ts
+
+import { CancellationToken, Event } from '@theia/core/lib/common';
+import { WebviewWidget } from '../webview/webview';
+
+export interface WebviewView {
+    title?: string;
+    description?: string;
+    readonly webview: WebviewWidget;
+    readonly onDidChangeVisibility: Event<boolean>;
+    readonly onDidDispose: Event<void>;
+
+    dispose(): void;
+    show(preserveFocus: boolean): void;
+}
+
+export interface WebviewViewResolver {
+    resolve(webviewView: WebviewView, cancellation: CancellationToken): Promise<void>;
+}

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

@@ -22,7 +22,7 @@ import { URI as Uri } from '@theia/core/shared/vscode-uri';
 import { UriComponents } from '../../common/uri-components';
 import { FileSearchService } from '@theia/file-search/lib/common/file-search-service';
 import URI from '@theia/core/lib/common/uri';
-import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { WorkspaceService, WorkspaceTrustService } from '@theia/workspace/lib/browser';
 import { Resource } from '@theia/core/lib/common/resource';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { Emitter, Event, ResourceResolver, CancellationToken } from '@theia/core';
@@ -52,6 +52,8 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
 
     private workspaceService: WorkspaceService;
 
+    private workspaceTrustService: WorkspaceTrustService;
+
     private fsPreferences: FileSystemPreferences;
 
     protected readonly toDispose = new DisposableCollection();
@@ -67,6 +69,7 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
         this.resourceResolver = container.get(TextContentResourceResolver);
         this.pluginServer = container.get(PluginServer);
         this.workspaceService = container.get(WorkspaceService);
+        this.workspaceTrustService = container.get(WorkspaceTrustService);
         this.fsPreferences = container.get(FileSystemPreferences);
 
         this.processWorkspaceFoldersChanged(this.workspaceService.tryGetRoots().map(root => root.resource.toString()));
@@ -76,6 +79,8 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
         this.toDispose.push(this.workspaceService.onWorkspaceLocationChanged(stat => {
             this.proxy.$onWorkspaceLocationChanged(stat);
         }));
+
+        this.workspaceTrustService.getWorkspaceTrust().then(trust => this.proxy.$onWorkspaceTrustChanged(trust));
     }
 
     dispose(): void {
@@ -269,6 +274,9 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
         await this.workspaceService.spliceRoots(start, deleteCount, ...rootsToAdd.map(root => new URI(root)));
     }
 
+    async $requestWorkspaceTrust(_options?: theia.WorkspaceTrustRequestOptions): Promise<boolean | undefined> {
+        return this.workspaceTrustService.requestWorkspaceTrust();
+    }
 }
 
 /**

package/src/main/electron-browser/webview/electron-webview-widget-factory.ts

@@ -35,7 +35,7 @@ export class ElectronWebviewWidgetFactory extends WebviewWidgetFactory {
      * @param endpoint cookie's target url
      */
     protected async attachElectronSecurityCookie(endpoint: string): Promise<void> {
-        await electronRemote.session.defaultSession!.cookies.set({
+        await electronRemote.session.defaultSession.cookies.set({
             url: endpoint,
             name: ElectronSecurityToken,
             value: JSON.stringify(this.container.get(ElectronSecurityToken)),
@@ -59,7 +59,7 @@ export class ElectronCustomEditorWidgetFactory extends CustomEditorWidgetFactory
      * @param endpoint cookie's target url
      */
     protected async attachElectronSecurityCookie(endpoint: string): Promise<void> {
-        await electronRemote.session.defaultSession!.cookies.set({
+        await electronRemote.session.defaultSession.cookies.set({
             url: endpoint,
             name: ElectronSecurityToken,
             value: JSON.stringify(this.container.get(ElectronSecurityToken)),

package/src/main/node/paths/plugin-paths-service.ts

@@ -142,7 +142,7 @@ export class PluginPathsServiceImpl implements PluginPathsService {
 
     private async cleanupOldLogs(parentLogsDir: string): Promise<void> {
         // @ts-ignore - fs-extra types (Even latest version) is not updated with the `withFileTypes` option.
-        const dirEntries = await readdir(parentLogsDir, { withFileTypes: true });
+        const dirEntries = await readdir(parentLogsDir, { withFileTypes: true }) as string[];
         // `Dirent` type is defined in @types/node since 10.10.0
         // However, upgrading the @types/node in theia to 10.11 (as defined in engine field)
         // Causes other packages to break in compilation, so we are using the infamous `any` type...

package/src/main/node/plugin-deployer-impl.ts

@@ -33,7 +33,7 @@ import { PluginDeployerFileHandlerContextImpl } from './plugin-deployer-file-han
 import { PluginDeployerDirectoryHandlerContextImpl } from './plugin-deployer-directory-handler-context-impl';
 import { ILogger, Emitter, ContributionProvider } from '@theia/core';
 import { PluginCliContribution } from './plugin-cli-contribution';
-import { performance } from 'perf_hooks';
+import { Measurement, Stopwatch } from '@theia/core/lib/common';
 
 @injectable()
 export class PluginDeployerImpl implements PluginDeployer {
@@ -50,6 +50,9 @@ export class PluginDeployerImpl implements PluginDeployer {
     @inject(PluginCliContribution)
     protected readonly cliContribution: PluginCliContribution;
 
+    @inject(Stopwatch)
+    protected readonly stopwatch: Stopwatch;
+
     /**
      * Inject all plugin resolvers found at runtime.
      */
@@ -117,7 +120,7 @@ export class PluginDeployerImpl implements PluginDeployer {
             }
         }
 
-        const startDeployTime = performance.now();
+        const deployPlugins = this.measure('deployPlugins');
         const unresolvedUserEntries = context.userEntries.map(id => ({
             id,
             type: PluginType.User
@@ -127,8 +130,9 @@ export class PluginDeployerImpl implements PluginDeployer {
             type: PluginType.System
         }));
         const plugins = await this.resolvePlugins([...unresolvedUserEntries, ...unresolvedSystemEntries]);
+        deployPlugins.log('Resolve plugins list');
         await this.deployPlugins(plugins);
-        this.logMeasurement('Deploy plugins list', startDeployTime);
+        deployPlugins.log('Deploy plugins list');
     }
 
     async undeploy(pluginId: string): Promise<void> {
@@ -138,9 +142,9 @@ export class PluginDeployerImpl implements PluginDeployer {
     }
 
     async deploy(plugin: UnresolvedPluginEntry): Promise<void> {
-        const startDeployTime = performance.now();
+        const deploy = this.measure('deploy');
         await this.deployMultipleEntries([plugin]);
-        this.logMeasurement('Deploy plugin entry', startDeployTime);
+        deploy.log(`Deploy plugin ${plugin}`);
     }
 
     protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[]): Promise<void> {
@@ -310,7 +314,7 @@ export class PluginDeployerImpl implements PluginDeployer {
         return pluginDeployerEntries;
     }
 
-    protected logMeasurement(prefix: string, startTime: number): void {
-        console.log(`${prefix} took: ${(performance.now() - startTime).toFixed(1)} ms`);
+    protected measure(name: string): Measurement {
+        return this.stopwatch.start(name);
     }
 }