@theia/vsx-registry 1.60.2 → 1.61.0

package/src/browser/vsx-extension.tsx

@@ -21,7 +21,7 @@ import URI from '@theia/core/lib/common/uri';
 import { TreeElement, TreeElementNode } from '@theia/core/lib/browser/source-tree';
 import { OpenerService, open, OpenerOptions } from '@theia/core/lib/browser/opener-service';
 import { HostedPluginSupport } from '@theia/plugin-ext/lib/hosted/browser/hosted-plugin';
-import { PluginServer, DeployedPlugin, PluginType, PluginIdentifiers, PluginDeployOptions } from '@theia/plugin-ext/lib/common/plugin-protocol';
+import { PluginServer, DeployedPlugin, PluginIdentifiers, PluginDeployOptions } from '@theia/plugin-ext/lib/common/plugin-protocol';
 import { VSCodeExtensionUri } from '@theia/plugin-ext-vscode/lib/common/plugin-vscode-uri';
 import { ProgressService } from '@theia/core/lib/common/progress-service';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';
@@ -32,13 +32,16 @@ import { codicon, ConfirmDialog, ContextMenuRenderer, HoverService, TreeWidget }
 import { VSXExtensionNamespaceAccess, VSXUser } from '@theia/ovsx-client/lib/ovsx-types';
 import { WindowService } from '@theia/core/lib/browser/window/window-service';
 import { MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering';
+import { VSXExtensionsModel } from './vsx-extensions-model';
 
 export const EXTENSIONS_CONTEXT_MENU: MenuPath = ['extensions_context_menu'];
 
 export namespace VSXExtensionsContextMenu {
     export const INSTALL = [...EXTENSIONS_CONTEXT_MENU, '1_install'];
-    export const COPY = [...EXTENSIONS_CONTEXT_MENU, '2_copy'];
-    export const CONTRIBUTION = [...EXTENSIONS_CONTEXT_MENU, '3_contribution'];
+    export const DISABLE = [...EXTENSIONS_CONTEXT_MENU, '2_disable'];
+    export const ENABLE = [...EXTENSIONS_CONTEXT_MENU, '2_enable'];
+    export const COPY = [...EXTENSIONS_CONTEXT_MENU, '3_copy'];
+    export const CONTRIBUTION = [...EXTENSIONS_CONTEXT_MENU, '4_contribution'];
 }
 
 @injectable()
@@ -86,6 +89,8 @@ export class VSXExtensionData {
 @injectable()
 export class VSXExtensionOptions {
     readonly id: string;
+    readonly version?: string;
+    readonly model: VSXExtensionsModel;
 }
 
 export const VSXExtensionFactory = Symbol('VSXExtensionFactory');
@@ -153,8 +158,16 @@ export class VSXExtension implements VSXExtensionData, TreeElement {
         return this.options.id;
     }
 
+    get installedVersion(): string | undefined {
+        return this.plugin?.metadata.model.version || this.options.version;
+    }
+
+    get model(): VSXExtensionsModel {
+        return this.options.model;
+    }
+
     get visible(): boolean {
-        return !!this.name;
+        return true;
     }
 
     get plugin(): DeployedPlugin | undefined {
@@ -162,11 +175,23 @@ export class VSXExtension implements VSXExtensionData, TreeElement {
     }
 
     get installed(): boolean {
-        return !!this.plugin;
+        return this.model.isInstalled(this.id);
+    }
+
+    get uninstalled(): boolean {
+        return this.model.isUninstalled(this.id);
+    }
+
+    get deployed(): boolean {
+        return this.model.isDeployed(this.id);
+    }
+
+    get disabled(): boolean {
+        return this.model.isDisabled(this.id);
     }
 
     get builtin(): boolean {
-        return this.plugin?.type === PluginType.System;
+        return this.model.isBuiltIn(this.id);
     }
 
     update(data: Partial<VSXExtensionData>): void {
@@ -298,9 +323,23 @@ export class VSXExtension implements VSXExtensionData, TreeElement {
         return md;
     }
 
-    protected _busy = 0;
-    get busy(): boolean {
-        return !!this._busy;
+    protected _currentTaskName: string | undefined;
+    get currentTask(): string | undefined {
+        return this._currentTaskName;
+    }
+    protected _currentTask: Promise<void> | undefined;
+
+    protected runTask(name: string, task: () => Promise<void>): Promise<void> {
+        if (this._currentTask) {
+            return Promise.reject('busy');
+        }
+        this._currentTaskName = name;
+        this._currentTask = task();
+        this._currentTask.finally(() => {
+            this._currentTask = undefined;
+            this._currentTaskName = undefined;
+        });
+        return this._currentTask;
     }
 
     async install(options?: PluginDeployOptions): Promise<void> {
@@ -310,39 +349,56 @@ export class VSXExtension implements VSXExtensionData, TreeElement {
                 msg: nls.localize('theia/vsx-registry/confirmDialogMessage', 'The extension "{0}" is unverified and might pose a security risk.', this.displayName)
             }).open();
             if (choice) {
-                this.doInstall(options);
+                await this.doInstall(options);
             }
         } else {
-            this.doInstall(options);
+            await this.doInstall(options);
         }
     }
 
     async uninstall(): Promise<void> {
-        this._busy++;
-        try {
-            const { plugin } = this;
-            if (plugin) {
-                await this.progressService.withProgress(
+        const { id, installedVersion } = this;
+        if (id && installedVersion) {
+            await this.runTask(nls.localizeByDefault('Uninstalling'),
+                async () => await this.progressService.withProgress(
                     nls.localizeByDefault('Uninstalling {0}...', this.id), 'extensions',
-                    () => this.pluginServer.uninstall(PluginIdentifiers.componentsToVersionedId(plugin.metadata.model))
+                    () => this.pluginServer.uninstall(PluginIdentifiers.idAndVersionToVersionedId({ id: (id as PluginIdentifiers.UnversionedId), version: installedVersion }))
+                )
+            );
+        }
+    }
+
+    async disable(): Promise<void> {
+        const { id, installedVersion } = this;
+        if (id && installedVersion) {
+            await this.runTask(nls.localize('vsx.disabling', 'Disabling'), async () => {
+                await this.progressService.withProgress(
+                    nls.localize('vsx.disabling.extensions', 'Disabling {0}...', this.id), 'extensions',
+                    () => this.pluginServer.disablePlugin(PluginIdentifiers.idAndVersionToVersionedId({ id: (id as PluginIdentifiers.UnversionedId), version: installedVersion }))
                 );
-            }
-        } finally {
-            this._busy--;
+            });
         }
     }
 
-    protected async doInstall(options?: PluginDeployOptions): Promise<void> {
-        this._busy++;
-        try {
-            await this.progressService.withProgress(nls.localizeByDefault("Installing extension '{0}' v{1}...", this.id, this.version ?? 0), 'extensions', () =>
-                this.pluginServer.deploy(this.uri.toString(), undefined, options)
-            );
-        } finally {
-            this._busy--;
+    async enable(): Promise<void> {
+        const { id, installedVersion } = this;
+        if (id && installedVersion) {
+            await this.runTask(nls.localize('vsx.enabling', 'Enabling'), async () => {
+                await this.progressService.withProgress(
+                    nls.localize('vsx.enabling.extension', 'Enabling {0}...', this.id), 'extensions',
+                    () => this.pluginServer.enablePlugin(PluginIdentifiers.idAndVersionToVersionedId({ id: (id as PluginIdentifiers.UnversionedId), version: installedVersion }))
+                );
+            });
         }
     }
 
+    protected async doInstall(options?: PluginDeployOptions): Promise<void> {
+        await this.runTask(nls.localizeByDefault('Installing'),
+            () => this.progressService.withProgress(nls.localizeByDefault("Installing extension '{0}' v{1}...", this.id, this.version ?? 0), 'extensions', () =>
+                this.pluginServer.install(this.uri.toString(), undefined, options)
+            ));
+    }
+
     handleContextMenu(e: React.MouseEvent<HTMLElement, MouseEvent>): void {
         e.preventDefault();
         this.contextMenuRenderer.render({
@@ -435,32 +491,24 @@ export abstract class AbstractVSXExtensionComponent<Props extends AbstractVSXExt
     };
 
     protected renderAction(host?: TreeWidget): React.ReactNode {
-        const { builtin, busy, plugin } = this.props.extension;
+        const { builtin, currentTask, disabled, uninstalled, installed, deployed } = this.props.extension;
         const isFocused = (host?.model.getFocusedNode() as TreeElementNode)?.element === this.props.extension;
         const tabIndex = (!host || isFocused) ? 0 : undefined;
-        const installed = !!plugin;
-        const outOfSynch = plugin?.metadata.outOfSync;
-        if (builtin) {
-            return <div className="codicon codicon-settings-gear action" tabIndex={tabIndex} onClick={this.manage}></div>;
+        const outOfSync = installed && (deployed ? (disabled || uninstalled) : !(disabled || uninstalled));
+        if (currentTask) {
+            return <button className="theia-button action prominent theia-mod-disabled">{currentTask}</button>;
         }
-        if (busy) {
-            if (installed) {
-                return <button className="theia-button action theia-mod-disabled">{nls.localizeByDefault('Uninstalling')}</button>;
+        return <div>
+            {
+                outOfSync && <button className="theia-button action" onClick={this.reloadWindow}>{nls.localizeByDefault('Reload Window')}</button>
             }
-            return <button className="theia-button action prominent theia-mod-disabled">{nls.localizeByDefault('Installing')}</button>;
-        }
-        if (installed) {
-            return <div>
-                {
-                    outOfSynch
-                        ? <button className="theia-button action" onClick={this.reloadWindow}>{nls.localizeByDefault('Reload Window')}</button>
-                        : <button className="theia-button action" onClick={this.uninstall}>{nls.localizeByDefault('Uninstall')}</button>
-                }
-
-                <div className="codicon codicon-settings-gear action" onClick={this.manage}></div>
-            </div>;
-        }
-        return <button className="theia-button prominent action" onClick={this.install}>{nls.localizeByDefault('Install')}</button>;
+            {
+                !builtin && ((installed && !uninstalled) ?
+                    <button className="theia-button action" onClick={this.uninstall}>{nls.localizeByDefault('Uninstall')}</button> :
+                    <button className="theia-button prominent action" onClick={this.install}>{nls.localizeByDefault('Install')}</button>)
+            }
+            <div className="codicon codicon-settings-gear action" tabIndex={tabIndex} onClick={this.manage}></div>
+        </div>;
     }
 
 }
@@ -486,7 +534,7 @@ export namespace VSXExtensionComponent {
 
 export class VSXExtensionComponent<Props extends VSXExtensionComponent.Props = VSXExtensionComponent.Props> extends AbstractVSXExtensionComponent<Props> {
     override render(): React.ReactNode {
-        const { iconUrl, publisher, displayName, description, version, downloadCount, averageRating, tooltip, verified } = this.props.extension;
+        const { iconUrl, publisher, displayName, description, version, downloadCount, averageRating, tooltip, verified, disabled } = this.props.extension;
 
         return <div
             className='theia-vsx-extension noselect'
@@ -509,7 +557,9 @@ export class VSXExtensionComponent<Props extends VSXExtensionComponent.Props = V
             <div className='theia-vsx-extension-content'>
                 <div className='title'>
                     <div className='noWrapInfo'>
-                        <span className='name'>{displayName}</span> <span className='version'>{VSXExtension.formatVersion(version)}</span>
+                        <span className='name'>{displayName}</span>&nbsp;
+                        <span className='version'>{VSXExtension.formatVersion(version)}&nbsp;
+                        </span>{disabled && <span className='disabled'>({nls.localizeByDefault('disabled')})</span>}
                     </div>
                     <div className='stat'>
                         {!!downloadCount && <span className='download-count'><i className={codicon('cloud-download')} />{downloadCompactFormatter.format(downloadCount)}</span>}
@@ -517,6 +567,7 @@ export class VSXExtensionComponent<Props extends VSXExtensionComponent.Props = V
                     </div>
                 </div>
                 <div className='noWrapInfo theia-vsx-extension-description'>{description}</div>
+
                 <div className='theia-vsx-extension-action-bar'>
                     <div className='theia-vsx-extension-publisher-container'>
                         {verified === true ? (

package/src/browser/vsx-extensions-contribution.ts

@@ -114,6 +114,18 @@ export class VSXExtensionsContribution extends AbstractViewContribution<VSXExten
             execute: async (extension: VSXExtension) => this.installAnotherVersion(extension),
         });
 
+        commands.registerCommand(VSXExtensionsCommands.DISABLE, {
+            isVisible: (extension: VSXExtension) => extension.installed && !extension.disabled,
+            isEnabled: (extension: VSXExtension) => extension.installed && !extension.disabled,
+            execute: async (extension: VSXExtension) => extension.disable(),
+        });
+
+        commands.registerCommand(VSXExtensionsCommands.ENABLE, {
+            isVisible: (extension: VSXExtension) => extension.installed && extension.disabled,
+            isEnabled: (extension: VSXExtension) => extension.installed && extension.disabled,
+            execute: async (extension: VSXExtension) => extension.enable(),
+        });
+
         commands.registerCommand(VSXExtensionsCommands.COPY, {
             execute: (extension: VSXExtension) => this.copy(extension)
         });
@@ -152,6 +164,15 @@ export class VSXExtensionsContribution extends AbstractViewContribution<VSXExten
             label: nls.localizeByDefault('Copy Extension ID'),
             order: '1'
         });
+        menus.registerMenuAction(VSXExtensionsContextMenu.DISABLE, {
+            commandId: VSXExtensionsCommands.DISABLE.id,
+            label: nls.localizeByDefault('Disable')
+        });
+
+        menus.registerMenuAction(VSXExtensionsContextMenu.ENABLE, {
+            commandId: VSXExtensionsCommands.ENABLE.id,
+            label: nls.localizeByDefault('Enable')
+        });
         menus.registerMenuAction(VSXExtensionsContextMenu.INSTALL, {
             commandId: VSXExtensionsCommands.INSTALL_ANOTHER_VERSION.id,
             label: nls.localizeByDefault('Install Specific Version...'),

package/src/browser/vsx-extensions-model.ts

@@ -34,19 +34,24 @@ import { RequestContext, RequestService } from '@theia/core/shared/@theia/reques
 import { OVSXApiFilterProvider } from '@theia/ovsx-client';
 import { ApplicationServer } from '@theia/core/lib/common/application-protocol';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { HostedPluginServer, PluginIdentifiers, PluginType } from '@theia/plugin-ext';
+import { HostedPluginWatcher } from '@theia/plugin-ext/lib/hosted/browser/hosted-plugin-watcher';
 
 @injectable()
 export class VSXExtensionsModel {
-
     protected initialized: Promise<void>;
     /**
      * Single source for all extensions
      */
     protected readonly extensions = new Map<string, VSXExtension>();
     protected readonly onDidChangeEmitter = new Emitter<void>();
-    protected _installed = new Set<string>();
+    protected disabled = new Set<PluginIdentifiers.UnversionedId>();
+    protected uninstalled = new Set<PluginIdentifiers.UnversionedId>();
+    protected deployed = new Set<PluginIdentifiers.UnversionedId>();
+    protected _installed = new Set<PluginIdentifiers.UnversionedId>();
     protected _recommended = new Set<string>();
     protected _searchResult = new Set<string>();
+    protected builtins = new Set<PluginIdentifiers.UnversionedId>();
     protected _searchError?: string;
 
     protected searchCancellationTokenSource = new CancellationTokenSource();
@@ -61,6 +66,12 @@ export class VSXExtensionsModel {
     @inject(HostedPluginSupport)
     protected readonly pluginSupport: HostedPluginSupport;
 
+    @inject(HostedPluginWatcher)
+    protected pluginWatcher: HostedPluginWatcher;
+
+    @inject(HostedPluginServer)
+    protected readonly pluginServer: HostedPluginServer;
+
     @inject(VSXExtensionFactory)
     protected readonly extensionFactory: VSXExtensionFactory;
 
@@ -128,8 +139,24 @@ export class VSXExtensionsModel {
         this.updateSearchResult();
     }
 
+    isBuiltIn(id: string): boolean {
+        return this.builtins.has(id as PluginIdentifiers.UnversionedId);
+    }
+
     isInstalled(id: string): boolean {
-        return this._installed.has(id);
+        return this._installed.has(id as PluginIdentifiers.UnversionedId);
+    }
+
+    isUninstalled(id: string): boolean {
+        return this.uninstalled.has(id as PluginIdentifiers.UnversionedId);
+    }
+
+    isDeployed(id: string): boolean {
+        return this.deployed.has(id as PluginIdentifiers.UnversionedId);
+    }
+
+    isDisabled(id: string): boolean {
+        return this.disabled.has(id as PluginIdentifiers.UnversionedId);
     }
 
     getExtension(id: string): VSXExtension | undefined {
@@ -187,12 +214,15 @@ export class VSXExtensionsModel {
 
     protected async initInstalled(): Promise<void> {
         await this.pluginSupport.willStart;
-        this.pluginSupport.onDidChangePlugins(() => this.updateInstalled());
         try {
             await this.updateInstalled();
         } catch (e) {
             console.error(e);
         }
+
+        this.pluginWatcher.onDidDeploy(() => {
+            this.updateInstalled();
+        });
     }
 
     protected async initSearchResult(): Promise<void> {
@@ -223,10 +253,10 @@ export class VSXExtensionsModel {
         return this.searchCancellationTokenSource = new CancellationTokenSource();
     }
 
-    protected setExtension(id: string): VSXExtension {
+    protected setExtension(id: string, version?: string): VSXExtension {
         let extension = this.extensions.get(id);
         if (!extension) {
-            extension = this.extensionFactory({ id });
+            extension = this.extensionFactory({ id, version, model: this });
             this.extensions.set(id, extension);
         }
         return extension;
@@ -328,19 +358,41 @@ export class VSXExtensionsModel {
     }
 
     protected async updateInstalled(): Promise<void> {
+        const [deployed, uninstalled, disabled] = await Promise.all(
+            [this.pluginServer.getDeployedPluginIds(), this.pluginServer.getUninstalledPluginIds(), this.pluginServer.getDisabledPluginIds()]);
+
+        this.uninstalled = new Set();
+        uninstalled.forEach(id => this.uninstalled.add(PluginIdentifiers.unversionedFromVersioned(id)));
+        this.disabled = new Set();
+        disabled.forEach(id => this.disabled.add(PluginIdentifiers.unversionedFromVersioned(id)));
+        this.deployed = new Set();
+        deployed.forEach(id => this.deployed.add(PluginIdentifiers.unversionedFromVersioned(id)));
+
         const prevInstalled = this._installed;
+        const installedVersioned = new Set<PluginIdentifiers.VersionedId>();
         return this.doChange(async () => {
-            const plugins = this.pluginSupport.plugins;
-            const currInstalled = new Set<string>();
+            const currInstalled = new Set<PluginIdentifiers.UnversionedId>();
             const refreshing = [];
-            for (const plugin of plugins) {
-                if (plugin.model.engine.type === 'vscode') {
-                    const version = plugin.model.version;
-                    const id = plugin.model.id;
-                    this._installed.delete(id);
-                    const extension = this.setExtension(id);
-                    currInstalled.add(extension.id);
-                    refreshing.push(this.refresh(id, version));
+            for (const versionedId of deployed) {
+                installedVersioned.add(versionedId);
+                const idAndVersion = PluginIdentifiers.idAndVersionFromVersionedId(versionedId);
+                if (idAndVersion) {
+                    this._installed.delete(idAndVersion.id);
+                    this.setExtension(idAndVersion.id, idAndVersion.version);
+                    currInstalled.add(idAndVersion.id);
+                    refreshing.push(this.refresh(idAndVersion.id, idAndVersion.version));
+                }
+            }
+            for (const versionedId of disabled) {
+                const idAndVersion = PluginIdentifiers.idAndVersionFromVersionedId(versionedId);
+                installedVersioned.add(versionedId);
+                if (idAndVersion && !this.isUninstalled(idAndVersion.id)) {
+                    if (!currInstalled.has(idAndVersion.id)) {
+                        this._installed.delete(idAndVersion.id);
+                        this.setExtension(idAndVersion.id, idAndVersion.version);
+                        currInstalled.add(idAndVersion.id);
+                        refreshing.push(this.refresh(idAndVersion.id, idAndVersion.version));
+                    }
                 }
             }
             for (const id of this._installed) {
@@ -348,10 +400,33 @@ export class VSXExtensionsModel {
                 if (!extension) { continue; }
                 refreshing.push(this.refresh(id, extension.version));
             }
+            await Promise.all(refreshing);
             const installed = new Set([...prevInstalled, ...currInstalled]);
             const installedSorted = Array.from(installed).sort((a, b) => this.compareExtensions(a, b));
             this._installed = new Set(installedSorted.values());
-            await Promise.all(refreshing);
+
+            const missingIds = new Set<PluginIdentifiers.VersionedId>();
+            for (const id of installedVersioned) {
+                const unversionedId = PluginIdentifiers.unversionedFromVersioned(id);
+                const plugin = this.pluginSupport.getPlugin(unversionedId);
+                if (plugin) {
+                    if (plugin.type === PluginType.System) {
+                        this.builtins.add(unversionedId);
+                    } else {
+                        this.builtins.delete(unversionedId);
+                    }
+                } else {
+                    missingIds.add(id);
+                }
+            }
+            const missing = await this.pluginServer.getDeployedPlugins([...missingIds.values()]);
+            for (const plugin of missing) {
+                if (plugin.type === PluginType.System) {
+                    this.builtins.add(PluginIdentifiers.componentsToUnversionedId(plugin.metadata.model));
+                } else {
+                    this.builtins.delete(PluginIdentifiers.componentsToUnversionedId(plugin.metadata.model));
+                }
+            }
         });
     }
 
@@ -362,7 +437,7 @@ export class VSXExtensionsModel {
 
             const updateRecommendationsForScope = (scope: PreferenceInspectionScope, root?: URI) => {
                 const { recommendations, unwantedRecommendations } = this.getRecommendationsForScope(scope, root);
-                recommendations.forEach(recommendation => allRecommendations.add(recommendation));
+                recommendations.forEach(recommendation => allRecommendations.add(recommendation.toLowerCase()));
                 unwantedRecommendations.forEach(unwantedRecommendation => allUnwantedRecommendations.add(unwantedRecommendation));
             };
 
@@ -449,15 +524,12 @@ export class VSXExtensionsModel {
      * @param extension the extension to refresh.
      */
     protected shouldRefresh(extension?: VSXExtension): boolean {
-        if (extension === undefined) {
-            return true;
-        }
-        return !extension.builtin;
+        return extension === undefined || extension.plugin === undefined;
     }
 
     protected onDidFailRefresh(id: string, error: unknown): VSXExtension | undefined {
         const cached = this.getExtension(id);
-        if (cached && cached.installed) {
+        if (cached && cached.deployed) {
             return cached;
         }
         console.error(`[${id}]: failed to refresh, reason:`, error);

package/src/browser/vsx-language-quick-pick-service.ts

@@ -71,7 +71,7 @@ export class VSXLanguageQuickPickService extends LanguageQuickPickService {
                                 });
                                 try {
                                     const extensionUri = VSCodeExtensionUri.fromId(`${extension.extension.namespace}.${extension.extension.name}`).toString();
-                                    await this.pluginServer.deploy(extensionUri);
+                                    await this.pluginServer.install(extensionUri);
                                 } finally {
                                     progress.cancel();
                                 }