@theia/plugin-ext 1.27.0-next.39 → 1.27.0-next.42

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;
@@ -487,6 +490,8 @@ export interface PluginDeployerFileHandlerContext {
 
 export interface PluginDeployerDirectoryHandlerContext {
 
+    copy(origin: string, target: string): Promise<void>;
+
     pluginEntry(): PluginDeployerEntry;
 
 }
@@ -811,6 +816,7 @@ export interface PluginMetadata {
     model: PluginModel;
     lifecycle: PluginLifecycle;
     isUnderDevelopment?: boolean;
+    outOfSync: boolean;
 }
 
 export const MetadataProcessor = Symbol('MetadataProcessor');
@@ -837,6 +843,11 @@ 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>
 }
 
@@ -845,14 +856,25 @@ export interface PluginDeployerHandler {
     deployFrontendPlugins(frontendPlugins: PluginDeployerEntry[]): Promise<void>;
     deployBackendPlugins(backendPlugins: PluginDeployerEntry[]): Promise<void>;
 
-    getDeployedPlugin(pluginId: string): DeployedPlugin | undefined;
-    undeployPlugin(pluginId: string): Promise<boolean>;
+    getDeployedPluginsById(pluginId: string): DeployedPlugin[];
+
+    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 {
@@ -867,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[]>;
 
@@ -899,8 +923,8 @@ 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>;
+    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>;
@@ -925,7 +949,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,33 @@ 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) {
+                    didChangeInstallationStatus = true;
+                    plugin.metadata.outOfSync = 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 +346,7 @@ export class HostedPluginSupport {
                 }
             }
         } finally {
-            if (initialized || toUnload.size) {
+            if (initialized || toUnload.size || didChangeInstallationStatus) {
                 this.onDidChangePluginsEmitter.fire(undefined);
             }
 

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 originalLocations = new Map<PluginIdentifiers.VersionedId, 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).version === 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);
     }
 
     /**
@@ -123,6 +141,8 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
     protected async deployPlugin(entry: PluginDeployerEntry, entryPoint: keyof PluginEntryPoint): Promise<void> {
         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) {
@@ -133,12 +153,15 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             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.originalLocations.set(id, entry.originalPath());
 
             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;
             }
@@ -147,14 +170,35 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             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) {
+            success = false;
             deployPlugin.error(`Failed to deploy ${entryPoint} plugin from '${pluginPath}' path`, e);
+        } finally {
+            if (success && id) {
+                this.uninstallationManager.markAsInstalled(id);
+            }
+        }
+    }
+
+    async uninstallPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+        try {
+            const originalPath = this.originalLocations.get(pluginId);
+            if (!originalPath) {
+                return false;
+            }
+            await fs.remove(originalPath);
+            this.originalLocations.delete(pluginId);
+            this.uninstallationManager.markAsUninstalled(pluginId);
+            return true;
+        } catch (e) {
+            console.error('Error uninstalling plugin', e);
+            return false;
         }
     }
 
-    async undeployPlugin(pluginId: string): Promise<boolean> {
+    async undeployPlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
         this.deployedBackendPlugins.delete(pluginId);
         this.deployedFrontendPlugins.delete(pluginId);
         const deployedLocations = this.deployedLocations.get(pluginId);

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

@@ -18,7 +18,7 @@ import * as cp from 'child_process';
 import { injectable, inject, named } from '@theia/core/shared/inversify';
 import { ILogger, ConnectionErrorHandler, ContributionProvider, MessageService } from '@theia/core/lib/common';
 import { createIpcEnv } from '@theia/core/lib/node/messaging/ipc-protocol';
-import { HostedPluginClient, ServerPluginRunner, PluginHostEnvironmentVariable, DeployedPlugin, PLUGIN_HOST_BACKEND } from '../../common/plugin-protocol';
+import { HostedPluginClient, ServerPluginRunner, PluginHostEnvironmentVariable, DeployedPlugin, PLUGIN_HOST_BACKEND, PluginIdentifiers } from '../../common/plugin-protocol';
 import { MessageType } from '../../common/rpc-protocol';
 import { HostedPluginCliContribution } from './hosted-plugin-cli-contribution';
 import * as psTree from 'ps-tree';
@@ -225,7 +225,7 @@ export class HostedPluginProcess implements ServerPluginRunner {
     /**
      * Provides additional plugin ids.
      */
-    public async getExtraDeployedPluginIds(): Promise<string[]> {
+    public async getExtraDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         return [];
     }
 

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

@@ -16,7 +16,7 @@
 
 import { injectable, inject, multiInject, postConstruct, optional } from '@theia/core/shared/inversify';
 import { ILogger, ConnectionErrorHandler } from '@theia/core/lib/common';
-import { HostedPluginClient, PluginModel, ServerPluginRunner, DeployedPlugin } from '../../common/plugin-protocol';
+import { HostedPluginClient, PluginModel, ServerPluginRunner, DeployedPlugin, PluginIdentifiers } from '../../common/plugin-protocol';
 import { LogPart } from '../../common/types';
 import { HostedPluginProcess } from './hosted-plugin-process';
 
@@ -95,7 +95,7 @@ export class HostedPluginSupport {
     /**
      * Provides additional plugin ids.
      */
-    async getExtraDeployedPluginIds(): Promise<string[]> {
+    async getExtraDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         return [].concat.apply([], await Promise.all(this.pluginRunners.map(runner => runner.getExtraDeployedPluginIds())));
     }
 

package/src/hosted/node/metadata-scanner.ts

@@ -14,15 +14,16 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, multiInject } from '@theia/core/shared/inversify';
-import { PluginPackage, PluginScanner, PluginMetadata, PLUGIN_HOST_BACKEND } from '../../common/plugin-protocol';
+import { inject, injectable, multiInject } from '@theia/core/shared/inversify';
+import { PluginPackage, PluginScanner, PluginMetadata, PLUGIN_HOST_BACKEND, PluginIdentifiers } from '../../common/plugin-protocol';
+import { PluginUninstallationManager } from '../../main/node/plugin-uninstallation-manager';
 @injectable()
 export class MetadataScanner {
     private scanners: Map<string, PluginScanner> = new Map();
 
-    constructor( // eslint-disable-next-line @typescript-eslint/indent
-        @multiInject(PluginScanner) scanners: PluginScanner[]
-    ) {
+    @inject(PluginUninstallationManager) protected readonly uninstallationManager: PluginUninstallationManager;
+
+    constructor(@multiInject(PluginScanner) scanners: PluginScanner[]) {
         scanners.forEach((scanner: PluginScanner) => {
             this.scanners.set(scanner.apiType, scanner);
         });
@@ -33,7 +34,8 @@ export class MetadataScanner {
         return {
             host: PLUGIN_HOST_BACKEND,
             model: scanner.getModel(plugin),
-            lifecycle: scanner.getLifecycle(plugin)
+            lifecycle: scanner.getLifecycle(plugin),
+            outOfSync: this.uninstallationManager.isUninstalled(PluginIdentifiers.componentsToVersionedId(plugin)),
         };
     }
 

package/src/hosted/node/plugin-manifest-loader.ts

@@ -16,6 +16,7 @@
 
 import * as path from 'path';
 import * as fs from '@theia/core/shared/fs-extra';
+import { PluginIdentifiers } from '../../common';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function loadManifest(pluginPath: string): Promise<any> {
@@ -25,5 +26,6 @@ export async function loadManifest(pluginPath: string): Promise<any> {
     if (manifest && manifest.name && manifest.name.startsWith(built_prefix)) {
         manifest.name = manifest.name.substr(built_prefix.length);
     }
+    manifest.publisher ??= PluginIdentifiers.UNPUBLISHED;
     return manifest;
 }

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

@@ -14,13 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 import { injectable, inject, named, postConstruct } from '@theia/core/shared/inversify';
-import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin } from '../../common/plugin-protocol';
+import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin, PluginIdentifiers } from '../../common/plugin-protocol';
 import { HostedPluginSupport } from './hosted-plugin';
-import { ILogger, Disposable, ContributionProvider } from '@theia/core';
+import { ILogger, Disposable, ContributionProvider, DisposableCollection } from '@theia/core';
 import { ExtPluginApiProvider, ExtPluginApi } from '../../common/plugin-ext-api-contribution';
 import { HostedPluginDeployerHandler } from './hosted-plugin-deployer-handler';
 import { PluginDeployerImpl } from '../../main/node/plugin-deployer-impl';
 import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
+import { PluginUninstallationManager } from '../../main/node/plugin-uninstallation-manager';
 
 @injectable()
 export class HostedPluginServerImpl implements HostedPluginServer {
@@ -40,9 +41,21 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     @named(Symbol.for(ExtPluginApiProvider))
     protected readonly extPluginAPIContributions: ContributionProvider<ExtPluginApiProvider>;
 
+    @inject(PluginUninstallationManager) protected readonly uninstallationManager: PluginUninstallationManager;
+
     protected client: HostedPluginClient | undefined;
+    protected toDispose = new DisposableCollection();
+
+    protected _ignoredPlugins?: Set<PluginIdentifiers.VersionedId>;
+    // We ignore any plugins that are marked as uninstalled the first time the frontend requests information about deployed plugins.
+    protected get ignoredPlugins(): Set<PluginIdentifiers.VersionedId> {
+        if (!this._ignoredPlugins) {
+            this._ignoredPlugins = new Set(this.uninstallationManager.getUninstalledPluginIds());
+        }
+        return this._ignoredPlugins;
+    }
 
-    protected deployedListener: Disposable;
+    protected readonly pluginVersions = new Map<PluginIdentifiers.UnversionedId, string>();
 
     constructor(
         @inject(HostedPluginSupport) private readonly hostedPlugin: HostedPluginSupport) {
@@ -50,38 +63,78 @@ export class HostedPluginServerImpl implements HostedPluginServer {
 
     @postConstruct()
     protected init(): void {
-        this.deployedListener = this.pluginDeployer.onDidDeploy(() => {
-            if (this.client) {
-                this.client.onDidDeploy();
-            }
-        });
+        this.toDispose.pushAll([
+            this.pluginDeployer.onDidDeploy(() => this.client?.onDidDeploy()),
+            this.uninstallationManager.onDidChangeUninstalledPlugins(currentUninstalled => {
+                if (this._ignoredPlugins) {
+                    const uninstalled = new Set(currentUninstalled);
+                    for (const previouslyUninstalled of this._ignoredPlugins) {
+                        if (!uninstalled.has(previouslyUninstalled)) {
+                            this._ignoredPlugins.delete(previouslyUninstalled);
+                        }
+                    }
+                }
+                this.client?.onDidDeploy();
+            }),
+            Disposable.create(() => this.hostedPlugin.clientClosed()),
+        ]);
     }
 
     dispose(): void {
-        this.hostedPlugin.clientClosed();
-        this.deployedListener.dispose();
+        this.toDispose.dispose();
     }
+
     setClient(client: HostedPluginClient): void {
         this.client = client;
         this.hostedPlugin.setClient(client);
     }
 
-    async getDeployedPluginIds(): Promise<string[]> {
+    async getDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         const backendMetadata = await this.deployerHandler.getDeployedBackendPluginIds();
         if (backendMetadata.length > 0) {
             this.hostedPlugin.runPluginServer();
         }
-        const plugins = new Set<string>();
-        for (const pluginId of await this.deployerHandler.getDeployedFrontendPluginIds()) {
-            plugins.add(pluginId);
+        const plugins = new Set<PluginIdentifiers.VersionedId>();
+        const addIds = async (identifiers: PluginIdentifiers.VersionedId[]): Promise<void> => {
+            for (const pluginId of identifiers) {
+                if (this.isRelevantPlugin(pluginId)) {
+                    plugins.add(pluginId);
+                }
+            }
+        };
+        addIds(await this.deployerHandler.getDeployedFrontendPluginIds());
+        addIds(backendMetadata);
+        addIds(await this.hostedPlugin.getExtraDeployedPluginIds());
+        return Array.from(plugins);
+    }
+
+    /**
+     * Ensures that the plugin was not uninstalled when this session was started
+     * and that it matches the first version of the given plugin seen by this session.
+     *
+     * The deployment system may have multiple versions of the same plugin available, but
+     * a single session should only ever activate one of them.
+     */
+    protected isRelevantPlugin(identifier: PluginIdentifiers.VersionedId): boolean {
+        const versionAndId = PluginIdentifiers.idAndVersionFromVersionedId(identifier);
+        if (!versionAndId) {
+            return false;
         }
-        for (const pluginId of backendMetadata) {
-            plugins.add(pluginId);
+        const knownVersion = this.pluginVersions.get(versionAndId.id);
+        if (knownVersion !== undefined && knownVersion !== versionAndId.version) {
+            return false;
         }
-        for (const pluginId of await this.hostedPlugin.getExtraDeployedPluginIds()) {
-            plugins.add(pluginId);
+        if (this.ignoredPlugins.has(identifier)) {
+            return false;
         }
-        return [...plugins.values()];
+        if (knownVersion === undefined) {
+            this.pluginVersions.set(versionAndId.id, versionAndId.version);
+        }
+        return true;
+    }
+
+    getUninstalledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return Promise.resolve(this.uninstallationManager.getUninstalledPluginIds());
     }
 
     async getDeployedPlugins({ pluginIds }: GetDeployedPluginsParams): Promise<DeployedPlugin[]> {
@@ -90,16 +143,19 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         }
         const plugins: DeployedPlugin[] = [];
         let extraDeployedPlugins: Map<string, DeployedPlugin> | undefined;
-        for (const pluginId of pluginIds) {
-            let plugin = this.deployerHandler.getDeployedPlugin(pluginId);
+        for (const versionedId of pluginIds) {
+            if (!this.isRelevantPlugin(versionedId)) {
+                continue;
+            }
+            let plugin = this.deployerHandler.getDeployedPlugin(versionedId);
             if (!plugin) {
                 if (!extraDeployedPlugins) {
                     extraDeployedPlugins = new Map<string, DeployedPlugin>();
                     for (const extraDeployedPlugin of await this.hostedPlugin.getExtraDeployedPlugins()) {
-                        extraDeployedPlugins.set(extraDeployedPlugin.metadata.model.id, extraDeployedPlugin);
+                        extraDeployedPlugins.set(PluginIdentifiers.componentsToVersionedId(extraDeployedPlugin.metadata.model), extraDeployedPlugin);
                     }
                 }
-                plugin = extraDeployedPlugins.get(pluginId);
+                plugin = extraDeployedPlugins.get(versionedId);
             }
             if (plugin) {
                 plugins.push(plugin);

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

@@ -58,7 +58,8 @@ import {
     PluginPackageLocalization,
     Localization,
     PluginPackageTranslation,
-    Translation
+    Translation,
+    PluginIdentifiers
 } from '../../../common/plugin-protocol';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -109,13 +110,14 @@ export class TheiaPluginScanner implements PluginScanner {
     }
 
     getModel(plugin: PluginPackage): PluginModel {
+        const publisher = plugin.publisher ?? PluginIdentifiers.UNPUBLISHED;
         const result: PluginModel = {
             packagePath: plugin.packagePath,
             packageUri: this.pluginUriFactory.createUri(plugin).toString(),
             // see id definition: https://github.com/microsoft/vscode/blob/15916055fe0cb9411a5f36119b3b012458fe0a1d/src/vs/platform/extensions/common/extensions.ts#L167-L169
-            id: `${plugin.publisher.toLowerCase()}.${plugin.name.toLowerCase()}`,
+            id: `${publisher.toLowerCase()}.${plugin.name.toLowerCase()}`,
             name: plugin.name,
-            publisher: plugin.publisher,
+            publisher,
             version: plugin.version,
             displayName: plugin.displayName,
             description: plugin.description,