@theia/plugin-ext 1.27.0-next.8 → 1.28.0-next.0

package/src/main/node/handlers/plugin-theia-directory-handler.ts

@@ -14,18 +14,24 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import * as path from 'path';
+import * as filenamify from 'filenamify';
+import * as fs from '@theia/core/shared/fs-extra';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { FileUri } from '@theia/core/lib/node';
 import {
-    PluginDeployerDirectoryHandler,
-    PluginDeployerEntry, PluginPackage, PluginDeployerDirectoryHandlerContext,
-    PluginDeployerEntryType
+    PluginDeployerDirectoryHandler, PluginDeployerEntry, PluginPackage, PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginType, PluginIdentifiers
 } from '../../../common/plugin-protocol';
-import { injectable } from '@theia/core/shared/inversify';
-import * as fs from '@theia/core/shared/fs-extra';
-import * as path from 'path';
+import { PluginCliContribution } from '../plugin-cli-contribution';
+import { getTempDir } from '../temp-dir-util';
 
 @injectable()
 export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandler {
 
+    protected readonly deploymentDirectory = FileUri.create(getTempDir('theia-copied'));
+
+    @inject(PluginCliContribution) protected readonly pluginCli: PluginCliContribution;
+
     accept(resolvedPlugin: PluginDeployerEntry): boolean {
 
         console.log('PluginTheiaDirectoryHandler: accepting plugin with path', resolvedPlugin.path());
@@ -37,33 +43,26 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
 
         // is there a package.json ?
         const packageJsonPath = path.resolve(resolvedPlugin.path(), 'package.json');
-        const existsPackageJson: boolean = fs.existsSync(packageJsonPath);
-        if (!existsPackageJson) {
-            return false;
-        }
-
-        let packageJson: PluginPackage = resolvedPlugin.getValue('package.json');
-        if (!packageJson) {
-            packageJson = fs.readJSONSync(packageJsonPath);
-            resolvedPlugin.storeValue('package.json', packageJson);
-        }
 
-        if (!packageJson.engines) {
-            return false;
-        }
-
-        if (packageJson.engines && packageJson.engines.theiaPlugin) {
-            return true;
-        }
+        try {
+            let packageJson = resolvedPlugin.getValue<PluginPackage>('package.json');
+            if (!packageJson) {
+                packageJson = fs.readJSONSync(packageJsonPath);
+                packageJson.publisher ??= PluginIdentifiers.UNPUBLISHED;
+                resolvedPlugin.storeValue('package.json', packageJson);
+            }
 
+            if (packageJson?.engines?.theiaPlugin) {
+                return true;
+            }
+        } catch { /* Failed to read file. Fall through. */ }
         return false;
-
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handle(context: PluginDeployerDirectoryHandlerContext): Promise<any> {
+    async handle(context: PluginDeployerDirectoryHandlerContext): Promise<void> {
+        await this.copyDirectory(context);
         const types: PluginDeployerEntryType[] = [];
-        const packageJson: PluginPackage = context.pluginEntry().getValue('package.json');
+        const packageJson = context.pluginEntry().getValue<PluginPackage>('package.json');
         if (packageJson.theiaPlugin && packageJson.theiaPlugin.backend) {
             types.push(PluginDeployerEntryType.BACKEND);
         }
@@ -72,6 +71,35 @@ export class PluginTheiaDirectoryHandler implements PluginDeployerDirectoryHandl
         }
 
         context.pluginEntry().accept(...types);
-        return Promise.resolve(true);
+    }
+
+    protected async copyDirectory(context: PluginDeployerDirectoryHandlerContext): Promise<void> {
+        if (this.pluginCli.copyUncompressedPlugins() && context.pluginEntry().type === PluginType.User) {
+            const entry = context.pluginEntry();
+            const id = entry.id();
+            const pathToRestore = entry.path();
+            const origin = entry.originalPath();
+            const targetDir = await this.getExtensionDir(context);
+            try {
+                if (fs.existsSync(targetDir) || !entry.path().startsWith(origin)) {
+                    console.log(`[${id}]: already copied.`);
+                } else {
+                    console.log(`[${id}]: copying to "${targetDir}"`);
+                    await fs.mkdirp(FileUri.fsPath(this.deploymentDirectory));
+                    await context.copy(origin, targetDir);
+                    entry.updatePath(targetDir);
+                    if (!this.accept(entry)) {
+                        throw new Error('Unable to resolve plugin metadata after copying');
+                    }
+                }
+            } catch (e) {
+                console.warn(`[${id}]: Error when copying.`, e);
+                entry.updatePath(pathToRestore);
+            }
+        }
+    }
+
+    protected async getExtensionDir(context: PluginDeployerDirectoryHandlerContext): Promise<string> {
+        return FileUri.fsPath(this.deploymentDirectory.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
     }
 }

package/src/main/node/handlers/plugin-theia-file-handler.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import * as path from 'path';
 import { PluginDeployerFileHandler, PluginDeployerEntry, PluginDeployerFileHandlerContext, PluginType } from '../../../common/plugin-protocol';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { getTempDir } from '../temp-dir-util';
@@ -21,6 +22,7 @@ import * as fs from '@theia/core/shared/fs-extra';
 import * as filenamify from 'filenamify';
 import { FileUri } from '@theia/core/lib/node/file-uri';
 import { PluginTheiaEnvironment } from '../../common/plugin-theia-environment';
+import URI from '@theia/core/lib/common/uri';
 
 @injectable()
 export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
@@ -35,6 +37,7 @@ export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
     }
 
     async handle(context: PluginDeployerFileHandlerContext): Promise<void> {
+        await this.ensureDiscoverability(context);
         const id = context.pluginEntry().id();
         const pluginDir = await this.getPluginDir(context);
         console.log(`[${id}]: trying to decompress into "${pluginDir}"...`);
@@ -48,11 +51,30 @@ export class PluginTheiaFileHandler implements PluginDeployerFileHandler {
         context.pluginEntry().updatePath(pluginDir);
     }
 
-    protected async getPluginDir(context: PluginDeployerFileHandlerContext): Promise<string> {
-        let pluginsDirUri = this.systemPluginsDirUri;
+    /**
+     * Ensures that a user-installed plugin file is transferred to the user extension folder.
+     */
+    protected async ensureDiscoverability(context: PluginDeployerFileHandlerContext): Promise<void> {
         if (context.pluginEntry().type === PluginType.User) {
-            pluginsDirUri = await this.environment.getPluginsDirUri();
+            const userExtensionsDir = await this.environment.getPluginsDirUri();
+            const currentPath = context.pluginEntry().path();
+            if (!userExtensionsDir.isEqualOrParent(new URI(currentPath)) && !userExtensionsDir.isEqualOrParent(new URI(context.pluginEntry().originalPath()))) {
+                try {
+                    const newPath = FileUri.fsPath(userExtensionsDir.resolve(path.basename(currentPath)));
+                    await fs.mkdirp(FileUri.fsPath(userExtensionsDir));
+                    await new Promise<void>((resolve, reject) => {
+                        fs.copyFile(currentPath, newPath, error => error ? reject(error) : resolve());
+                    });
+                    context.pluginEntry().updatePath(newPath);
+                    context.pluginEntry().storeValue('sourceLocations', [newPath]);
+                } catch (e) {
+                    console.error(`[${context.pluginEntry().id}]: Failed to copy to user directory. Future sessions may not have access to this plugin.`);
+                }
+            }
         }
-        return FileUri.fsPath(pluginsDirUri.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
+    }
+
+    protected async getPluginDir(context: PluginDeployerFileHandlerContext): Promise<string> {
+        return FileUri.fsPath(this.systemPluginsDirUri.resolve(filenamify(context.pluginEntry().id(), { replacement: '_' })));
     }
 }

package/src/main/node/plugin-cli-contribution.ts

@@ -24,6 +24,7 @@ export class PluginCliContribution implements CliContribution {
 
     static PLUGINS = 'plugins';
     static PLUGIN_MAX_SESSION_LOGS_FOLDERS = 'plugin-max-session-logs-folders';
+    static UNCOMPRESSED_PLUGINS_IN_PLACE = 'uncompressed-plugins-in-place';
     /**
      * This is the default value used in VSCode, see:
      * - https://github.com/Microsoft/vscode/blob/613447d6b3f458ef7fee227e3876303bf5184580/src/vs/code/electron-browser/sharedProcess/contrib/logsDataCleaner.ts#L32
@@ -32,6 +33,7 @@ export class PluginCliContribution implements CliContribution {
 
     protected _localDir: string | undefined;
     protected _maxSessionLogsFolders: number;
+    protected _keepUncompressedInPlace = false;
 
     configure(conf: Argv): void {
         conf.option(PluginCliContribution.PLUGINS, {
@@ -48,6 +50,12 @@ export class PluginCliContribution implements CliContribution {
             default: PluginCliContribution.DEFAULT_PLUGIN_MAX_SESSION_LOGS_FOLDERS,
             nargs: 1
         });
+
+        conf.option(PluginCliContribution.UNCOMPRESSED_PLUGINS_IN_PLACE, {
+            description: 'Whether user plugins that are stored on disk as uncompressed directories should be run in place or copied to temporary folder.',
+            type: 'boolean',
+            default: false,
+        });
     }
 
     setArguments(args: Arguments): void {
@@ -60,6 +68,7 @@ export class PluginCliContribution implements CliContribution {
         if (maxSessionLogsFoldersArg && Number.isInteger(maxSessionLogsFoldersArg) && maxSessionLogsFoldersArg > 0) {
             this._maxSessionLogsFolders = maxSessionLogsFoldersArg;
         }
+        this._keepUncompressedInPlace = Boolean(args[PluginCliContribution.UNCOMPRESSED_PLUGINS_IN_PLACE]);
     }
 
     localDir(): string | undefined {
@@ -70,4 +79,7 @@ export class PluginCliContribution implements CliContribution {
         return this._maxSessionLogsFolders;
     }
 
+    copyUncompressedPlugins(): boolean {
+        return !this._keepUncompressedInPlace;
+    }
 }

package/src/main/node/plugin-deployer-directory-handler-context-impl.ts

@@ -14,12 +14,28 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import * as path from 'path';
+import * as fs from '@theia/core/shared/fs-extra';
 import { PluginDeployerEntry, PluginDeployerDirectoryHandlerContext } from '../../common/plugin-protocol';
 
 export class PluginDeployerDirectoryHandlerContextImpl implements PluginDeployerDirectoryHandlerContext {
 
-    constructor(private readonly pluginDeployerEntry: PluginDeployerEntry) {
+    constructor(private readonly pluginDeployerEntry: PluginDeployerEntry) { }
 
+    async copy(origin: string, target: string): Promise<void> {
+        const contents = await fs.readdir(origin);
+        await fs.mkdirp(target);
+        await Promise.all(contents.map(async item => {
+            const itemPath = path.resolve(origin, item);
+            const targetPath = path.resolve(target, item);
+            const stat = await fs.stat(itemPath);
+            if (stat.isDirectory()) {
+                return this.copy(itemPath, targetPath);
+            }
+            if (stat.isFile()) {
+                return new Promise<void>((resolve, reject) => fs.copyFile(itemPath, targetPath, e => e === null ? resolve() : reject(e)));
+            }
+        }));
     }
 
     pluginEntry(): PluginDeployerEntry {

package/src/main/node/plugin-deployer-file-handler-context-impl.ts

@@ -25,7 +25,6 @@ export class PluginDeployerFileHandlerContextImpl implements PluginDeployerFileH
 
     async unzip(sourcePath: string, destPath: string): Promise<void> {
         await decompress(sourcePath, destPath);
-        return Promise.resolve();
     }
 
     pluginEntry(): PluginDeployerEntry {

package/src/main/node/plugin-deployer-impl.ts

@@ -17,11 +17,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { injectable, optional, multiInject, inject, named } from '@theia/core/shared/inversify';
+import * as semver from 'semver';
 import {
     PluginDeployerResolver, PluginDeployerFileHandler, PluginDeployerDirectoryHandler,
     PluginDeployerEntry, PluginDeployer, PluginDeployerParticipant, PluginDeployerStartContext,
     PluginDeployerResolverInit, PluginDeployerFileHandlerContext,
-    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry
+    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions
 } from '../../common/plugin-protocol';
 import { PluginDeployerEntryImpl } from './plugin-deployer-entry-impl';
 import {
@@ -135,21 +136,26 @@ export class PluginDeployerImpl implements PluginDeployer {
         deployPlugins.log('Deploy plugins list');
     }
 
-    async undeploy(pluginId: string): Promise<void> {
+    async uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
+        await this.pluginDeployerHandler.uninstallPlugin(pluginId);
+    }
+
+    async undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         if (await this.pluginDeployerHandler.undeployPlugin(pluginId)) {
             this.onDidDeployEmitter.fire();
         }
     }
 
-    async deploy(plugin: UnresolvedPluginEntry): Promise<void> {
+    async deploy(plugin: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
         const deploy = this.measure('deploy');
-        await this.deployMultipleEntries([plugin]);
-        deploy.log(`Deploy plugin ${plugin}`);
+        const numDeployedPlugins = await this.deployMultipleEntries([plugin], options);
+        deploy.log(`Deploy plugin ${plugin.id}`);
+        return numDeployedPlugins;
     }
 
-    protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[]): Promise<void> {
-        const pluginsToDeploy = await this.resolvePlugins(plugins);
-        await this.deployPlugins(pluginsToDeploy);
+    protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[], options?: PluginDeployOptions): Promise<number> {
+        const pluginsToDeploy = await this.resolvePlugins(plugins, options);
+        return this.deployPlugins(pluginsToDeploy);
     }
 
     /**
@@ -161,51 +167,51 @@ export class PluginDeployerImpl implements PluginDeployer {
      * deployer.deployPlugins(await deployer.resolvePlugins(allPluginEntries));
      * ```
      */
-    async resolvePlugins(plugins: UnresolvedPluginEntry[]): Promise<PluginDeployerEntry[]> {
+    async resolvePlugins(plugins: UnresolvedPluginEntry[], options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
         const visited = new Set<string>();
-        const pluginsToDeploy = new Map<string, PluginDeployerEntry>();
+        const hasBeenVisited = (id: string) => visited.has(id) || (visited.add(id), false);
+        const pluginsToDeploy = new Map<PluginIdentifiers.VersionedId, PluginDeployerEntry>();
+        const unversionedIdsHandled = new Map<PluginIdentifiers.UnversionedId, string[]>();
 
-        let queue: UnresolvedPluginEntry[] = [...plugins];
+        const queue: UnresolvedPluginEntry[] = [...plugins];
         while (queue.length) {
-            const dependenciesChunk: Array<{
+            const pendingDependencies: Array<{
                 dependencies: Map<string, string>
                 type: PluginType
             }> = [];
-            const workload: UnresolvedPluginEntry[] = [];
-            while (queue.length) {
-                const current = queue.shift()!;
-                if (visited.has(current.id)) {
-                    continue;
-                } else {
-                    workload.push(current);
-                }
-                visited.add(current.id);
-            }
-            queue = [];
-            await Promise.all(workload.map(async ({ id, type }) => {
-                if (type === undefined) {
-                    type = PluginType.System;
+            await Promise.all(queue.map(async entry => {
+                if (hasBeenVisited(entry.id)) {
+                    return;
                 }
+                const type = entry.type ?? PluginType.System;
                 try {
-                    const pluginDeployerEntries = await this.resolvePlugin(id, type);
-                    await this.applyFileHandlers(pluginDeployerEntries);
-                    await this.applyDirectoryFileHandlers(pluginDeployerEntries);
+                    const pluginDeployerEntries = await this.resolveAndHandle(entry.id, type, options);
                     for (const deployerEntry of pluginDeployerEntries) {
-                        const dependencies = await this.pluginDeployerHandler.getPluginDependencies(deployerEntry);
-                        if (dependencies && !pluginsToDeploy.has(dependencies.metadata.model.id)) {
-                            pluginsToDeploy.set(dependencies.metadata.model.id, deployerEntry);
-                            if (dependencies.mapping) {
-                                dependenciesChunk.push({ dependencies: dependencies.mapping, type });
+                        const pluginData = await this.pluginDeployerHandler.getPluginDependencies(deployerEntry);
+                        const versionedId = pluginData && PluginIdentifiers.componentsToVersionedId(pluginData.metadata.model);
+                        const unversionedId = versionedId && PluginIdentifiers.componentsToUnversionedId(pluginData.metadata.model);
+                        if (unversionedId && !pluginsToDeploy.has(versionedId)) {
+                            pluginsToDeploy.set(versionedId, deployerEntry);
+                            if (pluginData.mapping) {
+                                pendingDependencies.push({ dependencies: pluginData.mapping, type });
+                            }
+                            const otherVersions = unversionedIdsHandled.get(unversionedId) ?? [];
+                            otherVersions.push(pluginData.metadata.model.version);
+                            if (otherVersions.length === 1) {
+                                unversionedIdsHandled.set(unversionedId, otherVersions);
+                            } else {
+                                this.findBestVersion(unversionedId, otherVersions, pluginsToDeploy);
                             }
                         }
                     }
                 } catch (e) {
-                    console.error(`Failed to resolve plugins from '${id}'`, e);
+                    console.error(`Failed to resolve plugins from '${entry.id}'`, e);
                 }
             }));
-            for (const { dependencies, type } of dependenciesChunk) {
+            queue.length = 0;
+            for (const { dependencies, type } of pendingDependencies) {
                 for (const [dependency, deployableDependency] of dependencies) {
-                    if (!pluginsToDeploy.has(dependency)) {
+                    if (!unversionedIdsHandled.has(dependency as PluginIdentifiers.UnversionedId)) {
                         queue.push({
                             id: deployableDependency,
                             type
@@ -217,10 +223,50 @@ export class PluginDeployerImpl implements PluginDeployer {
         return [...pluginsToDeploy.values()];
     }
 
+    protected async resolveAndHandle(id: string, type: PluginType, options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
+        const entries = await this.resolvePlugin(id, type, options);
+        await this.applyFileHandlers(entries);
+        await this.applyDirectoryFileHandlers(entries);
+        return entries;
+    }
+
+    protected findBestVersion(unversionedId: PluginIdentifiers.UnversionedId, versions: string[], knownPlugins: Map<PluginIdentifiers.VersionedId, PluginDeployerEntry>): void {
+        // If left better, return negative. Then best is index 0.
+        versions.map(version => ({ version, plugin: knownPlugins.get(PluginIdentifiers.idAndVersionToVersionedId({ version, id: unversionedId })) }))
+            .sort((left, right) => {
+                const leftPlugin = left.plugin;
+                const rightPlugin = right.plugin;
+                if (!leftPlugin && !rightPlugin) {
+                    return 0;
+                }
+                if (!rightPlugin) {
+                    return -1;
+                }
+                if (!leftPlugin) {
+                    return 1;
+                }
+                if (leftPlugin.type === PluginType.System && rightPlugin.type === PluginType.User) {
+                    return -1;
+                }
+                if (leftPlugin.type === PluginType.User && rightPlugin.type === PluginType.System) {
+                    return 1;
+                }
+                if (semver.gtr(left.version, right.version)) {
+                    return -1;
+                }
+                return 1;
+            }).forEach((versionedEntry, index) => {
+                if (index !== 0) {
+                    // Mark as not accepted to prevent deployment of all but the winner.
+                    versionedEntry.plugin?.accept();
+                }
+            });
+    }
+
     /**
      * deploy all plugins that have been accepted
      */
-    async deployPlugins(pluginsToDeploy: PluginDeployerEntry[]): Promise<any> {
+    async deployPlugins(pluginsToDeploy: PluginDeployerEntry[]): Promise<number> {
         const acceptedPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted());
         const acceptedFrontendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.FRONTEND));
         const acceptedBackendPlugins = pluginsToDeploy.filter(pluginDeployerEntry => pluginDeployerEntry.isAccepted(PluginDeployerEntryType.BACKEND));
@@ -237,12 +283,13 @@ export class PluginDeployerImpl implements PluginDeployer {
         const pluginPaths = acceptedBackendPlugins.map(pluginEntry => pluginEntry.path());
         this.logger.debug('local path to deploy on remote instance', pluginPaths);
 
-        await Promise.all([
+        const deployments = await Promise.all([
             // start the backend plugins
             this.pluginDeployerHandler.deployBackendPlugins(acceptedBackendPlugins),
             this.pluginDeployerHandler.deployFrontendPlugins(acceptedFrontendPlugins)
         ]);
         this.onDidDeployEmitter.fire(undefined);
+        return deployments.reduce<number>((accumulated, current) => accumulated += current ?? 0, 0);
     }
 
     /**
@@ -288,7 +335,7 @@ export class PluginDeployerImpl implements PluginDeployer {
     /**
      * Check a plugin ID see if there are some resolvers that can handle it. If there is a matching resolver, then we resolve the plugin
      */
-    public async resolvePlugin(pluginId: string, type: PluginType = PluginType.System): Promise<PluginDeployerEntry[]> {
+    public async resolvePlugin(pluginId: string, type: PluginType = PluginType.System, options?: PluginDeployOptions): Promise<PluginDeployerEntry[]> {
         const pluginDeployerEntries: PluginDeployerEntry[] = [];
         const foundPluginResolver = this.pluginResolvers.find(pluginResolver => pluginResolver.accept(pluginId));
         // there is a resolver for the input
@@ -297,7 +344,7 @@ export class PluginDeployerImpl implements PluginDeployer {
             // create context object
             const context = new PluginDeployerResolverContextImpl(foundPluginResolver, pluginId);
 
-            await foundPluginResolver.resolve(context);
+            await foundPluginResolver.resolve(context, options);
 
             context.getPlugins().forEach(entry => {
                 entry.type = type;

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

@@ -39,6 +39,7 @@ import { PluginCliContribution } from './plugin-cli-contribution';
 import { PluginTheiaEnvironment } from '../common/plugin-theia-environment';
 import { PluginTheiaDeployerParticipant } from './plugin-theia-deployer-participant';
 import { WebviewBackendSecurityWarnings } from './webview-backend-security-warnings';
+import { PluginUninstallationManager } from './plugin-uninstallation-manager';
 
 export function bindMainBackend(bind: interfaces.Bind): void {
     bind(PluginApiContribution).toSelf().inSingletonScope();
@@ -50,6 +51,8 @@ export function bindMainBackend(bind: interfaces.Bind): void {
     bind(PluginDeployerContribution).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(PluginDeployerContribution);
 
+    bind(PluginUninstallationManager).toSelf().inSingletonScope();
+
     bind(PluginDeployerResolver).to(LocalDirectoryPluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(LocalFilePluginDeployerResolver).inSingletonScope();
     bind(PluginDeployerResolver).to(GithubPluginDeployerResolver).inSingletonScope();

package/src/main/node/plugin-server-handler.ts

@@ -18,7 +18,7 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { PluginDeployerImpl } from './plugin-deployer-impl';
 import { PluginsKeyValueStorage } from './plugins-key-value-storage';
-import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry } from '../../common/plugin-protocol';
+import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry, PluginIdentifiers, PluginDeployOptions } from '../../common/plugin-protocol';
 import { KeysToAnyValues, KeysToKeysToAnyValue } from '../../common/types';
 
 @injectable()
@@ -30,19 +30,27 @@ export class PluginServerHandler implements PluginServer {
     @inject(PluginsKeyValueStorage)
     protected readonly pluginsKeyValueStorage: PluginsKeyValueStorage;
 
-    deploy(pluginEntry: string, arg2?: PluginType | CancellationToken): Promise<void> {
+    async deploy(pluginEntry: string, arg2?: PluginType | CancellationToken, options?: PluginDeployOptions): Promise<void> {
         const type = typeof arg2 === 'number' ? arg2 as PluginType : undefined;
-        return this.doDeploy({
+        const successfulDeployments = await this.doDeploy({
             id: pluginEntry,
             type: type ?? PluginType.User
-        });
+        }, options);
+        if (successfulDeployments === 0) {
+            const optionText = options ? ` and options ${JSON.stringify(options)} ` : ' ';
+            throw new Error(`Deployment of extension with ID ${pluginEntry}${optionText}failed.`);
+        }
     }
 
-    protected doDeploy(pluginEntry: UnresolvedPluginEntry): Promise<void> {
-        return this.pluginDeployer.deploy(pluginEntry);
+    protected doDeploy(pluginEntry: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
+        return this.pluginDeployer.deploy(pluginEntry, options);
     }
 
-    undeploy(pluginId: string): Promise<void> {
+    uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
+        return this.pluginDeployer.uninstall(pluginId);
+    }
+
+    undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         return this.pluginDeployer.undeploy(pluginId);
     }
 

package/src/main/node/plugin-uninstallation-manager.ts

@@ -0,0 +1,74 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+import { Emitter, Event } from '@theia/core';
+import { injectable } from '@theia/core/shared/inversify';
+import { PluginIdentifiers } from '../../common';
+
+@injectable()
+export class PluginUninstallationManager {
+    protected readonly onDidChangeUninstalledPluginsEmitter = new Emitter<readonly PluginIdentifiers.VersionedId[]>();
+
+    get onDidChangeUninstalledPlugins(): Event<readonly PluginIdentifiers.VersionedId[]> {
+        return this.onDidChangeUninstalledPluginsEmitter.event;
+    }
+
+    protected uninstalledPlugins: PluginIdentifiers.VersionedId[] = [];
+
+    protected fireDidChange(): void {
+        this.onDidChangeUninstalledPluginsEmitter.fire(Object.freeze(this.uninstalledPlugins.slice()));
+    }
+
+    markAsUninstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+        let didChange = false;
+        for (const id of pluginIds) { didChange = this.markOneAsUninstalled(id) || didChange; }
+        if (didChange) { this.fireDidChange(); }
+        return didChange;
+    }
+
+    protected markOneAsUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        if (!this.uninstalledPlugins.includes(pluginId)) {
+            this.uninstalledPlugins.push(pluginId);
+            return true;
+        }
+        return false;
+    }
+
+    markAsInstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+        let didChange = false;
+        for (const id of pluginIds) { didChange = this.markOneAsInstalled(id) || didChange; }
+        if (didChange) { this.fireDidChange(); }
+        return didChange;
+    }
+
+    protected markOneAsInstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        let index: number;
+        let didChange = false;
+        while ((index = this.uninstalledPlugins.indexOf(pluginId)) !== -1) {
+            this.uninstalledPlugins.splice(index, 1);
+            didChange = true;
+        }
+        return didChange;
+    }
+
+    isUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        return this.uninstalledPlugins.includes(pluginId);
+    }
+
+    getUninstalledPluginIds(): readonly PluginIdentifiers.VersionedId[] {
+        return Object.freeze(this.uninstalledPlugins.slice());
+    }
+}