@codingame/monaco-vscode-extensions-service-override 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.js

@@ -40,8 +40,57 @@ import { AsyncIterableProducer } from '@codingame/monaco-vscode-api/vscode/vs/ba
 
 var BrowserExtensionHostKindPicker_1;
 let ExtensionService = class ExtensionService extends AbstractExtensionService {
-    constructor(options, extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, _webExtensionsScannerService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, _userDataInitializationService, _userDataProfileService, _workspaceTrustManagementService, _remoteExplorerService, dialogService) {
-        super(options, extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, dialogService);
+    constructor(
+        options,
+        extensionsProposedApi,
+        extensionHostFactory,
+        extensionHostKindPicker,
+        instantiationService,
+        notificationService,
+        _browserEnvironmentService,
+        telemetryService,
+        extensionEnablementService,
+        fileService,
+        productService,
+        extensionManagementService,
+        contextService,
+        configurationService,
+        extensionManifestPropertiesService,
+        _webExtensionsScannerService,
+        logService,
+        remoteAgentService,
+        remoteExtensionsScannerService,
+        lifecycleService,
+        remoteAuthorityResolverService,
+        _userDataInitializationService,
+        _userDataProfileService,
+        _workspaceTrustManagementService,
+        _remoteExplorerService,
+        dialogService
+    ) {
+        super(
+            options,
+            extensionsProposedApi,
+            extensionHostFactory,
+            extensionHostKindPicker,
+            instantiationService,
+            notificationService,
+            _browserEnvironmentService,
+            telemetryService,
+            extensionEnablementService,
+            fileService,
+            productService,
+            extensionManagementService,
+            contextService,
+            configurationService,
+            extensionManifestPropertiesService,
+            logService,
+            remoteAgentService,
+            remoteExtensionsScannerService,
+            lifecycleService,
+            remoteAuthorityResolverService,
+            dialogService
+        );
         this._browserEnvironmentService = _browserEnvironmentService;
         this._webExtensionsScannerService = _webExtensionsScannerService;
         this._userDataInitializationService = _userDataInitializationService;
@@ -69,11 +118,12 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
                 try {
                     await Promise.all([
                         this._webExtensionsScannerService.scanSystemExtensions().then(extensions => system.push(...( extensions.map(e => toExtensionDescription(e))))),
-                        this._webExtensionsScannerService.scanUserExtensions(this._userDataProfileService.currentProfile.extensionsResource, { skipInvalidExtensions: true }).then(extensions => user.push(...( extensions.map(e => toExtensionDescription(e))))),
+                        this._webExtensionsScannerService.scanUserExtensions(this._userDataProfileService.currentProfile.extensionsResource, {
+                            skipInvalidExtensions: true
+                        }).then(extensions => user.push(...( extensions.map(e => toExtensionDescription(e))))),
                         this._webExtensionsScannerService.scanExtensionsUnderDevelopment().then(extensions => development.push(...( extensions.map(e => toExtensionDescription(e, true)))))
                     ]);
-                }
-                catch (error) {
+                } catch (error) {
                     this._logService.error(error);
                 }
                 return dedupExtensions(system, user, [], development, this._logService);
@@ -108,8 +158,7 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
         let resolverResult;
         try {
             resolverResult = await this._resolveAuthorityInitial(remoteAuthority);
-        }
-        catch (err) {
+        } catch (err) {
             if (RemoteAuthorityResolverError.isHandled(err)) {
                 console.log(`Error handled: Not showing a notification for the error`);
             }
@@ -120,7 +169,7 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
         this._remoteExplorerService.setTunnelInformation(resolverResult.tunnelInformation);
         const connection = this._remoteAgentService.getConnection();
         if (connection) {
-            this._register(connection.onDidStateChange(async (e) => {
+            this._register(connection.onDidStateChange(async e => {
                 if (e.type === PersistentConnectionEventType.ConnectionLost) {
                     this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
                 }
@@ -132,7 +181,7 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
     async _onExtensionHostExit(code) {
         await this._doStopExtensionHosts();
         const automatedWindow = mainWindow;
-        if (typeof automatedWindow.codeAutomationExit === 'function') {
+        if (typeof automatedWindow.codeAutomationExit === "function") {
             automatedWindow.codeAutomationExit(code, await getLogs(this._fileService, this._environmentService));
         }
     }
@@ -140,32 +189,18 @@ let ExtensionService = class ExtensionService extends AbstractExtensionService {
         return this._resolveAuthorityOnExtensionHosts(ExtensionHostKind.LocalWebWorker, remoteAuthority);
     }
 };
-ExtensionService = ( __decorate([
-    ( __param(4, IInstantiationService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IBrowserWorkbenchEnvironmentService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, IWorkbenchExtensionEnablementService)),
-    ( __param(9, IFileService)),
-    ( __param(10, IProductService)),
-    ( __param(11, IWorkbenchExtensionManagementService)),
-    ( __param(12, IWorkspaceContextService)),
-    ( __param(13, IConfigurationService)),
-    ( __param(14, IExtensionManifestPropertiesService)),
-    ( __param(15, IWebExtensionsScannerService)),
-    ( __param(16, ILogService)),
-    ( __param(17, IRemoteAgentService)),
-    ( __param(18, IRemoteExtensionsScannerService)),
-    ( __param(19, ILifecycleService)),
-    ( __param(20, IRemoteAuthorityResolverService)),
-    ( __param(21, IUserDataInitializationService)),
-    ( __param(22, IUserDataProfileService)),
-    ( __param(23, IWorkspaceTrustManagementService)),
-    ( __param(24, IRemoteExplorerService)),
-    ( __param(25, IDialogService))
-], ExtensionService));
+ExtensionService = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, INotificationService)), ( __param(6, IBrowserWorkbenchEnvironmentService)), ( __param(7, ITelemetryService)), ( __param(8, IWorkbenchExtensionEnablementService)), ( __param(9, IFileService)), ( __param(10, IProductService)), ( __param(11, IWorkbenchExtensionManagementService)), ( __param(12, IWorkspaceContextService)), ( __param(13, IConfigurationService)), ( __param(14, IExtensionManifestPropertiesService)), ( __param(15, IWebExtensionsScannerService)), ( __param(16, ILogService)), ( __param(17, IRemoteAgentService)), ( __param(18, IRemoteExtensionsScannerService)), ( __param(19, ILifecycleService)), ( __param(20, IRemoteAuthorityResolverService)), ( __param(21, IUserDataInitializationService)), ( __param(22, IUserDataProfileService)), ( __param(23, IWorkspaceTrustManagementService)), ( __param(24, IRemoteExplorerService)), ( __param(25, IDialogService))], ExtensionService));
 let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
-    constructor(_extensionsProposedApi, _scanWebExtensions, _getExtensionRegistrySnapshotWhenReady, _instantiationService, _remoteAgentService, _remoteAuthorityResolverService, _extensionEnablementService, _logService) {
+    constructor(
+        _extensionsProposedApi,
+        _scanWebExtensions,
+        _getExtensionRegistrySnapshotWhenReady,
+        _instantiationService,
+        _remoteAgentService,
+        _remoteAuthorityResolverService,
+        _extensionEnablementService,
+        _logService
+    ) {
         this._extensionsProposedApi = _extensionsProposedApi;
         this._scanWebExtensions = _scanWebExtensions;
         this._getExtensionRegistrySnapshotWhenReady = _getExtensionRegistrySnapshotWhenReady;
@@ -177,19 +212,29 @@ let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
     }
     createExtensionHost(runningLocations, runningLocation, isInitialStart) {
         switch (runningLocation.kind) {
-            case ExtensionHostKind.LocalProcess: {
+        case ExtensionHostKind.LocalProcess:
+            {
                 return null;
             }
-            case ExtensionHostKind.LocalWebWorker: {
-                const startup = (isInitialStart
-                    ? ExtensionHostStartup.EagerManualStart
-                    : ExtensionHostStartup.EagerAutoStart);
-                return this._instantiationService.createInstance(WebWorkerExtensionHost, runningLocation, startup, this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart));
+        case ExtensionHostKind.LocalWebWorker:
+            {
+                const startup = (isInitialStart ? ExtensionHostStartup.EagerManualStart : ExtensionHostStartup.EagerAutoStart);
+                return this._instantiationService.createInstance(
+                    WebWorkerExtensionHost,
+                    runningLocation,
+                    startup,
+                    this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart)
+                );
             }
-            case ExtensionHostKind.Remote: {
+        case ExtensionHostKind.Remote:
+            {
                 const remoteAgentConnection = this._remoteAgentService.getConnection();
                 if (remoteAgentConnection) {
-                    return this._instantiationService.createInstance(RemoteExtensionHost, runningLocation, this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority));
+                    return this._instantiationService.createInstance(
+                        RemoteExtensionHost,
+                        runningLocation,
+                        this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority)
+                    );
                 }
                 return null;
             }
@@ -199,17 +244,30 @@ let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
         return {
             getInitData: async () => {
                 if (isInitialStart) {
-                    const localExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, await this._scanWebExtensions(),  true);
+                    const localExtensions = checkEnabledAndProposedAPI(
+                        this._logService,
+                        this._extensionEnablementService,
+                        this._extensionsProposedApi,
+                        await this._scanWebExtensions(),
+                         true
+                    );
                     const runningLocation = runningLocations.computeRunningLocation(localExtensions, [], false);
-                    const myExtensions = filterExtensionDescriptions(localExtensions, runningLocation, extRunningLocation => desiredRunningLocation.equals(extRunningLocation));
+                    const myExtensions = filterExtensionDescriptions(
+                        localExtensions,
+                        runningLocation,
+                        extRunningLocation => desiredRunningLocation.equals(extRunningLocation)
+                    );
                     const extensions = ( new ExtensionHostExtensions(0, localExtensions, ( myExtensions.map(extension => extension.identifier))));
-                    return { extensions };
-                }
-                else {
+                    return {
+                        extensions
+                    };
+                } else {
                     const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
                     const myExtensions = runningLocations.filterByRunningLocation(snapshot.extensions, desiredRunningLocation);
                     const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
-                    return { extensions };
+                    return {
+                        extensions
+                    };
                 }
             }
         };
@@ -221,7 +279,7 @@ let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
                 const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
                 const remoteEnv = await this._remoteAgentService.getEnvironment();
                 if (!remoteEnv) {
-                    throw ( new Error('Cannot provide init data for remote extension host!'));
+                    throw ( new Error("Cannot provide init data for remote extension host!"));
                 }
                 const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, ExtensionHostKind.Remote);
                 const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
@@ -232,53 +290,52 @@ let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
                     extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
                     globalStorageHome: remoteEnv.globalStorageHome,
                     workspaceStorageHome: remoteEnv.workspaceStorageHome,
-                    extensions,
+                    extensions
                 };
             }
         };
     }
 };
-BrowserExtensionHostFactory = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IRemoteAgentService)),
-    ( __param(5, IRemoteAuthorityResolverService)),
-    ( __param(6, IWorkbenchExtensionEnablementService)),
-    ( __param(7, ILogService))
-], BrowserExtensionHostFactory));
+BrowserExtensionHostFactory = ( __decorate([( __param(3, IInstantiationService)), ( __param(4, IRemoteAgentService)), ( __param(5, IRemoteAuthorityResolverService)), ( __param(6, IWorkbenchExtensionEnablementService)), ( __param(7, ILogService))], BrowserExtensionHostFactory));
 let BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = class BrowserExtensionHostKindPicker {
     constructor(_logService) {
         this._logService = _logService;
     }
-    pickExtensionHostKind(extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
+    pickExtensionHostKind(
+        extensionId,
+        extensionKinds,
+        isInstalledLocally,
+        isInstalledRemotely,
+        preference
+    ) {
         const result = BrowserExtensionHostKindPicker_1.pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference);
-        this._logService.trace(`pickRunningLocation for ${extensionId.value}, extension kinds: [${extensionKinds.join(', ')}], isInstalledLocally: ${isInstalledLocally}, isInstalledRemotely: ${isInstalledRemotely}, preference: ${extensionRunningPreferenceToString(preference)} => ${extensionHostKindToString(result)}`);
+        this._logService.trace(
+            `pickRunningLocation for ${extensionId.value}, extension kinds: [${extensionKinds.join(", ")}], isInstalledLocally: ${isInstalledLocally}, isInstalledRemotely: ${isInstalledRemotely}, preference: ${extensionRunningPreferenceToString(preference)} => ${extensionHostKindToString(result)}`
+        );
         return result;
     }
     static pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
         const result = [];
         let canRunRemotely = false;
         for (const extensionKind of extensionKinds) {
-            if (extensionKind === 'ui' && isInstalledRemotely) {
+            if (extensionKind === "ui" && isInstalledRemotely) {
                 if (preference === ExtensionRunningPreference.Remote) {
                     return ExtensionHostKind.Remote;
-                }
-                else {
+                } else {
                     canRunRemotely = true;
                 }
             }
-            if (extensionKind === 'workspace' && isInstalledRemotely) {
+            if (extensionKind === "workspace" && isInstalledRemotely) {
                 if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Remote) {
                     return ExtensionHostKind.Remote;
-                }
-                else {
+                } else {
                     result.push(ExtensionHostKind.Remote);
                 }
             }
-            if (extensionKind === 'web' && (isInstalledLocally || isInstalledRemotely)) {
+            if (extensionKind === "web" && (isInstalledLocally || isInstalledRemotely)) {
                 if (preference === ExtensionRunningPreference.None || preference === ExtensionRunningPreference.Local) {
                     return ExtensionHostKind.LocalWebWorker;
-                }
-                else {
+                } else {
                     result.push(ExtensionHostKind.LocalWebWorker);
                 }
             }
@@ -289,8 +346,6 @@ let BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = class Br
         return (result.length > 0 ? result[0] : null);
     }
 };
-BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = ( __decorate([
-    ( __param(0, ILogService))
-], BrowserExtensionHostKindPicker));
+BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = ( __decorate([( __param(0, ILogService))], BrowserExtensionHostKindPicker));
 
 export { BrowserExtensionHostFactory, BrowserExtensionHostKindPicker, ExtensionService };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.js

@@ -13,7 +13,7 @@ import { isWeb, Language, language } from '@codingame/monaco-vscode-api/vscode/v
 import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
-import '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getNLSLanguage, getNLSMessages } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
 import { ILogService, ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
@@ -31,10 +31,25 @@ import { IBrowserWorkbenchEnvironmentService } from '@codingame/monaco-vscode-ap
 import { IDefaultLogLevelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/log/common/defaultLogLevels.service';
 import { ExtensionHostExitCode, isMessageOfType, MessageType, createMessageOfType, UIKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
 import { ExtensionHostStartup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
-import { getNLSLanguage, getNLSMessages } from '@codingame/monaco-vscode-api/vscode/vs/nls.messages';
 
 let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
-    constructor(runningLocation, startup, _initDataProvider, _telemetryService, _contextService, _labelService, _logService, _loggerService, _environmentService, _userDataProfilesService, _productService, _layoutService, _storageService, _webWorkerService, _defaultLogLevelsService) {
+    constructor(
+        runningLocation,
+        startup,
+        _initDataProvider,
+        _telemetryService,
+        _contextService,
+        _labelService,
+        _logService,
+        _loggerService,
+        _environmentService,
+        _userDataProfilesService,
+        _productService,
+        _layoutService,
+        _storageService,
+        _webWorkerService,
+        _defaultLogLevelsService
+    ) {
         super();
         this.runningLocation = runningLocation;
         this.startup = startup;
@@ -59,15 +74,15 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         this._isTerminating = false;
         this._protocolPromise = null;
         this._protocol = null;
-        this._extensionHostLogsLocation = joinPath(this._environmentService.extHostLogsPath, 'webWorker');
+        this._extensionHostLogsLocation = joinPath(this._environmentService.extHostLogsPath, "webWorker");
     }
     async _getWebWorkerExtensionHostIframeSrc() {
         const suffixSearchParams = ( new URLSearchParams());
         if (this._environmentService.debugExtensionHost && this._environmentService.debugRenderer) {
-            suffixSearchParams.set('debugged', '1');
+            suffixSearchParams.set("debugged", "1");
         }
         COI.addSearchParam(suffixSearchParams, true, true);
-        suffixSearchParams.set('parentOrigin', mainWindow.origin);
+        suffixSearchParams.set("parentOrigin", mainWindow.origin);
         const suffix = `?${( suffixSearchParams.toString())}`;
         const iframeModulePath = `vs/workbench/services/extensions/worker/webWorkerExtensionHostIframe.html`;
         if (isWeb) {
@@ -75,26 +90,24 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             const commit = this._productService.commit;
             const quality = this._productService.quality;
             if (webEndpointUrlTemplate && commit && quality) {
-                const key = 'webWorkerExtensionHostIframeStableOriginUUID';
+                const key = "webWorkerExtensionHostIframeStableOriginUUID";
                 let stableOriginUUID = this._storageService.get(key, StorageScope.WORKSPACE);
-                if (typeof stableOriginUUID === 'undefined') {
+                if (typeof stableOriginUUID === "undefined") {
                     stableOriginUUID = generateUuid();
                     this._storageService.store(key, stableOriginUUID, StorageScope.WORKSPACE, StorageTarget.MACHINE);
                 }
                 const hash = await parentOriginHash(mainWindow.origin, stableOriginUUID);
-                const baseUrl = (webEndpointUrlTemplate
-                    .replace('{{uuid}}', `v--${hash}`)
-                    .replace('{{commit}}', commit)
-                    .replace('{{quality}}', quality));
+                const baseUrl = (
+                webEndpointUrlTemplate.replace("{{uuid}}", `v--${hash}`).replace("{{commit}}", commit).replace("{{quality}}", quality));
                 const res = ( new URL(`${baseUrl}/out/${iframeModulePath}${suffix}`));
-                res.searchParams.set('salt', stableOriginUUID);
+                res.searchParams.set("salt", stableOriginUUID);
                 return ( res.toString());
             }
         }
         const relativeExtensionHostIframeSrc = this._webWorkerService.getWorkerUrl(( new WebWorkerDescriptor({
             esmModuleLocation: ( FileAccess.asBrowserUri(iframeModulePath)),
             esmModuleLocationBundler: ( new URL(`../worker/webWorkerExtensionHostIframe.html`, import.meta.url)),
-            label: 'webWorkerExtensionHostIframe'
+            label: "webWorkerExtensionHostIframe"
         })));
         return `${relativeExtensionHostIframeSrc}${suffix}`;
     }
@@ -108,14 +121,17 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
     async _startInsideIframe() {
         const webWorkerExtensionHostIframeSrc = await this._getWebWorkerExtensionHostIframeSrc();
         const emitter = this._register(( new Emitter()));
-        const iframe = createElement('iframe');
-        iframe.setAttribute('class', 'web-worker-ext-host-iframe');
-        iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
-        iframe.setAttribute('allow', 'usb; serial; hid; cross-origin-isolated; local-network-access;');
-        iframe.setAttribute('aria-hidden', 'true');
-        iframe.style.display = 'none';
+        const iframe = createElement("iframe");
+        iframe.setAttribute("class", "web-worker-ext-host-iframe");
+        iframe.setAttribute("sandbox", "allow-scripts allow-same-origin");
+        iframe.setAttribute("allow", "usb; serial; hid; cross-origin-isolated; local-network-access;");
+        iframe.setAttribute("aria-hidden", "true");
+        iframe.style.display = "none";
         const vscodeWebWorkerExtHostId = generateUuid();
-        iframe.setAttribute('src', `${webWorkerExtensionHostIframeSrc}&vscodeWebWorkerExtHostId=${vscodeWebWorkerExtHostId}`);
+        iframe.setAttribute(
+            "src",
+            `${webWorkerExtensionHostIframeSrc}&vscodeWebWorkerExtHostId=${vscodeWebWorkerExtHostId}`
+        );
         const barrier = ( new Barrier());
         let port;
         let barrierError = null;
@@ -129,15 +145,17 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             this._onDidExit.fire([ExtensionHostExitCode.UnexpectedError, barrierError.message]);
             barrier.open();
         };
-        const resolveBarrier = (messagePort) => {
+        const resolveBarrier = messagePort => {
             port = messagePort;
             clearTimeout(startTimeout);
             barrier.open();
         };
         startTimeout = setTimeout(() => {
-            console.warn(`The Web Worker Extension Host did not start in 60s, that might be a problem.`);
+            console.warn(
+                `The Web Worker Extension Host did not start in 60s, that might be a problem.`
+            );
         }, 60000);
-        this._register(addDisposableListener(mainWindow, 'message', (event) => {
+        this._register(addDisposableListener(mainWindow, "message", event => {
             if (event.source !== iframe.contentWindow) {
                 return;
             }
@@ -145,14 +163,18 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                 return;
             }
             if (event.data.error) {
-                const { name, message, stack } = event.data.error;
+                const {
+                    name,
+                    message,
+                    stack
+                } = event.data.error;
                 const err = ( new Error());
                 err.message = message;
                 err.name = name;
                 err.stack = stack;
                 return rejectBarrier(ExtensionHostExitCode.UnexpectedError, err);
             }
-            if (event.data.type === 'vscode.bootstrap.nls') {
+            if (event.data.type === "vscode.bootstrap.nls") {
                 iframe.contentWindow.postMessage({
                     type: event.data.type,
                     data: {
@@ -164,13 +186,15 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                             language: getNLSLanguage()
                         }
                     }
-                }, '*');
+                }, "*");
                 return;
             }
-            const { data } = event.data;
+            const {
+                data
+            } = event.data;
             if (barrier.isOpen() || !(data instanceof mainWindow.MessagePort)) {
-                console.warn('UNEXPECTED message', event);
-                const err = ( new Error('UNEXPECTED message'));
+                console.warn("UNEXPECTED message", event);
+                const err = ( new Error("UNEXPECTED message"));
                 return rejectBarrier(ExtensionHostExitCode.UnexpectedError, err);
             }
             resolveBarrier(data);
@@ -182,12 +206,17 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             throw barrierError;
         }
         const messagePorts = this._environmentService.options?.messagePorts ?? ( new Map());
-        iframe.contentWindow.postMessage({ type: 'vscode.init', data: messagePorts }, '*', [...( messagePorts.values())]);
-        port.onmessage = (event) => {
-            const { data } = event;
+        iframe.contentWindow.postMessage({
+            type: "vscode.init",
+            data: messagePorts
+        }, "*", [...( messagePorts.values())]);
+        port.onmessage = event => {
+            const {
+                data
+            } = event;
             if (!(data instanceof mainWindow.ArrayBuffer)) {
-                console.warn('UNKNOWN data received', data);
-                this._onDidExit.fire([77, 'UNKNOWN data received']);
+                console.warn("UNKNOWN data received", data);
+                this._onDidExit.fire([77, "UNKNOWN data received"]);
                 return;
             }
             emitter.fire(VSBuffer.wrap(new mainWindow.Uint8Array(data, 0, data.byteLength)));
@@ -202,7 +231,9 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         return this._performHandshake(protocol);
     }
     async _performHandshake(protocol) {
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Ready)));
+        await Event.toPromise(
+            Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Ready))
+        );
         if (this._isTerminating) {
             throw canceled();
         }
@@ -210,7 +241,9 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         if (this._isTerminating) {
             throw canceled();
         }
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Initialized)));
+        await Event.toPromise(
+            Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Initialized))
+        );
         if (this._isTerminating) {
             throw canceled();
         }
@@ -248,10 +281,11 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             environment: {
                 isExtensionDevelopmentDebug: this._environmentService.debugRenderer,
                 appName: this._productService.nameLong,
-                appHost: this._productService.embedderIdentifier ?? (isWeb ? 'web' : 'desktop'),
+                appHost: this._productService.embedderIdentifier ?? (isWeb ? "web" : "desktop"),
                 appUriScheme: this._productService.urlProtocol,
                 appLanguage: language,
                 isExtensionTelemetryLoggingOnly: isLoggingOnly(this._productService, this._environmentService),
+                isPortable: false,
                 extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
                 extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
                 globalStorageHome: this._userDataProfilesService.defaultProfile.globalStorageHome,
@@ -262,7 +296,8 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                 configuration: workspace.configuration || undefined,
                 id: workspace.id,
                 name: this._labelService.getWorkspaceLabel(workspace),
-                transient: workspace.transient
+                transient: workspace.transient,
+                isAgentSessionsWorkspace: workspace.isAgentSessionsWorkspace
             },
             consoleForward: {
                 includeStack: false,
@@ -293,22 +328,9 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         };
     }
 };
-WebWorkerExtensionHost = ( __decorate([
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, ILogService)),
-    ( __param(7, ILoggerService)),
-    ( __param(8, IBrowserWorkbenchEnvironmentService)),
-    ( __param(9, IUserDataProfilesService)),
-    ( __param(10, IProductService)),
-    ( __param(11, ILayoutService)),
-    ( __param(12, IStorageService)),
-    ( __param(13, IWebWorkerService)),
-    ( __param(14, IDefaultLogLevelsService))
-], WebWorkerExtensionHost));
+WebWorkerExtensionHost = ( __decorate([( __param(3, ITelemetryService)), ( __param(4, IWorkspaceContextService)), ( __param(5, ILabelService)), ( __param(6, ILogService)), ( __param(7, ILoggerService)), ( __param(8, IBrowserWorkbenchEnvironmentService)), ( __param(9, IUserDataProfilesService)), ( __param(10, IProductService)), ( __param(11, ILayoutService)), ( __param(12, IStorageService)), ( __param(13, IWebWorkerService)), ( __param(14, IDefaultLogLevelsService))], WebWorkerExtensionHost));
 const extensionHostWorkerMainDescriptor = ( new WebWorkerDescriptor({
-    label: 'extensionHostWorkerMain'
+    label: "extensionHostWorkerMain"
 }));
 
 export { WebWorkerExtensionHost };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerFileSystemProvider.js

@@ -17,8 +17,7 @@ class FetchFileSystemProvider {
                 return ( new Uint8Array(await res.arrayBuffer()));
             }
             throw createFileSystemProviderError(res.statusText, FileSystemProviderErrorCode.Unknown);
-        }
-        catch (err) {
+        } catch (err) {
             throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
         }
     }

package/vscode/src/vs/workbench/services/extensions/common/abstractExtensionService.d.ts

@@ -71,6 +71,7 @@ export declare abstract class AbstractExtensionService extends Disposable implem
     private readonly _installedExtensionsReady;
     private readonly _extensionStatus;
     private readonly _allRequestedActivateEvents;
+    private readonly _pendingRemoteActivationEvents;
     private readonly _runningLocations;
     private readonly _remoteCrashTracker;
     private _deltaExtensionsQueue;
@@ -93,6 +94,7 @@ export declare abstract class AbstractExtensionService extends Disposable implem
     private _initializePromise;
     protected _initializeIfNeeded(): Promise<void> | null;
     protected _initialize(): Promise<void>;
+    private _activateDeferredRemoteEvents;
     private _resolveAndProcessExtensions;
     private _handleExtensionTests;
     private findTestExtensionHost;