@theia/plugin-ext 1.42.0 → 1.43.0

package/src/common/plugin-api-rpc.ts

@@ -102,7 +102,6 @@ import {
 import { DebuggerDescription } from '@theia/debug/lib/common/debug-service';
 import { DebugProtocol } from '@vscode/debugprotocol';
 import { SymbolInformation } from '@theia/core/shared/vscode-languageserver-protocol';
-import { ArgumentProcessor } from '../plugin/command-registry';
 import * as files from '@theia/filesystem/lib/common/files';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 import { ResourceLabelFormatter } from '@theia/core/lib/common/label-protocol';
@@ -112,7 +111,7 @@ import type {
     TimelineChangeEvent,
     TimelineProviderDescriptor
 } from '@theia/timeline/lib/common/timeline-model';
-import { SerializableEnvironmentVariableCollection, SerializableExtensionEnvironmentVariableCollection } from '@theia/terminal/lib/common/base-terminal-protocol';
+import { SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/common/shell-terminal-protocol';
 import { ThemeType } from '@theia/core/lib/common/theme';
 import { Disposable } from '@theia/core/lib/common/disposable';
 import { isString, isObject, PickOptions, QuickInputButtonHandle } from '@theia/core/lib/common';
@@ -123,6 +122,10 @@ import { CellExecutionUpdateType, CellRange, NotebookCellExecutionState } from '
 import { LanguagePackBundle } from './language-pack-service';
 import { AccessibilityInformation } from '@theia/core/lib/common/accessibility';
 
+import { TreeDelta } from '@theia/test/lib/common/tree-delta';
+import { TestItemDTO, TestOutputDTO, TestRunDTO, TestRunProfileDTO, TestRunRequestDTO, TestStateChangeDTO } from './test-types';
+import { ArgumentProcessor } from './commands';
+
 export interface PreferenceData {
     [scope: number]: any;
 }
@@ -270,6 +273,8 @@ export interface CommandRegistryMain {
     $executeCommand<T>(id: string, ...args: any[]): PromiseLike<T | undefined>;
     $getCommands(): PromiseLike<string[]>;
     $getKeyBinding(commandId: string): PromiseLike<theia.CommandKeyBinding[] | undefined>;
+
+    registerArgumentProcessor(processor: ArgumentProcessor): void;
 }
 
 export interface CommandRegistryExt {
@@ -287,10 +292,10 @@ export interface TerminalServiceExt {
     $terminalSizeChanged(id: string, cols: number, rows: number): void;
     $currentTerminalChanged(id: string | undefined): void;
     $terminalStateChanged(id: string): void;
-    $initEnvironmentVariableCollections(collections: [string, SerializableEnvironmentVariableCollection][]): void;
+    $initEnvironmentVariableCollections(collections: [string, string, boolean, SerializableEnvironmentVariableCollection][]): void;
     $provideTerminalLinks(line: string, terminalId: string, token: theia.CancellationToken): Promise<ProvidedTerminalLink[]>;
     $handleTerminalLink(link: ProvidedTerminalLink): Promise<void>;
-    getEnvironmentVariableCollection(extensionIdentifier: string): theia.EnvironmentVariableCollection;
+    getEnvironmentVariableCollection(extensionIdentifier: string): theia.GlobalEnvironmentVariableCollection;
 }
 export interface OutputChannelRegistryExt {
     createOutputChannel(name: string, pluginInfo: PluginInfo): theia.OutputChannel,
@@ -408,7 +413,7 @@ export interface TerminalServiceMain {
      */
     $disposeByTerminalId(id: number, waitOnExit?: boolean | string): void;
 
-    $setEnvironmentVariableCollection(persistent: boolean, collection: SerializableExtensionEnvironmentVariableCollection): void;
+    $setEnvironmentVariableCollection(persistent: boolean, extensionIdentifier: string, rootUri: string, collection: SerializableEnvironmentVariableCollection): void;
 
     /**
      * Set the terminal widget name.
@@ -2142,6 +2147,60 @@ export interface TelemetryExt {
 
 // endregion
 
+// based from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/workbench/api/common/extHostTesting.ts
+export const enum TestingResourceExt {
+    Workspace,
+    TextDocument
+}
+
+// based from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/workbench/api/common/extHostTesting.ts
+export interface TestingExt {
+    $onCancelTestRun(controllerId: string, runId: string): void;
+    /** Configures a test run config. */
+    $onConfigureRunProfile(controllerId: string, profileId: string): void;
+
+    $onRunControllerTests(reqs: TestRunRequestDTO[]): void;
+
+    /** Asks the controller to refresh its tests */
+    $refreshTests(controllerId: string, token: CancellationToken): Promise<void>;
+
+    $onResolveChildren(controllerId: string, path: string[]): void;
+}
+
+export interface TestControllerUpdate {
+    label: string;
+    canRefresh: boolean;
+    canResolve: boolean;
+}
+
+// based from https://github.com/microsoft/vscode/blob/1.72.2/src/vs/workbench/api/common/extHostTesting.ts
+export interface TestingMain {
+    // --- test lifecycle:
+
+    /** Registers that there's a test controller with the given ID */
+    $registerTestController(controllerId: string, label: string): void;
+    /** Updates the label of an existing test controller. */
+    $updateController(controllerId: string, patch: Partial<TestControllerUpdate>): void;
+    /** Disposes of the test controller with the given ID */
+    $unregisterTestController(controllerId: string): void;
+    $notifyDelta(controllerId: string, diff: TreeDelta<string, TestItemDTO>[]): void;
+
+    // --- test run configurations:
+
+    /** Called when a new test run profile is available */
+    $notifyTestRunProfileCreated(controllerId: string, profile: TestRunProfileDTO): void;
+    /** Updates an existing test run profile */
+    $updateTestRunProfile(controllerId: string, profileId: string, update: Partial<TestRunProfileDTO>): void;
+    /** Removes a previously-published test run profile */
+    $removeTestRunProfile(controllerId: string, profileId: string): void;
+
+    // Test runs
+
+    $notifyTestRunCreated(controllerId: string, run: TestRunDTO): void;
+    $notifyTestStateChanged(controllerId: string, runId: string, stateChanges: TestStateChangeDTO[], outputChanges: TestOutputDTO[]): void;
+    $notifyTestRunEnded(controllerId: string, runId: string): void;
+}
+
 export const PLUGIN_RPC_CONTEXT = {
     AUTHENTICATION_MAIN: <ProxyIdentifier<AuthenticationMain>>createProxyIdentifier<AuthenticationMain>('AuthenticationMain'),
     COMMAND_REGISTRY_MAIN: <ProxyIdentifier<CommandRegistryMain>>createProxyIdentifier<CommandRegistryMain>('CommandRegistryMain'),
@@ -2185,6 +2244,7 @@ export const PLUGIN_RPC_CONTEXT = {
     TABS_MAIN: <ProxyIdentifier<TabsMain>>createProxyIdentifier<TabsMain>('TabsMain'),
     TELEMETRY_MAIN: <ProxyIdentifier<TelemetryMain>>createProxyIdentifier<TelemetryMain>('TelemetryMain'),
     LOCALIZATION_MAIN: <ProxyIdentifier<LocalizationMain>>createProxyIdentifier<LocalizationMain>('LocalizationMain'),
+    TESTING_MAIN: createProxyIdentifier<TestingMain>('TestingMain')
 };
 
 export const MAIN_RPC_CONTEXT = {
@@ -2225,7 +2285,8 @@ export const MAIN_RPC_CONTEXT = {
     THEMING_EXT: createProxyIdentifier<ThemingExt>('ThemingExt'),
     COMMENTS_EXT: createProxyIdentifier<CommentsExt>('CommentsExt'),
     TABS_EXT: createProxyIdentifier<TabsExt>('TabsExt'),
-    TELEMETRY_EXT: createProxyIdentifier<TelemetryExt>('TelemetryExt)')
+    TELEMETRY_EXT: createProxyIdentifier<TelemetryExt>('TelemetryExt)'),
+    TESTING_EXT: createProxyIdentifier<TestingExt>('TestingExt')
 };
 
 export interface TasksExt {
@@ -2423,6 +2484,7 @@ export interface CellExecuteOutputEditDto {
 export interface CellExecuteOutputItemEditDto {
     editType: CellExecutionUpdateType.OutputItems;
     append?: boolean;
+    outputId: string;
     items: NotebookOutputItemDto[];
 }
 
@@ -2464,7 +2526,7 @@ export interface NotebooksExt extends NotebookDocumentsAndEditorsExt {
 }
 
 export interface NotebooksMain extends Disposable {
-    $registerNotebookSerializer(handle: number, extension: notebookCommon.NotebookExtensionDescription, viewType: string, options: notebookCommon.TransientOptions): void;
+    $registerNotebookSerializer(handle: number, viewType: string, options: notebookCommon.TransientOptions): void;
     $unregisterNotebookSerializer(handle: number): void;
 
     $registerNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined, viewType: string): Promise<void>;

package/src/common/plugin-protocol.ts

@@ -17,7 +17,7 @@ import { RpcServer } from '@theia/core/lib/common/messaging/proxy-factory';
 import { RPCProtocol } from './rpc-protocol';
 import { Disposable } from '@theia/core/lib/common/disposable';
 import { LogPart, KeysToAnyValues, KeysToKeysToAnyValue } from './types';
-import { CharacterPair, CommentRule, PluginAPIFactory, Plugin } from './plugin-api-rpc';
+import { CharacterPair, CommentRule, PluginAPIFactory, Plugin, ThemeIcon } from './plugin-api-rpc';
 import { ExtPluginApi } from './plugin-ext-api-contribution';
 import { IJSONSchema, IJSONSchemaSnippet } from '@theia/core/lib/common/json-schema';
 import { RecursivePartial } from '@theia/core/lib/common/types';
@@ -90,6 +90,7 @@ export interface PluginPackageContribution {
     snippets?: PluginPackageSnippetsContribution[];
     themes?: PluginThemeContribution[];
     iconThemes?: PluginIconThemeContribution[];
+    icons?: PluginIconContribution[];
     colors?: PluginColorContribution[];
     taskDefinitions?: PluginTaskDefinitionContribution[];
     problemMatchers?: PluginProblemMatcherContribution[];
@@ -262,6 +263,13 @@ export interface PluginIconThemeContribution {
     uiTheme?: PluginUiTheme;
 }
 
+export interface PluginIconContribution {
+    [id: string]: {
+        description: string;
+        default: { fontPath: string; fontCharacter: string } | string;
+    };
+}
+
 export interface PlatformSpecificAdapterContribution {
     program?: string;
     args?: string[];
@@ -586,6 +594,7 @@ export interface PluginContribution {
     snippets?: SnippetContribution[];
     themes?: ThemeContribution[];
     iconThemes?: IconThemeContribution[];
+    icons?: IconContribution[];
     colors?: ColorDefinition[];
     taskDefinitions?: TaskDefinition[];
     problemMatchers?: ProblemMatcherContribution[];
@@ -634,8 +643,7 @@ export interface Localization {
 export interface Translation {
     id: string;
     path: string;
-    version: string;
-    contents: { [scope: string]: { [key: string]: string } }
+    cachedContents?: { [scope: string]: { [key: string]: string } };
 }
 
 export interface SnippetContribution {
@@ -662,6 +670,26 @@ export interface IconThemeContribution {
     uiTheme?: UiTheme;
 }
 
+export interface IconDefinition {
+    fontCharacter: string;
+    location: string;
+}
+
+export type IconDefaults = ThemeIcon | IconDefinition;
+
+export interface IconContribution {
+    id: string;
+    extensionId: string;
+    description: string | undefined;
+    defaults: IconDefaults;
+}
+
+export namespace IconContribution {
+    export function isIconDefinition(defaults: IconDefaults): defaults is IconDefinition {
+        return 'fontCharacter' in defaults;
+    }
+}
+
 export interface GrammarsContribution {
     format: 'json' | 'plist';
     language?: string;

package/src/common/test-types.ts

@@ -0,0 +1,133 @@
+// *****************************************************************************
+// Copyright (C) 2023 Mathieu Bussieres 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
+// *****************************************************************************
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation and others. All rights reserved.
+ *  Licensed under the MIT License. See https://github.com/Microsoft/vscode/blob/master/LICENSE.txt for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// Based on https://github.com/microsoft/vscode/blob/1.72.2/src/vs/workbench/contrib/testing/common/testTypes.ts
+
+/* eslint-disable import/no-extraneous-dependencies */
+
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
+import { UriComponents } from './uri-components';
+import { Location, Range } from './plugin-api-rpc-model';
+import { isObject } from '@theia/core';
+
+export enum TestRunProfileKind {
+    Run = 1,
+    Debug = 2,
+    Coverage = 3
+}
+
+export interface TestRunProfileDTO {
+    readonly id: string;
+    readonly label: string;
+    readonly kind: TestRunProfileKind;
+    readonly isDefault: boolean;
+    readonly tag: string;
+    readonly canConfigure: boolean;
+}
+export interface TestRunDTO {
+    readonly id: string;
+    readonly name: string;
+    readonly isRunning: boolean;
+}
+
+export interface TestOutputDTO {
+    readonly output: string;
+    readonly location?: Location;
+    readonly itemPath?: string[];
+}
+
+export enum TestExecutionState {
+    Queued = 1,
+    Running = 2,
+    Passed = 3,
+    Failed = 4,
+    Skipped = 5,
+    Errored = 6
+}
+
+export interface TestStateChangeDTO {
+    readonly state: TestExecutionState;
+    readonly itemPath: string[];
+}
+
+export interface TestFailureDTO extends TestStateChangeDTO {
+    readonly state: TestExecutionState.Failed | TestExecutionState.Errored;
+    readonly messages: TestMessageDTO[];
+    readonly duration?: number;
+}
+
+export interface TestSuccessDTO extends TestStateChangeDTO {
+    readonly state: TestExecutionState.Passed;
+    readonly duration?: number;
+}
+
+export interface TestMessageDTO {
+    readonly expected?: string;
+    readonly actual?: string;
+    readonly location?: Location;
+    readonly message: string | MarkdownString;
+}
+
+export interface TestItemDTO {
+    readonly id: string;
+    readonly label: string;
+    readonly range?: Range;
+    readonly sortKey?: string;
+    readonly tags: string[];
+    readonly uri?: UriComponents;
+    readonly busy: boolean;
+    readonly canResolveChildren: boolean;
+    readonly description?: string;
+    readonly error?: string | MarkdownString
+    readonly children?: TestItemDTO[];
+}
+
+export interface TestRunRequestDTO {
+    controllerId: string;
+    profileId: string;
+    name: string;
+    includedTests: string[][]; // array of paths
+    excludedTests: string[][]; // array of paths
+}
+
+export interface TestItemReference {
+    typeTag: '$type_test_item_reference',
+    controllerId: string;
+    testPath: string[];
+}
+
+export namespace TestItemReference {
+    export function is(ref: unknown): ref is TestItemReference {
+        return isObject<TestItemReference>(ref)
+            && ref.typeTag === '$type_test_item_reference'
+            && typeof ref.controllerId === 'string'
+            && Array.isArray(ref.testPath);
+    }
+
+    export function create(controllerId: string, testPath: string[]): TestItemReference {
+        return {
+            typeTag: '$type_test_item_reference',
+            controllerId,
+            testPath
+        };
+    }
+}
+

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

@@ -69,7 +69,7 @@ import { LanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/
 import { Measurement, Stopwatch } from '@theia/core/lib/common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '@theia/core/lib/common/message-rpc/uint8-array-message-buffer';
 import { BasicChannel } from '@theia/core/lib/common/message-rpc/channel';
-import { NotebookTypeRegistry, NotebookService } from '@theia/notebook/lib/browser';
+import { NotebookTypeRegistry, NotebookService, NotebookRendererMessagingService } from '@theia/notebook/lib/browser';
 
 export type PluginHost = 'frontend' | string;
 export type DebugActivationEvent = 'onDebugResolve' | 'onDebugInitialConfigurations' | 'onDebugAdapterProtocolTracker' | 'onDebugDynamicConfigurations';
@@ -118,6 +118,9 @@ export class HostedPluginSupport {
     @inject(NotebookService)
     protected readonly notebookService: NotebookService;
 
+    @inject(NotebookRendererMessagingService)
+    protected readonly notebookRendererMessagingService: NotebookRendererMessagingService;
+
     @inject(CommandRegistry)
     protected readonly commands: CommandRegistry;
 
@@ -224,6 +227,7 @@ export class HostedPluginSupport {
         this.fileService.onWillActivateFileSystemProvider(event => this.ensureFileSystemActivation(event));
         this.customEditorRegistry.onWillOpenCustomEditor(event => this.activateByCustomEditor(event));
         this.notebookService.onWillOpenNotebook(async event => this.activateByNotebook(event));
+        this.notebookRendererMessagingService.onWillActivateRenderer(rendererId => this.activateByNotebookRenderer(rendererId));
 
         this.widgets.onDidCreateWidget(({ factoryId, widget }) => {
             if ((factoryId === WebviewWidget.FACTORY_ID || factoryId === CustomEditorWidget.FACTORY_ID) && widget instanceof WebviewWidget) {
@@ -633,6 +637,14 @@ export class HostedPluginSupport {
         await this.activateByEvent(`onNotebook:${viewType}`);
     }
 
+    async activateByNotebookSerializer(viewType: string): Promise<void> {
+        await this.activateByEvent(`onNotebookSerializer:${viewType}`);
+    }
+
+    async activateByNotebookRenderer(rendererId: string): Promise<void> {
+        await this.activateByEvent(`onRenderer:${rendererId}`);
+    }
+
     activateByFileSystem(event: FileSystemProviderActivationEvent): Promise<void> {
         return this.activateByEvent(`onFileSystem:${event.scheme}`);
     }

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

@@ -16,13 +16,13 @@
 
 import * as path from 'path';
 import * as fs from '@theia/core/shared/fs-extra';
-import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
+import { LazyLocalization, 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, Translation } from '../../common';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { BackendApplicationContribution } from '@theia/core/lib/node';
-import { Disposable, DisposableCollection, isObject, MaybePromise, nls, URI } from '@theia/core';
+import { Disposable, DisposableCollection, isObject, MaybePromise, nls, Path, URI } from '@theia/core';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { LanguagePackBundle, LanguagePackService } from '../../common/language-pack-service';
 
@@ -70,11 +70,8 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
         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);
-            disposable.push(Disposable.create(() => {
-                this.localizationProvider.removeLocalizations(...localizations);
-            }));
-            this.localizationProvider.addLocalizations(...localizations);
+            const localizations = buildLocalizations(plugin.metadata.model.packageUri, plugin.contributes.localizations);
+            disposable.push(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
@@ -100,26 +97,29 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
         const pluginId = plugin.metadata.model.id;
         const packageUri = new URI(plugin.metadata.model.packageUri);
         if (plugin.contributes?.localizations) {
+            const l10nPromises: Promise<void>[] = [];
             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);
-                        }));
-                    }
+                    l10nPromises.push(getL10nTranslation(plugin.metadata.model.packageUri, translation).then(l10n => {
+                        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);
+                            }));
+                        }
+                    }));
                 }
             }
+            await Promise.all(l10nPromises);
         }
         // 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
@@ -150,11 +150,13 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
      */
     async localizePlugin(plugin: DeployedPlugin): Promise<DeployedPlugin> {
         const currentLanguage = this.localizationProvider.getCurrentLanguage();
-        const localization = this.localizationProvider.loadLocalization(currentLanguage);
         const pluginPath = new URI(plugin.metadata.model.packageUri).path.fsPath();
         const pluginId = plugin.metadata.model.id;
         try {
-            const translations = await loadPackageTranslations(pluginPath, currentLanguage);
+            const [localization, translations] = await Promise.all([
+                this.localizationProvider.loadLocalization(currentLanguage),
+                loadPackageTranslations(pluginPath, currentLanguage),
+            ]);
             plugin = localizePackage(plugin, translations, (key, original) => {
                 const fullKey = `${pluginId}/package/${key}`;
                 return Localization.localize(localization, fullKey, original);
@@ -218,10 +220,24 @@ export class HostedPluginLocalizationService implements BackendApplicationContri
 
 // New plugin localization logic using vscode.l10n
 
-function getL10nTranslation(translation: Translation): UnprocessedL10nBundle | undefined {
+async function getL10nTranslation(packageUri: string, translation: Translation): Promise<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;
+    if (translation.cachedContents) {
+        return translation.cachedContents.bundle;
+    } else {
+        const translationPath = new URI(packageUri).path.join(translation.path).fsPath();
+        try {
+            const translationJson = await fs.readJson(translationPath);
+            translation.cachedContents = translationJson?.contents;
+            return translationJson?.contents?.bundle;
+        } catch (err) {
+            console.error('Failed reading translation file from: ' + translationPath, err);
+            // Store an empty object, so we don't reattempt to load the file
+            translation.cachedContents = {};
+            return undefined;
+        }
+    }
 }
 
 async function loadPluginBundles(l10nUri: URI): Promise<Record<string, LanguagePackBundle> | undefined> {
@@ -262,28 +278,47 @@ function processL10nBundle(bundle: UnprocessedL10nBundle): Record<string, string
 
 // Old plugin localization logic for vscode-nls
 // vscode-nls was used until version 1.73 of VSCode to translate extensions
+// This style of localization is still used by vscode language packs
 
-function buildLocalizations(localizations: PluginLocalization[]): Localization[] {
-    const theiaLocalizations: Localization[] = [];
+function buildLocalizations(packageUri: string, localizations: PluginLocalization[]): LazyLocalization[] {
+    const theiaLocalizations: LazyLocalization[] = [];
+    const packagePath = new URI(packageUri).path;
     for (const localization of localizations) {
-        const theiaLocalization: Localization = {
+        let cachedLocalization: Promise<Record<string, string>> | undefined;
+        const theiaLocalization: LazyLocalization = {
             languageId: localization.languageId,
             languageName: localization.languageName,
             localizedLanguageName: localization.localizedLanguageName,
             languagePack: true,
-            translations: {}
+            async getTranslations(): Promise<Record<string, string>> {
+                cachedLocalization ??= loadTranslations(packagePath, localization.translations);
+                return cachedLocalization;
+            },
         };
-        for (const translation of localization.translations) {
-            for (const [scope, value] of Object.entries(translation.contents)) {
+        theiaLocalizations.push(theiaLocalization);
+    }
+    return theiaLocalizations;
+}
+
+async function loadTranslations(packagePath: Path, translations: Translation[]): Promise<Record<string, string>> {
+    const allTranslations = await Promise.all(translations.map(async translation => {
+        const values: Record<string, string> = {};
+        const translationPath = packagePath.join(translation.path).fsPath();
+        try {
+            const translationJson = await fs.readJson(translationPath);
+            const translationContents: Record<string, Record<string, string>> = translationJson?.contents;
+            for (const [scope, value] of Object.entries(translationContents ?? {})) {
                 for (const [key, item] of Object.entries(value)) {
                     const translationKey = buildTranslationKey(translation.id, scope, key);
-                    theiaLocalization.translations[translationKey] = item;
+                    values[translationKey] = item;
                 }
             }
+        } catch (err) {
+            console.error('Failed to load translation from: ' + translationPath, err);
         }
-        theiaLocalizations.push(theiaLocalization);
-    }
-    return theiaLocalizations;
+        return values;
+    }));
+    return Object.assign({}, ...allTranslations);
 }
 
 function buildTranslationKey(pluginId: string, scope: string, key: string): string {

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

@@ -17,6 +17,7 @@
 import * as path from 'path';
 import * as express from '@theia/core/shared/express';
 import * as escape_html from 'escape-html';
+import { realpath } from 'fs/promises';
 import { ILogger } from '@theia/core';
 import { inject, injectable, optional, multiInject } from '@theia/core/shared/inversify';
 import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
@@ -93,11 +94,12 @@ export class HostedPluginReader implements BackendApplicationContribution {
         if (!pluginPath) {
             return undefined;
         }
-        const manifest = await loadManifest(pluginPath);
+        const resolvedPluginPath = await realpath(pluginPath);
+        const manifest = await loadManifest(resolvedPluginPath);
         if (!manifest) {
             return undefined;
         }
-        manifest.packagePath = pluginPath;
+        manifest.packagePath = resolvedPluginPath;
         return manifest;
     }