@theia/core 1.56.0 → 1.57.0-next.136

package/src/browser/shell/application-shell.ts

@@ -22,7 +22,7 @@ import {
 } from '@phosphor/widgets';
 import { Message } from '@phosphor/messaging';
 import { IDragEvent } from '@phosphor/dragdrop';
-import { RecursivePartial, Event as CommonEvent, DisposableCollection, Disposable, environment, isObject } from '../../common';
+import { RecursivePartial, Event as CommonEvent, DisposableCollection, Disposable, environment, isObject, UntitledResourceResolver, UNTITLED_SCHEME } from '../../common';
 import { animationFrame } from '../browser';
 import { Saveable, SaveableWidget, SaveOptions } from '../saveable';
 import { StatusBarImpl, StatusBarEntry, StatusBarAlignment } from '../status-bar/status-bar';
@@ -232,6 +232,9 @@ export class ApplicationShell extends Widget {
     @inject(OpenerService)
     protected readonly openerService: OpenerService;
 
+    @inject(UntitledResourceResolver)
+    protected readonly untitledResourceResolver: UntitledResourceResolver;
+
     protected readonly onDidAddWidgetEmitter = new Emitter<Widget>();
     readonly onDidAddWidget = this.onDidAddWidgetEmitter.event;
     protected fireDidAddWidget(widget: Widget): void {
@@ -323,6 +326,7 @@ export class ApplicationShell extends Widget {
 
     protected initializeShell(): void {
         this.addClass(APPLICATION_SHELL_CLASS);
+        this.addClass('monaco-workbench'); // needed for compatility with VSCode styles
         this.id = 'theia-app-shell';
 
         this.mainPanel = this.createMainPanel();
@@ -572,16 +576,28 @@ export class ApplicationShell extends Widget {
                     uris.forEach(openUri);
                 } else if (event.dataTransfer.files?.length > 0) {
                     // the files were dragged from the outside the workspace
-                    Array.from(event.dataTransfer.files).forEach(file => {
-                        if (file.path) {
-                            const fileUri = URI.fromComponents({
-                                scheme: 'file',
-                                path: file.path,
-                                authority: '',
-                                query: '',
-                                fragment: ''
-                            });
-                            openUri(fileUri);
+                    Array.from(event.dataTransfer.files).forEach(async file => {
+                        if (environment.electron.is()) {
+                            if (file.path) {
+                                const fileUri = URI.fromFilePath(file.path);
+                                openUri(fileUri);
+                            }
+                        } else {
+                            const fileContent = await file.text();
+                            const fileName = file.name;
+                            const uri = new URI(`${UNTITLED_SCHEME}:/${fileName}`);
+                            // Only create a new untitled resource if it doesn't already exist.
+                            // VS Code does the same thing, and there's not really a better solution,
+                            // since we want to keep the original name of the file,
+                            // but also to prevent duplicates of the same file.
+                            if (!this.untitledResourceResolver.has(uri)) {
+                                const untitledResource = await this.untitledResourceResolver.createUntitledResource(
+                                    fileContent,
+                                    undefined,
+                                    new URI(`${UNTITLED_SCHEME}:/${fileName}`)
+                                );
+                                openUri(untitledResource.uri);
+                            }
                         }
                     });
                 }

package/src/browser/style/dockpanel.css

@@ -14,6 +14,16 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  ********************************************************************************/
 
+/*
+ * phosphor.js sets the z-index of its panels to 0, which causes overlay issues
+ * See also https://github.com/eclipse-theia/theia/issues/14290
+ */
+.p-SplitPanel-child,
+.p-DockPanel,
+.p-DockPanel-widget {
+  z-index: initial;
+}
+
 .p-DockPanel.p-SplitPanel-child {
   padding: 0px;
 }

package/src/browser/test/jsdom.ts

@@ -43,7 +43,12 @@ export function enableJSDOM(): () => void {
     });
     (global as any)['document'] = dom.window.document;
     (global as any)['window'] = dom.window;
-    (global as any)['navigator'] = { userAgent: 'node.js', platform: 'Mac' };
+    try {
+        (global as any)['navigator'] = { userAgent: 'node.js', platform: 'Mac' };
+
+    } catch (e) {
+        // node 21+ already has a navigator object
+    }
 
     const toCleanup: string[] = [];
     Object.getOwnPropertyNames((dom.window as any)).forEach(property => {

package/src/browser/tree/tree-widget.tsx

@@ -32,7 +32,7 @@ import { notEmpty } from '../../common/objects';
 import { isOSX } from '../../common/os';
 import { ReactWidget } from '../widgets/react-widget';
 import * as React from 'react';
-import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
+import { Virtuoso, VirtuosoHandle, VirtuosoProps } from 'react-virtuoso';
 import { TopDownTreeIterator } from './tree-iterator';
 import { SearchBox, SearchBoxFactory, SearchBoxProps } from './search-box';
 import { TreeSearch } from './tree-search';
@@ -111,6 +111,10 @@ export interface TreeProps {
      */
     readonly expandOnlyOnExpansionToggleClick?: boolean;
 
+    /**
+     * Props that are forwarded to the virtuoso list rendered. Defaults to `{}`.
+     */
+    readonly viewProps?: VirtuosoProps<unknown, unknown>;
 }
 
 /**
@@ -498,6 +502,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 rows={rows}
                 renderNodeRow={this.renderNodeRow}
                 scrollToRow={this.scrollToRow}
+                {...this.props.viewProps}
             />;
         }
         // eslint-disable-next-line no-null/no-null
@@ -1546,7 +1551,7 @@ export namespace TreeWidget {
     /**
      * Representation of the tree view properties.
      */
-    export interface ViewProps {
+    export interface ViewProps extends VirtuosoProps<unknown, unknown> {
         /**
          * The width property.
          */
@@ -1568,7 +1573,7 @@ export namespace TreeWidget {
     export class View extends React.Component<ViewProps> {
         list: VirtuosoHandle | undefined;
         override render(): React.ReactNode {
-            const { rows, width, height, scrollToRow } = this.props;
+            const { rows, width, height, scrollToRow, renderNodeRow, ...other } = this.props;
             return <Virtuoso
                 ref={list => {
                     this.list = (list || undefined);
@@ -1580,11 +1585,12 @@ export namespace TreeWidget {
                     }
                 }}
                 totalCount={rows.length}
-                itemContent={index => this.props.renderNodeRow(rows[index])}
+                itemContent={index => renderNodeRow(rows[index])}
                 width={width}
                 height={height}
                 // This is a pixel value, it will scan 200px to the top and bottom of the current view
                 overscan={500}
+                {...other}
             />;
         }
     }

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

@@ -22,6 +22,8 @@ import { ClipboardService } from '../clipboard-service';
 import { BrowserClipboardService } from '../browser-clipboard-service';
 import { SecondaryWindowService } from './secondary-window-service';
 import { DefaultSecondaryWindowService } from './default-secondary-window-service';
+import { bindContributionProvider } from '../../common';
+import { WindowTitleContribution } from './window-title-service';
 
 export default new ContainerModule(bind => {
     bind(DefaultWindowService).toSelf().inSingletonScope();
@@ -29,4 +31,5 @@ export default new ContainerModule(bind => {
     bind(FrontendApplicationContribution).toService(DefaultWindowService);
     bind(ClipboardService).to(BrowserClipboardService).inSingletonScope();
     bind(SecondaryWindowService).to(DefaultSecondaryWindowService).inSingletonScope();
+    bindContributionProvider(bind, WindowTitleContribution);
 });

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

@@ -20,11 +20,15 @@ import { ExtractableWidget } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
 import { PreferenceService } from '../preferences';
-import { environment } from '../../common';
+import { Emitter, environment, Event } from '../../common';
 import { SaveableService } from '../saveable-service';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
+    protected readonly onWindowOpenedEmitter = new Emitter<Window>;
+    readonly onWindowOpened: Event<Window> = this.onWindowOpenedEmitter.event;
+    protected readonly onWindowClosedEmitter = new Emitter<Window>;
+    readonly onWindowClosed: Event<Window> = this.onWindowClosedEmitter.event;
     // secondary-window.html is part of Theia's generated code. It is generated by dev-packages/application-manager/src/generator/frontend-generator.ts
     protected static SECONDARY_WINDOW_URL = 'secondary-window.html';
 
@@ -94,6 +98,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
         const newWindow = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), options) ?? undefined;
         if (newWindow) {
             this.secondaryWindows.push(newWindow);
+            this.onWindowOpenedEmitter.fire(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
                     const saveable = Saveable.get(widget);
@@ -113,6 +118,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
 
                     const extIndex = this.secondaryWindows.indexOf(newWindow);
                     if (extIndex > -1) {
+                        this.onWindowClosedEmitter.fire(newWindow);
                         this.secondaryWindows.splice(extIndex, 1);
                     };
                 });

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

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { Event } from '../../common';
 import { ApplicationShell } from '../shell';
 import { ExtractableWidget } from '../widgets';
 
@@ -33,6 +34,8 @@ export interface SecondaryWindowService {
      * @returns the created window or `undefined` if it could not be created
      */
     createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined;
+    readonly onWindowOpened: Event<Window>;
+    readonly onWindowClosed: Event<Window>;
 
     /** Handles focussing the given secondary window in the browser and on Electron. */
     focus(win: Window): void;

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

@@ -14,11 +14,17 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, named, postConstruct } from 'inversify';
 import { escapeRegExpCharacters } from '../../common/strings';
 import { Emitter, Event } from '../../common/event';
 import { CorePreferences } from '../core-preferences';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+import { ContributionProvider } from '../../common';
+
+export const WindowTitleContribution = Symbol('WindowTitleAddOnContribution');
+export interface WindowTitleContribution {
+    enhanceTitle(title: string, parts: Map<string, string | undefined>): string;
+}
 
 export const InitialWindowTitleParts = {
     activeEditorShort: undefined,
@@ -43,6 +49,9 @@ export class WindowTitleService {
     @inject(CorePreferences)
     protected readonly preferences: CorePreferences;
 
+    @inject(ContributionProvider) @named(WindowTitleContribution)
+    protected readonly titleContributions: ContributionProvider<WindowTitleContribution>;
+
     protected _title = '';
     protected titleTemplate?: string;
 
@@ -95,6 +104,10 @@ export class WindowTitleService {
             }
             const separatedTitle = title.split('${separator}').filter(e => e.trim().length > 0);
             this._title = separatedTitle.join(this.separator);
+            const contributions = this.titleContributions.getContributions();
+            for (const contribution of contributions) {
+                this._title = contribution.enhanceTitle(this.title, this.titleParts);
+            }
         }
         const developmentHost = this.titleParts.get('developmentHost');
         if (developmentHost) {

package/src/common/logger-binding.ts

@@ -0,0 +1,34 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { interfaces } from 'inversify';
+import { ILogger, Logger, LoggerName, rootLoggerName } from './logger';
+import { LoggerWatcher } from './logger-watcher';
+
+export function bindCommonLogger(bind: interfaces.Bind): void {
+    bind(LoggerName).toConstantValue(rootLoggerName);
+    bind(ILogger).to(Logger).inSingletonScope().when(request => getName(request) === undefined);
+    bind(ILogger).toDynamicValue(ctx => {
+        const logger = ctx.container.get<ILogger>(ILogger);
+        return logger.child(getName(ctx.currentRequest)!);
+    }).when(request => getName(request) !== undefined);
+    bind(LoggerWatcher).toSelf().inSingletonScope();
+}
+
+function getName(request: interfaces.Request): string | undefined {
+    const named = request.target.metadata.find(e => e.key === 'named');
+    return named ? named.value?.toString() : undefined;
+}

package/src/common/logger-protocol.ts

@@ -110,10 +110,12 @@ export namespace ConsoleLogger {
         console.trace = consoles.get(LogLevel.TRACE)!;
         console.log = originalConsoleLog;
     }
-    export function log(name: string, logLevel: number, message: string, params: any[]): void {
+    export function log(name: string, logLevel: number, message: string, params: any[]): string {
         const console = consoles.get(logLevel) || originalConsoleLog;
         const severity = (LogLevel.strings.get(logLevel) || 'unknown').toUpperCase();
         const now = new Date();
-        console(`${now.toISOString()} ${name} ${severity} ${message}`, ...params);
+        const formattedMessage = `${now.toISOString()} ${name} ${severity} ${message}`;
+        console(formattedMessage, ...params);
+        return formattedMessage;
     }
 }

package/src/common/logger.ts

@@ -240,6 +240,8 @@ export class Logger implements ILogger {
     @inject(LoggerFactory) protected readonly factory: LoggerFactory;
     @inject(LoggerName) protected name: string;
 
+    protected cache = new Map<string, ILogger>();
+
     @postConstruct()
     protected init(): void {
         if (this.name !== rootLoggerName) {
@@ -384,6 +386,13 @@ export class Logger implements ILogger {
     }
 
     child(name: string): ILogger {
-        return this.factory(name);
+        const existing = this.cache.get(name);
+        if (existing) {
+            return existing;
+        } else {
+            const child = this.factory(name);
+            this.cache.set(name, child);
+            return child;
+        }
     }
 }

package/src/common/resource.ts

@@ -60,6 +60,8 @@ export interface Resource extends Disposable {
     readonly onDidChangeReadOnly?: Event<boolean | MarkdownString>;
 
     readonly readOnly?: boolean | MarkdownString;
+
+    readonly initiallyDirty?: boolean;
     /**
      * Reads latest content of this resource.
      *
@@ -378,11 +380,13 @@ export class UntitledResourceResolver implements ResourceResolver {
 export class UntitledResource implements Resource {
 
     protected readonly onDidChangeContentsEmitter = new Emitter<void>();
+    initiallyDirty: boolean;
     get onDidChangeContents(): Event<void> {
         return this.onDidChangeContentsEmitter.event;
     }
 
     constructor(private resources: Map<string, UntitledResource>, public uri: URI, private content?: string) {
+        this.initiallyDirty = (content !== undefined && content.length > 0);
         this.resources.set(this.uri.toString(), this);
     }
 

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

@@ -23,6 +23,11 @@ export function getLocalPort(): string | undefined {
     return params.get('localPort') ?? undefined;
 }
 
+export function getCurrentPort(): string | undefined {
+    const params = new URLSearchParams(location.search);
+    return params.get('port') ?? undefined;
+}
+
 @injectable()
 export class ElectronLocalWebSocketConnectionSource extends WebSocketConnectionSource {
 

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

@@ -30,6 +30,8 @@ import { bindWindowPreferences } from './electron-window-preferences';
 import { ElectronWindowService } from './electron-window-service';
 import { ExternalAppOpenHandler } from './external-app-open-handler';
 import { ElectronUriHandlerContribution } from '../electron-uri-handler';
+import { bindContributionProvider } from '../../common';
+import { WindowTitleContribution } from '../../browser/window/window-title-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ElectronMainWindowService).toDynamicValue(context =>
@@ -45,4 +47,5 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(SecondaryWindowService).to(ElectronSecondaryWindowService).inSingletonScope();
     bind(ExternalAppOpenHandler).toSelf().inSingletonScope();
     bind(OpenHandler).toService(ExternalAppOpenHandler);
+    bindContributionProvider(bind, WindowTitleContribution);
 });

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

@@ -396,7 +396,7 @@ export class ElectronMainApplication {
     }
 
     protected isShowSplashScreen(): boolean {
-        return typeof this.config.electron.splashScreenOptions === 'object' && !!this.config.electron.splashScreenOptions.content;
+        return !process.env.THEIA_NO_SPLASH && typeof this.config.electron.splashScreenOptions === 'object' && !!this.config.electron.splashScreenOptions.content;
     }
 
     protected getSplashScreenOptions(): ElectronFrontendApplicationConfig.SplashScreenOptions | undefined {
@@ -522,21 +522,21 @@ export class ElectronMainApplication {
     }
 
     protected async handleMainCommand(options: ElectronMainCommandOptions): Promise<void> {
-        if (options.secondInstance === false) {
-            await this.openWindowWithWorkspace(''); // restore previous workspace.
-        } else if (options.file === undefined) {
-            await this.openDefaultWindow();
-        } else {
-            let workspacePath: string | undefined;
+        let workspacePath: string | undefined;
+        if (options.file) {
             try {
                 workspacePath = await fs.realpath(path.resolve(options.cwd, options.file));
             } catch {
                 console.error(`Could not resolve the workspace path. "${options.file}" is not a valid 'file' option. Falling back to the default workspace location.`);
             }
-            if (workspacePath === undefined) {
+        }
+        if (workspacePath !== undefined) {
+            await this.openWindowWithWorkspace(workspacePath);
+        } else {
+            if (options.secondInstance === false) {
+                await this.openWindowWithWorkspace(''); // restore previous workspace.
+            } else if (options.file === undefined) {
                 await this.openDefaultWindow();
-            } else {
-                await this.openWindowWithWorkspace(workspacePath);
             }
         }
     }

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

@@ -186,10 +186,18 @@ export class TheiaElectronWindow {
     }
 
     protected restoreMaximizedState(): void {
-        if (this.options.isMaximized) {
-            this._window.maximize();
+        const restore = () => {
+            if (this.options.isMaximized) {
+                this._window.maximize();
+            } else {
+                this._window.unmaximize();
+            }
+        };
+
+        if (this._window.isVisible()) {
+            restore();
         } else {
-            this._window.unmaximize();
+            this._window.once('show', () => restore());
         }
     }
 

package/src/node/console-logger-server.ts

@@ -18,11 +18,14 @@ import { inject, injectable, postConstruct } from 'inversify';
 import { LoggerWatcher } from '../common/logger-watcher';
 import { LogLevelCliContribution } from './logger-cli-contribution';
 import { ILoggerServer, ILoggerClient, ConsoleLogger, rootLoggerName } from '../common/logger-protocol';
+import { format } from 'util';
+import { EOL } from 'os';
+import * as fs from 'fs';
 
 @injectable()
 export class ConsoleLoggerServer implements ILoggerServer {
 
-    protected client: ILoggerClient | undefined = undefined;
+    protected client?: ILoggerClient;
 
     @inject(LoggerWatcher)
     protected watcher: LoggerWatcher;
@@ -30,6 +33,8 @@ export class ConsoleLoggerServer implements ILoggerServer {
     @inject(LogLevelCliContribution)
     protected cli: LogLevelCliContribution;
 
+    protected logFileStream?: fs.WriteStream;
+
     @postConstruct()
     protected init(): void {
         this.setLogLevel(rootLoggerName, this.cli.defaultLogLevel);
@@ -59,7 +64,22 @@ export class ConsoleLoggerServer implements ILoggerServer {
     async log(name: string, logLevel: number, message: string, params: any[]): Promise<void> {
         const configuredLogLevel = await this.getLogLevel(name);
         if (logLevel >= configuredLogLevel) {
-            ConsoleLogger.log(name, logLevel, message, params);
+            const fullMessage = ConsoleLogger.log(name, logLevel, message, params);
+            this.logToFile(fullMessage, params);
+        }
+    }
+
+    protected logToFile(message: string, params: any[]): void {
+        if (this.cli.logFile && !this.logFileStream) {
+            this.logFileStream = fs.createWriteStream(this.cli.logFile, { flags: 'a' });
+            // Only log errors once to avoid spamming the console
+            this.logFileStream.once('error', error => {
+                console.error(`Error writing to log file ${this.cli.logFile}`, error);
+            });
+        }
+        if (this.logFileStream) {
+            const formatted = format(message, ...params) + EOL;
+            this.logFileStream.write(formatted);
         }
     }
 

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

@@ -16,20 +16,19 @@
 
 import { ContainerModule, Container, interfaces } from 'inversify';
 import { ConnectionHandler, RpcConnectionHandler } from '../common/messaging';
-import { ILogger, LoggerFactory, Logger, setRootLogger, LoggerName, rootLoggerName } from '../common/logger';
+import { ILogger, LoggerFactory, Logger, setRootLogger, LoggerName } from '../common/logger';
 import { ILoggerServer, ILoggerClient, loggerPath, DispatchingLoggerClient } from '../common/logger-protocol';
 import { ConsoleLoggerServer } from './console-logger-server';
 import { LoggerWatcher } from '../common/logger-watcher';
 import { BackendApplicationContribution } from './backend-application';
 import { CliContribution } from './cli';
 import { LogLevelCliContribution } from './logger-cli-contribution';
+import { bindCommonLogger } from '../common/logger-binding';
 
 export function bindLogger(bind: interfaces.Bind, props?: {
     onLoggerServerActivation?: (context: interfaces.Context, server: ILoggerServer) => void
 }): void {
-    bind(LoggerName).toConstantValue(rootLoggerName);
-    bind(ILogger).to(Logger).inSingletonScope().whenTargetIsDefault();
-    bind(LoggerWatcher).toSelf().inSingletonScope();
+    bindCommonLogger(bind);
     bind<ILoggerServer>(ILoggerServer).to(ConsoleLoggerServer).inSingletonScope().onActivation((context, server) => {
         if (props && props.onLoggerServerActivation) {
             props.onLoggerServerActivation(context, server);

package/src/node/logger-cli-contribution.ts

@@ -43,6 +43,8 @@ export class LogLevelCliContribution implements CliContribution {
      */
     protected _defaultLogLevel: LogLevel = LogLevel.INFO;
 
+    protected _logFile?: string;
+
     protected logConfigChangedEvent: Emitter<void> = new Emitter<void>();
 
     get defaultLogLevel(): LogLevel {
@@ -53,6 +55,10 @@ export class LogLevelCliContribution implements CliContribution {
         return this._logLevels;
     }
 
+    get logFile(): string | undefined {
+        return this._logFile;
+    }
+
     configure(conf: yargs.Argv): void {
         conf.option('log-level', {
             description: 'Sets the default log level',
@@ -65,6 +71,12 @@ export class LogLevelCliContribution implements CliContribution {
             type: 'string',
             nargs: 1,
         });
+
+        conf.option('log-file', {
+            description: 'Path to the log file',
+            type: 'string',
+            nargs: 1
+        });
     }
 
     async setArguments(args: yargs.Arguments): Promise<void> {
@@ -87,22 +99,46 @@ export class LogLevelCliContribution implements CliContribution {
                 console.error(`Error reading log config file ${filename}: ${e}`);
             }
         }
+
+        if (args['log-file'] !== undefined) {
+            let filename = args['log-file'] as string;
+            try {
+                filename = path.resolve(filename);
+                try {
+                    const stat = await fs.stat(filename);
+                    if (stat && stat.isFile()) {
+                        // Rename the previous log file to avoid overwriting it
+                        const oldFilename = `${filename}.${stat.ctime.toISOString().replace(/:/g, '-')}.old`;
+                        await fs.rename(filename, oldFilename);
+                    }
+                } catch {
+                    // File does not exist, just continue to create it
+                }
+                await fs.writeFile(filename, '');
+                this._logFile = filename;
+            } catch (e) {
+                console.error(`Error creating log file ${filename}: ${e}`);
+            }
+        }
     }
 
     protected async watchLogConfigFile(filename: string): Promise<void> {
-        await subscribe(filename, async (err, events) => {
+        const dir = path.dirname(filename);
+        await subscribe(dir, async (err, events) => {
             if (err) {
                 console.log(`Error during log file watching ${filename}: ${err}`);
                 return;
             }
             try {
                 for (const event of events) {
-                    switch (event.type) {
-                        case 'create':
-                        case 'update':
-                            await this.slurpLogConfigFile(filename);
-                            this.logConfigChangedEvent.fire(undefined);
-                            break;
+                    if (event.path === filename) {
+                        switch (event.type) {
+                            case 'create':
+                            case 'update':
+                                await this.slurpLogConfigFile(filename);
+                                this.logConfigChangedEvent.fire(undefined);
+                                break;
+                        }
                     }
                 }
             } catch (e) {

package/src/node/messaging/test/test-web-socket-channel.ts

@@ -47,7 +47,12 @@ export class TestWebSocketChannelSetup {
         path: string
     }) {
         const address = (server.address() as AddressInfo);
-        const url = `ws://${address.address}:${address.port}${servicesPath}`;
+        let url;
+        if (address.family === 'IPv6') {
+            url = `ws://[${address.address}]:${address.port}${servicesPath}`;
+        } else {
+            url = `ws://${address.address}:${address.port}${servicesPath}`;
+        }
         this.connectionProvider = this.createConnectionProvider(url);
     }