@codingame/monaco-vscode-extension-gallery-service-override 3.2.2 → 4.0.0

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagementService.js

@@ -1,9 +1,10 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Event, EventMultiplexer } from 'vscode/vscode/vs/base/common/event';
+import { Emitter, Event, EventMultiplexer } from 'vscode/vscode/vs/base/common/event';
 import { ExtensionManagementErrorCode, EXTENSION_INSTALL_SYNC_CONTEXT, ExtensionManagementError, IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
-import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { extensionsConfigurationNodeBase, IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
 import { isLanguagePackExtension, getWorkspaceSupportTypeMessage } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { areSameExtensions, computeTargetPlatform } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
@@ -11,24 +12,32 @@ import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IDownloadService } from 'vscode/vscode/vs/platform/download/common/download';
-import { flatten } from 'vscode/vscode/vs/base/common/arrays';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import Severity from 'vscode/vscode/vs/base/common/severity';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 import { IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { Promises } from 'vscode/vscode/vs/base/common/async';
 import { IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { isUndefined } from 'vscode/vscode/vs/base/common/types';
+import { isString, isUndefined } from 'vscode/vscode/vs/base/common/types';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { getErrorMessage, CancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { IExtensionsScannerService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionsScannerService';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
+var WorkspaceExtensionsManagementService_1;
 let ExtensionManagementService = class ExtensionManagementService extends Disposable {
-    constructor(extensionManagementServerService, extensionGalleryService, userDataProfileService, configurationService, productService, downloadService, userDataSyncEnablementService, dialogService, workspaceTrustRequestService, extensionManifestPropertiesService, fileService, logService, instantiationService) {
+    constructor(extensionManagementServerService, extensionGalleryService, userDataProfileService, configurationService, productService, downloadService, userDataSyncEnablementService, dialogService, workspaceTrustRequestService, extensionManifestPropertiesService, fileService, logService, instantiationService, extensionsScannerService, telemetryService) {
         super();
         this.extensionManagementServerService = extensionManagementServerService;
         this.extensionGalleryService = extensionGalleryService;
@@ -43,7 +52,38 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
         this.fileService = fileService;
         this.logService = logService;
         this.instantiationService = instantiationService;
+        this.extensionsScannerService = extensionsScannerService;
+        this.telemetryService = telemetryService;
+        this._onInstallExtension = this._register(( new Emitter()));
+        this._onDidInstallExtensions = this._register(( new Emitter()));
+        this._onUninstallExtension = this._register(( new Emitter()));
+        this._onDidUninstallExtension = this._register(( new Emitter()));
         this.servers = [];
+        if (productService.quality !== 'stable') {
+            ( Registry.as(Extensions.Configuration))
+                .registerConfiguration({
+                ...extensionsConfigurationNodeBase,
+                properties: {
+                    'extensions.experimental.supportWorkspaceExtensions': {
+                        type: 'boolean',
+                        description: ( localizeWithPath(
+                            'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                            'extensions.experimental.supportWorkspaceExtensions',
+                            "Enables support for workspace specific local extensions."
+                        )),
+                        default: false,
+                        scope: 1
+                    }
+                }
+            });
+        }
+        if (this.productService.quality !== 'stable' && this.configurationService.getValue('extensions.experimental.supportWorkspaceExtensions') === true) {
+            this.workspaceExtensionManagementService = this._register(this.instantiationService.createInstance(WorkspaceExtensionsManagementService));
+            this.onDidEnableExtensions = this.workspaceExtensionManagementService.onDidChangeInvalidExtensions;
+        }
+        else {
+            this.onDidEnableExtensions = Event.None;
+        }
         if (this.extensionManagementServerService.localExtensionManagementServer) {
             this.servers.push(this.extensionManagementServerService.localExtensionManagementServer);
         }
@@ -53,32 +93,62 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
         if (this.extensionManagementServerService.webExtensionManagementServer) {
             this.servers.push(this.extensionManagementServerService.webExtensionManagementServer);
         }
-        this.onInstallExtension = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
-            server.extensionManagementService.onInstallExtension,
-            e => ({ ...e, server })
-        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
-        this.onDidInstallExtensions = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(server.extensionManagementService.onDidInstallExtensions)); return emitter; }, this._register(( new EventMultiplexer())))).event;
-        this.onUninstallExtension = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
-            server.extensionManagementService.onUninstallExtension,
-            e => ({ ...e, server })
-        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
-        this.onDidUninstallExtension = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
-            server.extensionManagementService.onDidUninstallExtension,
-            e => ({ ...e, server })
-        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
-        this.onDidUpdateExtensionMetadata = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(server.extensionManagementService.onDidUpdateExtensionMetadata)); return emitter; }, this._register(( new EventMultiplexer())))).event;
-        this.onDidChangeProfile = this._register(this.servers.reduce((emitter, server) => { this._register(emitter.add(( Event.map(
-            server.extensionManagementService.onDidChangeProfile,
-            e => ({ ...e, server })
-        )))); return emitter; }, this._register(( new EventMultiplexer())))).event;
-    }
-    async getInstalled(type, profileLocation) {
-        const result = await Promise.all(( this.servers.map(
-            ({ extensionManagementService }) => extensionManagementService.getInstalled(type, profileLocation)
-        )));
-        return flatten(result);
+        const onInstallExtensionEventMultiplexer = this._register(( new EventMultiplexer()));
+        this._register(onInstallExtensionEventMultiplexer.add(this._onInstallExtension.event));
+        this.onInstallExtension = onInstallExtensionEventMultiplexer.event;
+        const onDidInstallExtensionsEventMultiplexer = this._register(( new EventMultiplexer()));
+        this._register(onDidInstallExtensionsEventMultiplexer.add(this._onDidInstallExtensions.event));
+        this.onDidInstallExtensions = onDidInstallExtensionsEventMultiplexer.event;
+        const onUninstallExtensionEventMultiplexer = this._register(( new EventMultiplexer()));
+        this._register(onUninstallExtensionEventMultiplexer.add(this._onUninstallExtension.event));
+        this.onUninstallExtension = onUninstallExtensionEventMultiplexer.event;
+        const onDidUninstallExtensionEventMultiplexer = this._register(( new EventMultiplexer()));
+        this._register(onDidUninstallExtensionEventMultiplexer.add(this._onDidUninstallExtension.event));
+        this.onDidUninstallExtension = onDidUninstallExtensionEventMultiplexer.event;
+        const onDidUpdateExtensionMetadaEventMultiplexer = this._register(( new EventMultiplexer()));
+        this.onDidUpdateExtensionMetadata = onDidUpdateExtensionMetadaEventMultiplexer.event;
+        const onDidChangeProfileEventMultiplexer = this._register(( new EventMultiplexer()));
+        this.onDidChangeProfile = onDidChangeProfileEventMultiplexer.event;
+        for (const server of this.servers) {
+            this._register(onInstallExtensionEventMultiplexer.add(( Event.map(
+                server.extensionManagementService.onInstallExtension,
+                e => ({ ...e, server })
+            ))));
+            this._register(onDidInstallExtensionsEventMultiplexer.add(server.extensionManagementService.onDidInstallExtensions));
+            this._register(onUninstallExtensionEventMultiplexer.add(( Event.map(
+                server.extensionManagementService.onUninstallExtension,
+                e => ({ ...e, server })
+            ))));
+            this._register(onDidUninstallExtensionEventMultiplexer.add(( Event.map(
+                server.extensionManagementService.onDidUninstallExtension,
+                e => ({ ...e, server })
+            ))));
+            this._register(onDidUpdateExtensionMetadaEventMultiplexer.add(server.extensionManagementService.onDidUpdateExtensionMetadata));
+            this._register(onDidChangeProfileEventMultiplexer.add(( Event.map(
+                server.extensionManagementService.onDidChangeProfile,
+                e => ({ ...e, server })
+            ))));
+        }
+    }
+    isWorkspaceExtensionsSupported() {
+        return !!this.workspaceExtensionManagementService;
+    }
+    async getInstalled(type, profileLocation, productVersion) {
+        const result = [];
+        await Promise.all(( this.servers.map(async (server) => {
+            const installed = await server.extensionManagementService.getInstalled(type, profileLocation, productVersion);
+            if (server === this.getWorkspaceExtensionsServer()) {
+                const workspaceExtensions = await this.getInstalledWorkspaceExtensions(true);
+                installed.push(...workspaceExtensions);
+            }
+            result.push(...installed);
+        })));
+        return result;
     }
     async uninstall(extension, options) {
+        if (extension.isWorkspaceScoped) {
+            return this.uninstallExtensionFromWorkspace(extension);
+        }
         const server = this.getServer(extension);
         if (!server) {
             return Promise.reject(`Invalid location ${( extension.location.toString())}`);
@@ -152,7 +222,7 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
     async reinstallFromGallery(extension) {
         const server = this.getServer(extension);
         if (server) {
-            await this.checkForWorkspaceTrust(extension.manifest);
+            await this.checkForWorkspaceTrust(extension.manifest, false);
             return server.extensionManagementService.reinstallFromGallery(extension);
         }
         return Promise.reject(`Invalid location ${( extension.location.toString())}`);
@@ -191,7 +261,7 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
     async installVSIX(vsix, manifest, options) {
         const serversToInstall = this.getServersToInstall(manifest);
         if (serversToInstall?.length) {
-            await this.checkForWorkspaceTrust(manifest);
+            await this.checkForWorkspaceTrust(manifest, false);
             const [local] = await Promises.settled(( serversToInstall.map(server => this.installVSIXInServer(vsix, server, options))));
             return local;
         }
@@ -331,6 +401,113 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
             server => server.extensionManagementService.installFromGallery(gallery, installOptions)
         ))).then(([local]) => local);
     }
+    async getExtensions(locations) {
+        if (!this.workspaceExtensionManagementService) {
+            return [];
+        }
+        const scannedExtensions = await this.extensionsScannerService.scanMultipleExtensions(locations, 1 , { includeInvalid: true });
+        const result = [];
+        await Promise.all(( scannedExtensions.map(async (scannedExtension) => {
+            const workspaceExtension = await this.workspaceExtensionManagementService?.toLocalWorkspaceExtension(scannedExtension);
+            if (workspaceExtension) {
+                result.push({
+                    identifier: workspaceExtension.identifier,
+                    location: workspaceExtension.location,
+                    manifest: workspaceExtension.manifest,
+                    changelogUri: workspaceExtension.changelogUrl,
+                    readmeUri: workspaceExtension.readmeUrl,
+                });
+            }
+        })));
+        return result;
+    }
+    async getInstalledWorkspaceExtensions(includeInvalid) {
+        return this.workspaceExtensionManagementService?.getInstalled(includeInvalid) ?? [];
+    }
+    async installResourceExtension(extension, installOptions) {
+        if (!installOptions.isWorkspaceScoped) {
+            return this.installFromLocation(extension.location);
+        }
+        if (!this.workspaceExtensionManagementService) {
+            throw new Error('Workspace Extensions are not supported');
+        }
+        this.logService.info(`Installing the extension ${extension.identifier.id} from ${( extension.location.toString())} in workspace`);
+        const server = this.getWorkspaceExtensionsServer();
+        this._onInstallExtension.fire({
+            identifier: extension.identifier,
+            source: extension.location,
+            server,
+            applicationScoped: false,
+            profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
+            workspaceScoped: true
+        });
+        try {
+            await this.checkForWorkspaceTrust(extension.manifest, true);
+            const workspaceExtension = await this.workspaceExtensionManagementService.install(extension);
+            this.logService.info(`Successfully installed the extension ${workspaceExtension.identifier.id} from ${( extension.location.toString())} in the workspace`);
+            this._onDidInstallExtensions.fire([{
+                    identifier: workspaceExtension.identifier,
+                    source: extension.location,
+                    operation: 2 ,
+                    applicationScoped: false,
+                    profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
+                    local: workspaceExtension,
+                    workspaceScoped: true
+                }]);
+            return workspaceExtension;
+        }
+        catch (error) {
+            this.logService.error(`Failed to install the extension ${extension.identifier.id} from ${( extension.location.toString())} in the workspace`, getErrorMessage(error));
+            this._onDidInstallExtensions.fire([{
+                    identifier: extension.identifier,
+                    source: extension.location,
+                    operation: 2 ,
+                    applicationScoped: false,
+                    profileLocation: this.userDataProfileService.currentProfile.extensionsResource,
+                    error,
+                    workspaceScoped: true
+                }]);
+            throw error;
+        }
+    }
+    async uninstallExtensionFromWorkspace(extension) {
+        if (!extension.isWorkspaceScoped) {
+            throw new Error('The extension is not a workspace extension');
+        }
+        if (!this.workspaceExtensionManagementService) {
+            throw new Error('Workspace Extensions are not supported');
+        }
+        this.logService.info(`Uninstalling the workspace extension ${extension.identifier.id} from ${( extension.location.toString())}`);
+        const server = this.getWorkspaceExtensionsServer();
+        this._onUninstallExtension.fire({
+            identifier: extension.identifier,
+            server,
+            applicationScoped: false,
+            workspaceScoped: true
+        });
+        try {
+            await this.workspaceExtensionManagementService.uninstall(extension);
+            this.logService.info(`Successfully uninstalled the workspace extension ${extension.identifier.id} from ${( extension.location.toString())}`);
+            this.telemetryService.publicLog2('workspaceextension:uninstall');
+            this._onDidUninstallExtension.fire({
+                identifier: extension.identifier,
+                server,
+                applicationScoped: false,
+                workspaceScoped: true
+            });
+        }
+        catch (error) {
+            this.logService.error(`Failed to uninstall the workspace extension ${extension.identifier.id} from ${( extension.location.toString())}`, getErrorMessage(error));
+            this._onDidUninstallExtension.fire({
+                identifier: extension.identifier,
+                server,
+                error,
+                applicationScoped: false,
+                workspaceScoped: true
+            });
+            throw error;
+        }
+    }
     async validateAndGetExtensionManagementServersToInstall(gallery, installOptions) {
         const manifest = await this.extensionGalleryService.getManifest(gallery, CancellationToken.None);
         if (!manifest) {
@@ -362,7 +539,7 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
             throw error;
         }
         if (!installOptions?.context?.[EXTENSION_INSTALL_SYNC_CONTEXT]) {
-            await this.checkForWorkspaceTrust(manifest);
+            await this.checkForWorkspaceTrust(manifest, false);
         }
         if (!installOptions?.donotIncludePackAndDependencies) {
             await this.checkInstallingExtensionOnWeb(gallery, manifest);
@@ -393,7 +570,7 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
     async hasToFlagExtensionsMachineScoped(extensions) {
         if (this.isExtensionsSyncEnabled()) {
             const { result } = await this.dialogService.prompt({
-                type: Severity.Info,
+                type: Severity$1.Info,
                 message: extensions.length === 1 ? ( localizeWithPath(
                     'vs/workbench/services/extensionManagement/common/extensionManagementService',
                     'install extension',
@@ -456,33 +633,50 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
         return Promise.resolve({ malicious: [], deprecated: {}, search: [] });
     }
     getServer(extension) {
+        if (extension.isWorkspaceScoped) {
+            return this.getWorkspaceExtensionsServer();
+        }
         return this.extensionManagementServerService.getExtensionManagementServer(extension);
     }
-    async checkForWorkspaceTrust(manifest) {
-        if (this.extensionManifestPropertiesService.getExtensionUntrustedWorkspaceSupportType(manifest) === false) {
+    getWorkspaceExtensionsServer() {
+        if (this.extensionManagementServerService.remoteExtensionManagementServer) {
+            return this.extensionManagementServerService.remoteExtensionManagementServer;
+        }
+        if (this.extensionManagementServerService.localExtensionManagementServer) {
+            return this.extensionManagementServerService.localExtensionManagementServer;
+        }
+        if (this.extensionManagementServerService.webExtensionManagementServer) {
+            return this.extensionManagementServerService.webExtensionManagementServer;
+        }
+        throw new Error('No extension server found');
+    }
+    async checkForWorkspaceTrust(manifest, requireTrust) {
+        if (requireTrust || this.extensionManifestPropertiesService.getExtensionUntrustedWorkspaceSupportType(manifest) === false) {
+            const buttons = [];
+            buttons.push({ label: ( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'extensionInstallWorkspaceTrustButton',
+                "Trust Workspace & Install"
+            )), type: 'ContinueWithTrust' });
+            if (!requireTrust) {
+                buttons.push({ label: ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                    'extensionInstallWorkspaceTrustContinueButton',
+                    "Install"
+                )), type: 'ContinueWithoutTrust' });
+            }
+            buttons.push({ label: ( localizeWithPath(
+                'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                'extensionInstallWorkspaceTrustManageButton',
+                "Learn More"
+            )), type: 'Manage' });
             const trustState = await this.workspaceTrustRequestService.requestWorkspaceTrust({
                 message: ( localizeWithPath(
                     'vs/workbench/services/extensionManagement/common/extensionManagementService',
                     'extensionInstallWorkspaceTrustMessage',
                     "Enabling this extension requires a trusted workspace."
                 )),
-                buttons: [
-                    { label: ( localizeWithPath(
-                        'vs/workbench/services/extensionManagement/common/extensionManagementService',
-                        'extensionInstallWorkspaceTrustButton',
-                        "Trust Workspace & Install"
-                    )), type: 'ContinueWithTrust' },
-                    { label: ( localizeWithPath(
-                        'vs/workbench/services/extensionManagement/common/extensionManagementService',
-                        'extensionInstallWorkspaceTrustContinueButton',
-                        "Install"
-                    )), type: 'ContinueWithoutTrust' },
-                    { label: ( localizeWithPath(
-                        'vs/workbench/services/extensionManagement/common/extensionManagementService',
-                        'extensionInstallWorkspaceTrustManageButton',
-                        "Learn More"
-                    )), type: 'Manage' }
-                ]
+                buttons
             });
             if (trustState === undefined) {
                 throw new CancellationError();
@@ -574,7 +768,7 @@ let ExtensionManagementService = class ExtensionManagementService extends Dispos
             ];
         }
         await this.dialogService.prompt({
-            type: Severity.Info,
+            type: Severity$1.Info,
             message,
             detail,
             buttons,
@@ -627,7 +821,225 @@ ExtensionManagementService = ( __decorate([
     ( __param(9, IExtensionManifestPropertiesService)),
     ( __param(10, IFileService)),
     ( __param(11, ILogService)),
-    ( __param(12, IInstantiationService))
+    ( __param(12, IInstantiationService)),
+    ( __param(13, IExtensionsScannerService)),
+    ( __param(14, ITelemetryService))
 ], ExtensionManagementService));
+let WorkspaceExtensionsManagementService = class WorkspaceExtensionsManagementService extends Disposable {
+    static { WorkspaceExtensionsManagementService_1 = this; }
+    static { this.WORKSPACE_EXTENSIONS_KEY = 'workspaceExtensions.locations'; }
+    constructor(fileService, logService, workspaceService, extensionsScannerService, storageService, uriIdentityService, telemetryService) {
+        super();
+        this.fileService = fileService;
+        this.logService = logService;
+        this.workspaceService = workspaceService;
+        this.extensionsScannerService = extensionsScannerService;
+        this.storageService = storageService;
+        this.uriIdentityService = uriIdentityService;
+        this.telemetryService = telemetryService;
+        this._onDidChangeInvalidExtensions = this._register(( new Emitter()));
+        this.onDidChangeInvalidExtensions = this._onDidChangeInvalidExtensions.event;
+        this.extensions = [];
+        this.invalidExtensionWatchers = this._register(( new DisposableStore()));
+        this._register(Event.debounce(this.fileService.onDidFilesChange, (last, e) => {
+            (last = last ?? []).push(e);
+            return last;
+        }, 1000)(events => {
+            const changedInvalidExtensions = this.extensions.filter(extension => !extension.isValid && ( events.some(e => e.affects(extension.location))));
+            if (changedInvalidExtensions.length) {
+                this.checkExtensionsValidity(changedInvalidExtensions);
+            }
+        }));
+        this.initializePromise = this.initialize();
+    }
+    async initialize() {
+        const existingLocations = this.getWorkspaceExtensionsLocations();
+        if (!existingLocations.length) {
+            return;
+        }
+        await Promise.allSettled(( existingLocations.map(async (location) => {
+            if (!this.workspaceService.isInsideWorkspace(location)) {
+                this.logService.info(`Removing the workspace extension ${( location.toString())} as it is not inside the workspace`);
+                return;
+            }
+            if (!(await this.fileService.exists(location))) {
+                this.logService.info(`Removing the workspace extension ${( location.toString())} as it does not exist`);
+                return;
+            }
+            try {
+                const extension = await this.scanWorkspaceExtension(location);
+                if (extension) {
+                    this.extensions.push(extension);
+                }
+                else {
+                    this.logService.info(`Skipping workspace extension ${( location.toString())} as it does not exist`);
+                }
+            }
+            catch (error) {
+                this.logService.error('Skipping the workspace extension', ( location.toString()), error);
+            }
+        })));
+        this.saveWorkspaceExtensions();
+    }
+    watchInvalidExtensions() {
+        this.invalidExtensionWatchers.clear();
+        for (const extension of this.extensions) {
+            if (!extension.isValid) {
+                this.invalidExtensionWatchers.add(this.fileService.watch(extension.location));
+            }
+        }
+    }
+    async checkExtensionsValidity(extensions) {
+        const validExtensions = [];
+        await Promise.all(( extensions.map(async (extension) => {
+            const newExtension = await this.scanWorkspaceExtension(extension.location);
+            if (newExtension?.isValid) {
+                validExtensions.push(newExtension);
+            }
+        })));
+        let changed = false;
+        for (const extension of validExtensions) {
+            const index = this.extensions.findIndex(e => this.uriIdentityService.extUri.isEqual(e.location, extension.location));
+            if (index !== -1) {
+                changed = true;
+                this.extensions.splice(index, 1, extension);
+            }
+        }
+        if (changed) {
+            this.saveWorkspaceExtensions();
+            this._onDidChangeInvalidExtensions.fire(validExtensions);
+        }
+    }
+    async getInstalled(includeInvalid) {
+        await this.initializePromise;
+        return this.extensions.filter(e => includeInvalid || e.isValid);
+    }
+    async install(extension) {
+        await this.initializePromise;
+        const workspaceExtension = await this.scanWorkspaceExtension(extension.location);
+        if (!workspaceExtension) {
+            throw new Error('Cannot install the extension as it does not exist.');
+        }
+        const existingExtensionIndex = this.extensions.findIndex(e => areSameExtensions(e.identifier, extension.identifier));
+        if (existingExtensionIndex === -1) {
+            this.extensions.push(workspaceExtension);
+        }
+        else {
+            this.extensions.splice(existingExtensionIndex, 1, workspaceExtension);
+        }
+        this.saveWorkspaceExtensions();
+        this.telemetryService.publicLog2('workspaceextension:install');
+        return workspaceExtension;
+    }
+    async uninstall(extension) {
+        await this.initializePromise;
+        const existingExtensionIndex = this.extensions.findIndex(e => areSameExtensions(e.identifier, extension.identifier));
+        if (existingExtensionIndex !== -1) {
+            this.extensions.splice(existingExtensionIndex, 1);
+            this.saveWorkspaceExtensions();
+        }
+        this.telemetryService.publicLog2('workspaceextension:uninstall');
+    }
+    getWorkspaceExtensionsLocations() {
+        const locations = [];
+        try {
+            const parsed = JSON.parse(this.storageService.get(WorkspaceExtensionsManagementService_1.WORKSPACE_EXTENSIONS_KEY, 1 , '[]'));
+            if (Array.isArray(locations)) {
+                for (const location of parsed) {
+                    if (isString(location)) {
+                        if (this.workspaceService.getWorkbenchState() === 2 ) {
+                            locations.push(this.workspaceService.getWorkspace().folders[0].toResource(location));
+                        }
+                        else {
+                            this.logService.warn(`Invalid value for 'extensions' in workspace storage: ${location}`);
+                        }
+                    }
+                    else {
+                        locations.push(URI.revive(location));
+                    }
+                }
+            }
+            else {
+                this.logService.warn(`Invalid value for 'extensions' in workspace storage: ${locations}`);
+            }
+        }
+        catch (error) {
+            this.logService.warn(`Error parsing workspace extensions locations: ${getErrorMessage(error)}`);
+        }
+        return locations;
+    }
+    saveWorkspaceExtensions() {
+        const locations = ( this.extensions.map(extension => extension.location));
+        if (this.workspaceService.getWorkbenchState() === 2 ) {
+            this.storageService.store(WorkspaceExtensionsManagementService_1.WORKSPACE_EXTENSIONS_KEY, JSON.stringify(coalesce(( locations
+                .map(
+                location => this.uriIdentityService.extUri.relativePath(this.workspaceService.getWorkspace().folders[0].uri, location)
+            )))), 1 , 1 );
+        }
+        else {
+            this.storageService.store(WorkspaceExtensionsManagementService_1.WORKSPACE_EXTENSIONS_KEY, JSON.stringify(locations), 1 , 1 );
+        }
+        this.watchInvalidExtensions();
+    }
+    async scanWorkspaceExtension(location) {
+        const scannedExtension = await this.extensionsScannerService.scanExistingExtension(location, 1 , { includeInvalid: true });
+        return scannedExtension ? this.toLocalWorkspaceExtension(scannedExtension) : null;
+    }
+    async toLocalWorkspaceExtension(extension) {
+        const stat = await this.fileService.resolve(extension.location);
+        let readmeUrl;
+        let changelogUrl;
+        if (stat.children) {
+            readmeUrl = stat.children.find(({ name }) => /^readme(\.txt|\.md|)$/i.test(name))?.resource;
+            changelogUrl = stat.children.find(({ name }) => /^changelog(\.txt|\.md|)$/i.test(name))?.resource;
+        }
+        const validations = [...extension.validations];
+        let isValid = extension.isValid;
+        if (extension.manifest.main) {
+            if (!(await this.fileService.exists(this.uriIdentityService.extUri.joinPath(extension.location, extension.manifest.main)))) {
+                isValid = false;
+                validations.push([Severity$1.Error, ( localizeWithPath(
+                    'vs/workbench/services/extensionManagement/common/extensionManagementService',
+                    'main.notFound',
+                    "Cannot activate, becase {0} not found",
+                    extension.manifest.main
+                ))]);
+            }
+        }
+        return {
+            identifier: extension.identifier,
+            type: extension.type,
+            isBuiltin: extension.isBuiltin || !!extension.metadata?.isBuiltin,
+            location: extension.location,
+            manifest: extension.manifest,
+            targetPlatform: extension.targetPlatform,
+            validations,
+            isValid,
+            readmeUrl,
+            changelogUrl,
+            publisherDisplayName: extension.metadata?.publisherDisplayName || null,
+            publisherId: extension.metadata?.publisherId || null,
+            isApplicationScoped: !!extension.metadata?.isApplicationScoped,
+            isMachineScoped: !!extension.metadata?.isMachineScoped,
+            isPreReleaseVersion: !!extension.metadata?.isPreReleaseVersion,
+            hasPreReleaseVersion: !!extension.metadata?.hasPreReleaseVersion,
+            preRelease: !!extension.metadata?.preRelease,
+            installedTimestamp: extension.metadata?.installedTimestamp,
+            updated: !!extension.metadata?.updated,
+            pinned: !!extension.metadata?.pinned,
+            isWorkspaceScoped: true,
+            source: 'resource'
+        };
+    }
+};
+WorkspaceExtensionsManagementService = WorkspaceExtensionsManagementService_1 = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IExtensionsScannerService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, IUriIdentityService)),
+    ( __param(6, ITelemetryService))
+], WorkspaceExtensionsManagementService));
 
 export { ExtensionManagementService };

package/vscode/src/vs/workbench/services/extensionManagement/common/webExtensionManagementService.js

@@ -139,8 +139,8 @@ let WebExtensionManagementService = class WebExtensionManagementService extends
     async copyExtensions(fromProfileLocation, toProfileLocation) {
         await this.webExtensionsScannerService.copyExtensions(fromProfileLocation, toProfileLocation, e => !e.metadata?.isApplicationScoped);
     }
-    async getCompatibleVersion(extension, sameVersion, includePreRelease) {
-        const compatibleExtension = await super.getCompatibleVersion(extension, sameVersion, includePreRelease);
+    async getCompatibleVersion(extension, sameVersion, includePreRelease, productVersion) {
+        const compatibleExtension = await super.getCompatibleVersion(extension, sameVersion, includePreRelease, productVersion);
         if (compatibleExtension) {
             return compatibleExtension;
         }
@@ -213,6 +213,8 @@ function toLocalExtension(extension) {
         targetPlatform: "web" ,
         updated: !!metadata.updated,
         pinned: !!metadata?.pinned,
+        isWorkspaceScoped: false,
+        source: metadata?.source ?? (extension.identifier.uuid ? 'gallery' : 'resource')
     };
 }
 function getMetadata(options, existingExtension) {
@@ -255,6 +257,7 @@ class InstallExtensionTask extends AbstractExtensionTask {
             metadata.preRelease = isBoolean(this.options.preRelease)
                 ? this.options.preRelease
                 : this.options.installPreReleaseVersion || this.extension.properties.isPreReleaseVersion || metadata.preRelease;
+            metadata.source = URI.isUri(this.extension) ? 'resource' : 'gallery';
         }
         metadata.pinned = this.options.installGivenVersion ? true : (this.options.pinned ?? metadata.pinned);
         this._profileLocation = metadata.isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : this.options.profileLocation;