@theia/core 1.26.0 → 1.27.0-next.10

package/src/common/messaging/proxy-factory.ts

@@ -16,10 +16,12 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { MessageConnection, ResponseError } from 'vscode-ws-jsonrpc';
+import { ResponseError } from '../message-rpc/rpc-message-encoder';
 import { ApplicationError } from '../application-error';
-import { Event, Emitter } from '../event';
 import { Disposable } from '../disposable';
+import { Emitter, Event } from '../event';
+import { Channel } from '../message-rpc/channel';
+import { RequestHandler, RpcProtocol } from '../message-rpc/rpc-protocol';
 import { ConnectionHandler } from './handler';
 
 export type JsonRpcServer<Client> = Disposable & {
@@ -45,13 +47,19 @@ export class JsonRpcConnectionHandler<T extends object> implements ConnectionHan
         readonly factoryConstructor: new () => JsonRpcProxyFactory<T> = JsonRpcProxyFactory
     ) { }
 
-    onConnection(connection: MessageConnection): void {
+    onConnection(connection: Channel): void {
         const factory = new this.factoryConstructor();
         const proxy = factory.createProxy();
         factory.target = this.targetFactory(proxy);
         factory.listen(connection);
     }
 }
+/**
+ * Factory for creating a new {@link RpcConnection} for a given chanel and {@link RequestHandler}.
+ */
+export type RpcConnectionFactory = (channel: Channel, requestHandler: RequestHandler) => RpcProtocol;
+
+const defaultRPCConnectionFactory: RpcConnectionFactory = (channel, requestHandler) => new RpcProtocol(channel, requestHandler);
 
 /**
  * Factory for JSON-RPC proxy objects.
@@ -95,13 +103,14 @@ export class JsonRpcConnectionHandler<T extends object> implements ConnectionHan
  *
  * @param <T> - The type of the object to expose to JSON-RPC.
  */
+
 export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
 
     protected readonly onDidOpenConnectionEmitter = new Emitter<void>();
     protected readonly onDidCloseConnectionEmitter = new Emitter<void>();
 
-    protected connectionPromiseResolve: (connection: MessageConnection) => void;
-    protected connectionPromise: Promise<MessageConnection>;
+    protected connectionPromiseResolve: (connection: RpcProtocol) => void;
+    protected connectionPromise: Promise<RpcProtocol>;
 
     /**
      * Build a new JsonRpcProxyFactory.
@@ -109,7 +118,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * @param target - The object to expose to JSON-RPC methods calls.  If this
      *   is omitted, the proxy won't be able to handle requests, only send them.
      */
-    constructor(public target?: any) {
+    constructor(public target?: any, protected rpcConnectionFactory = defaultRPCConnectionFactory) {
         this.waitForConnection();
     }
 
@@ -118,9 +127,11 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
             this.connectionPromiseResolve = resolve
         );
         this.connectionPromise.then(connection => {
-            connection.onClose(() =>
-                this.onDidCloseConnectionEmitter.fire(undefined)
-            );
+            connection.channel.onClose(() => {
+                this.onDidCloseConnectionEmitter.fire(undefined);
+                // Wait for connection in case the backend reconnects
+                this.waitForConnection();
+            });
             this.onDidOpenConnectionEmitter.fire(undefined);
         });
     }
@@ -131,11 +142,10 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * This connection will be used to send/receive JSON-RPC requests and
      * response.
      */
-    listen(connection: MessageConnection): void {
-        connection.onRequest((prop, ...args) => this.onRequest(prop, ...args));
-        connection.onNotification((prop, ...args) => this.onNotification(prop, ...args));
-        connection.onDispose(() => this.waitForConnection());
-        connection.listen();
+    listen(channel: Channel): void {
+        const connection = this.rpcConnectionFactory(channel, (meth, args) => this.onRequest(meth, ...args));
+        connection.onNotification(event => this.onNotification(event.method, ...event.args));
+
         this.connectionPromiseResolve(connection);
     }
 
@@ -239,10 +249,10 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
                 new Promise<void>((resolve, reject) => {
                     try {
                         if (isNotify) {
-                            connection.sendNotification(method, ...args);
+                            connection.sendNotification(method, args);
                             resolve(undefined);
                         } else {
-                            const resultPromise = connection.sendRequest(method, ...args) as Promise<any>;
+                            const resultPromise = connection.sendRequest(method, args) as Promise<any>;
                             resultPromise
                                 .catch((err: any) => reject(this.deserializeError(capturedError, err)))
                                 .then((result: any) => resolve(result));
@@ -293,3 +303,4 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
     }
 
 }
+

package/src/common/messaging/web-socket-channel.ts

@@ -16,157 +16,101 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { IWebSocket } from 'vscode-ws-jsonrpc/lib/socket/socket';
-import { Disposable, DisposableCollection } from '../disposable';
-import { Emitter } from '../event';
-
-export class WebSocketChannel implements IWebSocket {
-
+import { Emitter, Event } from '../event';
+import { WriteBuffer } from '../message-rpc';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../message-rpc/uint8-array-message-buffer';
+import { Channel, MessageProvider, ChannelCloseEvent } from '../message-rpc/channel';
+import { DisposableCollection } from '../disposable';
+
+/**
+ * A channel that manages the main websocket connection between frontend and backend. All service channels
+ * are reusing this main channel. (multiplexing). An {@link IWebSocket} abstraction is used to keep the implementation
+ * independent of the actual websocket implementation and its execution context (backend vs. frontend).
+ */
+export class WebSocketChannel implements Channel {
     static wsPath = '/services';
 
-    protected readonly closeEmitter = new Emitter<[number, string]>();
-    protected readonly toDispose = new DisposableCollection(this.closeEmitter);
-
-    constructor(
-        readonly id: number,
-        protected readonly doSend: (content: string) => void
-    ) { }
-
-    dispose(): void {
-        this.toDispose.dispose();
-    }
-
-    protected checkNotDisposed(): void {
-        if (this.toDispose.disposed) {
-            throw new Error('The channel has been disposed.');
-        }
+    protected readonly onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
+    get onClose(): Event<ChannelCloseEvent> {
+        return this.onCloseEmitter.event;
     }
 
-    handleMessage(message: WebSocketChannel.Message): void {
-        if (message.kind === 'ready') {
-            this.fireOpen();
-        } else if (message.kind === 'data') {
-            this.fireMessage(message.content);
-        } else if (message.kind === 'close') {
-            this.fireClose(message.code, message.reason);
-        }
+    protected readonly onMessageEmitter: Emitter<MessageProvider> = new Emitter();
+    get onMessage(): Event<MessageProvider> {
+        return this.onMessageEmitter.event;
     }
 
-    open(path: string): void {
-        this.checkNotDisposed();
-        this.doSend(JSON.stringify(<WebSocketChannel.OpenMessage>{
-            kind: 'open',
-            id: this.id,
-            path
-        }));
+    protected readonly onErrorEmitter: Emitter<unknown> = new Emitter();
+    get onError(): Event<unknown> {
+        return this.onErrorEmitter.event;
     }
 
-    ready(): void {
-        this.checkNotDisposed();
-        this.doSend(JSON.stringify(<WebSocketChannel.ReadyMessage>{
-            kind: 'ready',
-            id: this.id
-        }));
-    }
+    protected toDispose = new DisposableCollection();
 
-    send(content: string): void {
-        this.checkNotDisposed();
-        this.doSend(JSON.stringify(<WebSocketChannel.DataMessage>{
-            kind: 'data',
-            id: this.id,
-            content
+    constructor(protected readonly socket: IWebSocket) {
+        this.toDispose.pushAll([this.onCloseEmitter, this.onMessageEmitter, this.onErrorEmitter]);
+        socket.onClose((reason, code) => this.onCloseEmitter.fire({ reason, code }));
+        socket.onClose(() => this.close());
+        socket.onError(error => this.onErrorEmitter.fire(error));
+        // eslint-disable-next-line arrow-body-style
+        socket.onMessage(data => this.onMessageEmitter.fire(() => {
+            // In the browser context socketIO receives binary messages as ArrayBuffers.
+            // So we have to convert them to a Uint8Array before delegating the message to the read buffer.
+            const buffer = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+            return new Uint8ArrayReadBuffer(buffer);
         }));
     }
 
-    close(code: number = 1000, reason: string = ''): void {
-        if (this.closing) {
-            // Do not try to close the channel if it is already closing.
-            return;
-        }
-        this.checkNotDisposed();
-        this.doSend(JSON.stringify(<WebSocketChannel.CloseMessage>{
-            kind: 'close',
-            id: this.id,
-            code,
-            reason
-        }));
-        this.fireClose(code, reason);
-    }
+    getWriteBuffer(): WriteBuffer {
+        const result = new Uint8ArrayWriteBuffer();
 
-    tryClose(code: number = 1000, reason: string = ''): void {
-        if (this.closing || this.toDispose.disposed) {
-            // Do not try to close the channel if it is already closing or disposed.
-            return;
-        }
-        this.doSend(JSON.stringify(<WebSocketChannel.CloseMessage>{
-            kind: 'close',
-            id: this.id,
-            code,
-            reason
-        }));
-        this.fireClose(code, reason);
-    }
+        result.onCommit(buffer => {
+            if (this.socket.isConnected()) {
+                this.socket.send(buffer);
+            }
+        });
 
-    protected fireOpen: () => void = () => { };
-    onOpen(cb: () => void): void {
-        this.checkNotDisposed();
-        this.fireOpen = cb;
-        this.toDispose.push(Disposable.create(() => this.fireOpen = () => { }));
+        return result;
     }
 
-    protected fireMessage: (data: any) => void = () => { };
-    onMessage(cb: (data: any) => void): void {
-        this.checkNotDisposed();
-        this.fireMessage = cb;
-        this.toDispose.push(Disposable.create(() => this.fireMessage = () => { }));
-    }
-
-    fireError: (reason: any) => void = () => { };
-    onError(cb: (reason: any) => void): void {
-        this.checkNotDisposed();
-        this.fireError = cb;
-        this.toDispose.push(Disposable.create(() => this.fireError = () => { }));
-    }
-
-    protected closing = false;
-    protected fireClose(code: number, reason: string): void {
-        if (this.closing) {
-            return;
-        }
-        this.closing = true;
-        try {
-            this.closeEmitter.fire([code, reason]);
-        } finally {
-            this.closing = false;
-        }
-        this.dispose();
-    }
-    onClose(cb: (code: number, reason: string) => void): Disposable {
-        this.checkNotDisposed();
-        return this.closeEmitter.event(([code, reason]) => cb(code, reason));
+    close(): void {
+        this.toDispose.dispose();
+        this.socket.close();
     }
-
 }
-export namespace WebSocketChannel {
-    export interface OpenMessage {
-        kind: 'open'
-        id: number
-        path: string
-    }
-    export interface ReadyMessage {
-        kind: 'ready'
-        id: number
-    }
-    export interface DataMessage {
-        kind: 'data'
-        id: number
-        content: string
-    }
-    export interface CloseMessage {
-        kind: 'close'
-        id: number
-        code: number
-        reason: string
-    }
-    export type Message = OpenMessage | ReadyMessage | DataMessage | CloseMessage;
+
+/**
+ * An abstraction that enables reuse of the `{@link WebSocketChannel} class in the frontend and backend
+ * independent of the actual underlying socket implementation.
+ */
+export interface IWebSocket {
+    /**
+     * Sends the given message over the web socket in binary format.
+     * @param message The binary message.
+     */
+    send(message: Uint8Array): void;
+    /**
+     * Closes the websocket from the local side.
+     */
+    close(): void;
+    /**
+     * The connection state of the web socket.
+     */
+    isConnected(): boolean;
+    /**
+     * Listener callback to handle incoming messages.
+     * @param cb The callback.
+     */
+    onMessage(cb: (message: Uint8Array) => void): void;
+    /**
+     * Listener callback to handle socket errors.
+     * @param cb The callback.
+     */
+    onError(cb: (reason: any) => void): void;
+    /**
+     * Listener callback to handle close events (Remote side).
+     * @param cb The callback.
+     */
+    onClose(cb: (reason: string, code?: number) => void): void;
 }
+

package/src/electron-browser/messaging/electron-ipc-connection-provider.ts

@@ -17,9 +17,11 @@
 import { Event as ElectronEvent, ipcRenderer } from '@theia/electron/shared/electron';
 import { injectable, interfaces } from 'inversify';
 import { JsonRpcProxy } from '../../common/messaging';
-import { WebSocketChannel } from '../../common/messaging/web-socket-channel';
 import { AbstractConnectionProvider } from '../../common/messaging/abstract-connection-provider';
 import { THEIA_ELECTRON_IPC_CHANNEL_NAME } from '../../electron-common/messaging/electron-connection-handler';
+import { Emitter, Event } from '../../common';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
+import { Channel, MessageProvider } from '../../common/message-rpc/channel';
 
 export interface ElectronIpcOptions {
 }
@@ -36,15 +38,27 @@ export class ElectronIpcConnectionProvider extends AbstractConnectionProvider<El
 
     constructor() {
         super();
-        ipcRenderer.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (event: ElectronEvent, data: string) => {
-            this.handleIncomingRawMessage(data);
-        });
+        this.initializeMultiplexer();
     }
 
-    protected createChannel(id: number): WebSocketChannel {
-        return new WebSocketChannel(id, content => {
-            ipcRenderer.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, content);
+    protected createMainChannel(): Channel {
+        const onMessageEmitter = new Emitter<MessageProvider>();
+        ipcRenderer.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (_event: ElectronEvent, data: Uint8Array) => {
+            onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
         });
+        return {
+            close: () => Event.None,
+            getWriteBuffer: () => {
+                const writer = new Uint8ArrayWriteBuffer();
+                writer.onCommit(buffer =>
+                    ipcRenderer.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, buffer)
+                );
+                return writer;
+            },
+            onClose: Event.None,
+            onError: Event.None,
+            onMessage: onMessageEmitter.event
+        };
     }
 
 }

package/src/electron-browser/messaging/electron-ws-connection-provider.ts

@@ -15,9 +15,9 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
-import { WebSocketChannel } from '../../common/messaging/web-socket-channel';
 import { WebSocketConnectionProvider, WebSocketOptions } from '../../browser/messaging/ws-connection-provider';
 import { FrontendApplicationContribution } from '../../browser/frontend-application';
+import { Channel } from '../../common';
 
 /**
  * Customized connection provider between the frontend and the backend in electron environment.
@@ -34,16 +34,13 @@ export class ElectronWebSocketConnectionProvider extends WebSocketConnectionProv
 
     onStop(): void {
         this.stopping = true;
-        // Close the websocket connection `onStop`. Otherwise, the channels will be closed with 30 sec (`MessagingContribution#checkAliveTimeout`) delay.
+        // Manually close the websocket connections `onStop`. Otherwise, the channels will be closed with 30 sec (`MessagingContribution#checkAliveTimeout`) delay.
         // https://github.com/eclipse-theia/theia/issues/6499
-        for (const channel of [...this.channels.values()]) {
-            // `1001` indicates that an endpoint is "going away", such as a server going down or a browser having navigated away from a page.
-            // But we cannot use `1001`: https://github.com/TypeFox/vscode-ws-jsonrpc/issues/15
-            channel.close(1000, 'The frontend is "going away"...');
-        }
+        // `1001` indicates that an endpoint is "going away", such as a server going down or a browser having navigated away from a page.
+        this.channelMultiPlexer?.onUnderlyingChannelClose({ reason: 'The frontend is "going away"', code: 1001 });
     }
 
-    override openChannel(path: string, handler: (channel: WebSocketChannel) => void, options?: WebSocketOptions): void {
+    override async openChannel(path: string, handler: (channel: Channel) => void, options?: WebSocketOptions): Promise<void> {
         if (!this.stopping) {
             super.openChannel(path, handler, options);
         }

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

@@ -16,24 +16,23 @@
 
 import { IpcMainEvent, ipcMain, WebContents } from '@theia/electron/shared/electron';
 import { inject, injectable, named, postConstruct } from 'inversify';
-import { MessageConnection } from 'vscode-ws-jsonrpc';
-import { createWebSocketConnection } from 'vscode-ws-jsonrpc/lib/socket/connection';
 import { ContributionProvider } from '../../common/contribution-provider';
-import { WebSocketChannel } from '../../common/messaging/web-socket-channel';
 import { MessagingContribution } from '../../node/messaging/messaging-contribution';
-import { ConsoleLogger } from '../../node/messaging/logger';
 import { ElectronConnectionHandler, THEIA_ELECTRON_IPC_CHANNEL_NAME } from '../../electron-common/messaging/electron-connection-handler';
 import { ElectronMainApplicationContribution } from '../electron-main-application';
 import { ElectronMessagingService } from './electron-messaging-service';
+import { Channel, ChannelCloseEvent, ChannelMultiplexer, MessageProvider } from '../../common/message-rpc/channel';
+import { Emitter, Event, WriteBuffer } from '../../common';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
 
 /**
  * This component replicates the role filled by `MessagingContribution` but for Electron.
  * Unlike the WebSocket based implementation, we do not expect to receive
  * connection events. Instead, we'll create channels based on incoming `open`
  * events on the `ipcMain` channel.
- *
  * This component allows communication between renderer process (frontend) and electron main process.
  */
+
 @injectable()
 export class ElectronMessagingContribution implements ElectronMainApplicationContribution, ElectronMessagingService {
 
@@ -43,89 +42,112 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
     @inject(ContributionProvider) @named(ElectronConnectionHandler)
     protected readonly connectionHandlers: ContributionProvider<ElectronConnectionHandler>;
 
-    protected readonly channelHandlers = new MessagingContribution.ConnectionHandlers<WebSocketChannel>();
-    protected readonly windowChannels = new Map<number, Map<number, WebSocketChannel>>();
+    protected readonly channelHandlers = new MessagingContribution.ConnectionHandlers<Channel>();
+    /**
+     * Each electron window has a main chanel and its own multiplexer to route multiple client messages the same IPC connection.
+     */
+    protected readonly windowChannelMultiplexer = new Map<number, { channel: ElectronWebContentChannel, multiPlexer: ChannelMultiplexer }>();
 
     @postConstruct()
     protected init(): void {
-        ipcMain.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (event: IpcMainEvent, data: string) => {
-            this.handleIpcMessage(event, data);
+        ipcMain.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (event: IpcMainEvent, data: Uint8Array) => {
+            this.handleIpcEvent(event, data);
         });
     }
 
+    protected handleIpcEvent(event: IpcMainEvent, data: Uint8Array): void {
+        const sender = event.sender;
+        // 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));
+        } 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);
+        const multiPlexer = new ChannelMultiplexer(mainChannel);
+        multiPlexer.onDidOpenChannel(openEvent => {
+            const { channel, id } = openEvent;
+            if (this.channelHandlers.route(id, channel)) {
+                console.debug(`Opening channel for service path '${id}'.`);
+                channel.onClose(() => console.debug(`Closing channel on service path '${id}'.`));
+            }
+        });
+
+        sender.once('did-navigate', () => multiPlexer.onUnderlyingChannelClose({ reason: 'Window was refreshed' })); // When refreshing the browser window.
+        sender.once('destroyed', () => multiPlexer.onUnderlyingChannelClose({ reason: '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);
+    }
+
     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) => {
-                const connection = createWebSocketConnection(channel, new ConsoleLogger());
-                connectionHandler.onConnection(connection);
+                connectionHandler.onConnection(channel);
             });
         }
     }
 
-    listen(spec: string, callback: (params: ElectronMessagingService.PathParams, connection: MessageConnection) => void): void {
-        this.ipcChannel(spec, (params, channel) => {
-            const connection = createWebSocketConnection(channel, new ConsoleLogger());
-            callback(params, connection);
-        });
-    }
-
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ipcChannel(spec: string, callback: (params: any, channel: WebSocketChannel) => void): void {
+    ipcChannel(spec: string, callback: (params: any, channel: Channel) => void): void {
         this.channelHandlers.push(spec, callback);
     }
+}
+
+/**
+ * Used to establish a connection between the ipcMain and the Electron frontend (window).
+ * Messages a transferred via electron IPC.
+ */
+export class ElectronWebContentChannel implements Channel {
+    protected readonly onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
+    get onClose(): Event<ChannelCloseEvent> {
+        return this.onCloseEmitter.event;
+    }
 
-    protected handleIpcMessage(event: IpcMainEvent, data: string): void {
-        const sender = event.sender;
-        try {
-            // Get the channel map for a given window id
-            let channels = this.windowChannels.get(sender.id)!;
-            if (!channels) {
-                this.windowChannels.set(sender.id, channels = new Map<number, WebSocketChannel>());
-            }
-            // Start parsing the message to extract the channel id and route
-            const message: WebSocketChannel.Message = JSON.parse(data.toString());
-            // Someone wants to open a logical channel
-            if (message.kind === 'open') {
-                const { id, path } = message;
-                const channel = this.createChannel(id, sender);
-                if (this.channelHandlers.route(path, channel)) {
-                    channel.ready();
-                    channels.set(id, channel);
-                    channel.onClose(() => channels.delete(id));
-                } else {
-                    console.error('Cannot find a service for the path: ' + path);
-                }
-            } else {
-                const { id } = message;
-                const channel = channels.get(id);
-                if (channel) {
-                    channel.handleMessage(message);
-                } else {
-                    console.error('The ipc channel does not exist', id);
-                }
-            }
-            const close = () => {
-                for (const channel of Array.from(channels.values())) {
-                    channel.close(undefined, 'webContent destroyed');
-                }
-                channels.clear();
-            };
-            sender.once('did-navigate', close); // When refreshing the browser window.
-            sender.once('destroyed', close); // When closing the browser window.
-        } catch (error) {
-            console.error('IPC: Failed to handle message', { error, data });
-        }
+    // Make the message emitter public so that we can easily forward messages received from the ipcMain.
+    readonly onMessageEmitter: Emitter<MessageProvider> = new Emitter();
+    get onMessage(): Event<MessageProvider> {
+        return this.onMessageEmitter.event;
+    }
+
+    protected readonly onErrorEmitter: Emitter<unknown> = new Emitter();
+    get onError(): Event<unknown> {
+        return this.onErrorEmitter.event;
+    }
+
+    constructor(protected readonly sender: Electron.WebContents) {
     }
 
-    protected createChannel(id: number, sender: WebContents): WebSocketChannel {
-        return new WebSocketChannel(id, content => {
-            if (!sender.isDestroyed()) {
-                sender.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, content);
+    getWriteBuffer(): WriteBuffer {
+        const writer = new Uint8ArrayWriteBuffer();
+
+        writer.onCommit(buffer => {
+            if (!this.sender.isDestroyed()) {
+                this.sender.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, buffer);
             }
         });
-    }
 
+        return writer;
+    }
+    close(): void {
+        this.onCloseEmitter.dispose();
+        this.onMessageEmitter.dispose();
+        this.onErrorEmitter.dispose();
+    }
 }

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

@@ -14,20 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import type { MessageConnection } from 'vscode-jsonrpc';
-import type { WebSocketChannel } from '../../common/messaging/web-socket-channel';
+import { Channel } from '../../common/message-rpc/channel';
 
 export interface ElectronMessagingService {
-    /**
-     * Accept a JSON-RPC connection on the given path.
-     * A path supports the route syntax: https://github.com/rcs/route-parser#what-can-i-use-in-my-routes.
-     */
-    listen(path: string, callback: (params: ElectronMessagingService.PathParams, connection: MessageConnection) => void): void;
     /**
      * Accept an ipc channel on the given path.
      * A path supports the route syntax: https://github.com/rcs/route-parser#what-can-i-use-in-my-routes.
      */
-    ipcChannel(path: string, callback: (params: ElectronMessagingService.PathParams, socket: WebSocketChannel) => void): void;
+    ipcChannel(path: string, callback: (params: ElectronMessagingService.PathParams, socket: Channel) => void): void;
 }
 export namespace ElectronMessagingService {
     export interface PathParams {