@theia/core 1.42.1 → 1.43.0

package/src/common/index.ts

@@ -47,3 +47,4 @@ export * from './telemetry';
 export * from './types';
 export { default as URI } from './uri';
 export * from './view-column';
+export * from './version';

package/src/common/{keytar-protocol.ts → key-store.ts}

@@ -14,10 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-export const keytarServicePath = '/services/keytar';
+export const keyStoreServicePath = '/services/keyStore';
 
-export const KeytarService = Symbol('KeytarService');
-export interface KeytarService {
+export const KeyStoreService = Symbol('KeyStoreService');
+export interface KeyStoreService {
     setPassword(service: string, account: string, password: string): Promise<void>;
     getPassword(service: string, account: string): Promise<string | undefined>;
     deletePassword(service: string, account: string): Promise<boolean>;

package/src/common/keybinding.ts

@@ -107,6 +107,32 @@ export namespace Keybinding {
     export function is(arg: unknown): arg is Keybinding {
         return isObject(arg) && 'command' in arg && 'keybinding' in arg;
     }
+
+    export function replaceKeybinding(keybindings: Keybinding[], oldKeybinding: Keybinding, newKeybinding: Keybinding): boolean {
+        const indexOld = keybindings.findIndex(keybinding => Keybinding.equals(keybinding, oldKeybinding, false, true));
+        if (indexOld >= 0) {
+            const indexNew = keybindings.findIndex(keybinding => Keybinding.equals(keybinding, newKeybinding, false, true));
+            if (indexNew >= 0 && indexNew !== indexOld) {
+                // if keybindings already contain the new keybinding, remove the old keybinding and update the new one
+                keybindings.splice(indexOld, 1);
+                keybindings[indexNew] = newKeybinding;
+            } else {
+                keybindings[indexOld] = newKeybinding;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    export function addKeybinding(keybindings: Keybinding[], newKeybinding: Keybinding): void {
+        const index = keybindings.findIndex(keybinding => Keybinding.equals(keybinding, newKeybinding, false, true));
+        if (index >= 0) {
+            // if keybindings already contain the new keybinding, update it
+            keybindings[index] = newKeybinding;
+        } else {
+            keybindings.push(newKeybinding);
+        }
+    }
 }
 
 /**

package/src/common/markdown-rendering/markdown-string.ts

@@ -123,3 +123,27 @@ export function escapeMarkdownSyntaxTokens(text: string): string {
     // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
     return text.replace(/[\\`*_{}[\]()#+\-!]/g, '\\$&');
 }
+
+// Copied from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/base/common/htmlContent.ts
+
+export function parseHrefAndDimensions(href: string): { href: string; dimensions: string[] } {
+    const dimensions: string[] = [];
+    const splitted = href.split('|').map(s => s.trim());
+    href = splitted[0];
+    const parameters = splitted[1];
+    if (parameters) {
+        const heightFromParams = /height=(\d+)/.exec(parameters);
+        const widthFromParams = /width=(\d+)/.exec(parameters);
+        const height = heightFromParams ? heightFromParams[1] : '';
+        const width = widthFromParams ? widthFromParams[1] : '';
+        const widthIsFinite = isFinite(parseInt(width));
+        const heightIsFinite = isFinite(parseInt(height));
+        if (widthIsFinite) {
+            dimensions.push(`width="${width}"`);
+        }
+        if (heightIsFinite) {
+            dimensions.push(`height="${height}"`);
+        }
+    }
+    return { href, dimensions };
+}

package/src/common/menu/menu-types.ts

@@ -19,7 +19,7 @@ import { isObject } from '../types';
 
 export type MenuPath = string[];
 export const MAIN_MENU_BAR: MenuPath = ['menubar'];
-export const SETTINGS_MENU: MenuPath = ['settings_menu'];
+export const MANAGE_MENU: MenuPath = ['manage_menu'];
 export const ACCOUNTS_MENU: MenuPath = ['accounts_menu'];
 export const ACCOUNTS_SUBMENU = [...ACCOUNTS_MENU, '1_accounts_submenu'];
 

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

@@ -134,16 +134,12 @@ export class RpcProtocol {
     }
 
     protected handleReplyErr(id: number, error: any): void {
-        try {
-            const replyHandler = this.pendingRequests.get(id);
-            if (replyHandler) {
-                this.pendingRequests.delete(id);
-                replyHandler.reject(error);
-            } else {
-                throw new Error(`No reply handler for error reply with id: ${id}`);
-            }
-        } catch (err) {
-            throw err;
+        const replyHandler = this.pendingRequests.get(id);
+        if (replyHandler) {
+            this.pendingRequests.delete(id);
+            replyHandler.reject(error);
+        } else {
+            throw new Error(`No reply handler for error reply with id: ${id}`);
         }
     }
 

package/src/common/objects.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { isObject, isUndefined } from './types';
+import { isObject, isUndefined, isUndefinedOrNull } from './types';
 
 export function deepClone<T>(obj: T): T {
     if (!isObject(obj)) {
@@ -71,17 +71,21 @@ export function isEmpty(arg: Object): boolean {
     return Object.keys(arg).length === 0 && arg.constructor === Object;
 }
 
-// copied and modified from https://github.com/microsoft/vscode/blob/1.76.0/src/vs/base/common/objects.ts#L45-L83
 /*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *  Copyright (c) Microsoft Corporation and others. All rights reserved.
+ *  Licensed under the MIT License. See https://github.com/Microsoft/vscode/blob/master/LICENSE.txt for license information.
  *--------------------------------------------------------------------------------------------*/
 
+// Copied from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/base/common/objects.ts
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function cloneAndChange(obj: any, changer: (orig: any) => any, seen: Set<any>): any {
-    // impossible to clone an undefined or null object
-    // eslint-disable-next-line no-null/no-null
-    if (isUndefined(obj) || obj === null) {
+export function cloneAndChange(obj: any, changer: (orig: any) => any): any {
+    return _cloneAndChange(obj, changer, new Set());
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _cloneAndChange(obj: any, changer: (orig: any) => any, seen: Set<any>): any {
+    if (isUndefinedOrNull(obj)) {
         return obj;
     }
 
@@ -94,7 +98,7 @@ export function cloneAndChange(obj: any, changer: (orig: any) => any, seen: Set<
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const r1: any[] = [];
         for (const e of obj) {
-            r1.push(cloneAndChange(e, changer, seen));
+            r1.push(_cloneAndChange(e, changer, seen));
         }
         return r1;
     }
@@ -108,7 +112,7 @@ export function cloneAndChange(obj: any, changer: (orig: any) => any, seen: Set<
         for (const i2 in obj) {
             if (_hasOwnProperty.call(obj, i2)) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                (r2 as any)[i2] = cloneAndChange(obj[i2], changer, seen);
+                (r2 as any)[i2] = _cloneAndChange(obj[i2], changer, seen);
             }
         }
         seen.delete(obj);

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

@@ -272,6 +272,7 @@ export interface QuickPickOptions<T extends QuickPickItemOrSeparator> {
     onDidTriggerItemButton?: (ItemButtonEvent: QuickPickItemButtonContext<T>) => void
 }
 
+export const quickInputServicePath = '/services/quickInput';
 export const QuickInputService = Symbol('QuickInputService');
 export interface QuickInputService {
     readonly backButton: QuickInputButton;

package/src/common/strings.ts

@@ -218,3 +218,14 @@ export function compareSubstringIgnoreCase(a: string, b: string, aStart: number
 
     return 0;
 }
+
+// Copied from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/base/common/strings.ts
+
+export function regExpFlags(regexp: RegExp): string {
+    return (regexp.global ? 'g' : '')
+        + (regexp.ignoreCase ? 'i' : '')
+        + (regexp.multiline ? 'm' : '')
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        + ((regexp as any /* standalone editor compilation */).unicode ? 'u' : '');
+}
+

package/src/common/types.ts

@@ -116,3 +116,25 @@ export function nullToUndefined<T>(nullable: MaybeNull<T>): MaybeUndefined<T> {
 export function unreachable(_never: never, message: string = 'unhandled case'): never {
     throw new Error(message);
 }
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation and others. All rights reserved.
+ *  Licensed under the MIT License. See https://github.com/Microsoft/vscode/blob/master/LICENSE.txt for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// Copied from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/base/common/types.ts
+
+/**
+ * @returns whether the provided parameter is defined.
+ */
+export function isDefined<T>(arg: T | null | undefined): arg is T {
+    return !isUndefinedOrNull(arg);
+}
+
+/**
+ * @returns whether the provided parameter is undefined or null.
+ */
+export function isUndefinedOrNull(obj: unknown): obj is undefined | null {
+    // eslint-disable-next-line no-null/no-null
+    return (isUndefined(obj) || obj === null);
+}

package/src/common/uri.ts

@@ -27,10 +27,6 @@ export class URI {
         return new URI(Uri.file(path));
     }
 
-    public static isUri(uri: unknown): boolean {
-        return Uri.isUri(uri);
-    }
-
     private readonly codeUri: Uri;
     private _path: Path | undefined;
 

package/src/common/uuid.ts

@@ -0,0 +1,99 @@
+// *****************************************************************************
+// Copyright (C) 2023 Mathieu Bussieres 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
+// *****************************************************************************
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation and others. All rights reserved.
+ *  Licensed under the MIT License. See https://github.com/Microsoft/vscode/blob/master/LICENSE.txt for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// based on https://github.com/microsoft/vscode/blob/1.72.2/src/vs/base/common/uuid.ts
+
+const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export function isUUID(value: string): boolean {
+    return _UUIDPattern.test(value);
+}
+
+declare const crypto: undefined | {
+    // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#browser_compatibility
+    getRandomValues?(data: Uint8Array): Uint8Array;
+    // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID#browser_compatibility
+    randomUUID?(): string;
+};
+
+export const generateUuid = (function (): () => string {
+
+    // use `randomUUID` if possible
+    if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID.bind(crypto);
+    }
+
+    // use `randomValues` if possible
+    let getRandomValues: (bucket: Uint8Array) => Uint8Array;
+    if (typeof crypto === 'object' && typeof crypto.getRandomValues === 'function') {
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+
+    } else {
+        getRandomValues = function (bucket: Uint8Array): Uint8Array {
+            for (let i = 0; i < bucket.length; i++) {
+                bucket[i] = Math.floor(Math.random() * 256);
+            }
+            return bucket;
+        };
+    }
+
+    // prep-work
+    const _data = new Uint8Array(16);
+    const _hex: string[] = [];
+    for (let i = 0; i < 256; i++) {
+        _hex.push(i.toString(16).padStart(2, '0'));
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    return function generateUuid(): string {
+        // get data
+        getRandomValues(_data);
+
+        // set version bits
+        _data[6] = (_data[6] & 0x0f) | 0x40;
+        _data[8] = (_data[8] & 0x3f) | 0x80;
+
+        // print as string
+        let i = 0;
+        let result = '';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        return result;
+    };
+})();

package/src/common/version.ts

@@ -0,0 +1,17 @@
+// *****************************************************************************
+// Copyright (C) 2017 TypeFox 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
+// *****************************************************************************
+
+export const THEIA_VERSION: string = require('../../package.json').version;

package/src/common/window.ts

@@ -28,3 +28,7 @@ export interface NewWindowOptions {
      */
     readonly external?: boolean;
 }
+
+export interface WindowSearchParams {
+    [key: string]: string
+}

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

@@ -21,7 +21,7 @@ import { ElectronKeyboardLayoutChangeNotifier } from './electron-keyboard-layout
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(KeyboardLayoutProvider).toDynamicValue(ctx =>
-        WebSocketConnectionProvider.createProxy<KeyboardLayoutProvider>(ctx.container, keyboardPath)
+        WebSocketConnectionProvider.createLocalProxy<KeyboardLayoutProvider>(ctx.container, keyboardPath)
     ).inSingletonScope();
     bind(ElectronKeyboardLayoutChangeNotifier).toSelf().inSingletonScope();
     bind(KeyboardLayoutChangeNotifier).toService(ElectronKeyboardLayoutChangeNotifier);

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

@@ -0,0 +1,45 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox 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 { injectable } from 'inversify';
+import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
+import { Endpoint } from '../../browser/endpoint';
+
+export function getLocalPort(): string | undefined {
+    const params = new URLSearchParams(location.search);
+    return params.get('localPort') ?? undefined;
+}
+
+@injectable()
+export class ElectronLocalWebSocketConnectionProvider extends WebSocketConnectionProvider {
+
+    protected override createEndpoint(path: string): Endpoint {
+        const localPort = getLocalPort();
+        if (!localPort) {
+            throw new Error('This should only be called in case there is a local port specified!');
+        }
+        const endpoint = new Endpoint({
+            path
+        }, {
+            host: `localhost:${localPort}`,
+            pathname: '/',
+            protocol: 'http',
+            search: ''
+        });
+        return endpoint;
+    }
+
+}

package/src/electron-browser/messaging/electron-messaging-frontend-module.ts

@@ -15,14 +15,27 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
-import { FrontendApplicationContribution } from '../../browser/frontend-application';
-import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
+import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
+import { LocalWebSocketConnectionProvider, WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
 import { ElectronWebSocketConnectionProvider } from './electron-ws-connection-provider';
 import { ElectronIpcConnectionProvider } from './electron-ipc-connection-provider';
+import { ElectronLocalWebSocketConnectionProvider, getLocalPort } from './electron-local-ws-connection-provider';
 
 export const messagingFrontendModule = new ContainerModule(bind => {
     bind(ElectronWebSocketConnectionProvider).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(ElectronWebSocketConnectionProvider);
     bind(WebSocketConnectionProvider).toService(ElectronWebSocketConnectionProvider);
+    bind(ElectronLocalWebSocketConnectionProvider).toSelf().inSingletonScope();
+    bind(LocalWebSocketConnectionProvider).toDynamicValue(ctx => {
+        const localPort = getLocalPort();
+        if (localPort) {
+            // Return new web socket provider that connects to local app
+            return ctx.container.get(ElectronLocalWebSocketConnectionProvider);
+        } else {
+            // Return the usual web socket provider that already established its connection
+            // That way we don't create a second socket connection
+            return ctx.container.get(WebSocketConnectionProvider);
+        }
+    }).inSingletonScope();
     bind(ElectronIpcConnectionProvider).toSelf().inSingletonScope();
 });

package/src/electron-browser/messaging/electron-ws-connection-provider.ts

@@ -16,7 +16,7 @@
 
 import { injectable } from 'inversify';
 import { WebSocketConnectionProvider, WebSocketOptions } from '../../browser/messaging/ws-connection-provider';
-import { FrontendApplicationContribution } from '../../browser/frontend-application';
+import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
 import { Channel } from '../../common';
 
 /**

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

@@ -17,7 +17,7 @@
 import { ContainerModule } from 'inversify';
 import { WindowService } from '../../browser/window/window-service';
 import { ElectronWindowService } from './electron-window-service';
-import { FrontendApplicationContribution } from '../../browser/frontend-application';
+import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
 import { ElectronClipboardService } from '../electron-clipboard-service';
 import { ClipboardService } from '../../browser/clipboard-service';
 import { ElectronMainWindowService, electronMainWindowServicePath } from '../../electron-common/electron-main-window-service';

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

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { injectable, inject, postConstruct } from 'inversify';
-import { NewWindowOptions } from '../../common/window';
+import { NewWindowOptions, WindowSearchParams } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
 import { ElectronWindowPreferences } from './electron-window-preferences';
@@ -44,8 +44,8 @@ export class ElectronWindowService extends DefaultWindowService {
         return undefined;
     }
 
-    override openNewDefaultWindow(): void {
-        this.delegate.openNewDefaultWindow();
+    override openNewDefaultWindow(params?: WindowSearchParams): void {
+        this.delegate.openNewDefaultWindow(params);
     }
 
     @postConstruct()
@@ -75,7 +75,12 @@ export class ElectronWindowService extends DefaultWindowService {
         }
     }
 
-    override reload(): void {
-        window.electronTheiaCore.requestReload();
+    override reload(params?: WindowSearchParams): void {
+        if (params) {
+            const query = Object.entries(params).map(([name, value]) => `${name}=${value}`).join('&');
+            location.search = query;
+        } else {
+            window.electronTheiaCore.requestReload();
+        }
     }
 }

package/src/electron-common/electron-main-window-service.ts

@@ -14,11 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { NewWindowOptions } from '../common/window';
+import { NewWindowOptions, WindowSearchParams } from '../common/window';
 
 export const electronMainWindowServicePath = '/services/electron-window';
 export const ElectronMainWindowService = Symbol('ElectronMainWindowService');
 export interface ElectronMainWindowService {
     openNewWindow(url: string, options?: NewWindowOptions): undefined;
-    openNewDefaultWindow(): void;
+    openNewDefaultWindow(params?: WindowSearchParams): void;
 }

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

@@ -31,7 +31,7 @@ import { ElectronSecurityTokenService } from './electron-security-token-service'
 import { ElectronSecurityToken } from '../electron-common/electron-token';
 import Storage = require('electron-store');
 import { Disposable, DisposableCollection, isOSX, isWindows } from '../common';
-import { DEFAULT_WINDOW_HASH } from '../common/window';
+import { DEFAULT_WINDOW_HASH, WindowSearchParams } from '../common/window';
 import { TheiaBrowserWindowOptions, TheiaElectronWindow, TheiaElectronWindowFactory } from './theia-electron-window';
 import { ElectronMainApplicationGlobals } from './electron-main-constants';
 import { createDisposableListener } from './event-utils';
@@ -343,9 +343,9 @@ export class ElectronMainApplication {
         };
     }
 
-    async openDefaultWindow(): Promise<BrowserWindow> {
+    async openDefaultWindow(params?: WindowSearchParams): Promise<BrowserWindow> {
         const options = this.getDefaultTheiaWindowOptions();
-        const [uri, electronWindow] = await Promise.all([this.createWindowUri(), this.reuseOrCreateWindow(options)]);
+        const [uri, electronWindow] = await Promise.all([this.createWindowUri(params), this.reuseOrCreateWindow(options)]);
         electronWindow.loadURL(uri.withFragment(DEFAULT_WINDOW_HASH).toString(true));
         return electronWindow;
     }
@@ -419,9 +419,13 @@ export class ElectronMainApplication {
         }
     }
 
-    protected async createWindowUri(): Promise<URI> {
+    protected async createWindowUri(params: WindowSearchParams = {}): Promise<URI> {
+        if (!('port' in params)) {
+            params.port = (await this.backendPort).toString();
+        }
+        const query = Object.entries(params).map(([name, value]) => `${name}=${value}`).join('&');
         return FileUri.create(this.globals.THEIA_FRONTEND_HTML_PATH)
-            .withQuery(`port=${await this.backendPort}`);
+            .withQuery(query);
     }
 
     protected getDefaultTheiaWindowOptions(): TheiaBrowserWindowOptions {

package/src/electron-main/electron-main-window-service-impl.ts

@@ -18,7 +18,7 @@ import { shell } from '@theia/electron/shared/electron';
 import { injectable, inject } from 'inversify';
 import { ElectronMainWindowService } from '../electron-common/electron-main-window-service';
 import { ElectronMainApplication } from './electron-main-application';
-import { NewWindowOptions } from '../common/window';
+import { NewWindowOptions, WindowSearchParams } from '../common/window';
 
 @injectable()
 export class ElectronMainWindowServiceImpl implements ElectronMainWindowService {
@@ -37,8 +37,8 @@ export class ElectronMainWindowServiceImpl implements ElectronMainWindowService
         return undefined;
     }
 
-    openNewDefaultWindow(): void {
-        this.app.openDefaultWindow();
+    openNewDefaultWindow(params?: WindowSearchParams): void {
+        this.app.openDefaultWindow(params);
     }
 
 }

package/src/electron-node/hosting/electron-ws-origin-validator.ts

@@ -15,13 +15,21 @@
 // *****************************************************************************
 
 import * as http from 'http';
-import { injectable } from 'inversify';
+import { inject, injectable } from 'inversify';
+import { BackendRemoteService } from '../../node/backend-remote-service';
 import { WsRequestValidatorContribution } from '../../node/ws-request-validators';
 
 @injectable()
 export class ElectronWsOriginValidator implements WsRequestValidatorContribution {
 
+    @inject(BackendRemoteService)
+    protected readonly backendRemoteService: BackendRemoteService;
+
     allowWsUpgrade(request: http.IncomingMessage): boolean {
+        // If we are running as a remote server, requests will come from an http endpoint
+        if (this.backendRemoteService.isRemoteServer()) {
+            return true;
+        }
         // On Electron the main page is served from the `file` protocol.
         // We don't expect the requests to come from anywhere else.
         return request.headers.origin === 'file://';

package/src/electron-node/token/electron-token-validator.ts

@@ -28,7 +28,7 @@ import { WsRequestValidatorContribution } from '../../node/ws-request-validators
 @injectable()
 export class ElectronTokenValidator implements WsRequestValidatorContribution {
 
-    protected electronSecurityToken: ElectronSecurityToken;
+    protected electronSecurityToken?: ElectronSecurityToken;
 
     @postConstruct()
     protected init(): void {
@@ -43,6 +43,9 @@ export class ElectronTokenValidator implements WsRequestValidatorContribution {
      * Expects the token to be passed via cookies by default.
      */
     allowRequest(request: http.IncomingMessage): boolean {
+        if (!this.electronSecurityToken) {
+            return true;
+        }
         const cookieHeader = request.headers.cookie;
         if (isString(cookieHeader)) {
             const token = cookie.parse(cookieHeader)[ElectronSecurityToken];
@@ -76,8 +79,15 @@ export class ElectronTokenValidator implements WsRequestValidatorContribution {
     /**
      * Returns the token to compare to when authorizing requests.
      */
-    protected getToken(): ElectronSecurityToken {
-        return JSON.parse(process.env[ElectronSecurityToken]!);
+    protected getToken(): ElectronSecurityToken | undefined {
+        const token = process.env[ElectronSecurityToken];
+        if (token) {
+            return JSON.parse(token);
+        } else {
+            // No token has been passed to the backend server
+            // That indicates we're running without a local frontend
+            return undefined;
+        }
     }
 
 }