@theia/plugin-ext 1.60.2 → 1.61.0

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

@@ -14,14 +14,15 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { injectable, inject, named, optional, postConstruct } from '@theia/core/shared/inversify';
-import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin, PluginIdentifiers } from '../../common/plugin-protocol';
+import { HostedPluginServer, HostedPluginClient, PluginDeployer, DeployedPlugin, PluginIdentifiers } from '../../common/plugin-protocol';
 import { HostedPluginSupport } from './hosted-plugin';
 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 { PluginDeployerHandlerImpl } from './plugin-deployer-handler-impl';
 import { PluginDeployerImpl } from '../../main/node/plugin-deployer-impl';
 import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 import { PluginUninstallationManager } from '../../main/node/plugin-uninstallation-manager';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export const BackendPluginHostableFilter = Symbol('BackendPluginHostableFilter');
 /**
@@ -31,13 +32,16 @@ export const BackendPluginHostableFilter = Symbol('BackendPluginHostableFilter')
  */
 export type BackendPluginHostableFilter = (plugin: DeployedPlugin) => boolean;
 
+/**
+ * This class implements the per-front-end services for plugin management and communication
+ */
 @injectable()
 export class HostedPluginServerImpl implements HostedPluginServer {
     @inject(ILogger)
     protected readonly logger: ILogger;
 
-    @inject(HostedPluginDeployerHandler)
-    protected readonly deployerHandler: HostedPluginDeployerHandler;
+    @inject(PluginDeployerHandlerImpl)
+    protected readonly deployerHandler: PluginDeployerHandlerImpl;
 
     @inject(PluginDeployer)
     protected readonly pluginDeployer: PluginDeployerImpl;
@@ -58,18 +62,13 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     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 uninstalledPlugins: Set<PluginIdentifiers.VersionedId>;
+    protected disabledPlugins: Set<PluginIdentifiers.VersionedId>;
 
     protected readonly pluginVersions = new Map<PluginIdentifiers.UnversionedId, string>();
 
+    protected readonly initialized = new Deferred<void>();
+
     constructor(
         @inject(HostedPluginSupport) private readonly hostedPlugin: HostedPluginSupport) {
     }
@@ -80,21 +79,40 @@ export class HostedPluginServerImpl implements HostedPluginServer {
             this.backendPluginHostableFilter = () => true;
         }
 
-        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.uninstalledPlugins = new Set(this.uninstallationManager.getUninstalledPluginIds());
+
+        const asyncInit = async () => {
+            this.disabledPlugins = new Set(await this.uninstallationManager.getDisabledPluginIds());
+
+            this.toDispose.pushAll([
+                this.pluginDeployer.onDidDeploy(() => this.client?.onDidDeploy()),
+                this.uninstallationManager.onDidChangeUninstalledPlugins(currentUninstalled => {
+                    if (this.uninstalledPlugins) {
+                        const uninstalled = new Set(currentUninstalled);
+                        for (const previouslyUninstalled of this.uninstalledPlugins) {
+                            if (!uninstalled.has(previouslyUninstalled)) {
+                                this.uninstalledPlugins.delete(previouslyUninstalled);
+                            }
                         }
                     }
-                }
-                this.client?.onDidDeploy();
-            }),
-            Disposable.create(() => this.hostedPlugin.clientClosed()),
-        ]);
+                    this.client?.onDidDeploy();
+                }),
+                this.uninstallationManager.onDidChangeDisabledPlugins(currentlyDisabled => {
+                    if (this.disabledPlugins) {
+                        const disabled = new Set(currentlyDisabled);
+                        for (const previouslyUninstalled of this.disabledPlugins) {
+                            if (!disabled.has(previouslyUninstalled)) {
+                                this.disabledPlugins.delete(previouslyUninstalled);
+                            }
+                        }
+                    }
+                    this.client?.onDidDeploy();
+                }),
+                Disposable.create(() => this.hostedPlugin.clientClosed()),
+            ]);
+            this.initialized.resolve();
+        };
+        asyncInit();
     }
 
     protected getServerName(): string {
@@ -111,6 +129,7 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     }
 
     async getDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
+        await this.initialized.promise;
         const backendPlugins = (await this.deployerHandler.getDeployedBackendPlugins())
             .filter(this.backendPluginHostableFilter);
         if (backendPlugins.length > 0) {
@@ -126,7 +145,6 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         };
         addIds(await this.deployerHandler.getDeployedFrontendPluginIds());
         addIds(await this.deployerHandler.getDeployedBackendPluginIds());
-        addIds(await this.hostedPlugin.getExtraDeployedPluginIds());
         return Array.from(plugins);
     }
 
@@ -146,7 +164,11 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         if (knownVersion !== undefined && knownVersion !== versionAndId.version) {
             return false;
         }
-        if (this.ignoredPlugins.has(identifier)) {
+        if (this.uninstalledPlugins.has(identifier)) {
+            return false;
+        }
+
+        if (this.disabledPlugins.has(identifier)) {
             return false;
         }
         if (knownVersion === undefined) {
@@ -159,26 +181,18 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         return Promise.resolve(this.uninstallationManager.getUninstalledPluginIds());
     }
 
-    async getDeployedPlugins({ pluginIds }: GetDeployedPluginsParams): Promise<DeployedPlugin[]> {
+    getDisabledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return Promise.resolve(this.uninstallationManager.getDisabledPluginIds());
+    }
+
+    async getDeployedPlugins(pluginIds: PluginIdentifiers.VersionedId[]): Promise<DeployedPlugin[]> {
         if (!pluginIds.length) {
             return [];
         }
         const plugins: DeployedPlugin[] = [];
-        let extraDeployedPlugins: Map<string, DeployedPlugin> | undefined;
         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(PluginIdentifiers.componentsToVersionedId(extraDeployedPlugin.metadata.model), extraDeployedPlugin);
-                    }
-                }
-                plugin = extraDeployedPlugins.get(versionedId);
-            }
+            const plugin = this.deployerHandler.getDeployedPlugin(versionedId);
+
             if (plugin) {
                 plugins.push(plugin);
             }

package/src/main/browser/editors-and-documents-main.ts

@@ -16,6 +16,7 @@
 
 import { interfaces } from '@theia/core/shared/inversify';
 import * as monaco from '@theia/monaco-editor-core';
+import { type ILineChange } from '@theia/monaco-editor-core/esm/vs/editor/common/diff/legacyLinesDiffComputer';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import {
     MAIN_RPC_CONTEXT,
@@ -212,6 +213,11 @@ export class EditorsAndDocumentsMain implements Disposable {
         }
         return Promise.resolve();
     }
+
+    getDiffInformation(id: string): ILineChange[] {
+        const editor = this.getEditor(id);
+        return editor?.diffInformation || [];
+    }
 }
 
 class EditorAndDocumentStateComputer implements Disposable {

package/src/main/browser/menus/menus-contribution-handler.ts

@@ -121,7 +121,8 @@ export class MenusContributionPointHandler {
                         }
                     }
                 } catch (error) {
-                    console.warn(`Failed to register a menu item for plugin ${plugin.metadata.model.id} contributed to ${contributionPoint}`, item, error);
+                    console.warn(`Failed to register a menu item for plugin ${plugin.metadata.model.id} contributed to ${contributionPoint}`, item);
+                    console.debug(error);
                 }
             }
         }

package/src/main/browser/notebooks/renderers/cell-output-webview.tsx

@@ -43,6 +43,8 @@ import { NotebookCellModel } from '@theia/notebook/lib/browser/view-model/notebo
 import { CellOutput, NotebookCellsChangeType } from '@theia/notebook/lib/common';
 import { NotebookCellOutputModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-output-model';
 import { Deferred } from '@theia/core/lib/common/promise-util';
+import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
+import { NOTEBOOK_OUTPUT_FOCUSED } from '@theia/notebook/lib/browser/contributions/notebook-context-keys';
 
 export const AdditionalNotebookCellOutputCss = Symbol('AdditionalNotebookCellOutputCss');
 
@@ -228,6 +230,9 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
     @inject(NotebookOptionsService)
     protected readonly notebookOptionsService: NotebookOptionsService;
 
+    @inject(ContextKeyService)
+    protected readonly contextKeyService: ContextKeyService;
+
     // returns the output Height
     protected readonly onDidRenderOutputEmitter = new Emitter<OutputRenderEvent>();
     readonly onDidRenderOutput = this.onDidRenderOutputEmitter.event;
@@ -524,6 +529,12 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
                     this.notebook.setSelectedCell(selectedCell);
                 }
                 break;
+            case 'webviewFocusChanged':
+                if (message.focused) {
+                    window.getSelection()?.empty();
+                }
+                this.contextKeyService.setContext(NOTEBOOK_OUTPUT_FOCUSED, message.focused);
+                break;
             case 'cellHeightRequest':
                 const cellHeight = this.notebook.getCellByHandle(message.cellHandle)?.cellHeight ?? 0;
                 this.webviewWidget.sendMessage({

package/src/main/browser/notebooks/renderers/output-webview-internal.ts

@@ -801,11 +801,15 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
             theia.postMessage({ type: 'inputFocusChanged', focused: focus } as webviewCommunication.InputFocusChange);
         }
     };
-
     window.addEventListener('focusin', (event: FocusEvent) => focusChange(event, true));
-
     window.addEventListener('focusout', (event: FocusEvent) => focusChange(event, false));
 
+    const webviewFocuseChange = (focus: boolean) => {
+        theia.postMessage({ type: 'webviewFocusChanged', focused: focus } as webviewCommunication.WebviewFocusChange);
+    };
+    window.addEventListener('focus', () => webviewFocuseChange(true));
+    window.addEventListener('blur', () => webviewFocuseChange(false));
+
     new ResizeObserver(() => {
         theia.postMessage({
             type: 'bodyHeightChange',

package/src/main/browser/notebooks/renderers/webview-communication.ts

@@ -150,6 +150,11 @@ export interface CellOuputFocus {
     readonly cellHandle: number;
 }
 
+export interface WebviewFocusChange {
+    readonly type: 'webviewFocusChanged';
+    readonly focused: boolean;
+}
+
 export interface CellHeightRequest {
     readonly type: 'cellHeightRequest';
     readonly cellHandle: number;
@@ -167,6 +172,7 @@ export type FromWebviewMessage = WebviewInitialized
     | KernelMessage
     | InputFocusChange
     | CellOuputFocus
+    | WebviewFocusChange
     | CellHeightRequest
     | BodyHeightChange;
 

package/src/main/browser/text-editor-main.ts

@@ -16,6 +16,7 @@
 
 import * as monaco from '@theia/monaco-editor-core';
 import { StandaloneCodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
+import { type ILineChange } from '@theia/monaco-editor-core/esm/vs/editor/common/diff/legacyLinesDiffComputer';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 import {
@@ -34,6 +35,7 @@ import { Emitter, Event } from '@theia/core';
 import { TextEditorCursorStyle, cursorStyleToString } from '../../common/editor-options';
 import { TextEditorLineNumbersStyle, EndOfLine } from '../../plugin/types-impl';
 import { SimpleMonacoEditor } from '@theia/monaco/lib/browser/simple-monaco-editor';
+import { MonacoDiffEditor } from '@theia/monaco/lib/browser/monaco-diff-editor';
 import { EndOfLineSequence, ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
 import { EditorOption, RenderLineNumbersType } from '@theia/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
 
@@ -130,6 +132,13 @@ export class TextEditorMain implements Disposable {
         return this.onPropertiesChangedEmitter.event;
     }
 
+    get diffInformation(): ILineChange[] | undefined {
+        if (!(this.editor instanceof MonacoDiffEditor)) {
+            return [];
+        }
+        return this.editor.diffInformation;
+    }
+
     setSelections(selections: Selection[]): void {
         if (this.editor) {
             this.editor.getControl().setSelections(selections);

package/src/main/browser/text-editors-main.ts

@@ -47,6 +47,7 @@ import { ResourceEdit } from '@theia/monaco-editor-core/esm/vs/editor/browser/se
 import { IDecorationRenderOptions } from '@theia/monaco-editor-core/esm/vs/editor/common/editorCommon';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
+import { type ILineChange } from '@theia/monaco-editor-core/esm/vs/editor/common/diff/legacyLinesDiffComputer';
 import { ArrayUtils, URI } from '@theia/core';
 import { toNotebookWorspaceEdit } from './notebooks/notebooks-main';
 import { interfaces } from '@theia/core/shared/inversify';
@@ -231,4 +232,8 @@ export class TextEditorsMainImpl implements TextEditorsMain, Disposable {
         return this.editorsAndDocuments.saveAll(includeUntitled);
     }
 
+    $getDiffInformation(id: string): Promise<ILineChange[]> {
+        return Promise.resolve(this.editorsAndDocuments.getDiffInformation(id));
+    }
+
 }

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

@@ -141,6 +141,14 @@ export class PluginDeployerImpl implements PluginDeployer {
         await this.pluginDeployerHandler.uninstallPlugin(pluginId);
     }
 
+    enablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+        return this.pluginDeployerHandler.enablePlugin(pluginId);
+    }
+
+    disablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+        return this.pluginDeployerHandler.disablePlugin(pluginId);
+    }
+
     async undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         if (await this.pluginDeployerHandler.undeployPlugin(pluginId)) {
             this.onDidDeployEmitter.fire();

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

@@ -33,7 +33,7 @@ import { HttpPluginDeployerResolver } from './plugin-http-resolver';
 import { ConnectionHandler, RpcConnectionHandler, bindContributionProvider } from '@theia/core';
 import { PluginPathsService, pluginPathsServicePath } from '../common/plugin-paths-protocol';
 import { PluginPathsServiceImpl } from './paths/plugin-paths-service';
-import { PluginServerHandler } from './plugin-server-handler';
+import { PluginServerImpl } from './plugin-server-impl';
 import { PluginCliContribution } from './plugin-cli-contribution';
 import { PluginTheiaEnvironment } from '../common/plugin-theia-environment';
 import { PluginTheiaDeployerParticipant } from './plugin-theia-deployer-participant';
@@ -70,7 +70,7 @@ export function bindMainBackend(bind: interfaces.Bind, unbind: interfaces.Unbind
     bind(PluginDeployerFileHandler).to(PluginTheiaFileHandler).inSingletonScope();
     bind(PluginDeployerDirectoryHandler).to(PluginTheiaDirectoryHandler).inSingletonScope();
 
-    bind(PluginServer).to(PluginServerHandler).inSingletonScope();
+    bind(PluginServer).to(PluginServerImpl).inSingletonScope();
 
     bind(PluginsKeyValueStorage).toSelf().inSingletonScope();
 

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

@@ -17,7 +17,7 @@
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { Argv, Arguments } from '@theia/core/shared/yargs';
 import { CliContribution } from '@theia/core/lib/node/cli';
-import { HostedPluginDeployerHandler } from '../../hosted/node/hosted-plugin-deployer-handler';
+import { PluginDeployerHandlerImpl } from '../../hosted/node/plugin-deployer-handler-impl';
 import { PluginType } from '../../common';
 
 @injectable()
@@ -27,8 +27,8 @@ export class PluginMgmtCliContribution implements CliContribution {
     static SHOW_VERSIONS = '--show-versions';
     static SHOW_BUILTINS = '--show-builtins';
 
-    @inject(HostedPluginDeployerHandler)
-    protected deployerHandler: HostedPluginDeployerHandler;
+    @inject(PluginDeployerHandlerImpl)
+    protected deployerHandler: PluginDeployerHandlerImpl;
 
     configure(conf: Argv): void {
         conf.command([PluginMgmtCliContribution.LIST_PLUGINS, 'list-extensions'],

package/src/main/node/{plugin-server-handler.ts → plugin-server-impl.ts}

@@ -18,21 +18,31 @@ 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, PluginIdentifiers, PluginDeployOptions } from '../../common/plugin-protocol';
+import {
+    PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry, PluginIdentifiers,
+    PluginDeployOptions, PluginDeployerHandler
+} from '../../common/plugin-protocol';
 import { KeysToAnyValues, KeysToKeysToAnyValue } from '../../common/types';
+import { PluginUninstallationManager } from './plugin-uninstallation-manager';
 
 @injectable()
-export class PluginServerHandler implements PluginServer {
+export class PluginServerImpl implements PluginServer {
 
     @inject(PluginDeployer)
     protected readonly pluginDeployer: PluginDeployerImpl;
 
+    @inject(PluginDeployerHandler)
+    protected readonly pluginDeployerHandler: PluginDeployerHandler;
+
     @inject(PluginsKeyValueStorage)
     protected readonly pluginsKeyValueStorage: PluginsKeyValueStorage;
 
-    async deploy(pluginEntry: string, arg2?: PluginType | CancellationToken, options?: PluginDeployOptions): Promise<void> {
+    @inject(PluginUninstallationManager)
+    protected readonly uninstallationManager: PluginUninstallationManager;
+
+    async install(pluginEntry: string, arg2?: PluginType | CancellationToken, options?: PluginDeployOptions): Promise<void> {
         const type = typeof arg2 === 'number' ? arg2 as PluginType : undefined;
-        const successfulDeployments = await this.doDeploy({
+        const successfulDeployments = await this.doInstall({
             id: pluginEntry,
             type: type ?? PluginType.User
         }, options);
@@ -42,16 +52,32 @@ export class PluginServerHandler implements PluginServer {
         }
     }
 
-    protected doDeploy(pluginEntry: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
+    protected doInstall(pluginEntry: UnresolvedPluginEntry, options?: PluginDeployOptions): Promise<number> {
         return this.pluginDeployer.deploy(pluginEntry, options);
     }
 
+    getInstalledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return Promise.resolve(this.pluginDeployerHandler.getDeployedPluginIds());
+    }
+
+    getUninstalledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return Promise.resolve(this.uninstallationManager.getUninstalledPluginIds());
+    }
+
+    getDisabledPlugins(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return Promise.resolve(this.uninstallationManager.getDisabledPluginIds());
+    }
+
     uninstall(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
         return this.pluginDeployer.uninstall(pluginId);
     }
 
-    undeploy(pluginId: PluginIdentifiers.VersionedId): Promise<void> {
-        return this.pluginDeployer.undeploy(pluginId);
+    enablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+        return this.pluginDeployer.enablePlugin(pluginId);
+    }
+
+    disablePlugin(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+        return this.pluginDeployer.disablePlugin(pluginId);
     }
 
     setStorageValue(key: string, value: KeysToAnyValues, kind: PluginStorageKind): Promise<boolean> {

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

@@ -15,60 +15,118 @@
 // *****************************************************************************
 
 import { Emitter, Event } from '@theia/core';
-import { injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { PluginIdentifiers } from '../../common';
+import { SettingService } from '@theia/core/lib/node';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 @injectable()
 export class PluginUninstallationManager {
+    static DISABLED_PLUGINS = 'installedPlugins.disabledPlugins';
+
+    @inject(SettingService)
+    protected readonly settingService: SettingService;
+
     protected readonly onDidChangeUninstalledPluginsEmitter = new Emitter<readonly PluginIdentifiers.VersionedId[]>();
+    onDidChangeUninstalledPlugins: Event<readonly PluginIdentifiers.VersionedId[]> = this.onDidChangeUninstalledPluginsEmitter.event;
+
+    protected readonly onDidChangeDisabledPluginsEmitter = new Emitter<readonly PluginIdentifiers.VersionedId[]>();
+    onDidChangeDisabledPlugins: Event<readonly PluginIdentifiers.VersionedId[]> = this.onDidChangeDisabledPluginsEmitter.event;
 
-    get onDidChangeUninstalledPlugins(): Event<readonly PluginIdentifiers.VersionedId[]> {
-        return this.onDidChangeUninstalledPluginsEmitter.event;
+    protected uninstalledPlugins: Set<PluginIdentifiers.VersionedId> = new Set();
+    protected disabledPlugins: Set<PluginIdentifiers.VersionedId> = new Set();
+
+    protected readonly initialized = new Deferred<void>();
+
+    @postConstruct()
+    init(): void {
+        this.load().then(() => this.initialized.resolve());
     }
 
-    protected uninstalledPlugins: PluginIdentifiers.VersionedId[] = [];
+    protected async load(): Promise<void> {
+        try {
+            const disabled: PluginIdentifiers.VersionedId[] = JSON.parse(await this.settingService.get(PluginUninstallationManager.DISABLED_PLUGINS) || '[]');
+            disabled.forEach(id => this.disabledPlugins.add(id));
+        } catch (e) {
+            // settings may be corrupt; just carry on
+            console.warn(e);
+        }
+    }
 
-    protected fireDidChange(): void {
-        this.onDidChangeUninstalledPluginsEmitter.fire(Object.freeze(this.uninstalledPlugins.slice()));
+    protected async save(): Promise<void> {
+        await this.settingService.set(PluginUninstallationManager.DISABLED_PLUGINS, JSON.stringify(await this.getDisabledPluginIds()));
     }
 
-    markAsUninstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+    async markAsUninstalled(...pluginIds: PluginIdentifiers.VersionedId[]): Promise<boolean> {
         let didChange = false;
-        for (const id of pluginIds) { didChange = this.markOneAsUninstalled(id) || didChange; }
-        if (didChange) { this.fireDidChange(); }
+        for (const id of pluginIds) {
+            if (!this.uninstalledPlugins.has(id)) {
+                didChange = true;
+                this.uninstalledPlugins.add(id);
+            }
+        }
+        if (didChange) {
+            this.onDidChangeUninstalledPluginsEmitter.fire(this.getUninstalledPluginIds());
+        }
+        this.markAsEnabled(...pluginIds);
         return didChange;
     }
 
-    protected markOneAsUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
-        if (!this.uninstalledPlugins.includes(pluginId)) {
-            this.uninstalledPlugins.push(pluginId);
-            return true;
+    async markAsInstalled(...pluginIds: PluginIdentifiers.VersionedId[]): Promise<boolean> {
+        let didChange = false;
+        for (const id of pluginIds) {
+            didChange = this.uninstalledPlugins.delete(id) || didChange;
+        }
+        if (didChange) {
+            this.onDidChangeUninstalledPluginsEmitter.fire(this.getUninstalledPluginIds());
         }
-        return false;
+        return didChange;
     }
 
-    markAsInstalled(...pluginIds: PluginIdentifiers.VersionedId[]): boolean {
+    isUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
+        return this.uninstalledPlugins.has(pluginId);
+    }
+
+    getUninstalledPluginIds(): readonly PluginIdentifiers.VersionedId[] {
+        return [...this.uninstalledPlugins];
+    }
+
+    async markAsDisabled(...pluginIds: PluginIdentifiers.VersionedId[]): Promise<boolean> {
+        await this.initialized.promise;
         let didChange = false;
-        for (const id of pluginIds) { didChange = this.markOneAsInstalled(id) || didChange; }
-        if (didChange) { this.fireDidChange(); }
+        for (const id of pluginIds) {
+            if (!this.disabledPlugins.has(id)) {
+                this.disabledPlugins.add(id);
+                didChange = true;
+            }
+        }
+        if (didChange) {
+            await this.save();
+            this.onDidChangeDisabledPluginsEmitter.fire([...this.disabledPlugins]);
+        }
         return didChange;
     }
 
-    protected markOneAsInstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
-        let index: number;
+    async markAsEnabled(...pluginIds: PluginIdentifiers.VersionedId[]): Promise<boolean> {
+        await this.initialized.promise;
         let didChange = false;
-        while ((index = this.uninstalledPlugins.indexOf(pluginId)) !== -1) {
-            this.uninstalledPlugins.splice(index, 1);
-            didChange = true;
+        for (const id of pluginIds) {
+            didChange = this.disabledPlugins.delete(id) || didChange;
+        }
+        if (didChange) {
+            await this.save();
+            this.onDidChangeDisabledPluginsEmitter.fire([...this.disabledPlugins]);
         }
         return didChange;
     }
 
-    isUninstalled(pluginId: PluginIdentifiers.VersionedId): boolean {
-        return this.uninstalledPlugins.includes(pluginId);
+    async isDisabled(pluginId: PluginIdentifiers.VersionedId): Promise<boolean> {
+        await this.initialized.promise;
+        return this.disabledPlugins.has(pluginId);
     }
 
-    getUninstalledPluginIds(): readonly PluginIdentifiers.VersionedId[] {
-        return Object.freeze(this.uninstalledPlugins.slice());
+    async getDisabledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        await this.initialized.promise;
+        return [...this.disabledPlugins];
     }
 }

package/src/plugin/file-system-event-service-ext-impl.ts

@@ -163,8 +163,8 @@ export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServ
     // --- file events
 
     createFileSystemWatcher(globPattern: string | IRelativePattern, ignoreCreateEvents?: boolean,
-        ignoreChangeEvents?: boolean, ignoreDeleteEvents?: boolean, excludes?: string[]): vscode.FileSystemWatcher {
-        return new FileSystemWatcher(this._onFileSystemEvent.event, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents, excludes);
+        ignoreChangeEvents?: boolean, ignoreDeleteEvents?: boolean): vscode.FileSystemWatcher {
+        return new FileSystemWatcher(this._onFileSystemEvent.event, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents);
     }
 
     $onFileEvent(events: FileSystemEvents) {