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

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsWorkbenchService.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { semverExports } from '../../../../../../../external/vscode-semver/semver.js';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { index } from 'vscode/vscode/vs/base/common/arrays';
+import { firstOrDefault, index } from 'vscode/vscode/vs/base/common/arrays';
 import { ThrottledDelayer, Promises, createCancelablePromise } from 'vscode/vscode/vs/base/common/async';
 import { CancellationError, isCancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -31,7 +31,7 @@ import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/langu
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
 import { FileAccess } from 'vscode/vscode/vs/base/common/network';
 import { IIgnoredExtensionsManagementService } from 'vscode/vscode/vs/platform/userDataSync/common/ignoredExtensions';
-import { IUserDataAutoSyncService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { IUserDataAutoSyncService, IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { isUndefined, isBoolean, isString } from 'vscode/vscode/vs/base/common/types';
 import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
@@ -43,15 +43,21 @@ import { TelemetryTrustedValue } from 'vscode/vscode/vs/platform/telemetry/commo
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IUpdateService } from 'vscode/vscode/vs/platform/update/common/update';
+import { isEngineValid } from 'vscode/vscode/vs/platform/extensions/common/extensionValidator';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 var Extensions_1, ExtensionsWorkbenchService_1;
 let Extension = class Extension {
-    constructor(stateProvider, runtimeStateProvider, server, local, gallery, galleryService, telemetryService, logService, fileService, productService) {
+    constructor(stateProvider, runtimeStateProvider, server, local, gallery, resourceExtensionInfo, galleryService, telemetryService, logService, fileService, productService) {
         this.stateProvider = stateProvider;
         this.runtimeStateProvider = runtimeStateProvider;
         this.server = server;
         this.local = local;
         this.gallery = gallery;
+        this.resourceExtensionInfo = resourceExtensionInfo;
         this.galleryService = galleryService;
         this.telemetryService = telemetryService;
         this.logService = logService;
@@ -59,6 +65,7 @@ let Extension = class Extension {
         this.productService = productService;
         this.enablementState = 8 ;
         this.isMalicious = false;
+        this.resourceExtension = resourceExtensionInfo?.resourceExtension;
     }
     get type() {
         return this.local ? this.local.type : 1 ;
@@ -66,26 +73,44 @@ let Extension = class Extension {
     get isBuiltin() {
         return this.local ? this.local.isBuiltin : false;
     }
+    get isWorkspaceScoped() {
+        if (this.local) {
+            return this.local.isWorkspaceScoped;
+        }
+        if (this.resourceExtensionInfo) {
+            return this.resourceExtensionInfo.isWorkspaceScoped;
+        }
+        return false;
+    }
     get name() {
-        return this.gallery ? this.gallery.name : this.local.manifest.name;
+        if (this.gallery) {
+            return this.gallery.name;
+        }
+        return this.getManifestFromLocalOrResource()?.name ?? '';
     }
     get displayName() {
         if (this.gallery) {
             return this.gallery.displayName || this.gallery.name;
         }
-        return this.local.manifest.displayName || this.local.manifest.name;
+        return this.getManifestFromLocalOrResource()?.displayName ?? this.name;
     }
     get identifier() {
         if (this.gallery) {
             return this.gallery.identifier;
         }
+        if (this.resourceExtension) {
+            return this.resourceExtension.identifier;
+        }
         return this.local.identifier;
     }
     get uuid() {
-        return this.gallery ? this.gallery.identifier.uuid : this.local.identifier.uuid;
+        return this.gallery ? this.gallery.identifier.uuid : this.local?.identifier.uuid;
     }
     get publisher() {
-        return this.gallery ? this.gallery.publisher : this.local.manifest.publisher;
+        if (this.gallery) {
+            return this.gallery.publisher;
+        }
+        return this.getManifestFromLocalOrResource()?.publisher ?? '';
     }
     get publisherDisplayName() {
         if (this.gallery) {
@@ -94,7 +119,7 @@ let Extension = class Extension {
         if (this.local?.publisherDisplayName) {
             return this.local.publisherDisplayName;
         }
-        return this.local.manifest.publisher;
+        return this.publisher;
     }
     get publisherUrl() {
         if (!this.productService.extensionsGallery || !this.gallery) {
@@ -115,10 +140,10 @@ let Extension = class Extension {
         return !!this.local?.pinned;
     }
     get latestVersion() {
-        return this.gallery ? this.gallery.version : this.local.manifest.version;
+        return this.gallery ? this.gallery.version : this.getManifestFromLocalOrResource()?.version ?? '';
     }
     get description() {
-        return this.gallery ? this.gallery.description : this.local.manifest.description || '';
+        return this.gallery ? this.gallery.description : this.getManifestFromLocalOrResource()?.description ?? '';
     }
     get url() {
         if (!this.productService.extensionsGallery || !this.gallery) {
@@ -127,10 +152,10 @@ let Extension = class Extension {
         return `${this.productService.extensionsGallery.itemUrl}?itemName=${this.publisher}.${this.name}`;
     }
     get iconUrl() {
-        return this.galleryIconUrl || this.localIconUrl || this.defaultIconUrl;
+        return this.galleryIconUrl || this.resourceExtensionIconUrl || this.localIconUrl || this.defaultIconUrl;
     }
     get iconUrlFallback() {
-        return this.galleryIconUrlFallback || this.localIconUrl || this.defaultIconUrl;
+        return this.galleryIconUrlFallback || this.resourceExtensionIconUrl || this.localIconUrl || this.defaultIconUrl;
     }
     get localIconUrl() {
         if (this.local && this.local.manifest.icon) {
@@ -138,6 +163,12 @@ let Extension = class Extension {
         }
         return null;
     }
+    get resourceExtensionIconUrl() {
+        if (this.resourceExtension?.manifest.icon) {
+            return ( FileAccess.uriToBrowserUri(joinPath(this.resourceExtension.location, this.resourceExtension.manifest.icon)).toString(true));
+        }
+        return null;
+    }
     get galleryIconUrl() {
         return this.gallery?.assets.icon ? this.gallery.assets.icon.uri : null;
     }
@@ -207,7 +238,7 @@ let Extension = class Extension {
             && this.local.targetPlatform !== this.gallery.properties.targetPlatform
             && semverExports.eq(this.latestVersion, this.version);
     }
-    get reloadRequiredStatus() {
+    get runtimeState() {
         return this.runtimeStateProvider(this);
     }
     get telemetryData() {
@@ -215,9 +246,12 @@ let Extension = class Extension {
         if (gallery) {
             return getGalleryExtensionTelemetryData(gallery);
         }
-        else {
+        else if (local) {
             return getLocalExtensionTelemetryData(local);
         }
+        else {
+            return {};
+        }
     }
     get preview() {
         return this.local?.manifest.preview ?? this.gallery?.preview ?? false;
@@ -235,7 +269,7 @@ let Extension = class Extension {
         return !!this.gallery?.hasPreReleaseVersion || !!this.local?.hasPreReleaseVersion;
     }
     get hasReleaseVersion() {
-        return !!this.gallery?.hasReleaseVersion;
+        return !!this.resourceExtension || !!this.gallery?.hasReleaseVersion;
     }
     getLocal() {
         return this.local && !this.outdated ? this.local : undefined;
@@ -256,6 +290,9 @@ let Extension = class Extension {
             )), this.identifier.id);
             return null;
         }
+        if (this.resourceExtension) {
+            return this.resourceExtension.manifest;
+        }
         return null;
     }
     hasReadme() {
@@ -265,6 +302,9 @@ let Extension = class Extension {
         if (this.gallery && this.gallery.assets.readme) {
             return true;
         }
+        if (this.resourceExtension?.readmeUri) {
+            return true;
+        }
         return this.type === 0 ;
     }
     async getReadme(token) {
@@ -286,6 +326,10 @@ let Extension = class Extension {
 ${this.description}
 `);
         }
+        if (this.resourceExtension?.readmeUri) {
+            const content = await this.fileService.readFile(this.resourceExtension?.readmeUri);
+            return ( content.value.toString());
+        }
         return Promise.reject(( new Error('not available')));
     }
     hasChangelog() {
@@ -312,13 +356,16 @@ ${this.description}
         return Promise.reject(( new Error('not available')));
     }
     get categories() {
-        const { local, gallery } = this;
+        const { local, gallery, resourceExtension } = this;
         if (local && local.manifest.categories && !this.outdated) {
             return local.manifest.categories;
         }
         if (gallery) {
             return gallery.categories;
         }
+        if (resourceExtension) {
+            return resourceExtension.manifest.categories ?? [];
+        }
         return [];
     }
     get tags() {
@@ -329,32 +376,47 @@ ${this.description}
         return [];
     }
     get dependencies() {
-        const { local, gallery } = this;
+        const { local, gallery, resourceExtension } = this;
         if (local && local.manifest.extensionDependencies && !this.outdated) {
             return local.manifest.extensionDependencies;
         }
         if (gallery) {
             return gallery.properties.dependencies || [];
         }
+        if (resourceExtension) {
+            return resourceExtension.manifest.extensionDependencies || [];
+        }
         return [];
     }
     get extensionPack() {
-        const { local, gallery } = this;
+        const { local, gallery, resourceExtension } = this;
         if (local && local.manifest.extensionPack && !this.outdated) {
             return local.manifest.extensionPack;
         }
         if (gallery) {
             return gallery.properties.extensionPack || [];
         }
+        if (resourceExtension) {
+            return resourceExtension.manifest.extensionPack || [];
+        }
         return [];
     }
+    getManifestFromLocalOrResource() {
+        if (this.local) {
+            return this.local.manifest;
+        }
+        if (this.resourceExtension) {
+            return this.resourceExtension.manifest;
+        }
+        return null;
+    }
 };
 Extension = ( __decorate([
-    ( __param(5, IExtensionGalleryService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IFileService)),
-    ( __param(9, IProductService))
+    ( __param(6, IExtensionGalleryService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, ILogService)),
+    ( __param(9, IFileService)),
+    ( __param(10, IProductService))
 ], Extension));
 const EXTENSIONS_AUTO_UPDATE_KEY = 'extensions.autoUpdate';
 let Extensions = Extensions_1 = class Extensions extends Disposable {
@@ -364,13 +426,15 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
     }
     get onChange() { return this._onChange.event; }
     get onReset() { return this._onReset.event; }
-    constructor(server, stateProvider, runtimeStateProvider, galleryService, extensionEnablementService, telemetryService, instantiationService) {
+    constructor(server, stateProvider, runtimeStateProvider, isWorkspaceServer, galleryService, extensionEnablementService, workbenchExtensionManagementService, telemetryService, instantiationService) {
         super();
         this.server = server;
         this.stateProvider = stateProvider;
         this.runtimeStateProvider = runtimeStateProvider;
+        this.isWorkspaceServer = isWorkspaceServer;
         this.galleryService = galleryService;
         this.extensionEnablementService = extensionEnablementService;
+        this.workbenchExtensionManagementService = workbenchExtensionManagementService;
         this.telemetryService = telemetryService;
         this.instantiationService = instantiationService;
         this._onChange = this._register(( new Emitter()));
@@ -386,6 +450,29 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
         this._register(server.extensionManagementService.onDidChangeProfile(() => this.reset()));
         this._register(extensionEnablementService.onEnablementChanged(e => this.onEnablementChanged(e)));
         this._register(Event.any(this.onChange, this.onReset)(() => this._local = undefined));
+        if (this.isWorkspaceServer) {
+            this._register(this.workbenchExtensionManagementService.onInstallExtension(e => {
+                if (e.workspaceScoped) {
+                    this.onInstallExtension(e);
+                }
+            }));
+            this._register(this.workbenchExtensionManagementService.onDidInstallExtensions(e => {
+                const result = e.filter(e => e.workspaceScoped);
+                if (result.length) {
+                    this.onDidInstallExtensions(result);
+                }
+            }));
+            this._register(this.workbenchExtensionManagementService.onUninstallExtension(e => {
+                if (e.workspaceScoped) {
+                    this.onUninstallExtension(e.identifier);
+                }
+            }));
+            this._register(this.workbenchExtensionManagementService.onDidUninstallExtension(e => {
+                if (e.workspaceScoped) {
+                    this.onDidUninstallExtension(e);
+                }
+            }));
+        }
     }
     get local() {
         if (!this._local) {
@@ -401,14 +488,13 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
         }
         return this._local;
     }
-    async queryInstalled() {
-        await this.fetchInstalledExtensions();
+    async queryInstalled(productVersion) {
+        await this.fetchInstalledExtensions(productVersion);
         this._onChange.fire(undefined);
         return this.local;
     }
-    async syncInstalledExtensionsWithGallery(galleryExtensions) {
-        let hasChanged = false;
-        const extensions = await this.mapInstalledExtensionWithCompatibleGalleryExtension(galleryExtensions);
+    async syncInstalledExtensionsWithGallery(galleryExtensions, productVersion) {
+        const extensions = await this.mapInstalledExtensionWithCompatibleGalleryExtension(galleryExtensions, productVersion);
         for (const [extension, gallery] of extensions) {
             if (extension.local && !extension.local.identifier.uuid) {
                 extension.local = await this.updateMetadata(extension.local, gallery);
@@ -416,19 +502,17 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
             if (!extension.gallery || extension.gallery.version !== gallery.version || extension.gallery.properties.targetPlatform !== gallery.properties.targetPlatform) {
                 extension.gallery = gallery;
                 this._onChange.fire({ extension });
-                hasChanged = true;
             }
         }
-        return hasChanged;
     }
-    async mapInstalledExtensionWithCompatibleGalleryExtension(galleryExtensions) {
+    async mapInstalledExtensionWithCompatibleGalleryExtension(galleryExtensions, productVersion) {
         const mappedExtensions = this.mapInstalledExtensionWithGalleryExtension(galleryExtensions);
         const targetPlatform = await this.server.extensionManagementService.getTargetPlatform();
         const compatibleGalleryExtensions = [];
         const compatibleGalleryExtensionsToFetch = [];
         await Promise.allSettled(( mappedExtensions.map(async ([extension, gallery]) => {
             if (extension.local) {
-                if (await this.galleryService.isExtensionCompatible(gallery, extension.local.preRelease, targetPlatform)) {
+                if (await this.galleryService.isExtensionCompatible(gallery, extension.local.preRelease, targetPlatform, productVersion)) {
                     compatibleGalleryExtensions.push(gallery);
                 }
                 else {
@@ -437,7 +521,7 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
             }
         })));
         if (compatibleGalleryExtensionsToFetch.length) {
-            const result = await this.galleryService.getExtensions(compatibleGalleryExtensionsToFetch, { targetPlatform, compatible: true, queryAllVersions: true }, CancellationToken.None);
+            const result = await this.galleryService.getExtensions(compatibleGalleryExtensionsToFetch, { targetPlatform, compatible: true, queryAllVersions: true, productVersion }, CancellationToken.None);
             compatibleGalleryExtensions.push(...result);
         }
         return this.mapInstalledExtensionWithGalleryExtension(compatibleGalleryExtensions);
@@ -457,9 +541,11 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
                     continue;
                 }
             }
-            const gallery = byID.get(installed.identifier.id.toLowerCase());
-            if (gallery) {
-                mappedExtensions.push([installed, gallery]);
+            if (installed.local?.source !== 'resource') {
+                const gallery = byID.get(installed.identifier.id.toLowerCase());
+                if (gallery) {
+                    mappedExtensions.push([installed, gallery]);
+                }
             }
         }
         return mappedExtensions;
@@ -479,15 +565,18 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
     onInstallExtension(event) {
         const { source } = event;
         if (source && !URI.isUri(source)) {
-            const extension = this.installed.filter(e => areSameExtensions(e.identifier, source.identifier))[0]
-                || this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, undefined, source);
+            const extension = this.installed.find(e => areSameExtensions(e.identifier, source.identifier))
+                ?? this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, undefined, source, undefined);
             this.installing.push(extension);
             this._onChange.fire({ extension });
         }
     }
-    async fetchInstalledExtensions() {
+    async fetchInstalledExtensions(productVersion) {
         const extensionsControlManifest = await this.server.extensionManagementService.getExtensionsControlManifest();
-        const all = await this.server.extensionManagementService.getInstalled();
+        const all = await this.server.extensionManagementService.getInstalled(undefined, undefined, productVersion);
+        if (this.isWorkspaceServer) {
+            all.push(...(await this.workbenchExtensionManagementService.getInstalledWorkspaceExtensions(true)));
+        }
         const installed = groupByExtension(all, r => r.identifier).reduce((result, extensions) => {
             const extension = extensions.length === 1 ? extensions[0]
                 : extensions.find(e => e.type === 1 ) || extensions.find(e => e.type === 0 );
@@ -496,7 +585,7 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
         }, []);
         const byId = index(this.installed, e => e.local ? e.local.identifier.id : e.identifier.id);
         this.installed = ( installed.map(local => {
-            const extension = byId[local.identifier.id] || this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined);
+            const extension = byId[local.identifier.id] || this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined, undefined);
             extension.local = local;
             extension.enablementState = this.extensionEnablementService.getEnablementState(local);
             Extensions_1.updateExtensionFromControlManifest(extension, extensionsControlManifest);
@@ -518,7 +607,7 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
             const installingExtension = gallery ? this.installing.filter(e => areSameExtensions(e.identifier, gallery.identifier))[0] : null;
             this.installing = installingExtension ? this.installing.filter(e => e !== installingExtension) : this.installing;
             let extension = installingExtension ? installingExtension
-                : (location || local) ? this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined)
+                : (location || local) ? this.instantiationService.createInstance(Extension, this.stateProvider, this.runtimeStateProvider, this.server, local, undefined, undefined)
                     : undefined;
             if (extension) {
                 if (local) {
@@ -538,7 +627,7 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
                 }
             }
             this._onChange.fire(!local || !extension ? undefined : { extension, operation: event.operation });
-            if (extension && extension.local && !extension.gallery) {
+            if (extension && extension.local && !extension.gallery && extension.local.source !== 'resource') {
                 await this.syncInstalledExtensionWithGallery(extension);
             }
         }
@@ -609,17 +698,18 @@ let Extensions = Extensions_1 = class Extensions extends Disposable {
     }
 };
 Extensions = Extensions_1 = ( __decorate([
-    ( __param(3, IExtensionGalleryService)),
-    ( __param(4, IWorkbenchExtensionEnablementService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, IInstantiationService))
+    ( __param(4, IExtensionGalleryService)),
+    ( __param(5, IWorkbenchExtensionEnablementService)),
+    ( __param(6, IWorkbenchExtensionManagementService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IInstantiationService))
 ], Extensions));
 let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Disposable {
     static { ExtensionsWorkbenchService_1 = this; }
     static { this.UpdatesCheckInterval = 1000 * 60 * 60 * 12; }
     get onChange() { return this._onChange.event; }
     get onReset() { return this._onReset.event; }
-    constructor(instantiationService, editorService, extensionManagementService, galleryService, configurationService, telemetryService, notificationService, urlService, extensionEnablementService, hostService, progressService, extensionManagementServerService, languageService, extensionsSyncManagementService, userDataAutoSyncService, productService, contextKeyService, extensionManifestPropertiesService, logService, extensionService, localeService, lifecycleService, fileService, userDataProfileService, storageService) {
+    constructor(instantiationService, editorService, extensionManagementService, galleryService, configurationService, telemetryService, notificationService, urlService, extensionEnablementService, hostService, progressService, extensionManagementServerService, languageService, extensionsSyncManagementService, userDataAutoSyncService, productService, contextKeyService, extensionManifestPropertiesService, logService, extensionService, localeService, lifecycleService, fileService, userDataProfileService, storageService, dialogService, userDataSyncEnablementService, updateService, uriIdentityService) {
         super();
         this.instantiationService = instantiationService;
         this.editorService = editorService;
@@ -644,6 +734,10 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         this.fileService = fileService;
         this.userDataProfileService = userDataProfileService;
         this.storageService = storageService;
+        this.dialogService = dialogService;
+        this.userDataSyncEnablementService = userDataSyncEnablementService;
+        this.updateService = updateService;
+        this.uriIdentityService = uriIdentityService;
         this.localExtensions = null;
         this.remoteExtensions = null;
         this.webExtensions = null;
@@ -659,19 +753,19 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         this.hasOutdatedExtensionsContextKey = HasOutdatedExtensionsContext.bindTo(contextKeyService);
         if (extensionManagementServerService.localExtensionManagementServer) {
-            this.localExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.localExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getReloadStatus(ext)));
+            this.localExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.localExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), !extensionManagementServerService.remoteExtensionManagementServer));
             this._register(this.localExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
             this._register(this.localExtensions.onReset(e => this.reset()));
             this.extensionsServers.push(this.localExtensions);
         }
         if (extensionManagementServerService.remoteExtensionManagementServer) {
-            this.remoteExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.remoteExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getReloadStatus(ext)));
+            this.remoteExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.remoteExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), true));
             this._register(this.remoteExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
             this._register(this.remoteExtensions.onReset(e => this.reset()));
             this.extensionsServers.push(this.remoteExtensions);
         }
         if (extensionManagementServerService.webExtensionManagementServer) {
-            this.webExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.webExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getReloadStatus(ext)));
+            this.webExtensions = this._register(instantiationService.createInstance(Extensions, extensionManagementServerService.webExtensionManagementServer, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), !(extensionManagementServerService.remoteExtensionManagementServer || extensionManagementServerService.localExtensionManagementServer)));
             this._register(this.webExtensions.onChange(e => this.onDidChangeExtensions(e?.extension)));
             this._register(this.webExtensions.onReset(e => this.reset()));
             this.extensionsServers.push(this.webExtensions);
@@ -718,6 +812,14 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             }
         }));
         this._register(Event.debounce(this.onChange, () => undefined, 100)(() => this.hasOutdatedExtensionsContextKey.set(this.outdated.length > 0)));
+        this._register(this.updateService.onStateChange(e => {
+            if (!this.isAutoUpdateEnabled()) {
+                return;
+            }
+            if ((e.type === "checking for updates"  && e.explicit) || e.type === "available for download"  || e.type === "downloaded" ) {
+                this.eventuallyCheckForUpdates(true);
+            }
+        }));
         this.hasOutdatedExtensionsContextKey.set(this.outdated.length > 0);
         this.eventuallyCheckForUpdates(true);
         if (isWeb) {
@@ -801,18 +903,18 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     async queryLocal(server) {
         if (server) {
             if (this.localExtensions && this.extensionManagementServerService.localExtensionManagementServer === server) {
-                return this.localExtensions.queryInstalled();
+                return this.localExtensions.queryInstalled(this.getProductVersion());
             }
             if (this.remoteExtensions && this.extensionManagementServerService.remoteExtensionManagementServer === server) {
-                return this.remoteExtensions.queryInstalled();
+                return this.remoteExtensions.queryInstalled(this.getProductVersion());
             }
             if (this.webExtensions && this.extensionManagementServerService.webExtensionManagementServer === server) {
-                return this.webExtensions.queryInstalled();
+                return this.webExtensions.queryInstalled(this.getProductVersion());
             }
         }
         if (this.localExtensions) {
             try {
-                await this.localExtensions.queryInstalled();
+                await this.localExtensions.queryInstalled(this.getProductVersion());
             }
             catch (error) {
                 this.logService.error(error);
@@ -820,7 +922,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         if (this.remoteExtensions) {
             try {
-                await this.remoteExtensions.queryInstalled();
+                await this.remoteExtensions.queryInstalled(this.getProductVersion());
             }
             catch (error) {
                 this.logService.error(error);
@@ -828,7 +930,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         if (this.webExtensions) {
             try {
-                await this.webExtensions.queryInstalled();
+                await this.webExtensions.queryInstalled(this.getProductVersion());
             }
             catch (error) {
                 this.logService.error(error);
@@ -868,6 +970,13 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         this.syncInstalledExtensionsWithGallery(galleryExtensions);
         return ( galleryExtensions.map(gallery => this.fromGallery(gallery, extensionsControlManifest)));
     }
+    async getResourceExtensions(locations, isWorkspaceScoped) {
+        const resourceExtensions = await this.extensionManagementService.getExtensions(locations);
+        return ( resourceExtensions.map(
+            resourceExtension => this.getInstalledExtensionMatchingLocation(resourceExtension.location)
+                ?? this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, undefined, { resourceExtension, isWorkspaceScoped })
+        ));
+    }
     resolveQueryText(text) {
         text = text.replace(/@web/g, `tag:"${WEB_EXTENSION_TAG}"`);
         const extensionRegex = /\bext:([^\s]+)\b/g;
@@ -886,7 +995,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
     fromGallery(gallery, extensionsControlManifest) {
         let extension = this.getInstalledExtensionMatchingGallery(gallery);
         if (!extension) {
-            extension = this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getReloadStatus(ext), undefined, undefined, gallery);
+            extension = this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, gallery, undefined);
             Extensions.updateExtensionFromControlManifest(extension, extensionsControlManifest);
         }
         return extension;
@@ -898,7 +1007,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                     return installed;
                 }
             }
-            else {
+            else if (installed.local?.source !== 'resource') {
                 if (areSameExtensions(installed.identifier, gallery.identifier)) {
                     return installed;
                 }
@@ -906,6 +1015,9 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         return null;
     }
+    getInstalledExtensionMatchingLocation(location) {
+        return this.local.find(e => e.local && this.uriIdentityService.extUri.isEqualOrParent(location, e.local?.location)) ?? null;
+    }
     async open(extension, options) {
         if (typeof extension === 'string') {
             const id = extension;
@@ -925,18 +1037,74 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         return undefined;
     }
-    getReloadStatus(extension) {
+    async updateRunningExtensions() {
+        const toAdd = [];
+        const toRemove = [];
+        const extensionsToCheck = [...this.local];
+        const notExistingRunningExtensions = this.extensionService.extensions.filter(e => !( this.local.some(
+            local => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, local.identifier)
+        )));
+        if (notExistingRunningExtensions.length) {
+            const extensions = await this.getExtensions(( notExistingRunningExtensions.map(e => ({ id: e.identifier.value }))), CancellationToken.None);
+            extensionsToCheck.push(...extensions);
+        }
+        for (const extension of extensionsToCheck) {
+            const runtimeState = extension.runtimeState;
+            if (!runtimeState || runtimeState.action !== "restartExtensions" ) {
+                continue;
+            }
+            if (extension.state === 3 ) {
+                toRemove.push(extension.identifier.id);
+                continue;
+            }
+            if (!extension.local) {
+                continue;
+            }
+            const isEnabled = this.extensionEnablementService.isEnabled(extension.local);
+            if (isEnabled) {
+                const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, extension.identifier));
+                if (runningExtension) {
+                    toRemove.push(runningExtension.identifier.value);
+                }
+                toAdd.push(extension.local);
+            }
+            else {
+                toRemove.push(extension.identifier.id);
+            }
+        }
+        if (toAdd.length || toRemove.length) {
+            if (await this.extensionService.stopExtensionHosts(( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                'restart',
+                "Enable or Disable extensions"
+            )))) {
+                await this.extensionService.startExtensionHosts({ toAdd, toRemove });
+            }
+        }
+    }
+    getRuntimeState(extension) {
         const isUninstalled = extension.state === 3 ;
         const runningExtension = this.extensionService.extensions.find(e => areSameExtensions({ id: e.identifier.value, uuid: e.uuid }, extension.identifier));
+        const reloadAction = this.extensionManagementServerService.remoteExtensionManagementServer ? "reloadWindow"  : "restartExtensions" ;
+        const reloadActionLabel = reloadAction === "reloadWindow"  ? ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+            'reload',
+            "reload window"
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+            'restart extensions',
+            "restart extensions"
+        ));
         if (isUninstalled) {
             const canRemoveRunningExtension = runningExtension && this.extensionService.canRemoveExtension(runningExtension);
             const isSameExtensionRunning = runningExtension && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension)));
             if (!canRemoveRunningExtension && isSameExtensionRunning && !runningExtension.isUnderDevelopment) {
-                return ( localizeWithPath(
+                return { action: reloadAction, reason: ( localizeWithPath(
                     'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                     'postUninstallTooltip',
-                    "Please reload Visual Studio Code to complete the uninstallation of this extension."
-                ));
+                    "Please {0} to complete the uninstallation of this extension.",
+                    reloadActionLabel
+                )) };
             }
             return undefined;
         }
@@ -951,29 +1119,64 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                     const runningExtensionServer = this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension));
                     if (isSameExtensionRunning) {
                         if (!runningExtension.isUnderDevelopment && (extension.version !== runningExtension.version || extension.local.targetPlatform !== runningExtension.targetPlatform)) {
-                            return ( localizeWithPath(
+                            const productCurrentVersion = this.getProductCurrentVersion();
+                            const productUpdateVersion = this.getProductUpdateVersion();
+                            if (productUpdateVersion
+                                && !isEngineValid(extension.local.manifest.engines.vscode, productCurrentVersion.version, productCurrentVersion.date)
+                                && isEngineValid(extension.local.manifest.engines.vscode, productUpdateVersion.version, productUpdateVersion.date)) {
+                                const state = this.updateService.state;
+                                if (state.type === "available for download" ) {
+                                    return { action: "downloadUpdate" , reason: ( localizeWithPath(
+                                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                                        'postUpdateDownloadTooltip',
+                                        "Please update {0} to enable the updated extension.",
+                                        this.productService.nameLong
+                                    )) };
+                                }
+                                if (state.type === "downloaded" ) {
+                                    return { action: "applyUpdate" , reason: ( localizeWithPath(
+                                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                                        'postUpdateUpdateTooltip',
+                                        "Please update {0} to enable the updated extension.",
+                                        this.productService.nameLong
+                                    )) };
+                                }
+                                if (state.type === "ready" ) {
+                                    return { action: "quitAndInstall" , reason: ( localizeWithPath(
+                                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                                        'postUpdateRestartTooltip',
+                                        "Please restart {0} to enable the updated extension.",
+                                        this.productService.nameLong
+                                    )) };
+                                }
+                                return undefined;
+                            }
+                            return { action: reloadAction, reason: ( localizeWithPath(
                                 'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                                 'postUpdateTooltip',
-                                "Please reload Visual Studio Code to enable the updated extension."
-                            ));
+                                "Please {0} to enable the updated extension.",
+                                reloadActionLabel
+                            )) };
                         }
                         if (this.extensionsServers.length > 1) {
                             const extensionInOtherServer = this.installed.filter(e => areSameExtensions(e.identifier, extension.identifier) && e.server !== extension.server)[0];
                             if (extensionInOtherServer) {
                                 if (runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.localExtensionManagementServer) {
-                                    return ( localizeWithPath(
+                                    return { action: reloadAction, reason: ( localizeWithPath(
                                         'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                                         'enable locally',
-                                        "Please reload Visual Studio Code to enable this extension locally."
-                                    ));
+                                        "Please {0} to enable this extension locally.",
+                                        reloadActionLabel
+                                    )) };
                                 }
                                 if (runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.remoteExtensionManagementServer) {
-                                    return ( localizeWithPath(
+                                    return { action: reloadAction, reason: ( localizeWithPath(
                                         'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                                         'enable remote',
-                                        "Please reload Visual Studio Code to enable this extension in {0}.",
+                                        "Please {0} to enable this extension in {1}.",
+                                        reloadActionLabel,
                                         this.extensionManagementServerService.remoteExtensionManagementServer?.label
-                                    ));
+                                    )) };
                                 }
                             }
                         }
@@ -981,20 +1184,22 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                     else {
                         if (extension.server === this.extensionManagementServerService.localExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer) {
                             if (this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local.manifest)) {
-                                return ( localizeWithPath(
+                                return { action: reloadAction, reason: ( localizeWithPath(
                                     'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                                     'postEnableTooltip',
-                                    "Please reload Visual Studio Code to enable this extension."
-                                ));
+                                    "Please {0} to enable this extension.",
+                                    reloadActionLabel
+                                )) };
                             }
                         }
                         if (extension.server === this.extensionManagementServerService.remoteExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer) {
                             if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local.manifest)) {
-                                return ( localizeWithPath(
+                                return { action: reloadAction, reason: ( localizeWithPath(
                                     'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                                     'postEnableTooltip',
-                                    "Please reload Visual Studio Code to enable this extension."
-                                ));
+                                    "Please {0} to enable this extension.",
+                                    reloadActionLabel
+                                )) };
                             }
                         }
                     }
@@ -1002,32 +1207,35 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 }
                 else {
                     if (isSameExtensionRunning) {
-                        return ( localizeWithPath(
+                        return { action: reloadAction, reason: ( localizeWithPath(
                             'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                             'postDisableTooltip',
-                            "Please reload Visual Studio Code to disable this extension."
-                        ));
+                            "Please {0} to disable this extension.",
+                            reloadActionLabel
+                        )) };
                     }
                 }
                 return undefined;
             }
             else {
                 if (isEnabled && !this.extensionService.canAddExtension(toExtensionDescription(extension.local))) {
-                    return ( localizeWithPath(
+                    return { action: reloadAction, reason: ( localizeWithPath(
                         'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                         'postEnableTooltip',
-                        "Please reload Visual Studio Code to enable this extension."
-                    ));
+                        "Please {0} to enable this extension.",
+                        reloadActionLabel
+                    )) };
                 }
                 const otherServer = extension.server ? extension.server === this.extensionManagementServerService.localExtensionManagementServer ? this.extensionManagementServerService.remoteExtensionManagementServer : this.extensionManagementServerService.localExtensionManagementServer : null;
                 if (otherServer && extension.enablementState === 1 ) {
                     const extensionInOtherServer = this.local.filter(e => areSameExtensions(e.identifier, extension.identifier) && e.server === otherServer)[0];
                     if (extensionInOtherServer && extensionInOtherServer.local && this.extensionEnablementService.isEnabled(extensionInOtherServer.local)) {
-                        return ( localizeWithPath(
+                        return { action: reloadAction, reason: ( localizeWithPath(
                             'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
                             'postEnableTooltip',
-                            "Please reload Visual Studio Code to enable this extension."
-                        ));
+                            "Please {0} to enable this extension.",
+                            reloadActionLabel
+                        )) };
                     }
                 }
             }
@@ -1176,6 +1384,9 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             if (installed.isBuiltin && !installed.local?.pinned && (installed.type === 0  || !installed.local?.identifier.uuid)) {
                 continue;
             }
+            if (installed.local?.source === 'resource') {
+                continue;
+            }
             infos.push({ ...installed.identifier, preRelease: !!installed.local?.preRelease });
         }
         if (infos.length) {
@@ -1183,7 +1394,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             this.telemetryService.publicLog2('galleryService:checkingForUpdates', {
                 count: infos.length,
             });
-            const galleryExtensions = await this.galleryService.getExtensions(infos, { targetPlatform, compatible: true }, CancellationToken.None);
+            const galleryExtensions = await this.galleryService.getExtensions(infos, { targetPlatform, compatible: true, productVersion: this.getProductVersion() }, CancellationToken.None);
             if (galleryExtensions.length) {
                 await this.syncInstalledExtensionsWithGallery(galleryExtensions);
             }
@@ -1219,8 +1430,10 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (!extensions.length) {
             return;
         }
-        const result = await Promise.allSettled(( extensions.map(extensions => extensions.syncInstalledExtensionsWithGallery(gallery))));
-        if (this.isAutoUpdateEnabled() && ( result.some(r => r.status === 'fulfilled' && r.value))) {
+        await Promise.allSettled(( extensions.map(
+            extensions => extensions.syncInstalledExtensionsWithGallery(gallery, this.getProductVersion())
+        )));
+        if (this.isAutoUpdateEnabled()) {
             this.eventuallyAutoUpdateExtensions();
         }
     }
@@ -1235,12 +1448,19 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         return this.configurationService.getValue(AutoCheckUpdatesConfigurationKey);
     }
     eventuallyCheckForUpdates(immediate = false) {
+        this.updatesCheckDelayer.cancel();
         this.updatesCheckDelayer.trigger(async () => {
             if (this.isAutoUpdateEnabled() || this.isAutoCheckUpdatesEnabled()) {
                 await this.checkForUpdates();
             }
             this.eventuallyCheckForUpdates();
-        }, immediate ? 0 : ExtensionsWorkbenchService_1.UpdatesCheckInterval).then(undefined, err => null);
+        }, immediate ? 0 : this.getUpdatesCheckInterval()).then(undefined, err => null);
+    }
+    getUpdatesCheckInterval() {
+        if (this.productService.quality === 'insider' && this.getProductUpdateVersion()) {
+            return 1000 * 60 * 60 * 1;
+        }
+        return ExtensionsWorkbenchService_1.UpdatesCheckInterval;
     }
     eventuallyAutoUpdateExtensions() {
         this.autoUpdateDelayer.trigger(() => this.autoUpdateExtensions())
@@ -1272,10 +1492,34 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             return;
         }
         const toUpdate = this.outdated.filter(e => !e.local?.pinned && this.shouldAutoUpdateExtension(e));
+        if (!toUpdate.length) {
+            return;
+        }
+        const productVersion = this.getProductVersion();
         await Promises.settled(( toUpdate.map(
-            e => this.install(e, e.local?.preRelease ? { installPreReleaseVersion: true } : undefined)
+            e => this.install(e, e.local?.preRelease ? { installPreReleaseVersion: true, productVersion } : { productVersion })
         )));
     }
+    getProductVersion() {
+        return this.getProductUpdateVersion() ?? this.getProductCurrentVersion();
+    }
+    getProductCurrentVersion() {
+        return { version: this.productService.version, date: this.productService.date };
+    }
+    getProductUpdateVersion() {
+        switch (this.updateService.state.type) {
+            case "available for download" :
+            case "downloaded" :
+            case "updating" :
+            case "ready" : {
+                const version = this.updateService.state.update.productVersion;
+                if (version && semverExports.valid(version)) {
+                    return { version, date: this.updateService.state.update.timestamp ? ( new Date(this.updateService.state.update.timestamp)).toISOString() : undefined };
+                }
+            }
+        }
+        return undefined;
+    }
     async updateExtensionsPinnedState() {
         await Promise.all(( this.installed.map(async (e) => {
             if (e.isBuiltin) {
@@ -1423,33 +1667,196 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         if (extension.deprecationInfo?.disallowInstall) {
             return false;
         }
-        if (!extension.gallery) {
+        if (extension.gallery) {
+            if (this.localExtensions && (await this.localExtensions.canInstall(extension.gallery))) {
+                return true;
+            }
+            if (this.remoteExtensions && (await this.remoteExtensions.canInstall(extension.gallery))) {
+                return true;
+            }
+            if (this.webExtensions && (await this.webExtensions.canInstall(extension.gallery))) {
+                return true;
+            }
             return false;
         }
-        if (this.localExtensions && (await this.localExtensions.canInstall(extension.gallery))) {
-            return true;
-        }
-        if (this.remoteExtensions && (await this.remoteExtensions.canInstall(extension.gallery))) {
-            return true;
-        }
-        if (this.webExtensions && (await this.webExtensions.canInstall(extension.gallery))) {
+        if (extension.resourceExtension) {
             return true;
         }
         return false;
     }
-    install(extension, installOptions, progressLocation) {
-        return this.doInstall(extension, async () => {
-            if (extension instanceof URI) {
-                return this.installFromVSIX(extension, installOptions);
+    async install(arg, installOptions = {}, progressLocation) {
+        let installable;
+        let extension;
+        if (arg instanceof URI) {
+            installable = arg;
+        }
+        else {
+            let installableInfo;
+            let gallery;
+            if (isString(arg)) {
+                extension = this.local.find(e => areSameExtensions(e.identifier, { id: arg }));
+                if (!extension?.isBuiltin) {
+                    installableInfo = { id: arg, version: installOptions.version, preRelease: installOptions.installPreReleaseVersion ?? this.preferPreReleases };
+                }
+            }
+            else if (arg.gallery) {
+                extension = arg;
+                gallery = arg.gallery;
+                if (installOptions.version && installOptions.version !== gallery?.version) {
+                    installableInfo = { id: extension.identifier.id, version: installOptions.version };
+                }
+            }
+            else if (arg.resourceExtension) {
+                extension = arg;
+                installable = arg.resourceExtension;
             }
-            if (extension.isMalicious) {
+            if (installableInfo) {
+                const targetPlatform = extension?.server ? await extension.server.extensionManagementService.getTargetPlatform() : undefined;
+                gallery = firstOrDefault(await this.galleryService.getExtensions([installableInfo], { targetPlatform }, CancellationToken.None));
+            }
+            if (!extension && gallery) {
+                extension = this.instantiationService.createInstance(Extension, ext => this.getExtensionState(ext), ext => this.getRuntimeState(ext), undefined, undefined, gallery, undefined);
+                Extensions.updateExtensionFromControlManifest(extension, await this.extensionManagementService.getExtensionsControlManifest());
+            }
+            if (extension?.isMalicious) {
                 throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensionsWorkbenchService', 'malicious', "This extension is reported to be problematic."));
             }
-            if (!extension.gallery) {
-                throw new Error('Missing gallery');
+            if (!(installOptions.enable && extension?.local)) {
+                if (!installable) {
+                    if (!gallery) {
+                        const id = isString(arg) ? arg : arg.identifier.id;
+                        if (installOptions.version) {
+                            throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensionsWorkbenchService', 'not found version', "Unable to install extension '{0}' because the requested version '{1}' is not found.", id, installOptions.version));
+                        }
+                        else {
+                            throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensionsWorkbenchService', 'not found', "Unable to install extension '{0}' because it is not found.", id));
+                        }
+                    }
+                    installable = gallery;
+                }
+                if (installOptions.version) {
+                    installOptions.installGivenVersion = true;
+                }
+                if (extension?.isWorkspaceScoped) {
+                    installOptions.isWorkspaceScoped = true;
+                }
+            }
+        }
+        if (installable) {
+            if (installOptions.justification) {
+                const syncCheck = isUndefined(installOptions.isMachineScoped) && this.userDataSyncEnablementService.isEnabled() && this.userDataSyncEnablementService.isResourceEnabled("extensions" );
+                const buttons = [];
+                buttons.push({
+                    label: isString(installOptions.justification) || !installOptions.justification.action
+                        ? ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                        { key: 'installButtonLabel', comment: ['&& denotes a mnemonic'] },
+                        "&&Install Extension"
+                    ))
+                        : ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                        { key: 'installButtonLabelWithAction', comment: ['&& denotes a mnemonic'] },
+                        "&&Install Extension and {0}",
+                        installOptions.justification.action
+                    )), run: () => true
+                });
+                if (!extension) {
+                    buttons.push({ label: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                        'open',
+                        "Open Extension"
+                    )), run: () => { this.open(extension); return false; } });
+                }
+                const result = await this.dialogService.prompt({
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                        'installExtensionTitle',
+                        "Install Extension"
+                    )),
+                    message: extension ? ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                        'installExtensionMessage',
+                        "Would you like to install '{0}' extension from '{1}'?",
+                        extension.displayName,
+                        extension.publisherDisplayName
+                    )) : ( localizeWithPath(
+                        'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                        'installVSIXMessage',
+                        "Would you like to install the extension?"
+                    )),
+                    detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
+                    cancelButton: true,
+                    buttons,
+                    checkbox: syncCheck ? {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                            'sync extension',
+                            "Sync this extension"
+                        )),
+                        checked: true,
+                    } : undefined,
+                });
+                if (!result.result) {
+                    throw new CancellationError();
+                }
+                if (syncCheck) {
+                    installOptions.isMachineScoped = !result.checkboxChecked;
+                }
+            }
+            if (installable instanceof URI) {
+                extension = await this.doInstall(undefined, () => this.installFromVSIX(installable, installOptions), progressLocation);
+            }
+            else if (extension) {
+                if (extension.resourceExtension) {
+                    extension = await this.doInstall(extension, () => this.extensionManagementService.installResourceExtension(installable, installOptions), progressLocation);
+                }
+                else {
+                    extension = await this.doInstall(extension, () => this.installFromGallery(extension, installable, installOptions), progressLocation);
+                }
             }
-            return this.installFromGallery(extension, extension.gallery, installOptions);
-        }, progressLocation);
+        }
+        if (!extension) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensionsWorkbenchService', 'unknown', "Unable to install extension"));
+        }
+        if (installOptions.version) {
+            await this.updateAutoUpdateEnablementFor(extension, false);
+        }
+        if (installOptions.enable) {
+            if (extension.enablementState === 7  || extension.enablementState === 6 ) {
+                if (installOptions.justification) {
+                    const result = await this.dialogService.confirm({
+                        title: ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                            'enableExtensionTitle',
+                            "Enable Extension"
+                        )),
+                        message: ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                            'enableExtensionMessage',
+                            "Would you like to enable '{0}' extension?",
+                            extension.displayName
+                        )),
+                        detail: isString(installOptions.justification) ? installOptions.justification : installOptions.justification.reason,
+                        primaryButton: isString(installOptions.justification) ? ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                            { key: 'enableButtonLabel', comment: ['&& denotes a mnemonic'] },
+                            "&&Enable Extension"
+                        )) : ( localizeWithPath(
+                            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+                            { key: 'enableButtonLabelWithAction', comment: ['&& denotes a mnemonic'] },
+                            "&&Enable Extension and {0}",
+                            installOptions.justification.action
+                        )),
+                    });
+                    if (!result.confirmed) {
+                        throw new CancellationError();
+                    }
+                }
+                await this.setEnablement(extension, extension.enablementState === 7  ? 9  : 8 );
+            }
+            await this.waitUntilExtensionIsEnabled(extension);
+        }
+        return extension;
     }
     async installInServer(extension, server) {
         await this.doInstall(extension, async () => {
@@ -1525,22 +1932,6 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
             source: `${toUninstall.identifier.id}`
         }, () => this.extensionManagementService.uninstall(toUninstall).then(() => undefined));
     }
-    async installVersion(extension, version, installOptions = {}) {
-        extension = await this.doInstall(extension, async () => {
-            if (!extension.gallery) {
-                throw new Error('Missing gallery');
-            }
-            const targetPlatform = extension.server ? await extension.server.extensionManagementService.getTargetPlatform() : undefined;
-            const [gallery] = await this.galleryService.getExtensions([{ id: extension.gallery.identifier.id, version }], { targetPlatform }, CancellationToken.None);
-            if (!gallery) {
-                throw new Error(localizeWithPath('vs/workbench/contrib/extensions/browser/extensionsWorkbenchService', 'not found', "Unable to install extension '{0}' because the requested version '{1}' is not found.", extension.gallery.identifier.id, version));
-            }
-            installOptions.installGivenVersion = true;
-            return this.installFromGallery(extension, gallery, installOptions);
-        });
-        await this.updateAutoUpdateEnablementFor(extension, false);
-        return extension;
-    }
     reinstall(extension) {
         return this.doInstall(extension, () => {
             const ext = extension.local ? extension : this.local.filter(e => areSameExtensions(e.identifier, extension.identifier))[0];
@@ -1602,22 +1993,22 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         return extension;
     }
     doInstall(extension, installTask, progressLocation) {
-        const title = extension instanceof URI ? ( localizeWithPath(
-            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
-            'installing extension',
-            'Installing extension....'
-        )) : ( localizeWithPath(
+        const title = extension ? ( localizeWithPath(
             'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
             'installing named extension',
             "Installing '{0}' extension....",
             extension.displayName
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionsWorkbenchService',
+            'installing extension',
+            'Installing extension....'
         ));
         return this.withProgress({
             location: progressLocation ?? 5 ,
             title
         }, async () => {
             try {
-                if (!(extension instanceof URI)) {
+                if (extension) {
                     this.installing.push(extension);
                     this._onChange.fire(extension);
                 }
@@ -1625,7 +2016,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
                 return await this.waitAndGetInstalledExtension(local.identifier);
             }
             finally {
-                if (!(extension instanceof URI)) {
+                if (extension) {
                     this.installing = this.installing.filter(e => e !== extension);
                     this._onChange.fire(undefined);
                 }
@@ -1650,6 +2041,7 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         installOptions = installOptions ?? {};
         installOptions.pinned = extension.local?.pinned || !this.shouldAutoUpdateExtension(extension);
         if (extension.local) {
+            installOptions.productVersion = this.getProductVersion();
             return this.extensionManagementService.updateFromGallery(gallery, extension.local, installOptions);
         }
         else {
@@ -1667,6 +2059,27 @@ let ExtensionsWorkbenchService = class ExtensionsWorkbenchService extends Dispos
         }
         return installedExtension;
     }
+    async waitUntilExtensionIsEnabled(extension) {
+        if (this.extensionService.extensions.find(e => ExtensionIdentifier.equals(e.identifier, extension.identifier.id))) {
+            return;
+        }
+        if (!extension.local || !this.extensionService.canAddExtension(toExtensionDescription(extension.local))) {
+            return;
+        }
+        await ( new Promise((c, e) => {
+            const disposable = this.extensionService.onDidChangeExtensions(() => {
+                try {
+                    if (this.extensionService.extensions.find(e => ExtensionIdentifier.equals(e.identifier, extension.identifier.id))) {
+                        disposable.dispose();
+                        c();
+                    }
+                }
+                catch (error) {
+                    e(error);
+                }
+            });
+        }));
+    }
     promptAndSetEnablement(extensions, enablementState) {
         const enable = enablementState === 8  || enablementState === 9 ;
         if (enable) {
@@ -1928,7 +2341,11 @@ ExtensionsWorkbenchService = ExtensionsWorkbenchService_1 = ( __decorate([
     ( __param(21, ILifecycleService)),
     ( __param(22, IFileService)),
     ( __param(23, IUserDataProfileService)),
-    ( __param(24, IStorageService))
+    ( __param(24, IStorageService)),
+    ( __param(25, IDialogService)),
+    ( __param(26, IUserDataSyncEnablementService)),
+    ( __param(27, IUpdateService)),
+    ( __param(28, IUriIdentityService))
 ], ExtensionsWorkbenchService));
 
 export { Extension, ExtensionsWorkbenchService };