@theia/core 1.70.0-next.7 → 1.70.0-next.71

package/src/common/logger-sanitizer.spec.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import { DefaultLoggerSanitizer } from './logger-sanitizer';
+import { DefaultLoggerSanitizer, DefaultSanitizationRules } from './logger-sanitizer';
 
 describe('DefaultLoggerSanitizer', () => {
     let sanitizer: DefaultLoggerSanitizer;
@@ -285,4 +285,57 @@ describe('DefaultLoggerSanitizer', () => {
             expect(sanitized).to.equal('"serverAuthToken": "****"');
         });
     });
+
+    describe('precheck optimization', () => {
+        describe('URL precheck', () => {
+            it('should return false when :// is missing', () => {
+                const urlRule = DefaultSanitizationRules[0];
+
+                expect(urlRule.precheck!('user@host')).to.be.false;
+                expect(urlRule.precheck!('email@example.com')).to.be.false;
+                expect(urlRule.precheck!('no url here')).to.be.false;
+            });
+
+            it('should return false when @ is missing even if :// exists', () => {
+                const urlRule = DefaultSanitizationRules[0];
+
+                expect(urlRule.precheck!('https://example.com/path')).to.be.false;
+                expect(urlRule.precheck!('http://localhost:8080')).to.be.false;
+            });
+
+            it('should return true only when both :// and @ exist', () => {
+                const urlRule = DefaultSanitizationRules[0];
+
+                expect(urlRule.precheck!('http://user:pass@host.com')).to.be.true;
+                expect(urlRule.precheck!('https://u:p@example.com')).to.be.true;
+            });
+        });
+
+        describe('API key precheck', () => {
+            it('should return false when patterns are missing', () => {
+                const apiKeyRule = DefaultSanitizationRules[1];
+
+                expect(apiKeyRule.precheck!('normal log message')).to.be.false;
+                expect(apiKeyRule.precheck!('just api without the other word')).to.be.false;
+                expect(apiKeyRule.precheck!('just key without the other word')).to.be.false;
+                expect(apiKeyRule.precheck!('login failed')).to.be.false;
+            });
+
+            it('should return true when api and key patterns exist', () => {
+                const apiKeyRule = DefaultSanitizationRules[1];
+
+                expect(apiKeyRule.precheck!('"api_key": "value"')).to.be.true;
+                expect(apiKeyRule.precheck!('API_KEY=something')).to.be.true;
+                expect(apiKeyRule.precheck!('the apiKey is set')).to.be.true;
+            });
+
+            it('should return true when auth and token patterns exist', () => {
+                const apiKeyRule = DefaultSanitizationRules[1];
+
+                expect(apiKeyRule.precheck!('"auth_token": "value"')).to.be.true;
+                expect(apiKeyRule.precheck!('AUTH_TOKEN=something')).to.be.true;
+                expect(apiKeyRule.precheck!('the authToken is set')).to.be.true;
+            });
+        });
+    });
 });

package/src/common/logger-sanitizer.ts

@@ -65,6 +65,34 @@ export interface SanitizationRule {
      * The replacement string. Can include capture group references like $1, $2, etc.
      */
     replacement: string;
+
+    /**
+     * Optional quick check function that returns true if the message might contain
+     * sensitive data matching this rule. Used as a fast early-exit optimization
+     * to avoid running expensive regex operations on messages that definitely
+     * don't contain sensitive data.
+     *
+     * If not provided, the regex pattern will always be executed.
+     */
+    precheck?: (message: string) => boolean;
+}
+
+/**
+ * Checks if message might contain a URL with credentials.
+ * Checks for :// (required for any URL) and @ (required for credentials).
+ */
+function mightContainUrlCredentials(message: string): boolean {
+    return message.includes('://') && message.includes('@');
+}
+
+/**
+ * Checks if message might contain API key or auth token patterns.
+ * Uses lowercase comparison for case-insensitive matching.
+ */
+function mightContainApiKeyOrToken(message: string): boolean {
+    const lower = message.toLowerCase();
+    return (lower.includes('api') && lower.includes('key')) ||
+        (lower.includes('auth') && lower.includes('token'));
 }
 
 /**
@@ -78,7 +106,8 @@ export const DefaultSanitizationRules: SanitizationRule[] = [
          * Capture groups: $1=protocol, $2=username, $3=password, $4=host (with optional port)
          */
         pattern: /([a-z][a-z0-9+.-]*:\/\/)([^:/@]+):([^:/@]+)@([^/:@\s]+(?::\d+)?)/giu,
-        replacement: '$1****:****@$4'
+        replacement: '$1****:****@$4',
+        precheck: mightContainUrlCredentials
     },
     {
         /**
@@ -88,7 +117,8 @@ export const DefaultSanitizationRules: SanitizationRule[] = [
          * Capture groups: $1=key with opening quote of value, $2=closing quote of value
          */
         pattern: /(\\?["'][\w.-]*(?:api[_-]?key|auth[_-]?token)\\?["']\s*:\s*\\?["'])[^"'\\]+(\\?["'])/gi,
-        replacement: '$1****$2'
+        replacement: '$1****$2',
+        precheck: mightContainApiKeyOrToken
     }
 ];
 
@@ -101,9 +131,14 @@ export class DefaultLoggerSanitizer implements LoggerSanitizer {
     protected rules: SanitizationRule[] = DefaultSanitizationRules;
 
     sanitize(message: string): string {
+        if (!message) {
+            return message;
+        }
         let result = message;
         for (const rule of this.rules) {
-            result = result.replace(rule.pattern, rule.replacement);
+            if (!rule.precheck || rule.precheck(result)) {
+                result = result.replace(rule.pattern, rule.replacement);
+            }
         }
         return result;
     }

package/src/common/preferences/injectable-preference-proxy.ts

@@ -15,13 +15,16 @@
 // *****************************************************************************
 
 import { inject, injectable, postConstruct } from 'inversify';
-import { PreferenceSchema } from '../../common/preferences/preference-schema';
-import { Disposable, DisposableCollection, Emitter, Event, isObject, MaybePromise, PreferenceScope } from '../../common';
+import { PreferenceSchema } from './preference-schema';
 import { PreferenceChangeEvent, PreferenceEventEmitter, PreferenceProxy, PreferenceProxyOptions, PreferenceRetrieval } from './preference-proxy';
 import { PreferenceChange, PreferenceChangeImpl, PreferenceChanges, PreferenceService } from './preference-service';
 import { JSONValue } from '@lumino/coreutils';
 import { PreferenceProviderDataChange } from './preference-provider';
-import { OverridePreferenceName } from '../../common/preferences/preference-language-override-service';
+import { OverridePreferenceName } from './preference-language-override-service';
+import { isObject, MaybePromise } from '../types';
+import { DisposableCollection } from '../disposable';
+import { Emitter, Event } from '../event';
+import { PreferenceScope } from './preference-scope';
 
 export const PreferenceProxySchema = Symbol('PreferenceProxySchema');
 export interface PreferenceProxyFactory {

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

@@ -15,8 +15,8 @@
 // *****************************************************************************
 
 import { injectable, inject, named, interfaces } from 'inversify';
-import URI from '../../common/uri';
-import { ContributionProvider, bindRootContributionProvider } from '../../common/contribution-provider';
+import URI from '../uri';
+import { ContributionProvider, bindRootContributionProvider } from '../contribution-provider';
 
 export const PreferenceConfiguration = Symbol('PreferenceConfiguration');
 export interface PreferenceConfiguration {

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

@@ -17,11 +17,14 @@
 import debounce = require('p-debounce');
 import { injectable } from 'inversify';
 import { JSONObject } from '@lumino/coreutils';
-import URI from '../../common/uri';
-import { DisposableCollection, Emitter, Event, isObject, PreferenceLanguageOverrideService } from '../../common';
-import { Deferred } from '../../common/promise-util';
+import URI from '../uri';
+import { Emitter, Event } from '../event';
+import { Deferred } from '../promise-util';
 import { PreferenceScope } from './preference-scope';
 import { PreferenceProvider, PreferenceProviderDataChange, PreferenceProviderDataChanges, PreferenceResolveResult } from './preference-provider';
+import { DisposableCollection } from '../disposable';
+import { PreferenceLanguageOverrideService } from './preference-language-override-service';
+import { isObject } from '../types';
 
 export abstract class PreferenceProviderBase {
 

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

@@ -16,12 +16,14 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Disposable, Event, isObject, MaybePromise } from '../../common';
 import { PreferenceService } from './preference-service';
 import { PreferenceScope } from './preference-scope';
-import { IJSONSchema } from '../../common/json-schema';
-import { isThenable } from '../../common/promise-util';
-import { OverridePreferenceName } from '../../common/preferences/preference-language-override-service';
+import { IJSONSchema } from '../json-schema';
+import { isThenable } from '../promise-util';
+import { OverridePreferenceName } from './preference-language-override-service';
+import { isObject, MaybePromise } from '../types';
+import { Event } from '../event';
+import { Disposable } from '../disposable';
 
 /**
  * It is worth explaining the type for `PreferenceChangeEvent`:

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

@@ -18,14 +18,17 @@
 
 import { JSONValue } from '@lumino/coreutils';
 import { inject, injectable, postConstruct } from 'inversify';
-import { Disposable, DisposableCollection, Emitter, Event, deepFreeze, unreachable } from '../../common';
-import { Deferred } from '../../common/promise-util';
-import URI from '../../common/uri';
+import { Disposable, DisposableCollection } from '../disposable';
+import { Emitter, Event } from '../event';
+import { Deferred } from '../promise-util';
+import URI from '../uri';
 import { OverridePreferenceName, PreferenceLanguageOverrideService } from './preference-language-override-service';
 import { PreferenceProvider, PreferenceProviderDataChange, PreferenceProviderDataChanges, PreferenceResolveResult, PreferenceUtils } from './preference-provider';
 import { PreferenceSchemaService } from './preference-schema';
 import { PreferenceScope } from './preference-scope';
 import { PreferenceConfigurations } from './preference-configurations';
+import { deepFreeze } from '../objects';
+import { unreachable } from '../types';
 
 /**
  * Representation of a preference change. A preference value can be set to `undefined` for a specific scope.

package/src/common/quick-pick-service.ts

@@ -19,6 +19,7 @@ import { Event } from './event';
 import { KeySequence } from './keys';
 import { CancellationToken } from './cancellation';
 import { Severity } from './severity';
+import { findSubstringIndex, matchRank } from './fuzzy-match-utils';
 
 export const quickPickServicePath = '/services/quickPick';
 export const QuickPickService = Symbol('QuickPickService');
@@ -92,6 +93,26 @@ export interface QuickPickValue<V> extends QuickPickItem {
     value: V
 }
 
+/**
+ * Specifies the location where a {@link QuickInputButton} should be rendered.
+ */
+export enum QuickInputButtonLocation {
+    /**
+     * The button is rendered in the title bar.
+     */
+    Title = 1,
+
+    /**
+     * The button is rendered inline to the right of the input box.
+     */
+    Inline = 2,
+
+    /**
+     * The button is rendered at the far end inside the input box.
+     */
+    Input = 3
+}
+
 export interface QuickInputButton {
     iconClass?: string;
     tooltip?: string;
@@ -101,9 +122,8 @@ export interface QuickInputButton {
     alwaysVisible?: boolean;
     /**
      * The location where the button should be rendered.
-     * @monaco-uplift: consider using a typed enum matching Monaco's QuickInputButtonLocation instead of number.
      */
-    location?: number;
+    location?: QuickInputButtonLocation;
     /**
      * When present, indicates that the button is a toggle button.
      */
@@ -303,24 +323,52 @@ export function filterItems(items: QuickPickItemOrSeparator[], filter: string):
         return items;
     }
 
-    const filteredItems: QuickPickItemOrSeparator[] = [];
+    function matchesFilter(item: QuickPickItem): boolean {
+        return fuzzy.test(filter, item.label) ||
+            (!!item.description && fuzzy.test(filter, item.description)) ||
+            (!!item.detail && fuzzy.test(filter, item.detail));
+    }
+
+    function itemMatchRank(item: QuickPickItem): number {
+        return Math.min(
+            matchRank(item.label, filter),
+            item.description ? matchRank(item.description, filter) : 2,
+            item.detail ? matchRank(item.detail, filter) : 2
+        );
+    }
+
+    // Process items in separator groups, sorted by match rank within each group.
+    const result: QuickPickItemOrSeparator[] = [];
+    let currentSeparator: QuickPickSeparator | undefined;
+    let groupMatches: { item: QuickPickItem; rank: number }[] = [];
+
+    const flushGroup = (): void => {
+        if (groupMatches.length > 0) {
+            if (currentSeparator) {
+                result.push(currentSeparator);
+            }
+            groupMatches.sort((a, b) => a.rank - b.rank);
+            result.push(...groupMatches.map(m => m.item));
+        }
+        groupMatches = [];
+    };
+
     for (const item of items) {
         if (item.type === 'separator') {
-            filteredItems.push(item);
-        } else if (
-            fuzzy.test(filter, item.label) ||
-            (item.description && fuzzy.test(filter, item.description)) ||
-            (item.detail && fuzzy.test(filter, item.detail))
-        ) {
+            flushGroup();
+            currentSeparator = item;
+        } else if (matchesFilter(item)) {
             item.highlights = {
                 label: findMatches(item.label, filter),
                 description: item.description ? findMatches(item.description, filter) : undefined,
                 detail: item.detail ? findMatches(item.detail, filter) : undefined
             };
-            filteredItems.push(item);
+            groupMatches.push({ item, rank: itemMatchRank(item) });
         }
     }
-    return filteredItems;
+    flushGroup();
+
+    return result;
 }
 
 /**
@@ -337,6 +385,12 @@ export function findMatches(word: string, pattern: string): Array<{ start: numbe
         return undefined;
     }
 
+    // Prefer a contiguous substring highlight over scattered fuzzy character highlights.
+    const substringIndex = findSubstringIndex(word, pattern);
+    if (substringIndex !== -1) {
+        return [{ start: substringIndex, end: substringIndex + pattern.length }];
+    }
+
     const delimiter = '\u0000'; // null byte that shouldn't appear in the input and is used to denote matches.
     const matchResult = fuzzy.match(pattern.replace(/\u0000/gu, ''), word, { pre: delimiter, post: delimiter });
     if (!matchResult) {

package/src/common/uri.ts

@@ -22,7 +22,7 @@ export class URI {
     public static fromComponents(components: UriComponents): URI;
     public static fromComponents(components: undefined): undefined;
     public static fromComponents(components: UriComponents | undefined): URI | undefined {
-        return components ? new URI(Uri.revive(components)) : undefined;
+        return components ? new URI(Uri.from(components)) : undefined;
     }
 
     public static fromFilePath(path: string): URI {

package/src/electron-browser/menu/electron-main-menu-factory.ts

@@ -233,12 +233,10 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                 }
             };
 
-            if (isOSX) {
-                const role = this.roleFor(menu.id);
-                if (role) {
-                    menuItem.role = role;
-                    delete menuItem.execute;
-                }
+            const role = this.roleFor(menu.id);
+            if (role) {
+                menuItem.role = role;
+                delete menuItem.execute;
             }
             parentItems.push(menuItem);
         }

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

@@ -26,7 +26,7 @@ import {
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { FrontendApplicationStateService, FrontendApplicationState } from '../../browser/frontend-application-state';
 import { FrontendApplicationConfigProvider } from '../../browser/frontend-application-config-provider';
-import { ZoomLevel } from '../../electron-common/electron-window-preferences';
+import { PREF_WINDOW_ZOOM_LEVEL, ZoomLevel } from '../../electron-common/electron-window-preferences';
 import { BrowserMenuBarContribution } from '../../browser/menu/browser-menu-plugin';
 import { WindowService } from '../../browser/window/window-service';
 import { WindowTitleService } from '../../browser/window/window-title-service';
@@ -316,7 +316,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
                     zoomLevel = ZoomLevel.MAX;
                     return;
                 };
-                this.preferenceService.set('window.zoomLevel', zoomLevel, PreferenceScope.User);
+                this.preferenceService.set(PREF_WINDOW_ZOOM_LEVEL, zoomLevel, PreferenceScope.User);
             }
         });
         registry.registerCommand(ElectronCommands.ZOOM_OUT, {
@@ -328,11 +328,11 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
                     zoomLevel = ZoomLevel.MIN;
                     return;
                 };
-                this.preferenceService.set('window.zoomLevel', zoomLevel, PreferenceScope.User);
+                this.preferenceService.set(PREF_WINDOW_ZOOM_LEVEL, zoomLevel, PreferenceScope.User);
             }
         });
         registry.registerCommand(ElectronCommands.RESET_ZOOM, {
-            execute: () => this.preferenceService.set('window.zoomLevel', ZoomLevel.DEFAULT, PreferenceScope.User)
+            execute: () => this.preferenceService.set(PREF_WINDOW_ZOOM_LEVEL, ZoomLevel.DEFAULT, PreferenceScope.User)
         });
 
         registry.registerCommand(ElectronCommands.TOGGLE_FULL_SCREEN, {

package/src/electron-browser/messaging/electron-local-ws-connection-source.ts

@@ -18,14 +18,16 @@ import { injectable } from 'inversify';
 import { Endpoint } from '../../browser/endpoint';
 import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
 
+export const LOCAL_PORT_PARAM = 'localPort';
 export function getLocalPort(): string | undefined {
     const params = new URLSearchParams(location.search);
-    return params.get('localPort') ?? undefined;
+    return params.get(LOCAL_PORT_PARAM) ?? undefined;
 }
 
+export const CURRENT_PORT_PARAM = 'port';
 export function getCurrentPort(): string | undefined {
     const params = new URLSearchParams(location.search);
-    return params.get('port') ?? undefined;
+    return params.get(CURRENT_PORT_PARAM) ?? undefined;
 }
 
 @injectable()

package/src/electron-browser/preload.ts

@@ -207,8 +207,8 @@ const api: TheiaCoreAPI = {
         return ipcRenderer.invoke(CHANNEL_GET_ZOOM_LEVEL);
     },
 
-    setZoomLevel: function (desired: number): void {
-        ipcRenderer.send(CHANNEL_SET_ZOOM_LEVEL, desired);
+    setZoomLevel: function (desired: number, windowName?: string): void {
+        ipcRenderer.send(CHANNEL_SET_ZOOM_LEVEL, desired, windowName);
     },
     isFullScreenable: function (): boolean {
         return ipcRenderer.sendSync(CHANNEL_IS_FULL_SCREENABLE);

package/src/electron-browser/style/window-zoom-action-bar.css

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+.window-zoom-action-bar {
+    display: flex;
+    align-items: center;
+    gap: calc(var(--theia-ui-padding) / 3);
+    line-height: 1;
+}
+
+.window-zoom-action-bar .codicon {
+    font-size: inherit;
+}
+
+.window-zoom-display {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 1.5em;
+    padding: calc(var(--theia-ui-padding) / 3);
+    cursor: default;
+    user-select: none;
+}
+
+.window-zoom-button {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: calc(var(--theia-ui-padding) / 3);
+    border-radius: calc(var(--theia-ui-padding) / 2);
+    white-space: nowrap;
+}
+
+.window-zoom-button:hover {
+    background-color: var(--theia-toolbar-hoverBackground);
+}
+
+.window-zoom-button:focus-visible {
+    outline: 1px solid var(--theia-focusBorder);
+}
+
+#status-bar-window-zoom-status {
+    padding-inline: calc(var(--theia-ui-padding) * 2 / 3);
+}

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

@@ -14,14 +14,41 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 import { DefaultSecondaryWindowService } from '../../browser/window/default-secondary-window-service';
 import { ApplicationShell, ExtractableWidget } from '../../browser';
 import { ElectronWindowService } from './electron-window-service';
 import { Deferred, timeout } from '../../common/promise-util';
+import { ElectronWindowPreferences, PREF_WINDOW_ZOOM_LEVEL } from '../../electron-common/electron-window-preferences';
 
 @injectable()
 export class ElectronSecondaryWindowService extends DefaultSecondaryWindowService {
+
+    @inject(ElectronWindowPreferences)
+    protected readonly electronWindowPreferences: ElectronWindowPreferences;
+
+    @postConstruct()
+    override init(): void {
+        super.init();
+        this.electronWindowPreferences.ready.then(() => {
+            const initialZoomLevel = this.electronWindowPreferences.get(PREF_WINDOW_ZOOM_LEVEL);
+            this.updateWindowZoomLevel(initialZoomLevel);
+
+            this.electronWindowPreferences.onPreferenceChanged(e => {
+                if (e.preferenceName === PREF_WINDOW_ZOOM_LEVEL) {
+                    const zoomLevel = this.electronWindowPreferences.get(PREF_WINDOW_ZOOM_LEVEL, 0);
+                    this.updateWindowZoomLevel(zoomLevel);
+                }
+            });
+        });
+    }
+
+    protected async updateWindowZoomLevel(zoomLevel: number): Promise<void> {
+        this.secondaryWindows.forEach((win: Window) => {
+            window.electronTheiaCore.setZoomLevel(zoomLevel, win.name);
+        });
+    }
+
     override focus(win: Window): void {
         window.electronTheiaCore.focusWindow(win.name);
     }
@@ -50,6 +77,10 @@ export class ElectronSecondaryWindowService extends DefaultSecondaryWindowServic
         window.electronTheiaCore.setMenuBarVisible(false, newWindow.name);
         window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(newWindow.name, () => this.canClose(widget, shell, newWindow));
 
+        // Apply current zoom level to newly created secondary window
+        const currentZoomLevel = this.electronWindowPreferences.get(PREF_WINDOW_ZOOM_LEVEL, 0);
+        window.electronTheiaCore.setZoomLevel(currentZoomLevel, newWindow.name);
+
         // Below code may be used to debug contents of secondary window
         // window.electronTheiaCore.openDevToolsForWindow(newWindow.name);
     }

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

@@ -32,6 +32,8 @@ import { ExternalAppOpenHandler } from './external-app-open-handler';
 import { ElectronUriHandlerContribution } from '../electron-uri-handler';
 import { bindRootContributionProvider } from '../../common';
 import { WindowTitleContribution } from '../../browser/window/window-title-service';
+import { WindowZoomStatusBarItem } from './window-zoom-status-bar-item';
+import '../../../src/electron-browser/style/window-zoom-action-bar.css';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ElectronMainWindowService).toDynamicValue(context =>
@@ -48,4 +50,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ExternalAppOpenHandler).toSelf().inSingletonScope();
     bind(OpenHandler).toService(ExternalAppOpenHandler);
     bindRootContributionProvider(bind, WindowTitleContribution);
+    bind(WindowZoomStatusBarItem).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(WindowZoomStatusBarItem);
 });

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

@@ -15,10 +15,10 @@
 // *****************************************************************************
 
 import { injectable, inject, postConstruct } from 'inversify';
-import { NewWindowOptions, WindowSearchParams } from '../../common/window';
+import { NewWindowOptions } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
-import { ElectronWindowPreferences } from '../../electron-common/electron-window-preferences';
+import { ElectronWindowPreferences, PREF_WINDOW_ZOOM_LEVEL } from '../../electron-common/electron-window-preferences';
 import { ConnectionCloseService } from '../../common/messaging/connection-management';
 import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
 import { WindowReloadOptions } from '../../browser/window/window-service';
@@ -57,8 +57,12 @@ export class ElectronWindowService extends DefaultWindowService {
         return undefined;
     }
 
-    override openNewDefaultWindow(params?: WindowSearchParams): void {
-        this.delegate.openNewDefaultWindow(params);
+    override async openNewDefaultWindow(params?: WindowReloadOptions): Promise<number> {
+        return this.delegate.openNewDefaultWindow(params?.search);
+    }
+
+    override closeWindow(windowId: number): void {
+        this.delegate.closeWindow(windowId);
     }
 
     override focus(): void {
@@ -68,7 +72,7 @@ export class ElectronWindowService extends DefaultWindowService {
     protected init(): void {
         // Update the default zoom level on startup when the preferences event is fired.
         this.electronWindowPreferences.onPreferenceChanged(e => {
-            if (e.preferenceName === 'window.zoomLevel') {
+            if (e.preferenceName === PREF_WINDOW_ZOOM_LEVEL) {
                 this.updateWindowZoomLevel();
             }
         });
@@ -94,7 +98,7 @@ export class ElectronWindowService extends DefaultWindowService {
      * Updates the window zoom level based on the preference value.
      */
     protected async updateWindowZoomLevel(): Promise<void> {
-        const preferredZoomLevel = this.electronWindowPreferences['window.zoomLevel'];
+        const preferredZoomLevel = this.electronWindowPreferences[PREF_WINDOW_ZOOM_LEVEL];
         if (await window.electronTheiaCore.getZoomLevel() !== preferredZoomLevel) {
             window.electronTheiaCore.setZoomLevel(preferredZoomLevel);
         }
@@ -116,4 +120,3 @@ export class ElectronWindowService extends DefaultWindowService {
         }
     }
 }
-