@theia/plugin-ext 1.37.0-next.8 → 1.37.0

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

@@ -49,7 +49,8 @@ import { WaitUntilEvent } from '@theia/core/lib/common/event';
 import { FileSearchService } from '@theia/file-search/lib/common/file-search-service';
 import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
 import { PluginViewRegistry } from '../../main/browser/view/plugin-view-registry';
-import { TaskProviderRegistry, TaskResolverRegistry } from '@theia/task/lib/browser/task-contribution';
+import { WillResolveTaskProvider, TaskProviderRegistry, TaskResolverRegistry } from '@theia/task/lib/browser/task-contribution';
+import { TaskDefinitionRegistry } from '@theia/task/lib/browser/task-definition-registry';
 import { WebviewEnvironment } from '../../main/browser/webview/webview-environment';
 import { WebviewWidget } from '../../main/browser/webview/webview';
 import { WidgetManager } from '@theia/core/lib/browser/widget-manager';
@@ -73,6 +74,7 @@ export type PluginHost = 'frontend' | string;
 export type DebugActivationEvent = 'onDebugResolve' | 'onDebugInitialConfigurations' | 'onDebugAdapterProtocolTracker' | 'onDebugDynamicConfigurations';
 
 export const PluginProgressLocation = 'plugin';
+export const ALL_ACTIVATION_EVENT = '*';
 
 @injectable()
 export class HostedPluginSupport {
@@ -139,6 +141,9 @@ export class HostedPluginSupport {
     @inject(TaskResolverRegistry)
     protected readonly taskResolverRegistry: TaskResolverRegistry;
 
+    @inject(TaskDefinitionRegistry)
+    protected readonly taskDefinitionRegistry: TaskDefinitionRegistry;
+
     @inject(ProgressService)
     protected readonly progressService: ProgressService;
 
@@ -205,7 +210,7 @@ export class HostedPluginSupport {
         this.debugSessionManager.onWillResolveDebugConfiguration(event => this.ensureDebugActivation(event, 'onDebugResolve', event.debugType));
         this.debugConfigurationManager.onWillProvideDebugConfiguration(event => this.ensureDebugActivation(event, 'onDebugInitialConfigurations'));
         // Activate all providers of dynamic configurations, i.e. Let the user pick a configuration from all the available ones.
-        this.debugConfigurationManager.onWillProvideDynamicDebugConfiguration(event => this.ensureDebugActivation(event, 'onDebugDynamicConfigurations', '*'));
+        this.debugConfigurationManager.onWillProvideDynamicDebugConfiguration(event => this.ensureDebugActivation(event, 'onDebugDynamicConfigurations', ALL_ACTIVATION_EVENT));
         this.viewRegistry.onDidExpandView(id => this.activateByView(id));
         this.taskProviderRegistry.onWillProvideTaskProvider(event => this.ensureTaskActivation(event));
         this.taskResolverRegistry.onWillProvideTaskResolver(event => this.ensureTaskActivation(event));
@@ -510,7 +515,7 @@ export class HostedPluginSupport {
                 workspaceState,
                 env: {
                     queryParams: getQueryParameters(),
-                    language: nls.locale || 'en',
+                    language: nls.locale || nls.defaultLocale,
                     shell: defaultShell,
                     uiKind: isElectron ? UIKind.Desktop : UIKind.Web,
                     appName: FrontendApplicationConfigProvider.get().applicationName,
@@ -610,6 +615,10 @@ export class HostedPluginSupport {
         await this.activateByEvent(`onCommand:${commandId}`);
     }
 
+    async activateByTaskType(taskType: string): Promise<void> {
+        await this.activateByEvent(`onTaskType:${taskType}`);
+    }
+
     async activateByCustomEditor(viewType: string): Promise<void> {
         await this.activateByEvent(`onCustomEditor:${viewType}`);
     }
@@ -648,8 +657,20 @@ export class HostedPluginSupport {
         event.waitUntil(p);
     }
 
-    protected ensureTaskActivation(event: WaitUntilEvent): void {
-        event.waitUntil(this.activateByCommand('workbench.action.tasks.runTask'));
+    protected ensureTaskActivation(event: WillResolveTaskProvider): void {
+        const promises = [this.activateByCommand('workbench.action.tasks.runTask')];
+        const taskType = event.taskType;
+        if (taskType) {
+            if (taskType === ALL_ACTIVATION_EVENT) {
+                for (const taskDefinition of this.taskDefinitionRegistry.getAll()) {
+                    promises.push(this.activateByTaskType(taskDefinition.taskType));
+                }
+            } else {
+                promises.push(this.activateByTaskType(taskType));
+            }
+        }
+
+        event.waitUntil(Promise.all(promises));
     }
 
     protected ensureDebugActivation(event: WaitUntilEvent, activationEvent?: DebugActivationEvent, debugType?: string): void {
@@ -678,7 +699,7 @@ export class HostedPluginSupport {
         for (const activationEvent of activationEvents) {
             if (/^workspaceContains:/.test(activationEvent)) {
                 const fileNameOrGlob = activationEvent.substr('workspaceContains:'.length);
-                if (fileNameOrGlob.indexOf('*') >= 0 || fileNameOrGlob.indexOf('?') >= 0) {
+                if (fileNameOrGlob.indexOf(ALL_ACTIVATION_EVENT) >= 0 || fileNameOrGlob.indexOf('?') >= 0) {
                     includePatterns.push(fileNameOrGlob);
                 } else {
                     paths.push(fileNameOrGlob);

package/src/hosted/browser/worker/worker-main.ts

@@ -36,6 +36,7 @@ import { WorkspaceExtImpl } from '../../../plugin/workspace';
 import { createDebugExtStub } from './debug-stub';
 import { loadManifest } from './plugin-manifest-loader';
 import { WorkerEnvExtImpl } from './worker-env-ext';
+import { LocalizationExtImpl } from '../../../plugin/localization-ext';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const ctx = self as any;
@@ -77,6 +78,7 @@ const debugExt = createDebugExtStub(rpc);
 const clipboardExt = new ClipboardExt(rpc);
 const webviewExt = new WebviewsExtImpl(rpc, workspaceExt);
 const secretsExt = new SecretsExtImpl(rpc);
+const localizationExt = new LocalizationExtImpl(rpc);
 const terminalService: TerminalServiceExt = new TerminalServiceExtImpl(rpc);
 
 const pluginManager = new PluginManagerExtImpl({
@@ -171,7 +173,7 @@ const pluginManager = new PluginManagerExtImpl({
             }
         }
     }
-}, envExt, terminalService, storageProxy, secretsExt, preferenceRegistryExt, webviewExt, rpc);
+}, envExt, terminalService, storageProxy, secretsExt, preferenceRegistryExt, webviewExt, localizationExt, rpc);
 
 const apiFactory = createAPIFactory(
     rpc,
@@ -183,7 +185,8 @@ const apiFactory = createAPIFactory(
     workspaceExt,
     messageRegistryExt,
     clipboardExt,
-    webviewExt
+    webviewExt,
+    localizationExt
 );
 let defaultApi: typeof theia;
 

package/src/hosted/node/hosted-plugin-deployer-handler.ts

@@ -133,7 +133,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             if (await this.deployPlugin(plugin, 'backend')) { successes++; }
         }
         // rebuild translation config after deployment
-        this.localizationService.buildTranslationConfig([...this.deployedBackendPlugins.values()]);
+        await this.localizationService.buildTranslationConfig([...this.deployedBackendPlugins.values()]);
         // resolve on first deploy
         this.backendPluginsMetadataDeferred.resolve(undefined);
         return successes;
@@ -174,7 +174,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             const { type } = entry;
             const deployed: DeployedPlugin = { metadata, type };
             deployed.contributes = this.reader.readContribution(manifest);
-            this.localizationService.deployLocalizations(deployed);
+            await this.localizationService.deployLocalizations(deployed);
             deployedPlugins.set(id, deployed);
             deployPlugin.debug(`Deployed ${entryPoint} plugin "${id}" from "${metadata.model.entryPoint[entryPoint] || pluginPath}"`);
         } catch (e) {

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

@@ -19,12 +19,12 @@ import * as fs from '@theia/core/shared/fs-extra';
 import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
 import { Localization } from '@theia/core/lib/common/i18n/localization';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { DeployedPlugin, Localization as PluginLocalization, PluginIdentifiers } from '../../common';
-import { URI } from '@theia/core/shared/vscode-uri';
+import { DeployedPlugin, Localization as PluginLocalization, PluginIdentifiers, Translation } from '../../common';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { BackendApplicationContribution } from '@theia/core/lib/node';
-import { Disposable, isObject, MaybePromise } from '@theia/core';
+import { Disposable, DisposableCollection, isObject, MaybePromise, nls, URI } from '@theia/core';
 import { Deferred } from '@theia/core/lib/common/promise-util';
+import { LanguagePackBundle, LanguagePackService } from '../../common/language-pack-service';
 
 export interface VSCodeNlsConfig {
     locale: string
@@ -42,6 +42,9 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
     @inject(LocalizationProvider)
     protected readonly localizationProvider: LocalizationProvider;
 
+    @inject(LanguagePackService)
+    protected readonly languagePackService: LanguagePackService;
+
     @inject(EnvVariablesServer)
     protected readonly envVariables: EnvVariablesServer;
 
@@ -62,26 +65,93 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
             .then(() => this._ready.resolve());
     }
 
-    deployLocalizations(plugin: DeployedPlugin): void {
+    async deployLocalizations(plugin: DeployedPlugin): Promise<void> {
+        const disposable = new DisposableCollection();
         if (plugin.contributes?.localizations) {
+            // Indicator that this plugin is a vscode language pack
+            // Language packs translate Theia and some builtin vscode extensions
             const localizations = buildLocalizations(plugin.contributes.localizations);
-            const versionedId = PluginIdentifiers.componentsToVersionedId(plugin.metadata.model);
-            this.localizationDisposeMap.set(versionedId, Disposable.create(() => {
+            disposable.push(Disposable.create(() => {
                 this.localizationProvider.removeLocalizations(...localizations);
-                this.localizationDisposeMap.delete(versionedId);
             }));
             this.localizationProvider.addLocalizations(...localizations);
         }
+        if (plugin.metadata.model.l10n || plugin.contributes?.localizations) {
+            // Indicator that this plugin is a vscode language pack or has its own localization bundles
+            // These bundles are purely used for translating plugins
+            // The branch above builds localizations for Theia's own strings
+            disposable.push(await this.updateLanguagePackBundles(plugin));
+        }
+        if (!disposable.disposed) {
+            const versionedId = PluginIdentifiers.componentsToVersionedId(plugin.metadata.model);
+            disposable.push(Disposable.create(() => {
+                this.localizationDisposeMap.delete(versionedId);
+            }));
+            this.localizationDisposeMap.set(versionedId, disposable);
+        }
     }
 
     undeployLocalizations(plugin: PluginIdentifiers.VersionedId): void {
         this.localizationDisposeMap.get(plugin)?.dispose();
     }
 
+    protected async updateLanguagePackBundles(plugin: DeployedPlugin): Promise<Disposable> {
+        const disposable = new DisposableCollection();
+        const pluginId = plugin.metadata.model.id;
+        const packageUri = new URI(plugin.metadata.model.packageUri);
+        if (plugin.contributes?.localizations) {
+            for (const localization of plugin.contributes.localizations) {
+                for (const translation of localization.translations) {
+                    const l10n = getL10nTranslation(translation);
+                    if (l10n) {
+                        const translatedPluginId = translation.id;
+                        const translationUri = packageUri.resolve(translation.path);
+                        const locale = localization.languageId;
+                        // We store a bundle for another extension in here
+                        // Hence we use `translatedPluginId` instead of `pluginId`
+                        this.languagePackService.storeBundle(translatedPluginId, locale, {
+                            contents: processL10nBundle(l10n),
+                            uri: translationUri.toString()
+                        });
+                        disposable.push(Disposable.create(() => {
+                            // Only dispose the deleted locale for the specific plugin
+                            this.languagePackService.deleteBundle(translatedPluginId, locale);
+                        }));
+                    }
+                }
+            }
+        }
+        // The `l10n` field of the plugin model points to a relative directory path within the plugin
+        // It is supposed to contain localization bundles that contain translations of the plugin strings into different languages
+        if (plugin.metadata.model.l10n) {
+            const bundleDirectory = packageUri.resolve(plugin.metadata.model.l10n);
+            const bundles = await loadPluginBundles(bundleDirectory);
+            if (bundles) {
+                for (const [locale, bundle] of Object.entries(bundles)) {
+                    this.languagePackService.storeBundle(pluginId, locale, bundle);
+                }
+                disposable.push(Disposable.create(() => {
+                    // Dispose all bundles contributed by the deleted plugin
+                    this.languagePackService.deleteBundle(pluginId);
+                }));
+            }
+        }
+        return disposable;
+    }
+
+    /**
+     * Performs localization of the plugin model. Translates entries such as command names, view names and other items.
+     *
+     * Translatable items are indicated with a `%id%` value.
+     * The `id` is the translation key that gets replaced with the localized value for the currently selected language.
+     *
+     * Returns a copy of the plugin argument and does not modify the argument.
+     * This is done to preserve the original `%id%` values for subsequent invocations of this method.
+     */
     async localizePlugin(plugin: DeployedPlugin): Promise<DeployedPlugin> {
         const currentLanguage = this.localizationProvider.getCurrentLanguage();
         const localization = this.localizationProvider.loadLocalization(currentLanguage);
-        const pluginPath = URI.parse(plugin.metadata.model.packageUri).fsPath;
+        const pluginPath = new URI(plugin.metadata.model.packageUri).path.fsPath();
         const pluginId = plugin.metadata.model.id;
         try {
             const translations = await loadPackageTranslations(pluginPath, currentLanguage);
@@ -98,7 +168,7 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
     getNlsConfig(): VSCodeNlsConfig {
         const locale = this.localizationProvider.getCurrentLanguage();
         const configFile = this.translationConfigFiles.get(locale);
-        if (locale === 'en' || !configFile) {
+        if (locale === nls.defaultLocale || !configFile) {
             return { locale, availableLanguages: {} };
         }
         const cache = path.dirname(configFile);
@@ -118,7 +188,7 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
         const configs = new Map<string, Record<string, string>>();
         for (const plugin of plugins) {
             if (plugin.contributes?.localizations) {
-                const pluginPath = URI.parse(plugin.metadata.model.packageUri).fsPath;
+                const pluginPath = new URI(plugin.metadata.model.packageUri).path.fsPath();
                 for (const localization of plugin.contributes.localizations) {
                     const config = configs.get(localization.languageId) || {};
                     for (const translation of localization.translations) {
@@ -140,12 +210,59 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
     }
 
     protected async getLocalizationCacheDir(): Promise<string> {
-        const configDir = URI.parse(await this.envVariables.getConfigDirUri()).fsPath;
+        const configDir = new URI(await this.envVariables.getConfigDirUri()).path.fsPath();
         const cacheDir = path.join(configDir, 'localization-cache');
         return cacheDir;
     }
 }
 
+// New plugin localization logic using vscode.l10n
+
+function getL10nTranslation(translation: Translation): UnprocessedL10nBundle | undefined {
+    // 'bundle' is a special key that contains all translations for the l10n vscode API
+    // If that doesn't exist, we can assume that the language pack is using the old vscode-nls API
+    return translation.contents.bundle;
+}
+
+async function loadPluginBundles(l10nUri: URI): Promise<Record<string, LanguagePackBundle> | undefined> {
+    try {
+        const directory = l10nUri.path.fsPath();
+        const files = await fs.readdir(directory);
+        const result: Record<string, LanguagePackBundle> = {};
+        await Promise.all(files.map(async fileName => {
+            const match = fileName.match(/^bundle\.l10n\.([\w\-]+)\.json$/);
+            if (match) {
+                const locale = match[1];
+                const contents = await fs.readJSON(path.join(directory, fileName));
+                result[locale] = {
+                    contents,
+                    uri: l10nUri.resolve(fileName).toString()
+                };
+            }
+        }));
+        return result;
+    } catch (err) {
+        // The directory either doesn't exist or its contents cannot be parsed
+        console.error(`Failed to load plugin localization bundles from ${l10nUri}.`, err);
+        // In any way we should just safely return undefined
+        return undefined;
+    }
+}
+
+type UnprocessedL10nBundle = Record<string, string | { message: string }>;
+
+function processL10nBundle(bundle: UnprocessedL10nBundle): Record<string, string> {
+    const processedBundle: Record<string, string> = {};
+    for (const [name, value] of Object.entries(bundle)) {
+        const stringValue = typeof value === 'string' ? value : value.message;
+        processedBundle[name] = stringValue;
+    }
+    return processedBundle;
+}
+
+// Old plugin localization logic for vscode-nls
+// vscode-nls was used until version 1.73 of VSCode to translate extensions
+
 function buildLocalizations(localizations: PluginLocalization[]): Localization[] {
     const theiaLocalizations: Localization[] = [];
     for (const localization of localizations) {
@@ -173,6 +290,10 @@ function buildTranslationKey(pluginId: string, scope: string, key: string): stri
     return `${pluginId}/${Localization.transformKey(scope)}/${key}`;
 }
 
+// Localization logic for `package.json` entries
+// Extensions can use `package.nls.json` files to store translations for values in their package.json
+// This logic has not changed with the introduction of the vscode.l10n API
+
 interface PackageTranslation {
     translation?: Record<string, string>
     default?: Record<string, string>

package/src/hosted/node/plugin-ext-hosted-backend-module.ts

@@ -34,6 +34,10 @@ import { HostedPluginDeployerHandler } from './hosted-plugin-deployer-handler';
 import { PluginUriFactory } from './scanners/plugin-uri-factory';
 import { FilePluginUriFactory } from './scanners/file-plugin-uri-factory';
 import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
+import { LanguagePackService, languagePackServicePath } from '../../common/language-pack-service';
+import { PluginLanguagePackService } from './plugin-language-pack-service';
+import { JsonRpcConnectionHandler } from '@theia/core/lib/common/messaging/proxy-factory';
+import { ConnectionHandler } from '@theia/core/lib/common/messaging/handler';
 
 const commonHostedConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService }) => {
     bind(HostedPluginProcess).toSelf().inSingletonScope();
@@ -64,6 +68,14 @@ export function bindCommonHostedBackend(bind: interfaces.Bind): void {
     bind(HostedPluginDeployerHandler).toSelf().inSingletonScope();
     bind(PluginDeployerHandler).toService(HostedPluginDeployerHandler);
 
+    bind(PluginLanguagePackService).toSelf().inSingletonScope();
+    bind(LanguagePackService).toService(PluginLanguagePackService);
+    bind(ConnectionHandler).toDynamicValue(ctx =>
+        new JsonRpcConnectionHandler(languagePackServicePath, () =>
+            ctx.container.get(LanguagePackService)
+        )
+    ).inSingletonScope();
+
     bind(GrammarsReader).toSelf().inSingletonScope();
     bind(HostedPluginProcessConfiguration).toConstantValue({
         path: path.join(__dirname, 'plugin-host'),

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

@@ -16,7 +16,7 @@
 
 import { dynamicRequire } from '@theia/core/lib/node/dynamic-require';
 import { PluginManagerExtImpl } from '../../plugin/plugin-manager';
-import { MAIN_RPC_CONTEXT, Plugin, PluginAPIFactory } from '../../common/plugin-api-rpc';
+import { LocalizationExt, MAIN_RPC_CONTEXT, Plugin, PluginAPIFactory } from '../../common/plugin-api-rpc';
 import { PluginMetadata } from '../../common/plugin-protocol';
 import { createAPIFactory } from '../../plugin/plugin-context';
 import { EnvExtImpl } from '../../plugin/env';
@@ -35,6 +35,7 @@ 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';
 
 /**
  * Handle the RPC calls.
@@ -61,7 +62,8 @@ export class PluginHostRPC {
         const webviewExt = new WebviewsExtImpl(this.rpc, workspaceExt);
         const terminalService = new TerminalServiceExtImpl(this.rpc);
         const secretsExt = new SecretsExtImpl(this.rpc);
-        this.pluginManager = this.createPluginManager(envExt, terminalService, storageProxy, preferenceRegistryExt, webviewExt, secretsExt, 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);
@@ -80,7 +82,8 @@ export class PluginHostRPC {
             workspaceExt,
             messageRegistryExt,
             clipboardExt,
-            webviewExt
+            webviewExt,
+            localizationExt
         );
         connectProxyResolver(workspaceExt, preferenceRegistryExt);
     }
@@ -102,7 +105,7 @@ export class PluginHostRPC {
 
     createPluginManager(
         envExt: EnvExtImpl, terminalService: TerminalServiceExtImpl, storageProxy: KeyValueStorageProxy,
-        preferencesManager: PreferenceRegistryExtImpl, webview: WebviewsExtImpl, secretsExt: SecretsExtImpl,
+        preferencesManager: PreferenceRegistryExtImpl, webview: WebviewsExtImpl, secretsExt: SecretsExtImpl, localization: LocalizationExt,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rpc: any
     ): PluginManagerExtImpl {
@@ -239,7 +242,7 @@ export class PluginHostRPC {
                     `Path ${extensionTestsPath} does not point to a valid extension test runner.`
                 );
             } : undefined
-        }, envExt, terminalService, storageProxy, secretsExt, preferencesManager, webview, rpc);
+        }, envExt, terminalService, storageProxy, secretsExt, preferencesManager, webview, localization, rpc);
         return pluginManager;
     }
 }

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

@@ -0,0 +1,43 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { LanguagePackBundle, LanguagePackService } from '../../common/language-pack-service';
+
+@injectable()
+export class PluginLanguagePackService implements LanguagePackService {
+
+    protected readonly storage = new Map<string, Map<string, LanguagePackBundle>>();
+
+    storeBundle(pluginId: string, locale: string, bundle: LanguagePackBundle): void {
+        if (!this.storage.has(pluginId)) {
+            this.storage.set(pluginId, new Map());
+        }
+        this.storage.get(pluginId)!.set(locale, bundle);
+    }
+
+    deleteBundle(pluginId: string, locale?: string): void {
+        if (locale) {
+            this.storage.get(pluginId)?.delete(locale);
+        } else {
+            this.storage.delete(pluginId);
+        }
+    }
+
+    async getBundle(pluginId: string, locale: string): Promise<LanguagePackBundle | undefined> {
+        return this.storage.get(pluginId)?.get(locale);
+    }
+}

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

@@ -116,6 +116,7 @@ export class TheiaPluginScanner implements PluginScanner {
             version: plugin.version,
             displayName: plugin.displayName,
             description: plugin.description,
+            l10n: plugin.l10n,
             engine: {
                 type: this._apiType,
                 version: plugin.engines[this._apiType]

package/src/main/browser/comments/comment-thread-widget.tsx

@@ -18,6 +18,7 @@ import {
     Comment,
     CommentMode,
     CommentThread,
+    CommentThreadState,
     CommentThreadCollapsibleState
 } from '../../../common/plugin-api-rpc-model';
 import { CommentGlyphWidget } from './comment-glyph-widget';
@@ -97,6 +98,9 @@ export class CommentThreadWidget extends BaseWidget {
                 commentForm.update();
             }
         }));
+        this.toDispose.push(this._commentThread.onDidChangeState(_state => {
+            this.update();
+        }));
         this.contextMenu = this.menus.getMenu(COMMENT_THREAD_CONTEXT);
         this.contextMenu.children.map(node => node instanceof ActionMenuNode && node.when).forEach(exp => {
             if (typeof exp === 'string') {
@@ -231,7 +235,8 @@ export class CommentThreadWidget extends BaseWidget {
             if (this._commentThread.comments && this._commentThread.comments.length) {
                 const onlyUnique = (value: Comment, index: number, self: Comment[]) => self.indexOf(value) === index;
                 const participantsList = this._commentThread.comments.filter(onlyUnique).map(comment => `@${comment.userName}`).join(', ');
-                label = `Participants: ${participantsList}`;
+                const resolutionState = this._commentThread.state === CommentThreadState.Resolved ? '(Resolved)' : '(Unresolved)';
+                label = `Participants: ${participantsList} ${resolutionState}`;
             } else {
                 label = 'Start discussion';
             }

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

@@ -23,7 +23,7 @@ import {
     CommentThreadChangedEvent
 } from '../../../common/plugin-api-rpc-model';
 import { Event, Emitter } from '@theia/core/lib/common/event';
-import { CommentThreadCollapsibleState } from '../../../plugin/types-impl';
+import { CommentThreadCollapsibleState, CommentThreadState } from '../../../plugin/types-impl';
 import {
     CommentProviderFeatures,
     CommentsExt,
@@ -124,6 +124,21 @@ export class CommentThreadImpl implements CommentThread, Disposable {
     private readonly onDidChangeCollapsibleStateEmitter = new Emitter<CommentThreadCollapsibleState | undefined>();
     readonly onDidChangeCollapsibleState = this.onDidChangeCollapsibleStateEmitter.event;
 
+    private _state: CommentThreadState | undefined;
+    get state(): CommentThreadState | undefined {
+        return this._state;
+    }
+
+    set state(newState: CommentThreadState | undefined) {
+        if (this._state !== newState) {
+            this._state = newState;
+            this.onDidChangeStateEmitter.fire(this._state);
+        }
+    }
+
+    private readonly onDidChangeStateEmitter = new Emitter<CommentThreadState | undefined>();
+    readonly onDidChangeState = this.onDidChangeStateEmitter.event;
+
     private readonly onDidChangeCanReplyEmitter = new Emitter<boolean>();
     readonly onDidChangeCanReply = this.onDidChangeCanReplyEmitter.event;
 
@@ -163,12 +178,14 @@ export class CommentThreadImpl implements CommentThread, Disposable {
         if (modified('contextValue')) { this._contextValue = changes.contextValue; }
         if (modified('comments')) { this._comments = changes.comments; }
         if (modified('collapseState')) { this._collapsibleState = changes.collapseState; }
+        if (modified('state')) { this._state = changes.state; }
         if (modified('canReply')) { this._canReply = changes.canReply!; }
     }
 
     dispose(): void {
         this._isDisposed = true;
         this.onDidChangeCollapsibleStateEmitter.dispose();
+        this.onDidChangeStateEmitter.dispose();
         this.onDidChangeCommentsEmitter.dispose();
         this.onDidChangeInputEmitter.dispose();
         this.onDidChangeLabelEmitter.dispose();

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

@@ -0,0 +1,34 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls } from '@theia/core';
+import { interfaces } from '@theia/core/shared/inversify';
+import { LocalizationMain } from '../../common/plugin-api-rpc';
+import { LanguagePackBundle, LanguagePackService } from '../../common/language-pack-service';
+
+export class LocalizationMainImpl implements LocalizationMain {
+
+    private readonly languagePackService: LanguagePackService;
+
+    constructor(container: interfaces.Container) {
+        this.languagePackService = container.get(LanguagePackService);
+    }
+
+    async $fetchBundle(id: string): Promise<LanguagePackBundle | undefined> {
+        const bundle = await this.languagePackService.getBundle(id, nls.locale ?? nls.defaultLocale);
+        return bundle;
+    }
+}

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

@@ -59,6 +59,7 @@ import { MonacoLanguages } from '@theia/monaco/lib/browser/monaco-languages';
 import { UntitledResourceResolver } from '@theia/core/lib/common/resource';
 import { ThemeService } from '@theia/core/lib/browser/theming';
 import { TabsMainImpl } from './tabs/tabs-main';
+import { LocalizationMainImpl } from './localization-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const authenticationMain = new AuthenticationMainImpl(rpc, container);
@@ -184,4 +185,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
     const tabsMain = new TabsMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.TABS_MAIN, tabsMain);
+
+    const localizationMain = new LocalizationMainImpl(container);
+    rpc.set(PLUGIN_RPC_CONTEXT.LOCALIZATION_MAIN, localizationMain);
 }

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -83,6 +83,7 @@ import './theme-icon-override';
 import { PluginTerminalRegistry } from './plugin-terminal-registry';
 import { DnDFileContentStore } from './view/dnd-file-content-store';
 import { WebviewContextKeys } from './webview/webview-context-keys';
+import { LanguagePackService, languagePackServicePath } from '../../common/language-pack-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -249,4 +250,9 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     rebind(AuthenticationService).toService(PluginAuthenticationServiceImpl);
 
     bind(PluginTerminalRegistry).toSelf().inSingletonScope();
+
+    bind(LanguagePackService).toDynamicValue(ctx => {
+        const provider = ctx.container.get(WebSocketConnectionProvider);
+        return provider.createProxy<LanguagePackService>(languagePackServicePath);
+    }).inSingletonScope();
 });