@theia/core 1.55.0-next.4 → 1.55.0-next.67

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

@@ -19,28 +19,35 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 // some code is copied and modified from: https://github.com/microsoft/vscode/blob/573e5145ae3b50523925a6f6315d373e649d1b06/src/vs/base/common/linkedText.ts
+// aligned the API and enablement behavior to https://github.com/microsoft/vscode/blob/c711bc9333ba339fde1a530de0094b3fa32f09de/src/vs/base/common/linkedText.ts
 
 import React = require('react');
 import { inject, injectable } from 'inversify';
-import { CommandRegistry } from '../../common';
+import { URI as CodeUri } from 'vscode-uri';
+import { CommandRegistry, DisposableCollection } from '../../common';
+import URI from '../../common/uri';
 import { ContextKeyService } from '../context-key-service';
+import { LabelIcon, LabelParser } from '../label-parser';
+import { OpenerService, open } from '../opener-service';
+import { codicon } from '../widgets';
+import { WindowService } from '../window/window-service';
 import { TreeModel } from './tree-model';
 import { TreeWidget } from './tree-widget';
-import { WindowService } from '../window/window-service';
 
-interface ViewWelcome {
+export interface ViewWelcome {
     readonly view: string;
     readonly content: string;
     readonly when?: string;
+    readonly enablement?: string;
     readonly order: number;
 }
 
-interface IItem {
+export interface IItem {
     readonly welcomeInfo: ViewWelcome;
     visible: boolean;
 }
 
-interface ILink {
+export interface ILink {
     readonly label: string;
     readonly href: string;
     readonly title?: string;
@@ -60,6 +67,14 @@ export class TreeViewWelcomeWidget extends TreeWidget {
     @inject(WindowService)
     protected readonly windowService: WindowService;
 
+    @inject(LabelParser)
+    protected readonly labelParser: LabelParser;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    protected readonly toDisposeBeforeUpdateViewWelcomeNodes = new DisposableCollection();
+
     protected viewWelcomeNodes: React.ReactNode[] = [];
     protected defaultItem: IItem | undefined;
     protected items: IItem[] = [];
@@ -130,13 +145,31 @@ export class TreeViewWelcomeWidget extends TreeWidget {
 
     protected updateViewWelcomeNodes(): void {
         this.viewWelcomeNodes = [];
+        this.toDisposeBeforeUpdateViewWelcomeNodes.dispose();
         const items = this.visibleItems.sort((a, b) => a.order - b.order);
 
-        for (const [iIndex, { content }] of items.entries()) {
+        const enablementKeys: Set<string>[] = [];
+        // the plugin-view-registry will push the changes when there is a change in the `when` prop  which controls the visibility
+        // this listener is to update the enablement of the components in the view welcome
+        this.toDisposeBeforeUpdateViewWelcomeNodes.push(
+            this.contextService.onDidChange(event => {
+                if (enablementKeys.some(keys => event.affects(keys))) {
+                    this.updateViewWelcomeNodes();
+                    this.update();
+                }
+            })
+        );
+        // Note: VS Code does not support the `renderSecondaryButtons` prop in welcome content either.
+        for (const { content, enablement } of items) {
+            const itemEnablementKeys = enablement
+                ? this.contextService.parseKeys(enablement)
+                : undefined;
+            if (itemEnablementKeys) {
+                enablementKeys.push(itemEnablementKeys);
+            }
             const lines = content.split('\n');
 
-            for (let [lIndex, line] of lines.entries()) {
-                const lineKey = `${iIndex}-${lIndex}`;
+            for (let line of lines) {
                 line = line.trim();
 
                 if (!line) {
@@ -146,42 +179,35 @@ export class TreeViewWelcomeWidget extends TreeWidget {
                 const linkedTextItems = this.parseLinkedText(line);
 
                 if (linkedTextItems.length === 1 && typeof linkedTextItems[0] !== 'string') {
+                    const node = linkedTextItems[0];
                     this.viewWelcomeNodes.push(
-                        this.renderButtonNode(linkedTextItems[0], lineKey)
+                        this.renderButtonNode(
+                            node,
+                            this.viewWelcomeNodes.length,
+                            enablement
+                        )
                     );
                 } else {
-                    const linkedTextNodes: React.ReactNode[] = [];
-
-                    for (const [nIndex, node] of linkedTextItems.entries()) {
-                        const linkedTextKey = `${lineKey}-${nIndex}`;
-
-                        if (typeof node === 'string') {
-                            linkedTextNodes.push(
-                                this.renderTextNode(node, linkedTextKey)
-                            );
-                        } else {
-                            linkedTextNodes.push(
-                                this.renderCommandLinkNode(node, linkedTextKey)
-                            );
-                        }
-                    }
+                    const renderNode = (item: LinkedTextItem, index: number) => typeof item == 'string'
+                        ? this.renderTextNode(item, index)
+                        : this.renderLinkNode(item, index, enablement);
 
                     this.viewWelcomeNodes.push(
-                        <div key={`line-${lineKey}`}>
-                            {...linkedTextNodes}
-                        </div>
+                        <p key={`p-${this.viewWelcomeNodes.length}`}>
+                            {...linkedTextItems.flatMap(renderNode)}
+                        </p>
                     );
                 }
             }
         }
     }
 
-    protected renderButtonNode(node: ILink, lineKey: string): React.ReactNode {
+    protected renderButtonNode(node: ILink, lineKey: string | number, enablement: string | undefined): React.ReactNode {
         return (
             <div key={`line-${lineKey}`} className='theia-WelcomeViewButtonWrapper'>
                 <button title={node.title}
                     className='theia-button theia-WelcomeViewButton'
-                    disabled={!this.isEnabledClick(node.href)}
+                    disabled={!this.isEnabledClick(enablement)}
                     onClick={e => this.openLinkOrCommand(e, node.href)}>
                     {node.label}
                 </button>
@@ -189,14 +215,22 @@ export class TreeViewWelcomeWidget extends TreeWidget {
         );
     }
 
-    protected renderTextNode(node: string, textKey: string): React.ReactNode {
-        return <span key={`text-${textKey}`}>{node}</span>;
+    protected renderTextNode(node: string, textKey: string | number): React.ReactNode {
+        return <span key={`text-${textKey}`}>
+            {this.labelParser.parse(node)
+                .map((segment, index) =>
+                    LabelIcon.is(segment)
+                        ? <span
+                            key={index}
+                            className={codicon(segment.name)}
+                        />
+                        : <span key={index}>{segment}</span>)}</span>;
     }
 
-    protected renderCommandLinkNode(node: ILink, linkKey: string): React.ReactNode {
+    protected renderLinkNode(node: ILink, linkKey: string | number, enablement: string | undefined): React.ReactNode {
         return (
             <a key={`link-${linkKey}`}
-                className={this.getLinkClassName(node.href)}
+                className={this.getLinkClassName(node.href, enablement)}
                 title={node.title || ''}
                 onClick={e => this.openLinkOrCommand(e, node.href)}>
                 {node.label}
@@ -204,37 +238,39 @@ export class TreeViewWelcomeWidget extends TreeWidget {
         );
     }
 
-    protected getLinkClassName(href: string): string {
+    protected getLinkClassName(href: string, enablement: string | undefined): string {
         const classNames = ['theia-WelcomeViewCommandLink'];
-        if (!this.isEnabledClick(href)) {
+        // Only command-backed links can be disabled. All other, https:, file: remain enabled
+        if (href.startsWith('command:') && !this.isEnabledClick(enablement)) {
             classNames.push('disabled');
         }
         return classNames.join(' ');
     }
 
-    protected isEnabledClick(href: string): boolean {
-        if (href.startsWith('command:')) {
-            const command = href.replace('command:', '');
-            return this.commands.isEnabled(command);
-        }
-        return true;
+    protected isEnabledClick(enablement: string | undefined): boolean {
+        return typeof enablement === 'string'
+            ? this.contextService.match(enablement)
+            : true;
     }
 
-    protected openLinkOrCommand = (event: React.MouseEvent, href: string): void => {
+    protected openLinkOrCommand = (event: React.MouseEvent, value: string): void => {
         event.stopPropagation();
 
-        if (href.startsWith('command:')) {
-            const command = href.replace('command:', '');
+        if (value.startsWith('command:')) {
+            const command = value.replace('command:', '');
             this.commands.executeCommand(command);
+        } else if (value.startsWith('file:')) {
+            const uri = value.replace('file:', '');
+            open(this.openerService, new URI(CodeUri.file(uri).toString()));
         } else {
-            this.windowService.openNewWindow(href, { external: true });
+            this.windowService.openNewWindow(value, { external: true });
         }
     };
 
     protected parseLinkedText(text: string): LinkedTextItem[] {
         const result: LinkedTextItem[] = [];
 
-        const linkRegex = /\[([^\]]+)\]\(((?:https?:\/\/|command:)[^\)\s]+)(?: ("|')([^\3]+)(\3))?\)/gi;
+        const linkRegex = /\[([^\]]+)\]\(((?:https?:\/\/|command:|file:)[^\)\s]+)(?: (["'])(.+?)(\3))?\)/gi;
         let index = 0;
         let match: RegExpExecArray | null;
 

package/src/browser/widget-status-bar-service.ts

@@ -0,0 +1,84 @@
+// *****************************************************************************
+// 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, named } from 'inversify';
+import { Widget } from './widgets';
+import { StatusBar } from './status-bar';
+import { FrontendApplicationContribution } from './frontend-application-contribution';
+import { ContributionProvider } from '../common';
+import { FrontendApplication } from './frontend-application';
+
+export const WidgetStatusBarContribution = Symbol('WidgetStatusBarContribution');
+
+export interface WidgetStatusBarContribution<T extends Widget> {
+    canHandle(widget: Widget): widget is T;
+    activate(statusBar: StatusBar, widget: T): void;
+    deactivate(statusBar: StatusBar): void;
+}
+
+/**
+ * Creates an empty {@link WidgetStatusBarContribution} that does nothing.
+ * Useful for widgets that are not handled by any other contribution, for example:
+ * * Settings widget
+ * * Welcome widget
+ * * Webview widget
+ *
+ * @param prototype Prototype to identify the kind of the widget.
+ * @returns An empty {@link WidgetStatusBarContribution}.
+ */
+export function noopWidgetStatusBarContribution(prototype: Function): WidgetStatusBarContribution<Widget> {
+    return {
+        canHandle(widget: Widget): widget is Widget {
+            return widget instanceof prototype;
+        },
+        activate: () => { },
+        deactivate: () => { }
+    };
+}
+
+@injectable()
+export class WidgetStatusBarService implements FrontendApplicationContribution {
+
+    @inject(ContributionProvider) @named(WidgetStatusBarContribution)
+    protected readonly contributionProvider: ContributionProvider<WidgetStatusBarContribution<Widget>>;
+
+    @inject(StatusBar)
+    protected readonly statusBar: StatusBar;
+
+    onStart(app: FrontendApplication): void {
+        app.shell.onDidChangeCurrentWidget(event => {
+            if (event.newValue) {
+                this.show(event.newValue);
+            }
+        });
+    }
+
+    protected show(widget: Widget): void {
+        const contributions = this.contributionProvider.getContributions();
+        // If any contribution can handle the widget, activate it
+        // If none can, keep everything as is
+        if (contributions.some(contribution => contribution.canHandle(widget))) {
+            for (const contribution of contributions) {
+                // Deactivate all contributions
+                contribution.deactivate(this.statusBar);
+                if (contribution.canHandle(widget)) {
+                    // Selectively re-activate them
+                    contribution.activate(this.statusBar, widget);
+                }
+            }
+        }
+    }
+}

package/src/browser/widgets/react-widget.tsx

@@ -38,7 +38,9 @@ export abstract class ReactWidget extends BaseWidget {
 
     protected override onUpdateRequest(msg: Message): void {
         super.onUpdateRequest(msg);
-        this.nodeRoot.render(<React.Fragment>{this.render()}</React.Fragment>);
+        if (!this.isDisposed) {
+            this.nodeRoot.render(<React.Fragment>{this.render()}</React.Fragment>);
+        }
     }
 
     /**

package/src/browser/widgets/widget.ts

@@ -24,6 +24,7 @@ import { KeyCode, KeysOrKeyCodes } from '../keyboard/keys';
 
 import PerfectScrollbar from 'perfect-scrollbar';
 import { PreviewableWidget } from '../widgets/previewable-widget';
+import { Slot } from '@phosphor/signaling';
 
 decorate(injectable(), Widget);
 decorate(unmanaged(), Widget, 0);
@@ -364,23 +365,37 @@ function waitForVisible(widget: Widget, visible: boolean, attached?: boolean): P
     });
 }
 
+const pinnedTitles = new Map<Title<Widget>, [boolean, Slot<Widget, void>]>();
+
 export function isPinned(title: Title<Widget>): boolean {
     const pinnedState = !title.closable && title.className.includes(PINNED_CLASS);
     return pinnedState;
 }
 
-export function unpin(title: Title<Widget>): void {
-    title.closable = true;
-    title.className = title.className.replace(PINNED_CLASS, '').trim();
-}
-
 export function pin(title: Title<Widget>): void {
+    const l = () => {
+        pinnedTitles.delete(title);
+    };
+    pinnedTitles.set(title, [title.closable, l]);
+    title.owner.disposed.connect(l);
     title.closable = false;
     if (!title.className.includes(PINNED_CLASS)) {
         title.className += ` ${PINNED_CLASS}`;
     }
 }
 
+export function unpin(title: Title<Widget>): void {
+    const entry = pinnedTitles.get(title);
+    if (entry) {
+        title.owner.disposed.disconnect(entry[1]);
+        title.closable = entry[0];
+        pinnedTitles.delete(title);
+    } else {
+        title.closable = true;
+    }
+    title.className = title.className.replace(PINNED_CLASS, '').trim();
+}
+
 export function isLocked(title: Title<Widget>): boolean {
     return title.className.includes(LOCKED_CLASS);
 }

package/src/electron-browser/menu/electron-context-menu-renderer.ts

@@ -23,7 +23,7 @@ import {
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { ContextMenuContext } from '../../browser/menu/context-menu-context';
 import { MenuPath, MenuContribution, MenuModelRegistry } from '../../common';
-import { BrowserContextMenuRenderer } from '../../browser/menu/browser-context-menu-renderer';
+import { BrowserContextMenuAccess, BrowserContextMenuRenderer } from '../../browser/menu/browser-context-menu-renderer';
 
 export class ElectronContextMenuAccess extends ContextMenuAccess {
     constructor(readonly menuHandle: Promise<number>) {
@@ -115,7 +115,15 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
             this.context.resetAltPressed();
             return new ElectronContextMenuAccess(menuHandle);
         } else {
-            return super.doRender(options);
+            const menuAccess = super.doRender(options);
+            const node = (menuAccess as BrowserContextMenuAccess).menu.node;
+            const topPanelHeight = document.getElementById('theia-top-panel')?.clientHeight ?? 0;
+            // ensure the context menu is not displayed outside of the main area
+            if (node.style.top && parseInt(node.style.top.substring(0, node.style.top.length - 2)) < topPanelHeight) {
+                node.style.top = `${topPanelHeight}px`;
+                node.style.maxHeight = `calc(${node.style.maxHeight} - ${topPanelHeight}px)`;
+            }
+            return menuAccess;
         }
     }
 

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

@@ -74,42 +74,45 @@ export type ElectronMenuItemRole = ('undo' | 'redo' | 'cut' | 'copy' | 'paste' |
 @injectable()
 export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
 
-    protected _menu?: MenuDto[];
-    protected _toggledCommands: Set<string> = new Set();
+    protected menu?: MenuDto[];
+    protected toggledCommands: Set<string> = new Set();
 
     @inject(PreferenceService)
     protected preferencesService: PreferenceService;
 
+    setMenuBar = debounce(() => this.doSetMenuBar(), 100);
+
     @postConstruct()
     postConstruct(): void {
-        this.preferencesService.onPreferenceChanged(
-            debounce(e => {
-                if (e.preferenceName === 'window.menuBarVisibility') {
-                    this.setMenuBar();
-                }
-                if (this._menu) {
-                    for (const cmd of this._toggledCommands) {
-                        const menuItem = this.findMenuById(this._menu, cmd);
-                        if (menuItem) {
-                            menuItem.checked = this.commandRegistry.isToggled(cmd);
-                        }
-                    }
-                    window.electronTheiaCore.setMenu(this._menu);
-                }
-            }, 10)
-        );
         this.keybindingRegistry.onKeybindingsChanged(() => {
             this.setMenuBar();
         });
         this.menuProvider.onDidChange(() => {
             this.setMenuBar();
         });
+        this.preferencesService.ready.then(() => {
+            this.preferencesService.onPreferenceChanged(
+                debounce(e => {
+                    if (e.preferenceName === 'window.menuBarVisibility') {
+                        this.doSetMenuBar();
+                    }
+                    if (this.menu) {
+                        for (const cmd of this.toggledCommands) {
+                            const menuItem = this.findMenuById(this.menu, cmd);
+                            if (menuItem && (!!menuItem.checked !== this.commandRegistry.isToggled(cmd))) {
+                                menuItem.checked = !menuItem.checked;
+                            }
+                        }
+                        window.electronTheiaCore.setMenu(this.menu);
+                    }
+                }, 10)
+            );
+        });
     }
 
-    async setMenuBar(): Promise<void> {
-        await this.preferencesService.ready;
-        const createdMenuBar = this.createElectronMenuBar();
-        window.electronTheiaCore.setMenu(createdMenuBar);
+    doSetMenuBar(): void {
+        this.menu = this.createElectronMenuBar();
+        window.electronTheiaCore.setMenu(this.menu);
     }
 
     createElectronMenuBar(): MenuDto[] | undefined {
@@ -117,14 +120,12 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         const maxWidget = document.getElementsByClassName(MAXIMIZED_CLASS);
         if (preference === 'visible' || (preference === 'classic' && maxWidget.length === 0)) {
             const menuModel = this.menuProvider.getMenu(MAIN_MENU_BAR);
-            this._menu = this.fillMenuTemplate([], menuModel, [], { honorDisabled: false, rootMenuPath: MAIN_MENU_BAR }, false);
+            const menu = this.fillMenuTemplate([], menuModel, [], { honorDisabled: false, rootMenuPath: MAIN_MENU_BAR }, false);
             if (isOSX) {
-                this._menu.unshift(this.createOSXMenu());
+                menu.unshift(this.createOSXMenu());
             }
-            return this._menu;
+            return menu;
         }
-        this._menu = undefined;
-        // eslint-disable-next-line no-null/no-null
         return undefined;
     }
 
@@ -208,7 +209,7 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             parentItems.push(menuItem);
 
             if (this.commandRegistry.getToggledHandler(commandId, ...args)) {
-                this._toggledCommands.add(commandId);
+                this.toggledCommands.add(commandId);
             }
         }
         return parentItems;
@@ -273,11 +274,11 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             // We need to check if we can execute it.
             if (this.menuCommandExecutor.isEnabled(menuPath, cmd, ...args)) {
                 await this.menuCommandExecutor.executeCommand(menuPath, cmd, ...args);
-                if (this._menu && this.menuCommandExecutor.isVisible(menuPath, cmd, ...args)) {
-                    const item = this.findMenuById(this._menu, cmd);
+                if (this.menu && this.menuCommandExecutor.isVisible(menuPath, cmd, ...args)) {
+                    const item = this.findMenuById(this.menu, cmd);
                     if (item) {
                         item.checked = this.menuCommandExecutor.isToggled(menuPath, cmd, ...args);
-                        window.electronTheiaCore.setMenu(this._menu);
+                        window.electronTheiaCore.setMenu(this.menu);
                     }
                 }
             }

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

@@ -29,7 +29,6 @@ import { WindowService } from '../../browser/window/window-service';
 import { WindowTitleService } from '../../browser/window/window-title-service';
 
 import '../../../src/electron-browser/menu/electron-menu-style.css';
-import { MenuDto } from '../../electron-common/electron-api';
 import { ThemeService } from '../../browser/theming';
 import { ThemeChangeEvent } from '../../common/theme';
 
@@ -203,7 +202,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         }
     }
 
-    protected setMenu(app: FrontendApplication, electronMenu: MenuDto[] | undefined = this.factory.createElectronMenuBar()): void {
+    protected setMenu(app: FrontendApplication): void {
         if (!isOSX) {
             this.hideTopPanel(app);
             if (this.titleBarStyle === 'custom' && !this.menuBar) {
@@ -211,7 +210,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
                 return;
             }
         }
-        window.electronTheiaCore.setMenu(electronMenu);
+        this.factory.setMenuBar();
     }
 
     protected createCustomTitleBar(app: FrontendApplication): void {

package/src/electron-browser/preload.ts

@@ -35,8 +35,8 @@ const { ipcRenderer, contextBridge } = require('electron');
 
 // a map of menuId => map<handler id => handler>
 const commandHandlers = new Map<number, Map<number, () => void>>();
-let nextHandlerId = 0;
-const mainMenuId = 0;
+let nextHandlerId = 1;
+const mainMenuId = 1;
 let nextMenuId = mainMenuId + 1;
 
 let openUrlHandler: ((url: string) => Promise<boolean>) | undefined;

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

@@ -23,6 +23,7 @@ import { EnvVariable, EnvVariablesServer } from '../../common/env-variables';
 import { isWindows } from '../../common/os';
 import { FileUri } from '../../common/file-uri';
 import { BackendApplicationPath } from '../backend-application';
+import { BackendApplicationConfigProvider } from '../backend-application-config-provider';
 
 @injectable()
 export class EnvVariablesServerImpl implements EnvVariablesServer {
@@ -64,7 +65,7 @@ export class EnvVariablesServerImpl implements EnvVariablesServer {
                 this.pathExistenceCache[userDataPath] = true;
             }
         } else {
-            process.env.THEIA_CONFIG_DIR = join(homedir(), '.theia');
+            process.env.THEIA_CONFIG_DIR = join(homedir(), BackendApplicationConfigProvider.get().configurationFolder);
         }
         return FileUri.create(process.env.THEIA_CONFIG_DIR).toString();
     }

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

@@ -19,7 +19,7 @@ import { injectable } from 'inversify';
 import { LogLevel } from '../common/logger';
 import { CliContribution } from './cli';
 import * as fs from 'fs-extra';
-import * as nsfw from 'nsfw';
+import { subscribe } from '@parcel/watcher';
 import { Event, Emitter } from '../common/event';
 import * as path from 'path';
 
@@ -89,13 +89,17 @@ export class LogLevelCliContribution implements CliContribution {
         }
     }
 
-    protected watchLogConfigFile(filename: string): Promise<void> {
-        return nsfw(filename, async (events: nsfw.FileChangeEvent[]) => {
+    protected async watchLogConfigFile(filename: string): Promise<void> {
+        await subscribe(filename, async (err, events) => {
+            if (err) {
+                console.log(`Error during log file watching ${filename}: ${err}`);
+                return;
+            }
             try {
                 for (const event of events) {
-                    switch (event.action) {
-                        case nsfw.actions.CREATED:
-                        case nsfw.actions.MODIFIED:
+                    switch (event.type) {
+                        case 'create':
+                        case 'update':
                             await this.slurpLogConfigFile(filename);
                             this.logConfigChangedEvent.fire(undefined);
                             break;
@@ -104,8 +108,6 @@ export class LogLevelCliContribution implements CliContribution {
             } catch (e) {
                 console.error(`Error reading log config file ${filename}: ${e}`);
             }
-        }).then((watcher: nsfw.NSFW) => {
-            watcher.start();
         });
     }
 

package/shared/nsfw/index.d.ts

@@ -1,2 +0,0 @@
-import nsfw = require('nsfw');
-export = nsfw;

package/shared/nsfw/index.js

@@ -1 +0,0 @@
-module.exports = require('nsfw');