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

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

@@ -0,0 +1,55 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ITimelineService } from 'vscode/vscode/vs/workbench/contrib/timeline/common/timeline';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+
+let MainThreadTimeline = class MainThreadTimeline {
+    constructor(context, logService, _timelineService) {
+        this.logService = logService;
+        this._timelineService = _timelineService;
+        this._providerEmitters = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostTimeline));
+    }
+    $registerTimelineProvider(provider) {
+        this.logService.trace(`MainThreadTimeline#registerTimelineProvider: id=${provider.id}`);
+        const proxy = this._proxy;
+        const emitters = this._providerEmitters;
+        let onDidChange = emitters.get(provider.id);
+        if (onDidChange === undefined) {
+            onDidChange = ( new Emitter());
+            emitters.set(provider.id, onDidChange);
+        }
+        this._timelineService.registerTimelineProvider({
+            ...provider,
+            onDidChange: onDidChange.event,
+            async provideTimeline(uri, options, token) {
+                return revive(await proxy.$getTimeline(provider.id, uri, options, token));
+            },
+            dispose() {
+                emitters.delete(provider.id);
+                onDidChange?.dispose();
+            }
+        });
+    }
+    $unregisterTimelineProvider(id) {
+        this.logService.trace(`MainThreadTimeline#unregisterTimelineProvider: id=${id}`);
+        this._timelineService.unregisterTimelineProvider(id);
+    }
+    $emitTimelineChangeEvent(e) {
+        this.logService.trace(`MainThreadTimeline#emitChangeEvent: id=${e.id}, uri=${e.uri?.toString(true)}`);
+        const emitter = this._providerEmitters.get(e.id);
+        emitter?.fire(e);
+    }
+    dispose() {
+    }
+};
+MainThreadTimeline = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTimeline),
+    ( __param(1, ILogService)),
+    ( __param(2, ITimelineService))
+], MainThreadTimeline);
+
+export { MainThreadTimeline };

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

@@ -0,0 +1,313 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IViewsService, Extensions, NoTreeViewError, ResolvableTreeItem } from 'vscode/vscode/vs/workbench/common/views';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { isUndefinedOrNull, isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { VSDataTransfer, createStringDataTransferItem } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
+import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
+import { DataTransfer } from 'vscode/vscode/vs/workbench/api/common/extHostTypeConverters';
+
+let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
+    constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
+        super();
+        this.viewsService = viewsService;
+        this.notificationService = notificationService;
+        this.extensionService = extensionService;
+        this.logService = logService;
+        this._dataProviders = ( new Map());
+        this._dndControllers = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTreeViews));
+    }
+    async $registerTreeViewDataProvider(treeViewId, options) {
+        this.logService.trace('MainThreadTreeViews#$registerTreeViewDataProvider', treeViewId, options);
+        this.extensionService.whenInstalledExtensionsRegistered().then(() => {
+            const dataProvider = ( new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService));
+            const disposables = ( new DisposableStore());
+            this._register(disposables);
+            this._dataProviders.set(treeViewId, { dataProvider, disposables });
+            const dndController = (options.hasHandleDrag || options.hasHandleDrop)
+                ? ( new TreeViewDragAndDropController(
+                treeViewId,
+                options.dropMimeTypes,
+                options.dragMimeTypes,
+                options.hasHandleDrag,
+                this._proxy
+            )) : undefined;
+            const viewer = this.getTreeView(treeViewId);
+            if (viewer) {
+                viewer.showCollapseAllAction = options.showCollapseAll;
+                viewer.canSelectMany = options.canSelectMany;
+                viewer.manuallyManageCheckboxes = options.manuallyManageCheckboxes;
+                viewer.dragAndDropController = dndController;
+                if (dndController) {
+                    this._dndControllers.set(treeViewId, dndController);
+                }
+                viewer.dataProvider = dataProvider;
+                this.registerListeners(treeViewId, viewer, disposables);
+                this._proxy.$setVisible(treeViewId, viewer.visible);
+            }
+            else {
+                this.notificationService.error('No view is registered with id: ' + treeViewId);
+            }
+        });
+    }
+    $reveal(treeViewId, itemInfo, options) {
+        this.logService.trace('MainThreadTreeViews#$reveal', treeViewId, itemInfo?.item, itemInfo?.parentChain, options);
+        return this.viewsService.openView(treeViewId, options.focus)
+            .then(() => {
+            const viewer = this.getTreeView(treeViewId);
+            if (viewer && itemInfo) {
+                return this.reveal(viewer, this._dataProviders.get(treeViewId).dataProvider, itemInfo.item, itemInfo.parentChain, options);
+            }
+            return undefined;
+        });
+    }
+    $refresh(treeViewId, itemsToRefreshByHandle) {
+        this.logService.trace('MainThreadTreeViews#$refresh', treeViewId, itemsToRefreshByHandle);
+        const viewer = this.getTreeView(treeViewId);
+        const dataProvider = this._dataProviders.get(treeViewId);
+        if (viewer && dataProvider) {
+            const itemsToRefresh = dataProvider.dataProvider.getItemsToRefresh(itemsToRefreshByHandle);
+            return viewer.refresh(itemsToRefresh.length ? itemsToRefresh : undefined);
+        }
+        return Promise.resolve();
+    }
+    $setMessage(treeViewId, message) {
+        this.logService.trace('MainThreadTreeViews#$setMessage', treeViewId, ( message.toString()));
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.message = message;
+        }
+    }
+    $setTitle(treeViewId, title, description) {
+        this.logService.trace('MainThreadTreeViews#$setTitle', treeViewId, title, description);
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.title = title;
+            viewer.description = description;
+        }
+    }
+    $setBadge(treeViewId, badge) {
+        this.logService.trace('MainThreadTreeViews#$setBadge', treeViewId, badge?.value, badge?.tooltip);
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.badge = badge;
+        }
+    }
+    $resolveDropFileData(destinationViewId, requestId, dataItemId) {
+        const controller = this._dndControllers.get(destinationViewId);
+        if (!controller) {
+            throw new Error('Unknown tree');
+        }
+        return controller.resolveDropFileData(requestId, dataItemId);
+    }
+    async $disposeTree(treeViewId) {
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.dataProvider = undefined;
+        }
+        const dataProvider = this._dataProviders.get(treeViewId);
+        if (dataProvider) {
+            dataProvider.disposables.dispose();
+            this._dataProviders.delete(treeViewId);
+        }
+    }
+    async reveal(treeView, dataProvider, itemIn, parentChain, options) {
+        options = options ? options : { select: false, focus: false };
+        const select = isUndefinedOrNull(options.select) ? false : options.select;
+        const focus = isUndefinedOrNull(options.focus) ? false : options.focus;
+        let expand = Math.min(isNumber(options.expand) ? options.expand : options.expand === true ? 1 : 0, 3);
+        if (dataProvider.isEmpty()) {
+            await treeView.refresh();
+        }
+        for (const parent of parentChain) {
+            const parentItem = dataProvider.getItem(parent.handle);
+            if (parentItem) {
+                await treeView.expand(parentItem);
+            }
+        }
+        const item = dataProvider.getItem(itemIn.handle);
+        if (item) {
+            await treeView.reveal(item);
+            if (select) {
+                treeView.setSelection([item]);
+            }
+            if (focus === false) {
+                treeView.setFocus();
+            }
+            else if (focus) {
+                treeView.setFocus(item);
+            }
+            let itemsToExpand = [item];
+            for (; itemsToExpand.length > 0 && expand > 0; expand--) {
+                await treeView.expand(itemsToExpand);
+                itemsToExpand = itemsToExpand.reduce((result, itemValue) => {
+                    const item = dataProvider.getItem(itemValue.handle);
+                    if (item && item.children && item.children.length) {
+                        result.push(...item.children);
+                    }
+                    return result;
+                }, []);
+            }
+        }
+    }
+    registerListeners(treeViewId, treeView, disposables) {
+        disposables.add(treeView.onDidExpandItem(item => this._proxy.$setExpanded(treeViewId, item.handle, true)));
+        disposables.add(treeView.onDidCollapseItem(item => this._proxy.$setExpanded(treeViewId, item.handle, false)));
+        disposables.add(treeView.onDidChangeSelectionAndFocus(items => this._proxy.$setSelectionAndFocus(treeViewId, ( items.selection.map(({ handle }) => handle)), items.focus.handle)));
+        disposables.add(treeView.onDidChangeVisibility(isVisible => this._proxy.$setVisible(treeViewId, isVisible)));
+        disposables.add(treeView.onDidChangeCheckboxState(items => {
+            this._proxy.$changeCheckboxState(treeViewId, ( items.map(item => {
+                return { treeItemHandle: item.handle, newState: item.checkbox?.isChecked ?? false };
+            })));
+        }));
+    }
+    getTreeView(treeViewId) {
+        const viewDescriptor = ( Registry.as(Extensions.ViewsRegistry)).getView(treeViewId);
+        return viewDescriptor ? viewDescriptor.treeView : null;
+    }
+    dispose() {
+        this._dataProviders.forEach((dataProvider, treeViewId) => {
+            const treeView = this.getTreeView(treeViewId);
+            if (treeView) {
+                treeView.dataProvider = undefined;
+            }
+        });
+        this._dataProviders.clear();
+        this._dndControllers.clear();
+        super.dispose();
+    }
+};
+MainThreadTreeViews = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTreeViews),
+    ( __param(1, IViewsService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, ILogService))
+], MainThreadTreeViews);
+class TreeViewDragAndDropController {
+    constructor(treeViewId, dropMimeTypes, dragMimeTypes, hasWillDrop, _proxy) {
+        this.treeViewId = treeViewId;
+        this.dropMimeTypes = dropMimeTypes;
+        this.dragMimeTypes = dragMimeTypes;
+        this.hasWillDrop = hasWillDrop;
+        this._proxy = _proxy;
+        this.dataTransfersCache = ( new DataTransferFileCache());
+    }
+    async handleDrop(dataTransfer, targetTreeItem, token, operationUuid, sourceTreeId, sourceTreeItemHandles) {
+        const request = this.dataTransfersCache.add(dataTransfer);
+        try {
+            const dataTransferDto = await DataTransfer.from(dataTransfer);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            return await this._proxy.$handleDrop(this.treeViewId, request.id, dataTransferDto, targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
+        }
+        finally {
+            request.dispose();
+        }
+    }
+    async handleDrag(sourceTreeItemHandles, operationUuid, token) {
+        if (!this.hasWillDrop) {
+            return;
+        }
+        const additionalDataTransferDTO = await this._proxy.$handleDrag(this.treeViewId, sourceTreeItemHandles, operationUuid, token);
+        if (!additionalDataTransferDTO) {
+            return;
+        }
+        const additionalDataTransfer = ( new VSDataTransfer());
+        additionalDataTransferDTO.items.forEach(([type, item]) => {
+            additionalDataTransfer.replace(type, createStringDataTransferItem(item.asString));
+        });
+        return additionalDataTransfer;
+    }
+    resolveDropFileData(requestId, dataItemId) {
+        return this.dataTransfersCache.resolveFileData(requestId, dataItemId);
+    }
+}
+class TreeViewDataProvider {
+    constructor(treeViewId, _proxy, notificationService) {
+        this.treeViewId = treeViewId;
+        this._proxy = _proxy;
+        this.notificationService = notificationService;
+        this.itemsMap = ( new Map());
+        this.hasResolve = this._proxy.$hasResolve(this.treeViewId);
+    }
+    getChildren(treeItem) {
+        return this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : undefined)
+            .then(children => this.postGetChildren(children), err => {
+            if (!NoTreeViewError.is(err)) {
+                this.notificationService.error(err);
+            }
+            return [];
+        });
+    }
+    getItemsToRefresh(itemsToRefreshByHandle) {
+        const itemsToRefresh = [];
+        if (itemsToRefreshByHandle) {
+            for (const treeItemHandle of ( Object.keys(itemsToRefreshByHandle))) {
+                const currentTreeItem = this.getItem(treeItemHandle);
+                if (currentTreeItem) {
+                    const treeItem = itemsToRefreshByHandle[treeItemHandle];
+                    this.updateTreeItem(currentTreeItem, treeItem);
+                    if (treeItemHandle === treeItem.handle) {
+                        itemsToRefresh.push(currentTreeItem);
+                    }
+                    else {
+                        this.itemsMap.delete(treeItemHandle);
+                        this.itemsMap.set(currentTreeItem.handle, currentTreeItem);
+                        const parent = treeItem.parentHandle ? this.itemsMap.get(treeItem.parentHandle) : null;
+                        if (parent) {
+                            itemsToRefresh.push(parent);
+                        }
+                    }
+                }
+            }
+        }
+        return itemsToRefresh;
+    }
+    getItem(treeItemHandle) {
+        return this.itemsMap.get(treeItemHandle);
+    }
+    isEmpty() {
+        return this.itemsMap.size === 0;
+    }
+    async postGetChildren(elements) {
+        if (elements === undefined) {
+            return undefined;
+        }
+        const result = [];
+        const hasResolve = await this.hasResolve;
+        if (elements) {
+            for (const element of elements) {
+                const resolvable = ( new ResolvableTreeItem(element, hasResolve ? (token) => {
+                    return this._proxy.$resolve(this.treeViewId, element.handle, token);
+                } : undefined));
+                this.itemsMap.set(element.handle, resolvable);
+                result.push(resolvable);
+            }
+        }
+        return result;
+    }
+    updateTreeItem(current, treeItem) {
+        treeItem.children = treeItem.children ? treeItem.children : undefined;
+        if (current) {
+            const properties = distinct([...( Object.keys(current instanceof ResolvableTreeItem ? current.asTreeItem() : current)),
+                ...( Object.keys(treeItem))]);
+            for (const property of properties) {
+                current[property] = treeItem[property];
+            }
+            if (current instanceof ResolvableTreeItem) {
+                current.resetResolve();
+            }
+        }
+    }
+}
+
+export { MainThreadTreeViews };

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

@@ -0,0 +1,223 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+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 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+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.configurationService.getValue(PORT_AUTO_FORWARD_SETTING))));
+        }
+        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, ( nls.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: ( nls.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 };