@theia/core 1.74.0-next.0 → 1.74.0-next.15

package/src/common/logger.spec.ts

@@ -16,7 +16,7 @@
 
 import { expect } from 'chai';
 import { MockLogger } from './test/mock-logger';
-import { setRootLogger, unsetRootLogger, Logger } from './logger';
+import { setRootLogger, unsetRootLogger, Logger, LogLevel, Log } from './logger';
 import { DefaultLoggerSanitizer, LoggerSanitizer } from './logger-sanitizer';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -39,6 +39,24 @@ class TestableLogger extends Logger {
     public testSanitize(message: string): string {
         return this.sanitize(message);
     }
+
+    public testGetLog(logLevel: LogLevel): Promise<Log> {
+        return this.getLog(logLevel);
+    }
+
+    /** Configure the logger to behave as if the backend reported the given current log level. */
+    public configureLogLevel(level: LogLevel): void {
+        (this as any).created = Promise.resolve();
+        (this as any)._logLevel = Promise.resolve(level);
+        (this as any).server = {
+            log: (...args: any[]) => {
+                this.loggedMessages.push(args);
+                return Promise.resolve();
+            }
+        };
+    }
+
+    public readonly loggedMessages: any[][] = [];
 }
 
 describe('logger', () => {
@@ -66,6 +84,49 @@ describe('logger', () => {
         ).to.not.throw(ReferenceError);
     });
 
+    describe('log level gating', () => {
+        it('resolves debug() when the debug level is not enabled', async function (): Promise<void> {
+            this.timeout(1000);
+            const logger = new TestableLogger();
+            logger.configureLogLevel(LogLevel.INFO); // DEBUG is below INFO, so it is disabled
+
+            await logger.debug('this should not hang');
+
+            expect(logger.loggedMessages).to.have.lengthOf(0);
+        });
+
+        it('resolves debug() and logs when the debug level is enabled', async () => {
+            const logger = new TestableLogger();
+            logger.configureLogLevel(LogLevel.DEBUG);
+
+            await logger.debug('hello');
+
+            expect(logger.loggedMessages).to.have.lengthOf(1);
+        });
+
+        it('does not invoke a loggable when the level is not enabled', async function (): Promise<void> {
+            this.timeout(1000);
+            const logger = new TestableLogger();
+            logger.configureLogLevel(LogLevel.INFO);
+            let invoked = false;
+
+            await logger.debug(() => { invoked = true; });
+
+            expect(invoked).to.equal(false);
+        });
+
+        it('getLog() resolves to a no-op when the level is not enabled', async function (): Promise<void> {
+            this.timeout(1000);
+            const logger = new TestableLogger();
+            logger.configureLogLevel(LogLevel.INFO);
+
+            const log = await logger.testGetLog(LogLevel.DEBUG);
+            log('this should be ignored');
+
+            expect(logger.loggedMessages).to.have.lengthOf(0);
+        });
+    });
+
     describe('Logger sanitization', () => {
         let loggerWithSanitizer: TestableLogger;
         let loggerWithoutSanitizer: TestableLogger;

package/src/common/logger.ts

@@ -56,6 +56,9 @@ export function setRootLogger(aLogger: ILogger): void {
 export type Log = (message: any, ...params: any[]) => void;
 export type Loggable = (log: Log) => void;
 
+/** Shared no-op {@link Log} returned for a disabled level so that callers neither block nor emit. */
+const nullLogger: Log = () => { };
+
 export const LoggerFactory = Symbol('LoggerFactory');
 export type LoggerFactory = (name: string) => ILogger;
 
@@ -304,6 +307,9 @@ export class Logger implements ILogger {
     }
     log(logLevel: number, arg2: any | Loggable, ...params: any[]): Promise<void> {
         return this.getLog(logLevel).then(log => {
+            if (log === nullLogger) {
+                return;
+            }
             if (typeof arg2 === 'function') {
                 const loggable = arg2;
                 loggable(log);
@@ -313,12 +319,15 @@ export class Logger implements ILogger {
         });
     }
     protected getLog(logLevel: number): Promise<Log> {
-        return this.ifEnabled(logLevel).then(() =>
-            this.created.then(() =>
+        return this.isEnabled(logLevel).then(enabled => {
+            if (!enabled) {
+                return nullLogger;
+            }
+            return this.created.then(() =>
                 (message: any, ...params: any[]) =>
                     this.server.log(this.name, logLevel, this.format(message), params.map(p => this.format(p)))
-            )
-        );
+            );
+        });
     }
     protected format(value: any): any {
         switch (typeof value) {

package/src/common/preferences/index.ts

@@ -16,6 +16,7 @@
 
 export * from './defaults-preference-provider';
 export * from './preference-language-override-service';
+export * from './session-preference-provider';
 export * from './preference-provider-impl';
 export * from './preference-provider';
 export * from './preference-schema-service';

package/src/common/preferences/preference-scope.spec.ts

@@ -20,11 +20,11 @@ import { PreferenceScope } from './preference-scope';
 describe('PreferenceScope', () => {
 
     it('getScopes() should return numbers from broadest to narrowest', () => {
-        expect(PreferenceScope.getScopes()).deep.equal([0, 1, 2, 3]);
+        expect(PreferenceScope.getScopes()).deep.equal([0, 1, 2, 3, 4]);
     });
 
     it('getReversedScopes() should return numbers from narrowest to broadest', () => {
-        expect(PreferenceScope.getReversedScopes()).deep.equal([3, 2, 1, 0]);
+        expect(PreferenceScope.getReversedScopes()).deep.equal([4, 3, 2, 1, 0]);
     });
 
     it('getScopeNames() should return the names of scopes broader than the current one', () => {
@@ -36,11 +36,13 @@ describe('PreferenceScope', () => {
         expect(PreferenceScope.is(PreferenceScope.User)).to.be.true;
         expect(PreferenceScope.is(PreferenceScope.Workspace)).to.be.true;
         expect(PreferenceScope.is(PreferenceScope.Folder)).to.be.true;
+        expect(PreferenceScope.is(PreferenceScope.Session)).to.be.true;
         expect(PreferenceScope.is(0)).to.be.true;
         expect(PreferenceScope.is(1)).to.be.true;
         expect(PreferenceScope.is(2)).to.be.true;
         expect(PreferenceScope.is(3)).to.be.true;
-        expect(PreferenceScope.is(4)).to.be.false;
+        expect(PreferenceScope.is(4)).to.be.true;
+        expect(PreferenceScope.is(5)).to.be.false;
         expect(PreferenceScope.is(-1)).to.be.false;
         expect(PreferenceScope.is({})).to.be.false;
         expect(PreferenceScope.is('Default')).to.be.false;

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

@@ -23,7 +23,12 @@ export enum PreferenceScope {
     Default,
     User,
     Workspace,
-    Folder
+    Folder,
+    /**
+     * Process-lifetime, in-memory scope used by `--session-preference` CLI overrides.
+     * Has the highest precedence and is never persisted to disk.
+     */
+    Session
 }
 
 export namespace PreferenceScope {

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

@@ -254,6 +254,10 @@ export interface PreferenceInspection<T = JSONValue> {
      * Value in folder scope.
      */
     workspaceFolderValue: T | undefined,
+    /**
+     * Value in session scope (in-memory, set via `--session-preference`).
+     */
+    sessionValue?: T | undefined,
     /**
      * The value that is active, i.e. the value set in the lowest scope available.
      */
@@ -453,11 +457,37 @@ export class PreferenceServiceImpl implements PreferenceService {
         }
         const provider = this.getProvider(resolvedScope);
         if (provider && await provider.setPreference(preferenceName, value, resourceUri)) {
+            await this.evictSessionOverride(preferenceName, resolvedScope);
             return;
         }
         throw new Error(`Unable to write to ${PreferenceScope[resolvedScope]} Settings.`);
     }
 
+    /**
+     * When a preference is written to a persistent scope, drop any in-memory session
+     * override (set via `--session-preference`) for the same key so that the explicit
+     * change takes effect for the remainder of the session. Without this, the session
+     * scope would keep shadowing the user's change because it has higher precedence.
+     *
+     * Note: this fires for any write to a persistent scope, including programmatic
+     * writes from extensions. Extensions that race with startup CLI overrides will
+     * therefore clear them. This is intentional: a programmatic write is "explicit"
+     * from the preference system's point of view, but consumers should be aware.
+     *
+     * Session preferences are global (no per-resource scoping), so `resourceUri` is
+     * not threaded through.
+     */
+    protected async evictSessionOverride(preferenceName: string, writtenScope: PreferenceScope): Promise<void> {
+        if (writtenScope === PreferenceScope.Session || writtenScope === PreferenceScope.Default) {
+            return;
+        }
+        const sessionProvider = this.getProvider(PreferenceScope.Session);
+        if (sessionProvider && sessionProvider.get(preferenceName) !== undefined) {
+            // Passing `undefined` clears the value in the session provider.
+            await sessionProvider.setPreference(preferenceName, undefined as unknown as JSONValue);
+        }
+    }
+
     getBoolean(preferenceName: string): boolean | undefined;
     getBoolean(preferenceName: string, defaultValue: boolean): boolean;
     getBoolean(preferenceName: string, defaultValue: boolean, resourceUri: string): boolean;
@@ -499,10 +529,11 @@ export class PreferenceServiceImpl implements PreferenceService {
         const globalValue = this.inspectInScope<T>(preferenceName, PreferenceScope.User, resourceUri, forceLanguageOverride);
         const workspaceValue = this.inspectInScope<T>(preferenceName, PreferenceScope.Workspace, resourceUri, forceLanguageOverride);
         const workspaceFolderValue = this.inspectInScope<T>(preferenceName, PreferenceScope.Folder, resourceUri, forceLanguageOverride);
+        const sessionValue = this.inspectInScope<T>(preferenceName, PreferenceScope.Session, resourceUri, forceLanguageOverride);
 
-        const valueApplied = workspaceFolderValue ?? workspaceValue ?? globalValue ?? defaultValue;
+        const valueApplied = sessionValue ?? workspaceFolderValue ?? workspaceValue ?? globalValue ?? defaultValue;
 
-        return { preferenceName, defaultValue, globalValue, workspaceValue, workspaceFolderValue, value: valueApplied };
+        return { preferenceName, defaultValue, globalValue, workspaceValue, workspaceFolderValue, sessionValue, value: valueApplied };
     }
 
     inspectInScope<T extends JSONValue>(preferenceName: string, scope: PreferenceScope, resourceUri?: string, forceLanguageOverride?: boolean): T | undefined {
@@ -526,6 +557,8 @@ export class PreferenceServiceImpl implements PreferenceService {
                 return inspection.workspaceValue;
             case PreferenceScope.Folder:
                 return inspection.workspaceFolderValue;
+            case PreferenceScope.Session:
+                return inspection.sessionValue;
         }
         unreachable(scope, 'Not all PreferenceScope enum variants handled.');
     }
@@ -551,9 +584,10 @@ export class PreferenceServiceImpl implements PreferenceService {
         }
 
         // Scopes in ascending order of scope breadth.
-        const allScopes = [...this.schemaService.validScopes].reverse();
-        // Get rid of Default scope. We can't set anything there.
-        allScopes.pop();
+        const allScopes = [...this.schemaService.validScopes].reverse()
+            // Default is read-only, and Session is populated only by `--session-preference`,
+            // so neither is a valid target for a regular user edit.
+            .filter(scope => scope !== PreferenceScope.Default && scope !== PreferenceScope.Session);
 
         const isScopeDefined = (scope: PreferenceScope) => this.getScopedValueFromInspection(inspection, scope) !== undefined;
 

package/src/common/preferences/session-preference-provider.spec.ts

@@ -0,0 +1,78 @@
+// *****************************************************************************
+// 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 { SessionPreferenceProvider } from './session-preference-provider';
+import { PreferenceScope } from './preference-scope';
+
+describe('SessionPreferenceProvider', () => {
+
+    let provider: SessionPreferenceProvider;
+
+    beforeEach(() => {
+        provider = new SessionPreferenceProvider();
+        // PostConstruct emulation
+        (provider as unknown as { init(): void }).init();
+    });
+
+    it('claims only the Session scope', () => {
+        expect(provider.canHandleScope(PreferenceScope.Session)).to.be.true;
+        expect(provider.canHandleScope(PreferenceScope.User)).to.be.false;
+        expect(provider.canHandleScope(PreferenceScope.Workspace)).to.be.false;
+        expect(provider.canHandleScope(PreferenceScope.Folder)).to.be.false;
+        expect(provider.canHandleScope(PreferenceScope.Default)).to.be.false;
+    });
+
+    it('starts empty', () => {
+        expect(provider.getPreferences()).to.deep.equal({});
+    });
+
+    it('stores set values in memory and exposes them via get/resolve', async () => {
+        const ok = await provider.setPreference('editor.fontSize', 18);
+        expect(ok).to.be.true;
+        expect(provider.get('editor.fontSize')).to.equal(18);
+        expect(provider.resolve('editor.fontSize').value).to.equal(18);
+        expect(provider.getPreferences()).to.deep.equal({ 'editor.fontSize': 18 });
+    });
+
+    it('emits a change event on set', async () => {
+        let received: { name: string; newValue: unknown; oldValue: unknown; scope: PreferenceScope } | undefined;
+        provider.onDidPreferencesChanged(changes => {
+            const key = Object.keys(changes)[0];
+            received = {
+                name: changes[key].preferenceName,
+                newValue: changes[key].newValue,
+                oldValue: changes[key].oldValue,
+                scope: changes[key].scope
+            };
+        });
+        await provider.setPreference('foo', 'bar');
+        expect(received).to.deep.equal({ name: 'foo', newValue: 'bar', oldValue: undefined, scope: PreferenceScope.Session });
+    });
+
+    it('removes a value when set to undefined', async () => {
+        await provider.setPreference('foo', 'bar');
+        const removed = await provider.setPreference('foo', undefined as never);
+        expect(removed).to.be.true;
+        expect(provider.get('foo')).to.equal(undefined);
+        expect(provider.getPreferences()).to.deep.equal({});
+    });
+
+    it('returns false when removing a key that was never set', async () => {
+        const removed = await provider.setPreference('missing', undefined as never);
+        expect(removed).to.be.false;
+    });
+});

package/src/common/preferences/session-preference-provider.ts

@@ -0,0 +1,69 @@
+// *****************************************************************************
+// 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 { JSONObject, JSONValue } from '@lumino/coreutils';
+import { injectable, postConstruct } from 'inversify';
+import { PreferenceProvider, PreferenceProviderDataChange } from './preference-provider';
+import { PreferenceProviderImpl } from './preference-provider-impl';
+import { PreferenceScope } from './preference-scope';
+
+/**
+ * In-memory preference provider used for process-lifetime overrides such as those
+ * supplied via the `--session-preference` CLI option. Values live in memory only
+ * and are dropped when the process exits.
+ */
+@injectable()
+export class SessionPreferenceProvider extends PreferenceProviderImpl implements PreferenceProvider {
+
+    protected readonly preferences = new Map<string, JSONValue>();
+
+    @postConstruct()
+    protected init(): void {
+        this._ready.resolve();
+    }
+
+    override canHandleScope(scope: PreferenceScope): boolean {
+        return scope === PreferenceScope.Session;
+    }
+
+    getPreferences(): JSONObject {
+        const result: JSONObject = {};
+        for (const [name, value] of this.preferences) {
+            result[name] = value;
+        }
+        return result;
+    }
+
+    async setPreference(key: string, value: JSONValue | undefined): Promise<boolean> {
+        const oldValue = this.preferences.get(key);
+        if (value === undefined) {
+            if (!this.preferences.has(key)) {
+                return false;
+            }
+            this.preferences.delete(key);
+        } else {
+            this.preferences.set(key, value);
+        }
+        const change: PreferenceProviderDataChange = {
+            preferenceName: key,
+            newValue: value,
+            oldValue,
+            scope: PreferenceScope.Session
+        };
+        await this.emitPreferencesChangedEvent([change]);
+        return true;
+    }
+}