@theia/core 1.75.0-next.29 → 1.75.0-next.34

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;
     }

package/src/node/key-store-server.ts

@@ -21,12 +21,15 @@
 // code copied and modified from https://github.com/microsoft/vscode/blob/1.55.2/src/vs/platform/native/electron-main/nativeHostMainService.ts#L679-L771
 
 import { KeyStoreService } from '../common/key-store';
-import { injectable } from 'inversify';
-import { isWindows } from '../common';
+import { injectable, inject, named } from 'inversify';
+import { isWindows, ILogger } from '../common';
 
 @injectable()
 export class KeyStoreServiceImpl implements KeyStoreService {
 
+    @inject(ILogger) @named('core:KeyStoreServiceImpl')
+    protected readonly logger: ILogger;
+
     private static readonly MAX_PASSWORD_LENGTH = 2500;
     private static readonly PASSWORD_CHUNK_SIZE = KeyStoreServiceImpl.MAX_PASSWORD_LENGTH - 100;
 
@@ -108,7 +111,7 @@ export class KeyStoreServiceImpl implements KeyStoreService {
             await this.keytarImplementation.findCredentials('test-keytar-loads');
         } catch (err) {
             this.keytarImplementation = new InMemoryCredentialsProvider();
-            console.warn('OS level credential store could not be accessed. Using in-memory credentials provider', err);
+            this.logger.warn('OS level credential store could not be accessed. Using in-memory credentials provider', err);
         }
         return this.keytarImplementation;
     }

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

@@ -75,7 +75,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)));
+        socket.onClose(() => connectionContainer.unbindAllAsync().catch(e => this.logger.error(e)));
         return connectionContainer;
     }
 

package/src/node/messaging/ipc-connection-provider.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import * as cp from 'child_process';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import * as path from 'path';
 import { createInterface } from 'readline';
 import { Channel, ConnectionErrorHandler, Disposable, DisposableCollection, ILogger } from '../../common';
@@ -38,7 +38,7 @@ export type IPCConnectionOptions = Partial<ResolvedIPCConnectionOptions> & {
 @injectable()
 export class IPCConnectionProvider {
 
-    @inject(ILogger)
+    @inject(ILogger) @named('core:IPCConnectionProvider')
     protected readonly logger: ILogger;
 
     listen(options: IPCConnectionOptions, acceptor: (connection: Channel) => void): Disposable {

package/src/node/messaging/websocket-endpoint.ts

@@ -55,7 +55,7 @@ export class WebsocketEndpoint implements BackendApplicationContribution {
                 this.wsRequestValidator.allowWsUpgrade(req).then(
                     allowed => callback(noError, allowed),
                     error => {
-                        console.error('Error during WebSocket allowRequest validation:', error);
+                        this.logger.error('Error during WebSocket allowRequest validation:', error);
                         callback(error?.message ?? 'Validation error', false);
                     }
                 );

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

@@ -15,7 +15,7 @@
 
 import { Channel, WriteBuffer } from '../../common/message-rpc';
 import { MessagingService } from './messaging-service';
-import { inject, injectable, interfaces } from 'inversify';
+import { inject, injectable, interfaces, named } from 'inversify';
 import { Socket } from 'socket.io';
 import { ConnectionHandlers, MessagingContainer } from './default-messaging-service';
 import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
@@ -25,7 +25,7 @@ import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/messag
 import { BackendApplicationConfigProvider } from '../backend-application-config-provider';
 import { WebsocketEndpoint } from './websocket-endpoint';
 import { ConnectionManagementMessages } from '../../common/messaging/connection-management';
-import { Disposable, DisposableCollection } from '../../common';
+import { Disposable, DisposableCollection, ILogger } from '../../common';
 
 @injectable()
 export class WebsocketFrontendConnectionService implements FrontendConnectionService {
@@ -36,6 +36,9 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     @inject(MessagingContainer)
     protected readonly container: interfaces.Container;
 
+    @inject(ILogger) @named('core:WebsocketFrontendConnectionService')
+    protected readonly logger: ILogger;
+
     protected readonly wsHandlers = new ConnectionHandlers();
     protected readonly connectionsByFrontend = new Map<string, ReconnectableSocketChannel>();
     protected readonly closeTimeouts = new Map<string, NodeJS.Timeout>();
@@ -65,7 +68,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
             socket.off(ConnectionManagementMessages.RECONNECT, reconnectListener);
             const channel = this.connectionsByFrontend.get(frontEndId);
             if (channel) {
-                console.info(`Reconnecting to front end ${frontEndId}`);
+                this.logger.info(`Reconnecting to front end ${frontEndId}`);
                 socket.emit(ConnectionManagementMessages.RECONNECT, true);
                 channel.connect(socket);
                 this.handleSocketDisconnect(socket, channel, frontEndId);
@@ -73,7 +76,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
                 clearTimeout(pendingTimeout);
                 this.closeTimeouts.delete(frontEndId);
             } else {
-                console.info(`Reconnecting failed for ${frontEndId}`);
+                this.logger.info(`Reconnecting failed for ${frontEndId}`);
                 socket.emit(ConnectionManagementMessages.RECONNECT, false);
             }
         };
@@ -82,7 +85,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     }
 
     protected closeConnection(frontEndId: string, reason: string): void {
-        console.info(`closing connection for ${frontEndId}`);
+        this.logger.info(`closing connection for ${frontEndId}`);
         const connection = this.connectionsByFrontend.get(frontEndId)!; // not called when no connection is present
 
         this.connectionsByFrontend.delete(frontEndId);
@@ -97,7 +100,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     }
 
     protected createConnection(socket: Socket, frontEndId: string): ReconnectableSocketChannel {
-        console.info(`creating connection for ${frontEndId}`);
+        this.logger.info(`creating connection for ${frontEndId}`);
         const channel = this.container.get(ReconnectableSocketChannel);
         channel.connect(socket);
 
@@ -107,7 +110,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
 
     handleSocketDisconnect(socket: Socket, channel: ReconnectableSocketChannel, frontEndId: string): void {
         socket.on('disconnect', evt => {
-            console.info('socket closed');
+            this.logger.info('socket closed');
             channel.disconnect();
 
             const timeout = this.frontendConnectionTimeout();
@@ -115,7 +118,7 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
             if (timeout === 0 || isMarkedForClose) {
                 this.closeConnection(frontEndId, evt);
             } else if (timeout > 0) {
-                console.info(`setting close timeout for id ${frontEndId} to ${timeout}`);
+                this.logger.info(`setting close timeout for id ${frontEndId} to ${timeout}`);
                 const handle = setTimeout(() => {
                     this.closeConnection(frontEndId, evt);
                 }, timeout);

package/src/node/setting-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { promises as fs } from 'fs';
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, postConstruct, named } from 'inversify';
 import { ILogger, URI } from '../common';
 import { EnvVariablesServer } from '../common/env-variables';
 import { Deferred } from '../common/promise-util';
@@ -32,7 +32,7 @@ export interface SettingService {
 
 @injectable()
 export class SettingServiceImpl implements SettingService {
-    @inject(ILogger)
+    @inject(ILogger) @named('core:SettingServiceImpl')
     protected readonly logger: ILogger;
 
     @inject(EnvVariablesServer)