@theia/core 1.44.0 → 1.45.0

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

@@ -54,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;
 }
 
 /**
@@ -212,21 +206,38 @@ export class ElectronMainApplication {
     }
 
     async start(config: FrontendApplicationConfig): Promise<void> {
-        const args = this.processArgv.getProcessArgvWithoutBin(process.argv);
-        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: args,
-            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' {
@@ -288,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.
      *
@@ -395,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.
@@ -422,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.`);
             }
@@ -461,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
@@ -645,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/messaging/default-messaging-service.ts

@@ -0,0 +1,129 @@
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, inject, named, interfaces, Container } from 'inversify';
+import { ContributionProvider, ConnectionHandler, bindContributionProvider, servicesPath } from '../../common';
+import { MessagingService } from './messaging-service';
+import { ConnectionContainerModule } from './connection-container-module';
+import Route = require('route-parser');
+import { Channel, ChannelMultiplexer } from '../../common/message-rpc/channel';
+import { FrontendConnectionService } from './frontend-connection-service';
+import { BackendApplicationContribution } from '../backend-application';
+
+export const MessagingContainer = Symbol('MessagingContainer');
+export const MainChannel = Symbol('MainChannel');
+
+@injectable()
+export class DefaultMessagingService implements MessagingService, BackendApplicationContribution {
+    @inject(MessagingContainer)
+    protected readonly container: interfaces.Container;
+
+    @inject(FrontendConnectionService)
+    protected readonly frontendConnectionService: FrontendConnectionService;
+
+    @inject(ContributionProvider) @named(ConnectionContainerModule)
+    protected readonly connectionModules: ContributionProvider<interfaces.ContainerModule>;
+
+    @inject(ContributionProvider) @named(MessagingService.Contribution)
+    protected readonly contributions: ContributionProvider<MessagingService.Contribution>;
+
+    protected readonly channelHandlers = new ConnectionHandlers<Channel>();
+
+    initialize(): void {
+        this.registerConnectionHandler(servicesPath, (_, socket) => this.handleConnection(socket));
+        for (const contribution of this.contributions.getContributions()) {
+            contribution.configure(this);
+        }
+    }
+
+    registerConnectionHandler(path: string, callback: (params: MessagingService.PathParams, mainChannel: Channel) => void): void {
+        this.frontendConnectionService.registerConnectionHandler(path, callback);
+    }
+
+    registerChannelHandler(spec: string, callback: (params: MessagingService.PathParams, channel: Channel) => void): void {
+        this.channelHandlers.push(spec, (params, channel) => callback(params, channel));
+    }
+
+    protected handleConnection(channel: Channel): void {
+        const multiplexer = new ChannelMultiplexer(channel);
+        const channelHandlers = this.getConnectionChannelHandlers(channel);
+        multiplexer.onDidOpenChannel(event => {
+            if (channelHandlers.route(event.id, event.channel)) {
+                console.debug(`Opening channel for service path '${event.id}'.`);
+                event.channel.onClose(() => console.info(`Closing channel on service path '${event.id}'.`));
+            }
+        });
+    }
+
+    protected createMainChannelContainer(socket: Channel): Container {
+        const connectionContainer: Container = this.container.createChild() as Container;
+        connectionContainer.bind(MainChannel).toConstantValue(socket);
+        return connectionContainer;
+    }
+
+    protected getConnectionChannelHandlers(socket: Channel): ConnectionHandlers<Channel> {
+        const connectionContainer = this.createMainChannelContainer(socket);
+        bindContributionProvider(connectionContainer, ConnectionHandler);
+        connectionContainer.load(...this.connectionModules.getContributions());
+        const connectionChannelHandlers = new ConnectionHandlers<Channel>(this.channelHandlers);
+        const connectionHandlers = connectionContainer.getNamed<ContributionProvider<ConnectionHandler>>(ContributionProvider, ConnectionHandler);
+        for (const connectionHandler of connectionHandlers.getContributions(true)) {
+            connectionChannelHandlers.push(connectionHandler.path, (_, channel) => {
+                connectionHandler.onConnection(channel);
+            });
+        }
+        return connectionChannelHandlers;
+    }
+
+}
+
+export class ConnectionHandlers<T> {
+    protected readonly handlers: ((path: string, connection: T) => string | false)[] = [];
+
+    constructor(
+        protected readonly parent?: ConnectionHandlers<T>
+    ) { }
+
+    push(spec: string, callback: (params: MessagingService.PathParams, connection: T) => void): void {
+        const route = new Route(spec);
+        const handler = (path: string, channel: T): string | false => {
+            const params = route.match(path);
+            if (!params) {
+                return false;
+            }
+            callback(params, channel);
+            return route.reverse(params);
+        };
+        this.handlers.push(handler);
+    }
+
+    route(path: string, connection: T): string | false {
+        for (const handler of this.handlers) {
+            try {
+                const result = handler(path, connection);
+                if (result) {
+                    return result;
+                }
+            } catch (e) {
+                console.error(e);
+            }
+        }
+        if (this.parent) {
+            return this.parent.route(path, connection);
+        }
+        return false;
+    }
+}

package/src/node/messaging/frontend-connection-service.ts

@@ -0,0 +1,24 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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-only WITH Classpath-exception-2.0
+
+import { Channel } from '../../common/message-rpc/';
+import { MessagingService } from './messaging-service';
+
+export const FrontendConnectionService = Symbol('FrontendConnectionService');
+
+export interface FrontendConnectionService {
+    registerConnectionHandler(path: string, callback: (params: MessagingService.PathParams, mainChannel: Channel) => void): void;
+}
+

package/src/node/messaging/messaging-backend-module.ts

@@ -15,23 +15,38 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
-import { bindContributionProvider } from '../../common';
-import { BackendApplicationContribution } from '../backend-application';
-import { MessagingContribution, MessagingContainer } from './messaging-contribution';
+import { ConnectionHandler, RpcConnectionHandler, bindContributionProvider } from '../../common';
+// import { BackendApplicationContribution } from '../backend-application';
+import { DefaultMessagingService, MessagingContainer } from './default-messaging-service';
 import { ConnectionContainerModule } from './connection-container-module';
 import { MessagingService } from './messaging-service';
 import { MessagingListener, MessagingListenerContribution } from './messaging-listeners';
+import { FrontendConnectionService } from './frontend-connection-service';
+import { BackendApplicationContribution } from '../backend-application';
+import { connectionCloseServicePath } from '../../common/messaging/connection-management';
+import { WebsocketFrontendConnectionService } from './websocket-frontend-connection-service';
+import { WebsocketEndpoint } from './websocket-endpoint';
 
 export const messagingBackendModule = new ContainerModule(bind => {
     bindContributionProvider(bind, ConnectionContainerModule);
     bindContributionProvider(bind, MessagingService.Contribution);
-    bind(MessagingService.Identifier).to(MessagingContribution).inSingletonScope();
-    bind(MessagingContribution).toDynamicValue(({ container }) => {
-        const child = container.createChild();
-        child.bind(MessagingContainer).toConstantValue(container);
-        return child.get(MessagingService.Identifier);
-    }).inSingletonScope();
-    bind(BackendApplicationContribution).toService(MessagingContribution);
+    bind(DefaultMessagingService).toSelf().inSingletonScope();
+    bind(MessagingService.Identifier).toService(DefaultMessagingService);
+    bind(BackendApplicationContribution).toService(DefaultMessagingService);
+    bind(MessagingContainer).toDynamicValue(({ container }) => container).inSingletonScope();
+    bind(WebsocketEndpoint).toSelf().inSingletonScope();
+    bind(BackendApplicationContribution).toService(WebsocketEndpoint);
+    bind(WebsocketFrontendConnectionService).toSelf().inSingletonScope();
+    bind(FrontendConnectionService).toService(WebsocketFrontendConnectionService);
     bind(MessagingListener).toSelf().inSingletonScope();
     bindContributionProvider(bind, MessagingListenerContribution);
+
+    bind(ConnectionHandler).toDynamicValue(context => {
+        const connectionService = context.container.get<WebsocketFrontendConnectionService>(FrontendConnectionService);
+        return new RpcConnectionHandler<object>(connectionCloseServicePath, () => ({
+            markForClose: (channelId: string) => {
+                connectionService.markForClose(channelId);
+            }
+        }));
+    }).inSingletonScope();
 });

package/src/node/messaging/messaging-service.ts

@@ -14,7 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Socket } from 'socket.io';
 import { Channel } from '../../common/message-rpc/channel';
 
 export interface MessagingService {
@@ -22,7 +21,7 @@ export interface MessagingService {
      * Accept a web socket channel on the given path.
      * A path supports the route syntax: https://github.com/rcs/route-parser#what-can-i-use-in-my-routes.
      */
-    wsChannel(path: string, callback: (params: MessagingService.PathParams, channel: Channel) => void): void;
+    registerChannelHandler(path: string, handler: (params: MessagingService.PathParams, channel: Channel) => void): void;
     /**
      * Accept a web socket connection on the given path.
      * A path supports the route syntax: https://github.com/rcs/route-parser#what-can-i-use-in-my-routes.
@@ -31,8 +30,9 @@ export interface MessagingService {
      * Prefer using web socket channels over establishing new web socket connection. Clients can handle only limited amount of web sockets
      * and excessive amount can cause performance degradation. All web socket channels share a single web socket connection.
      */
-    ws(path: string, callback: (params: MessagingService.PathParams, socket: Socket) => void): void;
+    registerConnectionHandler(path: string, callback: (params: MessagingService.PathParams, mainChannel: Channel) => void): void;
 }
+
 export namespace MessagingService {
     /** Inversify container identifier for the `MessagingService` component. */
     export const Identifier = Symbol('MessagingService');