@theia/core 1.75.0-next.3 → 1.75.0-next.35

package/src/common/command.spec.ts

@@ -139,6 +139,131 @@ describe('Commands', () => {
         expect(commandRegistry.getAllHandlers('id').length).to.be.equal(2);
     });
 
+    describe('registerAlias', () => {
+
+        it('onDidExecuteCommand fires for alias when target is executed', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+        it('onDidExecuteCommand fires only for alias when alias is executed (no reverse)', async () => {
+            commandRegistry.registerCommand({ id: 'alias' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('alias');
+            // Unidirectional: an alias fires for its target, but not the other way round
+            expect(events).to.deep.equal(['alias']);
+        });
+
+        it('onWillExecuteCommand fires for alias when target is executed', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onWillExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+        it('disposing the alias removes the event link', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            const disposable = commandRegistry.registerAlias('alias', 'target');
+            disposable.dispose();
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target']);
+        });
+
+        it('getAliases returns the aliases registered for a target', () => {
+            commandRegistry.registerAlias('a', 'b');
+            expect(commandRegistry.getAliases('b')).to.deep.equal(['a']);
+        });
+
+        it('getAliases returns nothing for the alias direction (unidirectional)', () => {
+            commandRegistry.registerAlias('a', 'b');
+            expect(commandRegistry.getAliases('a')).to.be.empty;
+        });
+
+        it('getAliases returns nothing for unaliased commands', () => {
+            expect(commandRegistry.getAliases('nonexistent')).to.be.empty;
+        });
+
+        it('a target can carry several aliases', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerAlias('alias1', 'target');
+            commandRegistry.registerAlias('alias2', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias1', 'alias2']);
+        });
+
+        it('disposing one alias keeps the others', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            const first = commandRegistry.registerAlias('alias1', 'target');
+            commandRegistry.registerAlias('alias2', 'target');
+            first.dispose();
+            expect(commandRegistry.getAliases('target')).to.deep.equal(['alias2']);
+        });
+
+        it('alias events include correct args', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new ConcatCommandHandler());
+            commandRegistry.registerAlias('alias', 'target');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const capturedArgs: any[][] = [];
+            commandRegistry.onDidExecuteCommand(e => capturedArgs.push(e.args));
+            await commandRegistry.executeCommand('target', 'x', 'y');
+            expect(capturedArgs.length).to.equal(2);
+            expect(capturedArgs[0]).to.deep.equal(['x', 'y']);
+            expect(capturedArgs[1]).to.deep.equal(['x', 'y']);
+        });
+
+        it('nested execution: alias handler delegating to target fires target and alias events', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerCommand({ id: 'alias' }, {
+                execute: () => commandRegistry.executeCommand('target')
+            });
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('alias');
+            // The alias is on the stack while the target runs, so its event is only reported once.
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+        it('reports the alias once for the will execute event as well', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerCommand({ id: 'alias' }, {
+                execute: () => commandRegistry.executeCommand('target')
+            });
+            commandRegistry.registerAlias('alias', 'target');
+            const events: string[] = [];
+            commandRegistry.onWillExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('alias');
+            expect(events).to.deep.equal(['alias', 'target']);
+        });
+
+        it('reports the alias again once the delegating execution finished', async () => {
+            commandRegistry.registerCommand({ id: 'target' }, new StubCommandHandler());
+            commandRegistry.registerCommand({ id: 'alias' }, {
+                execute: () => commandRegistry.executeCommand('target')
+            });
+            commandRegistry.registerAlias('alias', 'target');
+            await commandRegistry.executeCommand('alias');
+
+            const events: string[] = [];
+            commandRegistry.onDidExecuteCommand(e => events.push(e.commandId));
+            await commandRegistry.executeCommand('target');
+            expect(events).to.deep.equal(['target', 'alias']);
+        });
+
+    });
+
     describe('compareCommands', () => {
 
         it('should sort command \'a\' before command \'b\' with categories', () => {

package/src/common/command.ts

@@ -202,6 +202,19 @@ export class CommandRegistry implements CommandService {
     // List of recently used commands.
     protected _recent: string[] = [];
 
+    /**
+     * Unidirectional alias map from a target command id to the alias command ids registered for it.
+     * When the target (for instance a native Theia command) is executed, events also fire for its
+     * aliases (for instance the VS Code command ids).
+     */
+    protected readonly _aliases = new Map<string, Set<string>>();
+
+    /**
+     * How often each command is currently executing, so that an alias event can be skipped while the
+     * alias command itself is on the stack.
+     */
+    protected readonly executionDepth = new Map<string, number>();
+
     protected readonly onWillExecuteCommandEmitter = new Emitter<WillExecuteCommandEvent>();
     readonly onWillExecuteCommand = this.onWillExecuteCommandEmitter.event;
 
@@ -277,6 +290,42 @@ export class CommandRegistry implements CommandService {
         }
     }
 
+    /**
+     * Register a unidirectional alias from a target command to an alias command.
+     * When the target command is executed, {@link onDidExecuteCommand} and {@link onWillExecuteCommand}
+     * fire for the alias id as well.
+     *
+     * This does not affect command handlers, enablement or visibility, only event emission. A target may
+     * carry several aliases.
+     *
+     * No event is fired for an alias while that alias is executing, which keeps an alias command that
+     * delegates to its target from reporting itself twice. The check is by command id rather than by call
+     * stack, so an unrelated execution of the alias that happens to overlap suppresses the event as well.
+     *
+     * @param aliasId the alias command id, for instance a VS Code command id
+     * @param targetId the target command id, for instance the native Theia command id
+     * @returns a `Disposable` that removes this alias again
+     */
+    registerAlias(aliasId: string, targetId: string): Disposable {
+        const aliases = this._aliases.get(targetId) ?? new Set<string>();
+        aliases.add(aliasId);
+        this._aliases.set(targetId, aliases);
+        return Disposable.create(() => {
+            const registered = this._aliases.get(targetId);
+            if (registered?.delete(aliasId) && registered.size === 0) {
+                this._aliases.delete(targetId);
+            }
+        });
+    }
+
+    /**
+     * Returns the alias ids registered for the given command id.
+     */
+    getAliases(commandId: string): readonly string[] {
+        const aliases = this._aliases.get(commandId);
+        return aliases ? Array.from(aliases) : [];
+    }
+
     /**
      * Register the given handler for the given command identifier.
      *
@@ -341,10 +390,23 @@ export class CommandRegistry implements CommandService {
     async executeCommand<T>(commandId: string, ...args: any[]): Promise<T | undefined> {
         const handler = this.getActiveHandler(commandId, ...args);
         if (handler) {
-            await this.fireWillExecuteCommand(commandId, args);
-            const result = await handler.execute(...args);
-            this.onDidExecuteCommandEmitter.fire({ commandId, args });
-            return result;
+            this.executionDepth.set(commandId, (this.executionDepth.get(commandId) ?? 0) + 1);
+            try {
+                await this.fireWillExecuteCommand(commandId, args);
+                const result = await handler.execute(...args);
+                this.onDidExecuteCommandEmitter.fire({ commandId, args });
+                for (const alias of this.getPendingAliases(commandId)) {
+                    this.onDidExecuteCommandEmitter.fire({ commandId: alias, args });
+                }
+                return result;
+            } finally {
+                const depth = this.executionDepth.get(commandId) ?? 1;
+                if (depth > 1) {
+                    this.executionDepth.set(commandId, depth - 1);
+                } else {
+                    this.executionDepth.delete(commandId);
+                }
+            }
         }
         throw Object.assign(new Error(`The command '${commandId}' cannot be executed. There are no active handlers available for the command.`), { code: 'NO_ACTIVE_HANDLER' });
     }
@@ -352,6 +414,17 @@ export class CommandRegistry implements CommandService {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     protected async fireWillExecuteCommand(commandId: string, args: any[] = []): Promise<void> {
         await WaitUntilEvent.fire(this.onWillExecuteCommandEmitter, { commandId, args }, 30000);
+        for (const alias of this.getPendingAliases(commandId)) {
+            await WaitUntilEvent.fire(this.onWillExecuteCommandEmitter, { commandId: alias, args }, 30000);
+        }
+    }
+
+    /**
+     * The aliases of the given command that are not executing themselves, and for which events are
+     * therefore still owed.
+     */
+    protected getPendingAliases(commandId: string): readonly string[] {
+        return this.getAliases(commandId).filter(alias => !this.executionDepth.has(alias));
     }
 
     /**

package/src/common/message-service-protocol.ts

@@ -14,9 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import { CancellationToken } from './cancellation';
 import { nls } from './nls';
+import { ILogger } from './logger';
 
 export const messageServicePath = '/services/messageService';
 
@@ -115,6 +116,9 @@ export interface ProgressUpdate {
 @injectable()
 export class MessageClient {
 
+    @inject(ILogger) @named('core:MessageClient')
+    protected readonly logger: ILogger;
+
     /**
      * Show a message of the given type and possible actions to the user.
      * Resolve to a chosen action.
@@ -123,7 +127,7 @@ export class MessageClient {
      * To be implemented by an extension, e.g. by the messages extension.
      */
     showMessage(message: Message): Promise<string | undefined> {
-        console.info(message.text);
+        this.logger.info(message.text);
         return Promise.resolve(undefined);
     }
 
@@ -133,7 +137,7 @@ export class MessageClient {
      * To be implemented by an extension, e.g. by the messages extension.
      */
     showProgress(progressId: string, message: ProgressMessage, cancellationToken: CancellationToken): Promise<string | undefined> {
-        console.info(message.text);
+        this.logger.info(message.text);
         return Promise.resolve(undefined);
     }
 

package/src/common/performance/stopwatch.ts

@@ -16,7 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { inject, injectable, unmanaged } from 'inversify';
+import { inject, injectable, unmanaged, named } from 'inversify';
 import { ILogger, LogLevel } from '../logger';
 import { MaybePromise } from '../types';
 import { Measurement, MeasurementOptions, MeasurementResult } from './measurement';
@@ -48,7 +48,7 @@ interface LogOptions extends MeasurementOptions {
 @injectable()
 export abstract class Stopwatch {
 
-    @inject(ILogger)
+    @inject(ILogger) @named('core:Stopwatch')
     protected readonly logger: ILogger;
 
     protected _storedMeasurements: MeasurementResult[] = [];

package/src/common/preferences/preference-schema-service.ts

@@ -24,6 +24,7 @@ import { PreferenceScope, ValidPreferenceScopes } from './preference-scope';
 import { PreferenceUtils } from './preference-provider';
 import { ContributionProvider } from '../contribution-provider';
 import { Deferred } from '../promise-util';
+import { ILogger } from '../logger';
 
 export const NO_OVERRIDE = {};
 export const OVERRIDE_PROPERTY = '\\[(.*)\\]$';
@@ -78,6 +79,9 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
     @inject(ContributionProvider) @named(PreferenceContribution)
     protected readonly preferenceContributions: ContributionProvider<PreferenceContribution>;
 
+    @inject(ILogger) @named('core:PreferenceSchemaServiceImpl')
+    protected readonly logger: ILogger;
+
     @postConstruct()
     protected init(): void {
         for (const scope of this.validScopes) {
@@ -128,7 +132,7 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
 
         for (const [key, property] of Object.entries(schema.properties)) {
             if (this.properties.has(key)) {
-                console.warn(`Property with id '${key}' already exists`);
+                this.logger.warn(`Property with id '${key}' already exists`);
                 continue;
             }
             this.pendingDefaultRegistrationWarnings?.delete(key);
@@ -210,14 +214,14 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
             this.setJSONSchemasProperty(key, updatedProperty);
             this.schemaChangedEmitter.fire();
         } else {
-            console.warn(`Trying to update non-existent property ${key}`);
+            this.logger.warn(`Trying to update non-existent property ${key}`);
         }
     }
 
     protected pendingDefaultRegistrationWarnings: Set<string> | undefined = new Set();
     protected logDefaultRegistrationWarnings(): void {
         if (this.pendingDefaultRegistrationWarnings?.size) {
-            console.warn('Default overrides registered for these keys, but preferences not registered', Array.from(this.pendingDefaultRegistrationWarnings));
+            this.logger.warn('Default overrides registered for these keys, but preferences not registered', Array.from(this.pendingDefaultRegistrationWarnings));
         }
         this.pendingDefaultRegistrationWarnings = undefined;
     }
@@ -226,7 +230,7 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
         if (this.pendingDefaultRegistrationWarnings) {
             this.pendingDefaultRegistrationWarnings.add(key);
         } else {
-            console.warn(`Trying to register default override for non-existent preference: ${key}`);
+            this.logger.warn(`Trying to register default override for non-existent preference: ${key}`);
         }
     }
 
@@ -236,7 +240,7 @@ export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
         if (!property) {
             this.logDefaultRegistrationWarning(key);
         } else if (!property.overridable && overrideIdentifier) {
-            console.warn(`Trying to register default override for identifier ${overrideIdentifier} for non-overridable preference: ${key}`);
+            this.logger.warn(`Trying to register default override for identifier ${overrideIdentifier} for non-overridable preference: ${key}`);
         }
 
         let overrides = this.defaultOverrides.get(key);

package/src/common/preferences/preference-service.ts

@@ -17,7 +17,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { JSONValue } from '@lumino/coreutils';
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, postConstruct, named } from 'inversify';
 import { Disposable, DisposableCollection } from '../disposable';
 import { Emitter, Event } from '../event';
 import { Deferred } from '../promise-util';
@@ -29,6 +29,7 @@ import { PreferenceScope } from './preference-scope';
 import { PreferenceConfigurations } from './preference-configurations';
 import { deepFreeze } from '../objects';
 import { unreachable } from '../types';
+import { ILogger } from '../logger';
 
 /**
  * Representation of a preference change. A preference value can be set to `undefined` for a specific scope.
@@ -296,6 +297,9 @@ export class PreferenceServiceImpl implements PreferenceService {
     @inject(PreferenceLanguageOverrideService)
     protected readonly preferenceOverrideService: PreferenceLanguageOverrideService;
 
+    @inject(ILogger) @named('core:PreferenceServiceImpl')
+    protected readonly logger: ILogger;
+
     protected readonly preferenceProviders = new Map<PreferenceScope, PreferenceProvider>();
 
     protected async initializeProviders(): Promise<void> {
@@ -309,7 +313,7 @@ export class PreferenceServiceImpl implements PreferenceService {
                     ));
                     await provider.ready;
                 } else {
-                    console.warn(`No preference provider bound for ${PreferenceScope[scope]}`);
+                    this.logger.warn(`No preference provider bound for ${PreferenceScope[scope]}`);
                 }
             }
             this._ready.resolve();

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -139,7 +139,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         const disposeHandler = window.electronTheiaCore.onWindowEvent('focus', () => {
             this.setMenu(app);
         });
-        window.addEventListener('unload', () => disposeHandler.dispose());
+        window.addEventListener('pagehide', () => disposeHandler.dispose());
     }
 
     protected attachMenuBarVisibilityListener(): void {

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

@@ -61,7 +61,7 @@ export class ElectronSecondaryWindowService extends DefaultSecondaryWindowServic
             for (let i = this.secondaryWindows.length - 1; i >= 0; i--) {
                 const windowClosed = new Deferred<void>();
                 const win = this.secondaryWindows[i];
-                win.addEventListener('unload', () => {
+                win.addEventListener('pagehide', () => {
                     windowClosed.resolve();
                 });
                 promises.push(windowClosed.promise);

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

@@ -89,9 +89,9 @@ export class ElectronWindowService extends DefaultWindowService {
             }
             return willShutDown;
         });
-        window.addEventListener('unload', () => {
-            this.onUnloadEmitter.fire();
-        });
+        // Intentionally not calling `super`: in Electron the close request handler above takes the role of
+        // `beforeunload`, and there is no back/forward cache, so only the `pagehide` listener is shared.
+        this.registerPageHideListener();
     }
 
     /**

package/src/node/backend-application.spec.ts

@@ -142,7 +142,8 @@ describe('BackendApplication', () => {
             const container = createTestContainer();
             const cleanupError = new Error('cleanup boom');
             sandbox.stub(container, 'unbindAllAsync').rejects(cleanupError);
-            const warnStub = sandbox.stub(console, 'warn');
+            const mockLogger = container.get(ILogger) as ILogger;
+            const warnStub = sandbox.stub(mockLogger, 'warn');
 
             const app = container.get(TestBackendApplication);
 
@@ -157,7 +158,8 @@ describe('BackendApplication', () => {
             const clock = sandbox.useFakeTimers();
             const container = createTestContainer();
             sandbox.stub(container, 'unbindAllAsync').returns(new Promise<void>(() => { /* never */ }));
-            const warnStub = sandbox.stub(console, 'warn');
+            const mockLogger = container.get(ILogger) as ILogger;
+            const warnStub = sandbox.stub(mockLogger, 'warn');
 
             const app = container.get(TestBackendApplication);
 
@@ -220,7 +222,8 @@ describe('BackendApplication', () => {
                 onStop: () => new Promise<void>(() => { /* never */ })
             });
             const unbindSpy = sandbox.spy(container, 'unbindAllAsync');
-            const warnStub = sandbox.stub(console, 'warn');
+            const mockLogger = container.get(ILogger) as ILogger;
+            const warnStub = sandbox.stub(mockLogger, 'warn');
 
             const app = container.get(TestBackendApplication);
             const shutdownPromise = app.invokeGracefulShutdown();

package/src/node/backend-application.ts

@@ -226,7 +226,7 @@ export class BackendApplication {
 
         // Handles `Ctrl+C` and `kill pid`. Delegates to gracefulShutdown so that
         // root-scoped singletons get their @preDestroy hooks invoked before exit.
-        const onSignal = () => { this.gracefulShutdown().catch(err => console.error(err)); };
+        const onSignal = () => { this.gracefulShutdown().catch(err => this.logger.error(err)); };
         process.on('SIGINT', onSignal);
         process.on('SIGTERM', onSignal);
     }
@@ -407,7 +407,7 @@ export class BackendApplication {
             ]);
         } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.warn(`Backend contributions cleanup failed: ${message}`);
+            this.logger.warn(`Backend contributions cleanup failed: ${message}`);
         }
 
         try {
@@ -417,7 +417,7 @@ export class BackendApplication {
             ]);
         } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.warn(`Backend root container cleanup failed: ${message}`);
+            this.logger.warn(`Backend root container cleanup failed: ${message}`);
         }
 
         process.exit(1);
@@ -428,7 +428,7 @@ export class BackendApplication {
             return;
         }
         this.stoppedContributions = true;
-        console.info('>>> Stopping backend contributions...');
+        this.logger.info('>>> Stopping backend contributions...');
         // The `async` wrapper converts a synchronous throw inside a non-async
         // contribution's `onStop` into a rejected promise so the per-contribution
         // try/catch can handle it; otherwise `Promise.all` would abort.
@@ -441,7 +441,7 @@ export class BackendApplication {
                 }
             }
         }));
-        console.info('<<< All backend contributions have been stopped.');
+        this.logger.info('<<< All backend contributions have been stopped.');
     }
 
     protected onStop(): void {

package/src/node/console-logger-server.ts

@@ -14,6 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+// This is the console logger itself, so it cannot log through an ILogger.
+/* eslint-disable @theia/named-logger-check */
+
 import { inject, injectable, postConstruct } from 'inversify';
 import { LoggerWatcher } from '../common/logger-watcher';
 import { LogLevelCliContribution } from './logger-cli-contribution';

package/src/node/env-variables/env-variables-server.ts

@@ -16,7 +16,7 @@
 
 import { join } from 'path';
 import { homedir } from 'os';
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import * as drivelist from 'drivelist';
 import { pathExists, mkdir } from 'fs-extra';
 import { EnvVariable, EnvVariablesServer } from '../../common/env-variables';
@@ -24,6 +24,7 @@ import { isWindows } from '../../common/os';
 import { FileUri } from '../../common/file-uri';
 import { BackendApplicationPath } from '../backend-application';
 import { BackendApplicationConfigProvider } from '../backend-application-config-provider';
+import { ILogger } from '../../common/logger';
 
 @injectable()
 export class EnvVariablesServerImpl implements EnvVariablesServer {
@@ -33,9 +34,12 @@ export class EnvVariablesServerImpl implements EnvVariablesServer {
     protected readonly configDirUri: Promise<string>;
     protected readonly pathExistenceCache: { [key: string]: boolean } = {};
 
+    @inject(ILogger) @named('core:EnvVariablesServerImpl')
+    protected readonly logger: ILogger;
+
     constructor() {
         this.configDirUri = this.createConfigDirUri();
-        this.configDirUri.then(configDirUri => console.log(`Configuration directory URI: '${configDirUri}'`));
+        this.configDirUri.then(configDirUri => this.logger.info(`Configuration directory URI: '${configDirUri}'`));
         const prEnv = process.env;
         Object.keys(prEnv).forEach((key: string) => {
             let keyName = key;

package/src/node/hosting/browser-connection-token.spec.ts

@@ -109,19 +109,24 @@ describe('BrowserConnectionTokenBackendContribution', () => {
         interface MockResponse {
             cookieCalls: CookieCall[];
             nextCalled: boolean;
+            requestHeaders: Record<string, string | undefined>;
         }
 
-        function callMiddleware(cookieValue?: string): MockResponse {
+        function callMiddleware(cookieValue?: string, conditionalHeaders = false): MockResponse {
             const contribution = createContribution();
-            const result: MockResponse = { cookieCalls: [], nextCalled: false };
-
             const req = {
                 headers: {} as Record<string, string | undefined>,
                 socket: { remoteAddress: '127.0.0.1' }
             };
+            const result: MockResponse = { cookieCalls: [], nextCalled: false, requestHeaders: req.headers };
+
             if (cookieValue !== undefined) {
                 req.headers.cookie = `${BROWSER_TOKEN_COOKIE_NAME}=${cookieValue}`;
             }
+            if (conditionalHeaders) {
+                req.headers['if-none-match'] = 'W/"etag"';
+                req.headers['if-modified-since'] = 'Thu, 01 Jan 2026 00:00:00 GMT';
+            }
 
             const res = {
                 cookie: (name: string, value: string, options: Record<string, unknown>) => {
@@ -164,6 +169,28 @@ describe('BrowserConnectionTokenBackendContribution', () => {
             expect(result.cookieCalls).to.have.length(1);
             expect(result.cookieCalls[0].value).to.equal(token.value);
         });
+
+        it('should drop conditional request headers when re-issuing the cookie (stale token)', () => {
+            const result = callMiddleware('stale-token-from-old-server', true);
+            expect(result.nextCalled).to.be.true;
+            expect(result.cookieCalls).to.have.length(1);
+            expect(result.requestHeaders['if-none-match']).to.be.undefined;
+            expect(result.requestHeaders['if-modified-since']).to.be.undefined;
+        });
+
+        it('should drop conditional request headers when issuing the cookie (no cookie)', () => {
+            const result = callMiddleware(undefined, true);
+            expect(result.cookieCalls).to.have.length(1);
+            expect(result.requestHeaders['if-none-match']).to.be.undefined;
+            expect(result.requestHeaders['if-modified-since']).to.be.undefined;
+        });
+
+        it('should keep conditional request headers when the cookie is valid', () => {
+            const result = callMiddleware(token.value, true);
+            expect(result.cookieCalls).to.have.length(0);
+            expect(result.requestHeaders['if-none-match']).to.equal('W/"etag"');
+            expect(result.requestHeaders['if-modified-since']).to.equal('Thu, 01 Jan 2026 00:00:00 GMT');
+        });
     });
 
     describe('validateRequest (HTTP token enforcement)', () => {

package/src/node/hosting/browser-connection-token.ts

@@ -18,12 +18,13 @@ import * as cookie from 'cookie';
 import * as crypto from 'crypto';
 import * as http from 'http';
 import express = require('express');
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import { environment } from '../../common/index';
 import { MaybePromise } from '../../common';
 import { BackendApplicationContribution, EarlyExpressMiddleware } from '../backend-application';
 import { WsRequestValidatorContribution } from '../ws-request-validators';
 import { generateUuid } from '../../common/uuid';
+import { ILogger } from '../../common/logger';
 
 export const BrowserConnectionToken = Symbol('BrowserConnectionToken');
 
@@ -79,6 +80,9 @@ export class BrowserConnectionTokenBackendContribution implements BackendApplica
     @inject(EarlyExpressMiddleware)
     protected readonly earlyMiddleware: EarlyExpressMiddleware;
 
+    @inject(ILogger) @named('core:BrowserConnectionTokenBackendContribution')
+    protected readonly logger: ILogger;
+
     /**
      * Register the cookie middleware during `initialize()` via `EarlyExpressMiddleware`
      * so it runs before `express.static()` (which is registered later during `configure()`).
@@ -138,6 +142,13 @@ export class BrowserConnectionTokenBackendContribution implements BackendApplica
                 sameSite: 'strict',
                 path: '/'
             });
+            // The static handlers would answer a revalidation of an unchanged page with a 304,
+            // and reverse proxies commonly drop Set-Cookie from 304 replies or answer the
+            // revalidation from their own cache. The browser would then keep the stale token
+            // and every WebSocket handshake would be rejected, with no way to recover short of
+            // a cache-bypassing hard reload. Force a full 200 so the cookie reaches the browser.
+            delete req.headers['if-none-match'];
+            delete req.headers['if-modified-since'];
         }
         next();
     }
@@ -156,7 +167,7 @@ export class BrowserConnectionTokenBackendContribution implements BackendApplica
             const expected = Buffer.from(this.browserConnectionToken.value, 'utf8');
             return received.byteLength === expected.byteLength && crypto.timingSafeEqual(received, expected);
         } catch (error) {
-            console.error(error);
+            this.logger.error(error);
         }
         return false;
     }