@codingame/monaco-vscode-extensions-service-override 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.js

@@ -0,0 +1,223 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { MainContext, ExtHostContext, CandidatePortSource } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { TunnelDtoConverter } from 'vscode/vscode/vs/workbench/api/common/extHostTunnelService';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
+import { ITunnelService, TunnelProtocol } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { INotificationService, Severity } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { TunnelSource, TunnelCloseReason, forwardedPortsViewEnabled, makeAddress } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
+
+let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
+    constructor(extHostContext, remoteExplorerService, tunnelService, notificationService, configurationService, logService, remoteAgentService, contextKeyService) {
+        super();
+        this.remoteExplorerService = remoteExplorerService;
+        this.tunnelService = tunnelService;
+        this.notificationService = notificationService;
+        this.configurationService = configurationService;
+        this.logService = logService;
+        this.remoteAgentService = remoteAgentService;
+        this.contextKeyService = contextKeyService;
+        this.elevateionRetry = false;
+        this.portsAttributesProviders = ( new Map());
+        this._alreadyRegistered = false;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTunnelService));
+        this._register(tunnelService.onTunnelOpened(() => this._proxy.$onDidTunnelsChange()));
+        this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
+    }
+    processFindingEnabled() {
+        return (!!this.configurationService.getValue(PORT_AUTO_FORWARD_SETTING) || this.tunnelService.hasTunnelProvider)
+            && (this.configurationService.getValue(PORT_AUTO_SOURCE_SETTING) !== PORT_AUTO_SOURCE_SETTING_OUTPUT);
+    }
+    async $setRemoteTunnelService(processId) {
+        this.remoteExplorerService.namedProcesses.set(processId, 'Code Extension Host');
+        if (this.remoteExplorerService.portsFeaturesEnabled) {
+            this._proxy.$registerCandidateFinder(this.processFindingEnabled());
+        }
+        else {
+            this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.processFindingEnabled())));
+        }
+        this._register(this.configurationService.onDidChangeConfiguration(async (e) => {
+            if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING)) {
+                return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
+            }
+        }));
+        this._register(this.tunnelService.onAddedTunnelProvider(() => {
+            return this._proxy.$registerCandidateFinder(this.processFindingEnabled());
+        }));
+    }
+    async $registerPortsAttributesProvider(selector, providerHandle) {
+        this.portsAttributesProviders.set(providerHandle, selector);
+        if (!this._alreadyRegistered) {
+            this.remoteExplorerService.tunnelModel.addAttributesProvider(this);
+            this._alreadyRegistered = true;
+        }
+    }
+    async $unregisterPortsAttributesProvider(providerHandle) {
+        this.portsAttributesProviders.delete(providerHandle);
+    }
+    async providePortAttributes(ports, pid, commandLine, token) {
+        if (this.portsAttributesProviders.size === 0) {
+            return [];
+        }
+        const appropriateHandles = ( Array.from(this.portsAttributesProviders.entries()).filter(entry => {
+            const selector = entry[1];
+            const portRange = (typeof selector.portRange === 'number') ? [selector.portRange, selector.portRange + 1] : selector.portRange;
+            const portInRange = portRange ? ( ports.some(port => portRange[0] <= port && port < portRange[1])) : true;
+            const commandMatches = !selector.commandPattern || (commandLine && (commandLine.match(selector.commandPattern)));
+            return portInRange && commandMatches;
+        }).map(entry => entry[0]));
+        if (appropriateHandles.length === 0) {
+            return [];
+        }
+        return this._proxy.$providePortAttributes(appropriateHandles, ports, pid, commandLine, token);
+    }
+    async $openTunnel(tunnelOptions, source) {
+        const tunnel = await this.remoteExplorerService.forward({
+            remote: tunnelOptions.remoteAddress,
+            local: tunnelOptions.localAddressPort,
+            name: tunnelOptions.label,
+            source: {
+                source: TunnelSource.Extension,
+                description: source
+            },
+            elevateIfNeeded: false
+        });
+        if (!tunnel || (typeof tunnel === 'string')) {
+            return undefined;
+        }
+        if (!this.elevateionRetry
+            && (tunnelOptions.localAddressPort !== undefined)
+            && (tunnel.tunnelLocalPort !== undefined)
+            && this.tunnelService.isPortPrivileged(tunnelOptions.localAddressPort)
+            && (tunnel.tunnelLocalPort !== tunnelOptions.localAddressPort)
+            && this.tunnelService.canElevate) {
+            this.elevationPrompt(tunnelOptions, tunnel, source);
+        }
+        return TunnelDtoConverter.fromServiceTunnel(tunnel);
+    }
+    async elevationPrompt(tunnelOptions, tunnel, source) {
+        return this.notificationService.prompt(Severity.Info, ( localizeWithPath(
+            'vs/workbench/api/browser/mainThreadTunnelService',
+            'remote.tunnel.openTunnel',
+            "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
+            source,
+            tunnelOptions.remoteAddress.port,
+            tunnelOptions.localAddressPort
+        )), [{
+                label: ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadTunnelService',
+                    'remote.tunnelsView.elevationButton',
+                    "Use Port {0} as Sudo...",
+                    tunnel.tunnelRemotePort
+                )),
+                run: async () => {
+                    this.elevateionRetry = true;
+                    await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
+                    await this.remoteExplorerService.forward({
+                        remote: tunnelOptions.remoteAddress,
+                        local: tunnelOptions.localAddressPort,
+                        name: tunnelOptions.label,
+                        source: {
+                            source: TunnelSource.Extension,
+                            description: source
+                        },
+                        elevateIfNeeded: true
+                    });
+                    this.elevateionRetry = false;
+                }
+            }]);
+    }
+    async $closeTunnel(remote) {
+        return this.remoteExplorerService.close(remote, TunnelCloseReason.Other);
+    }
+    async $getTunnels() {
+        return ( (await this.tunnelService.tunnels).map(tunnel => {
+            return {
+                remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
+                localAddress: tunnel.localAddress,
+                privacy: tunnel.privacy,
+                protocol: tunnel.protocol
+            };
+        }));
+    }
+    async $onFoundNewCandidates(candidates) {
+        this.remoteExplorerService.onFoundNewCandidates(candidates);
+    }
+    async $setTunnelProvider(features) {
+        const tunnelProvider = {
+            forwardPort: (tunnelOptions, tunnelCreationOptions) => {
+                const forward = this._proxy.$forwardPort(tunnelOptions, tunnelCreationOptions);
+                return forward.then(tunnelOrError => {
+                    if (!tunnelOrError) {
+                        return undefined;
+                    }
+                    else if (typeof tunnelOrError === 'string') {
+                        return tunnelOrError;
+                    }
+                    const tunnel = tunnelOrError;
+                    this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) New tunnel established by tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
+                    return {
+                        tunnelRemotePort: tunnel.remoteAddress.port,
+                        tunnelRemoteHost: tunnel.remoteAddress.host,
+                        localAddress: typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port),
+                        tunnelLocalPort: typeof tunnel.localAddress !== 'string' ? tunnel.localAddress.port : undefined,
+                        public: tunnel.public,
+                        privacy: tunnel.privacy,
+                        protocol: tunnel.protocol ?? TunnelProtocol.Http,
+                        dispose: async (silent) => {
+                            this.logService.trace(`ForwardedPorts: (MainThreadTunnelService) Closing tunnel from tunnel provider: ${tunnel?.remoteAddress.host}:${tunnel?.remoteAddress.port}`);
+                            return this._proxy.$closeTunnel({ host: tunnel.remoteAddress.host, port: tunnel.remoteAddress.port }, silent);
+                        }
+                    };
+                });
+            }
+        };
+        if (features) {
+            this.tunnelService.setTunnelFeatures(features);
+        }
+        this.tunnelService.setTunnelProvider(tunnelProvider);
+        this.contextKeyService.createKey(forwardedPortsViewEnabled.key, true);
+    }
+    async $setCandidateFilter() {
+        this.remoteExplorerService.setCandidateFilter((candidates) => {
+            return this._proxy.$applyCandidateFilter(candidates);
+        });
+    }
+    async $setCandidatePortSource(source) {
+        this.remoteAgentService.getEnvironment().then(() => {
+            switch (source) {
+                case CandidatePortSource.None: {
+                    ( Registry.as(Extensions.Configuration))
+                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPorts': false } }]);
+                    break;
+                }
+                case CandidatePortSource.Output: {
+                    ( Registry.as(Extensions.Configuration))
+                        .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]);
+                    break;
+                }
+            }
+        }).catch(() => {
+        });
+    }
+};
+MainThreadTunnelService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTunnelService),
+    ( __param(1, IRemoteExplorerService)),
+    ( __param(2, ITunnelService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IRemoteAgentService)),
+    ( __param(7, IContextKeyService))
+], MainThreadTunnelService);
+
+export { MainThreadTunnelService };

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.js

@@ -0,0 +1,110 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { INotificationService, Severity } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { defaultExternalUriOpenerId } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
+import { ContributedExternalUriOpenersStore } from '../../contrib/externalUriOpener/common/contributedOpeners.js';
+import { IExternalUriOpenerService } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
+    constructor(context, storageService, externalUriOpenerService, extensionService, openerService, notificationService) {
+        super();
+        this.extensionService = extensionService;
+        this.openerService = openerService;
+        this.notificationService = notificationService;
+        this._registeredOpeners = ( new Map());
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUriOpeners));
+        this._register(externalUriOpenerService.registerExternalOpenerProvider(this));
+        this._contributedExternalUriOpenersStore = this._register(( new ContributedExternalUriOpenersStore(storageService, extensionService)));
+    }
+    async *getOpeners(targetUri) {
+        if (targetUri.scheme !== Schemas.http && targetUri.scheme !== Schemas.https) {
+            return;
+        }
+        await this.extensionService.activateByEvent(`onOpenExternalUri:${targetUri.scheme}`);
+        for (const [id, openerMetadata] of this._registeredOpeners) {
+            if (( openerMetadata.schemes.has(targetUri.scheme))) {
+                yield this.createOpener(id, openerMetadata);
+            }
+        }
+    }
+    createOpener(id, metadata) {
+        return {
+            id: id,
+            label: metadata.label,
+            canOpen: (uri, token) => {
+                return this.proxy.$canOpenUri(id, uri, token);
+            },
+            openExternalUri: async (uri, ctx, token) => {
+                try {
+                    await this.proxy.$openUri(id, { resolvedUri: uri, sourceUri: ctx.sourceUri }, token);
+                }
+                catch (e) {
+                    if (!isCancellationError(e)) {
+                        const openDefaultAction = ( new Action('default', ( localizeWithPath(
+                            'vs/workbench/api/browser/mainThreadUriOpeners',
+                            'openerFailedUseDefault',
+                            "Open using default opener"
+                        )), undefined, undefined, async () => {
+                            await this.openerService.open(uri, {
+                                allowTunneling: false,
+                                allowContributedOpeners: defaultExternalUriOpenerId,
+                            });
+                        }));
+                        openDefaultAction.tooltip = ( uri.toString());
+                        this.notificationService.notify({
+                            severity: Severity.Error,
+                            message: ( localizeWithPath('vs/workbench/api/browser/mainThreadUriOpeners', {
+                                key: 'openerFailedMessage',
+                                comment: ['{0} is the id of the opener. {1} is the url being opened.'],
+                            }, 'Could not open uri with \'{0}\': {1}', id, ( e.toString()))),
+                            actions: {
+                                primary: [
+                                    openDefaultAction
+                                ]
+                            }
+                        });
+                    }
+                }
+                return true;
+            },
+        };
+    }
+    async $registerUriOpener(id, schemes, extensionId, label) {
+        if (( this._registeredOpeners.has(id))) {
+            throw new Error(`Opener with id '${id}' already registered`);
+        }
+        this._registeredOpeners.set(id, {
+            schemes: ( new Set(schemes)),
+            label,
+            extensionId,
+        });
+        this._contributedExternalUriOpenersStore.didRegisterOpener(id, extensionId.value);
+    }
+    async $unregisterUriOpener(id) {
+        this._registeredOpeners.delete(id);
+        this._contributedExternalUriOpenersStore.delete(id);
+    }
+    dispose() {
+        super.dispose();
+        this._registeredOpeners.clear();
+    }
+};
+MainThreadUriOpeners = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadUriOpeners),
+    ( __param(1, IStorageService)),
+    ( __param(2, IExternalUriOpenerService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IOpenerService)),
+    ( __param(5, INotificationService))
+], MainThreadUriOpeners);
+
+export { MainThreadUriOpeners };

package/vscode/src/vs/workbench/api/browser/mainThreadUrls.js

@@ -0,0 +1,61 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url';
+import { IExtensionUrlHandler } from 'vscode/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+
+class ExtensionUrlHandler {
+    constructor(proxy, handle, extensionId, extensionDisplayName) {
+        this.proxy = proxy;
+        this.handle = handle;
+        this.extensionId = extensionId;
+        this.extensionDisplayName = extensionDisplayName;
+    }
+    handleURL(uri, options) {
+        if (!ExtensionIdentifier.equals(this.extensionId, uri.authority)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.proxy.$handleExternalUri(this.handle, uri)).then(() => true);
+    }
+}
+let MainThreadUrls = class MainThreadUrls {
+    constructor(context, urlService, extensionUrlHandler) {
+        this.urlService = urlService;
+        this.extensionUrlHandler = extensionUrlHandler;
+        this.handlers = ( new Map());
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUrls));
+    }
+    $registerUriHandler(handle, extensionId, extensionDisplayName) {
+        const handler = ( new ExtensionUrlHandler(this.proxy, handle, extensionId, extensionDisplayName));
+        const disposable = this.urlService.registerHandler(handler);
+        this.handlers.set(handle, { extensionId, disposable });
+        this.extensionUrlHandler.registerExtensionHandler(extensionId, handler);
+        return Promise.resolve(undefined);
+    }
+    $unregisterUriHandler(handle) {
+        const tuple = this.handlers.get(handle);
+        if (!tuple) {
+            return Promise.resolve(undefined);
+        }
+        const { extensionId, disposable } = tuple;
+        this.extensionUrlHandler.unregisterExtensionHandler(extensionId);
+        this.handlers.delete(handle);
+        disposable.dispose();
+        return Promise.resolve(undefined);
+    }
+    async $createAppUri(uri) {
+        return this.urlService.create(uri);
+    }
+    dispose() {
+        this.handlers.forEach(({ disposable }) => disposable.dispose());
+        this.handlers.clear();
+    }
+};
+MainThreadUrls = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadUrls),
+    ( __param(1, IURLService)),
+    ( __param(2, IExtensionUrlHandler))
+], MainThreadUrls);
+
+export { MainThreadUrls };

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewManager.js

@@ -0,0 +1,29 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { MainThreadCustomEditors } from './mainThreadCustomEditors.js';
+import { MainThreadWebviewPanels } from './mainThreadWebviewPanels.js';
+import { MainThreadWebviews } from './mainThreadWebviews.js';
+import { MainThreadWebviewsViews } from './mainThreadWebviewViews.js';
+import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadWebviewManager = class MainThreadWebviewManager extends Disposable {
+    constructor(context, instantiationService) {
+        super();
+        const webviews = this._register(instantiationService.createInstance(MainThreadWebviews, context));
+        context.set(MainContext.MainThreadWebviews, webviews);
+        const webviewPanels = this._register(instantiationService.createInstance(MainThreadWebviewPanels, context, webviews));
+        context.set(MainContext.MainThreadWebviewPanels, webviewPanels);
+        const customEditors = this._register(instantiationService.createInstance(MainThreadCustomEditors, context, webviews, webviewPanels));
+        context.set(MainContext.MainThreadCustomEditors, customEditors);
+        const webviewViews = this._register(instantiationService.createInstance(MainThreadWebviewsViews, context, webviews));
+        context.set(MainContext.MainThreadWebviewViews, webviewViews);
+    }
+};
+MainThreadWebviewManager = __decorate([
+    extHostCustomer,
+    ( __param(1, IInstantiationService))
+], MainThreadWebviewManager);
+
+export { MainThreadWebviewManager };