@theia/plugin-ext 1.45.0 → 1.46.0

package/src/hosted/node/plugin-host-rpc.ts

@@ -14,10 +14,15 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { dynamicRequire, removeFromCache } from '@theia/core/lib/node/dynamic-require';
-import { PluginManagerExtImpl } from '../../plugin/plugin-manager';
-import { LocalizationExt, MAIN_RPC_CONTEXT, Plugin, PluginAPIFactory } from '../../common/plugin-api-rpc';
-import { PluginMetadata } from '../../common/plugin-protocol';
+import { ContainerModule, inject, injectable, postConstruct, unmanaged } from '@theia/core/shared/inversify';
+import { AbstractPluginManagerExtImpl, PluginHost, PluginManagerExtImpl } from '../../plugin/plugin-manager';
+import { MAIN_RPC_CONTEXT, Plugin, PluginAPIFactory, PluginManager,
+    LocalizationExt
+} from '../../common/plugin-api-rpc';
+import { PluginMetadata, PluginModel } from '../../common/plugin-protocol';
 import { createAPIFactory } from '../../plugin/plugin-context';
 import { EnvExtImpl } from '../../plugin/env';
 import { PreferenceRegistryExtImpl } from '../../plugin/preference-registry';
@@ -26,95 +31,139 @@ import { DebugExtImpl } from '../../plugin/debug/debug-ext';
 import { EditorsAndDocumentsExtImpl } from '../../plugin/editors-and-documents';
 import { WorkspaceExtImpl } from '../../plugin/workspace';
 import { MessageRegistryExt } from '../../plugin/message-registry';
-import { EnvNodeExtImpl } from '../../plugin/node/env-node-ext';
 import { ClipboardExt } from '../../plugin/clipboard-ext';
 import { loadManifest } from './plugin-manifest-loader';
 import { KeyValueStorageProxy } from '../../plugin/plugin-storage';
 import { WebviewsExtImpl } from '../../plugin/webviews';
 import { TerminalServiceExtImpl } from '../../plugin/terminal-ext';
 import { SecretsExtImpl } from '../../plugin/secrets-ext';
-import { BackendInitializationFn } from '../../common';
 import { connectProxyResolver } from './plugin-host-proxy';
 import { LocalizationExtImpl } from '../../plugin/localization-ext';
+import { RPCProtocol, ProxyIdentifier } from '../../common/rpc-protocol';
+import { PluginApiCache } from '../../plugin/node/plugin-container-module';
+
+/**
+ * The full set of all possible `Ext` interfaces that a plugin manager can support.
+ */
+export interface ExtInterfaces {
+    envExt: EnvExtImpl,
+    storageExt: KeyValueStorageProxy,
+    debugExt: DebugExtImpl,
+    editorsAndDocumentsExt: EditorsAndDocumentsExtImpl,
+    messageRegistryExt: MessageRegistryExt,
+    workspaceExt: WorkspaceExtImpl,
+    preferenceRegistryExt: PreferenceRegistryExtImpl,
+    clipboardExt: ClipboardExt,
+    webviewExt: WebviewsExtImpl,
+    terminalServiceExt: TerminalServiceExtImpl,
+    secretsExt: SecretsExtImpl,
+    localizationExt: LocalizationExtImpl
+}
+
+/**
+ * The RPC proxy identifier keys to set in the RPC object to register our `Ext` interface implementations.
+ */
+export type RpcKeys<EXT extends Partial<ExtInterfaces>> = Partial<Record<keyof EXT, ProxyIdentifier<any>>> & {
+    $pluginManager: ProxyIdentifier<any>;
+};
+
+export const PluginContainerModuleLoader = Symbol('PluginContainerModuleLoader');
+/**
+ * A function that loads a `PluginContainerModule` exported by a plugin's entry-point
+ * script, returning the per-`Container` cache of its exported API instances if the
+ * module has an API factory registered.
+ */
+export type PluginContainerModuleLoader = (module: ContainerModule) => PluginApiCache<object> | undefined;
 
 /**
  * Handle the RPC calls.
+ *
+ * @template PM is the plugin manager (ext) type
+ * @template PAF is the plugin API factory type
+ * @template EXT is the type identifying the `Ext` interfaces supported by the plugin manager
  */
-export class PluginHostRPC {
+@injectable()
+export abstract class AbstractPluginHostRPC<PM extends AbstractPluginManagerExtImpl<any>, PAF, EXT extends Partial<ExtInterfaces>> {
+
+    @inject(RPCProtocol)
+    protected readonly rpc: any;
 
-    private apiFactory: PluginAPIFactory;
+    @inject(PluginContainerModuleLoader)
+    protected readonly loadContainerModule: PluginContainerModuleLoader;
 
-    private pluginManager: PluginManagerExtImpl;
+    @inject(AbstractPluginManagerExtImpl)
+    protected readonly pluginManager: PM;
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    constructor(protected readonly rpc: any) {
+    protected readonly banner: string;
+
+    protected apiFactory: PAF;
+
+    constructor(
+        @unmanaged() name: string,
+        @unmanaged() private readonly backendInitPath: string | undefined,
+        @unmanaged() private readonly extRpc: RpcKeys<EXT>) {
+        this.banner = `${name}(${process.pid}):`;
     }
 
+    @postConstruct()
     initialize(): void {
-        const envExt = new EnvNodeExtImpl(this.rpc);
-        const storageProxy = new KeyValueStorageProxy(this.rpc);
-        const debugExt = new DebugExtImpl(this.rpc);
-        const editorsAndDocumentsExt = new EditorsAndDocumentsExtImpl(this.rpc);
-        const messageRegistryExt = new MessageRegistryExt(this.rpc);
-        const workspaceExt = new WorkspaceExtImpl(this.rpc, editorsAndDocumentsExt, messageRegistryExt);
-        const preferenceRegistryExt = new PreferenceRegistryExtImpl(this.rpc, workspaceExt);
-        const clipboardExt = new ClipboardExt(this.rpc);
-        const webviewExt = new WebviewsExtImpl(this.rpc, workspaceExt);
-        const terminalService = new TerminalServiceExtImpl(this.rpc);
-        const secretsExt = new SecretsExtImpl(this.rpc);
-        const localizationExt = new LocalizationExtImpl(this.rpc);
-        this.pluginManager = this.createPluginManager(envExt, terminalService, storageProxy, preferenceRegistryExt, webviewExt, secretsExt, localizationExt, this.rpc);
-        this.rpc.set(MAIN_RPC_CONTEXT.HOSTED_PLUGIN_MANAGER_EXT, this.pluginManager);
-        this.rpc.set(MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT, editorsAndDocumentsExt);
-        this.rpc.set(MAIN_RPC_CONTEXT.WORKSPACE_EXT, workspaceExt);
-        this.rpc.set(MAIN_RPC_CONTEXT.PREFERENCE_REGISTRY_EXT, preferenceRegistryExt);
-        this.rpc.set(MAIN_RPC_CONTEXT.STORAGE_EXT, storageProxy);
-        this.rpc.set(MAIN_RPC_CONTEXT.WEBVIEWS_EXT, webviewExt);
-        this.rpc.set(MAIN_RPC_CONTEXT.SECRETS_EXT, secretsExt);
-
-        this.apiFactory = createAPIFactory(
-            this.rpc,
-            this.pluginManager,
-            envExt,
-            debugExt,
-            preferenceRegistryExt,
-            editorsAndDocumentsExt,
-            workspaceExt,
-            messageRegistryExt,
-            clipboardExt,
-            webviewExt,
-            localizationExt
-        );
-        connectProxyResolver(workspaceExt, preferenceRegistryExt);
+        this.pluginManager.setPluginHost(this.createPluginHost());
+
+        const extInterfaces = this.createExtInterfaces();
+        this.registerExtInterfaces(extInterfaces);
+
+        this.apiFactory = this.createAPIFactory(extInterfaces);
+
+        this.loadContainerModule(new ContainerModule(bind => bind(PluginManager).toConstantValue(this.pluginManager)));
     }
 
     async terminate(): Promise<void> {
         await this.pluginManager.terminate();
     }
 
+    protected abstract createAPIFactory(extInterfaces: EXT): PAF;
+
+    protected abstract createExtInterfaces(): EXT;
+
+    protected registerExtInterfaces(extInterfaces: EXT): void {
+        for (const _key in this.extRpc) {
+            if (Object.hasOwnProperty.call(this.extRpc, _key)) {
+                const key = _key as keyof ExtInterfaces;
+                // In case of present undefineds
+                if (extInterfaces[key]) {
+                    this.rpc.set(this.extRpc[key], extInterfaces[key]);
+                }
+            }
+        }
+        this.rpc.set(this.extRpc.$pluginManager, this.pluginManager);
+    }
+
     initContext(contextPath: string, plugin: Plugin): void {
         const { name, version } = plugin.rawModel;
-        console.debug('PLUGIN_HOST(' + process.pid + '): initializing(' + name + '@' + version + ' with ' + contextPath + ')');
+        console.debug(this.banner, 'initializing(' + name + '@' + version + ' with ' + contextPath + ')');
         try {
-            const backendInit = dynamicRequire<{ doInitialization: BackendInitializationFn }>(contextPath);
+            type BackendInitFn = (pluginApiFactory: PAF, plugin: Plugin) => void;
+            const backendInit = dynamicRequire<{ doInitialization: BackendInitFn }>(contextPath);
             backendInit.doInitialization(this.apiFactory, plugin);
         } catch (e) {
             console.error(e);
         }
     }
 
-    createPluginManager(
-        envExt: EnvExtImpl, terminalService: TerminalServiceExtImpl, storageProxy: KeyValueStorageProxy,
-        preferencesManager: PreferenceRegistryExtImpl, webview: WebviewsExtImpl, secretsExt: SecretsExtImpl, localization: LocalizationExt,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        rpc: any
-    ): PluginManagerExtImpl {
+    protected getBackendPluginPath(pluginModel: PluginModel): string | undefined {
+        return pluginModel.entryPoint.backend;
+    }
+
+    /**
+     * Create the {@link PluginHost} that is required by my plugin manager ext interface to delegate
+     * critical behaviour such as loading and initializing plugins to me.
+     */
+    createPluginHost(): PluginHost {
         const { extensionTestsPath } = process.env;
         const self = this;
-        const pluginManager = new PluginManagerExtImpl({
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return {
             loadPlugin(plugin: Plugin): any {
-                console.debug('PLUGIN_HOST(' + process.pid + '): PluginManagerExtImpl/loadPlugin(' + plugin.pluginPath + ')');
+                console.debug(self.banner, 'PluginManagerExtImpl/loadPlugin(' + plugin.pluginPath + ')');
                 // cleaning the cache for all files of that plug-in.
                 // this prevents a memory leak on plugin host restart. See for reference:
                 // https://github.com/eclipse-theia/theia/pull/4931
@@ -125,7 +174,7 @@ export class PluginHostRPC {
                 }
             },
             async init(raw: PluginMetadata[]): Promise<[Plugin[], Plugin[]]> {
-                console.log('PLUGIN_HOST(' + process.pid + '): PluginManagerExtImpl/init()');
+                console.log(self.banner, 'PluginManagerExtImpl/init()');
                 const result: Plugin[] = [];
                 const foreign: Plugin[] = [];
                 for (const plg of raw) {
@@ -146,14 +195,16 @@ export class PluginHostRPC {
                                 isUnderDevelopment: !!plg.isUnderDevelopment
                             });
                         } else {
+                            // Headless and backend plugins are, for now, very similar
                             let backendInitPath = pluginLifecycle.backendInitPath;
                             // if no init path, try to init as regular Theia plugin
-                            if (!backendInitPath) {
-                                backendInitPath = __dirname + '/scanners/backend-init-theia.js';
+                            if (!backendInitPath && self.backendInitPath) {
+                                backendInitPath = __dirname + self.backendInitPath;
                             }
 
+                            const pluginPath = self.getBackendPluginPath(pluginModel);
                             const plugin: Plugin = {
-                                pluginPath: pluginModel.entryPoint.backend!,
+                                pluginPath,
                                 pluginFolder: pluginModel.packagePath,
                                 pluginUri: pluginModel.packageUri,
                                 model: pluginModel,
@@ -162,30 +213,30 @@ export class PluginHostRPC {
                                 isUnderDevelopment: !!plg.isUnderDevelopment
                             };
 
-                            self.initContext(backendInitPath, plugin);
-
+                            if (backendInitPath) {
+                                self.initContext(backendInitPath, plugin);
+                            } else {
+                                const { name, version } = plugin.rawModel;
+                                console.debug(self.banner, 'initializing(' + name + '@' + version + ' without any default API)');
+                            }
                             result.push(plugin);
                         }
                     } catch (e) {
-                        console.error(`Failed to initialize ${plg.model.id} plugin.`, e);
+                        console.error(self.banner, `Failed to initialize ${plg.model.id} plugin.`, e);
                     }
                 }
                 return [result, foreign];
             },
             initExtApi(extApi: ExtPluginApi[]): void {
                 for (const api of extApi) {
-                    if (api.backendInitPath) {
-                        try {
-                            const extApiInit = dynamicRequire<{ provideApi: ExtPluginApiBackendInitializationFn }>(api.backendInitPath);
-                            extApiInit.provideApi(rpc, pluginManager);
-                        } catch (e) {
-                            console.error(e);
-                        }
+                    try {
+                        self.initExtApi(api);
+                    } catch (e) {
+                        console.error(e);
                     }
                 }
             },
             loadTests: extensionTestsPath ? async () => {
-                /* eslint-disable @typescript-eslint/no-explicit-any */
                 // Require the test runner via node require from the provided path
                 let testRunner: any;
                 let requireError: Error | undefined;
@@ -212,7 +263,115 @@ export class PluginHostRPC {
                     `Path ${extensionTestsPath} does not point to a valid extension test runner.`
                 );
             } : undefined
-        }, envExt, terminalService, storageProxy, secretsExt, preferencesManager, webview, localization, rpc);
-        return pluginManager;
+        };
+    }
+
+    /**
+     * Initialize the end of the given provided extension API applicable to the current plugin host.
+     * Errors should be propagated to the caller.
+     *
+     * @param extApi the extension API to initialize, if appropriate
+     * @throws if any error occurs in initializing the extension API
+     */
+     protected abstract initExtApi(extApi: ExtPluginApi): void;
+}
+
+/**
+ * The RPC handler for frontend-connection-scoped plugins (Theia and VSCode plugins).
+ */
+@injectable()
+export class PluginHostRPC extends AbstractPluginHostRPC<PluginManagerExtImpl, PluginAPIFactory, ExtInterfaces> {
+    @inject(EnvExtImpl)
+    protected readonly envExt: EnvExtImpl;
+
+    @inject(LocalizationExt)
+    protected readonly localizationExt: LocalizationExtImpl;
+
+    @inject(KeyValueStorageProxy)
+    protected readonly keyValueStorageProxy: KeyValueStorageProxy;
+
+    @inject(DebugExtImpl)
+    protected readonly debugExt: DebugExtImpl;
+
+    @inject(EditorsAndDocumentsExtImpl)
+    protected readonly editorsAndDocumentsExt: EditorsAndDocumentsExtImpl;
+
+    @inject(MessageRegistryExt)
+    protected readonly messageRegistryExt: MessageRegistryExt;
+
+    @inject(WorkspaceExtImpl)
+    protected readonly workspaceExt: WorkspaceExtImpl;
+
+    @inject(PreferenceRegistryExtImpl)
+    protected readonly preferenceRegistryExt: PreferenceRegistryExtImpl;
+
+    @inject(ClipboardExt)
+    protected readonly clipboardExt: ClipboardExt;
+
+    @inject(WebviewsExtImpl)
+    protected readonly webviewExt: WebviewsExtImpl;
+
+    @inject(TerminalServiceExtImpl)
+    protected readonly terminalServiceExt: TerminalServiceExtImpl;
+
+    @inject(SecretsExtImpl)
+    protected readonly secretsExt: SecretsExtImpl;
+
+    constructor() {
+        super('PLUGIN_HOST', '/scanners/backend-init-theia.js',
+            {
+                $pluginManager: MAIN_RPC_CONTEXT.HOSTED_PLUGIN_MANAGER_EXT,
+                editorsAndDocumentsExt: MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT,
+                workspaceExt: MAIN_RPC_CONTEXT.WORKSPACE_EXT,
+                preferenceRegistryExt: MAIN_RPC_CONTEXT.PREFERENCE_REGISTRY_EXT,
+                storageExt: MAIN_RPC_CONTEXT.STORAGE_EXT,
+                webviewExt: MAIN_RPC_CONTEXT.WEBVIEWS_EXT,
+                secretsExt: MAIN_RPC_CONTEXT.SECRETS_EXT
+            }
+        );
+    }
+
+    protected createExtInterfaces(): ExtInterfaces {
+        connectProxyResolver(this.workspaceExt, this.preferenceRegistryExt);
+        return {
+            envExt: this.envExt,
+            storageExt: this.keyValueStorageProxy,
+            debugExt: this.debugExt,
+            editorsAndDocumentsExt: this.editorsAndDocumentsExt,
+            messageRegistryExt: this.messageRegistryExt,
+            workspaceExt: this.workspaceExt,
+            preferenceRegistryExt: this.preferenceRegistryExt,
+            clipboardExt: this.clipboardExt,
+            webviewExt: this.webviewExt,
+            terminalServiceExt: this.terminalServiceExt,
+            secretsExt: this.secretsExt,
+            localizationExt: this.localizationExt
+        };
+    }
+
+    protected createAPIFactory(extInterfaces: ExtInterfaces): PluginAPIFactory {
+        const {
+            envExt, debugExt, preferenceRegistryExt, editorsAndDocumentsExt, workspaceExt,
+            messageRegistryExt, clipboardExt, webviewExt, localizationExt
+        } = extInterfaces;
+        return createAPIFactory(this.rpc, this.pluginManager, envExt, debugExt, preferenceRegistryExt,
+            editorsAndDocumentsExt, workspaceExt, messageRegistryExt, clipboardExt, webviewExt,
+            localizationExt);
+    }
+
+    protected initExtApi(extApi: ExtPluginApi): void {
+        interface PluginExports {
+            containerModule?: ContainerModule;
+            provideApi?: ExtPluginApiBackendInitializationFn;
+        }
+        if (extApi.backendInitPath) {
+            const { containerModule, provideApi } = dynamicRequire<PluginExports>(extApi.backendInitPath);
+            if (containerModule) {
+                this.loadContainerModule(containerModule);
+            }
+            if (provideApi) {
+                provideApi(this.rpc, this.pluginManager);
+            }
+        }
     }
 }

package/src/hosted/node/plugin-host.ts

@@ -14,10 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import '@theia/core/shared/reflect-metadata';
-import { ConnectionClosedError, RPCProtocolImpl } from '../../common/rpc-protocol';
+import { Container } from '@theia/core/shared/inversify';
+import { ConnectionClosedError, RPCProtocol } from '../../common/rpc-protocol';
 import { ProcessTerminatedMessage, ProcessTerminateMessage } from './hosted-plugin-protocol';
 import { PluginHostRPC } from './plugin-host-rpc';
-import { IPCChannel } from '@theia/core/lib/node';
+import pluginHostModule from './plugin-host-module';
 
 console.log('PLUGIN_HOST(' + process.pid + ') starting instance');
 
@@ -74,8 +75,12 @@ process.on('rejectionHandled', (promise: Promise<any>) => {
 });
 
 let terminating = false;
-const channel = new IPCChannel();
-const rpc = new RPCProtocolImpl(channel);
+
+const container = new Container();
+container.load(pluginHostModule);
+
+const rpc: RPCProtocol = container.get(RPCProtocol);
+const pluginHostRPC = container.get(PluginHostRPC);
 
 process.on('message', async (message: string) => {
     if (terminating) {
@@ -103,6 +108,3 @@ process.on('message', async (message: string) => {
         console.error(e);
     }
 });
-
-const pluginHostRPC = new PluginHostRPC(rpc);
-pluginHostRPC.initialize();

package/src/hosted/node/plugin-reader.ts

@@ -108,6 +108,9 @@ export class HostedPluginReader implements BackendApplicationContribution {
         if (pluginMetadata.model.entryPoint.backend) {
             pluginMetadata.model.entryPoint.backend = path.resolve(plugin.packagePath, pluginMetadata.model.entryPoint.backend);
         }
+        if (pluginMetadata.model.entryPoint.headless) {
+            pluginMetadata.model.entryPoint.headless = path.resolve(plugin.packagePath, pluginMetadata.model.entryPoint.headless);
+        }
         if (pluginMetadata) {
             // Add post processor
             if (this.metadataProcessors) {

package/src/hosted/node/plugin-service.ts

@@ -13,7 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { injectable, inject, named, postConstruct } from '@theia/core/shared/inversify';
+import { injectable, inject, named, optional, postConstruct } from '@theia/core/shared/inversify';
 import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin, PluginIdentifiers } from '../../common/plugin-protocol';
 import { HostedPluginSupport } from './hosted-plugin';
 import { ILogger, Disposable, ContributionProvider, DisposableCollection } from '@theia/core';
@@ -23,6 +23,14 @@ import { PluginDeployerImpl } from '../../main/node/plugin-deployer-impl';
 import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 import { PluginUninstallationManager } from '../../main/node/plugin-uninstallation-manager';
 
+export const BackendPluginHostableFilter = Symbol('BackendPluginHostableFilter');
+/**
+ * A filter matching backend plugins that are hostable in my plugin host process.
+ * Only if at least one backend plugin is deployed that matches my filter will I
+ * start the host process.
+ */
+export type BackendPluginHostableFilter = (plugin: DeployedPlugin) => boolean;
+
 @injectable()
 export class HostedPluginServerImpl implements HostedPluginServer {
     @inject(ILogger)
@@ -43,6 +51,10 @@ export class HostedPluginServerImpl implements HostedPluginServer {
 
     @inject(PluginUninstallationManager) protected readonly uninstallationManager: PluginUninstallationManager;
 
+    @inject(BackendPluginHostableFilter)
+    @optional()
+    protected backendPluginHostableFilter: BackendPluginHostableFilter;
+
     protected client: HostedPluginClient | undefined;
     protected toDispose = new DisposableCollection();
 
@@ -63,6 +75,10 @@ export class HostedPluginServerImpl implements HostedPluginServer {
 
     @postConstruct()
     protected init(): void {
+        if (!this.backendPluginHostableFilter) {
+            this.backendPluginHostableFilter = () => true;
+        }
+
         this.toDispose.pushAll([
             this.pluginDeployer.onDidDeploy(() => this.client?.onDidDeploy()),
             this.uninstallationManager.onDidChangeUninstalledPlugins(currentUninstalled => {
@@ -90,8 +106,9 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     }
 
     async getDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
-        const backendMetadata = await this.deployerHandler.getDeployedBackendPluginIds();
-        if (backendMetadata.length > 0) {
+        const backendPlugins = (await this.deployerHandler.getDeployedBackendPlugins())
+            .filter(this.backendPluginHostableFilter);
+        if (backendPlugins.length > 0) {
             this.hostedPlugin.runPluginServer();
         }
         const plugins = new Set<PluginIdentifiers.VersionedId>();
@@ -103,7 +120,7 @@ export class HostedPluginServerImpl implements HostedPluginServer {
             }
         };
         addIds(await this.deployerHandler.getDeployedFrontendPluginIds());
-        addIds(backendMetadata);
+        addIds(await this.deployerHandler.getDeployedBackendPluginIds());
         addIds(await this.hostedPlugin.getExtraDeployedPluginIds());
         return Array.from(plugins);
     }

package/src/hosted/node/scanners/file-plugin-uri-factory.ts

@@ -17,7 +17,7 @@
 import { injectable } from '@theia/core/shared/inversify';
 import * as path from 'path';
 import URI from '@theia/core/lib/common/uri';
-import { FileUri } from '@theia/core/lib/node/file-uri';
+import { FileUri } from '@theia/core/lib/common/file-uri';
 import { PluginPackage } from '../../../common';
 import { PluginUriFactory } from './plugin-uri-factory';
 /**

package/src/hosted/node/scanners/scanner-theia.ts

@@ -62,7 +62,9 @@ import {
     Translation,
     PluginIdentifiers,
     TerminalProfile,
-    PluginIconContribution
+    PluginIconContribution,
+    PluginEntryPoint,
+    PluginPackageContribution
 } from '../../../common/plugin-protocol';
 import { promises as fs } from 'fs';
 import * as path from 'path';
@@ -87,17 +89,19 @@ function getFileExtension(filePath: string): string {
     return index === -1 ? '' : filePath.substring(index + 1);
 }
 
-@injectable()
-export class TheiaPluginScanner implements PluginScanner {
+type PluginPackageWithContributes = PluginPackage & { contributes: PluginPackageContribution };
 
-    private readonly _apiType: PluginEngine = 'theiaPlugin';
+@injectable()
+export abstract class AbstractPluginScanner implements PluginScanner {
 
     @inject(GrammarsReader)
-    private readonly grammarsReader: GrammarsReader;
+    protected readonly grammarsReader: GrammarsReader;
 
     @inject(PluginUriFactory)
     protected readonly pluginUriFactory: PluginUriFactory;
 
+    constructor(private readonly _apiType: PluginEngine, private readonly _backendInitPath?: string) { }
+
     get apiType(): PluginEngine {
         return this._apiType;
     }
@@ -119,22 +123,25 @@ export class TheiaPluginScanner implements PluginScanner {
                 type: this._apiType,
                 version: plugin.engines[this._apiType]
             },
-            entryPoint: {
-                frontend: plugin.theiaPlugin!.frontend,
-                backend: plugin.theiaPlugin!.backend
-            }
+            entryPoint: this.getEntryPoint(plugin)
         };
         return result;
     }
 
+    protected abstract getEntryPoint(plugin: PluginPackage): PluginEntryPoint;
+
     getLifecycle(plugin: PluginPackage): PluginLifecycle {
-        return {
+        const result: PluginLifecycle = {
             startMethod: 'start',
             stopMethod: 'stop',
             frontendModuleName: buildFrontendModuleName(plugin),
-
-            backendInitPath: path.join(__dirname, 'backend-init-theia')
         };
+
+        if (this._backendInitPath) {
+            result.backendInitPath = path.join(__dirname, this._backendInitPath);
+        }
+
+        return result;
     }
 
     getDependencies(rawPlugin: PluginPackage): Map<string, string> | undefined {
@@ -155,6 +162,33 @@ export class TheiaPluginScanner implements PluginScanner {
             return contributions;
         }
 
+        return this.readContributions(rawPlugin as PluginPackageWithContributes, contributions);
+    }
+
+    protected async readContributions(rawPlugin: PluginPackageWithContributes, contributions: PluginContribution): Promise<PluginContribution> {
+        return contributions;
+    }
+
+}
+
+@injectable()
+export class TheiaPluginScanner extends AbstractPluginScanner {
+    constructor() {
+        super('theiaPlugin', 'backend-init-theia');
+    }
+
+    protected getEntryPoint(plugin: PluginPackage): PluginEntryPoint {
+        const result: PluginEntryPoint = {
+            frontend: plugin.theiaPlugin!.frontend,
+            backend: plugin.theiaPlugin!.backend
+        };
+        if (plugin.theiaPlugin?.headless) {
+            result.headless = plugin.theiaPlugin.headless;
+        }
+        return result;
+    }
+
+    protected override async readContributions(rawPlugin: PluginPackageWithContributes, contributions: PluginContribution): Promise<PluginContribution> {
         try {
             if (rawPlugin.contributes.configuration) {
                 const configurations = Array.isArray(rawPlugin.contributes.configuration) ? rawPlugin.contributes.configuration : [rawPlugin.contributes.configuration];

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

@@ -361,7 +361,9 @@ export class AuthenticationProviderImpl implements AuthenticationProvider {
 
     removeSession(sessionId: string): Thenable<void> {
         return this.proxy.$removeSession(this.id, sessionId)
-            .then(() => { this.messageService.info('Successfully signed out.'); });
+            .then(() => {
+                this.messageService.info(nls.localizeByDefault('Successfully signed out.'));
+            });
     }
 }