@theia/core 1.43.1 → 1.45.0

package/src/common/message-rpc/channel.ts

@@ -220,6 +220,8 @@ export class ChannelMultiplexer implements Disposable {
             this.openChannels.set(id, channel);
             resolve(channel);
             this.onOpenChannelEmitter.fire({ id, channel });
+        } else {
+            console.error(`not expecting ack-open on for ${id}`);
         }
     }
 
@@ -234,6 +236,8 @@ export class ChannelMultiplexer implements Disposable {
             }
             this.underlyingChannel.getWriteBuffer().writeUint8(MessageTypes.AckOpen).writeString(id).commit();
             this.onOpenChannelEmitter.fire({ id, channel });
+        } else {
+            console.error(`channel already open: ${id}`);
         }
     }
 
@@ -275,7 +279,7 @@ export class ChannelMultiplexer implements Disposable {
     }
 
     open(id: string): Promise<Channel> {
-        if (this.openChannels.has(id)) {
+        if (this.openChannels.has(id) || this.pendingOpen.has(id)) {
             throw new Error(`Another channel with the id '${id}' is already open.`);
         }
         const result = new Promise<Channel>((resolve, reject) => {

package/src/common/message-rpc/message-buffer.ts

@@ -25,6 +25,7 @@ export interface WriteBuffer {
     writeBytes(value: Uint8Array): this
     writeNumber(value: number): this
     writeLength(value: number): this
+    writeRaw(bytes: Uint8Array): this;
     /**
      * Makes any writes to the buffer permanent, for example by sending the writes over a channel.
      * You must obtain a new write buffer after committing
@@ -71,6 +72,11 @@ export class ForwardingWriteBuffer implements WriteBuffer {
         return this;
     }
 
+    writeRaw(bytes: Uint8Array): this {
+        this.underlying.writeRaw(bytes);
+        return this;
+    }
+
     commit(): void {
         this.underlying.commit();
     }

package/src/common/message-rpc/uint8-array-message-buffer.ts

@@ -76,6 +76,13 @@ export class Uint8ArrayWriteBuffer implements WriteBuffer, Disposable {
         return this;
     }
 
+    writeRaw(bytes: Uint8Array): this {
+        this.ensureCapacity(bytes.byteLength);
+        this.buffer.set(bytes, this.offset);
+        this.offset += bytes.byteLength;
+        return this;
+    }
+
     writeUint16(value: number): this {
         this.ensureCapacity(2);
         this.msg.setUint16(this.offset, value);

package/src/common/messaging/connection-management.ts

@@ -0,0 +1,43 @@
+
+// *****************************************************************************
+// Copyright (C) 2017 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
+// *****************************************************************************
+
+export const ConnectionCloseService = Symbol('ConnectionCloseService');
+export const connectionCloseServicePath = '/services/ChannelCloseService';
+
+/**
+ * These messages are used to negotiate service reconnection between a front ends and back end.
+ * Whenever a front end first connects to a back end, it sends the ${@link ConnectionManagementMessages#INITIAL_CONNECT} message
+ * together with its front end id.
+ * The back end then starts a new front end connection context for that front end. If the back end already had another connection context
+ * for the given front end id, it gets discarded.
+ * If the front end reconnects after a websocket disconnect, it sends the ${@link ConnectionManagementMessages#RECONNECT} message
+ * together with its front end id..
+ * If the back end still has a connection context for the front end id, the context is reconnected and the back end replies with the value true.
+ * If there is no context anymore, the back end replies with value false. The front end can then either do an initial connect or reload
+ * the whole UI.
+ */
+export namespace ConnectionManagementMessages {
+    export const INITIAL_CONNECT = 'initialConnection';
+    export const RECONNECT = 'reconnect';
+}
+
+/**
+ * A service to mark a front end as unused. As soon as it disconnects from the back end, the connection context will be discarded.
+ */
+export interface ConnectionCloseService {
+    markForClose(frontEndId: string): Promise<void>;
+}

package/src/common/messaging/handler.ts

@@ -16,6 +16,8 @@
 
 import { Channel } from '../message-rpc/channel';
 
+export const servicesPath = '/services';
+
 export const ConnectionHandler = Symbol('ConnectionHandler');
 
 export interface ConnectionHandler {

package/src/common/messaging/socket-write-buffer.ts

@@ -0,0 +1,52 @@
+// *****************************************************************************
+// 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 { WebSocket } from './web-socket-channel';
+
+export class SocketWriteBuffer {
+    private static DISCONNECTED_BUFFER_SIZE = 100 * 1024;
+
+    private disconnectedBuffer: Uint8Array | undefined;
+    private bufferWritePosition = 0;
+
+    buffer(data: Uint8Array): void {
+        this.ensureWriteBuffer(data.byteLength);
+        this.disconnectedBuffer?.set(data, this.bufferWritePosition);
+        this.bufferWritePosition += data.byteLength;
+    }
+
+    protected ensureWriteBuffer(byteLength: number): void {
+        if (!this.disconnectedBuffer) {
+            this.disconnectedBuffer = new Uint8Array(SocketWriteBuffer.DISCONNECTED_BUFFER_SIZE);
+            this.bufferWritePosition = 0;
+        }
+
+        if (this.bufferWritePosition + byteLength > this.disconnectedBuffer.byteLength) {
+            throw new Error(`Max disconnected buffer size exceeded by adding ${byteLength} bytes`);
+        }
+    }
+
+    flush(socket: WebSocket): void {
+        if (this.disconnectedBuffer) {
+            socket.send(this.disconnectedBuffer.slice(0, this.bufferWritePosition));
+            this.disconnectedBuffer = undefined;
+        }
+    }
+
+    drain(): void {
+        this.disconnectedBuffer = undefined;
+    }
+}

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

@@ -19,7 +19,11 @@
 import { WriteBuffer } from '../message-rpc';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../message-rpc/uint8-array-message-buffer';
 import { AbstractChannel } from '../message-rpc/channel';
-import { Disposable } from '../disposable';
+import { Socket as ClientSocket } from 'socket.io-client';
+import { Socket as ServerSocket } from 'socket.io';
+import { Emitter } from 'vscode-languageserver-protocol';
+
+export type WebSocket = ClientSocket | ServerSocket;
 
 /**
  * A channel that manages the main websocket connection between frontend and backend. All service channels
@@ -29,65 +33,44 @@ import { Disposable } from '../disposable';
 export class WebSocketChannel extends AbstractChannel {
     static wsPath = '/services';
 
-    constructor(protected readonly socket: IWebSocket) {
+    private onDidConnectEmitter = new Emitter<void>();
+    onDidConnect = this.onDidConnectEmitter.event;
+
+    constructor(protected readonly socket: WebSocket) {
         super();
-        this.toDispose.push(Disposable.create(() => socket.close()));
-        socket.onClose((reason, code) => this.onCloseEmitter.fire({ reason, code }));
-        socket.onClose(() => this.close());
-        socket.onError(error => this.onErrorEmitter.fire(error));
-        socket.onMessage(data => this.onMessageEmitter.fire(() => {
+        socket.on('connect', () => {
+            this.onDidConnectEmitter.fire();
+        });
+
+        socket.on('disconnect', reason => {
+            this.onCloseEmitter.fire({
+                reason: reason
+            });
+        });
+
+        socket.on('error', reason => this.onErrorEmitter.fire(reason));
+        socket.on('message', data => {
             // 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);
-        }));
+            this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(buffer));
+        });
     }
 
     getWriteBuffer(): WriteBuffer {
         const result = new Uint8ArrayWriteBuffer();
 
         result.onCommit(buffer => {
-            if (this.socket.isConnected()) {
+            if (this.socket.connected) {
                 this.socket.send(buffer);
             }
         });
 
         return result;
     }
-}
 
-/**
- * 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;
+    override close(): void {
+        this.socket.disconnect();
+        super.close();
+    }
 }
-

package/src/common/nls.ts

@@ -81,6 +81,10 @@ interface NlsInfo {
 
 class LocalizationKeyProvider {
 
+    private preferredKeys = new Set([
+        // We only want the `File` translation used in the menu
+        'vscode/fileActions.contribution/filesCategory'
+    ]);
     private data = this.buildData();
 
     get(defaultValue: string): string | undefined {
@@ -100,9 +104,16 @@ class LocalizationKeyProvider {
         const keys: NlsKeys = bundles.keys;
         const messages: Record<string, string[]> = bundles.messages;
         const data = new Map<string, string>();
+        const foundPreferredKeys = new Set<string>();
         const keysAndMessages = this.buildKeyMessageTuples(keys, messages);
         for (const { key, message } of keysAndMessages) {
-            data.set(message, key);
+            if (!foundPreferredKeys.has(message)) {
+                data.set(message, key);
+                if (this.preferredKeys.has(key)) {
+                    // Prevent messages with preferred keys to be overridden
+                    foundPreferredKeys.add(message);
+                }
+            }
         }
         // Second pass adds each message again in upper case, if the message doesn't already exist in upper case
         // The second pass is needed to not accidentally override any translations which actually use the upper case message

package/src/electron-browser/messaging/electron-frontend-id-provider.ts

@@ -0,0 +1,25 @@
+// *****************************************************************************
+// 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 { injectable } from 'inversify';
+import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
+
+@injectable()
+export class ElectronFrontendIdProvider implements FrontendIdProvider {
+    getId(): string {
+        return window.electronTheiaCore.WindowMetadata.webcontentId;
+    }
+}

package/src/electron-browser/messaging/{electron-ipc-connection-provider.ts → electron-ipc-connection-source.ts}

@@ -16,32 +16,36 @@
 
 import { injectable, interfaces } from 'inversify';
 import { RpcProxy } from '../../common/messaging';
-import { AbstractConnectionProvider } from '../../common/messaging/abstract-connection-provider';
-import { AbstractChannel, Channel, WriteBuffer } from '../../common';
+import { AbstractChannel, Channel, Emitter, Event, MaybePromise, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
+import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+import { FrontendApplicationContribution } from '../../browser';
 
 export interface ElectronIpcOptions {
 }
 
+export const ElectronMainConnectionProvider = Symbol('ElectronMainConnectionProvider');
+
 /**
  * Connection provider between the Theia frontend and the electron-main process via IPC.
  */
-@injectable()
-export class ElectronIpcConnectionProvider extends AbstractConnectionProvider<ElectronIpcOptions> {
+export namespace ElectronIpcConnectionProvider {
 
-    static override createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
-        return container.get(ElectronIpcConnectionProvider).createProxy<T>(path, arg);
+    export function createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
+        return container.get<ServiceConnectionProvider>(ElectronMainConnectionProvider).createProxy<T>(path, arg);
     }
+}
 
-    constructor() {
-        super();
-        this.initializeMultiplexer();
-    }
+@injectable()
+export class ElectronIpcConnectionSource implements ConnectionSource, FrontendApplicationContribution {
+    protected readonly onConnectionDidOpenEmitter: Emitter<Channel> = new Emitter();
+    onConnectionDidOpen: Event<Channel> = this.onConnectionDidOpenEmitter.event;
 
-    protected createMainChannel(): Channel {
-        return new ElectronIpcRendererChannel();
+    onStart(): MaybePromise<void> {
+        const channel = new ElectronIpcRendererChannel();
+        this.onConnectionDidOpenEmitter.fire(channel);
     }
-
 }
 
 export class ElectronIpcRendererChannel extends AbstractChannel {

package/src/electron-browser/messaging/{electron-local-ws-connection-provider.ts → electron-local-ws-connection-source.ts}

@@ -15,8 +15,8 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
-import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
 import { Endpoint } from '../../browser/endpoint';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
 
 export function getLocalPort(): string | undefined {
     const params = new URLSearchParams(location.search);
@@ -24,7 +24,7 @@ export function getLocalPort(): string | undefined {
 }
 
 @injectable()
-export class ElectronLocalWebSocketConnectionProvider extends WebSocketConnectionProvider {
+export class ElectronLocalWebSocketConnectionSource extends WebSocketConnectionSource {
 
     protected override createEndpoint(path: string): Endpoint {
         const localPort = getLocalPort();

package/src/electron-browser/messaging/electron-messaging-frontend-module.ts

@@ -16,26 +16,63 @@
 
 import { ContainerModule } from 'inversify';
 import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
-import { LocalWebSocketConnectionProvider, WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
-import { ElectronWebSocketConnectionProvider } from './electron-ws-connection-provider';
-import { ElectronIpcConnectionProvider } from './electron-ipc-connection-provider';
-import { ElectronLocalWebSocketConnectionProvider, getLocalPort } from './electron-local-ws-connection-provider';
+import { ElectronWebSocketConnectionSource } from './electron-ws-connection-source';
+import { ElectronIpcConnectionSource, ElectronMainConnectionProvider } from './electron-ipc-connection-source';
+import { ElectronLocalWebSocketConnectionSource, getLocalPort } from './electron-local-ws-connection-source';
+import { ElectronFrontendIdProvider } from './electron-frontend-id-provider';
+import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { WebSocketConnectionProvider } from '../../browser';
+import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
+
+const backendServiceProvider = Symbol('backendServiceProvider2');
+const localServiceProvider = Symbol('localServiceProvider');
 
 export const messagingFrontendModule = new ContainerModule(bind => {
-    bind(ElectronWebSocketConnectionProvider).toSelf().inSingletonScope();
-    bind(FrontendApplicationContribution).toService(ElectronWebSocketConnectionProvider);
-    bind(WebSocketConnectionProvider).toService(ElectronWebSocketConnectionProvider);
-    bind(ElectronLocalWebSocketConnectionProvider).toSelf().inSingletonScope();
-    bind(LocalWebSocketConnectionProvider).toDynamicValue(ctx => {
+    bind(ConnectionCloseService).toDynamicValue(ctx => WebSocketConnectionProvider.createProxy(ctx.container, connectionCloseServicePath)).inSingletonScope();
+    bind(ElectronWebSocketConnectionSource).toSelf().inSingletonScope();
+    bind(WebSocketConnectionSource).toService(ElectronWebSocketConnectionSource);
+    bind(ElectronIpcConnectionSource).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(ElectronIpcConnectionSource);
+    bind(ElectronLocalWebSocketConnectionSource).toSelf().inSingletonScope();
+    bind(backendServiceProvider).toDynamicValue(ctx => {
+        const container = ctx.container.createChild();
+        container.bind(ServiceConnectionProvider).toSelf().inSingletonScope();
+        container.bind(ConnectionSource).toService(ElectronWebSocketConnectionSource);
+        return container.get(ServiceConnectionProvider);
+    }).inSingletonScope();
+
+    bind(localServiceProvider).toDynamicValue(ctx => {
+        const container = ctx.container.createChild();
+        container.bind(ServiceConnectionProvider).toSelf().inSingletonScope();
+        container.bind(ConnectionSource).toService(ElectronLocalWebSocketConnectionSource);
+        return container.get(ServiceConnectionProvider);
+    }).inSingletonScope();
+
+    bind(ElectronMainConnectionProvider).toDynamicValue(ctx => {
+        const container = ctx.container.createChild();
+        container.bind(ServiceConnectionProvider).toSelf().inSingletonScope();
+        container.bind(ConnectionSource).toService(ElectronIpcConnectionSource);
+        return container.get(ServiceConnectionProvider);
+    }).inSingletonScope();
+
+    bind(LocalConnectionProvider).toDynamicValue(ctx => {
         const localPort = getLocalPort();
         if (localPort) {
             // Return new web socket provider that connects to local app
-            return ctx.container.get(ElectronLocalWebSocketConnectionProvider);
+            return ctx.container.get(localServiceProvider);
         } else {
             // Return the usual web socket provider that already established its connection
             // That way we don't create a second socket connection
-            return ctx.container.get(WebSocketConnectionProvider);
+            return ctx.container.get(backendServiceProvider);
         }
     }).inSingletonScope();
-    bind(ElectronIpcConnectionProvider).toSelf().inSingletonScope();
+    bind(RemoteConnectionProvider).toService(backendServiceProvider);
+
+    bind(FrontendApplicationContribution).toService(ElectronWebSocketConnectionSource);
+    bind(ElectronFrontendIdProvider).toSelf().inSingletonScope();
+    bind(FrontendIdProvider).toService(ElectronFrontendIdProvider);
+    bind(WebSocketConnectionProvider).toSelf().inSingletonScope();
 });

package/src/electron-browser/messaging/{electron-ws-connection-provider.ts → electron-ws-connection-source.ts}

@@ -15,9 +15,8 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
-import { WebSocketConnectionProvider, WebSocketOptions } from '../../browser/messaging/ws-connection-provider';
 import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
-import { Channel } from '../../common';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
 
 /**
  * Customized connection provider between the frontend and the backend in electron environment.
@@ -25,25 +24,15 @@ import { Channel } from '../../common';
  * once the electron-browser window is refreshed. Otherwise, backend resources are not disposed.
  */
 @injectable()
-export class ElectronWebSocketConnectionProvider extends WebSocketConnectionProvider implements FrontendApplicationContribution {
-
-    /**
-     * Do not try to reconnect when the frontend application is stopping. The browser is navigating away from this page.
-     */
-    protected stopping = false;
+export class ElectronWebSocketConnectionSource extends WebSocketConnectionSource implements FrontendApplicationContribution {
+    constructor() {
+        super();
+    }
 
     onStop(): void {
-        this.stopping = true;
         // 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
         // `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 });
+        this.socket.close();
     }
-
-    override async openChannel(path: string, handler: (channel: Channel) => void, options?: WebSocketOptions): Promise<void> {
-        if (!this.stopping) {
-            super.openChannel(path, handler, options);
-        }
-    }
-
 }

package/src/electron-browser/preload.ts

@@ -25,7 +25,8 @@ import {
     CHANNEL_ON_WINDOW_EVENT, CHANNEL_GET_ZOOM_LEVEL, CHANNEL_SET_ZOOM_LEVEL, CHANNEL_IS_FULL_SCREENABLE, CHANNEL_TOGGLE_FULL_SCREEN,
     CHANNEL_IS_FULL_SCREEN, CHANNEL_SET_MENU_BAR_VISIBLE, CHANNEL_REQUEST_CLOSE, CHANNEL_SET_TITLE_STYLE, CHANNEL_RESTART,
     CHANNEL_REQUEST_RELOAD, CHANNEL_APP_STATE_CHANGED, CHANNEL_SHOW_ITEM_IN_FOLDER, CHANNEL_READ_CLIPBOARD, CHANNEL_WRITE_CLIPBOARD,
-    CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto, CHANNEL_REQUEST_SECONDARY_CLOSE, CHANNEL_SET_BACKGROUND_COLOR
+    CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto, CHANNEL_REQUEST_SECONDARY_CLOSE, CHANNEL_SET_BACKGROUND_COLOR,
+    CHANNEL_WC_METADATA, CHANNEL_ABOUT_TO_CLOSE
 } from '../electron-common/electron-api';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -65,6 +66,7 @@ function convertMenu(menu: MenuDto[] | undefined, handlerMap: Map<number, () =>
 }
 
 const api: TheiaCoreAPI = {
+    WindowMetadata: { webcontentId: 'none' },
     setMenuBarVisible: (visible: boolean, windowName?: string) => ipcRenderer.send(CHANNEL_SET_MENU_BAR_VISIBLE, visible, windowName),
     setMenu: (menu: MenuDto[] | undefined) => {
         commandHandlers.delete(mainMenuId);
@@ -119,6 +121,17 @@ const api: TheiaCoreAPI = {
     close: function (): void {
         ipcRenderer.send(CHANNEL_CLOSE);
     },
+
+    onAboutToClose(handler: () => void): Disposable {
+        const h = (event: Electron.IpcRendererEvent, replyChannel: string) => {
+            handler();
+            event.sender.send(replyChannel);
+        };
+
+        ipcRenderer.on(CHANNEL_ABOUT_TO_CLOSE, h);
+        return Disposable.create(() => ipcRenderer.off(CHANNEL_ABOUT_TO_CLOSE, h));
+    },
+
     onWindowEvent: function (event: WindowEvent, handler: () => void): Disposable {
         const h = (_event: unknown, evt: WindowEvent) => {
             if (event === evt) {
@@ -207,6 +220,7 @@ const api: TheiaCoreAPI = {
     sendData: data => {
         ipcRenderer.send(CHANNEL_IPC_CONNECTION, data);
     },
+    useNativeElements: !('THEIA_ELECTRON_DISABLE_NATIVE_ELEMENTS' in process.env && process.env.THEIA_ELECTRON_DISABLE_NATIVE_ELEMENTS === '1')
 };
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -226,6 +240,7 @@ export function preload(): void {
             }
         }
     });
+    api.WindowMetadata.webcontentId = ipcRenderer.sendSync(CHANNEL_WC_METADATA);
 
     contextBridge.exposeInMainWorld('electronTheiaCore', api);
 }

package/src/electron-browser/window/electron-secondary-window-service.ts

@@ -16,7 +16,7 @@
 
 import { injectable } from 'inversify';
 import { DefaultSecondaryWindowService } from '../../browser/window/default-secondary-window-service';
-import { ApplicationShell, ExtractableWidget } from 'src/browser';
+import { ApplicationShell, ExtractableWidget } from '../../browser';
 
 @injectable()
 export class ElectronSecondaryWindowService extends DefaultSecondaryWindowService {

package/src/electron-browser/window/electron-window-module.ts

@@ -21,7 +21,7 @@ import { FrontendApplicationContribution } from '../../browser/frontend-applicat
 import { ElectronClipboardService } from '../electron-clipboard-service';
 import { ClipboardService } from '../../browser/clipboard-service';
 import { ElectronMainWindowService, electronMainWindowServicePath } from '../../electron-common/electron-main-window-service';
-import { ElectronIpcConnectionProvider } from '../messaging/electron-ipc-connection-provider';
+import { ElectronIpcConnectionProvider } from '../messaging/electron-ipc-connection-source';
 import { bindWindowPreferences } from './electron-window-preferences';
 import { FrontendApplicationStateService } from '../../browser/frontend-application-state';
 import { ElectronFrontendApplicationStateService } from './electron-frontend-application-state';

package/src/electron-browser/window/electron-window-preferences.ts

@@ -46,7 +46,7 @@ export const electronWindowPreferencesSchema: PreferenceSchema = {
             default: isWindows ? 'custom' : 'native',
             scope: 'application',
             // eslint-disable-next-line max-len
-            description: nls.localizeByDefault('Adjust the appearance of the window title bar. On Linux and Windows, this setting also affects the application and context menu appearances. Changes require a full restart to apply.'),
+            description: nls.localizeByDefault('Adjust the appearance of the window title bar to be native by the OS or custom. On Linux and Windows, this setting also affects the application and context menu appearances. Changes require a full restart to apply.'),
             included: !isOSX
         },
     }

package/src/electron-browser/window/electron-window-service.ts

@@ -19,6 +19,8 @@ import { NewWindowOptions, WindowSearchParams } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
 import { ElectronWindowPreferences } from './electron-window-preferences';
+import { ConnectionCloseService } from '../../common/messaging/connection-management';
+import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
 
 @injectable()
 export class ElectronWindowService extends DefaultWindowService {
@@ -33,12 +35,18 @@ export class ElectronWindowService extends DefaultWindowService {
      */
     protected closeOnUnload: boolean = false;
 
+    @inject(FrontendIdProvider)
+    protected readonly frontendIdProvider: FrontendIdProvider;
+
     @inject(ElectronMainWindowService)
     protected readonly delegate: ElectronMainWindowService;
 
     @inject(ElectronWindowPreferences)
     protected readonly electronWindowPreferences: ElectronWindowPreferences;
 
+    @inject(ConnectionCloseService)
+    protected readonly connectionCloseService: ConnectionCloseService;
+
     override openNewWindow(url: string, { external }: NewWindowOptions = {}): undefined {
         this.delegate.openNewWindow(url, { external });
         return undefined;
@@ -56,6 +64,9 @@ export class ElectronWindowService extends DefaultWindowService {
                 this.updateWindowZoomLevel();
             }
         });
+        window.electronTheiaCore.onAboutToClose(() => {
+            this.connectionCloseService.markForClose(this.frontendIdProvider.getId());
+        });
     }
 
     protected override registerUnloadListeners(): void {