@theia/core 1.71.0-next.8 → 1.71.0

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

@@ -30,6 +30,7 @@ import URI from '../common/uri';
 import { FileUri } from '../common/file-uri';
 import { Deferred, timeout } from '../common/promise-util';
 import { MaybePromise } from '../common/types';
+import { Stopwatch } from '../common/performance';
 import { ContributionProvider } from '../common/contribution-provider';
 import { ElectronSecurityTokenService } from './electron-security-token-service';
 import { ElectronSecurityToken } from '../electron-common/electron-token';
@@ -49,6 +50,8 @@ export { ElectronMainApplicationGlobals };
 
 const createYargs: (argv?: string[], cwd?: string) => Argv = require('yargs/yargs');
 
+const ELECTRON_TIMER_WARNING_THRESHOLD = 50;
+
 /**
  * Options passed to the main/default command handler.
  */
@@ -171,6 +174,9 @@ export class ElectronMainApplication {
     @inject(TheiaElectronWindowFactory)
     protected readonly windowFactory: TheiaElectronWindowFactory;
 
+    @inject(Stopwatch)
+    protected readonly stopwatch: Stopwatch;
+
     protected isPortable = this.makePortable();
 
     protected readonly electronStore = new Storage<{
@@ -229,15 +235,19 @@ export class ElectronMainApplication {
                         await fs.mkdir(args.electronUserData, { recursive: true });
                         app.setPath('userData', args.electronUserData);
                     }
+                    const startupMeasurement = this.stopwatch.start('electron-main-startup');
                     this.useNativeWindowFrame = this.getTitleBarStyle(config) === 'native';
                     this._config = config;
                     this.hookApplicationEvents();
                     this.showInitialWindow(argv.includes('--open-url') ? argv[argv.length - 1] : undefined);
-                    const port = await this.startBackend();
+                    const port = await this.stopwatch.startAsync('electron-main-start-backend', 'Starting backend', () => this.startBackend());
                     this._backendPort.resolve(port);
                     await app.whenReady();
-                    await this.attachElectronSecurityToken(port);
-                    await this.startContributions();
+                    await this.stopwatch.startAsync('electron-main-security-token', 'Attaching security token',
+                        () => this.attachElectronSecurityToken(port));
+                    await this.stopwatch.startAsync('electron-main-start-contributions', 'Starting contributions',
+                        () => this.startContributions());
+                    startupMeasurement.info('Startup sequence completed');
 
                     this.handleMainCommand({
                         file: args.file,
@@ -920,8 +930,14 @@ export class ElectronMainApplication {
     protected async startContributions(): Promise<void> {
         const promises = [];
         for (const contribution of this.contributions.getContributions()) {
-            if (contribution.onStart) {
-                promises.push(contribution.onStart(this));
+            const onStart = contribution.onStart;
+            if (onStart) {
+                promises.push(this.stopwatch.startAsync(
+                    `${contribution.constructor.name}.onStart`,
+                    `${contribution.constructor.name}.onStart`,
+                    () => onStart.call(contribution, this),
+                    { thresholdMillis: ELECTRON_TIMER_WARNING_THRESHOLD }
+                ));
             }
         }
         await Promise.all(promises);

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

@@ -140,6 +140,9 @@ export class TheiaElectronWindow {
 
     protected async doCloseWindow(): Promise<void> {
         this.closeIsConfirmed = true;
+        // Hide the window immediately so the user perceives an instant close.
+        // This is done after veto checks have passed to ensure save dialogs remain visible.
+        this._window.hide();
         await TheiaRendererAPI.sendAboutToClose(this._window.webContents);
         this._window.close();
     }

package/src/node/backend-application.ts

@@ -22,7 +22,7 @@ import * as express from 'express';
 import * as yargs from 'yargs';
 import * as fs from 'fs-extra';
 import { inject, named, injectable, postConstruct } from 'inversify';
-import { ContributionProvider, MaybePromise, Stopwatch } from '../common';
+import { ContributionProvider, LogLevel, MaybePromise, MeasurementContext, Stopwatch } from '../common';
 import { CliContribution } from './cli';
 import { Deferred } from '../common/promise-util';
 import { environment } from '../common/index';
@@ -164,6 +164,8 @@ export class BackendApplication {
 
     private _configured: Promise<void>;
 
+    private settlementContext?: MeasurementContext<BackendApplicationContribution>;
+
     constructor(
         @inject(ContributionProvider) @named(BackendApplicationContribution)
         protected readonly contributionsProvider: ContributionProvider<BackendApplicationContribution>,
@@ -195,9 +197,8 @@ export class BackendApplication {
         await Promise.all(this.contributionsProvider.getContributions().map(async contribution => {
             if (contribution.initialize) {
                 try {
-                    await this.measure(contribution.constructor.name + '.initialize',
-                        () => contribution.initialize!()
-                    );
+                    await this.measureContribution(contribution, 'initialize',
+                        () => contribution.initialize!());
                 } catch (error) {
                     console.error('Could not initialize contribution', error);
                 }
@@ -211,6 +212,7 @@ export class BackendApplication {
 
     @postConstruct()
     protected init(): void {
+        this.settlementContext = new MeasurementContext(this.stopwatch, 'Backend', TIMER_WARNING_THRESHOLD);
         this._configured = this.configure();
     }
 
@@ -232,7 +234,8 @@ export class BackendApplication {
         await Promise.all(this.contributionsProvider.getContributions().map(async contribution => {
             if (contribution.configure) {
                 try {
-                    await contribution.configure!(this.app);
+                    await this.measureContribution(contribution, 'configure',
+                        () => contribution.configure!(this.app));
                 } catch (error) {
                     console.error('Could not configure contribution', error);
                 }
@@ -246,6 +249,8 @@ export class BackendApplication {
     }
 
     async start(port?: number, hostname?: string): Promise<http.Server | https.Server> {
+        const startupMeasurement = this.stopwatch.start('backend-startup');
+
         hostname ??= this.cliParams.hostname;
         port ??= this.cliParams.port;
 
@@ -307,15 +312,17 @@ export class BackendApplication {
         for (const contribution of this.contributionsProvider.getContributions()) {
             if (contribution.onStart) {
                 try {
-                    await this.measure(contribution.constructor.name + '.onStart',
-                        () => contribution.onStart!(server)
-                    );
+                    await this.measureContribution(contribution, 'onStart',
+                        () => contribution.onStart!(server));
                 } catch (error) {
                     console.error('Could not start contribution', error);
                 }
             }
         }
-        return this.stopwatch.startAsync('server', 'Finished starting backend application', () => deferred.promise);
+        await deferred.promise;
+        startupMeasurement.info('Backend application startup sequence completed (async work may still be pending)');
+        this.settlementContext?.armAllSettled();
+        return server;
     }
 
     protected getHttpUrl({ address, port, family }: AddressInfo, ssl?: boolean): string {
@@ -358,8 +365,18 @@ export class BackendApplication {
         next();
     }
 
+    protected async measureContribution<T>(contribution: BackendApplicationContribution, hook: string, fn: () => MaybePromise<T>): Promise<T> {
+        let innerResult: MaybePromise<T>;
+        this.settlementContext?.ensureEntry(contribution);
+        const result = await this.measure(contribution.constructor.name + '.' + hook,
+            () => (innerResult = fn())
+        );
+        this.settlementContext?.trackSettlement(contribution, innerResult!);
+        return result;
+    }
+
     protected async measure<T>(name: string, fn: () => MaybePromise<T>): Promise<T> {
-        return this.stopwatch.startAsync(name, `Backend ${name}`, fn, { thresholdMillis: TIMER_WARNING_THRESHOLD });
+        return this.stopwatch.startAsync(name, `Backend ${name}`, fn, { thresholdMillis: TIMER_WARNING_THRESHOLD, defaultLogLevel: LogLevel.DEBUG });
     }
 
     protected handleUncaughtError(error: Error): void {

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

@@ -71,6 +71,7 @@ export class DefaultMessagingService implements MessagingService, BackendApplica
     protected createMainChannelContainer(socket: Channel): Container {
         const connectionContainer: Container = this.container.createChild() as Container;
         connectionContainer.bind(MainChannel).toConstantValue(socket);
+        socket.onClose(() => connectionContainer.unbindAllAsync().catch(e => console.error(e)));
         return connectionContainer;
     }
 

package/src/node/messaging/index.ts

@@ -17,3 +17,4 @@
 export * from './messaging-service';
 export * from './ipc-connection-provider';
 export * from './ipc-channel';
+export * from './websocket-frontend-connection-service';

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

@@ -24,8 +24,9 @@ import { MessagingListener, MessagingListenerContribution } from './messaging-li
 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 { ReconnectableSocketChannel, WebsocketFrontendConnectionService } from './websocket-frontend-connection-service';
 import { WebsocketEndpoint } from './websocket-endpoint';
+import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
 
 export const messagingBackendModule = new ContainerModule(bind => {
     bindRootContributionProvider(bind, ConnectionContainerModule);
@@ -36,6 +37,9 @@ export const messagingBackendModule = new ContainerModule(bind => {
     bind(MessagingContainer).toDynamicValue(({ container }) => container).inSingletonScope();
     bind(WebsocketEndpoint).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(WebsocketEndpoint);
+    // Transient: each connection gets its own private buffer and channel instances.
+    bind(SocketWriteBuffer).toSelf();
+    bind(ReconnectableSocketChannel).toSelf();
     bind(WebsocketFrontendConnectionService).toSelf().inSingletonScope();
     bind(FrontendConnectionService).toService(WebsocketFrontendConnectionService);
     bind(MessagingListener).toSelf().inSingletonScope();

package/src/node/messaging/test/default-messaging-service.spec.ts

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { Container, injectable, preDestroy } from 'inversify';
+import { ConnectionHandler, bindContributionProvider, servicesPath } from '../../../common';
+import { BasicChannel, Channel } from '../../../common/message-rpc/channel';
+import { Uint8ArrayWriteBuffer } from '../../../common/message-rpc/uint8-array-message-buffer';
+import { ConnectionContainerModule } from '../connection-container-module';
+import { DefaultMessagingService, MessagingContainer } from '../default-messaging-service';
+import { FrontendConnectionService } from '../frontend-connection-service';
+import { MessagingService } from '../messaging-service';
+
+describe('DefaultMessagingService', () => {
+
+    describe('when a frontend connection closes', () => {
+
+        it('disposes the connection-scoped child container, invoking @preDestroy on bound singleton services', async () => {
+            let canaryDisposed = false;
+
+            @injectable()
+            class CanaryConnectionHandler implements ConnectionHandler {
+                readonly path = 'canary';
+                onConnection(_channel: Channel): void { /* not relevant for this test */ }
+
+                @preDestroy()
+                protected onPreDestroy(): void {
+                    canaryDisposed = true;
+                }
+            }
+
+            const canaryModule = ConnectionContainerModule.create(({ bind }) => {
+                bind(CanaryConnectionHandler).toSelf().inSingletonScope();
+                bind(ConnectionHandler).toService(CanaryConnectionHandler);
+            });
+
+            const container = new Container();
+            container.bind(MessagingContainer).toConstantValue(container);
+            container.bind(DefaultMessagingService).toSelf().inSingletonScope();
+            container.bind(ConnectionContainerModule).toConstantValue(canaryModule);
+            bindContributionProvider(container, ConnectionContainerModule);
+            bindContributionProvider(container, MessagingService.Contribution);
+
+            let serviceHandler: ((params: MessagingService.PathParams, mainChannel: Channel) => void) | undefined;
+            const frontendConnectionService: FrontendConnectionService = {
+                registerConnectionHandler(path, callback): void {
+                    if (path === servicesPath) {
+                        serviceHandler = callback;
+                    }
+                }
+            };
+            container.bind(FrontendConnectionService).toConstantValue(frontendConnectionService);
+
+            const messagingService = container.get(DefaultMessagingService);
+            messagingService.initialize();
+
+            expect(serviceHandler, 'connection handler not registered on the services path').to.not.be.undefined;
+
+            const mainChannel = new BasicChannel(() => new Uint8ArrayWriteBuffer());
+            serviceHandler!({}, mainChannel);
+
+            expect(canaryDisposed, 'canary should not be disposed before the channel is closed').to.be.false;
+
+            mainChannel.onCloseEmitter.fire({ reason: 'frontend connection closed' });
+            await new Promise<void>(resolve => setImmediate(resolve));
+
+            expect(canaryDisposed, 'canary @preDestroy was not invoked').to.be.true;
+        });
+
+    });
+
+});

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

@@ -15,9 +15,9 @@
 
 import { Channel, WriteBuffer } from '../../common/message-rpc';
 import { MessagingService } from './messaging-service';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, interfaces } from 'inversify';
 import { Socket } from 'socket.io';
-import { ConnectionHandlers } from './default-messaging-service';
+import { ConnectionHandlers, MessagingContainer } from './default-messaging-service';
 import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
 import { FrontendConnectionService } from './frontend-connection-service';
 import { AbstractChannel } from '../../common/message-rpc/channel';
@@ -33,6 +33,9 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     @inject(WebsocketEndpoint)
     protected readonly websocketServer: WebsocketEndpoint;
 
+    @inject(MessagingContainer)
+    protected readonly container: interfaces.Container;
+
     protected readonly wsHandlers = new ConnectionHandlers();
     protected readonly connectionsByFrontend = new Map<string, ReconnectableSocketChannel>();
     protected readonly closeTimeouts = new Map<string, NodeJS.Timeout>();
@@ -89,12 +92,13 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
         this.closeTimeouts.delete(frontEndId);
 
         connection.onCloseEmitter.fire({ reason });
+        connection.drainBuffer();
         connection.close();
     }
 
     protected createConnection(socket: Socket, frontEndId: string): ReconnectableSocketChannel {
         console.info(`creating connection for ${frontEndId}`);
-        const channel = new ReconnectableSocketChannel();
+        const channel = this.container.get(ReconnectableSocketChannel);
         channel.connect(socket);
 
         this.connectionsByFrontend.set(frontEndId, channel);
@@ -136,12 +140,17 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     }
 }
 
-class ReconnectableSocketChannel extends AbstractChannel {
-    private socket: Socket | undefined;
-    private socketBuffer = new SocketWriteBuffer();
-    private disposables = new DisposableCollection();
+@injectable()
+export class ReconnectableSocketChannel extends AbstractChannel {
+    protected socket: Socket | undefined;
+
+    @inject(SocketWriteBuffer)
+    protected socketBuffer: SocketWriteBuffer;
+
+    protected disposables = new DisposableCollection();
 
     connect(socket: Socket): void {
+        this.disposables.dispose();
         this.disposables = new DisposableCollection();
         this.socket = socket;
         const errorHandler = (err: Error) => {
@@ -171,6 +180,10 @@ class ReconnectableSocketChannel extends AbstractChannel {
         this.socket = undefined;
     }
 
+    drainBuffer(): void {
+        this.socketBuffer.drain();
+    }
+
     override getWriteBuffer(): WriteBuffer {
         const writeBuffer = new Uint8ArrayWriteBuffer();
         writeBuffer.onCommit(data => {

package/src/node/performance/node-stopwatch.ts

@@ -23,7 +23,7 @@ export class NodeStopwatch extends Stopwatch {
 
     constructor() {
         super({
-            owner: 'backend',
+            owner: 'backend process',
             now: () => performance.now(),
         });
     }

package/src/node/process-utils.ts

@@ -32,7 +32,15 @@ export class ProcessUtils {
     }
 
     protected winTerminateProcessTree(ppid: number): void {
-        this.spawnSync('taskkill.exe', ['/f', '/t', '/pid', ppid.toString(10)]);
+        const result = cp.spawnSync('taskkill.exe', ['/f', '/t', '/pid', ppid.toString(10)], { encoding: 'utf8' });
+        if (result.error) {
+            throw result.error;
+        }
+        // taskkill may exit with a non-zero code when some child processes have already exited.
+        // This is expected during shutdown — log but don't throw.
+        if (result.status !== 0) {
+            console.warn(`taskkill.exe exited with ${result.status} for PID ${ppid}. Output:\n${JSON.stringify(result.output)}`);
+        }
     }
 
     protected unixTerminateProcessTree(ppid: number): void {