@theia/core 1.43.1 → 1.45.0

package/src/electron-common/electron-api.ts

@@ -41,6 +41,9 @@ export type InternalMenuDto = Omit<MenuDto, 'execute' | 'submenu'> & {
 export type WindowEvent = 'maximize' | 'unmaximize' | 'focus';
 
 export interface TheiaCoreAPI {
+    WindowMetadata: {
+        webcontentId: string;
+    }
     getSecurityToken: () => string;
     attachSecurityToken: (endpoint: string) => Promise<void>;
 
@@ -63,6 +66,7 @@ export interface TheiaCoreAPI {
     unMaximize(): void;
     close(): void;
     onWindowEvent(event: WindowEvent, handler: () => void): Disposable;
+    onAboutToClose(handler: () => void): Disposable;
     setCloseRequestHandler(handler: (reason: StopReason) => Promise<boolean>): void;
 
     setSecondaryWindowCloseRequestHandler(windowName: string, handler: () => Promise<boolean>): void;
@@ -87,6 +91,7 @@ export interface TheiaCoreAPI {
 
     sendData(data: Uint8Array): void;
     onData(handler: (data: Uint8Array) => void): Disposable;
+    useNativeElements: boolean;
 }
 
 declare global {
@@ -95,6 +100,7 @@ declare global {
     }
 }
 
+export const CHANNEL_WC_METADATA = 'WebContentMetadata';
 export const CHANNEL_SET_MENU = 'SetMenu';
 export const CHANNEL_SET_MENU_BAR_VISIBLE = 'SetMenuBarVisible';
 export const CHANNEL_INVOKE_MENU = 'InvokeMenu';
@@ -116,6 +122,8 @@ export const CHANNEL_MINIMIZE = 'Minimize';
 export const CHANNEL_MAXIMIZE = 'Maximize';
 export const CHANNEL_IS_MAXIMIZED = 'IsMaximized';
 
+export const CHANNEL_ABOUT_TO_CLOSE = 'AboutToClose';
+
 export const CHANNEL_UNMAXIMIZE = 'UnMaximize';
 export const CHANNEL_ON_WINDOW_EVENT = 'OnWindowEvent';
 export const CHANNEL_TOGGLE_DEVTOOLS = 'ToggleDevtools';

package/src/electron-main/electron-api-main.ts

@@ -51,7 +51,9 @@ import {
     CHANNEL_TOGGLE_FULL_SCREEN,
     CHANNEL_IS_MAXIMIZED,
     CHANNEL_REQUEST_SECONDARY_CLOSE,
-    CHANNEL_SET_BACKGROUND_COLOR
+    CHANNEL_SET_BACKGROUND_COLOR,
+    CHANNEL_WC_METADATA,
+    CHANNEL_ABOUT_TO_CLOSE
 } from '../electron-common/electron-api';
 import { ElectronMainApplication, ElectronMainApplicationContribution } from './electron-main-application';
 import { Disposable, DisposableCollection, isOSX, MaybePromise } from '../common';
@@ -65,6 +67,10 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
     protected readonly openPopups = new Map<number, Menu>();
 
     onStart(application: ElectronMainApplication): MaybePromise<void> {
+        ipcMain.on(CHANNEL_WC_METADATA, event => {
+            event.returnValue = event.sender.id.toString();
+        });
+
         // electron security token
         ipcMain.on(CHANNEL_GET_SECURITY_TOKEN, event => {
             event.returnValue = this.electronSecurityToken.value;
@@ -254,6 +260,19 @@ export namespace TheiaRendererAPI {
         wc.send(CHANNEL_ON_WINDOW_EVENT, event);
     }
 
+    export function sendAboutToClose(wc: WebContents): Promise<void> {
+        return new Promise<void>(resolve => {
+            const channelNr = nextReplyChannel++;
+            const replyChannel = `aboutToClose${channelNr}`;
+            const l = createDisposableListener(ipcMain, replyChannel, e => {
+                l.dispose();
+                resolve();
+            });
+
+            wc.send(CHANNEL_ABOUT_TO_CLOSE, replyChannel);
+        });
+    }
+
     export function requestClose(wc: WebContents, stopReason: StopReason): Promise<boolean> {
         const channelNr = nextReplyChannel++;
         const confirmChannel = `confirm-${channelNr}`;

package/src/electron-main/electron-main-application-module.ts

@@ -22,12 +22,12 @@ import { ElectronSecurityToken } from '../electron-common/electron-token';
 import { ElectronMainWindowService, electronMainWindowServicePath } from '../electron-common/electron-main-window-service';
 import { ElectronMainApplication, ElectronMainApplicationContribution, ElectronMainProcessArgv } from './electron-main-application';
 import { ElectronMainWindowServiceImpl } from './electron-main-window-service-impl';
-import { ElectronMessagingContribution } from './messaging/electron-messaging-contribution';
-import { ElectronMessagingService } from './messaging/electron-messaging-service';
-import { ElectronConnectionHandler } from '../electron-common/messaging/electron-connection-handler';
-import { ElectronSecurityTokenService } from './electron-security-token-service';
 import { TheiaBrowserWindowOptions, TheiaElectronWindow, TheiaElectronWindowFactory, WindowApplicationConfig } from './theia-electron-window';
 import { TheiaMainApi } from './electron-api-main';
+import { ElectronMessagingContribution } from './messaging/electron-messaging-contribution';
+import { ElectronSecurityTokenService } from './electron-security-token-service';
+import { ElectronMessagingService } from './messaging/electron-messaging-service';
+import { ElectronConnectionHandler } from './messaging/electron-connection-handler';
 
 const electronSecurityToken: ElectronSecurityToken = { value: v4() };
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -36,6 +36,7 @@ const electronSecurityToken: ElectronSecurityToken = { value: v4() };
 export default new ContainerModule(bind => {
     bind(ElectronMainApplication).toSelf().inSingletonScope();
     bind(ElectronMessagingContribution).toSelf().inSingletonScope();
+    bind(ElectronMainApplicationContribution).toService(ElectronMessagingContribution);
     bind(ElectronSecurityToken).toConstantValue(electronSecurityToken);
     bind(ElectronSecurityTokenService).toSelf().inSingletonScope();
 
@@ -43,7 +44,6 @@ export default new ContainerModule(bind => {
     bindContributionProvider(bind, ElectronMessagingService.Contribution);
     bindContributionProvider(bind, ElectronMainApplicationContribution);
 
-    bind(ElectronMainApplicationContribution).toService(ElectronMessagingContribution);
     bind(TheiaMainApi).toSelf().inSingletonScope();
     bind(ElectronMainApplicationContribution).toService(TheiaMainApi);
 

package/src/electron-main/electron-main-application.ts

@@ -20,6 +20,7 @@ import * as path from 'path';
 import { Argv } from 'yargs';
 import { AddressInfo } from 'net';
 import { promises as fs } from 'fs';
+import { existsSync, mkdirSync } from 'fs-extra';
 import { fork, ForkOptions } from 'child_process';
 import { DefaultTheme, FrontendApplicationConfig } from '@theia/application-package/lib/application-props';
 import URI from '../common/uri';
@@ -53,19 +54,13 @@ export interface ElectronMainCommandOptions {
      */
     readonly file?: string;
 
-}
+    readonly cwd: string;
 
-/**
- * Fields related to a launch event.
- *
- * This kind of event is triggered in two different contexts:
- *  1. The app is launched for the first time, `secondInstance` is false.
- *  2. The app is already running but user relaunches it, `secondInstance` is true.
- */
-export interface ElectronMainExecutionParams {
+    /**
+     * If the app is launched for the first time, `secondInstance` is false.
+     * If the app is already running but user relaunches it, `secondInstance` is true.
+     */
     readonly secondInstance: boolean;
-    readonly argv: string[];
-    readonly cwd: string;
 }
 
 /**
@@ -171,6 +166,8 @@ export class ElectronMainApplication {
     @inject(TheiaElectronWindowFactory)
     protected readonly windowFactory: TheiaElectronWindowFactory;
 
+    protected isPortable = this.makePortable();
+
     protected readonly electronStore = new Storage<{
         windowstate?: TheiaBrowserWindowOptions
     }>();
@@ -194,24 +191,59 @@ export class ElectronMainApplication {
         return this._config;
     }
 
+    protected makePortable(): boolean {
+        const dataFolderPath = path.join(app.getAppPath(), 'data');
+        const appDataPath = path.join(dataFolderPath, 'app-data');
+        if (existsSync(dataFolderPath)) {
+            if (!existsSync(appDataPath)) {
+                mkdirSync(appDataPath);
+            }
+            app.setPath('userData', appDataPath);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
     async start(config: FrontendApplicationConfig): Promise<void> {
-        this.useNativeWindowFrame = this.getTitleBarStyle(config) === 'native';
-        this._config = config;
-        this.hookApplicationEvents();
-        this.showInitialWindow();
-        const port = await this.startBackend();
-        this._backendPort.resolve(port);
-        await app.whenReady();
-        await this.attachElectronSecurityToken(port);
-        await this.startContributions();
-        await this.launch({
-            secondInstance: false,
-            argv: this.processArgv.getProcessArgvWithoutBin(process.argv),
-            cwd: process.cwd()
-        });
+        const argv = this.processArgv.getProcessArgvWithoutBin(process.argv);
+        createYargs(argv, process.cwd())
+            .command('$0 [file]', false,
+                cmd => cmd
+                    .option('electronUserData', {
+                        type: 'string',
+                        describe: 'The area where the electron main process puts its data'
+                    })
+                    .positional('file', { type: 'string' }),
+                async args => {
+                    if (args.electronUserData) {
+                        console.info(`using electron user data area : '${args.electronUserData}'`);
+                        await fs.mkdir(args.electronUserData, { recursive: true });
+                        app.setPath('userData', args.electronUserData);
+                    }
+                    this.useNativeWindowFrame = this.getTitleBarStyle(config) === 'native';
+                    this._config = config;
+                    this.hookApplicationEvents();
+                    this.showInitialWindow();
+                    const port = await this.startBackend();
+                    this._backendPort.resolve(port);
+                    await app.whenReady();
+                    await this.attachElectronSecurityToken(port);
+                    await this.startContributions();
+
+                    this.handleMainCommand({
+                        file: args.file,
+                        cwd: process.cwd(),
+                        secondInstance: false
+                    });
+                },
+            ).parse();
     }
 
     protected getTitleBarStyle(config: FrontendApplicationConfig): 'native' | 'custom' {
+        if ('THEIA_ELECTRON_DISABLE_NATIVE_ELEMENTS' in process.env && process.env.THEIA_ELECTRON_DISABLE_NATIVE_ELEMENTS === '1') {
+            return 'custom';
+        }
         if (isOSX) {
             return 'native';
         }
@@ -256,7 +288,9 @@ export class ElectronMainApplication {
     }
 
     protected showInitialWindow(): void {
-        if (this.config.electron.showWindowEarly) {
+        if (this.config.electron.showWindowEarly &&
+            !('THEIA_ELECTRON_NO_EARLY_WINDOW' in process.env && process.env.THEIA_ELECTRON_NO_EARLY_WINDOW === '1')) {
+            console.log('Showing main window early');
             app.whenReady().then(async () => {
                 const options = await this.getLastWindowOptions();
                 this.initialWindow = await this.createWindow({ ...options });
@@ -265,15 +299,6 @@ export class ElectronMainApplication {
         }
     }
 
-    protected async launch(params: ElectronMainExecutionParams): Promise<void> {
-        createYargs(params.argv, params.cwd)
-            .command('$0 [file]', false,
-                cmd => cmd
-                    .positional('file', { type: 'string' }),
-                args => this.handleMainCommand(params, { file: args.file }),
-            ).parse();
-    }
-
     /**
      * Use this rather than creating `BrowserWindow` instances from scratch, since some security parameters need to be set, this method will do it.
      *
@@ -372,7 +397,7 @@ export class ElectronMainApplication {
         electronWindow.webContents.setWindowOpenHandler(() => {
             const { minWidth, minHeight } = this.getDefaultOptions();
             const options: BrowserWindowConstructorOptions = {
-                ...this.getDefaultTheiaWindowBounds(),
+                ...this.getDefaultTheiaSecondaryWindowBounds(),
                 // We always need the native window frame for now because the secondary window does not have Theia's title bar by default.
                 // In 'custom' title bar mode this would leave the window without any window controls (close, min, max)
                 // TODO set to this.useNativeWindowFrame when secondary windows support a custom title bar.
@@ -399,15 +424,15 @@ export class ElectronMainApplication {
         app.quit();
     }
 
-    protected async handleMainCommand(params: ElectronMainExecutionParams, options: ElectronMainCommandOptions): Promise<void> {
-        if (params.secondInstance === false) {
+    protected async handleMainCommand(options: ElectronMainCommandOptions): Promise<void> {
+        if (options.secondInstance === false) {
             await this.openWindowWithWorkspace(''); // restore previous workspace.
         } else if (options.file === undefined) {
             await this.openDefaultWindow();
         } else {
             let workspacePath: string | undefined;
             try {
-                workspacePath = await fs.realpath(path.resolve(params.cwd, options.file));
+                workspacePath = await fs.realpath(path.resolve(options.cwd, options.file));
             } catch {
                 console.error(`Could not resolve the workspace path. "${options.file}" is not a valid 'file' option. Falling back to the default workspace location.`);
             }
@@ -438,6 +463,10 @@ export class ElectronMainApplication {
         };
     }
 
+    protected getDefaultTheiaSecondaryWindowBounds(): TheiaBrowserWindowOptions {
+        return {};
+    }
+
     protected getDefaultTheiaWindowBounds(): TheiaBrowserWindowOptions {
         // The `screen` API must be required when the application is ready.
         // See: https://electronjs.org/docs/api/screen#screen
@@ -461,7 +490,7 @@ export class ElectronMainApplication {
      */
     protected attachSaveWindowState(electronWindow: BrowserWindow): void {
         const windowStateListeners = new DisposableCollection();
-        let delayedSaveTimeout: NodeJS.Timer | undefined;
+        let delayedSaveTimeout: NodeJS.Timeout | undefined;
         const saveWindowStateDelayed = () => {
             if (delayedSaveTimeout) {
                 clearTimeout(delayedSaveTimeout);
@@ -547,8 +576,8 @@ export class ElectronMainApplication {
                 backendProcess.on('error', error => {
                     reject(error);
                 });
-                backendProcess.on('exit', () => {
-                    reject(new Error('backend process exited'));
+                backendProcess.on('exit', code => {
+                    reject(code);
                 });
                 app.on('quit', () => {
                     // Only issue a kill signal if the backend process is running.
@@ -622,9 +651,8 @@ export class ElectronMainApplication {
         if (wrapper) {
             const listener = wrapper.onDidClose(async () => {
                 listener.dispose();
-                await this.launch({
+                await this.handleMainCommand({
                     secondInstance: false,
-                    argv: this.processArgv.getProcessArgvWithoutBin(process.argv),
                     cwd: process.cwd()
                 });
                 this.restarting = false;

package/src/electron-main/messaging/electron-messaging-contribution.ts

@@ -16,15 +16,15 @@
 
 import { WebContents } from '@theia/electron/shared/electron';
 import { inject, injectable, named, postConstruct } from 'inversify';
-import { ContributionProvider } from '../../common/contribution-provider';
-import { MessagingContribution } from '../../node/messaging/messaging-contribution';
-import { ElectronConnectionHandler } from '../../electron-common/messaging/electron-connection-handler';
-import { ElectronMainApplicationContribution } from '../electron-main-application';
-import { ElectronMessagingService } from './electron-messaging-service';
+import { ConnectionHandlers } from '../../node/messaging/default-messaging-service';
 import { AbstractChannel, Channel, ChannelMultiplexer, MessageProvider } from '../../common/message-rpc/channel';
-import { ConnectionHandler, Emitter, WriteBuffer } from '../../common';
+import { ConnectionHandler, ContributionProvider, Emitter, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
 import { TheiaRendererAPI } from '../electron-api-main';
+import { MessagingService } from '../../node';
+import { ElectronMessagingService } from './electron-messaging-service';
+import { ElectronConnectionHandler } from './electron-connection-handler';
+import { ElectronMainApplicationContribution } from '../electron-main-application';
 
 /**
  * This component replicates the role filled by `MessagingContribution` but for Electron.
@@ -36,37 +36,54 @@ import { TheiaRendererAPI } from '../electron-api-main';
 
 @injectable()
 export class ElectronMessagingContribution implements ElectronMainApplicationContribution, ElectronMessagingService {
-
     @inject(ContributionProvider) @named(ElectronMessagingService.Contribution)
     protected readonly messagingContributions: ContributionProvider<ElectronMessagingService.Contribution>;
 
     @inject(ContributionProvider) @named(ElectronConnectionHandler)
     protected readonly connectionHandlers: ContributionProvider<ConnectionHandler>;
 
-    protected readonly channelHandlers = new MessagingContribution.ConnectionHandlers<Channel>();
+    protected readonly channelHandlers = new ConnectionHandlers<Channel>();
+
     /**
      * Each electron window has a main channel and its own multiplexer to route multiple client messages the same IPC connection.
      */
-    protected readonly windowChannelMultiplexer = new Map<number, { channel: ElectronWebContentChannel, multiplexer: ChannelMultiplexer }>();
+    protected readonly openChannels = new Map<number, ElectronWebContentChannel>();
 
     @postConstruct()
     protected init(): void {
         TheiaRendererAPI.onIpcData((sender, data) => this.handleIpcEvent(sender, data));
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ipcChannel(spec: string, callback: (params: any, channel: Channel) => void): void {
+        this.channelHandlers.push(spec, callback);
+    }
+
+    onStart(): void {
+        for (const contribution of this.messagingContributions.getContributions()) {
+            contribution.configure(this);
+        }
+        for (const connectionHandler of this.connectionHandlers.getContributions()) {
+            this.channelHandlers.push(connectionHandler.path, (params, channel) => {
+                connectionHandler.onConnection(channel);
+            });
+        }
+    }
+
     protected handleIpcEvent(sender: WebContents, data: Uint8Array): void {
         // Get the multiplexer for a given window id
         try {
-            const windowChannelData = this.windowChannelMultiplexer.get(sender.id) ?? this.createWindowChannelData(sender);
-            windowChannelData!.channel.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
+            const windowChannel = this.openChannels.get(sender.id) ?? this.createWindowChannel(sender);
+            windowChannel.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
         } catch (error) {
             console.error('IPC: Failed to handle message', { error, data });
         }
     }
 
-    // Creates a new multiplexer for a given sender/window
-    protected createWindowChannelData(sender: Electron.WebContents): { channel: ElectronWebContentChannel, multiplexer: ChannelMultiplexer } {
-        const mainChannel = this.createWindowMainChannel(sender);
+    // Creates a new channel for a given sender/window
+    protected createWindowChannel(sender: Electron.WebContents): ElectronWebContentChannel {
+        const mainChannel = new ElectronWebContentChannel(sender);
+
         const multiplexer = new ChannelMultiplexer(mainChannel);
         multiplexer.onDidOpenChannel(openEvent => {
             const { channel, id } = openEvent;
@@ -75,41 +92,26 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
                 channel.onClose(() => console.debug(`Closing channel on service path '${id}'.`));
             }
         });
-
-        sender.once('did-navigate', () => this.disposeMultiplexer(sender.id, multiplexer, 'Window was refreshed')); // When refreshing the browser window.
-        sender.once('destroyed', () => this.disposeMultiplexer(sender.id, multiplexer, 'Window was closed')); // When closing the browser window.
-        const data = { channel: mainChannel, multiplexer };
-        this.windowChannelMultiplexer.set(sender.id, data);
-        return data;
-    }
-
-    /**
-     * Creates the main channel to a window.
-     * @param sender The window that the channel should be established to.
-     */
-    protected createWindowMainChannel(sender: WebContents): ElectronWebContentChannel {
-        return new ElectronWebContentChannel(sender);
+        sender.once('did-navigate', () => this.deleteChannel(sender.id, 'Window was refreshed'));
+        sender.once('destroyed', () => this.deleteChannel(sender.id, 'Window was closed'));
+        this.openChannels.set(sender.id, mainChannel);
+        return mainChannel;
     }
 
-    protected disposeMultiplexer(windowId: number, multiplexer: ChannelMultiplexer, reason: string): void {
-        multiplexer.onUnderlyingChannelClose({ reason });
-        this.windowChannelMultiplexer.delete(windowId);
-    }
-
-    onStart(): void {
-        for (const contribution of this.messagingContributions.getContributions()) {
-            contribution.configure(this);
-        }
-        for (const connectionHandler of this.connectionHandlers.getContributions()) {
-            this.channelHandlers.push(connectionHandler.path, (params, channel) => {
-                connectionHandler.onConnection(channel);
+    protected deleteChannel(senderId: number, reason: string): void {
+        const channel = this.openChannels.get(senderId);
+        if (channel) {
+            this.openChannels.delete(senderId);
+            channel.onCloseEmitter.fire({
+                reason: reason
             });
         }
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ipcChannel(spec: string, callback: (params: any, channel: Channel) => void): void {
-        this.channelHandlers.push(spec, callback);
+    protected readonly wsHandlers = new ConnectionHandlers();
+
+    registerConnectionHandler(spec: string, callback: (params: MessagingService.PathParams, channel: Channel) => void): void {
+        this.wsHandlers.push(spec, callback);
     }
 }
 

package/src/electron-main/messaging/electron-messaging-service.ts

@@ -23,6 +23,7 @@ export interface ElectronMessagingService {
      */
     ipcChannel(path: string, callback: (params: ElectronMessagingService.PathParams, socket: Channel) => void): void;
 }
+
 export namespace ElectronMessagingService {
     export interface PathParams {
         [name: string]: string

package/src/electron-main/theia-electron-window.ts

@@ -129,8 +129,9 @@ export class TheiaElectronWindow {
         }, this.toDispose);
     }
 
-    protected doCloseWindow(): void {
+    protected async doCloseWindow(): Promise<void> {
         this.closeIsConfirmed = true;
+        await TheiaRendererAPI.sendAboutToClose(this._window.webContents);
         this._window.close();
     }
 
@@ -139,13 +140,13 @@ export class TheiaElectronWindow {
     }
 
     protected reload(): void {
-        this.handleStopRequest(() => {
+        this.handleStopRequest(async () => {
             this.applicationState = 'init';
             this._window.reload();
         }, StopReason.Reload);
     }
 
-    protected async handleStopRequest(onSafeCallback: () => unknown, reason: StopReason): Promise<boolean> {
+    protected async handleStopRequest(onSafeCallback: () => Promise<unknown>, reason: StopReason): Promise<boolean> {
         // Only confirm close to windows that have loaded our frontend.
         // Both the windows's URL and the FS path of the `index.html` should be converted to the "same" format to be able to compare them. (#11226)
         // Notes:

package/src/node/backend-application.ts

@@ -170,6 +170,8 @@ export class BackendApplication {
     @inject(Stopwatch)
     protected readonly stopwatch: Stopwatch;
 
+    private _configured: Promise<void>;
+
     constructor(
         @inject(ContributionProvider) @named(BackendApplicationContribution)
         protected readonly contributionsProvider: ContributionProvider<BackendApplicationContribution>,
@@ -198,7 +200,7 @@ export class BackendApplication {
     }
 
     protected async initialize(): Promise<void> {
-        for (const contribution of this.contributionsProvider.getContributions()) {
+        await Promise.all(this.contributionsProvider.getContributions().map(async contribution => {
             if (contribution.initialize) {
                 try {
                     await this.measure(contribution.constructor.name + '.initialize',
@@ -208,18 +210,20 @@ export class BackendApplication {
                     console.error('Could not initialize contribution', error);
                 }
             }
-        }
+        }));
+    }
+
+    get configured(): Promise<void> {
+        return this._configured;
     }
 
     @postConstruct()
     protected init(): void {
-        this.configure();
+        this._configured = this.configure();
     }
 
     protected async configure(): Promise<void> {
-        // Do not await the initialization because contributions are expected to handle
-        // concurrent initialize/configure in undefined order if they provide both
-        this.initialize();
+        await this.initialize();
 
         this.app.get('*.js', this.serveGzipped.bind(this, 'text/javascript'));
         this.app.get('*.js.map', this.serveGzipped.bind(this, 'application/json'));
@@ -233,17 +237,16 @@ export class BackendApplication {
         this.app.get('*.woff', this.serveGzipped.bind(this, 'font/woff'));
         this.app.get('*.woff2', this.serveGzipped.bind(this, 'font/woff2'));
 
-        for (const contribution of this.contributionsProvider.getContributions()) {
+        await Promise.all(this.contributionsProvider.getContributions().map(async contribution => {
             if (contribution.configure) {
                 try {
-                    await this.measure(contribution.constructor.name + '.configure',
-                        () => contribution.configure!(this.app)
-                    );
+                    await contribution.configure!(this.app);
                 } catch (error) {
                     console.error('Could not configure contribution', error);
                 }
             }
-        }
+        }));
+        console.info('configured all backend app contributions');
     }
 
     use(...handlers: express.Handler[]): void {

package/src/node/cli.spec.ts

@@ -44,7 +44,7 @@ describe('CliManager', () => {
                 value.resolve(args['foo'] as string);
             }
         });
-        await manager.initializeCli(['-f', 'bla']);
+        await manager.initializeCli(['-f', 'bla'], () => Promise.resolve(), () => Promise.resolve());
         chai.assert.equal(await value.promise, 'bla');
     });
 
@@ -59,14 +59,14 @@ describe('CliManager', () => {
                 value.resolve(args['bar'] as string);
             }
         });
-        await manager.initializeCli(['--foo']);
+        await manager.initializeCli(['--foo'], () => Promise.resolve(), () => Promise.resolve());
         chai.assert.equal(await value.promise, 'my-default');
     });
 
     it('prints help and exits', async () =>
         assertExits(async () => {
             const manager = new TestCliManager();
-            await manager.initializeCli(['--help']);
+            await manager.initializeCli(['--help'], () => Promise.resolve(), () => Promise.resolve());
         })
     );
 });

package/src/node/cli.ts

@@ -35,7 +35,7 @@ export class CliManager {
     constructor(@inject(ContributionProvider) @named(CliContribution)
     protected readonly contributionsProvider: ContributionProvider<CliContribution>) { }
 
-    async initializeCli(argv: string[]): Promise<void> {
+    async initializeCli<T>(argv: string[], postSetArguments: () => Promise<void>, defaultCommand: () => Promise<void>): Promise<void> {
         const pack = require('../../package.json');
         const version = pack.version;
         const command = yargs.version(version);
@@ -43,14 +43,18 @@ export class CliManager {
         for (const contrib of this.contributionsProvider.getContributions()) {
             contrib.configure(command);
         }
-        const args = command
+        await command
             .detectLocale(false)
             .showHelpOnFail(false, 'Specify --help for available options')
             .help('help')
+            .middleware(async args => {
+                for (const contrib of this.contributionsProvider.getContributions()) {
+                    await contrib.setArguments(args);
+                }
+                await postSetArguments();
+            })
+            .command('$0', false, () => { }, defaultCommand)
             .parse(argv);
-        for (const contrib of this.contributionsProvider.getContributions()) {
-            await contrib.setArguments(args);
-        }
     }
 
     protected isExit(): boolean {