@theia/plugin-ext 1.45.1 → 1.46.0

package/src/plugin/node/plugin-container-module.ts

@@ -0,0 +1,165 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource 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, ContainerModule } from '@theia/core/shared/inversify';
+import { Plugin, PluginManager, emptyPlugin } from '../../common';
+
+export type ApiFactory<T extends object> = (plugin: Plugin) => T;
+
+/**
+ * Bind a service identifier for the factory function creating API objects of
+ * type `T` for a client plugin to a class providing a `call()` method that
+ * implements that factory function.
+ *
+ * @template T the API object type that the factory creates
+ * @param serviceIdentifier the injection key identifying the API factory function
+ * @param factoryClass the class implementing the API factory function via its `call()` method
+ */
+export type BindApiFactory = <T extends object>(
+    apiModuleName: string,
+    serviceIdentifier: interfaces.ServiceIdentifier<ApiFactory<T>>,
+    factoryClass: new () => { createApi: ApiFactory<T>}) => void;
+
+/**
+ * An analogue of the callback function in the constructor of the Inversify
+ * `ContainerModule` providing a registry that, in addition to the standard
+ * binding-related functions, includes a custom function for binding an
+ * API factory.
+ */
+export type PluginContainerModuleCallBack = (registry: {
+    bind: interfaces.Bind;
+    unbind: interfaces.Unbind;
+    isBound: interfaces.IsBound;
+    rebind: interfaces.Rebind;
+    bindApiFactory: BindApiFactory;
+}) => void;
+
+/**
+ * Factory for an Inversify `ContainerModule` that supports registration of the plugin's
+ * API factory. Use the `PluginContainerModule`'s `create()` method to create the container
+ * module; its `callback` function provides a `registry` of Inversify binding functions that
+ * includes a `bindApiFactory` function for binding the API factory.
+ */
+export const PluginContainerModule: symbol & { create(callback: PluginContainerModuleCallBack): ContainerModule } = Object.assign(Symbol('PluginContainerModule'), {
+    create(callback: PluginContainerModuleCallBack): ContainerModule {
+        const result: InternalPluginContainerModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+            const bindApiFactory: BindApiFactory = (apiModuleName, serviceIdentifier, factoryClass) => {
+                result.initializeApi = container => {
+                    const apiCache = new PluginApiCache(apiModuleName, serviceIdentifier);
+                    apiCache.initializeApi(container);
+                    return apiCache;
+                };
+                bind(factoryClass).toSelf().inSingletonScope();
+                bind(serviceIdentifier).toDynamicValue(({ container }) => {
+                    const factory = container.get(factoryClass);
+                    return factory.createApi.bind(factory);
+                }).inSingletonScope();
+            };
+            callback({ bind, unbind, isBound, rebind, bindApiFactory });
+        });
+        return result;
+    }
+});
+
+/**
+ * Definition of additional API provided by the `ContainerModule` created by the
+ * {@link PluginContainerModule} factory function that is for internal use by Theia.
+ */
+export type InternalPluginContainerModule = ContainerModule & {
+    /** Use my API factory binding to initialize the plugin API in some `container`. */
+    initializeApi?: (container: interfaces.Container) => PluginApiCache<object>;
+};
+
+/**
+ * An object that creates and caches the instance of the plugin API created by the
+ * factory binding in a {@link PluginContainerModule} in some plugin host.
+ *
+ * @template T the custom API object's type
+ */
+export class PluginApiCache<T extends object> {
+
+    private apiFactory: ApiFactory<T>;
+    private pluginManager: PluginManager;
+    private defaultApi: T;
+    private pluginsApiImpl = new Map<string, T>();
+    private hookedModuleLoader = false;
+
+    /**
+     * Initializes me with the module name by which plugins import the API
+     * and the service identifier to look up in the Inversify `Container` to
+     * obtain the {@link ApiFactory} that will instantiate it.
+     */
+    constructor(private readonly apiModuleName: string,
+        private readonly serviceIdentifier: interfaces.ServiceIdentifier<ApiFactory<T>>) {}
+
+    // Called by Theia to do any prep work needed for dishing out the API object
+    // when it's requested. The key part of that is hooking into the node module
+    // loader. This is called every time a plugin-host process is forked.
+    initializeApi(container: interfaces.Container): void {
+        this.apiFactory = container.get(this.serviceIdentifier);
+        this.pluginManager = container.get(PluginManager);
+
+        if (!this.hookedModuleLoader) {
+            this.hookedModuleLoader = true;
+            this.overrideInternalLoad();
+        }
+    }
+
+    /**
+     * Hook into the override chain of JavaScript's `module` loading function
+     * to implement ourselves, using the API provider's registered factory,
+     * the construction of its default exports object.
+     */
+    private overrideInternalLoad(): void {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const module = require('module');
+
+        const internalLoad = module._load;
+        const self = this;
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        module._load = function (request: string, parent: any, isMain: any): any {
+            if (request !== self.apiModuleName) {
+                // Pass the request to the next implementation down the chain
+                return internalLoad.call(this, request, parent, isMain);
+            }
+
+            const plugin = self.findPlugin(parent.filename);
+            if (plugin) {
+                let apiImpl = self.pluginsApiImpl.get(plugin.model.id);
+                if (!apiImpl) {
+                    apiImpl = self.apiFactory(plugin);
+                    self.pluginsApiImpl.set(plugin.model.id, apiImpl);
+                }
+                return apiImpl;
+            }
+
+            console.warn(
+                `Extension module ${parent.filename} did an import of '${self.apiModuleName}' but our cache ` +
+                    ' has no knowledge of that extension. Returning a generic API object; some functionality might not work correctly.'
+            );
+            if (!self.defaultApi) {
+                self.defaultApi = self.apiFactory(emptyPlugin);
+            }
+            return self.defaultApi;
+        };
+    }
+
+    // Search all loaded plugins to see which one has the given file (absolute path)
+    protected findPlugin(filePath: string): Plugin | undefined {
+        return this.pluginManager.getAllPlugins().find(plugin => filePath.startsWith(plugin.pluginFolder));
+    }
+}

package/src/plugin/notebook/notebook-kernels.ts

@@ -334,7 +334,6 @@ export class NotebookKernelsExtImpl implements NotebookKernelsExt {
             await obj.controller.executeHandler.call(obj.controller, cells, document.apiNotebook, obj.controller);
         } catch (err) {
             console.error(`NotebookController[${handle}] execute cells FAILED`, err);
-            console.error(err);
         }
 
     }

package/src/plugin/plugin-context.ts

@@ -87,6 +87,7 @@ import {
     InlineValueContext,
     DocumentHighlightKind,
     DocumentHighlight,
+    MultiDocumentHighlight,
     DocumentLink,
     DocumentDropEdit,
     CodeLens,
@@ -200,7 +201,7 @@ import {
     ExternalUriOpenerPriority,
     EditSessionIdentityMatch,
     TerminalOutputAnchor,
-    TerminalQuickFixExecuteTerminalCommand,
+    TerminalQuickFixTerminalCommand,
     TerminalQuickFixOpener,
     TestResultState
 } from './types-impl';
@@ -916,6 +917,13 @@ export function createAPIFactory(
             registerDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.DocumentHighlightProvider): theia.Disposable {
                 return languagesExt.registerDocumentHighlightProvider(selector, provider, pluginToPluginInfo(plugin));
             },
+            /**
+             * @stubbed
+             * @monaco-uplift: wait until API is available in Monaco (1.85.0+)
+             */
+            registerMultiDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.MultiDocumentHighlightProvider): theia.Disposable {
+                return Disposable.NULL;
+            },
             registerWorkspaceSymbolProvider(provider: theia.WorkspaceSymbolProvider): theia.Disposable {
                 return languagesExt.registerWorkspaceSymbolProvider(provider, pluginToPluginInfo(plugin));
             },
@@ -1261,6 +1269,7 @@ export function createAPIFactory(
             InlineValueContext,
             DocumentHighlightKind,
             DocumentHighlight,
+            MultiDocumentHighlight,
             DocumentLink,
             DocumentDropEdit,
             CodeLens,
@@ -1375,7 +1384,7 @@ export function createAPIFactory(
             TerminalExitReason,
             DocumentPasteEdit,
             ExternalUriOpenerPriority,
-            TerminalQuickFixExecuteTerminalCommand,
+            TerminalQuickFixTerminalCommand,
             TerminalQuickFixOpener,
             EditSessionIdentityMatch,
             TestResultState

package/src/plugin/plugin-manager.ts

@@ -14,8 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import {
     PLUGIN_RPC_CONTEXT,
+    AbstractPluginManagerExt,
     NotificationMain,
     MainMessageType,
     MessageRegistryMain,
@@ -35,13 +37,13 @@ import * as types from './types-impl';
 import { join } from './path';
 import { EnvExtImpl } from './env';
 import { PreferenceRegistryExtImpl } from './preference-registry';
-import { Memento, KeyValueStorageProxy, GlobalState } from './plugin-storage';
+import { InternalStorageExt, Memento, GlobalState } from './plugin-storage';
 import { ExtPluginApi } from '../common/plugin-ext-api-contribution';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { Emitter } from '@theia/core/lib/common/event';
 import { WebviewsExtImpl } from './webviews';
 import { URI as Uri } from './types-impl';
-import { SecretsExtImpl, SecretStorageExt } from '../plugin/secrets-ext';
+import { InternalSecretsExt, SecretStorageExt } from '../plugin/secrets-ext';
 import { PluginExt } from './plugin-context';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 
@@ -77,7 +79,34 @@ class ActivatedPlugin {
     }
 }
 
-export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
+export const MinimalTerminalServiceExt = Symbol('MinimalTerminalServiceExt');
+export type MinimalTerminalServiceExt = Pick<TerminalServiceExt,
+    'getEnvironmentVariableCollection'|'$initEnvironmentVariableCollections'|'$setShell'>;
+
+@injectable()
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export abstract class AbstractPluginManagerExtImpl<P extends Record<string, any>> implements AbstractPluginManagerExt<P>, PluginManager {
+
+    @inject(EnvExtImpl)
+    protected readonly envExt: EnvExtImpl;
+
+    @inject(MinimalTerminalServiceExt)
+    protected readonly terminalService: MinimalTerminalServiceExt;
+
+    @inject(InternalStorageExt)
+    protected readonly storage: InternalStorageExt;
+
+    @inject(InternalSecretsExt)
+    protected readonly secrets: InternalSecretsExt;
+
+    @inject(LocalizationExt)
+    protected readonly localization: LocalizationExt;
+
+    @inject(RPCProtocol)
+    protected readonly rpc: RPCProtocol;
+
+    // Cannot be Inversify-injected because it induces a dependency cycle
+    protected host: PluginHost;
 
     private configStorage: ConfigStorage | undefined;
     private readonly registry = new Map<string, Plugin>();
@@ -90,29 +119,22 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
     private onDidChangeEmitter = new Emitter<void>();
     private messageRegistryProxy: MessageRegistryMain;
     private notificationMain: NotificationMain;
-    private supportedActivationEvents: Set<string>;
-    protected fireOnDidChange(): void {
-        this.onDidChangeEmitter.fire(undefined);
-    }
 
     protected jsonValidation: PluginJsonValidationContribution[] = [];
     protected ready = new Deferred();
 
-    constructor(
-        private readonly host: PluginHost,
-        private readonly envExt: EnvExtImpl,
-        private readonly terminalService: TerminalServiceExt,
-        private readonly storageProxy: KeyValueStorageProxy,
-        private readonly secrets: SecretsExtImpl,
-        private readonly preferencesManager: PreferenceRegistryExtImpl,
-        private readonly webview: WebviewsExtImpl,
-        private readonly localization: LocalizationExt,
-        private readonly rpc: RPCProtocol
-    ) {
+    @postConstruct()
+    initialize(): void {
         this.messageRegistryProxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.MESSAGE_REGISTRY_MAIN);
         this.notificationMain = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTIFICATION_MAIN);
     }
 
+    setPluginHost(pluginHost: PluginHost): void {
+        this.host = pluginHost;
+    }
+
+    abstract $init(params: P): Promise<void>;
+
     async $stop(pluginId?: string): Promise<void> {
         if (!pluginId) {
             return this.stopAll();
@@ -179,28 +201,6 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
         }
     }
 
-    async $init(params: PluginManagerInitializeParams): Promise<void> {
-        this.storageProxy.init(params.globalState, params.workspaceState);
-
-        this.envExt.setQueryParameters(params.env.queryParams);
-        this.envExt.setLanguage(params.env.language);
-        this.terminalService.$setShell(params.env.shell);
-        this.envExt.setUIKind(params.env.uiKind);
-        this.envExt.setApplicationName(params.env.appName);
-        this.envExt.setAppHost(params.env.appHost);
-
-        this.preferencesManager.init(params.preferences);
-
-        if (params.extApi) {
-            this.host.initExtApi(params.extApi);
-        }
-
-        this.webview.init(params.webview);
-        this.jsonValidation = params.jsonValidation;
-
-        this.supportedActivationEvents = new Set(params.supportedActivationEvents ?? []);
-    }
-
     async $start(params: PluginManagerStartParams): Promise<void> {
         this.configStorage = params.configStorage;
 
@@ -239,15 +239,16 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
             contributes.jsonValidation = (contributes.jsonValidation || []).concat(this.jsonValidation);
         }
         this.registry.set(plugin.model.id, plugin);
-        if (plugin.pluginPath && Array.isArray(plugin.rawModel.activationEvents)) {
+        const activationEvents = this.getActivationEvents(plugin);
+        if (plugin.pluginPath && activationEvents) {
             const activation = () => this.$activatePlugin(plugin.model.id);
             // an internal activation event is a subject to change
             this.setActivation(`onPlugin:${plugin.model.id}`, activation);
-            const unsupportedActivationEvents = plugin.rawModel.activationEvents.filter(e => !this.supportedActivationEvents.has(e.split(':')[0]));
+            const unsupportedActivationEvents = activationEvents.filter(e => !this.isSupportedActivationEvent(e));
             if (unsupportedActivationEvents.length) {
                 console.warn(`Unsupported activation events: ${unsupportedActivationEvents.join(', ')}, please open an issue: https://github.com/eclipse-theia/theia/issues/new`);
             }
-            for (let activationEvent of plugin.rawModel.activationEvents) {
+            for (let activationEvent of activationEvents) {
                 if (activationEvent === 'onUri') {
                     activationEvent = `onUri:theia://${plugin.model.id}`;
                 }
@@ -255,6 +256,14 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
             }
         }
     }
+
+    protected getActivationEvents(plugin: Plugin): string[] | undefined {
+        const result = plugin.rawModel.activationEvents;
+        return Array.isArray(result) ? result : undefined;
+    }
+
+    protected abstract isSupportedActivationEvent(activationEvent: string): boolean;
+
     protected setActivation(activationEvent: string, activation: () => Promise<void>): void {
         const activations = this.activations.get(activationEvent) || [];
         activations.push(activation);
@@ -363,11 +372,12 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
         const globalStoragePath = join(configStorage.hostGlobalStoragePath, plugin.model.id);
         const extension = new PluginExt(this, plugin);
         const extensionModeValue = plugin.isUnderDevelopment ? types.ExtensionMode.Development : types.ExtensionMode.Production;
+
         const pluginContext: theia.PluginContext = {
             extensionPath: extension.extensionPath,
             extensionUri: extension.extensionUri,
-            globalState: new GlobalState(plugin.model.id, true, this.storageProxy),
-            workspaceState: new Memento(plugin.model.id, false, this.storageProxy),
+            globalState: new GlobalState(plugin.model.id, true, this.storage),
+            workspaceState: new Memento(plugin.model.id, false, this.storage),
             subscriptions: subscriptions,
             asAbsolutePath: asAbsolutePath,
             logPath: logPath,
@@ -431,6 +441,50 @@ export class PluginManagerExtImpl implements PluginManagerExt, PluginManager {
         return this.onDidChangeEmitter.event;
     }
 
+    protected fireOnDidChange(): void {
+        this.onDidChangeEmitter.fire(undefined);
+    }
+
+}
+
+@injectable()
+export class PluginManagerExtImpl extends AbstractPluginManagerExtImpl<PluginManagerInitializeParams> implements PluginManagerExt {
+
+    @inject(PreferenceRegistryExtImpl)
+    protected readonly preferencesManager: PreferenceRegistryExtImpl;
+
+    @inject(WebviewsExtImpl)
+    protected readonly webview: WebviewsExtImpl;
+
+    private supportedActivationEvents: Set<string>;
+
+    async $init(params: PluginManagerInitializeParams): Promise<void> {
+        this.storage.init(params.globalState, params.workspaceState);
+
+        this.envExt.setQueryParameters(params.env.queryParams);
+        this.envExt.setUIKind(params.env.uiKind);
+        this.envExt.setLanguage(params.env.language);
+        this.terminalService.$setShell(params.env.shell);
+        this.envExt.setApplicationName(params.env.appName);
+        this.envExt.setAppHost(params.env.appHost);
+        this.envExt.setAppRoot(params.env.appRoot);
+
+        this.preferencesManager.init(params.preferences);
+
+        if (params.extApi) {
+            this.host.initExtApi(params.extApi);
+        }
+
+        this.webview.init(params.webview);
+        this.jsonValidation = params.jsonValidation;
+
+        this.supportedActivationEvents = new Set(params.supportedActivationEvents ?? []);
+    }
+
+    protected isSupportedActivationEvent(activationEvent: string): boolean {
+        return this.supportedActivationEvents.has(activationEvent.split(':')[0]);
+    }
+
 }
 
 // for electron

package/src/plugin/plugin-storage.ts

@@ -15,7 +15,8 @@
 // *****************************************************************************
 
 import * as theia from '@theia/plugin';
-import { Event, Emitter } from '@theia/core/lib/common/event';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { Disposable, DisposableGroup, Event, Emitter } from '@theia/core';
 import { PLUGIN_RPC_CONTEXT, StorageMain, StorageExt } from '../common/plugin-api-rpc';
 import { KeysToAnyValues, KeysToKeysToAnyValue } from '../common/types';
 import { RPCProtocol } from '../common/rpc-protocol';
@@ -27,7 +28,7 @@ export class Memento implements theia.Memento {
     constructor(
         private readonly pluginId: string,
         private readonly isPluginGlobalData: boolean,
-        private readonly storage: KeyValueStorageProxy
+        private readonly storage: InternalStorageExt
     ) {
         this.cache = storage.getPerPluginData(pluginId, isPluginGlobalData);
 
@@ -69,11 +70,28 @@ export class GlobalState extends Memento {
     setKeysForSync(keys: readonly string[]): void { }
 }
 
+export const InternalStorageExt = Symbol('InternalStorageExt');
+export interface InternalStorageExt extends StorageExt {
+
+    init(initGlobalData: KeysToKeysToAnyValue, initWorkspaceData: KeysToKeysToAnyValue): void;
+
+    getPerPluginData(key: string, isGlobal: boolean): KeysToAnyValues;
+
+    setPerPluginData(key: string, value: KeysToAnyValues, isGlobal: boolean): Promise<boolean>;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    storageDataChangedEvent(listener: (e: KeysToKeysToAnyValue) => any, thisArgs?: any, disposables?: DisposableGroup): Disposable;
+
+    $updatePluginsWorkspaceData(workspaceData: KeysToKeysToAnyValue): void;
+
+}
+
 /**
  * Singleton.
  * Is used to proxy storage requests to main side.
  */
-export class KeyValueStorageProxy implements StorageExt {
+@injectable()
+export class KeyValueStorageProxy implements InternalStorageExt {
 
     private storageDataChangedEmitter = new Emitter<KeysToKeysToAnyValue>();
     public readonly storageDataChangedEvent: Event<KeysToKeysToAnyValue> = this.storageDataChangedEmitter.event;
@@ -83,7 +101,7 @@ export class KeyValueStorageProxy implements StorageExt {
     private globalDataCache: KeysToKeysToAnyValue;
     private workspaceDataCache: KeysToKeysToAnyValue;
 
-    constructor(rpc: RPCProtocol) {
+    constructor(@inject(RPCProtocol) rpc: RPCProtocol) {
         this.proxy = rpc.getProxy<StorageMain>(PLUGIN_RPC_CONTEXT.STORAGE_MAIN);
     }
 

package/src/plugin/preference-registry.spec.ts

@@ -14,6 +14,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 { PreferenceRegistryExtImpl, PreferenceScope } from './preference-registry';
 import * as chai from 'chai';
 import { WorkspaceExtImpl } from '../plugin/workspace';
@@ -38,7 +39,11 @@ describe('PreferenceRegistryExtImpl:', () => {
     const mockWorkspace: WorkspaceExtImpl = { workspaceFolders: [{ uri: workspaceRoot, name: 'workspace-root', index: 0 }] } as WorkspaceExtImpl;
 
     beforeEach(() => {
-        preferenceRegistryExtImpl = new PreferenceRegistryExtImpl(mockRPC, mockWorkspace);
+        const container = new Container();
+        container.bind(RPCProtocol).toConstantValue(mockRPC);
+        container.bind(WorkspaceExtImpl).toConstantValue(mockWorkspace);
+        container.bind(PreferenceRegistryExtImpl).toSelf().inSingletonScope();
+        preferenceRegistryExtImpl = container.get(PreferenceRegistryExtImpl);
     });
 
     describe('Prototype pollution', () => {

package/src/plugin/preference-registry.ts

@@ -16,6 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { Emitter, Event } from '@theia/core/lib/common/event';
 import { isOSX, isWindows } from '@theia/core/lib/common/os';
 import { URI } from '@theia/core/shared/vscode-uri';
@@ -78,18 +79,23 @@ export class TheiaWorkspace extends Workspace {
     }
 }
 
+@injectable()
 export class PreferenceRegistryExtImpl implements PreferenceRegistryExt {
+    @inject(RPCProtocol)
+    protected rpc: RPCProtocol;
+
+    @inject(WorkspaceExtImpl)
+    protected readonly workspace: WorkspaceExtImpl;
+
     private proxy: PreferenceRegistryMain;
     private _preferences: Configuration;
     private readonly _onDidChangeConfiguration = new Emitter<theia.ConfigurationChangeEvent>();
 
     readonly onDidChangeConfiguration: Event<theia.ConfigurationChangeEvent> = this._onDidChangeConfiguration.event;
 
-    constructor(
-        rpc: RPCProtocol,
-        private readonly workspace: WorkspaceExtImpl
-    ) {
-        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.PREFERENCE_REGISTRY_MAIN);
+    @postConstruct()
+    initialize(): void {
+        this.proxy = this.rpc.getProxy(PLUGIN_RPC_CONTEXT.PREFERENCE_REGISTRY_MAIN);
     }
 
     init(data: PreferenceData): void {

package/src/plugin/quick-open.ts

@@ -246,11 +246,11 @@ export class QuickOpenExtImpl implements QuickOpenExt {
     async $acceptOnDidTriggerButton(sessionId: number, btn: QuickInputButtonHandle): Promise<void> {
         const session = this._sessions.get(sessionId);
         if (session) {
-            if (btn.index === -1) {
+            if (btn.handle === -1) {
                 session._fireButtonTrigger(QuickInputButtons.Back);
             } else if (session && (session instanceof InputBoxExt || session instanceof QuickPickExt)) {
-                const btnFromIndex = session.buttons[btn.index];
-                session._fireButtonTrigger(btnFromIndex as theia.QuickInputButton);
+                const btnFromHandle = session.buttons[btn.handle];
+                session._fireButtonTrigger(btnFromHandle as theia.QuickInputButton);
             }
         }
     }

package/src/plugin/secrets-ext.ts

@@ -20,17 +20,37 @@
  *--------------------------------------------------------------------------------------------*/
 // code copied and modified from https://github.com/microsoft/vscode/blob/1.55.2/src/vs/workbench/api/common/extHostSecrets.ts
 
+import { inject, injectable } from '@theia/core/shared/inversify';
 import { Plugin, PLUGIN_RPC_CONTEXT, SecretsExt, SecretsMain } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { Event, Emitter } from '@theia/core/lib/common/event';
+import { Disposable, DisposableGroup } from '@theia/core';
 import * as theia from '@theia/plugin';
 
-export class SecretsExtImpl implements SecretsExt {
+export interface PasswordChange {
+    extensionId: string;
+    key: string;
+}
+
+export const InternalSecretsExt = Symbol('InternalSecretsExt');
+export interface InternalSecretsExt extends SecretsExt {
+    get(extensionId: string, key: string): Promise<string | undefined>;
+
+    store(extensionId: string, key: string, value: string): Promise<void>;
+
+    delete(extensionId: string, key: string): Promise<void>;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onDidChangePassword(listener: (e: PasswordChange) => any, thisArgs?: any, disposables?: DisposableGroup): Disposable;
+}
+
+@injectable()
+export class SecretsExtImpl implements InternalSecretsExt {
     private proxy: SecretsMain;
-    private onDidChangePasswordEmitter = new Emitter<{ extensionId: string, key: string }>();
+    private onDidChangePasswordEmitter = new Emitter<PasswordChange>();
     readonly onDidChangePassword = this.onDidChangePasswordEmitter.event;
 
-    constructor(rpc: RPCProtocol) {
+    constructor(@inject(RPCProtocol) rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.SECRETS_MAIN);
     }
 
@@ -54,12 +74,12 @@ export class SecretsExtImpl implements SecretsExt {
 export class SecretStorageExt implements theia.SecretStorage {
 
     protected readonly id: string;
-    readonly secretState: SecretsExtImpl;
+    readonly secretState: InternalSecretsExt;
 
     private onDidChangeEmitter = new Emitter<theia.SecretStorageChangeEvent>();
     readonly onDidChange: Event<theia.SecretStorageChangeEvent> = this.onDidChangeEmitter.event;
 
-    constructor(pluginDescription: Plugin, secretState: SecretsExtImpl) {
+    constructor(pluginDescription: Plugin, secretState: InternalSecretsExt) {
         this.id = pluginDescription.model.id.toLowerCase();
         this.secretState = secretState;
 

package/src/plugin/terminal-ext.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { UUID } from '@theia/core/shared/@phosphor/coreutils';
+import { inject, injectable } from '@theia/core/shared/inversify';
 import { Terminal, TerminalOptions, PseudoTerminalOptions, ExtensionTerminalOptions, TerminalState } from '@theia/plugin';
 import { TerminalServiceExt, TerminalServiceMain, PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
@@ -46,6 +47,7 @@ export function getIconClass(options: theia.TerminalOptions | theia.ExtensionTer
  * Provides high level terminal plugin api to use in the Theia plugins.
  * This service allow(with help proxy) create and use terminal emulator.
  */
+ @injectable()
 export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     private readonly proxy: TerminalServiceMain;
@@ -75,7 +77,7 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     private readonly onDidChangeShellEmitter = new Emitter<string>();
     readonly onDidChangeShell: theia.Event<string> = this.onDidChangeShellEmitter.event;
 
-    constructor(rpc: RPCProtocol) {
+    constructor(@inject(RPCProtocol) rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TERMINAL_MAIN);
     }
 
@@ -463,8 +465,8 @@ export class TerminalExtImpl implements Terminal {
         this.creationOptions = this.options;
     }
 
-    sendText(text: string, addNewLine: boolean = true): void {
-        this.id.promise.then(id => this.proxy.$sendText(id, text, addNewLine));
+    sendText(text: string, shouldExecute: boolean = true): void {
+        this.id.promise.then(id => this.proxy.$sendText(id, text, shouldExecute));
     }
 
     show(preserveFocus?: boolean): void {