@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

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

@@ -0,0 +1,58 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IRemoteUserDataProfilesService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles';
+import { ProfileAwareExtensionManagementChannelClient } from './extensionManagementChannelClient.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+
+let RemoteExtensionManagementService = class RemoteExtensionManagementService extends ProfileAwareExtensionManagementChannelClient {
+    constructor(channel, userDataProfileService, userDataProfilesService, remoteUserDataProfilesService, uriIdentityService) {
+        super(channel, userDataProfileService, uriIdentityService);
+        this.userDataProfilesService = userDataProfilesService;
+        this.remoteUserDataProfilesService = remoteUserDataProfilesService;
+    }
+    async filterEvent(e) {
+        if (e.applicationScoped) {
+            return true;
+        }
+        if (!e.profileLocation && this.userDataProfileService.currentProfile.isDefault) {
+            return true;
+        }
+        const currentRemoteProfile = await this.remoteUserDataProfilesService.getRemoteProfile(this.userDataProfileService.currentProfile);
+        if (this.uriIdentityService.extUri.isEqual(currentRemoteProfile.extensionsResource, e.profileLocation)) {
+            return true;
+        }
+        return false;
+    }
+    async getProfileLocation(profileLocation) {
+        if (!profileLocation && this.userDataProfileService.currentProfile.isDefault) {
+            return undefined;
+        }
+        profileLocation = await super.getProfileLocation(profileLocation);
+        let profile = this.userDataProfilesService.profiles.find(p => this.uriIdentityService.extUri.isEqual(p.extensionsResource, profileLocation));
+        if (profile) {
+            profile = await this.remoteUserDataProfilesService.getRemoteProfile(profile);
+        }
+        else {
+            profile = (await this.remoteUserDataProfilesService.getRemoteProfiles()).find(p => this.uriIdentityService.extUri.isEqual(p.extensionsResource, profileLocation));
+        }
+        return profile?.extensionsResource;
+    }
+    async switchExtensionsProfile(previousProfileLocation, currentProfileLocation, preserveExtensions) {
+        const remoteProfiles = await this.remoteUserDataProfilesService.getRemoteProfiles();
+        const previousProfile = remoteProfiles.find(p => this.uriIdentityService.extUri.isEqual(p.extensionsResource, previousProfileLocation));
+        const currentProfile = remoteProfiles.find(p => this.uriIdentityService.extUri.isEqual(p.extensionsResource, currentProfileLocation));
+        if (previousProfile?.id === currentProfile?.id) {
+            return { added: [], removed: [] };
+        }
+        return super.switchExtensionsProfile(previousProfileLocation, currentProfileLocation, preserveExtensions);
+    }
+};
+RemoteExtensionManagementService = ( __decorate([
+    ( __param(1, IUserDataProfileService)),
+    ( __param(2, IUserDataProfilesService)),
+    ( __param(3, IRemoteUserDataProfilesService)),
+    ( __param(4, IUriIdentityService))
+], RemoteExtensionManagementService));
+
+export { RemoteExtensionManagementService };

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

@@ -0,0 +1,269 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { getGalleryExtensionId, areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IWebExtensionsScannerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { AbstractExtensionManagementService, toExtensionManagementError, AbstractExtensionTask } from '../../../../platform/extensionManagement/common/abstractExtensionManagementService.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { isUndefined, isBoolean } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { delta } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+let WebExtensionManagementService = class WebExtensionManagementService extends AbstractExtensionManagementService {
+    get onProfileAwareInstallExtension() { return super.onInstallExtension; }
+    get onInstallExtension() { return Event.filter(this.onProfileAwareInstallExtension, e => this.filterEvent(e), this.disposables); }
+    get onProfileAwareDidInstallExtensions() { return super.onDidInstallExtensions; }
+    get onDidInstallExtensions() {
+        return Event.filter(( Event.map(
+            this.onProfileAwareDidInstallExtensions,
+            results => results.filter(e => this.filterEvent(e)),
+            this.disposables
+        )), results => results.length > 0, this.disposables);
+    }
+    get onProfileAwareUninstallExtension() { return super.onUninstallExtension; }
+    get onUninstallExtension() { return Event.filter(this.onProfileAwareUninstallExtension, e => this.filterEvent(e), this.disposables); }
+    get onProfileAwareDidUninstallExtension() { return super.onDidUninstallExtension; }
+    get onDidUninstallExtension() { return Event.filter(this.onProfileAwareDidUninstallExtension, e => this.filterEvent(e), this.disposables); }
+    constructor(extensionGalleryService, telemetryService, logService, webExtensionsScannerService, extensionManifestPropertiesService, userDataProfileService, productService, userDataProfilesService, uriIdentityService) {
+        super(extensionGalleryService, telemetryService, uriIdentityService, logService, productService, userDataProfilesService);
+        this.webExtensionsScannerService = webExtensionsScannerService;
+        this.extensionManifestPropertiesService = extensionManifestPropertiesService;
+        this.userDataProfileService = userDataProfileService;
+        this.disposables = this._register(( new DisposableStore()));
+        this._onDidChangeProfile = this._register(( new Emitter()));
+        this.onDidChangeProfile = this._onDidChangeProfile.event;
+        this._register(userDataProfileService.onDidChangeCurrentProfile(e => {
+            if (!this.uriIdentityService.extUri.isEqual(e.previous.extensionsResource, e.profile.extensionsResource)) {
+                e.join(this.whenProfileChanged(e));
+            }
+        }));
+    }
+    filterEvent({ profileLocation, applicationScoped }) {
+        profileLocation = profileLocation ?? this.userDataProfileService.currentProfile.extensionsResource;
+        return applicationScoped || this.uriIdentityService.extUri.isEqual(this.userDataProfileService.currentProfile.extensionsResource, profileLocation);
+    }
+    async getTargetPlatform() {
+        return "web" ;
+    }
+    async canInstall(gallery) {
+        if (await super.canInstall(gallery)) {
+            return true;
+        }
+        if (this.isConfiguredToExecuteOnWeb(gallery)) {
+            return true;
+        }
+        return false;
+    }
+    async getInstalled(type, profileLocation) {
+        const extensions = [];
+        if (type === undefined || type === 0 ) {
+            const systemExtensions = await this.webExtensionsScannerService.scanSystemExtensions();
+            extensions.push(...systemExtensions);
+        }
+        if (type === undefined || type === 1 ) {
+            const userExtensions = await this.webExtensionsScannerService.scanUserExtensions(profileLocation ?? this.userDataProfileService.currentProfile.extensionsResource);
+            extensions.push(...userExtensions);
+        }
+        return ( extensions.map(e => toLocalExtension(e)));
+    }
+    async install(location, options = {}) {
+        this.logService.trace('ExtensionManagementService#install', ( location.toString()));
+        const manifest = await this.webExtensionsScannerService.scanExtensionManifest(location);
+        if (!manifest) {
+            throw new Error(`Cannot find packageJSON from the location ${location.toString()}`);
+        }
+        const result = await this.installExtensions([{ manifest, extension: location, options }]);
+        if (result[0]?.local) {
+            return result[0]?.local;
+        }
+        if (result[0]?.error) {
+            throw result[0].error;
+        }
+        throw toExtensionManagementError(new Error(`Unknown error while installing extension ${getGalleryExtensionId(manifest.publisher, manifest.name)}`));
+    }
+    installFromLocation(location, profileLocation) {
+        return this.install(location, { profileLocation });
+    }
+    async copyExtension(extension, fromProfileLocation, toProfileLocation, metadata) {
+        const target = await this.webExtensionsScannerService.scanExistingExtension(extension.location, extension.type, toProfileLocation);
+        const source = await this.webExtensionsScannerService.scanExistingExtension(extension.location, extension.type, fromProfileLocation);
+        metadata = { ...source?.metadata, ...metadata };
+        let scanned;
+        if (target) {
+            scanned = await this.webExtensionsScannerService.updateMetadata(extension, { ...target.metadata, ...metadata }, toProfileLocation);
+        }
+        else {
+            scanned = await this.webExtensionsScannerService.addExtension(extension.location, metadata, toProfileLocation);
+        }
+        return toLocalExtension(scanned);
+    }
+    async installExtensionsFromProfile(extensions, fromProfileLocation, toProfileLocation) {
+        const result = [];
+        const extensionsToInstall = (await this.webExtensionsScannerService.scanUserExtensions(fromProfileLocation))
+            .filter(e => ( extensions.some(id => areSameExtensions(id, e.identifier))));
+        if (extensionsToInstall.length) {
+            await Promise.allSettled(( extensionsToInstall.map(async (e) => {
+                let local = await this.installFromLocation(e.location, toProfileLocation);
+                if (e.metadata) {
+                    local = await this.updateMetadata(local, e.metadata, fromProfileLocation);
+                }
+                result.push(local);
+            })));
+        }
+        return result;
+    }
+    async updateMetadata(local, metadata, profileLocation) {
+        metadata.isMachineScoped = metadata.isMachineScoped || undefined;
+        metadata.isBuiltin = metadata.isBuiltin || undefined;
+        metadata.pinned = metadata.pinned || undefined;
+        const updatedExtension = await this.webExtensionsScannerService.updateMetadata(local, metadata, profileLocation ?? this.userDataProfileService.currentProfile.extensionsResource);
+        const updatedLocalExtension = toLocalExtension(updatedExtension);
+        this._onDidUpdateExtensionMetadata.fire(updatedLocalExtension);
+        return updatedLocalExtension;
+    }
+    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);
+        if (compatibleExtension) {
+            return compatibleExtension;
+        }
+        if (this.isConfiguredToExecuteOnWeb(extension)) {
+            return extension;
+        }
+        return null;
+    }
+    isConfiguredToExecuteOnWeb(gallery) {
+        const configuredExtensionKind = this.extensionManifestPropertiesService.getUserConfiguredExtensionKind(gallery.identifier);
+        return !!configuredExtensionKind && configuredExtensionKind.includes('web');
+    }
+    getCurrentExtensionsManifestLocation() {
+        return this.userDataProfileService.currentProfile.extensionsResource;
+    }
+    createInstallExtensionTask(manifest, extension, options) {
+        return ( new InstallExtensionTask(
+            manifest,
+            extension,
+            options,
+            this.webExtensionsScannerService,
+            this.userDataProfilesService
+        ));
+    }
+    createUninstallExtensionTask(extension, options) {
+        return ( new UninstallExtensionTask(extension, options, this.webExtensionsScannerService));
+    }
+    zip(extension) { throw new Error('unsupported'); }
+    unzip(zipLocation) { throw new Error('unsupported'); }
+    getManifest(vsix) { throw new Error('unsupported'); }
+    download() { throw new Error('unsupported'); }
+    reinstallFromGallery() { throw new Error('unsupported'); }
+    async cleanUp() { }
+    async whenProfileChanged(e) {
+        const previousProfileLocation = e.previous.extensionsResource;
+        const currentProfileLocation = e.profile.extensionsResource;
+        if (!previousProfileLocation || !currentProfileLocation) {
+            throw new Error('This should not happen');
+        }
+        const oldExtensions = await this.webExtensionsScannerService.scanUserExtensions(previousProfileLocation);
+        const newExtensions = await this.webExtensionsScannerService.scanUserExtensions(currentProfileLocation);
+        const { added, removed } = delta(oldExtensions, newExtensions, (a, b) => compare(`${ExtensionIdentifier.toKey(a.identifier.id)}@${a.manifest.version}`, `${ExtensionIdentifier.toKey(b.identifier.id)}@${b.manifest.version}`));
+        this._onDidChangeProfile.fire({ added: ( added.map(e => toLocalExtension(e))), removed: ( removed.map(e => toLocalExtension(e))) });
+    }
+};
+WebExtensionManagementService = ( __decorate([
+    ( __param(0, IExtensionGalleryService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IWebExtensionsScannerService)),
+    ( __param(4, IExtensionManifestPropertiesService)),
+    ( __param(5, IUserDataProfileService)),
+    ( __param(6, IProductService)),
+    ( __param(7, IUserDataProfilesService)),
+    ( __param(8, IUriIdentityService))
+], WebExtensionManagementService));
+function toLocalExtension(extension) {
+    const metadata = getMetadata(undefined, extension);
+    return {
+        ...extension,
+        identifier: { id: extension.identifier.id, uuid: metadata.id ?? extension.identifier.uuid },
+        isMachineScoped: !!metadata.isMachineScoped,
+        isApplicationScoped: !!metadata.isApplicationScoped,
+        publisherId: metadata.publisherId || null,
+        publisherDisplayName: metadata.publisherDisplayName || null,
+        installedTimestamp: metadata.installedTimestamp,
+        isPreReleaseVersion: !!metadata.isPreReleaseVersion,
+        preRelease: !!metadata.preRelease,
+        targetPlatform: "web" ,
+        updated: !!metadata.updated,
+        pinned: !!metadata?.pinned,
+    };
+}
+function getMetadata(options, existingExtension) {
+    const metadata = { ...(existingExtension?.metadata || {}) };
+    metadata.isMachineScoped = options?.isMachineScoped || metadata.isMachineScoped;
+    return metadata;
+}
+class InstallExtensionTask extends AbstractExtensionTask {
+    get profileLocation() { return this._profileLocation; }
+    get operation() { return isUndefined(this.options.operation) ? this._operation : this.options.operation; }
+    constructor(manifest, extension, options, webExtensionsScannerService, userDataProfilesService) {
+        super();
+        this.extension = extension;
+        this.options = options;
+        this.webExtensionsScannerService = webExtensionsScannerService;
+        this.userDataProfilesService = userDataProfilesService;
+        this._profileLocation = this.options.profileLocation;
+        this._operation = 2 ;
+        this.identifier = URI.isUri(extension) ? { id: getGalleryExtensionId(manifest.publisher, manifest.name) } : extension.identifier;
+        this.source = extension;
+    }
+    async doRun(token) {
+        const userExtensions = await this.webExtensionsScannerService.scanUserExtensions(this.options.profileLocation);
+        const existingExtension = userExtensions.find(e => areSameExtensions(e.identifier, this.identifier));
+        if (existingExtension) {
+            this._operation = 3 ;
+        }
+        const metadata = getMetadata(this.options, existingExtension);
+        if (!URI.isUri(this.extension)) {
+            metadata.id = this.extension.identifier.uuid;
+            metadata.publisherDisplayName = this.extension.publisherDisplayName;
+            metadata.publisherId = this.extension.publisherId;
+            metadata.installedTimestamp = Date.now();
+            metadata.isPreReleaseVersion = this.extension.properties.isPreReleaseVersion;
+            metadata.isBuiltin = this.options.isBuiltin || existingExtension?.isBuiltin;
+            metadata.isSystem = existingExtension?.type === 0  ? true : undefined;
+            metadata.updated = !!existingExtension;
+            metadata.isApplicationScoped = this.options.isApplicationScoped || metadata.isApplicationScoped;
+            metadata.preRelease = this.extension.properties.isPreReleaseVersion ||
+                ((isBoolean(this.options.installPreReleaseVersion) ? this.options.installPreReleaseVersion  : metadata?.preRelease) );
+        }
+        metadata.pinned = this.options.installGivenVersion ? true : undefined;
+        this._profileLocation = metadata.isApplicationScoped ? this.userDataProfilesService.defaultProfile.extensionsResource : this.options.profileLocation;
+        const scannedExtension = URI.isUri(this.extension) ? await this.webExtensionsScannerService.addExtension(this.extension, metadata, this.profileLocation)
+            : await this.webExtensionsScannerService.addExtensionFromGallery(this.extension, metadata, this.profileLocation);
+        return toLocalExtension(scannedExtension);
+    }
+}
+class UninstallExtensionTask extends AbstractExtensionTask {
+    constructor(extension, options, webExtensionsScannerService) {
+        super();
+        this.extension = extension;
+        this.options = options;
+        this.webExtensionsScannerService = webExtensionsScannerService;
+    }
+    doRun(token) {
+        return this.webExtensionsScannerService.removeExtension(this.extension, this.options.profileLocation);
+    }
+}
+
+export { WebExtensionManagementService };

package/vscode/src/vs/workbench/services/extensionRecommendations/common/extensionIgnoredRecommendationsService.js

@@ -0,0 +1,83 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IWorkspaceExtensionsConfigService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/workspaceExtensionsConfig';
+
+const ignoredRecommendationsStorageKey = 'extensionsAssistant/ignored_recommendations';
+let ExtensionIgnoredRecommendationsService = class ExtensionIgnoredRecommendationsService extends Disposable {
+    get globalIgnoredRecommendations() { return [...this._globalIgnoredRecommendations]; }
+    get ignoredRecommendations() { return distinct([...this.globalIgnoredRecommendations, ...this.ignoredWorkspaceRecommendations]); }
+    constructor(workspaceExtensionsConfigService, storageService) {
+        super();
+        this.workspaceExtensionsConfigService = workspaceExtensionsConfigService;
+        this.storageService = storageService;
+        this._onDidChangeIgnoredRecommendations = this._register(( new Emitter()));
+        this.onDidChangeIgnoredRecommendations = this._onDidChangeIgnoredRecommendations.event;
+        this._globalIgnoredRecommendations = [];
+        this._onDidChangeGlobalIgnoredRecommendation = this._register(( new Emitter()));
+        this.onDidChangeGlobalIgnoredRecommendation = this._onDidChangeGlobalIgnoredRecommendation.event;
+        this.ignoredWorkspaceRecommendations = [];
+        this._globalIgnoredRecommendations = this.getCachedIgnoredRecommendations();
+        this._register(this.storageService.onDidChangeValue(0 , ignoredRecommendationsStorageKey, this._register(( new DisposableStore())))(e => this.onDidStorageChange()));
+        this.initIgnoredWorkspaceRecommendations();
+    }
+    async initIgnoredWorkspaceRecommendations() {
+        this.ignoredWorkspaceRecommendations = await this.workspaceExtensionsConfigService.getUnwantedRecommendations();
+        this._onDidChangeIgnoredRecommendations.fire();
+        this._register(this.workspaceExtensionsConfigService.onDidChangeExtensionsConfigs(async () => {
+            this.ignoredWorkspaceRecommendations = await this.workspaceExtensionsConfigService.getUnwantedRecommendations();
+            this._onDidChangeIgnoredRecommendations.fire();
+        }));
+    }
+    toggleGlobalIgnoredRecommendation(extensionId, shouldIgnore) {
+        extensionId = extensionId.toLowerCase();
+        const ignored = this._globalIgnoredRecommendations.indexOf(extensionId) !== -1;
+        if (ignored === shouldIgnore) {
+            return;
+        }
+        this._globalIgnoredRecommendations = shouldIgnore ? [...this._globalIgnoredRecommendations, extensionId] : this._globalIgnoredRecommendations.filter(id => id !== extensionId);
+        this.storeCachedIgnoredRecommendations(this._globalIgnoredRecommendations);
+        this._onDidChangeGlobalIgnoredRecommendation.fire({ extensionId, isRecommended: !shouldIgnore });
+        this._onDidChangeIgnoredRecommendations.fire();
+    }
+    getCachedIgnoredRecommendations() {
+        const ignoredRecommendations = JSON.parse(this.ignoredRecommendationsValue);
+        return ( ignoredRecommendations.map(e => e.toLowerCase()));
+    }
+    onDidStorageChange() {
+        if (this.ignoredRecommendationsValue !== this.getStoredIgnoredRecommendationsValue() ) {
+            this._ignoredRecommendationsValue = undefined;
+            this._globalIgnoredRecommendations = this.getCachedIgnoredRecommendations();
+            this._onDidChangeIgnoredRecommendations.fire();
+        }
+    }
+    storeCachedIgnoredRecommendations(ignoredRecommendations) {
+        this.ignoredRecommendationsValue = JSON.stringify(ignoredRecommendations);
+    }
+    get ignoredRecommendationsValue() {
+        if (!this._ignoredRecommendationsValue) {
+            this._ignoredRecommendationsValue = this.getStoredIgnoredRecommendationsValue();
+        }
+        return this._ignoredRecommendationsValue;
+    }
+    set ignoredRecommendationsValue(ignoredRecommendationsValue) {
+        if (this.ignoredRecommendationsValue !== ignoredRecommendationsValue) {
+            this._ignoredRecommendationsValue = ignoredRecommendationsValue;
+            this.setStoredIgnoredRecommendationsValue(ignoredRecommendationsValue);
+        }
+    }
+    getStoredIgnoredRecommendationsValue() {
+        return this.storageService.get(ignoredRecommendationsStorageKey, 0 , '[]');
+    }
+    setStoredIgnoredRecommendationsValue(value) {
+        this.storageService.store(ignoredRecommendationsStorageKey, value, 0 , 0 );
+    }
+};
+ExtensionIgnoredRecommendationsService = ( __decorate([
+    ( __param(0, IWorkspaceExtensionsConfigService)),
+    ( __param(1, IStorageService))
+], ExtensionIgnoredRecommendationsService));
+
+export { ExtensionIgnoredRecommendationsService };

package/vscode/src/vs/workbench/services/remote/common/remoteExtensionsScanner.js

@@ -0,0 +1,73 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { RemoteExtensionsScannerChannelName } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IRemoteUserDataProfilesService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IActiveLanguagePackService } from 'vscode/vscode/vs/workbench/services/localization/common/locale';
+
+let RemoteExtensionsScannerService = class RemoteExtensionsScannerService {
+    constructor(remoteAgentService, environmentService, userDataProfileService, remoteUserDataProfilesService, logService, activeLanguagePackService) {
+        this.remoteAgentService = remoteAgentService;
+        this.environmentService = environmentService;
+        this.userDataProfileService = userDataProfileService;
+        this.remoteUserDataProfilesService = remoteUserDataProfilesService;
+        this.logService = logService;
+        this.activeLanguagePackService = activeLanguagePackService;
+    }
+    whenExtensionsReady() {
+        return this.withChannel(channel => channel.call('whenExtensionsReady'), undefined);
+    }
+    async scanExtensions() {
+        try {
+            const languagePack = await this.activeLanguagePackService.getExtensionIdProvidingCurrentLocale();
+            return await this.withChannel(async (channel) => {
+                const profileLocation = this.userDataProfileService.currentProfile.isDefault ? undefined : (await this.remoteUserDataProfilesService.getRemoteProfile(this.userDataProfileService.currentProfile)).extensionsResource;
+                const scannedExtensions = await channel.call('scanExtensions', [platform.language, profileLocation, this.environmentService.extensionDevelopmentLocationURI, languagePack]);
+                scannedExtensions.forEach((extension) => {
+                    extension.extensionLocation = URI.revive(extension.extensionLocation);
+                });
+                return scannedExtensions;
+            }, []);
+        }
+        catch (error) {
+            this.logService.error(error);
+            return [];
+        }
+    }
+    async scanSingleExtension(extensionLocation, isBuiltin) {
+        try {
+            return await this.withChannel(async (channel) => {
+                const extension = await channel.call('scanSingleExtension', [extensionLocation, isBuiltin, platform.language]);
+                if (extension !== null) {
+                    extension.extensionLocation = URI.revive(extension.extensionLocation);
+                }
+                return extension;
+            }, null);
+        }
+        catch (error) {
+            this.logService.error(error);
+            return null;
+        }
+    }
+    withChannel(callback, fallback) {
+        const connection = this.remoteAgentService.getConnection();
+        if (!connection) {
+            return Promise.resolve(fallback);
+        }
+        return connection.withChannel(RemoteExtensionsScannerChannelName, (channel) => callback(channel));
+    }
+};
+RemoteExtensionsScannerService = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IUserDataProfileService)),
+    ( __param(3, IRemoteUserDataProfilesService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IActiveLanguagePackService))
+], RemoteExtensionsScannerService));
+
+export { RemoteExtensionsScannerService };