@theia/plugin-ext 1.37.0-next.8 → 1.37.0

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

@@ -632,13 +632,23 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
 
     handleDragEnd(node: TreeViewNode, event: React.DragEvent<HTMLElement>): void {
         this.applicationShell.clearAdditionalDraggedEditorUris();
+        this.model.proxy!.$dragEnd(this.id);
     }
 
     handleDragOver(event: React.DragEvent<HTMLElement>): void {
+        const hasFiles = (items: DataTransferItemList) => {
+            for (let i = 0; i < items.length; i++) {
+                if (items[i].kind === 'file') {
+                    return true;
+                }
+            }
+            return false;
+        };
+
         if (event.dataTransfer) {
             const canDrop = event.dataTransfer.types.some(type => this.options.dropMimeTypes!.includes(type)) ||
                 event.dataTransfer.types.includes(this.treeDragType) ||
-                this.options.dropMimeTypes!.includes('files') && event.dataTransfer.files.length > 0;
+                this.options.dropMimeTypes!.includes('files') && hasFiles(event.dataTransfer.items);
             if (canDrop) {
                 event.preventDefault();
                 event.dataTransfer.dropEffect = 'move';

package/src/main/electron-browser/webview/electron-webview-widget-factory.ts

@@ -14,12 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as electronRemote from '@theia/core/electron-shared/@electron/remote';
-import { ElectronSecurityToken } from '@theia/core/lib/electron-common/electron-token';
 import { WebviewWidgetFactory } from '../../browser/webview/webview-widget-factory';
 import { WebviewWidgetIdentifier, WebviewWidget } from '../../browser/webview/webview';
 import { CustomEditorWidgetFactory } from '../../browser/custom-editors/custom-editor-widget-factory';
 import { CustomEditorWidget } from '../../browser/custom-editors/custom-editor-widget';
+import '@theia/core/lib/electron-common/electron-api';
 
 export class ElectronWebviewWidgetFactory extends WebviewWidgetFactory {
 
@@ -34,13 +33,8 @@ export class ElectronWebviewWidgetFactory extends WebviewWidgetFactory {
      *
      * @param endpoint cookie's target url
      */
-    protected async attachElectronSecurityCookie(endpoint: string): Promise<void> {
-        await electronRemote.session.defaultSession.cookies.set({
-            url: endpoint,
-            name: ElectronSecurityToken,
-            value: JSON.stringify(this.container.get(ElectronSecurityToken)),
-            httpOnly: true
-        });
+    protected attachElectronSecurityCookie(endpoint: string): Promise<void> {
+        return window.electronTheiaCore.attachSecurityToken(endpoint);
     }
 
 }
@@ -59,12 +53,7 @@ export class ElectronCustomEditorWidgetFactory extends CustomEditorWidgetFactory
      * @param endpoint cookie's target url
      */
     protected async attachElectronSecurityCookie(endpoint: string): Promise<void> {
-        await electronRemote.session.defaultSession.cookies.set({
-            url: endpoint,
-            name: ElectronSecurityToken,
-            value: JSON.stringify(this.container.get(ElectronSecurityToken)),
-            httpOnly: true
-        });
+        return window.electronTheiaCore.attachSecurityToken(endpoint);
     }
 
 }

package/src/main/node/plugin-github-resolver.ts

@@ -14,11 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from '@theia/core/shared/inversify';
-import * as fs from 'fs';
+import { RequestContext, RequestService } from '@theia/core/shared/@theia/request';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { promises as fs, existsSync, mkdirSync } from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import * as request from 'request';
 import { PluginDeployerResolver, PluginDeployerResolverContext } from '../../common';
 
 /**
@@ -35,10 +35,13 @@ export class GithubPluginDeployerResolver implements PluginDeployerResolver {
 
     private unpackedFolder: string;
 
+    @inject(RequestService)
+    protected readonly request: RequestService;
+
     constructor() {
         this.unpackedFolder = path.resolve(os.tmpdir(), 'github-remote');
-        if (!fs.existsSync(this.unpackedFolder)) {
-            fs.mkdirSync(this.unpackedFolder);
+        if (!existsSync(this.unpackedFolder)) {
+            mkdirSync(this.unpackedFolder);
         }
     }
 
@@ -48,95 +51,76 @@ export class GithubPluginDeployerResolver implements PluginDeployerResolver {
     async resolve(pluginResolverContext: PluginDeployerResolverContext): Promise<void> {
 
         // download the file
-        return new Promise<void>((resolve, reject) => {
-            // extract data
-            const extracted = /^github:(.*)\/(.*)\/(.*)$/gm.exec(pluginResolverContext.getOriginId());
-            if (!extracted || extracted === null || extracted.length !== 4) {
-                reject(new Error('Invalid extension' + pluginResolverContext.getOriginId()));
-                return;
-            }
+        // extract data
+        const extracted = /^github:(.*)\/(.*)\/(.*)$/gm.exec(pluginResolverContext.getOriginId());
+        if (!extracted || extracted === null || extracted.length !== 4) {
+            throw new Error('Invalid extension' + pluginResolverContext.getOriginId());
+        }
 
-            const orgName = extracted[1];
-            const repoName = extracted[2];
-            const file = extracted[3];
-
-            // get version if any
-            const splitFile = file.split('@');
-            let version;
-            let filename: string;
-            if (splitFile.length === 1) {
-                filename = file;
-                version = 'latest';
-            } else {
-                filename = splitFile[0];
-                version = splitFile[1];
-            }
-            // latest version, need to get the redirect
-            const url = GithubPluginDeployerResolver.GITHUB_ENDPOINT + orgName + '/' + repoName + '/releases/latest';
+        const orgName = extracted[1];
+        const repoName = extracted[2];
+        const file = extracted[3];
+
+        // get version if any
+        const splitFile = file.split('@');
+        let version;
+        let filename: string;
+        if (splitFile.length === 1) {
+            filename = file;
+            version = 'latest';
+        } else {
+            filename = splitFile[0];
+            version = splitFile[1];
+        }
+        // latest version, need to get the redirect
+        const url = GithubPluginDeployerResolver.GITHUB_ENDPOINT + orgName + '/' + repoName + '/releases/latest';
 
+        // if latest, resolve first the real version
+        if (version === 'latest') {
             // disable redirect to grab the release
-            const options = {
-                followRedirect: false
-            };
-            // if latest, resolve first the real version
-            if (version === 'latest') {
-                request.get(url, options).on('response', response => {
-
-                    // should have a redirect
-                    if (response.statusCode === 302) {
-                        const redirectLocation = response.headers.location;
-                        if (!redirectLocation) {
-                            reject(new Error('Invalid github link with latest not being found'));
-                            return;
-                        }
-
-                        // parse redirect link
-                        const taggedValueArray = /^https:\/\/.*tag\/(.*)/gm.exec(redirectLocation);
-                        if (!taggedValueArray || taggedValueArray.length !== 2) {
-                            reject(new Error('The redirect link for latest is invalid ' + redirectLocation));
-                            return;
-                        }
-
-                        // grab version of tag
-                        this.grabGithubFile(pluginResolverContext, orgName, repoName, filename, taggedValueArray[1], resolve, reject);
-
-                    }
-                });
-            } else {
-                this.grabGithubFile(pluginResolverContext, orgName, repoName, filename, version, resolve, reject);
-            }
-
-        });
+            const followRedirects = 0;
+            const response = await this.request.request({ url, followRedirects });
+            // should have a redirect
+            if (response.res.statusCode === 302) {
+                const redirectLocation = response.res.headers.location;
+                if (!redirectLocation) {
+                    throw new Error('Invalid github link with latest not being found');
+                }
+
+                // parse redirect link
+                const taggedValueArray = /^https:\/\/.*tag\/(.*)/gm.exec(redirectLocation);
+                if (!taggedValueArray || taggedValueArray.length !== 2) {
+                    throw new Error('The redirect link for latest is invalid ' + redirectLocation);
+                }
+
+                // grab version of tag
+                return this.grabGithubFile(pluginResolverContext, orgName, repoName, filename, taggedValueArray[1]);
 
+            }
+        } else {
+            return this.grabGithubFile(pluginResolverContext, orgName, repoName, filename, version);
+        }
     }
 
     /*
      * Grab the github file specified by the plugin's ID
      */
-    protected grabGithubFile(pluginResolverContext: PluginDeployerResolverContext, orgName: string, repoName: string, filename: string, version: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        resolve: (value?: void | PromiseLike<void>) => void, reject: (reason?: any) => void): void {
-
+    protected async grabGithubFile(pluginResolverContext: PluginDeployerResolverContext, orgName: string, repoName: string, filename: string, version: string): Promise<void> {
         const unpackedPath = path.resolve(this.unpackedFolder, path.basename(version + filename));
-        const finish = () => {
-            pluginResolverContext.addPlugin(pluginResolverContext.getOriginId(), unpackedPath);
-            resolve();
-        };
-
-        // use of cache. If file is already there use it directly
-        if (fs.existsSync(unpackedPath)) {
-            finish();
+        try {
+            await fs.access(unpackedPath);
+            // use of cache. If file is already there use it directly
             return;
-        }
-        const dest = fs.createWriteStream(unpackedPath);
+        } catch { }
 
-        dest.addListener('finish', finish);
         const url = GithubPluginDeployerResolver.GITHUB_ENDPOINT + orgName + '/' + repoName + '/releases/download/' + version + '/' + filename;
-        request.get(url)
-            .on('error', err => {
-                reject(err);
-            }).pipe(dest);
-
+        const response = await this.request.request({ url });
+        if (RequestContext.isSuccess(response)) {
+            await fs.writeFile(unpackedPath, response.buffer);
+            pluginResolverContext.addPlugin(pluginResolverContext.getOriginId(), unpackedPath);
+        } else {
+            throw new Error(`Could not download the plugin from GitHub. URL: ${url}. HTTP status code: ${response.res.statusCode}`);
+        }
     }
 
     /**

package/src/main/node/plugin-http-resolver.ts

@@ -14,13 +14,12 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from '@theia/core/shared/inversify';
-import * as fs from 'fs';
+import { RequestContext, RequestService } from '@theia/core/shared/@theia/request';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { promises as fs, existsSync, mkdirSync } from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import * as url from 'url';
-import * as request from 'request';
-
 import { PluginDeployerResolver, PluginDeployerResolverContext } from '../../common';
 
 /**
@@ -33,10 +32,13 @@ export class HttpPluginDeployerResolver implements PluginDeployerResolver {
 
     private unpackedFolder: string;
 
+    @inject(RequestService)
+    protected readonly request: RequestService;
+
     constructor() {
         this.unpackedFolder = path.resolve(os.tmpdir(), 'http-remote');
-        if (!fs.existsSync(this.unpackedFolder)) {
-            fs.mkdirSync(this.unpackedFolder);
+        if (!existsSync(this.unpackedFolder)) {
+            mkdirSync(this.unpackedFolder);
         }
     }
 
@@ -46,39 +48,31 @@ export class HttpPluginDeployerResolver implements PluginDeployerResolver {
     async resolve(pluginResolverContext: PluginDeployerResolverContext): Promise<void> {
 
         // download the file
-        return new Promise<void>((resolve, reject) => {
-
-            // keep filename of the url
-            const urlPath = pluginResolverContext.getOriginId();
-            const link = url.parse(urlPath);
-            if (!link.pathname) {
-                reject(new Error('invalid link URI' + urlPath));
-                return;
-            }
-
-            const dirname = path.dirname(link.pathname);
-            const basename = path.basename(link.pathname);
-            const filename = dirname.replace(/\W/g, '_') + ('-') + basename;
-            const unpackedPath = path.resolve(this.unpackedFolder, path.basename(filename));
+        // keep filename of the url
+        const urlPath = pluginResolverContext.getOriginId();
+        const link = url.parse(urlPath);
+        if (!link.pathname) {
+            throw new Error('invalid link URI' + urlPath);
+        }
 
-            const finish = () => {
-                pluginResolverContext.addPlugin(pluginResolverContext.getOriginId(), unpackedPath);
-                resolve();
-            };
+        const dirname = path.dirname(link.pathname);
+        const basename = path.basename(link.pathname);
+        const filename = dirname.replace(/\W/g, '_') + ('-') + basename;
+        const unpackedPath = path.resolve(this.unpackedFolder, path.basename(filename));
 
+        try {
+            await fs.access(unpackedPath);
             // use of cache. If file is already there use it directly
-            if (fs.existsSync(unpackedPath)) {
-                finish();
-                return;
-            }
-            const dest = fs.createWriteStream(unpackedPath);
+            return;
+        } catch { }
 
-            dest.addListener('finish', finish);
-            request.get(pluginResolverContext.getOriginId())
-                .on('error', err => {
-                    reject(err);
-                }).pipe(dest);
-        });
+        const response = await this.request.request({ url: pluginResolverContext.getOriginId() });
+        if (RequestContext.isSuccess(response)) {
+            await fs.writeFile(unpackedPath, response.buffer);
+            pluginResolverContext.addPlugin(pluginResolverContext.getOriginId(), unpackedPath);
+        } else {
+            throw new Error(`Could not download the plugin from ${pluginResolverContext.getOriginId()}. HTTP status code: ${response.res.statusCode}`);
+        }
 
     }
 

package/src/main/node/plugins-key-value-storage.ts

@@ -62,7 +62,7 @@ export class PluginsKeyValueStorage {
 
         const data = await this.readFromFile(dataPath);
 
-        if (value === undefined || value === {}) {
+        if (value === undefined) {
             delete data[key];
         } else {
             data[key] = value;

package/src/plugin/comments.ts

@@ -18,10 +18,11 @@ import * as theia from '@theia/plugin';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { CommandRegistryImpl } from './command-registry';
 import { UriComponents } from '../common/uri-components';
-import { CommentThreadCollapsibleState, URI } from './types-impl';
+import { CommentThreadCollapsibleState, CommentThreadState, URI } from './types-impl';
 import {
     Range,
     Comment,
+    CommentThreadState as CommentThreadStateModel,
     CommentThreadCollapsibleState as CommentThreadCollapsibleStateModel,
     CommentOptions
 } from '../common/plugin-api-rpc-model';
@@ -185,6 +186,7 @@ type CommentThreadModification = Partial<{
     contextValue: string | undefined,
     comments: theia.Comment[],
     collapsibleState: theia.CommentThreadCollapsibleState
+    state: theia.CommentThreadState
     canReply: boolean;
 }>;
 
@@ -276,6 +278,20 @@ export class ExtHostCommentThread implements theia.CommentThread, theia.Disposab
         this._onDidUpdateCommentThread.fire();
     }
 
+    private _state?: theia.CommentThreadState;
+
+    get state(): theia.CommentThreadState {
+        return this._state!;
+    }
+
+    set state(newState: theia.CommentThreadState) {
+        if (this._state !== newState) {
+            this._state = newState;
+            this.modifications.state = newState;
+            this._onDidUpdateCommentThread.fire();
+        }
+    }
+
     private localDisposables: Disposable[];
 
     private _isDisposed: boolean;
@@ -357,6 +373,9 @@ export class ExtHostCommentThread implements theia.CommentThread, theia.Disposab
         if (modified('collapsibleState')) {
             formattedModifications.collapseState = convertToCollapsibleState(this.collapseState);
         }
+        if (modified('state')) {
+            formattedModifications.state = convertToState(this._state);
+        }
         if (modified('canReply')) {
             formattedModifications.canReply = this.canReply;
         }
@@ -516,3 +535,15 @@ function convertToCollapsibleState(kind: theia.CommentThreadCollapsibleState | u
     }
     return CommentThreadCollapsibleStateModel.Collapsed;
 }
+
+function convertToState(kind: theia.CommentThreadState | undefined): CommentThreadStateModel {
+    if (kind !== undefined) {
+        switch (kind) {
+            case CommentThreadState.Resolved:
+                return CommentThreadStateModel.Resolved;
+            case CommentThreadState.Unresolved:
+                return CommentThreadStateModel.Unresolved;
+        }
+    }
+    return CommentThreadStateModel.Unresolved;
+}

package/src/plugin/localization-ext.ts

@@ -0,0 +1,84 @@
+// *****************************************************************************
+// 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { nls } from '@theia/core';
+import { Localization } from '@theia/core/lib/common/i18n/localization';
+import { LocalizationExt, LocalizationMain, Plugin, PLUGIN_RPC_CONTEXT, StringDetails } from '../common';
+import { LanguagePackBundle } from '../common/language-pack-service';
+import { RPCProtocol } from '../common/rpc-protocol';
+import { URI } from './types-impl';
+
+export class LocalizationExtImpl implements LocalizationExt {
+
+    private readonly _proxy: LocalizationMain;
+    private currentLanguage?: string;
+    private isDefaultLanguage = true;
+    private readonly bundleCache = new Map<string, LanguagePackBundle | undefined>();
+
+    constructor(rpc: RPCProtocol) {
+        this._proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.LOCALIZATION_MAIN);
+    }
+
+    translateMessage(pluginId: string, details: StringDetails): string {
+        const { message, args, comment } = details;
+        if (this.isDefaultLanguage) {
+            return Localization.format(message, (args ?? {}));
+        }
+
+        let key = message;
+        if (comment && comment.length > 0) {
+            key += `/${Array.isArray(comment) ? comment.join() : comment}`;
+        }
+        const str = this.bundleCache.get(pluginId)?.contents[key];
+        return Localization.format(str ?? message, (args ?? {}));
+    }
+
+    getBundle(pluginId: string): { [key: string]: string } | undefined {
+        return this.bundleCache.get(pluginId)?.contents;
+    }
+
+    getBundleUri(pluginId: string): URI | undefined {
+        const uri = this.bundleCache.get(pluginId)?.uri;
+        return uri ? URI.parse(uri) : undefined;
+    }
+
+    async initializeLocalizedMessages(plugin: Plugin, currentLanguage: string): Promise<void> {
+        this.currentLanguage ??= currentLanguage;
+        this.isDefaultLanguage = this.currentLanguage === nls.defaultLocale;
+
+        if (this.isDefaultLanguage) {
+            return;
+        }
+
+        if (this.bundleCache.has(plugin.model.id)) {
+            return;
+        }
+
+        let bundle: LanguagePackBundle | undefined;
+
+        try {
+            bundle = await this._proxy.$fetchBundle(plugin.model.id);
+        } catch (e) {
+            console.error(`Failed to load translations for ${plugin.model.id}: ${e.message}`);
+            return;
+        }
+
+        this.bundleCache.set(plugin.model.id, bundle);
+    }
+
+}

package/src/plugin/output-channel/log-output-channel.ts

@@ -0,0 +1,108 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { Emitter } from '@theia/core/shared/vscode-languageserver-protocol';
+import * as theia from '@theia/plugin';
+
+import { OutputChannelRegistryMain, PluginInfo } from '../../common/plugin-api-rpc';
+import { OutputChannelImpl } from './output-channel-item';
+import { LogLevel } from '../types-impl';
+import { isArray, isObject } from '@theia/core';
+
+export class LogOutputChannelImpl extends OutputChannelImpl implements theia.LogOutputChannel {
+
+    readonly onDidChangeLogLevelEmitter: Emitter<theia.LogLevel> = new Emitter<theia.LogLevel>();
+    readonly onDidChangeLogLevel: theia.Event<theia.LogLevel> = this.onDidChangeLogLevelEmitter.event;
+    public logLevel: theia.LogLevel;
+
+    constructor(name: string, proxy: OutputChannelRegistryMain, pluginInfo: PluginInfo) {
+        super(name, proxy, pluginInfo);
+        this.setLogLevel(LogLevel.Info);
+    }
+
+    setLogLevel(level: theia.LogLevel): void {
+        if (this.logLevel !== level) {
+            this.logLevel = level;
+            this.onDidChangeLogLevelEmitter.fire(this.logLevel);
+        }
+    }
+
+    getLogLevel(): theia.LogLevel {
+        return this.logLevel;
+    }
+
+    override append(value: string): void {
+        super.validate();
+        this.info(value);
+    }
+
+    override appendLine(value: string): void {
+        super.validate();
+        this.append(value + '\n');
+    }
+
+    override dispose(): void {
+        super.dispose();
+        this.onDidChangeLogLevelEmitter.dispose();
+    }
+
+    protected log(level: theia.LogLevel, message: string): void {
+        super.validate();
+        if (this.checkLogLevel(level)) {
+            const now = new Date();
+            const eol = message.endsWith('\n') ? '' : '\n';
+            const logMessage = `${now.toISOString()} [${LogLevel[level]}] ${message}${eol}`;
+            this.proxy.$append(this.name, logMessage, this.pluginInfo);
+        }
+    }
+
+    private checkLogLevel(level: theia.LogLevel): boolean {
+        return this.logLevel <= level;
+    }
+
+    trace(message: string, ...args: any[]): void {
+        this.log(LogLevel.Trace, this.format(message, args));
+    }
+
+    debug(message: string, ...args: any[]): void {
+        this.log(LogLevel.Debug, this.format(message, args));
+    }
+
+    info(message: string, ...args: any[]): void {
+        this.log(LogLevel.Info, this.format(message, args));
+    }
+
+    warn(message: string, ...args: any[]): void {
+        this.log(LogLevel.Warning, this.format(message, args));
+    }
+
+    error(errorMsg: string | Error, ...args: any[]): void {
+        if (errorMsg instanceof Error) {
+            this.log(LogLevel.Error, this.format(errorMsg.stack || errorMsg.message, args));
+        } else {
+            this.log(LogLevel.Error, this.format(errorMsg, args));
+        }
+    }
+
+    private format(message: string, args: any[]): string {
+        if (args.length > 0) {
+            return `${message} ${args.map((arg: any) => isObject(arg) || isArray(arg) ? JSON.stringify(arg) : arg).join(' ')}`;
+        }
+        return message;
+    }
+
+}

package/src/plugin/output-channel/output-channel-item.ts

@@ -20,7 +20,7 @@ export class OutputChannelImpl implements theia.OutputChannel {
 
     private disposed: boolean;
 
-    constructor(readonly name: string, private proxy: OutputChannelRegistryMain, private readonly pluginInfo: PluginInfo) {
+    constructor(readonly name: string, protected readonly proxy: OutputChannelRegistryMain, protected readonly pluginInfo: PluginInfo) {
     }
 
     dispose(): void {
@@ -65,7 +65,7 @@ export class OutputChannelImpl implements theia.OutputChannel {
         this.proxy.$close(this.name);
     }
 
-    private validate(): void {
+    protected validate(): void {
         if (this.disposed) {
             throw new Error('Channel has been closed');
         }