@theia/vsx-registry 1.45.1 → 1.46.0-next.137

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

@@ -28,7 +28,7 @@ import { PreferenceInspectionScope, PreferenceService } from '@theia/core/lib/br
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { RecommendedExtensions } from './recommended-extensions/recommended-extensions-preference-contribution';
 import URI from '@theia/core/lib/common/uri';
-import { VSXExtensionRaw, VSXResponseError, VSXSearchOptions } from '@theia/ovsx-client/lib/ovsx-types';
+import { OVSXClient, VSXAllVersions, VSXExtensionRaw, VSXResponseError, VSXSearchEntry, VSXSearchOptions } from '@theia/ovsx-client/lib/ovsx-types';
 import { OVSXClientProvider } from '../common/ovsx-client-provider';
 import { RequestContext, RequestService } from '@theia/core/shared/@theia/request';
 import { OVSXApiFilter } from '@theia/ovsx-client';
@@ -113,6 +113,13 @@ export class VSXExtensionsModel {
         return this._recommended.values();
     }
 
+    setOnlyShowVerifiedExtensions(bool: boolean): void {
+        if (this.preferences.get('extensions.onlyShowVerifiedExtensions') !== bool) {
+            this.preferences.updateValue('extensions.onlyShowVerifiedExtensions', bool);
+        }
+        this.updateSearchResult();
+    }
+
     isInstalled(id: string): boolean {
         return this._installed.has(id);
     }
@@ -208,9 +215,8 @@ export class VSXExtensionsModel {
 
     protected doUpdateSearchResult(param: VSXSearchOptions, token: CancellationToken): Promise<void> {
         return this.doChange(async () => {
-            const searchResult = new Set<string>();
+            this._searchResult = new Set<string>();
             if (!param.query) {
-                this._searchResult = searchResult;
                 return;
             }
             const client = await this.clientProvider();
@@ -225,20 +231,55 @@ export class VSXExtensionsModel {
                 if (!allVersions) {
                     continue;
                 }
-                this.setExtension(id).update(Object.assign(data, {
-                    publisher: data.namespace,
-                    downloadUrl: data.files.download,
-                    iconUrl: data.files.icon,
-                    readmeUrl: data.files.readme,
-                    licenseUrl: data.files.license,
-                    version: allVersions.version
-                }));
-                searchResult.add(id);
+                if (this.preferences.get('extensions.onlyShowVerifiedExtensions')) {
+                    this.fetchVerifiedStatus(id, client, allVersions).then(verified => {
+                        this.doChange(() => {
+                            this.addExtensions(data, id, allVersions, !!verified);
+                            return Promise.resolve();
+                        });
+                    });
+                } else {
+                    this.addExtensions(data, id, allVersions);
+                    this.fetchVerifiedStatus(id, client, allVersions).then(verified => {
+                        this.doChange(() => {
+                            let extension = this.getExtension(id);
+                            extension = this.setExtension(id);
+                            extension.update(Object.assign({
+                                verified: verified
+                            }));
+                            return Promise.resolve();
+                        });
+                    });
+                }
             }
-            this._searchResult = searchResult;
         }, token);
     }
 
+    protected async fetchVerifiedStatus(id: string, client: OVSXClient, allVersions: VSXAllVersions): Promise<boolean | undefined> {
+        const res = await client.query({ extensionId: id, extensionVersion: allVersions.version, includeAllVersions: true });
+        let verified = res.extensions?.[0].verified;
+        if (!verified && res.extensions?.[0].publishedBy.loginName === 'open-vsx') {
+            verified = true;
+        }
+        return verified;
+    }
+
+    protected addExtensions(data: VSXSearchEntry, id: string, allVersions: VSXAllVersions, verified?: boolean): void {
+        if (!this.preferences.get('extensions.onlyShowVerifiedExtensions') || verified) {
+            const extension = this.setExtension(id);
+            extension.update(Object.assign(data, {
+                publisher: data.namespace,
+                downloadUrl: data.files.download,
+                iconUrl: data.files.icon,
+                readmeUrl: data.files.readme,
+                licenseUrl: data.files.license,
+                version: allVersions.version,
+                verified: verified
+            }));
+            this._searchResult.add(id);
+        }
+    }
+
     protected async updateInstalled(): Promise<void> {
         const prevInstalled = this._installed;
         return this.doChange(async () => {
@@ -331,6 +372,11 @@ export class VSXExtensionsModel {
             if (data.error) {
                 return this.onDidFailRefresh(id, data.error);
             }
+            if (!data.verified) {
+                if (data.publishedBy.loginName === 'open-vsx') {
+                    data.verified = true;
+                }
+            }
             extension = this.setExtension(id);
             extension.update(Object.assign(data, {
                 publisher: data.namespace,
@@ -338,7 +384,8 @@ export class VSXExtensionsModel {
                 iconUrl: data.files.icon,
                 readmeUrl: data.files.readme,
                 licenseUrl: data.files.license,
-                version: data.version
+                version: data.version,
+                verified: data.verified
             }));
             return extension;
         } catch (e) {

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

@@ -0,0 +1,58 @@
+// *****************************************************************************
+// Copyright (C) 2023 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { interfaces } from '@theia/core/shared/inversify';
+import {
+    createPreferenceProxy,
+    PreferenceProxy,
+    PreferenceService,
+    PreferenceSchema,
+    PreferenceContribution
+} from '@theia/core/lib/browser/preferences';
+import { nls } from '@theia/core';
+
+export const VsxExtensionsPreferenceSchema: PreferenceSchema = {
+    'type': 'object',
+    properties: {
+        'extensions.onlyShowVerifiedExtensions': {
+            type: 'boolean',
+            default: false,
+            description: nls.localize('theia/vsx-registry/onlyShowVerifiedExtensionsDescription', 'This allows the {0} to only show verified extensions.', 'Open VSX Registry')
+        },
+    }
+};
+
+export interface VsxExtensionsConfiguration {
+    'extensions.onlyShowVerifiedExtensions': boolean;
+}
+
+export const VsxExtensionsPreferenceContribution = Symbol('VsxExtensionsPreferenceContribution');
+export const VsxExtensionsPreferences = Symbol('VsxExtensionsPreferences');
+export type VsxExtensionsPreferences = PreferenceProxy<VsxExtensionsConfiguration>;
+
+export function createVsxExtensionsPreferences(preferences: PreferenceService, schema: PreferenceSchema = VsxExtensionsPreferenceSchema): VsxExtensionsPreferences {
+    return createPreferenceProxy(preferences, schema);
+}
+
+export function bindVsxExtensionsPreferences(bind: interfaces.Bind): void {
+    bind(VsxExtensionsPreferences).toDynamicValue(ctx => {
+        const preferences = ctx.container.get<PreferenceService>(PreferenceService);
+        const contribution = ctx.container.get<PreferenceContribution>(VsxExtensionsPreferenceContribution);
+        return createVsxExtensionsPreferences(preferences, contribution.schema);
+    }).inSingletonScope();
+    bind(VsxExtensionsPreferenceContribution).toConstantValue({ schema: VsxExtensionsPreferenceSchema });
+    bind(PreferenceContribution).toService(VsxExtensionsPreferenceContribution);
+}

package/src/browser/vsx-extensions-search-bar.tsx

@@ -16,37 +16,57 @@
 
 import * as React from '@theia/core/shared/react';
 import { injectable, postConstruct, inject } from '@theia/core/shared/inversify';
-import { ReactWidget, Message } from '@theia/core/lib/browser/widgets';
+import { ReactWidget, Message, codicon } from '@theia/core/lib/browser/widgets';
+import { PreferenceService } from '@theia/core/lib/browser';
 import { VSXExtensionsSearchModel } from './vsx-extensions-search-model';
+import { VSXExtensionsModel } from './vsx-extensions-model';
 import { nls } from '@theia/core/lib/common/nls';
 
 @injectable()
 export class VSXExtensionsSearchBar extends ReactWidget {
 
+    @inject(VSXExtensionsModel)
+    protected readonly extensionsModel: VSXExtensionsModel;
+
     @inject(VSXExtensionsSearchModel)
-    protected readonly model: VSXExtensionsSearchModel;
+    protected readonly searchModel: VSXExtensionsSearchModel;
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    protected input: HTMLInputElement | undefined;
+    protected onlyShowVerifiedExtensions: boolean | undefined;
 
     @postConstruct()
     protected init(): void {
+        this.onlyShowVerifiedExtensions = this.preferenceService.get('extensions.onlyShowVerifiedExtensions');
         this.id = 'vsx-extensions-search-bar';
         this.addClass('theia-vsx-extensions-search-bar');
-        this.model.onDidChangeQuery((query: string) => this.updateSearchTerm(query));
+        this.searchModel.onDidChangeQuery((query: string) => this.updateSearchTerm(query));
+        this.preferenceService.onPreferenceChanged(change => {
+            if (change.preferenceName === 'extensions.onlyShowVerifiedExtensions') {
+                this.extensionsModel.setOnlyShowVerifiedExtensions(!!change.newValue);
+                this.onlyShowVerifiedExtensions = change.newValue;
+                this.update();
+            }
+        });
     }
 
-    protected input: HTMLInputElement | undefined;
-
     protected render(): React.ReactNode {
-        return <input type='text'
-            ref={input => this.input = input || undefined}
-            defaultValue={this.model.query}
-            spellCheck={false}
-            className='theia-input'
-            placeholder={nls.localize('theia/vsx-registry/searchPlaceholder', 'Search Extensions in {0}', 'Open VSX Registry')}
-            onChange={this.updateQuery}>
-        </input>;
+        return <div className='vsx-search-container'>
+            <input type='text'
+                ref={input => this.input = input || undefined}
+                defaultValue={this.searchModel.query}
+                spellCheck={false}
+                className='theia-input'
+                placeholder={nls.localize('theia/vsx-registry/searchPlaceholder', 'Search Extensions in {0}', 'Open VSX Registry')}
+                onChange={this.updateQuery}>
+            </input>
+            {this.renderOptionContainer()}
+        </div>;
     }
 
-    protected updateQuery = (e: React.ChangeEvent<HTMLInputElement>) => this.model.query = e.target.value;
+    protected updateQuery = (e: React.ChangeEvent<HTMLInputElement>) => this.searchModel.query = e.target.value;
 
     protected updateSearchTerm(term: string): void {
         if (this.input) {
@@ -54,6 +74,24 @@ export class VSXExtensionsSearchBar extends ReactWidget {
         }
     }
 
+    protected renderOptionContainer(): React.ReactNode {
+        const showVerifiedExtensions = this.renderShowVerifiedExtensions();
+        return <div className='option-buttons'>{showVerifiedExtensions}</div>;
+    }
+
+    protected renderShowVerifiedExtensions(): React.ReactNode {
+        return <span
+            className={`${codicon('verified')} option action-label ${this.onlyShowVerifiedExtensions ? 'enabled' : ''}`}
+            title={nls.localize('theia/vsx-registry/onlyShowVerifiedExtensionsTitle', 'Only Show Verified Extensions')}
+            onClick={() => this.handleShowVerifiedExtensionsClick()}>
+        </span>;
+    }
+
+    protected handleShowVerifiedExtensionsClick(): void {
+        this.extensionsModel.setOnlyShowVerifiedExtensions(!this.onlyShowVerifiedExtensions);
+        this.update();
+    }
+
     protected override onActivateRequest(msg: Message): void {
         super.onActivateRequest(msg);
         if (this.input) {

package/src/browser/vsx-extensions-widget.tsx

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { injectable, interfaces, postConstruct, inject } from '@theia/core/shared/inversify';
-import { TreeModel, TreeNode } from '@theia/core/lib/browser';
+import { Message, TreeModel, TreeNode } from '@theia/core/lib/browser';
 import { SourceTreeWidget } from '@theia/core/lib/browser/source-tree';
 import { VSXExtensionsSource, VSXExtensionsSourceOptions } from './vsx-extensions-source';
 import { nls } from '@theia/core/lib/common/nls';
@@ -153,4 +153,13 @@ export class VSXExtensionsWidget extends SourceTreeWidget implements BadgeWidget
         }
         return super.renderTree(model);
     }
+
+    protected override onAfterShow(msg: Message): void {
+        super.onAfterShow(msg);
+        if (this.options.id === VSXExtensionsSourceOptions.INSTALLED) {
+            // This is needed when an Extension was installed outside of the extension view.
+            // E.g. using explorer context menu.
+            this.doUpdateRows();
+        }
+    }
 }

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

@@ -72,7 +72,7 @@ export class VSXLanguageQuickPickService extends LanguageQuickPickService {
                                     localizationContribution.localizedLanguageName ?? localizationContribution.languageName ?? localizationContribution.languageId),
                             });
                             try {
-                                const extensionUri = VSCodeExtensionUri.toUri(extension.extension.name, extension.extension.namespace).toString();
+                                const extensionUri = VSCodeExtensionUri.fromId(extension.extension.name, extension.extension.namespace).toString();
                                 await this.pluginServer.deploy(extensionUri);
                             } finally {
                                 progress.cancel();

package/src/browser/vsx-registry-frontend-module.ts

@@ -33,9 +33,12 @@ import { VSXExtensionsSourceOptions } from './vsx-extensions-source';
 import { VSXExtensionsSearchModel } from './vsx-extensions-search-model';
 import { bindExtensionPreferences } from './recommended-extensions/recommended-extensions-preference-contribution';
 import { bindPreferenceProviderOverrides } from './recommended-extensions/preference-provider-overrides';
+import { bindVsxExtensionsPreferences } from './vsx-extensions-preferences';
 import { VSXEnvironment, VSX_ENVIRONMENT_PATH } from '../common/vsx-environment';
 import { LanguageQuickPickService } from '@theia/core/lib/browser/i18n/language-quick-pick-service';
 import { VSXLanguageQuickPickService } from './vsx-language-quick-pick-service';
+import { VsxExtensionArgumentProcessor } from './vsx-extension-argument-processor';
+import { ArgumentProcessorContribution } from '@theia/plugin-ext/lib/main/browser/command-registry-main';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(VSXEnvironment)
@@ -103,4 +106,8 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bindExtensionPreferences(bind);
     bindPreferenceProviderOverrides(bind, unbind);
+    bindVsxExtensionsPreferences(bind);
+
+    bind(VsxExtensionArgumentProcessor).toSelf().inSingletonScope();
+    bind(ArgumentProcessorContribution).toService(VsxExtensionArgumentProcessor);
 });

package/src/node/vsx-cli-deployer-participant.ts

@@ -0,0 +1,46 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { PluginDeployerParticipant, PluginDeployerStartContext } from '@theia/plugin-ext';
+import { VsxCli } from './vsx-cli';
+import { VSXExtensionUri } from '../common';
+import * as fs from 'fs';
+import { FileUri } from '@theia/core/lib/node';
+import * as path from 'path';
+
+@injectable()
+export class VsxCliDeployerParticipant implements PluginDeployerParticipant {
+
+    @inject(VsxCli)
+    protected readonly vsxCli: VsxCli;
+
+    async onWillStart(context: PluginDeployerStartContext): Promise<void> {
+        const pluginUris = this.vsxCli.pluginsToInstall.map(async id => {
+            try {
+                const resolvedPath = path.resolve(id);
+                const stat = await fs.promises.stat(resolvedPath);
+                if (stat.isFile()) {
+                    return FileUri.create(resolvedPath).withScheme('local-file').toString();
+                }
+            } catch (e) {
+                // expected if file does not exist
+            }
+            return VSXExtensionUri.fromVersionedId(id).toString();
+        });
+        context.userEntries.push(...await Promise.all(pluginUris));
+    }
+}

package/src/node/vsx-cli.ts

@@ -24,9 +24,15 @@ import * as fs from 'fs';
 export class VsxCli implements CliContribution {
 
     ovsxRouterConfig: OVSXRouterConfig | undefined;
+    pluginsToInstall: string[] = [];
 
     configure(conf: Argv<{}>): void {
         conf.option('ovsx-router-config', { description: 'JSON configuration file for the OVSX router client', type: 'string' });
+        conf.option('install-plugin', {
+            alias: 'install-extension',
+            nargs: 1,
+            desc: 'Installs or updates a plugin. Argument is a path to the *.vsix file or a plugin id of the form "publisher.name[@version]"'
+        });
     }
 
     async setArguments(args: Record<string, unknown>): Promise<void> {
@@ -34,5 +40,12 @@ export class VsxCli implements CliContribution {
         if (typeof ovsxRouterConfig === 'string') {
             this.ovsxRouterConfig = JSON.parse(await fs.promises.readFile(ovsxRouterConfig, 'utf8'));
         }
+        let pluginsToInstall = args.installPlugin;
+        if (typeof pluginsToInstall === 'string') {
+            pluginsToInstall = [pluginsToInstall];
+        }
+        if (Array.isArray(pluginsToInstall)) {
+            this.pluginsToInstall = pluginsToInstall;
+        }
     }
 }

package/src/node/vsx-extension-resolver.ts

@@ -51,13 +51,14 @@ export class VSXExtensionResolver implements PluginDeployerResolver {
         }
         let extension: VSXExtensionRaw | undefined;
         const client = await this.clientProvider();
-        if (options) {
-            console.log(`[${id}]: trying to resolve version ${options.version}...`);
-            const { extensions } = await client.query({ extensionId: id, extensionVersion: options.version, includeAllVersions: true });
+        const version = options?.version || id.version;
+        if (version) {
+            console.log(`[${id}]: trying to resolve version ${version}...`);
+            const { extensions } = await client.query({ extensionId: id.id, extensionVersion: version, includeAllVersions: true });
             extension = extensions[0];
         } else {
             console.log(`[${id}]: trying to resolve latest version...`);
-            const { extensions } = await client.query({ extensionId: id, includeAllVersions: true });
+            const { extensions } = await client.query({ extensionId: id.id, includeAllVersions: true });
             extension = this.vsxApiFilter.getLatestCompatibleExtension(extensions);
         }
         if (!extension) {
@@ -66,12 +67,12 @@ export class VSXExtensionResolver implements PluginDeployerResolver {
         if (extension.error) {
             throw new Error(extension.error);
         }
-        const resolvedId = id + '-' + extension.version;
+        const resolvedId = id.id + '-' + extension.version;
         const downloadUrl = extension.files.download;
-        console.log(`[${id}]: resolved to '${resolvedId}'`);
+        console.log(`[${id.id}]: resolved to '${resolvedId}'`);
 
         if (!options?.ignoreOtherVersions) {
-            const existingVersion = this.hasSameOrNewerVersion(id, extension);
+            const existingVersion = this.hasSameOrNewerVersion(id.id, extension);
             if (existingVersion) {
                 console.log(`[${id}]: is already installed with the same or newer version '${existingVersion}'`);
                 return;

package/src/node/vsx-registry-backend-module.ts

@@ -17,11 +17,12 @@
 import { ConnectionHandler, JsonRpcConnectionHandler } from '@theia/core';
 import { CliContribution } from '@theia/core/lib/node';
 import { ContainerModule } from '@theia/core/shared/inversify';
-import { PluginDeployerResolver } from '@theia/plugin-ext/lib/common/plugin-protocol';
+import { PluginDeployerParticipant, PluginDeployerResolver } from '@theia/plugin-ext/lib/common/plugin-protocol';
 import { VSXEnvironment, VSX_ENVIRONMENT_PATH } from '../common/vsx-environment';
 import { VsxCli } from './vsx-cli';
 import { VSXEnvironmentImpl } from './vsx-environment-impl';
 import { VSXExtensionResolver } from './vsx-extension-resolver';
+import { VsxCliDeployerParticipant } from './vsx-cli-deployer-participant';
 
 export default new ContainerModule(bind => {
     bind(VSXEnvironment).to(VSXEnvironmentImpl).inSingletonScope();
@@ -32,4 +33,6 @@ export default new ContainerModule(bind => {
         .inSingletonScope();
     bind(VSXExtensionResolver).toSelf().inSingletonScope();
     bind(PluginDeployerResolver).toService(VSXExtensionResolver);
+    bind(VsxCliDeployerParticipant).toSelf().inSingletonScope();
+    bind(PluginDeployerParticipant).toService(VsxCliDeployerParticipant);
 });