@theia/plugin-ext 1.23.0-next.4 → 1.23.0-next.42

package/src/main/browser/workspace-main.ts

@@ -22,7 +22,7 @@ import { URI as Uri } from '@theia/core/shared/vscode-uri';
 import { UriComponents } from '../../common/uri-components';
 import { FileSearchService } from '@theia/file-search/lib/common/file-search-service';
 import URI from '@theia/core/lib/common/uri';
-import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { WorkspaceService, WorkspaceTrustService } from '@theia/workspace/lib/browser';
 import { Resource } from '@theia/core/lib/common/resource';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { Emitter, Event, ResourceResolver, CancellationToken } from '@theia/core';
@@ -52,6 +52,8 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
 
     private workspaceService: WorkspaceService;
 
+    private workspaceTrustService: WorkspaceTrustService;
+
     private fsPreferences: FileSystemPreferences;
 
     protected readonly toDispose = new DisposableCollection();
@@ -67,6 +69,7 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
         this.resourceResolver = container.get(TextContentResourceResolver);
         this.pluginServer = container.get(PluginServer);
         this.workspaceService = container.get(WorkspaceService);
+        this.workspaceTrustService = container.get(WorkspaceTrustService);
         this.fsPreferences = container.get(FileSystemPreferences);
 
         this.processWorkspaceFoldersChanged(this.workspaceService.tryGetRoots().map(root => root.resource.toString()));
@@ -76,6 +79,8 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
         this.toDispose.push(this.workspaceService.onWorkspaceLocationChanged(stat => {
             this.proxy.$onWorkspaceLocationChanged(stat);
         }));
+
+        this.workspaceTrustService.getWorkspaceTrust().then(trust => this.proxy.$onWorkspaceTrustChanged(trust));
     }
 
     dispose(): void {
@@ -269,6 +274,9 @@ export class WorkspaceMainImpl implements WorkspaceMain, Disposable {
         await this.workspaceService.spliceRoots(start, deleteCount, ...rootsToAdd.map(root => new URI(root)));
     }
 
+    async $requestWorkspaceTrust(_options?: theia.WorkspaceTrustRequestOptions): Promise<boolean | undefined> {
+        return this.workspaceTrustService.requestWorkspaceTrust();
+    }
 }
 
 /**

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

@@ -23,7 +23,7 @@ import { CustomEditorWidget } from '../../browser/custom-editors/custom-editor-w
 
 export class ElectronWebviewWidgetFactory extends WebviewWidgetFactory {
 
-    async createWidget(identifier: WebviewWidgetIdentifier): Promise<WebviewWidget> {
+    override async createWidget(identifier: WebviewWidgetIdentifier): Promise<WebviewWidget> {
         const widget = await super.createWidget(identifier);
         await this.attachElectronSecurityCookie(widget.externalEndpoint);
         return widget;
@@ -35,7 +35,7 @@ export class ElectronWebviewWidgetFactory extends WebviewWidgetFactory {
      * @param endpoint cookie's target url
      */
     protected async attachElectronSecurityCookie(endpoint: string): Promise<void> {
-        await electronRemote.session.defaultSession!.cookies.set({
+        await electronRemote.session.defaultSession.cookies.set({
             url: endpoint,
             name: ElectronSecurityToken,
             value: JSON.stringify(this.container.get(ElectronSecurityToken)),
@@ -47,7 +47,7 @@ export class ElectronWebviewWidgetFactory extends WebviewWidgetFactory {
 
 export class ElectronCustomEditorWidgetFactory extends CustomEditorWidgetFactory {
 
-    async createWidget(identifier: WebviewWidgetIdentifier): Promise<CustomEditorWidget> {
+    override async createWidget(identifier: WebviewWidgetIdentifier): Promise<CustomEditorWidget> {
         const widget = await super.createWidget(identifier);
         await this.attachElectronSecurityCookie(widget.externalEndpoint);
         return widget;
@@ -59,7 +59,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({
+        await electronRemote.session.defaultSession.cookies.set({
             url: endpoint,
             name: ElectronSecurityToken,
             value: JSON.stringify(this.container.get(ElectronSecurityToken)),

package/src/main/node/paths/plugin-paths-service.ts

@@ -142,7 +142,7 @@ export class PluginPathsServiceImpl implements PluginPathsService {
 
     private async cleanupOldLogs(parentLogsDir: string): Promise<void> {
         // @ts-ignore - fs-extra types (Even latest version) is not updated with the `withFileTypes` option.
-        const dirEntries = await readdir(parentLogsDir, { withFileTypes: true });
+        const dirEntries = await readdir(parentLogsDir, { withFileTypes: true }) as string[];
         // `Dirent` type is defined in @types/node since 10.10.0
         // However, upgrading the @types/node in theia to 10.11 (as defined in engine field)
         // Causes other packages to break in compilation, so we are using the infamous `any` type...

package/src/main/node/plugin-deployer-impl.ts

@@ -33,7 +33,7 @@ import { PluginDeployerFileHandlerContextImpl } from './plugin-deployer-file-han
 import { PluginDeployerDirectoryHandlerContextImpl } from './plugin-deployer-directory-handler-context-impl';
 import { ILogger, Emitter, ContributionProvider } from '@theia/core';
 import { PluginCliContribution } from './plugin-cli-contribution';
-import { performance } from 'perf_hooks';
+import { Measurement, Stopwatch } from '@theia/core/lib/common';
 
 @injectable()
 export class PluginDeployerImpl implements PluginDeployer {
@@ -50,6 +50,9 @@ export class PluginDeployerImpl implements PluginDeployer {
     @inject(PluginCliContribution)
     protected readonly cliContribution: PluginCliContribution;
 
+    @inject(Stopwatch)
+    protected readonly stopwatch: Stopwatch;
+
     /**
      * Inject all plugin resolvers found at runtime.
      */
@@ -117,7 +120,7 @@ export class PluginDeployerImpl implements PluginDeployer {
             }
         }
 
-        const startDeployTime = performance.now();
+        const deployPlugins = this.measure('deployPlugins');
         const unresolvedUserEntries = context.userEntries.map(id => ({
             id,
             type: PluginType.User
@@ -127,8 +130,9 @@ export class PluginDeployerImpl implements PluginDeployer {
             type: PluginType.System
         }));
         const plugins = await this.resolvePlugins([...unresolvedUserEntries, ...unresolvedSystemEntries]);
+        deployPlugins.log('Resolve plugins list');
         await this.deployPlugins(plugins);
-        this.logMeasurement('Deploy plugins list', startDeployTime);
+        deployPlugins.log('Deploy plugins list');
     }
 
     async undeploy(pluginId: string): Promise<void> {
@@ -138,9 +142,9 @@ export class PluginDeployerImpl implements PluginDeployer {
     }
 
     async deploy(plugin: UnresolvedPluginEntry): Promise<void> {
-        const startDeployTime = performance.now();
+        const deploy = this.measure('deploy');
         await this.deployMultipleEntries([plugin]);
-        this.logMeasurement('Deploy plugin entry', startDeployTime);
+        deploy.log(`Deploy plugin ${plugin}`);
     }
 
     protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[]): Promise<void> {
@@ -310,7 +314,7 @@ export class PluginDeployerImpl implements PluginDeployer {
         return pluginDeployerEntries;
     }
 
-    protected logMeasurement(prefix: string, startTime: number): void {
-        console.log(`${prefix} took: ${(performance.now() - startTime).toFixed(1)} ms`);
+    protected measure(name: string): Measurement {
+        return this.stopwatch.start(name);
     }
 }

package/src/plugin/authentication-ext.ts

@@ -28,8 +28,7 @@ import {
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { Emitter, Event } from '@theia/core/lib/common/event';
-import * as theia from '@theia/plugin';
-import { AuthenticationSession, AuthenticationSessionsChangeEvent } from '../common/plugin-api-rpc-model';
+import * as theia from '@theia/plugin/';
 
 export class AuthenticationExtImpl implements AuthenticationExt {
     private proxy: AuthenticationMain;
@@ -61,82 +60,88 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         return Object.freeze(this._providers.slice());
     }
 
-    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: string[],
-                     options: theia.AuthenticationGetSessionOptions & { createIfNone: true }): Promise<theia.AuthenticationSession>;
-    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: string[],
-                     options: theia.AuthenticationGetSessionOptions = {}): Promise<theia.AuthenticationSession | undefined> {
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions & ({ createIfNone: true } | { forceNewSession: true } | { forceNewSession: { detail: string } })):
+        Promise<theia.AuthenticationSession>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions & { forceNewSession: true }): Promise<theia.AuthenticationSession>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions & { forceNewSession: { detail: string } }): Promise<theia.AuthenticationSession>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions): Promise<theia.AuthenticationSession | undefined>;
+    async getSession(requestingExtension: InternalPlugin, providerId: string, scopes: readonly string[],
+        options: theia.AuthenticationGetSessionOptions = {}): Promise<theia.AuthenticationSession | undefined> {
         const extensionName = requestingExtension.model.displayName || requestingExtension.model.name;
         const extensionId = requestingExtension.model.id.toLowerCase();
-
         return this.proxy.$getSession(providerId, scopes, extensionId, extensionName, options);
     }
 
     async logout(providerId: string, sessionId: string): Promise<void> {
-        return this.proxy.$logout(providerId, sessionId);
+        return this.proxy.$removeSession(providerId, sessionId);
     }
 
-    registerAuthenticationProvider(provider: theia.AuthenticationProvider): theia.Disposable {
-        if (this.authenticationProviders.get(provider.id)) {
-            throw new Error(`An authentication provider with id '${provider.id}' is already registered.`);
+    registerAuthenticationProvider(id: string, label: string, provider: theia.AuthenticationProvider, options?: theia.AuthenticationProviderOptions): theia.Disposable {
+        if (this.authenticationProviders.get(id)) {
+            throw new Error(`An authentication provider with id '${id}' is already registered.`);
         }
 
-        this.authenticationProviders.set(provider.id, provider);
-        if (this._providerIds.indexOf(provider.id) === -1) {
-            this._providerIds.push(provider.id);
+        this.authenticationProviders.set(id, provider);
+        if (this._providerIds.indexOf(id) === -1) {
+            this._providerIds.push(id);
         }
 
-        if (!this._providers.find(p => p.id === provider.id)) {
+        if (!this._providers.find(p => p.id === id)) {
             this._providers.push({
-                id: provider.id,
-                label: provider.label
+                id,
+                label
             });
         }
 
         const listener = provider.onDidChangeSessions(e => {
-            this.proxy.$updateSessions(provider.id, e);
+            this.proxy.$sendDidChangeSessions(id, e);
         });
 
-        this.proxy.$registerAuthenticationProvider(provider.id, provider.label, provider.supportsMultipleAccounts);
+        this.proxy.$registerAuthenticationProvider(id, label, !!options?.supportsMultipleAccounts);
 
         return new Disposable(() => {
             listener.dispose();
-            this.authenticationProviders.delete(provider.id);
-            const index = this._providerIds.findIndex(id => id === provider.id);
+            this.authenticationProviders.delete(id);
+            const index = this._providerIds.findIndex(pid => id === pid);
             if (index > -1) {
                 this._providerIds.splice(index);
             }
 
-            const i = this._providers.findIndex(p => p.id === provider.id);
+            const i = this._providers.findIndex(p => p.id === id);
             if (i > -1) {
                 this._providers.splice(i);
             }
 
-            this.proxy.$unregisterAuthenticationProvider(provider.id);
+            this.proxy.$unregisterAuthenticationProvider(id);
         });
     }
 
-    $login(providerId: string, scopes: string[]): Promise<AuthenticationSession> {
+    $createSession(providerId: string, scopes: string[]): Promise<theia.AuthenticationSession> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            return Promise.resolve(authProvider.login(scopes));
+            return Promise.resolve(authProvider.createSession(scopes));
         }
 
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    $logout(providerId: string, sessionId: string): Promise<void> {
+    $removeSession(providerId: string, sessionId: string): Promise<void> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            return Promise.resolve(authProvider.logout(sessionId));
+            return Promise.resolve(authProvider.removeSession(sessionId));
         }
 
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    async $getSessions(providerId: string): Promise<ReadonlyArray<AuthenticationSession>> {
+    async $getSessions(providerId: string, scopes?: string[]): Promise<ReadonlyArray<theia.AuthenticationSession>> {
         const authProvider = this.authenticationProviders.get(providerId);
         if (authProvider) {
-            const sessions = await authProvider.getSessions();
+            const sessions = await authProvider.getSessions(scopes);
 
             /* Wrap the session object received from the plugin to prevent serialization mismatches
             e.g. if the plugin object is constructed with the help of getters they won't be serialized:
@@ -158,12 +163,12 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         throw new Error(`Unable to find authentication provider with handle: ${providerId}`);
     }
 
-    $onDidChangeAuthenticationSessions(id: string, label: string, event: AuthenticationSessionsChangeEvent): Promise<void> {
-        this.onDidChangeSessionsEmitter.fire({ provider: { id, label }, ...event });
+    $onDidChangeAuthenticationSessions(id: string, label: string): Promise<void> {
+        this.onDidChangeSessionsEmitter.fire({ provider: { id, label } });
         return Promise.resolve();
     }
 
-   async $onDidChangeAuthenticationProviders(added: theia.AuthenticationProviderInformation[], removed: theia.AuthenticationProviderInformation[]): Promise<void> {
+    async $onDidChangeAuthenticationProviders(added: theia.AuthenticationProviderInformation[], removed: theia.AuthenticationProviderInformation[]): Promise<void> {
         added.forEach(id => {
             if (this._providers.indexOf(id) === -1) {
                 this._providers.push(id);
@@ -179,4 +184,9 @@ export class AuthenticationExtImpl implements AuthenticationExt {
 
         this.onDidChangeAuthenticationProvidersEmitter.fire({ added, removed });
     }
+
+    $setProviders(providers: theia.AuthenticationProviderInformation[]): Promise<void> {
+        this._providers.push(...providers);
+        return Promise.resolve(undefined);
+    }
 }

package/src/plugin/languages/code-action.ts

@@ -16,7 +16,7 @@
 
 import * as theia from '@theia/plugin';
 import { URI } from '@theia/core/shared/vscode-uri';
-import { Selection } from '../../common/plugin-api-rpc';
+import { Selection, WorkspaceEditDto } from '../../common/plugin-api-rpc';
 import { Range, CodeActionContext, CodeAction } from '../../common/plugin-api-rpc-model';
 import * as Converter from '../type-converters';
 import { DocumentsExtImpl } from '../documents';
@@ -35,6 +35,11 @@ export class CodeActionAdapter {
         private readonly commands: CommandRegistryImpl
     ) { }
 
+    private readonly cache = new Map<number, theia.CodeAction | theia.Command>();
+    private readonly disposables = new Map<number, DisposableCollection>();
+
+    private cacheId = 0;
+
     async provideCodeAction(resource: URI, rangeOrSelection: Range | Selection,
         context: CodeActionContext, token: theia.CancellationToken): Promise<CodeAction[] | undefined> {
         const document = this.document.getDocumentData(resource);
@@ -64,15 +69,21 @@ export class CodeActionAdapter {
         if (!Array.isArray(commandsOrActions) || commandsOrActions.length === 0) {
             return undefined;
         }
-        // TODO cache toDispose and dispose it
-        const toDispose = new DisposableCollection();
         const result: CodeAction[] = [];
         for (const candidate of commandsOrActions) {
             if (!candidate) {
                 continue;
             }
+
+            // Cache candidates and created commands.
+            const nextCacheId = this.nextCacheId();
+            const toDispose = new DisposableCollection();
+            this.cache.set(nextCacheId, candidate);
+            this.disposables.set(nextCacheId, toDispose);
+
             if (CodeActionAdapter._isCommand(candidate)) {
                 result.push({
+                    cacheId: nextCacheId,
                     title: candidate.title || '',
                     command: this.commands.converter.toSafeCommand(candidate, toDispose)
                 });
@@ -88,6 +99,7 @@ export class CodeActionAdapter {
                 }
 
                 result.push({
+                    cacheId: nextCacheId,
                     title: candidate.title,
                     command: this.commands.converter.toSafeCommand(candidate.command, toDispose),
                     diagnostics: candidate.diagnostics && candidate.diagnostics.map(Converter.convertDiagnosticToMarkerData),
@@ -100,6 +112,37 @@ export class CodeActionAdapter {
         return result;
     }
 
+    async releaseCodeActions(cacheIds: number[]): Promise<void> {
+        cacheIds.forEach(id => {
+            this.cache.delete(id);
+            const toDispose = this.disposables.get(id);
+            if (toDispose) {
+                toDispose.dispose();
+                this.disposables.delete(id);
+            }
+        });
+    }
+
+    async resolveCodeAction(cacheId: number, token: theia.CancellationToken): Promise<WorkspaceEditDto | undefined> {
+        if (!this.provider.resolveCodeAction) {
+            return undefined;
+        }
+
+        // Code actions are only resolved if they are not legacy commands and don't have an edit property
+        // https://code.visualstudio.com/api/references/vscode-api#CodeActionProvider
+        const candidate = this.cache.get(cacheId);
+        if (!candidate || CodeActionAdapter._isCommand(candidate) || candidate.edit) {
+            return undefined;
+        }
+
+        const resolved = await this.provider.resolveCodeAction(candidate, token);
+        return resolved?.edit && Converter.fromWorkspaceEdit(resolved.edit);
+    }
+
+    private nextCacheId(): number {
+        return this.cacheId++;
+    }
+
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     private static _isCommand(smth: any): smth is theia.Command {
         return typeof (<theia.Command>smth).command === 'string';

package/src/plugin/languages.ts

@@ -463,6 +463,15 @@ export class LanguagesExtImpl implements LanguagesExt {
     ): Promise<CodeAction[] | undefined> {
         return this.withAdapter(handle, CodeActionAdapter, adapter => adapter.provideCodeAction(URI.revive(resource), rangeOrSelection, context, token), undefined);
     }
+
+    $releaseCodeActions(handle: number, cacheIds: number[]): void {
+        this.withAdapter(handle, CodeActionAdapter, adapter => adapter.releaseCodeActions(cacheIds), undefined);
+    }
+
+    $resolveCodeAction(handle: number, cacheId: number, token: theia.CancellationToken): Promise<WorkspaceEditDto | undefined> {
+        return this.withAdapter(handle, CodeActionAdapter, adapter => adapter.resolveCodeAction(cacheId, token), undefined);
+    };
+
     // ### Code Actions Provider end
 
     // ### Code Lens Provider begin

package/src/plugin/node/debug/plugin-debug-adapter-session.ts

@@ -30,7 +30,7 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
     readonly configuration: theia.DebugConfiguration;
 
     constructor(
-        readonly debugAdapter: DebugAdapter,
+        override readonly debugAdapter: DebugAdapter,
         protected readonly tracker: theia.DebugAdapterTracker,
         protected readonly theiaSession: theia.DebugSession) {
 
@@ -41,14 +41,14 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
         this.configuration = theiaSession.configuration;
     }
 
-    async start(channel: Channel): Promise<void> {
+    override async start(channel: Channel): Promise<void> {
         if (this.tracker.onWillStartSession) {
             this.tracker.onWillStartSession();
         }
         await super.start(channel);
     }
 
-    async stop(): Promise<void> {
+    override async stop(): Promise<void> {
         if (this.tracker.onWillStopSession) {
             this.tracker.onWillStopSession();
         }
@@ -59,14 +59,14 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
         return this.theiaSession.customRequest(command, args);
     }
 
-    protected onDebugAdapterError(error: Error): void {
+    protected override onDebugAdapterError(error: Error): void {
         if (this.tracker.onError) {
             this.tracker.onError(error);
         }
         super.onDebugAdapterError(error);
     }
 
-    protected send(message: string): void {
+    protected override send(message: string): void {
         try {
             super.send(message);
         } finally {
@@ -76,14 +76,14 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
         }
     }
 
-    protected write(message: string): void {
+    protected override write(message: string): void {
         if (this.tracker.onWillReceiveMessage) {
             this.tracker.onWillReceiveMessage(JSON.parse(message));
         }
         super.write(message);
     }
 
-    protected onDebugAdapterExit(): void {
+    protected override onDebugAdapterExit(): void {
         if (this.tracker.onExit) {
             this.tracker.onExit(undefined, undefined);
         }

package/src/plugin/node/debug/plugin-debug-adapter-starter.ts

@@ -18,7 +18,7 @@ import * as net from 'net';
 import { ChildProcess, spawn, fork, ForkOptions } from 'child_process';
 import { DebugAdapter } from '@theia/debug/lib/node/debug-model';
 import { DebugAdapterExecutable, DebugAdapterInlineImplementation, DebugAdapterNamedPipeServer, DebugAdapterServer } from '../../types-impl';
-import { InlineDebugAdapter } from '@theia/debug/lib/node/inline-debug-adapter';
+import { InlineDebugAdapter } from './plugin-inline-debug-adapter';
 import { ProcessDebugAdapter, SocketDebugAdapter } from '@theia/debug/lib/node/stream-debug-adapter';
 const isElectron = require('is-electron');
 

package/src/plugin/node/debug/plugin-inline-debug-adapter.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * Copyright (C) 2021 Red Hat, Inc. 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
+ ********************************************************************************/
+
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import { DebugAdapter } from '@theia/debug/lib/node/debug-model';
+import * as theia from '@theia/plugin';
+
+/**
+ * A debug adapter for using the inline implementation from a plugin.
+ */
+export class InlineDebugAdapter implements DebugAdapter {
+    private messageReceivedEmitter = new Emitter<string>();
+    onMessageReceived: Event<string> = this.messageReceivedEmitter.event;
+    onError: Event<Error> = Event.None;
+    private closeEmitter = new Emitter<void>();
+    onClose: Event<void> = this.closeEmitter.event;
+
+    constructor(private debugAdapter: theia.DebugAdapter) {
+        this.debugAdapter.onDidSendMessage(msg => {
+            this.messageReceivedEmitter.fire(JSON.stringify(msg));
+        });
+    }
+
+    async start(): Promise<void> {
+    }
+
+    send(message: string): void {
+        this.debugAdapter.handleMessage(JSON.parse(message));
+    }
+
+    async stop(): Promise<void> {
+        this.debugAdapter.dispose();
+    }
+}

package/src/plugin/node/env-node-ext.ts

@@ -43,7 +43,7 @@ export class EnvNodeExtImpl extends EnvExtImpl {
     /**
      * override machineID
      */
-    get machineId(): string {
+    override get machineId(): string {
         return this.macMachineId;
     }