@theia/plugin-ext 1.27.0-next.9 → 1.27.0

package/src/common/plugin-identifiers.ts

@@ -0,0 +1,84 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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
+// *****************************************************************************
+
+export namespace PluginIdentifiers {
+    export interface Components {
+        publisher?: string;
+        name: string;
+        version: string;
+    }
+
+    export interface IdAndVersion {
+        id: UnversionedId;
+        version: string;
+    }
+
+    export type VersionedId = `${string}.${string}@${string}`;
+    export type UnversionedId = `${string}.${string}`;
+    /** Unpublished plugins (not from Open VSX or VSCode plugin store) may not have a `publisher` field. */
+    export const UNPUBLISHED = '<unpublished>';
+
+    /**
+     * @returns a string in the format `<publisher>.<name>`
+     */
+    export function componentsToUnversionedId({ publisher = UNPUBLISHED, name }: Components): UnversionedId {
+        return `${publisher.toLowerCase()}.${name.toLowerCase()}`;
+    }
+    /**
+     * @returns a string in the format `<publisher>.<name>@<version>`.
+     */
+    export function componentsToVersionedId({ publisher = UNPUBLISHED, name, version }: Components): VersionedId {
+        return `${publisher.toLowerCase()}.${name.toLowerCase()}@${version}`;
+    }
+    export function componentsToVersionWithId(components: Components): IdAndVersion {
+        return { id: componentsToUnversionedId(components), version: components.version };
+    }
+    /**
+     * @returns a string in the format `<id>@<version>`.
+     */
+    export function idAndVersionToVersionedId({ id, version }: IdAndVersion): VersionedId {
+        return `${id}@${version}`;
+    }
+    /**
+     * @returns a string in the format `<publisher>.<name>`.
+     */
+    export function unversionedFromVersioned(id: VersionedId): UnversionedId {
+        const endOfId = id.indexOf('@');
+        return id.slice(0, endOfId) as UnversionedId;
+    }
+    /**
+     * @returns `undefined` if it looks like the string passed in does not have the format returned by {@link PluginIdentifiers.toVersionedId}.
+     */
+    export function identifiersFromVersionedId(probablyId: string): Components | undefined {
+        const endOfPublisher = probablyId.indexOf('.');
+        const endOfName = probablyId.indexOf('@', endOfPublisher);
+        if (endOfPublisher === -1 || endOfName === -1) {
+            return undefined;
+        }
+        return { publisher: probablyId.slice(0, endOfPublisher), name: probablyId.slice(endOfPublisher + 1, endOfName), version: probablyId.slice(endOfName + 1) };
+    }
+    /**
+     * @returns `undefined` if it looks like the string passed in does not have the format returned by {@link PluginIdentifiers.toVersionedId}.
+     */
+    export function idAndVersionFromVersionedId(probablyId: string): IdAndVersion | undefined {
+        const endOfPublisher = probablyId.indexOf('.');
+        const endOfName = probablyId.indexOf('@', endOfPublisher);
+        if (endOfPublisher === -1 || endOfName === -1) {
+            return undefined;
+        }
+        return { id: probablyId.slice(0, endOfName) as UnversionedId, version: probablyId.slice(endOfName + 1) };
+    }
+}

package/src/common/plugin-protocol.ts

@@ -25,7 +25,9 @@ import { PreferenceSchema, PreferenceSchemaProperties } from '@theia/core/lib/co
 import { ProblemMatcherContribution, ProblemPatternContribution, TaskDefinition } from '@theia/task/lib/common';
 import { ColorDefinition } from '@theia/core/lib/common/color';
 import { ResourceLabelFormatter } from '@theia/core/lib/common/label-protocol';
+import { PluginIdentifiers } from './plugin-identifiers';
 
+export { PluginIdentifiers };
 export const hostedServicePath = '/services/hostedPlugin';
 
 /**
@@ -38,7 +40,8 @@ export type PluginEngine = string;
  */
 export interface PluginPackage {
     name: string;
-    publisher: string;
+    // The publisher is not guaranteed to be defined for unpublished plugins. https://github.com/microsoft/vscode-vsce/commit/a38657ece04c20e4fbde15d5ac1ed39ca51cb856
+    publisher: string | undefined;
     version: string;
     engines: {
         [type in PluginEngine]: string;
@@ -271,6 +274,7 @@ export interface PluginPackageLanguageContributionConfiguration {
     wordPattern?: string;
     indentationRules?: IndentationRules;
     folding?: FoldingRules;
+    onEnterRules?: OnEnterRule[];
 }
 
 export interface PluginTaskDefinitionContribution {
@@ -339,7 +343,7 @@ export interface PluginDeployerResolver {
 
     accept(pluginSourceId: string): boolean;
 
-    resolve(pluginResolverContext: PluginDeployerResolverContext): Promise<void>;
+    resolve(pluginResolverContext: PluginDeployerResolverContext, options?: PluginDeployOptions): Promise<void>;
 
 }
 
@@ -486,6 +490,8 @@ export interface PluginDeployerFileHandlerContext {
 
 export interface PluginDeployerDirectoryHandlerContext {
 
+    copy(origin: string, target: string): Promise<void>;
+
     pluginEntry(): PluginDeployerEntry;
 
 }
@@ -622,6 +628,7 @@ export interface LanguageConfiguration {
     comments?: CommentRule;
     folding?: FoldingRules;
     wordPattern?: string;
+    onEnterRules?: OnEnterRule[];
 }
 
 /**
@@ -670,6 +677,19 @@ export interface FoldingRules {
     markers?: FoldingMarkers;
 }
 
+export interface OnEnterRule {
+    beforeText: string;
+    afterText?: string;
+    previousLineText?: string;
+    action: EnterAction;
+}
+
+export interface EnterAction {
+    indent: 'none' | 'indent' | 'outdent' | 'indentOutdent';
+    appendText?: string;
+    removeText?: number;
+}
+
 /**
  * Custom Editors contribution
  */
@@ -796,6 +816,7 @@ export interface PluginMetadata {
     model: PluginModel;
     lifecycle: PluginLifecycle;
     isUnderDevelopment?: boolean;
+    outOfSync: boolean;
 }
 
 export const MetadataProcessor = Symbol('MetadataProcessor');
@@ -822,22 +843,38 @@ export interface HostedPluginClient {
 
 export interface PluginDependencies {
     metadata: PluginMetadata
+    /**
+     * Actual listing of plugin dependencies.
+     * Mapping from {@link PluginIdentifiers.UnversionedId external representation} of plugin identity to a string
+     * that can be used to identify the resolver for the specific plugin case, e.g. with scheme `vscode://<id>`.
+     */
     mapping?: Map<string, string>
 }
 
 export const PluginDeployerHandler = Symbol('PluginDeployerHandler');
 export interface PluginDeployerHandler {
-    deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<void>;
-    deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<void>;
+    deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<number | undefined>;
+    deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<number | undefined>;
+
+    getDeployedPluginsById(pluginId: string): DeployedPlugin[];
 
-    getDeployedPlugin(pluginId: string): DeployedPlugin | undefined;
-    undeployPlugin(pluginId: string): Promise<boolean>;
+    getDeployedPlugin(pluginId: PluginIdentifiers.VersionedId): DeployedPlugin | undefined;
+    /**
+     * Removes the plugin from the location it originally resided on disk.
+     * Unless `--uncompressed-plugins-in-place` is passed to the CLI, this operation is safe.
+     */
+    uninstallPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean>;
+    /**
+     * Removes the plugin from the locations to which it had been deployed.
+     * This operation is not safe - references to deleted assets may remain.
+     */
+    undeployPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean>;
 
     getPluginDependencies(pluginToBeInstalled: PluginDeployerEntry): Promise<PluginDependencies | undefined>;
 }
 
 export interface GetDeployedPluginsParams {
-    pluginIds: string[]
+    pluginIds: PluginIdentifiers.VersionedId[]
 }
 
 export interface DeployedPlugin {
@@ -852,7 +889,9 @@ export interface DeployedPlugin {
 export const HostedPluginServer = Symbol('HostedPluginServer');
 export interface HostedPluginServer extends JsonRpcServer<HostedPluginClient> {
 
-    getDeployedPluginIds(): Promise<string[]>;
+    getDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]>;
+
+    getUninstalledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]>;
 
     getDeployedPlugins(params: GetDeployedPluginsParams): Promise<DeployedPlugin[]>;
 
@@ -871,6 +910,12 @@ export interface WorkspaceStorageKind {
 export type GlobalStorageKind = undefined;
 export type PluginStorageKind = GlobalStorageKind | WorkspaceStorageKind;
 
+export interface PluginDeployOptions {
+    version: string;
+    /** Instructs the deployer to ignore any existing plugins with different versions */
+    ignoreOtherVersions?: boolean;
+}
+
 /**
  * The JSON-RPC workspace interface.
  */
@@ -883,9 +928,9 @@ export interface PluginServer {
      *
      * @param type whether a plugin is installed by a system or a user, defaults to a user
      */
-    deploy(pluginEntry: string, type?: PluginType): Promise<void>;
-
-    undeploy(pluginId: string): Promise<void>;
+    deploy(pluginEntry: string, type?: PluginType, options?: PluginDeployOptions): Promise<void>;
+    uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void>;
+    undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void>;
 
     setStorageValue(key: string, value: KeysToAnyValues, kind: PluginStorageKind): Promise<boolean>;
     getStorageValue(key: string, kind: PluginStorageKind): Promise<KeysToAnyValues>;
@@ -910,7 +955,7 @@ export interface ServerPluginRunner {
     /**
      * Provides additional plugin ids.
      */
-    getExtraDeployedPluginIds(): Promise<string[]>;
+    getExtraDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]>;
 
 }
 

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

@@ -25,7 +25,7 @@ import debounce = require('@theia/core/shared/lodash.debounce');
 import { UUID } from '@theia/core/shared/@phosphor/coreutils';
 import { injectable, inject, interfaces, named, postConstruct } from '@theia/core/shared/inversify';
 import { PluginWorker } from './plugin-worker';
-import { PluginMetadata, getPluginId, HostedPluginServer, DeployedPlugin, PluginServer } from '../../common/plugin-protocol';
+import { PluginMetadata, getPluginId, HostedPluginServer, DeployedPlugin, PluginServer, PluginIdentifiers } from '../../common/plugin-protocol';
 import { HostedPluginWatcher } from './hosted-plugin-watcher';
 import { MAIN_RPC_CONTEXT, PluginManagerExt, ConfigStorage, UIKind } from '../../common/plugin-api-rpc';
 import { setUpPluginApi } from '../../main/browser/main-context';
@@ -165,7 +165,7 @@ export class HostedPluginSupport {
 
     protected readonly managers = new Map<string, PluginManagerExt>();
 
-    private readonly contributions = new Map<string, PluginContributions>();
+    private readonly contributions = new Map<PluginIdentifiers.UnversionedId, PluginContributions>();
 
     protected readonly activationEvents = new Set<string>();
 
@@ -240,7 +240,7 @@ export class HostedPluginSupport {
         return plugins;
     }
 
-    getPlugin(id: string): DeployedPlugin | undefined {
+    getPlugin(id: PluginIdentifiers.UnversionedId): DeployedPlugin | undefined {
         const contributions = this.contributions.get(id);
         return contributions && contributions.plugin;
     }
@@ -312,27 +312,38 @@ export class HostedPluginSupport {
         let syncPluginsMeasurement: Measurement | undefined;
 
         const toUnload = new Set(this.contributions.keys());
+        let didChangeInstallationStatus = false;
         try {
-            const pluginIds: string[] = [];
-            const deployedPluginIds = await this.server.getDeployedPluginIds();
+            const newPluginIds: PluginIdentifiers.VersionedId[] = [];
+            const [deployedPluginIds, uninstalledPluginIds] = await Promise.all([this.server.getDeployedPluginIds(), this.server.getUninstalledPluginIds()]);
             waitPluginsMeasurement.log('Waiting for backend deployment');
             syncPluginsMeasurement = this.measure('syncPlugins');
-            for (const pluginId of deployedPluginIds) {
-                toUnload.delete(pluginId);
-                if (!this.contributions.has(pluginId)) {
-                    pluginIds.push(pluginId);
+            for (const versionedId of deployedPluginIds) {
+                const unversionedId = PluginIdentifiers.unversionedFromVersioned(versionedId);
+                toUnload.delete(unversionedId);
+                if (!this.contributions.has(unversionedId)) {
+                    newPluginIds.push(versionedId);
                 }
             }
             for (const pluginId of toUnload) {
-                const contribution = this.contributions.get(pluginId);
-                if (contribution) {
-                    contribution.dispose();
+                this.contributions.get(pluginId)?.dispose();
+            }
+            for (const versionedId of uninstalledPluginIds) {
+                const plugin = this.getPlugin(PluginIdentifiers.unversionedFromVersioned(versionedId));
+                if (plugin && PluginIdentifiers.componentsToVersionedId(plugin.metadata.model) === versionedId && !plugin.metadata.outOfSync) {
+                    plugin.metadata.outOfSync = didChangeInstallationStatus = true;
+                }
+            }
+            for (const contribution of this.contributions.values()) {
+                if (contribution.plugin.metadata.outOfSync && !uninstalledPluginIds.includes(PluginIdentifiers.componentsToVersionedId(contribution.plugin.metadata.model))) {
+                    contribution.plugin.metadata.outOfSync = false;
+                    didChangeInstallationStatus = true;
                 }
             }
-            if (pluginIds.length) {
-                const plugins = await this.server.getDeployedPlugins({ pluginIds });
+            if (newPluginIds.length) {
+                const plugins = await this.server.getDeployedPlugins({ pluginIds: newPluginIds });
                 for (const plugin of plugins) {
-                    const pluginId = plugin.metadata.model.id;
+                    const pluginId = PluginIdentifiers.componentsToUnversionedId(plugin.metadata.model);
                     const contributions = new PluginContributions(plugin);
                     this.contributions.set(pluginId, contributions);
                     contributions.push(Disposable.create(() => this.contributions.delete(pluginId)));
@@ -340,7 +351,7 @@ export class HostedPluginSupport {
                 }
             }
         } finally {
-            if (initialized || toUnload.size) {
+            if (initialized || toUnload.size || didChangeInstallationStatus) {
                 this.onDidChangePluginsEmitter.fire(undefined);
             }
 
@@ -567,11 +578,7 @@ export class HostedPluginSupport {
             return;
         }
         this.activationEvents.add(activationEvent);
-        const activation: Promise<void>[] = [];
-        for (const manager of this.managers.values()) {
-            activation.push(manager.$activateByEvent(activationEvent));
-        }
-        await Promise.all(activation);
+        await Promise.all(Array.from(this.managers.values(), manager => manager.$activateByEvent(activationEvent)));
     }
 
     async activateByViewContainer(viewContainerId: string): Promise<void> {

package/src/hosted/browser/worker/debug-stub.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 // eslint-disable-next-line @theia/runtime-import-check
-import { DebugExtImpl } from '../../../plugin/node/debug/debug';
+import { DebugExtImpl } from '../../../plugin/debug/debug-ext';
 import { RPCProtocol } from '../../../common/rpc-protocol';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */

package/src/hosted/browser/worker/plugin-manifest-loader.ts

@@ -16,7 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { PluginModel, PluginPackage } from '../../../common/plugin-protocol';
+import { PluginIdentifiers, PluginModel, PluginPackage } from '../../../common/plugin-protocol';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';
 import URI from '@theia/core/lib/common/uri';
 
@@ -54,7 +54,9 @@ function readContents(uri: string): Promise<string> {
 
 async function readPluginJson(pluginModel: PluginModel, relativePath: string): Promise<any> {
     const content = await readPluginFile(pluginModel, relativePath);
-    return JSON.parse(content);
+    const json = JSON.parse(content) as PluginPackage;
+    json.publisher ??= PluginIdentifiers.UNPUBLISHED;
+    return json;
 }
 
 export async function loadManifest(pluginModel: PluginModel): Promise<any> {

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

@@ -17,11 +17,15 @@
 import * as fs from '@theia/core/shared/fs-extra';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { ILogger } from '@theia/core';
-import { PluginDeployerHandler, PluginDeployerEntry, PluginEntryPoint, DeployedPlugin, PluginDependencies, PluginType } from '../../common/plugin-protocol';
+import {
+    PluginDeployerHandler, PluginDeployerEntry, PluginEntryPoint, DeployedPlugin,
+    PluginDependencies, PluginType, PluginIdentifiers
+} from '../../common/plugin-protocol';
 import { HostedPluginReader } from './plugin-reader';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 import { Stopwatch } from '@theia/core/lib/common';
+import { PluginUninstallationManager } from '../../main/node/plugin-uninstallation-manager';
 
 @injectable()
 export class HostedPluginDeployerHandler implements PluginDeployerHandler {
@@ -38,42 +42,56 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
     @inject(Stopwatch)
     protected readonly stopwatch: Stopwatch;
 
-    private readonly deployedLocations = new Map<string, Set<string>>();
+    @inject(PluginUninstallationManager)
+    protected readonly uninstallationManager: PluginUninstallationManager;
+
+    private readonly deployedLocations = new Map<PluginIdentifiers.VersionedId, Set<string>>();
+    protected readonly sourceLocations = new Map<PluginIdentifiers.VersionedId, Set<string>>();
 
     /**
      * Managed plugin metadata backend entries.
      */
-    private readonly deployedBackendPlugins = new Map<string, DeployedPlugin>();
+    private readonly deployedBackendPlugins = new Map<PluginIdentifiers.VersionedId, DeployedPlugin>();
 
     /**
      * Managed plugin metadata frontend entries.
      */
-    private readonly deployedFrontendPlugins = new Map<string, DeployedPlugin>();
+    private readonly deployedFrontendPlugins = new Map<PluginIdentifiers.VersionedId, DeployedPlugin>();
 
     private backendPluginsMetadataDeferred = new Deferred<void>();
 
     private frontendPluginsMetadataDeferred = new Deferred<void>();
 
-    async getDeployedFrontendPluginIds(): Promise<string[]> {
+    async getDeployedFrontendPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         // await first deploy
         await this.frontendPluginsMetadataDeferred.promise;
         // fetch the last deployed state
-        return [...this.deployedFrontendPlugins.keys()];
+        return Array.from(this.deployedFrontendPlugins.keys());
     }
 
-    async getDeployedBackendPluginIds(): Promise<string[]> {
+    async getDeployedBackendPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         // await first deploy
         await this.backendPluginsMetadataDeferred.promise;
         // fetch the last deployed state
-        return [...this.deployedBackendPlugins.keys()];
+        return Array.from(this.deployedBackendPlugins.keys());
     }
 
-    getDeployedPlugin(pluginId: string): DeployedPlugin | undefined {
-        const metadata = this.deployedBackendPlugins.get(pluginId);
-        if (metadata) {
-            return metadata;
-        }
-        return this.deployedFrontendPlugins.get(pluginId);
+    getDeployedPluginsById(pluginId: string): DeployedPlugin[] {
+        const matches: DeployedPlugin[] = [];
+        const handle = (plugins: Iterable<DeployedPlugin>): void => {
+            for (const plugin of plugins) {
+                if (PluginIdentifiers.componentsToVersionWithId(plugin.metadata.model).id === pluginId) {
+                    matches.push(plugin);
+                }
+            }
+        };
+        handle(this.deployedFrontendPlugins.values());
+        handle(this.deployedBackendPlugins.values());
+        return matches;
+    }
+
+    getDeployedPlugin(pluginId: PluginIdentifiers.VersionedId): DeployedPlugin | undefined {
+        return this.deployedBackendPlugins.get(pluginId) ?? this.deployedFrontendPlugins.get(pluginId);
     }
 
     /**
@@ -99,62 +117,115 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         }
     }
 
-    async deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<void> {
+    async deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<number> {
+        let successes = 0;
         for (const plugin of frontendPlugins) {
-            await this.deployPlugin(plugin, 'frontend');
+            if (await this.deployPlugin(plugin, 'frontend')) { successes++; }
         }
         // resolve on first deploy
         this.frontendPluginsMetadataDeferred.resolve(undefined);
+        return successes;
     }
 
-    async deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<void> {
+    async deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<number> {
+        let successes = 0;
         for (const plugin of backendPlugins) {
-            await this.deployPlugin(plugin, 'backend');
+            if (await this.deployPlugin(plugin, 'backend')) { successes++; }
         }
         // rebuild translation config after deployment
         this.localizationService.buildTranslationConfig([...this.deployedBackendPlugins.values()]);
         // resolve on first deploy
         this.backendPluginsMetadataDeferred.resolve(undefined);
+        return successes;
     }
 
     /**
-     * @throws never! in order to isolate plugin deployment
+     * @throws never! in order to isolate plugin deployment.
+     * @returns whether the plugin is deployed after running this function. If the plugin was already installed, will still return `true`.
      */
-    protected async deployPlugin(entry: PluginDeployerEntry, entryPoint: keyof PluginEntryPoint): Promise<void> {
+    protected async deployPlugin(entry: PluginDeployerEntry, entryPoint: keyof PluginEntryPoint): Promise<boolean> {
         const pluginPath = entry.path();
         const deployPlugin = this.stopwatch.start('deployPlugin');
+        let id;
+        let success = true;
         try {
             const manifest = await this.reader.readPackage(pluginPath);
             if (!manifest) {
                 deployPlugin.error(`Failed to read ${entryPoint} plugin manifest from '${pluginPath}''`);
-                return;
+                return success = false;
             }
 
             const metadata = this.reader.readMetadata(manifest);
             metadata.isUnderDevelopment = entry.getValue('isUnderDevelopment') ?? false;
 
-            const deployedLocations = this.deployedLocations.get(metadata.model.id) || new Set<string>();
+            id = PluginIdentifiers.componentsToVersionedId(metadata.model);
+
+            const deployedLocations = this.deployedLocations.get(id) ?? new Set<string>();
             deployedLocations.add(entry.rootPath);
-            this.deployedLocations.set(metadata.model.id, deployedLocations);
+            this.deployedLocations.set(id, deployedLocations);
+            this.setSourceLocationsForPlugin(id, entry);
 
             const deployedPlugins = entryPoint === 'backend' ? this.deployedBackendPlugins : this.deployedFrontendPlugins;
-            if (deployedPlugins.has(metadata.model.id)) {
+            if (deployedPlugins.has(id)) {
                 deployPlugin.debug(`Skipped ${entryPoint} plugin ${metadata.model.name} already deployed`);
-                return;
+                return true;
             }
 
             const { type } = entry;
             const deployed: DeployedPlugin = { metadata, type };
             deployed.contributes = this.reader.readContribution(manifest);
             this.localizationService.deployLocalizations(deployed);
-            deployedPlugins.set(metadata.model.id, deployed);
-            deployPlugin.log(`Deployed ${entryPoint} plugin "${metadata.model.name}@${metadata.model.version}" from "${metadata.model.entryPoint[entryPoint] || pluginPath}"`);
+            deployedPlugins.set(id, deployed);
+            deployPlugin.log(`Deployed ${entryPoint} plugin "${id}" from "${metadata.model.entryPoint[entryPoint] || pluginPath}"`);
         } catch (e) {
             deployPlugin.error(`Failed to deploy ${entryPoint} plugin from '${pluginPath}' path`, e);
+            return success = false;
+        } finally {
+            if (success && id) {
+                this.markAsInstalled(id);
+            }
+        }
+        return success;
+    }
+
+    async uninstallPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+        try {
+            const sourceLocations = this.sourceLocations.get(pluginId);
+            if (!sourceLocations) {
+                return false;
+            }
+            await Promise.all(Array.from(sourceLocations,
+                location => fs.remove(location).catch(err => console.error(`Failed to remove source for ${pluginId} at ${location}`, err))));
+            this.sourceLocations.delete(pluginId);
+            this.uninstallationManager.markAsUninstalled(pluginId);
+            return true;
+        } catch (e) {
+            console.error('Error uninstalling plugin', e);
+            return false;
         }
     }
 
-    async undeployPlugin(pluginId: string): Promise<boolean> {
+    protected markAsInstalled(id: PluginIdentifiers.VersionedId): void {
+        const metadata = PluginIdentifiers.idAndVersionFromVersionedId(id);
+        if (metadata) {
+            const toMarkAsUninstalled: PluginIdentifiers.VersionedId[] = [];
+            const checkForDifferentVersions = (others: Iterable<PluginIdentifiers.VersionedId>) => {
+                for (const other of others) {
+                    const otherMetadata = PluginIdentifiers.idAndVersionFromVersionedId(other);
+                    if (metadata.id === otherMetadata?.id && metadata.version !== otherMetadata.version) {
+                        toMarkAsUninstalled.push(other);
+                    }
+                }
+            };
+            checkForDifferentVersions(this.deployedFrontendPlugins.keys());
+            checkForDifferentVersions(this.deployedBackendPlugins.keys());
+            this.uninstallationManager.markAsUninstalled(...toMarkAsUninstalled);
+            this.uninstallationManager.markAsInstalled(id);
+            toMarkAsUninstalled.forEach(pluginToUninstall => this.uninstallPlugin(pluginToUninstall));
+        }
+    }
+
+    async undeployPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
         this.deployedBackendPlugins.delete(pluginId);
         this.deployedFrontendPlugins.delete(pluginId);
         const deployedLocations = this.deployedLocations.get(pluginId);
@@ -176,4 +247,14 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
 
         return true;
     }
+
+    protected setSourceLocationsForPlugin(id: PluginIdentifiers.VersionedId, entry: PluginDeployerEntry): void {
+        const knownLocations = this.sourceLocations.get(id) ?? new Set();
+        const maybeStoredLocations = entry.getValue('sourceLocations');
+        const storedLocations = Array.isArray(maybeStoredLocations) && maybeStoredLocations.every(location => typeof location === 'string')
+            ? maybeStoredLocations.concat(entry.originalPath())
+            : [entry.originalPath()];
+        storedLocations.forEach(location => knownLocations.add(location));
+        this.sourceLocations.set(id, knownLocations);
+    }
 }

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

@@ -19,7 +19,7 @@ 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, PluginContribution } from '../../common';
+import { DeployedPlugin, Localization as PluginLocalization } from '../../common';
 import { URI } from '@theia/core/shared/vscode-uri';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 
@@ -55,18 +55,16 @@ export class HostedPluginLocalizationService {
         const localization = this.localizationProvider.loadLocalization(currentLanguage);
         const pluginPath = URI.parse(plugin.metadata.model.packageUri).fsPath;
         const pluginId = plugin.metadata.model.id;
-        // create a shallow copy to not override the original plugin's contributes property.
-        const shallowCopy = { ...plugin };
         try {
             const translations = await loadPackageTranslations(pluginPath, currentLanguage);
-            shallowCopy.contributes = localizePackage(shallowCopy.contributes, translations, (key, original) => {
+            plugin = localizePackage(plugin, translations, (key, original) => {
                 const fullKey = `${pluginId}/package/${key}`;
                 return Localization.localize(localization, fullKey, original);
-            }) as PluginContribution;
+            }) as DeployedPlugin;
         } catch (err) {
             console.error(`Failed to localize plugin '${pluginId}'.`, err);
         }
-        return shallowCopy;
+        return plugin;
     }
 
     getNlsConfig(): VSCodeNlsConfig {