@theia/plugin-ext 1.45.0 → 1.46.0

package/src/main/common/basic-notification-main.ts

@@ -0,0 +1,86 @@
+// *****************************************************************************
+// Copyright (C) 2018 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { NotificationExt, NotificationMain } from '../../common';
+import { ProgressService, Progress, ProgressMessage } from '@theia/core/lib/common';
+import { interfaces } from '@theia/core/shared/inversify';
+import { ProxyIdentifier, RPCProtocol } from '../../common/rpc-protocol';
+import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+
+export class BasicNotificationMainImpl implements NotificationMain, Disposable {
+    protected readonly progressService: ProgressService;
+    protected readonly progressMap = new Map<string, Progress>();
+    protected readonly progress2Work = new Map<string, number>();
+    protected readonly proxy: NotificationExt;
+
+    protected readonly toDispose = new DisposableCollection(
+        Disposable.create(() => { /* mark as not disposed */ })
+    );
+
+    constructor(rpc: RPCProtocol, container: interfaces.Container, extIdentifier: ProxyIdentifier<NotificationExt>) {
+        this.progressService = container.get(ProgressService);
+        this.proxy = rpc.getProxy(extIdentifier);
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    async $startProgress(options: NotificationMain.StartProgressOptions): Promise<string> {
+        const onDidCancel = () => {
+            // If the map does not contain current id, it has already stopped and should not be cancelled
+            if (this.progressMap.has(id)) {
+                this.proxy.$acceptProgressCanceled(id);
+            }
+        };
+
+        const progressMessage = this.mapOptions(options);
+        const progress = await this.progressService.showProgress(progressMessage, onDidCancel);
+        const id = progress.id;
+        this.progressMap.set(id, progress);
+        this.progress2Work.set(id, 0);
+        if (this.toDispose.disposed) {
+            this.$stopProgress(id);
+        } else {
+            this.toDispose.push(Disposable.create(() => this.$stopProgress(id)));
+        }
+        return id;
+    }
+    protected mapOptions(options: NotificationMain.StartProgressOptions): ProgressMessage {
+        const { title, location, cancellable } = options;
+        return { text: title, options: { location, cancelable: cancellable } };
+    }
+
+    $stopProgress(id: string): void {
+        const progress = this.progressMap.get(id);
+
+        if (progress) {
+            this.progressMap.delete(id);
+            this.progress2Work.delete(id);
+            progress.cancel();
+        }
+    }
+
+    $updateProgress(id: string, item: NotificationMain.ProgressReport): void {
+        const progress = this.progressMap.get(id);
+        if (!progress) {
+            return;
+        }
+        const done = Math.min((this.progress2Work.get(id) || 0) + (item.increment || 0), 100);
+        this.progress2Work.set(id, done);
+        progress.report({ message: item.message, work: done ? { done, total: 100 } : undefined });
+    }
+}

package/src/main/common/env-main.ts

@@ -0,0 +1,44 @@
+// *****************************************************************************
+// Copyright (C) 2018 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { interfaces } from '@theia/core/shared/inversify';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { RPCProtocol } from '../../common/rpc-protocol';
+import { EnvMain } from '../../common/plugin-api-rpc';
+import { isWindows, isOSX } from '@theia/core';
+import { OperatingSystem } from '../../plugin/types-impl';
+
+export class EnvMainImpl implements EnvMain {
+    private envVariableServer: EnvVariablesServer;
+
+    constructor(rpc: RPCProtocol, container: interfaces.Container) {
+        this.envVariableServer = container.get(EnvVariablesServer);
+    }
+
+    $getEnvVariable(envVarName: string): Promise<string | undefined> {
+        return this.envVariableServer.getValue(envVarName).then(result => result ? result.value : undefined);
+    }
+
+    async $getClientOperatingSystem(): Promise<OperatingSystem> {
+        if (isWindows) {
+            return OperatingSystem.Windows;
+        }
+        if (isOSX) {
+            return OperatingSystem.OSX;
+        }
+        return OperatingSystem.Linux;
+    }
+}

package/src/main/node/handlers/plugin-theia-directory-handler.ts

@@ -28,7 +28,7 @@ import { PluginCliContribution } from '../plugin-cli-contribution';
 import { getTempDirPathAsync } from '../temp-dir-util';
 
 @injectable()
-export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandler {
+export abstract class AbstractPluginDirectoryHandler implements PluginDeployerDirectoryHandler {
 
     protected readonly deploymentDirectory: Deferred<URI>;
 
@@ -42,15 +42,20 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
 
     async accept(resolvedPlugin: PluginDeployerEntry): Promise<boolean> {
 
-        console.debug('PluginTheiaDirectoryHandler: accepting plugin with path', resolvedPlugin.path());
+        console.debug(`Plugin directory handler: accepting plugin with path ${resolvedPlugin.path()}`);
 
         // handle only directories
         if (await resolvedPlugin.isFile()) {
             return false;
         }
 
+        // Was this directory unpacked from an NPM tarball?
+        const wasTarball = resolvedPlugin.originalPath().endsWith('.tgz');
+        const rootPath = resolvedPlugin.path();
+        const basePath = wasTarball ? path.resolve(rootPath, 'package') : rootPath;
+
         // is there a package.json ?
-        const packageJsonPath = path.resolve(resolvedPlugin.path(), 'package.json');
+        const packageJsonPath = path.resolve(basePath, 'package.json');
 
         try {
             let packageJson = resolvedPlugin.getValue<PluginPackage>('package.json');
@@ -60,26 +65,20 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
                 resolvedPlugin.storeValue('package.json', packageJson);
             }
 
-            if (packageJson?.engines?.theiaPlugin) {
+            if (this.acceptManifest(packageJson)) {
+                if (wasTarball) {
+                    resolvedPlugin.updatePath(basePath);
+                    resolvedPlugin.rootPath = rootPath;
+                }
                 return true;
             }
         } catch { /* Failed to read file. Fall through. */ }
         return false;
     }
 
-    async handle(context: PluginDeployerDirectoryHandlerContext): Promise<void> {
-        await this.copyDirectory(context);
-        const types: PluginDeployerEntryType[] = [];
-        const packageJson = context.pluginEntry().getValue<PluginPackage>('package.json');
-        if (packageJson.theiaPlugin && packageJson.theiaPlugin.backend) {
-            types.push(PluginDeployerEntryType.BACKEND);
-        }
-        if (packageJson.theiaPlugin && packageJson.theiaPlugin.frontend) {
-            types.push(PluginDeployerEntryType.FRONTEND);
-        }
+    protected abstract acceptManifest(plugin: PluginPackage): boolean;
 
-        context.pluginEntry().accept(...types);
-    }
+    abstract handle(context: PluginDeployerDirectoryHandlerContext): Promise<void>;
 
     protected async copyDirectory(context: PluginDeployerDirectoryHandlerContext): Promise<void> {
         if (this.pluginCli.copyUncompressedPlugins() && context.pluginEntry().type === PluginType.User) {
@@ -112,4 +111,27 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
         const deploymentDirectory = await this.deploymentDirectory.promise;
         return FileUri.fsPath(deploymentDirectory.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
     }
+
+}
+
+@injectable()
+export class PluginTheiaDirectoryHandler extends AbstractPluginDirectoryHandler {
+
+    protected acceptManifest(plugin: PluginPackage): boolean {
+        return plugin?.engines?.theiaPlugin !== undefined;
+    }
+
+    async handle(context: PluginDeployerDirectoryHandlerContext): Promise<void> {
+        await this.copyDirectory(context);
+        const types: PluginDeployerEntryType[] = [];
+        const packageJson = context.pluginEntry().getValue<PluginPackage>('package.json');
+        if (packageJson.theiaPlugin && packageJson.theiaPlugin.backend) {
+            types.push(PluginDeployerEntryType.BACKEND);
+        }
+        if (packageJson.theiaPlugin && packageJson.theiaPlugin.frontend) {
+            types.push(PluginDeployerEntryType.FRONTEND);
+        }
+
+        context.pluginEntry().accept(...types);
+    }
 }

package/src/main/node/handlers/plugin-theia-file-handler.ts

@@ -21,7 +21,7 @@ import { Deferred } from '@theia/core/lib/common/promise-util';
 import { getTempDirPathAsync } from '../temp-dir-util';
 import * as fs from '@theia/core/shared/fs-extra';
 import * as filenamify from 'filenamify';
-import { FileUri } from '@theia/core/lib/node/file-uri';
+import { FileUri } from '@theia/core/lib/common/file-uri';
 import { PluginTheiaEnvironment } from '../../common/plugin-theia-environment';
 
 @injectable()

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

@@ -271,20 +271,24 @@ export class PluginDeployerImpl implements PluginDeployer {
         const acceptedPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted());
         const acceptedFrontendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.FRONTEND));
         const acceptedBackendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.BACKEND));
+        const acceptedHeadlessPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.HEADLESS));
 
         this.logger.debug('the accepted plugins are', acceptedPlugins);
         this.logger.debug('the acceptedFrontendPlugins plugins are', acceptedFrontendPlugins);
         this.logger.debug('the acceptedBackendPlugins plugins are', acceptedBackendPlugins);
+        this.logger.debug('the acceptedHeadlessPlugins plugins are', acceptedHeadlessPlugins);
 
         acceptedPlugins.forEach(plugin => {
             this.logger.debug('will deploy plugin', plugin.id(), 'with changes', JSON.stringify(plugin.getChanges()), 'and this plugin has been resolved by', plugin.resolvedBy());
         });
 
         // local path to launch
-        const pluginPaths = acceptedBackendPlugins.map(pluginEntry => pluginEntry.path());
+        const pluginPaths = [...acceptedBackendPlugins, ...acceptedHeadlessPlugins].map(pluginEntry => pluginEntry.path());
         this.logger.debug('local path to deploy on remote instance', pluginPaths);
 
         const deployments = await Promise.all([
+            // headless plugins are deployed like backend plugins
+            this.pluginDeployerHandler.deployBackendPlugins(acceptedHeadlessPlugins),
             // start the backend plugins
             this.pluginDeployerHandler.deployBackendPlugins(acceptedBackendPlugins),
             this.pluginDeployerHandler.deployFrontendPlugins(acceptedFrontendPlugins)

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

@@ -18,7 +18,7 @@ import { injectable, inject, postConstruct } from '@theia/core/shared/inversify'
 import { FileSystemLocking } from '@theia/core/lib/node';
 import * as fs from '@theia/core/shared/fs-extra';
 import * as path from 'path';
-import { FileUri } from '@theia/core/lib/node/file-uri';
+import { FileUri } from '@theia/core/lib/common/file-uri';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { PluginPaths } from './paths/const';

package/src/plugin/clipboard-ext.ts

@@ -15,15 +15,21 @@
 // *****************************************************************************
 
 import * as theia from '@theia/plugin';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { PLUGIN_RPC_CONTEXT, ClipboardMain } from '../common';
 
+@injectable()
 export class ClipboardExt implements theia.Clipboard {
 
-    protected readonly proxy: ClipboardMain;
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.CLIPBOARD_MAIN);
+    protected proxy: ClipboardMain;
+
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.CLIPBOARD_MAIN);
     }
 
     readText(): Promise<string> {

package/src/plugin/debug/debug-ext.ts

@@ -13,6 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { Emitter } from '@theia/core/lib/common/event';
 import { Path } from '@theia/core/lib/common/path';
 import * as theia from '@theia/plugin';
@@ -43,7 +44,11 @@ interface ConfigurationProviderRecord {
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+@injectable()
 export class DebugExtImpl implements DebugExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
+
     // debug sessions by sessionId
     private sessions = new Map<string, PluginDebugAdapterSession>();
     private configurationProviderHandleGenerator: number;
@@ -83,8 +88,7 @@ export class DebugExtImpl implements DebugExt {
         return [...this._breakpoints.values()];
     }
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(Ext.DEBUG_MAIN);
+    constructor() {
         this.activeDebugConsole = {
             append: (value: string) => this.proxy.$appendToDebugConsole(value),
             appendLine: (value: string) => this.proxy.$appendLineToDebugConsole(value)
@@ -93,6 +97,11 @@ export class DebugExtImpl implements DebugExt {
         this.configurationProviders = [];
     }
 
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(Ext.DEBUG_MAIN);
+    }
+
     /**
      * Sets dependencies.
      */

package/src/plugin/documents.ts

@@ -158,7 +158,7 @@ export class DocumentsExtImpl implements DocumentsExt {
         const uriString = uri.toString();
         const data = this.editorsAndDocuments.getDocument(uriString);
         if (!data) {
-            throw new Error('unknown document');
+            throw new Error('unknown document: ' + uriString);
         }
         data.acceptIsDirty(isDirty);
         this._onDidChangeDocument.fire({
@@ -172,7 +172,7 @@ export class DocumentsExtImpl implements DocumentsExt {
         const uriString = uri.toString();
         const data = this.editorsAndDocuments.getDocument(uriString);
         if (!data) {
-            throw new Error('unknown document');
+            throw new Error('unknown document: ' + uriString);
         }
         data.acceptIsDirty(isDirty);
         data.onEvents(e);

package/src/plugin/editors-and-documents.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { inject, injectable } from '@theia/core/shared/inversify';
 import { EditorsAndDocumentsExt, EditorsAndDocumentsDelta, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
 import { TextEditorExt } from './text-editor';
 import { RPCProtocol } from '../common/rpc-protocol';
@@ -24,7 +25,11 @@ import * as Converter from './type-converters';
 import { dispose } from '../common/disposable-util';
 import { URI } from './types-impl';
 
+@injectable()
 export class EditorsAndDocumentsExtImpl implements EditorsAndDocumentsExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
+
     private activeEditorId: string | null = null;
 
     private readonly _onDidAddDocuments = new Emitter<DocumentDataExt[]>();
@@ -40,9 +45,6 @@ export class EditorsAndDocumentsExtImpl implements EditorsAndDocumentsExt {
     private readonly documents = new Map<string, DocumentDataExt>();
     private readonly editors = new Map<string, TextEditorExt>();
 
-    constructor(private readonly rpc: RPCProtocol) {
-    }
-
     async $acceptEditorsAndDocumentsDelta(delta: EditorsAndDocumentsDelta): Promise<void> {
         const removedDocuments = new Array<DocumentDataExt>();
         const addedDocuments = new Array<DocumentDataExt>();

package/src/plugin/env.ts

@@ -14,13 +14,18 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import * as theia from '@theia/plugin';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { EnvMain, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
 import { QueryParameters } from '../common/env';
 import { v4 } from 'uuid';
 
+@injectable()
 export abstract class EnvExtImpl {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
+
     private proxy: EnvMain;
     private queryParameters: QueryParameters;
     private lang: string;
@@ -29,15 +34,20 @@ export abstract class EnvExtImpl {
     private envMachineId: string;
     private envSessionId: string;
     private host: string;
+    private applicationRoot: string;
     private _remoteName: string | undefined;
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.ENV_MAIN);
+    constructor() {
         this.envSessionId = v4();
         this.envMachineId = v4();
         this._remoteName = undefined;
     }
 
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.ENV_MAIN);
+    }
+
     getEnvVariable(envVarName: string): Promise<string | undefined> {
         return this.proxy.$getEnvVariable(envVarName).then(x => {
             if (x === null) {
@@ -75,6 +85,10 @@ export abstract class EnvExtImpl {
         this.host = appHost;
     }
 
+    setAppRoot(appRoot: string): void {
+        this.applicationRoot = appRoot;
+    }
+
     getClientOperatingSystem(): Promise<theia.OperatingSystem> {
         return this.proxy.$getClientOperatingSystem();
     }
@@ -83,7 +97,9 @@ export abstract class EnvExtImpl {
         return this.applicationName;
     }
 
-    abstract get appRoot(): string;
+    get appRoot(): string {
+        return this.applicationRoot;
+    }
 
     abstract get isNewAppInstall(): boolean;
 

package/src/plugin/localization-ext.ts

@@ -16,6 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { nls } from '@theia/core';
 import { Localization } from '@theia/core/lib/common/i18n/localization';
 import { LocalizationExt, LocalizationMain, Plugin, PLUGIN_RPC_CONTEXT, StringDetails } from '../common';
@@ -23,15 +24,19 @@ import { LanguagePackBundle } from '../common/language-pack-service';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { URI } from './types-impl';
 
+@injectable()
 export class LocalizationExtImpl implements LocalizationExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
 
-    private readonly _proxy: LocalizationMain;
+    private _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);
+    @postConstruct()
+    initialize(): void {
+        this._proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.LOCALIZATION_MAIN);
     }
 
     translateMessage(pluginId: string, details: StringDetails): string {

package/src/plugin/message-registry.ts

@@ -13,18 +13,23 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import {
     PLUGIN_RPC_CONTEXT as Ext, MessageRegistryMain, MainMessageOptions, MainMessageType
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { MessageItem, MessageOptions } from '@theia/plugin';
 
+@injectable()
 export class MessageRegistryExt {
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
 
     private proxy: MessageRegistryMain;
 
-    constructor(rpc: RPCProtocol) {
-        this.proxy = rpc.getProxy(Ext.MESSAGE_REGISTRY_MAIN);
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(Ext.MESSAGE_REGISTRY_MAIN);
     }
 
     async showMessage(type: MainMessageType, message: string,

package/src/plugin/node/debug/debug.spec.ts

@@ -13,6 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Container } from '@theia/core/shared/inversify';
 import { DebugSession } from '@theia/plugin';
 import * as chai from 'chai';
 import { ProxyIdentifier, RPCProtocol } from '../../../common/rpc-protocol';
@@ -37,7 +38,10 @@ describe('Debug API', () => {
             }
         };
 
-        const debug = new DebugExtImpl(mockRPCProtocol);
+        const container = new Container();
+        container.bind(RPCProtocol).toConstantValue(mockRPCProtocol);
+        container.bind(DebugExtImpl).toSelf().inSingletonScope();
+        const debug = container.get(DebugExtImpl);
 
         it('should use sourceReference, path and sessionId', () => {
             const source = {

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

@@ -14,9 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable } from '@theia/core/shared/inversify';
 import * as mac from 'macaddress';
 import { EnvExtImpl } from '../env';
-import { RPCProtocol } from '../../common/rpc-protocol';
 import { createHash } from 'crypto';
 import { v4 } from 'uuid';
 import fs = require('fs');
@@ -25,13 +25,15 @@ import fs = require('fs');
  * Provides machineId using mac address. It's only possible on node side
  * Extending the common class
  */
+@injectable()
 export class EnvNodeExtImpl extends EnvExtImpl {
 
     private macMachineId: string;
     private _isNewAppInstall: boolean;
 
-    constructor(rpc: RPCProtocol) {
-        super(rpc);
+    constructor() {
+        super();
+
         mac.one((err, macAddress) => {
             if (err) {
                 this.macMachineId = v4();
@@ -49,13 +51,6 @@ export class EnvNodeExtImpl extends EnvExtImpl {
         return this.macMachineId;
     }
 
-    /**
-     * Provides application root.
-     */
-    get appRoot(): string {
-        return __dirname;
-    }
-
     get isNewAppInstall(): boolean {
         return this._isNewAppInstall;
     }