@theia/core 1.48.2 → 1.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theia/core",
-  "version": "1.48.2",
+  "version": "1.49.0",
   "description": "Theia is a cloud & desktop IDE framework implemented in TypeScript.",
   "main": "lib/common/index.js",
   "typings": "lib/common/index.d.ts",
@@ -16,8 +16,8 @@
     "@phosphor/signaling": "1",
     "@phosphor/virtualdom": "1",
     "@phosphor/widgets": "1",
-    "@theia/application-package": "1.48.2",
-    "@theia/request": "1.48.2",
+    "@theia/application-package": "1.49.0",
+    "@theia/request": "1.49.0",
     "@types/body-parser": "^1.16.4",
     "@types/cookie": "^0.3.3",
     "@types/dompurify": "^2.2.2",
@@ -206,12 +206,12 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.48.2",
-    "@theia/re-exports": "1.48.2",
+    "@theia/ext-scripts": "1.49.0",
+    "@theia/re-exports": "1.49.0",
     "minimist": "^1.2.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "0e9583d043dde303de7a0f86f68439659f8827b0"
+  "gitHead": "d413dadd87a70fce1c80df7eb22d9d2529cc129f"
 }

package/src/browser/command-open-handler.ts

@@ -41,7 +41,7 @@ export class CommandOpenHandler implements OpenHandler {
             try {
                 args = JSON.parse(uri.query);
             } catch {
-                // ignore error
+                args = uri.query;
             }
         }
         if (!Array.isArray(args)) {

package/src/browser/frontend-application-module.ts

@@ -140,6 +140,7 @@ import { HoverService } from './hover-service';
 import { AdditionalViewsMenuWidget, AdditionalViewsMenuWidgetFactory } from './shell/additional-views-menu-widget';
 import { LanguageIconLabelProvider } from './language-icon-provider';
 import { bindTreePreferences } from './tree';
+import { OpenWithService } from './open-with-service';
 
 export { bindResourceProvider, bindMessageService, bindPreferenceService };
 
@@ -224,6 +225,8 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
     bind(CommandOpenHandler).toSelf().inSingletonScope();
     bind(OpenHandler).toService(CommandOpenHandler);
 
+    bind(OpenWithService).toSelf().inSingletonScope();
+
     bind(TooltipServiceImpl).toSelf().inSingletonScope();
     bind(TooltipService).toService(TooltipServiceImpl);
 

package/src/browser/index.ts

@@ -19,6 +19,7 @@ export * from './frontend-application';
 export * from './frontend-application-contribution';
 export * from './keyboard';
 export * from './opener-service';
+export * from './open-with-service';
 export * from './browser';
 export * from './context-menu-renderer';
 export * from './widgets';

package/src/browser/keybinding.ts

@@ -497,7 +497,7 @@ export class KeybindingRegistry {
 
     isEnabledInScope(binding: common.Keybinding, target: HTMLElement | undefined): boolean {
         const context = binding.context && this.contexts[binding.context];
-        if (binding.command && !this.commandRegistry.isEnabled(binding.command, binding.args)) {
+        if (binding.command && (!this.isPseudoCommand(binding.command) && !this.commandRegistry.isEnabled(binding.command, binding.args))) {
             return false;
         }
         if (context && !context.isEnabled(binding)) {

package/src/browser/open-with-service.ts

@@ -0,0 +1,93 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { inject, injectable } from 'inversify';
+import { Disposable } from '../common/disposable';
+import { nls } from '../common/nls';
+import { MaybePromise } from '../common/types';
+import { URI } from '../common/uri';
+import { QuickInputService } from './quick-input';
+
+export interface OpenWithHandler {
+    /**
+     * A unique id of this handler.
+     */
+    readonly id: string;
+    /**
+     * A human-readable name of this handler.
+     */
+    readonly label?: string;
+    /**
+     * A human-readable provider name of this handler.
+     */
+    readonly providerName?: string;
+    /**
+     * A css icon class of this handler.
+     */
+    readonly iconClass?: string;
+    /**
+     * Test whether this handler can open the given URI for given options.
+     * Return a nonzero number if this handler can open; otherwise it cannot.
+     * Never reject.
+     *
+     * A returned value indicating a priority of this handler.
+     */
+    canHandle(uri: URI): number;
+    /**
+     * Open a widget for the given URI and options.
+     * Resolve to an opened widget or undefined, e.g. if a page is opened.
+     * Never reject if `canHandle` return a positive number; otherwise should reject.
+     */
+    open(uri: URI): MaybePromise<object | undefined>;
+}
+
+@injectable()
+export class OpenWithService {
+
+    @inject(QuickInputService)
+    protected readonly quickInputService: QuickInputService;
+
+    protected readonly handlers: OpenWithHandler[] = [];
+
+    registerHandler(handler: OpenWithHandler): Disposable {
+        this.handlers.push(handler);
+        return Disposable.create(() => {
+            const index = this.handlers.indexOf(handler);
+            if (index !== -1) {
+                this.handlers.splice(index, 1);
+            }
+        });
+    }
+
+    async openWith(uri: URI): Promise<object | undefined> {
+        const handlers = this.getHandlers(uri);
+        const result = await this.quickInputService.pick(handlers.map(handler => ({
+            handler: handler,
+            label: handler.label ?? handler.id,
+            detail: handler.providerName
+        })), {
+            placeHolder: nls.localizeByDefault("Select editor for '{0}'", uri.path.base)
+        });
+        if (result) {
+            return result.handler.open(uri);
+        }
+    }
+
+    getHandlers(uri: URI): OpenWithHandler[] {
+        const map = new Map<OpenWithHandler, number>(this.handlers.map(handler => [handler, handler.canHandle(uri)]));
+        return this.handlers.filter(handler => map.get(handler)! > 0).sort((a, b) => map.get(b)! - map.get(a)!);
+    }
+}

package/src/browser/shell/view-contribution.ts

@@ -18,7 +18,7 @@ import { injectable, inject, interfaces, optional } from 'inversify';
 import { Widget } from '@phosphor/widgets';
 import {
     MenuModelRegistry, Command, CommandContribution,
-    MenuContribution, CommandRegistry
+    MenuContribution, CommandRegistry, nls
 } from '../../common';
 import { KeybindingContribution, KeybindingRegistry } from '../keybinding';
 import { WidgetManager } from '../widget-manager';
@@ -69,7 +69,8 @@ export abstract class AbstractViewContribution<T extends Widget> implements Comm
         if (options.toggleCommandId) {
             this.toggleCommand = {
                 id: options.toggleCommandId,
-                label: 'Toggle ' + this.viewLabel + ' View'
+                category: nls.localizeByDefault('View'),
+                label: nls.localizeByDefault('Toggle {0}', this.viewLabel)
             };
         }
     }

package/src/common/command.ts

@@ -41,6 +41,10 @@ export interface Command {
      * An icon class of this command.
      */
     iconClass?: string;
+    /**
+     * A short title used for display in menus.
+     */
+    shortTitle?: string;
     /**
      * A category of this command.
      */

package/src/common/event.ts

@@ -467,3 +467,21 @@ export class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
     }
 
 }
+
+export class QueueableEmitter<T> extends Emitter<T[]> {
+
+    currentQueue?: T[];
+
+    queue(...arg: T[]): void {
+        if (!this.currentQueue) {
+            this.currentQueue = [];
+        }
+        this.currentQueue.push(...arg);
+    }
+
+    override fire(): void {
+        super.fire(this.currentQueue || []);
+        this.currentQueue = undefined;
+    }
+
+}

package/src/electron-browser/preload.ts

@@ -26,7 +26,7 @@ import {
     CHANNEL_IS_FULL_SCREEN, CHANNEL_SET_MENU_BAR_VISIBLE, CHANNEL_REQUEST_CLOSE, CHANNEL_SET_TITLE_STYLE, CHANNEL_RESTART,
     CHANNEL_REQUEST_RELOAD, CHANNEL_APP_STATE_CHANGED, CHANNEL_SHOW_ITEM_IN_FOLDER, CHANNEL_READ_CLIPBOARD, CHANNEL_WRITE_CLIPBOARD,
     CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto, CHANNEL_REQUEST_SECONDARY_CLOSE, CHANNEL_SET_BACKGROUND_COLOR,
-    CHANNEL_WC_METADATA, CHANNEL_ABOUT_TO_CLOSE
+    CHANNEL_WC_METADATA, CHANNEL_ABOUT_TO_CLOSE, CHANNEL_OPEN_WITH_SYSTEM_APP
 } from '../electron-common/electron-api';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -75,10 +75,13 @@ const api: TheiaCoreAPI = {
         ipcRenderer.send(CHANNEL_SET_MENU, mainMenuId, convertMenu(menu, handlers));
     },
     getSecurityToken: () => ipcRenderer.sendSync(CHANNEL_GET_SECURITY_TOKEN),
-    focusWindow: (name: string) => ipcRenderer.send(CHANNEL_FOCUS_WINDOW, name),
+    focusWindow: (name?: string) => ipcRenderer.send(CHANNEL_FOCUS_WINDOW, name),
     showItemInFolder: fsPath => {
         ipcRenderer.send(CHANNEL_SHOW_ITEM_IN_FOLDER, fsPath);
     },
+    openWithSystemApp: fsPath => {
+        ipcRenderer.send(CHANNEL_OPEN_WITH_SYSTEM_APP, fsPath);
+    },
     attachSecurityToken: (endpoint: string) => ipcRenderer.invoke(CHANNEL_ATTACH_SECURITY_TOKEN, endpoint),
 
     popup: async function (menu: MenuDto[], x: number, y: number, onClosed: () => void, windowName?: string): Promise<number> {

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

@@ -58,7 +58,7 @@ export class ElectronWindowService extends DefaultWindowService {
     }
 
     override focus(): void {
-        window.electronTheiaCore.focusWindow(window.name);
+        window.electronTheiaCore.focusWindow();
     }
     @postConstruct()
     protected init(): void {

package/src/electron-common/electron-api.ts

@@ -53,9 +53,10 @@ export interface TheiaCoreAPI {
     popup(menu: MenuDto[], x: number, y: number, onClosed: () => void, windowName?: string): Promise<number>;
     closePopup(handle: number): void;
 
-    focusWindow(name: string): void;
+    focusWindow(name?: string): void;
 
     showItemInFolder(fsPath: string): void;
+    openWithSystemApp(fsPath: string): void;
 
     getTitleBarStyleAtStartup(): Promise<string>;
     setTitleBarStyle(style: string): void;
@@ -112,6 +113,7 @@ export const CHANNEL_FOCUS_WINDOW = 'FocusWindow';
 export const CHANNEL_SHOW_OPEN = 'ShowOpenDialog';
 export const CHANNEL_SHOW_SAVE = 'ShowSaveDialog';
 export const CHANNEL_SHOW_ITEM_IN_FOLDER = 'ShowItemInFolder';
+export const CHANNEL_OPEN_WITH_SYSTEM_APP = 'OpenWithSystemApp';
 export const CHANNEL_ATTACH_SECURITY_TOKEN = 'AttachSecurityToken';
 
 export const CHANNEL_GET_TITLE_STYLE_AT_STARTUP = 'GetTitleStyleAtStartup';

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

@@ -53,7 +53,8 @@ import {
     CHANNEL_REQUEST_SECONDARY_CLOSE,
     CHANNEL_SET_BACKGROUND_COLOR,
     CHANNEL_WC_METADATA,
-    CHANNEL_ABOUT_TO_CLOSE
+    CHANNEL_ABOUT_TO_CLOSE,
+    CHANNEL_OPEN_WITH_SYSTEM_APP
 } from '../electron-common/electron-api';
 import { ElectronMainApplication, ElectronMainApplicationContribution } from './electron-main-application';
 import { Disposable, DisposableCollection, isOSX, MaybePromise } from '../common';
@@ -147,7 +148,9 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
 
         // focus windows for secondary window support
         ipcMain.on(CHANNEL_FOCUS_WINDOW, (event, windowName) => {
-            const electronWindow = BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName);
+            const electronWindow = windowName
+                ? BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName)
+                : BrowserWindow.fromWebContents(event.sender);
             if (electronWindow) {
                 if (electronWindow.isMinimized()) {
                     electronWindow.restore();
@@ -162,6 +165,10 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
             shell.showItemInFolder(fsPath);
         });
 
+        ipcMain.on(CHANNEL_OPEN_WITH_SYSTEM_APP, (event, fsPath) => {
+            shell.openPath(fsPath);
+        });
+
         ipcMain.handle(CHANNEL_GET_TITLE_STYLE_AT_STARTUP, event => application.getTitleBarStyleAtStartup(event.sender));
 
         ipcMain.on(CHANNEL_SET_TITLE_STYLE, (event, style) => application.setTitleBarStyle(event.sender, style));

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

@@ -22,16 +22,16 @@ import { AddressInfo } from 'net';
 import { promises as fs } from 'fs';
 import { existsSync, mkdirSync } from 'fs-extra';
 import { fork, ForkOptions } from 'child_process';
-import { DefaultTheme, FrontendApplicationConfig } from '@theia/application-package/lib/application-props';
+import { DefaultTheme, ElectronFrontendApplicationConfig, FrontendApplicationConfig } from '@theia/application-package/lib/application-props';
 import URI from '../common/uri';
 import { FileUri } from '../common/file-uri';
-import { Deferred } from '../common/promise-util';
+import { Deferred, timeout } from '../common/promise-util';
 import { MaybePromise } from '../common/types';
 import { ContributionProvider } from '../common/contribution-provider';
 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 { CancellationTokenSource, Disposable, DisposableCollection, isOSX, isWindows } from '../common';
 import { DEFAULT_WINDOW_HASH, WindowSearchParams } from '../common/window';
 import { TheiaBrowserWindowOptions, TheiaElectronWindow, TheiaElectronWindowFactory } from './theia-electron-window';
 import { ElectronMainApplicationGlobals } from './electron-main-constants';
@@ -182,6 +182,7 @@ export class ElectronMainApplication {
     protected windows = new Map<number, TheiaElectronWindow>();
     protected restarting = false;
 
+    /** Used to temporarily store the reference to an early created main window */
     protected initialWindow?: BrowserWindow;
 
     get config(): FrontendApplicationConfig {
@@ -287,18 +288,110 @@ export class ElectronMainApplication {
         return this.didUseNativeWindowFrameOnStart.get(webContents.id) ? 'native' : 'custom';
     }
 
+    protected async determineSplashScreenBounds(initialWindowBounds: { x: number, y: number, width: number, height: number }):
+        Promise<{ x: number, y: number, width: number, height: number }> {
+        const splashScreenOptions = this.getSplashScreenOptions();
+        const width = splashScreenOptions?.width ?? 640;
+        const height = splashScreenOptions?.height ?? 480;
+
+        // determine the screen on which to show the splash screen via the center of the window to show
+        const windowCenterPoint = { x: initialWindowBounds.x + (initialWindowBounds.width / 2), y: initialWindowBounds.y + (initialWindowBounds.height / 2) };
+        const { bounds } = screen.getDisplayNearestPoint(windowCenterPoint);
+
+        // place splash screen center of screen
+        const screenCenterPoint = { x: bounds.x + (bounds.width / 2), y: bounds.y + (bounds.height / 2) };
+        const x = screenCenterPoint.x - (width / 2);
+        const y = screenCenterPoint.y - (height / 2);
+
+        return {
+            x, y, width, height
+        };
+    }
+
+    protected isShowWindowEarly(): boolean {
+        return !!this.config.electron.showWindowEarly &&
+            !('THEIA_ELECTRON_NO_EARLY_WINDOW' in process.env && process.env.THEIA_ELECTRON_NO_EARLY_WINDOW === '1');
+    }
+
     protected showInitialWindow(): void {
-        if (this.config.electron.showWindowEarly &&
-            !('THEIA_ELECTRON_NO_EARLY_WINDOW' in process.env && process.env.THEIA_ELECTRON_NO_EARLY_WINDOW === '1')) {
-            console.log('Showing main window early');
+        if (this.isShowWindowEarly() || this.isShowSplashScreen()) {
             app.whenReady().then(async () => {
                 const options = await this.getLastWindowOptions();
+                // If we want to show a splash screen, don't auto open the main window
+                if (this.isShowSplashScreen()) {
+                    options.preventAutomaticShow = true;
+                }
                 this.initialWindow = await this.createWindow({ ...options });
-                this.initialWindow.show();
+
+                if (this.isShowSplashScreen()) {
+                    console.log('Showing splash screen');
+                    this.configureAndShowSplashScreen(this.initialWindow);
+                }
+
+                // Show main window early if windows shall be shown early and splash screen is not configured
+                if (this.isShowWindowEarly() && !this.isShowSplashScreen()) {
+                    console.log('Showing main window early');
+                    this.initialWindow.show();
+                }
             });
         }
     }
 
+    protected async configureAndShowSplashScreen(mainWindow: BrowserWindow): Promise<BrowserWindow> {
+        const splashScreenOptions = this.getSplashScreenOptions()!;
+        console.debug('SplashScreen options', splashScreenOptions);
+
+        const splashScreenBounds = await this.determineSplashScreenBounds(mainWindow.getBounds());
+        const splashScreenWindow = new BrowserWindow({
+            ...splashScreenBounds,
+            frame: false,
+            alwaysOnTop: true,
+            show: false
+        });
+
+        if (this.isShowWindowEarly()) {
+            console.log('Showing splash screen early');
+            splashScreenWindow.show();
+        } else {
+            splashScreenWindow.on('ready-to-show', () => {
+                splashScreenWindow.show();
+            });
+        }
+
+        splashScreenWindow.loadFile(path.resolve(this.globals.THEIA_APP_PROJECT_PATH, splashScreenOptions.content!).toString());
+
+        // close splash screen and show main window once frontend is ready or a timeout is hit
+        const cancelTokenSource = new CancellationTokenSource();
+        const minTime = timeout(splashScreenOptions.minDuration ?? 0, cancelTokenSource.token);
+        const maxTime = timeout(splashScreenOptions.maxDuration ?? 30000, cancelTokenSource.token);
+
+        const showWindowAndCloseSplashScreen = () => {
+            cancelTokenSource.cancel();
+            if (!mainWindow.isVisible()) {
+                mainWindow.show();
+            }
+            splashScreenWindow.close();
+        };
+        TheiaRendererAPI.onApplicationStateChanged(mainWindow.webContents, state => {
+            if (state === 'ready') {
+                minTime.then(() => showWindowAndCloseSplashScreen());
+            }
+        });
+        maxTime.then(() => showWindowAndCloseSplashScreen());
+        return splashScreenWindow;
+    }
+
+    protected isShowSplashScreen(): boolean {
+        return typeof this.config.electron.splashScreenOptions === 'object' && !!this.config.electron.splashScreenOptions.content;
+    }
+
+    protected getSplashScreenOptions(): ElectronFrontendApplicationConfig.SplashScreenOptions | undefined {
+        if (this.isShowSplashScreen()) {
+            return this.config.electron.splashScreenOptions;
+        }
+        return undefined;
+    }
+
     /**
      * Use this rather than creating `BrowserWindow` instances from scratch, since some security parameters need to be set, this method will do it.
      *
@@ -316,6 +409,7 @@ export class ElectronMainApplication {
         electronWindow.window.on('focus', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'focus'));
         this.attachSaveWindowState(electronWindow.window);
         this.configureNativeSecondaryWindowCreation(electronWindow.window);
+
         return electronWindow.window;
     }
 
@@ -548,10 +642,6 @@ export class ElectronMainApplication {
     protected async startBackend(): Promise<number> {
         // Check if we should run everything as one process.
         const noBackendFork = process.argv.indexOf('--no-cluster') !== -1;
-        // We cannot use the `process.cwd()` as the application project path (the location of the `package.json` in other words)
-        // in a bundled electron application because it depends on the way we start it. For instance, on OS X, these are a differences:
-        // https://github.com/eclipse-theia/theia/issues/3297#issuecomment-439172274
-        process.env.THEIA_APP_PROJECT_PATH = this.globals.THEIA_APP_PROJECT_PATH;
         // Set the electron version for both the dev and the production mode. (https://github.com/eclipse-theia/theia/issues/3254)
         // Otherwise, the forked backend processes will not know that they're serving the electron frontend.
         process.env.THEIA_ELECTRON_VERSION = process.versions.electron;

package/src/electron-main/theia-electron-window.ts

@@ -37,6 +37,12 @@ export interface TheiaBrowserWindowOptions extends BrowserWindowConstructorOptio
      * in which case we want to invalidate the stored options and use the default options instead.
      */
     screenLayout?: string;
+    /**
+     * By default, the window will be shown as soon as the content is ready to render.
+     * This can be prevented by handing over preventAutomaticShow: `true`.
+     * Use this for fine-grained control over when to show the window, e.g. to coordinate with a splash screen.
+     */
+    preventAutomaticShow?: boolean;
 }
 
 export const TheiaBrowserWindowOptions = Symbol('TheiaBrowserWindowOptions');
@@ -76,7 +82,9 @@ export class TheiaElectronWindow {
     protected init(): void {
         this._window = new BrowserWindow(this.options);
         this._window.setMenuBarVisibility(false);
-        this.attachReadyToShow();
+        if (!this.options.preventAutomaticShow) {
+            this.attachReadyToShow();
+        }
         this.restoreMaximizedState();
         this.attachCloseListeners();
         this.trackApplicationState();

package/src/node/application-server.ts

@@ -26,9 +26,9 @@ export class ApplicationServerImpl implements ApplicationServer {
     protected readonly applicationPackage: ApplicationPackage;
 
     getExtensionsInfos(): Promise<ExtensionInfo[]> {
-        const extensions = this.applicationPackage.extensionPackages;
-        const infos: ExtensionInfo[] = extensions.map(extension => ({ name: extension.name, version: extension.version }));
-        return Promise.resolve(infos);
+        // @ts-expect-error
+        const appInfo: ExtensionInfo[] = globalThis.extensionInfo;
+        return Promise.resolve(appInfo);
     }
 
     getApplicationInfo(): Promise<ApplicationInfo | undefined> {

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

@@ -21,7 +21,7 @@ import {
     bindContributionProvider, MessageService, MessageClient, ConnectionHandler, RpcConnectionHandler,
     CommandService, commandServicePath, messageServicePath, OSBackendProvider, OSBackendProviderPath
 } from '../common';
-import { BackendApplication, BackendApplicationContribution, BackendApplicationCliContribution, BackendApplicationServer } from './backend-application';
+import { BackendApplication, BackendApplicationContribution, BackendApplicationCliContribution, BackendApplicationServer, BackendApplicationPath } from './backend-application';
 import { CliManager, CliContribution } from './cli';
 import { IPCConnectionProvider } from './messaging';
 import { ApplicationServerImpl } from './application-server';
@@ -101,10 +101,7 @@ export const backendApplicationModule = new ContainerModule(bind => {
         })
     ).inSingletonScope();
 
-    bind(ApplicationPackage).toDynamicValue(({ container }) => {
-        const { projectPath } = container.get(BackendApplicationCliContribution);
-        return new ApplicationPackage({ projectPath });
-    }).inSingletonScope();
+    bind(ApplicationPackage).toConstantValue(new ApplicationPackage({ projectPath: BackendApplicationPath }));
 
     bind(WsRequestValidator).toSelf().inSingletonScope();
     bindContributionProvider(bind, WsRequestValidatorContribution);

package/src/node/backend-application.ts

@@ -27,9 +27,14 @@ import { CliContribution } from './cli';
 import { Deferred } from '../common/promise-util';
 import { environment } from '../common/index';
 import { AddressInfo } from 'net';
-import { ApplicationPackage } from '@theia/application-package';
 import { ProcessUtils } from './process-utils';
 
+/**
+ * The path to the application project directory. This is the directory where the application code is located.
+ * Mostly contains the `package.json` file and the `lib` directory.
+ */
+export const BackendApplicationPath = process.env.THEIA_APP_PROJECT_PATH || process.cwd();
+
 export type DnsResultOrder = 'ipv4first' | 'verbatim' | 'nodeDefault';
 
 const APP_PROJECT_PATH = 'app-project-path';
@@ -115,7 +120,8 @@ export class BackendApplicationCliContribution implements CliContribution {
     ssl: boolean | undefined;
     cert: string | undefined;
     certkey: string | undefined;
-    projectPath: string;
+    /** @deprecated Use the `BackendApplicationPath` constant or `process.env.THEIA_APP_PROJECT_PATH` environment variable instead */
+    projectPath = BackendApplicationPath;
 
     configure(conf: yargs.Argv): void {
         conf.option('port', { alias: 'p', description: 'The port the backend server listens on.', type: 'number', default: DEFAULT_PORT });
@@ -123,7 +129,7 @@ export class BackendApplicationCliContribution implements CliContribution {
         conf.option('ssl', { description: 'Use SSL (HTTPS), cert and certkey must also be set', type: 'boolean', default: DEFAULT_SSL });
         conf.option('cert', { description: 'Path to SSL certificate.', type: 'string' });
         conf.option('certkey', { description: 'Path to SSL certificate key.', type: 'string' });
-        conf.option(APP_PROJECT_PATH, { description: 'Sets the application project directory', default: this.appProjectPath() });
+        conf.option(APP_PROJECT_PATH, { description: 'Sets the application project directory', deprecated: true });
         conf.option('dnsDefaultResultOrder', {
             type: 'string',
             description: 'Configure Node\'s DNS resolver default behavior, see https://nodejs.org/docs/latest-v18.x/api/dns.html#dnssetdefaultresultorderorder',
@@ -138,19 +144,8 @@ export class BackendApplicationCliContribution implements CliContribution {
         this.ssl = args.ssl as boolean;
         this.cert = args.cert as string;
         this.certkey = args.certkey as string;
-        this.projectPath = args[APP_PROJECT_PATH] as string;
         this.dnsDefaultResultOrder = args.dnsDefaultResultOrder as DnsResultOrder;
     }
-
-    protected appProjectPath(): string {
-        if (environment.electron.is()) {
-            if (process.env.THEIA_APP_PROJECT_PATH) {
-                return process.env.THEIA_APP_PROJECT_PATH;
-            }
-            throw new Error('The \'THEIA_APP_PROJECT_PATH\' environment variable must be set when running in electron.');
-        }
-        return process.cwd();
-    }
 }
 
 /**
@@ -161,9 +156,6 @@ export class BackendApplication {
 
     protected readonly app: express.Application = express();
 
-    @inject(ApplicationPackage)
-    protected readonly applicationPackage: ApplicationPackage;
-
     @inject(ProcessUtils)
     protected readonly processUtils: ProcessUtils;
 
@@ -352,7 +344,7 @@ export class BackendApplication {
         const acceptedEncodings = req.acceptsEncodings();
 
         const gzUrl = `${req.url}.gz`;
-        const gzPath = path.join(this.applicationPackage.projectPath, 'lib', 'frontend', gzUrl);
+        const gzPath = path.join(BackendApplicationPath, 'lib', 'frontend', gzUrl);
         if (acceptedEncodings.indexOf('gzip') === -1 || !(await fs.pathExists(gzPath))) {
             next();
             return;

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

@@ -22,6 +22,7 @@ import { pathExists, mkdir } from 'fs-extra';
 import { EnvVariable, EnvVariablesServer } from '../../common/env-variables';
 import { isWindows } from '../../common/os';
 import { FileUri } from '../../common/file-uri';
+import { BackendApplicationPath } from '../backend-application';
 
 @injectable()
 export class EnvVariablesServerImpl implements EnvVariablesServer {
@@ -45,10 +46,7 @@ export class EnvVariablesServerImpl implements EnvVariablesServer {
     }
 
     protected async createConfigDirUri(): Promise<string> {
-        let dataFolderPath: string = '';
-        if (process.env.THEIA_APP_PROJECT_PATH) {
-            dataFolderPath = join(process.env.THEIA_APP_PROJECT_PATH, 'data');
-        }
+        const dataFolderPath = join(BackendApplicationPath, 'data');
         const userDataPath = join(dataFolderPath, 'user-data');
         const dataFolderExists = this.pathExistenceCache[dataFolderPath] ??= await pathExists(dataFolderPath);
         if (dataFolderExists) {