@theia/plugin-ext 1.76.0-next.7 → 1.77.0-next.0

package/src/hosted/browser-only/browser-only-plugin-server.spec.ts

@@ -0,0 +1,228 @@
+// *****************************************************************************
+// Copyright (C) 2026 Robert Jandow
+//
+// 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 { expect } from 'chai';
+import { ILogger } from '@theia/core';
+import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { Container } from '@theia/core/shared/inversify';
+import { LocalStorageService, StorageService } from '@theia/core/lib/browser/storage-service';
+import { PluginPathsService } from '../../main/common/plugin-paths-protocol';
+import { BrowserOnlyPluginServer } from './browser-only-plugin-server';
+import { installFakeLockManager as installNavigatorLocks } from './test/navigator-locks-test-util';
+
+class InMemoryStorageService implements StorageService {
+    readonly data = new Map<string, string>();
+
+    async setData<T>(key: string, data: T): Promise<void> {
+        this.data.set(key, JSON.stringify(data));
+    }
+
+    async getData<T>(key: string, defaultValue?: T): Promise<T | undefined> {
+        const stored = this.data.get(key);
+        return stored === undefined ? defaultValue : JSON.parse(stored);
+    }
+}
+
+/**
+ * Stands for `@theia/workspace`'s `WorkspaceStorageService`, to which `@theia/workspace` rebinds
+ * the plain `StorageService` symbol, prefixing every key with the current workspace.
+ */
+class PrefixingStorageService implements StorageService {
+
+    constructor(private readonly delegate: InMemoryStorageService, private readonly prefix: string) { }
+
+    setData<T>(key: string, data: T): Promise<void> {
+        return this.delegate.setData(`${this.prefix}:${key}`, data);
+    }
+
+    getData<T>(key: string, defaultValue?: T): Promise<T | undefined> {
+        return this.delegate.getData(`${this.prefix}:${key}`, defaultValue);
+    }
+}
+
+const pluginPathsService: PluginPathsService = {
+    getHostLogPath: async () => '/logs/host',
+    getHostStoragePath: async workspaceUri => workspaceUri && `/workspace-storage/${workspaceUri}`
+};
+
+/**
+ * Stand-in for the browser's `LockManager`. Like the real one, it runs requests for the same
+ * lock name one after another.
+ */
+class FakeLockManager {
+    private readonly queues = new Map<string, Promise<unknown>>();
+
+    request<T>(name: string, callback: () => T | PromiseLike<T>): Promise<T> {
+        const previous = this.queues.get(name) ?? Promise.resolve();
+        const run = (async () => {
+            await previous.catch(() => undefined);
+            return callback();
+        })();
+        this.queues.set(name, run.catch(() => undefined));
+        return run;
+    }
+}
+
+/** Installs a {@link FakeLockManager} as `navigator.locks`; see {@link installNavigatorLocks}. */
+function installFakeLockManager(): () => void {
+    return installNavigatorLocks(new FakeLockManager());
+}
+
+describe('BrowserOnlyPluginServer', () => {
+
+    let storageService: InMemoryStorageService;
+
+    function createServer(): BrowserOnlyPluginServer {
+        const container = new Container();
+        container.bind(BrowserOnlyPluginServer).toSelf().inSingletonScope();
+        container.bind(ILogger).to(MockLogger);
+        container.bind<StorageService>(LocalStorageService).toConstantValue(storageService);
+        container.bind(PluginPathsService).toConstantValue(pluginPathsService);
+        return container.get(BrowserOnlyPluginServer);
+    }
+
+    beforeEach(() => {
+        storageService = new InMemoryStorageService();
+    });
+
+    it('keeps global state across sessions', async () => {
+        expect(await createServer().setStorageValue('my.plugin', { count: 1 }, undefined)).to.be.true;
+
+        // a fresh server stands for the next session, reading from the same browser storage
+        expect(await createServer().getStorageValue('my.plugin', undefined)).to.deep.equal({ count: 1 });
+    });
+
+    it('keeps global state independent of a workspace-scoped StorageService binding', async () => {
+        const container = new Container();
+        container.bind(BrowserOnlyPluginServer).toSelf().inSingletonScope();
+        container.bind(ILogger).to(MockLogger);
+        container.bind<StorageService>(LocalStorageService).toConstantValue(storageService);
+        // simulates `@theia/workspace` rebinding the plain `StorageService` symbol; `BrowserOnlyPluginServer`
+        // must ignore it and inject `LocalStorageService` directly, or global state would end up
+        // scoped per workspace too
+        container.bind(StorageService).toConstantValue(new PrefixingStorageService(storageService, 'file:///a'));
+        container.bind(PluginPathsService).toConstantValue(pluginPathsService);
+        const server = container.get(BrowserOnlyPluginServer);
+
+        await server.setStorageValue('my.plugin', { count: 1 }, undefined);
+
+        expect(storageService.data.has('plugin-storage:global')).to.be.true;
+        expect(storageService.data.has('file:///a:plugin-storage:global')).to.be.false;
+    });
+
+    it('keeps workspace state per workspace', async () => {
+        const server = createServer();
+        await server.setStorageValue('my.plugin', { count: 1 }, { workspace: 'file:///a', roots: [] });
+        await server.setStorageValue('my.plugin', { count: 2 }, { workspace: 'file:///b', roots: [] });
+
+        expect(await server.getStorageValue('my.plugin', { workspace: 'file:///a', roots: [] })).to.deep.equal({ count: 1 });
+        expect(await server.getStorageValue('my.plugin', { workspace: 'file:///b', roots: [] })).to.deep.equal({ count: 2 });
+    });
+
+    it('keeps global and workspace state apart', async () => {
+        const server = createServer();
+        await server.setStorageValue('my.plugin', { scope: 'global' }, undefined);
+        await server.setStorageValue('my.plugin', { scope: 'workspace' }, { workspace: 'file:///a', roots: [] });
+
+        expect(await server.getStorageValue('my.plugin', undefined)).to.deep.equal({ scope: 'global' });
+        expect(await server.getAllStorageValues({ workspace: 'file:///a', roots: [] })).to.deep.equal({ 'my.plugin': { scope: 'workspace' } });
+    });
+
+    it('cannot keep workspace state while no workspace is open', async () => {
+        const server = createServer();
+
+        expect(await server.setStorageValue('my.plugin', { count: 1 }, { workspace: undefined, roots: [] })).to.be.false;
+        expect(await server.getAllStorageValues({ workspace: undefined, roots: [] })).to.deep.equal({});
+    });
+
+    it('does not drop what another host stored in the meantime', async () => {
+        const one = createServer();
+        // stands for another tab of the application, running its own plugin host over the same browser storage
+        const other = createServer();
+        await one.setStorageValue('plugin.one', { count: 1 }, undefined);
+        // as the plugin host does on start up, before the other tab writes
+        await one.getAllStorageValues(undefined);
+
+        await other.setStorageValue('plugin.other', { count: 2 }, undefined);
+        await one.setStorageValue('plugin.one', { count: 3 }, undefined);
+
+        expect(await createServer().getAllStorageValues(undefined)).to.deep.equal({
+            'plugin.one': { count: 3 },
+            'plugin.other': { count: 2 }
+        });
+    });
+
+    describe('concurrent writes', () => {
+
+        async function assertNeitherUpdateIsLost(one: BrowserOnlyPluginServer, other: BrowserOnlyPluginServer): Promise<void> {
+            // start both writes before awaiting either, so they actually overlap
+            await Promise.all([
+                one.setStorageValue('plugin.one', { count: 1 }, undefined),
+                other.setStorageValue('plugin.other', { count: 2 }, undefined)
+            ]);
+
+            expect(await createServer().getAllStorageValues(undefined)).to.deep.equal({
+                'plugin.one': { count: 1 },
+                'plugin.other': { count: 2 }
+            });
+        }
+
+        it('does not lose either update from two tabs, serialized via the Web Locks API', async () => {
+            const restore = installFakeLockManager();
+            try {
+                // one server per tab, sharing the same browser storage
+                await assertNeitherUpdateIsLost(createServer(), createServer());
+            } finally {
+                restore();
+            }
+        });
+
+        it('does not lose either update within one tab when the Web Locks API is unavailable', async () => {
+            const server = createServer();
+            await assertNeitherUpdateIsLost(server, server);
+        });
+    });
+
+    it('drops a value that is set to nothing', async () => {
+        const server = createServer();
+        await server.setStorageValue('my.plugin', { count: 1 }, undefined);
+
+        await server.setStorageValue('my.plugin', {}, undefined);
+
+        expect(await createServer().getAllStorageValues(undefined)).to.deep.equal({});
+    });
+
+    it('answers with an empty value for an unknown key', async () => {
+        expect(await createServer().getStorageValue('my.plugin', undefined)).to.deep.equal({});
+    });
+
+    it('rejects changing the deployed plugins', async () => {
+        const server = createServer();
+
+        await server.install('my.plugin').then(
+            () => expect.fail('should have rejected'),
+            error => expect(error.message).to.contain('browser-only'));
+        await server.uninstall('theia.a@1.0.0').then(
+            () => expect.fail('should have rejected'),
+            error => expect(error.message).to.contain('browser-only'));
+        await server.enablePlugin('theia.a').then(
+            () => expect.fail('should have rejected'),
+            error => expect(error.message).to.contain('browser-only'));
+        await server.disablePlugin('theia.a').then(
+            () => expect.fail('should have rejected'),
+            error => expect(error.message).to.contain('browser-only'));
+    });
+});

package/src/hosted/browser-only/browser-only-plugin-server.ts

@@ -0,0 +1,165 @@
+// *****************************************************************************
+// Copyright (C) 2026 Robert Jandow
+//
+// 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 { inject, injectable, named } from '@theia/core/shared/inversify';
+import { Mutex } from 'async-mutex';
+import { ILogger, nls } from '@theia/core';
+import { LocalStorageService, StorageService } from '@theia/core/lib/browser/storage-service';
+import { PluginDeployOptions, PluginIdentifiers, PluginServer, PluginStorageKind, PluginType } from '../../common';
+import { KeysToAnyValues, KeysToKeysToAnyValue } from '../../common/types';
+import { PluginPathsService } from '../../main/common/plugin-paths-protocol';
+
+const GLOBAL_STORAGE_KEY = 'plugin-storage:global';
+const WORKSPACE_STORAGE_KEY_PREFIX = 'plugin-storage:workspace:';
+const LOCK_NAME_PREFIX = 'theia:plugin-storage:';
+
+/**
+ * Plugins of a browser-only application are deployed at build time, so they can't be installed,
+ * uninstalled, enabled or disabled at runtime. The queries just report an empty result instead
+ * of failing, so callers like the plugin view still have something to render.
+ *
+ * The plugin key-value storage backing `ExtensionContext.globalState` and
+ * `ExtensionContext.workspaceState` lives in the browser's local storage.
+ */
+@injectable()
+export class BrowserOnlyPluginServer implements PluginServer {
+
+    @inject(ILogger) @named('plugin-ext:BrowserOnlyPluginServer')
+    protected readonly logger: ILogger;
+
+    // `@theia/workspace` rebinds `StorageService` to `WorkspaceStorageService`, which prefixes every
+    // key with the current workspace URI. That would scope `GLOBAL_STORAGE_KEY` per workspace too,
+    // so `LocalStorageService` is injected directly instead - the workspace store key already
+    // encodes the workspace via `PluginPathsService.getHostStoragePath`.
+    @inject(LocalStorageService)
+    protected readonly storageService: StorageService;
+
+    @inject(PluginPathsService)
+    protected readonly pluginPathsService: PluginPathsService;
+
+    /** Fallback for {@link withStoreLock} when the Web Locks API is unavailable. */
+    protected readonly localLock = new Mutex();
+    protected missingLocksWarned = false;
+
+    async install(pluginEntry: string, type?: PluginType, options?: PluginDeployOptions): Promise<void> {
+        throw new Error(nls.localize('theia/plugin-ext/browserOnlyInstallUnsupported', 'Installing plugins is not supported in a browser-only application.'));
+    }
+
+    async uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
+        throw new Error(nls.localize('theia/plugin-ext/browserOnlyUninstallUnsupported', 'Uninstalling plugins is not supported in a browser-only application.'));
+    }
+
+    async enablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
+        throw new Error(nls.localize('theia/plugin-ext/browserOnlyEnableUnsupported', 'Enabling plugins is not supported in a browser-only application.'));
+    }
+
+    async disablePlugin(pluginId: PluginIdentifiers.UnversionedId): Promise<boolean> {
+        throw new Error(nls.localize('theia/plugin-ext/browserOnlyDisableUnsupported', 'Disabling plugins is not supported in a browser-only application.'));
+    }
+
+    async getInstalledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return [];
+    }
+
+    async getUninstalledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return [];
+    }
+
+    async getDisabledPlugins(): Promise<readonly PluginIdentifiers.UnversionedId[]> {
+        return [];
+    }
+
+    async setStorageValue(key: string, value: KeysToAnyValues, kind: PluginStorageKind): Promise<boolean> {
+        const storeKey = await this.getStoreKey(kind);
+        if (!storeKey) {
+            this.logger.warn('Cannot save plugin data: no opened workspace.');
+            return false;
+        }
+        // the browser storage is shared with this application's other tabs, each running its own
+        // plugin host, so the read and write below need to be atomic - otherwise a concurrent
+        // update from another tab could land in between and get overwritten by this one
+        await this.withStoreLock(storeKey, async () => {
+            const store = await this.getStore(storeKey);
+            if (value === undefined || Object.keys(value).length === 0) {
+                delete store[key];
+            } else {
+                store[key] = value;
+            }
+            await this.storageService.setData(storeKey, store);
+        });
+        return true;
+    }
+
+    async getStorageValue(key: string, kind: PluginStorageKind): Promise<KeysToAnyValues> {
+        return (await this.getAllStorageValues(kind))[key] ?? {};
+    }
+
+    async getAllStorageValues(kind: PluginStorageKind): Promise<KeysToKeysToAnyValue> {
+        const storeKey = await this.getStoreKey(kind);
+        return storeKey ? this.getStore(storeKey) : {};
+    }
+
+    protected getStore(storeKey: string): Promise<KeysToKeysToAnyValue> {
+        return this.storageService.getData<KeysToKeysToAnyValue>(storeKey, {});
+    }
+
+    /**
+     * Runs `task` while holding the cross-tab lock for `storeKey`, via the Web Locks API, so a
+     * concurrent {@link setStorageValue} on this or another tab can't interleave with it.
+     */
+    protected withStoreLock<T>(storeKey: string, task: () => Promise<T>): Promise<T> {
+        const locks = this.getWebLocks();
+        if (locks) {
+            return this.requestLock(locks, `${LOCK_NAME_PREFIX}${storeKey}`, task);
+        }
+        // no Web Locks API (insecure context, older browser): fall back to serializing writes
+        // within this tab. A write from another tab can still race and get lost.
+        if (!this.missingLocksWarned) {
+            this.missingLocksWarned = true;
+            this.logger.warn('Web Locks API unavailable: plugin storage updates from different tabs may race.');
+        }
+        return this.localLock.runExclusive(task);
+    }
+
+    /** The Web Locks API of this browsing context, or `undefined` in an insecure context or an older browser. */
+    protected getWebLocks(): LockManager | undefined {
+        return typeof navigator === 'object' ? navigator.locks : undefined;
+    }
+
+    /**
+     * Requests `name` from `locks` and runs `callback` once granted, same as `LockManager.request()`.
+     *
+     * `LockGrantedCallback` is typed as `(lock: Lock | null) => T`, which doesn't account for an
+     * async or never-settling callback even though the API itself supports and awaits one, hence
+     * the cast. Kept as its own method so a subclass or test can swap the lock implementation.
+     */
+    protected requestLock<T>(locks: LockManager, name: string, callback: () => T | PromiseLike<T>): Promise<T> {
+        return locks.request<T>(name, callback as unknown as LockGrantedCallback<T>);
+    }
+
+    /**
+     * The browser storage key holding the given kind of values, or `undefined` if there's
+     * nowhere to keep them - e.g. workspace state while no workspace is open.
+     */
+    protected async getStoreKey(kind: PluginStorageKind): Promise<string | undefined> {
+        if (!kind) {
+            return GLOBAL_STORAGE_KEY;
+        }
+        // derived from the storage path so workspace state follows `ExtensionContext.storageUri`
+        const storagePath = await this.pluginPathsService.getHostStoragePath(kind.workspace, kind.roots);
+        return storagePath && `${WORKSPACE_STORAGE_KEY_PREFIX}${storagePath}`;
+    }
+}

package/src/hosted/browser-only/test/navigator-locks-test-util.ts

@@ -0,0 +1,54 @@
+// *****************************************************************************
+// Copyright (C) 2026 Robert Jandow
+//
+// 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
+// *****************************************************************************
+
+/**
+ * The subset of `LockManager` that the fakes in these tests actually implement. The real
+ * `LockManager.request()` is overloaded with an optional `options` parameter that none of our
+ * fakes need, so typing {@link installFakeLockManager} directly against the DOM `LockManager`
+ * interface would reject every fake as an incompatible overload - we cast to the real type just
+ * once instead, at the point where the fake gets installed as `navigator.locks`.
+ */
+export interface FakeLockManager {
+    request<T>(name: string, callback: () => T | PromiseLike<T>): Promise<T>;
+    query?(): Promise<{ held?: Array<{ name?: string }> }>;
+}
+
+/**
+ * Installs `manager` as `navigator.locks` and returns a function that restores whatever was
+ * there before. Doesn't assume `navigator` is even defined: `enableJSDOM()`/`disableJSDOM()`
+ * (see `packages/core/src/browser/test/jsdom.ts`) deletes the global `navigator` that Node
+ * normally provides as a side effect of disabling jsdom, and depending on which spec files ran
+ * earlier in this mocha process, it may already be gone by the time a test runs.
+ */
+export function installFakeLockManager(manager: FakeLockManager): () => void {
+    const target = globalThis as { navigator?: { locks?: unknown } };
+    const hadNavigator = typeof navigator !== 'undefined';
+    if (!hadNavigator) {
+        Object.defineProperty(target, 'navigator', { value: {}, configurable: true });
+    }
+    const originalLocks = Object.getOwnPropertyDescriptor(navigator, 'locks');
+    Object.defineProperty(navigator, 'locks', { value: manager as unknown as LockManager, configurable: true });
+
+    return () => {
+        if (!hadNavigator) {
+            delete target.navigator;
+        } else if (originalLocks) {
+            Object.defineProperty(navigator, 'locks', originalLocks);
+        } else {
+            delete (navigator as { locks?: unknown }).locks;
+        }
+    };
+}

package/src/hosted/common/hosted-plugin.ts

@@ -23,7 +23,7 @@
 
 import debounce = require('@theia/core/shared/lodash.debounce');
 import { injectable, inject, interfaces, named, postConstruct, unmanaged } from '@theia/core/shared/inversify';
-import { PluginMetadata, HostedPluginServer, DeployedPlugin, PluginServer, PluginIdentifiers } from '../../common/plugin-protocol';
+import { PluginMetadata, HostedPluginServer, DeployedPlugin, PluginServer, PluginIdentifiers, PLUGIN_HOST_FRONTEND } from '../../common/plugin-protocol';
 import { AbstractPluginManagerExt, ConfigStorage } from '../../common/plugin-api-rpc';
 import {
     Disposable, DisposableCollection, Emitter,
@@ -37,7 +37,7 @@ import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { environment } from '@theia/core/shared/@theia/application-package/lib/environment';
 import { Measurement, Stopwatch } from '@theia/core/lib/common';
 
-export type PluginHost = 'frontend' | string;
+export type PluginHost = typeof PLUGIN_HOST_FRONTEND | string;
 
 export const ALL_ACTIVATION_EVENT = '*';
 
@@ -336,7 +336,7 @@ export abstract class AbstractHostedPluginSupport<PM extends AbstractPluginManag
 
             if (contributions.state === PluginContributions.State.LOADED) {
                 contributions.state = PluginContributions.State.STARTING;
-                const host = plugin.model.entryPoint.frontend ? 'frontend' : plugin.host;
+                const host = plugin.model.entryPoint.frontend ? PLUGIN_HOST_FRONTEND : plugin.host;
                 const dynamicContributions = hostContributions.get(host) || [];
                 dynamicContributions.push(contributions);
                 hostContributions.set(host, dynamicContributions);
@@ -381,7 +381,7 @@ export abstract class AbstractHostedPluginSupport<PM extends AbstractPluginManag
 
         for (const [host, hostContributions] of contributionsByHost) {
             // do not start plugins for electron browser
-            if (host === 'frontend' && environment.electron.is()) {
+            if (host === PLUGIN_HOST_FRONTEND && environment.electron.is()) {
                 continue;
             }
 

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

@@ -39,6 +39,7 @@ import { setupPluginHostLogger } from './plugin-host-logger';
 import { LmExtImpl } from '../../plugin/lm-ext';
 import { LanguageModelToolsExtImpl } from '../../plugin/lm-tool-ext';
 import { EncodingService } from '@theia/core/lib/common/encoding-service';
+import { TelemetryExtImpl } from '../../plugin/telemetry-ext';
 
 export default new ContainerModule(bind => {
     const channel = new IPCChannel();
@@ -76,4 +77,5 @@ export default new ContainerModule(bind => {
     bind(WebviewsExtImpl).toSelf().inSingletonScope();
     bind(MinimalTerminalServiceExt).toService(TerminalServiceExtImpl);
     bind(TerminalServiceExtImpl).toSelf().inSingletonScope();
+    bind(TelemetryExtImpl).toSelf().inSingletonScope();
 });

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

@@ -31,6 +31,7 @@ import {
 import { PluginMetadata, PluginModel, PluginPackage } from '../../common/plugin-protocol';
 import { createAPIFactory } from '../../plugin/plugin-context';
 import { EnvExtImpl } from '../../plugin/env';
+import { TelemetryExtImpl } from '../../plugin/telemetry-ext';
 import { PreferenceRegistryExtImpl } from '../../plugin/preference-registry';
 import { ExtPluginApi, ExtPluginApiBackendInitializationFn } from '../../common/plugin-ext-api-contribution';
 import { DebugExtImpl } from '../../plugin/debug/debug-ext';
@@ -64,7 +65,8 @@ export interface ExtInterfaces {
     webviewExt: WebviewsExtImpl,
     terminalServiceExt: TerminalServiceExtImpl,
     secretsExt: SecretsExtImpl,
-    localizationExt: LocalizationExtImpl
+    localizationExt: LocalizationExtImpl,
+    telemetryExt: TelemetryExtImpl
 }
 
 /**
@@ -352,6 +354,9 @@ export class PluginHostRPC extends AbstractPluginHostRPC<PluginManagerExtImpl, P
     @inject(SecretsExtImpl)
     protected readonly secretsExt: SecretsExtImpl;
 
+    @inject(TelemetryExtImpl)
+    protected readonly telemetryExt: TelemetryExtImpl;
+
     constructor() {
         super('PLUGIN_HOST', '/scanners/backend-init-theia.js',
             {
@@ -380,18 +385,19 @@ export class PluginHostRPC extends AbstractPluginHostRPC<PluginManagerExtImpl, P
             webviewExt: this.webviewExt,
             terminalServiceExt: this.terminalServiceExt,
             secretsExt: this.secretsExt,
-            localizationExt: this.localizationExt
+            localizationExt: this.localizationExt,
+            telemetryExt: this.telemetryExt
         };
     }
 
     protected createAPIFactory(extInterfaces: ExtInterfaces): PluginAPIFactory {
         const {
             envExt, debugExt, preferenceRegistryExt, editorsAndDocumentsExt, workspaceExt,
-            messageRegistryExt, clipboardExt, webviewExt, localizationExt
+            messageRegistryExt, clipboardExt, webviewExt, localizationExt, telemetryExt
         } = extInterfaces;
         return createAPIFactory(this.rpc, this.pluginManager, envExt, debugExt, preferenceRegistryExt,
             editorsAndDocumentsExt, workspaceExt, messageRegistryExt, clipboardExt, webviewExt,
-            localizationExt);
+            localizationExt, telemetryExt);
     }
 
     protected initExtApi(extApi: ExtPluginApi): void {