@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

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

@@ -0,0 +1,283 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { getLogs } from '../../../../platform/log/browser/log.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IRemoteAuthorityResolverService, RemoteAuthorityResolverError } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IWebExtensionsScannerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { WebWorkerExtensionHost } from './webWorkerExtensionHost.js';
+import { FetchFileSystemProvider } from './webWorkerFileSystemProvider.js';
+import { AbstractExtensionService, ResolvedExtensions, checkEnabledAndProposedAPI } from '../common/abstractExtensionService.js';
+import { extensionRunningPreferenceToString, extensionHostKindToString } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
+import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
+import { filterExtensionDescriptions } from '../common/extensionRunningLocationTracker.js';
+import { toExtensionDescription, ExtensionHostExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { dedupExtensions } from '../common/extensionsUtil.js';
+import { RemoteExtensionHost } from '../common/remoteExtensionHost.js';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
+import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var BrowserExtensionHostKindPicker_1;
+let ExtensionService = class ExtensionService extends AbstractExtensionService {
+    constructor(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(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;
+        this._userDataProfileService = _userDataProfileService;
+        this._workspaceTrustManagementService = _workspaceTrustManagementService;
+        this._remoteExplorerService = _remoteExplorerService;
+        lifecycleService.when(2 ).then(async () => {
+            await this._userDataInitializationService.initializeInstalledExtensions(this._instantiationService);
+            this._initialize();
+        });
+        this._initFetchFileSystem();
+    }
+    async _scanSingleExtension(extension) {
+        if (extension.location.scheme === Schemas.vscodeRemote) {
+            return this._remoteExtensionsScannerService.scanSingleExtension(extension.location, extension.type === 0 );
+        }
+        const scannedExtension = await this._webExtensionsScannerService.scanExistingExtension(extension.location, extension.type, this._userDataProfileService.currentProfile.extensionsResource);
+        if (scannedExtension) {
+            return toExtensionDescription(scannedExtension);
+        }
+        return null;
+    }
+    _initFetchFileSystem() {
+        const provider = ( new FetchFileSystemProvider());
+        this._register(this._fileService.registerProvider(Schemas.http, provider));
+        this._register(this._fileService.registerProvider(Schemas.https, provider));
+    }
+    async _scanWebExtensions() {
+        const system = [], user = [], development = [];
+        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.scanExtensionsUnderDevelopment().then(extensions => development.push(...( extensions.map(e => toExtensionDescription(e, true)))))
+            ]);
+        }
+        catch (error) {
+            this._logService.error(error);
+        }
+        return dedupExtensions(system, user, development, this._logService);
+    }
+    async _resolveExtensionsDefault() {
+        const [localExtensions, remoteExtensions] = await Promise.all([
+            this._scanWebExtensions(),
+            this._remoteExtensionsScannerService.scanExtensions()
+        ]);
+        return ( new ResolvedExtensions(
+            localExtensions,
+            remoteExtensions,
+             false,
+             true
+        ));
+    }
+    async _resolveExtensions() {
+        if (!this._browserEnvironmentService.expectsResolverExtension) {
+            return this._resolveExtensionsDefault();
+        }
+        const remoteAuthority = this._environmentService.remoteAuthority;
+        await this._workspaceTrustManagementService.workspaceResolved;
+        let resolverResult;
+        try {
+            resolverResult = await this._resolveAuthorityInitial(remoteAuthority);
+        }
+        catch (err) {
+            if (RemoteAuthorityResolverError.isHandled(err)) {
+                console.log(`Error handled: Not showing a notification for the error`);
+            }
+            this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
+            return this._resolveExtensionsDefault();
+        }
+        this._remoteAuthorityResolverService._setResolvedAuthority(resolverResult.authority, resolverResult.options);
+        this._remoteExplorerService.setTunnelInformation(resolverResult.tunnelInformation);
+        const connection = this._remoteAgentService.getConnection();
+        if (connection) {
+            connection.onDidStateChange(async (e) => {
+                if (e.type === 0 ) {
+                    this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
+                }
+            });
+            connection.onReconnecting(() => this._resolveAuthorityAgain());
+        }
+        return this._resolveExtensionsDefault();
+    }
+    async _onExtensionHostExit(code) {
+        this._doStopExtensionHosts();
+        const automatedWindow = window;
+        if (typeof automatedWindow.codeAutomationExit === 'function') {
+            automatedWindow.codeAutomationExit(code, await getLogs(this._fileService, this._environmentService));
+        }
+    }
+    async _resolveAuthority(remoteAuthority) {
+        return this._resolveAuthorityOnExtensionHosts(2 , remoteAuthority);
+    }
+};
+ExtensionService = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IBrowserWorkbenchEnvironmentService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, IWorkbenchExtensionEnablementService)),
+    ( __param(8, IFileService)),
+    ( __param(9, IProductService)),
+    ( __param(10, IWorkbenchExtensionManagementService)),
+    ( __param(11, IWorkspaceContextService)),
+    ( __param(12, IConfigurationService)),
+    ( __param(13, IExtensionManifestPropertiesService)),
+    ( __param(14, IWebExtensionsScannerService)),
+    ( __param(15, ILogService)),
+    ( __param(16, IRemoteAgentService)),
+    ( __param(17, IRemoteExtensionsScannerService)),
+    ( __param(18, ILifecycleService)),
+    ( __param(19, IRemoteAuthorityResolverService)),
+    ( __param(20, IUserDataInitializationService)),
+    ( __param(21, IUserDataProfileService)),
+    ( __param(22, IWorkspaceTrustManagementService)),
+    ( __param(23, IRemoteExplorerService)),
+    ( __param(24, IDialogService))
+], ExtensionService));
+let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
+    constructor(_extensionsProposedApi, _scanWebExtensions, _getExtensionRegistrySnapshotWhenReady, _instantiationService, _remoteAgentService, _remoteAuthorityResolverService, _extensionEnablementService, _logService) {
+        this._extensionsProposedApi = _extensionsProposedApi;
+        this._scanWebExtensions = _scanWebExtensions;
+        this._getExtensionRegistrySnapshotWhenReady = _getExtensionRegistrySnapshotWhenReady;
+        this._instantiationService = _instantiationService;
+        this._remoteAgentService = _remoteAgentService;
+        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
+        this._extensionEnablementService = _extensionEnablementService;
+        this._logService = _logService;
+    }
+    createExtensionHost(runningLocations, runningLocation, isInitialStart) {
+        switch (runningLocation.kind) {
+            case 1 : {
+                return null;
+            }
+            case 2 : {
+                const startup = ((isInitialStart ? 2  : 1) );
+                return this._instantiationService.createInstance(WebWorkerExtensionHost, runningLocation, startup, this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart));
+            }
+            case 3 : {
+                const remoteAgentConnection = this._remoteAgentService.getConnection();
+                if (remoteAgentConnection) {
+                    return this._instantiationService.createInstance(RemoteExtensionHost, runningLocation, this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority));
+                }
+                return null;
+            }
+        }
+    }
+    _createLocalExtensionHostDataProvider(runningLocations, desiredRunningLocation, isInitialStart) {
+        return {
+            getInitData: async () => {
+                if (isInitialStart) {
+                    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 extensions = ( new ExtensionHostExtensions(0, localExtensions, ( myExtensions.map(extension => extension.identifier))));
+                    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 };
+                }
+            }
+        };
+    }
+    _createRemoteExtensionHostDataProvider(runningLocations, remoteAuthority) {
+        return {
+            remoteAuthority: remoteAuthority,
+            getInitData: async () => {
+                const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
+                const remoteEnv = await this._remoteAgentService.getEnvironment();
+                if (!remoteEnv) {
+                    throw new Error('Cannot provide init data for remote extension host!');
+                }
+                const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, 3 );
+                const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
+                return {
+                    connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAuthority),
+                    pid: remoteEnv.pid,
+                    appRoot: remoteEnv.appRoot,
+                    extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
+                    globalStorageHome: remoteEnv.globalStorageHome,
+                    workspaceStorageHome: remoteEnv.workspaceStorageHome,
+                    extensions,
+                };
+            }
+        };
+    }
+};
+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) {
+        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)}`);
+        return result;
+    }
+    static pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
+        const result = [];
+        let canRunRemotely = false;
+        for (const extensionKind of extensionKinds) {
+            if (extensionKind === 'ui' && isInstalledRemotely) {
+                if (preference === 2 ) {
+                    return 3 ;
+                }
+                else {
+                    canRunRemotely = true;
+                }
+            }
+            if (extensionKind === 'workspace' && isInstalledRemotely) {
+                if (preference === 0  || preference === 2 ) {
+                    return 3 ;
+                }
+                else {
+                    result.push(3 );
+                }
+            }
+            if (extensionKind === 'web' && (isInstalledLocally || isInstalledRemotely)) {
+                if (preference === 0  || preference === 1 ) {
+                    return 2 ;
+                }
+                else {
+                    result.push(2 );
+                }
+            }
+        }
+        if (canRunRemotely) {
+            result.push(3 );
+        }
+        return (result.length > 0 ? result[0] : null);
+    }
+};
+BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = ( __decorate([
+    ( __param(0, ILogService))
+], BrowserExtensionHostKindPicker));
+
+export { BrowserExtensionHostFactory, BrowserExtensionHostKindPicker, ExtensionService };

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

@@ -0,0 +1,273 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { parentOriginHash } from 'monaco-editor/esm/vs/base/browser/iframe.js';
+import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { canceled, onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { COI, FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { ILogService, ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { isLoggingOnly } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { isMessageOfType, createMessageOfType, UIKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
+
+let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
+    constructor(runningLocation, startup, _initDataProvider, _telemetryService, _contextService, _labelService, _logService, _loggerService, _environmentService, _userDataProfilesService, _productService, _layoutService, _storageService) {
+        super();
+        this.runningLocation = runningLocation;
+        this.startup = startup;
+        this._initDataProvider = _initDataProvider;
+        this._telemetryService = _telemetryService;
+        this._contextService = _contextService;
+        this._labelService = _labelService;
+        this._logService = _logService;
+        this._loggerService = _loggerService;
+        this._environmentService = _environmentService;
+        this._userDataProfilesService = _userDataProfilesService;
+        this._productService = _productService;
+        this._layoutService = _layoutService;
+        this._storageService = _storageService;
+        this.remoteAuthority = null;
+        this.extensions = null;
+        this._onDidExit = this._register(( new Emitter()));
+        this.onExit = this._onDidExit.event;
+        this._isTerminating = false;
+        this._protocolPromise = null;
+        this._protocol = null;
+        this._extensionHostLogsLocation = joinPath(this._environmentService.extHostLogsPath, 'webWorker');
+    }
+    async _getWebWorkerExtensionHostIframeSrc() {
+        const suffixSearchParams = ( new URLSearchParams());
+        if (this._environmentService.debugExtensionHost && this._environmentService.debugRenderer) {
+            suffixSearchParams.set('debugged', '1');
+        }
+        COI.addSearchParam(suffixSearchParams, true, true);
+        const suffix = `?${( suffixSearchParams.toString())}`;
+        const iframeModulePath = 'vs/workbench/services/extensions/worker/webWorkerExtensionHostIframe.html';
+        if (platform.isWeb) {
+            const webEndpointUrlTemplate = this._productService.webEndpointUrlTemplate;
+            const commit = this._productService.commit;
+            const quality = this._productService.quality;
+            if (webEndpointUrlTemplate && commit && quality) {
+                const key = 'webWorkerExtensionHostIframeStableOriginUUID';
+                let stableOriginUUID = this._storageService.get(key, 1 );
+                if (typeof stableOriginUUID === 'undefined') {
+                    stableOriginUUID = generateUuid();
+                    this._storageService.store(key, stableOriginUUID, 1 , 1 );
+                }
+                const hash = await parentOriginHash(window.origin, stableOriginUUID);
+                const baseUrl = (webEndpointUrlTemplate
+                    .replace('{{uuid}}', `v--${hash}`)
+                    .replace('{{commit}}', commit)
+                    .replace('{{quality}}', quality));
+                const res = ( new URL(`${baseUrl}/out/${iframeModulePath}${suffix}`));
+                res.searchParams.set('parentOrigin', window.origin);
+                res.searchParams.set('salt', stableOriginUUID);
+                return ( res.toString());
+            }
+        }
+        const relativeExtensionHostIframeSrc = ( FileAccess.asBrowserUri(iframeModulePath));
+        return `${( relativeExtensionHostIframeSrc.toString(true))}${suffix}`;
+    }
+    async start() {
+        if (!this._protocolPromise) {
+            this._protocolPromise = this._startInsideIframe();
+            this._protocolPromise.then(protocol => this._protocol = protocol);
+        }
+        return this._protocolPromise;
+    }
+    async _startInsideIframe() {
+        const webWorkerExtensionHostIframeSrc = await this._getWebWorkerExtensionHostIframeSrc();
+        const emitter = this._register(( new Emitter()));
+        const iframe = document.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;');
+        iframe.setAttribute('aria-hidden', 'true');
+        iframe.style.display = 'none';
+        const vscodeWebWorkerExtHostId = generateUuid();
+        iframe.setAttribute('src', `${webWorkerExtensionHostIframeSrc}&vscodeWebWorkerExtHostId=${vscodeWebWorkerExtHostId}`);
+        const barrier = ( new Barrier());
+        let port;
+        let barrierError = null;
+        let barrierHasError = false;
+        let startTimeout = null;
+        const rejectBarrier = (exitCode, error) => {
+            barrierError = error;
+            barrierHasError = true;
+            onUnexpectedError(barrierError);
+            clearTimeout(startTimeout);
+            this._onDidExit.fire([81 , barrierError.message]);
+            barrier.open();
+        };
+        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.`);
+        }, 60000);
+        this._register(dom.addDisposableListener(window, 'message', (event) => {
+            if (event.source !== iframe.contentWindow) {
+                return;
+            }
+            if (event.data.vscodeWebWorkerExtHostId !== vscodeWebWorkerExtHostId) {
+                return;
+            }
+            if (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(81 , err);
+            }
+            const { data } = event.data;
+            if (barrier.isOpen() || !(data instanceof MessagePort)) {
+                console.warn('UNEXPECTED message', event);
+                const err = ( new Error('UNEXPECTED message'));
+                return rejectBarrier(81 , err);
+            }
+            resolveBarrier(data);
+        }));
+        this._layoutService.container.appendChild(iframe);
+        this._register(toDisposable(() => iframe.remove()));
+        await barrier.wait();
+        if (barrierHasError) {
+            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;
+            if (!(data instanceof ArrayBuffer)) {
+                console.warn('UNKNOWN data received', data);
+                this._onDidExit.fire([77, 'UNKNOWN data received']);
+                return;
+            }
+            emitter.fire(VSBuffer.wrap(( new Uint8Array(data, 0, data.byteLength))));
+        };
+        const protocol = {
+            onMessage: emitter.event,
+            send: vsbuf => {
+                const data = vsbuf.buffer.buffer.slice(vsbuf.buffer.byteOffset, vsbuf.buffer.byteOffset + vsbuf.buffer.byteLength);
+                port.postMessage(data, [data]);
+            }
+        };
+        return this._performHandshake(protocol);
+    }
+    async _performHandshake(protocol) {
+        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 1 )));
+        if (this._isTerminating) {
+            throw canceled();
+        }
+        protocol.send(VSBuffer.fromString(JSON.stringify(await this._createExtHostInitData())));
+        if (this._isTerminating) {
+            throw canceled();
+        }
+        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 0 )));
+        if (this._isTerminating) {
+            throw canceled();
+        }
+        return protocol;
+    }
+    dispose() {
+        if (this._isTerminating) {
+            return;
+        }
+        this._isTerminating = true;
+        this._protocol?.send(createMessageOfType(2 ));
+        super.dispose();
+    }
+    getInspectPort() {
+        return undefined;
+    }
+    enableInspectPort() {
+        return Promise.resolve(false);
+    }
+    async _createExtHostInitData() {
+        const initData = await this._initDataProvider.getInitData();
+        this.extensions = initData.extensions;
+        const workspace = this._contextService.getWorkspace();
+        const nlsBaseUrl = this._productService.extensionsGallery?.nlsBaseUrl;
+        let nlsUrlWithDetails = undefined;
+        if (nlsBaseUrl && this._productService.commit && !platform.Language.isDefaultVariant()) {
+            nlsUrlWithDetails = URI.joinPath(( URI.parse(nlsBaseUrl)), this._productService.commit, this._productService.version, platform.Language.value());
+        }
+        return {
+            commit: this._productService.commit,
+            version: this._productService.version,
+            quality: this._productService.quality,
+            parentPid: 0,
+            environment: {
+                isExtensionDevelopmentDebug: this._environmentService.debugRenderer,
+                appName: this._productService.nameLong,
+                appHost: this._productService.embedderIdentifier ?? (platform.isWeb ? 'web' : 'desktop'),
+                appUriScheme: this._productService.urlProtocol,
+                appLanguage: platform.language,
+                extensionTelemetryLogResource: this._environmentService.extHostTelemetryLogFile,
+                isExtensionTelemetryLoggingOnly: isLoggingOnly(this._productService, this._environmentService),
+                extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
+                extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
+                globalStorageHome: this._userDataProfilesService.defaultProfile.globalStorageHome,
+                workspaceStorageHome: this._environmentService.workspaceStorageHome,
+                extensionLogLevel: this._environmentService.extensionLogLevel
+            },
+            workspace: this._contextService.getWorkbenchState() === 1  ? undefined : {
+                configuration: workspace.configuration || undefined,
+                id: workspace.id,
+                name: this._labelService.getWorkspaceLabel(workspace),
+                transient: workspace.transient
+            },
+            consoleForward: {
+                includeStack: false,
+                logNative: this._environmentService.debugRenderer
+            },
+            extensions: this.extensions.toSnapshot(),
+            nlsBaseUrl: nlsUrlWithDetails,
+            telemetryInfo: {
+                sessionId: this._telemetryService.sessionId,
+                machineId: this._telemetryService.machineId,
+                firstSessionDate: this._telemetryService.firstSessionDate,
+                msftInternal: this._telemetryService.msftInternal
+            },
+            logLevel: this._logService.getLevel(),
+            loggers: [...this._loggerService.getRegisteredLoggers()],
+            logsLocation: this._extensionHostLogsLocation,
+            autoStart: ((this.startup === 1) ),
+            remote: {
+                authority: this._environmentService.remoteAuthority,
+                connectionData: null,
+                isRemote: false
+            },
+            uiKind: platform.isWeb ? UIKind.Web : UIKind.Desktop
+        };
+    }
+};
+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))
+], WebWorkerExtensionHost));
+
+export { WebWorkerExtensionHost };

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

@@ -0,0 +1,52 @@
+import { FileSystemProviderErrorCode, createFileSystemProviderError, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { NotSupportedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+
+class FetchFileSystemProvider {
+    constructor() {
+        this.capabilities = 2048  + 2  + 1024 ;
+        this.onDidChangeCapabilities = Event.None;
+        this.onDidChangeFile = Event.None;
+    }
+    async readFile(resource) {
+        try {
+            const res = await fetch(( resource.toString(true)));
+            if (res.status === 200) {
+                return ( new Uint8Array(await res.arrayBuffer()));
+            }
+            throw createFileSystemProviderError(res.statusText, FileSystemProviderErrorCode.Unknown);
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+    }
+    async stat(_resource) {
+        return {
+            type: FileType.File,
+            size: 0,
+            mtime: 0,
+            ctime: 0
+        };
+    }
+    watch() {
+        return Disposable.None;
+    }
+    writeFile(_resource, _content, _opts) {
+        throw new NotSupportedError();
+    }
+    readdir(_resource) {
+        throw new NotSupportedError();
+    }
+    mkdir(_resource) {
+        throw new NotSupportedError();
+    }
+    delete(_resource, _opts) {
+        throw new NotSupportedError();
+    }
+    rename(_from, _to, _opts) {
+        throw new NotSupportedError();
+    }
+}
+
+export { FetchFileSystemProvider };