@codingame/monaco-vscode-api 1.81.8-next.2 → 1.82.0-next.0

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

@@ -1,832 +1,21 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ProvidedOnAutoForward, isLocalhost, isAllInterfaces, TunnelProtocol, TunnelPrivacyId, LOCALHOST_ADDRESSES, ALL_INTERFACES_ADDRESSES, ITunnelService } from '../../../../platform/tunnel/common/tunnel.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
-import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
-import { isString, isNumber, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-const IRemoteExplorerService = ( (createDecorator('remoteExplorerService')));
-const TUNNELS_TO_RESTORE = 'remote.tunnels.toRestore';
+const IRemoteExplorerService = ( createDecorator('remoteExplorerService'));
 const TUNNEL_VIEW_ID = '~remote.forwardedPorts';
 const PORT_AUTO_FORWARD_SETTING = 'remote.autoForwardPorts';
 const PORT_AUTO_SOURCE_SETTING = 'remote.autoForwardPortsSource';
 const PORT_AUTO_SOURCE_SETTING_OUTPUT = 'output';
 var TunnelType;
-( ((function(TunnelType) {
+( (function(TunnelType) {
     TunnelType["Candidate"] = "Candidate";
     TunnelType["Detected"] = "Detected";
     TunnelType["Forwarded"] = "Forwarded";
     TunnelType["Add"] = "Add";
-})(TunnelType || (TunnelType = {}))));
-var TunnelCloseReason;
-( ((function(TunnelCloseReason) {
-    TunnelCloseReason["Other"] = "Other";
-    TunnelCloseReason["User"] = "User";
-    TunnelCloseReason["AutoForwardEnd"] = "AutoForwardEnd";
-})(TunnelCloseReason || (TunnelCloseReason = {}))));
+})(TunnelType || (TunnelType = {})));
 var TunnelEditId;
-( ((function(TunnelEditId) {
+( (function(TunnelEditId) {
     TunnelEditId[TunnelEditId["None"] = 0] = "None";
     TunnelEditId[TunnelEditId["New"] = 1] = "New";
     TunnelEditId[TunnelEditId["Label"] = 2] = "Label";
     TunnelEditId[TunnelEditId["LocalPort"] = 3] = "LocalPort";
-})(TunnelEditId || (TunnelEditId = {}))));
-var TunnelSource;
-( ((function(TunnelSource) {
-    TunnelSource[TunnelSource["User"] = 0] = "User";
-    TunnelSource[TunnelSource["Auto"] = 1] = "Auto";
-    TunnelSource[TunnelSource["Extension"] = 2] = "Extension";
-})(TunnelSource || (TunnelSource = {}))));
-const UserTunnelSource = {
-    source: TunnelSource.User,
-    description: ( (nls.localize('tunnel.source.user', "User Forwarded")))
-};
-const AutoTunnelSource = {
-    source: TunnelSource.Auto,
-    description: ( (nls.localize('tunnel.source.auto', "Auto Forwarded")))
-};
-function makeAddress(host, port) {
-    return host + ':' + port;
-}
-function parseAddress(address) {
-    const matches = address.match(/^([a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*:)?([0-9]+)$/);
-    if (!matches) {
-        return undefined;
-    }
-    return { host: matches[1]?.substring(0, matches[1].length - 1) || 'localhost', port: Number(matches[2]) };
-}
-function mapHasAddress(map, host, port) {
-    const initialAddress = map.get(makeAddress(host, port));
-    if (initialAddress) {
-        return initialAddress;
-    }
-    if (isLocalhost(host)) {
-        for (const testHost of LOCALHOST_ADDRESSES) {
-            const testAddress = makeAddress(testHost, port);
-            if (( (map.has(testAddress)))) {
-                return map.get(testAddress);
-            }
-        }
-    }
-    else if (isAllInterfaces(host)) {
-        for (const testHost of ALL_INTERFACES_ADDRESSES) {
-            const testAddress = makeAddress(testHost, port);
-            if (( (map.has(testAddress)))) {
-                return map.get(testAddress);
-            }
-        }
-    }
-    return undefined;
-}
-function mapHasAddressLocalhostOrAllInterfaces(map, host, port) {
-    const originalAddress = mapHasAddress(map, host, port);
-    if (originalAddress) {
-        return originalAddress;
-    }
-    const otherHost = isAllInterfaces(host) ? 'localhost' : (isLocalhost(host) ? '0.0.0.0' : undefined);
-    if (otherHost) {
-        return mapHasAddress(map, otherHost, port);
-    }
-    return undefined;
-}
-var OnPortForward;
-( ((function(OnPortForward) {
-    OnPortForward["Notify"] = "notify";
-    OnPortForward["OpenBrowser"] = "openBrowser";
-    OnPortForward["OpenBrowserOnce"] = "openBrowserOnce";
-    OnPortForward["OpenPreview"] = "openPreview";
-    OnPortForward["Silent"] = "silent";
-    OnPortForward["Ignore"] = "ignore";
-})(OnPortForward || (OnPortForward = {}))));
-class PortsAttributes extends Disposable {
-    static { this.SETTING = 'remote.portsAttributes'; }
-    static { this.DEFAULTS = 'remote.otherPortsAttributes'; }
-    static { this.RANGE = /^(\d+)\-(\d+)$/; }
-    static { this.HOST_AND_PORT = /^([a-z0-9\-]+):(\d{1,5})$/; }
-    constructor(configurationService) {
-        super();
-        this.configurationService = configurationService;
-        this.portsAttributes = [];
-        this._onDidChangeAttributes = ( (new Emitter()));
-        this.onDidChangeAttributes = this._onDidChangeAttributes.event;
-        this._register(configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(PortsAttributes.SETTING) || e.affectsConfiguration(PortsAttributes.DEFAULTS)) {
-                this.updateAttributes();
-            }
-        }));
-        this.updateAttributes();
-    }
-    updateAttributes() {
-        this.portsAttributes = this.readSetting();
-        this._onDidChangeAttributes.fire();
-    }
-    getAttributes(port, host, commandLine) {
-        let index = this.findNextIndex(port, host, commandLine, this.portsAttributes, 0);
-        const attributes = {
-            label: undefined,
-            onAutoForward: undefined,
-            elevateIfNeeded: undefined,
-            requireLocalPort: undefined,
-            protocol: undefined
-        };
-        while (index >= 0) {
-            const found = this.portsAttributes[index];
-            if (found.key === port) {
-                attributes.onAutoForward = found.onAutoForward ?? attributes.onAutoForward;
-                attributes.elevateIfNeeded = (found.elevateIfNeeded !== undefined) ? found.elevateIfNeeded : attributes.elevateIfNeeded;
-                attributes.label = found.label ?? attributes.label;
-                attributes.requireLocalPort = found.requireLocalPort;
-                attributes.protocol = found.protocol;
-            }
-            else {
-                attributes.onAutoForward = attributes.onAutoForward ?? found.onAutoForward;
-                attributes.elevateIfNeeded = (attributes.elevateIfNeeded !== undefined) ? attributes.elevateIfNeeded : found.elevateIfNeeded;
-                attributes.label = attributes.label ?? found.label;
-                attributes.requireLocalPort = (attributes.requireLocalPort !== undefined) ? attributes.requireLocalPort : undefined;
-                attributes.protocol = attributes.protocol ?? found.protocol;
-            }
-            index = this.findNextIndex(port, host, commandLine, this.portsAttributes, index + 1);
-        }
-        if (attributes.onAutoForward !== undefined || attributes.elevateIfNeeded !== undefined
-            || attributes.label !== undefined || attributes.requireLocalPort !== undefined
-            || attributes.protocol !== undefined) {
-            return attributes;
-        }
-        return this.getOtherAttributes();
-    }
-    hasStartEnd(value) {
-        return (value.start !== undefined) && (value.end !== undefined);
-    }
-    hasHostAndPort(value) {
-        return (value.host !== undefined) && (value.port !== undefined)
-            && isString(value.host) && isNumber(value.port);
-    }
-    findNextIndex(port, host, commandLine, attributes, fromIndex) {
-        if (fromIndex >= attributes.length) {
-            return -1;
-        }
-        const shouldUseHost = !isLocalhost(host) && !isAllInterfaces(host);
-        const sliced = attributes.slice(fromIndex);
-        const foundIndex = sliced.findIndex((value) => {
-            if (isNumber(value.key)) {
-                return shouldUseHost ? false : value.key === port;
-            }
-            else if (this.hasStartEnd(value.key)) {
-                return shouldUseHost ? false : (port >= value.key.start && port <= value.key.end);
-            }
-            else if (this.hasHostAndPort(value.key)) {
-                return (port === value.key.port) && (host === value.key.host);
-            }
-            else {
-                return commandLine ? value.key.test(commandLine) : false;
-            }
-        });
-        return foundIndex >= 0 ? foundIndex + fromIndex : -1;
-    }
-    readSetting() {
-        const settingValue = this.configurationService.getValue(PortsAttributes.SETTING);
-        if (!settingValue || !isObject(settingValue)) {
-            return [];
-        }
-        const attributes = [];
-        for (const attributesKey in settingValue) {
-            if (attributesKey === undefined) {
-                continue;
-            }
-            const setting = settingValue[attributesKey];
-            let key = undefined;
-            if (Number(attributesKey)) {
-                key = Number(attributesKey);
-            }
-            else if (isString(attributesKey)) {
-                if (PortsAttributes.RANGE.test(attributesKey)) {
-                    const match = attributesKey.match(PortsAttributes.RANGE);
-                    key = { start: Number(match[1]), end: Number(match[2]) };
-                }
-                else if (PortsAttributes.HOST_AND_PORT.test(attributesKey)) {
-                    const match = attributesKey.match(PortsAttributes.HOST_AND_PORT);
-                    key = { host: match[1], port: Number(match[2]) };
-                }
-                else {
-                    let regTest = undefined;
-                    try {
-                        regTest = RegExp(attributesKey);
-                    }
-                    catch (e) {
-                    }
-                    if (regTest) {
-                        key = regTest;
-                    }
-                }
-            }
-            if (!key) {
-                continue;
-            }
-            attributes.push({
-                key: key,
-                elevateIfNeeded: setting.elevateIfNeeded,
-                onAutoForward: setting.onAutoForward,
-                label: setting.label,
-                requireLocalPort: setting.requireLocalPort,
-                protocol: setting.protocol
-            });
-        }
-        const defaults = this.configurationService.getValue(PortsAttributes.DEFAULTS);
-        if (defaults) {
-            this.defaultPortAttributes = {
-                elevateIfNeeded: defaults.elevateIfNeeded,
-                label: defaults.label,
-                onAutoForward: defaults.onAutoForward,
-                requireLocalPort: defaults.requireLocalPort,
-                protocol: defaults.protocol
-            };
-        }
-        return this.sortAttributes(attributes);
-    }
-    sortAttributes(attributes) {
-        function getVal(item, thisRef) {
-            if (isNumber(item.key)) {
-                return item.key;
-            }
-            else if (thisRef.hasStartEnd(item.key)) {
-                return item.key.start;
-            }
-            else if (thisRef.hasHostAndPort(item.key)) {
-                return item.key.port;
-            }
-            else {
-                return Number.MAX_VALUE;
-            }
-        }
-        return attributes.sort((a, b) => {
-            return getVal(a, this) - getVal(b, this);
-        });
-    }
-    getOtherAttributes() {
-        return this.defaultPortAttributes;
-    }
-    static providedActionToAction(providedAction) {
-        switch (providedAction) {
-            case ProvidedOnAutoForward.Notify: return OnPortForward.Notify;
-            case ProvidedOnAutoForward.OpenBrowser: return OnPortForward.OpenBrowser;
-            case ProvidedOnAutoForward.OpenBrowserOnce: return OnPortForward.OpenBrowserOnce;
-            case ProvidedOnAutoForward.OpenPreview: return OnPortForward.OpenPreview;
-            case ProvidedOnAutoForward.Silent: return OnPortForward.Silent;
-            case ProvidedOnAutoForward.Ignore: return OnPortForward.Ignore;
-            default: return undefined;
-        }
-    }
-    async addAttributes(port, attributes, target) {
-        const settingValue = this.configurationService.inspect(PortsAttributes.SETTING);
-        const remoteValue = settingValue.userRemoteValue;
-        let newRemoteValue;
-        if (!remoteValue || !isObject(remoteValue)) {
-            newRemoteValue = {};
-        }
-        else {
-            newRemoteValue = deepClone(remoteValue);
-        }
-        if (!newRemoteValue[`${port}`]) {
-            newRemoteValue[`${port}`] = {};
-        }
-        for (const attribute in attributes) {
-            newRemoteValue[`${port}`][attribute] = attributes[attribute];
-        }
-        return this.configurationService.updateValue(PortsAttributes.SETTING, newRemoteValue, target);
-    }
-}
-const MISMATCH_LOCAL_PORT_COOLDOWN = 10 * 1000;
-let TunnelModel = class TunnelModel extends Disposable {
-    constructor(tunnelService, storageService, configurationService, environmentService, remoteAuthorityResolverService, workspaceContextService, logService, dialogService) {
-        super();
-        this.tunnelService = tunnelService;
-        this.storageService = storageService;
-        this.configurationService = configurationService;
-        this.environmentService = environmentService;
-        this.remoteAuthorityResolverService = remoteAuthorityResolverService;
-        this.workspaceContextService = workspaceContextService;
-        this.logService = logService;
-        this.dialogService = dialogService;
-        this.inProgress = ( (new Map()));
-        this._onForwardPort = ( (new Emitter()));
-        this.onForwardPort = this._onForwardPort.event;
-        this._onClosePort = ( (new Emitter()));
-        this.onClosePort = this._onClosePort.event;
-        this._onPortName = ( (new Emitter()));
-        this.onPortName = this._onPortName.event;
-        this._onCandidatesChanged = ( (new Emitter()));
-        this.onCandidatesChanged = this._onCandidatesChanged.event;
-        this._onEnvironmentTunnelsSet = ( (new Emitter()));
-        this.onEnvironmentTunnelsSet = this._onEnvironmentTunnelsSet.event;
-        this._environmentTunnelsSet = false;
-        this.unrestoredExtensionTunnels = ( (new Map()));
-        this.sessionCachedProperties = ( (new Map()));
-        this.portAttributesProviders = [];
-        this.mismatchCooldown = ( (new Date()));
-        this.configPortsAttributes = ( (new PortsAttributes(configurationService)));
-        this.tunnelRestoreValue = this.getTunnelRestoreValue();
-        this._register(this.configPortsAttributes.onDidChangeAttributes(this.updateAttributes, this));
-        this.forwarded = ( (new Map()));
-        this.remoteTunnels = ( (new Map()));
-        this.tunnelService.tunnels.then(async (tunnels) => {
-            const attributes = await this.getAttributes(( (tunnels.map(tunnel => {
-                return { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost };
-            }))));
-            for (const tunnel of tunnels) {
-                if (tunnel.localAddress) {
-                    const key = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-                    const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-                    this.forwarded.set(key, {
-                        remotePort: tunnel.tunnelRemotePort,
-                        remoteHost: tunnel.tunnelRemoteHost,
-                        localAddress: tunnel.localAddress,
-                        protocol: attributes?.get(tunnel.tunnelRemotePort)?.protocol ?? TunnelProtocol.Http,
-                        localUri: await this.makeLocalUri(tunnel.localAddress, attributes?.get(tunnel.tunnelRemotePort)),
-                        localPort: tunnel.tunnelLocalPort,
-                        runningProcess: matchingCandidate?.detail,
-                        hasRunningProcess: !!matchingCandidate,
-                        pid: matchingCandidate?.pid,
-                        privacy: tunnel.privacy,
-                        source: UserTunnelSource,
-                    });
-                    this.remoteTunnels.set(key, tunnel);
-                }
-            }
-        });
-        this.detected = ( (new Map()));
-        this._register(this.tunnelService.onTunnelOpened(async (tunnel) => {
-            const key = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-            if (!mapHasAddressLocalhostOrAllInterfaces(this.forwarded, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort)
-                && !mapHasAddressLocalhostOrAllInterfaces(this.detected, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort)
-                && !mapHasAddressLocalhostOrAllInterfaces(this.inProgress, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort)
-                && tunnel.localAddress) {
-                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
-                const attributes = (await this.getAttributes([{ port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost }]))?.get(tunnel.tunnelRemotePort);
-                this.forwarded.set(key, {
-                    remoteHost: tunnel.tunnelRemoteHost,
-                    remotePort: tunnel.tunnelRemotePort,
-                    localAddress: tunnel.localAddress,
-                    protocol: attributes?.protocol ?? TunnelProtocol.Http,
-                    localUri: await this.makeLocalUri(tunnel.localAddress, attributes),
-                    localPort: tunnel.tunnelLocalPort,
-                    closeable: true,
-                    runningProcess: matchingCandidate?.detail,
-                    hasRunningProcess: !!matchingCandidate,
-                    pid: matchingCandidate?.pid,
-                    privacy: tunnel.privacy,
-                    source: UserTunnelSource,
-                });
-            }
-            await this.storeForwarded();
-            this.remoteTunnels.set(key, tunnel);
-            this._onForwardPort.fire(this.forwarded.get(key));
-        }));
-        this._register(this.tunnelService.onTunnelClosed(address => {
-            return this.onTunnelClosed(address, TunnelCloseReason.Other);
-        }));
-    }
-    async onTunnelClosed(address, reason) {
-        const key = makeAddress(address.host, address.port);
-        if (( (this.forwarded.has(key)))) {
-            this.forwarded.delete(key);
-            await this.storeForwarded();
-            this._onClosePort.fire(address);
-        }
-    }
-    makeLocalUri(localAddress, attributes) {
-        if (localAddress.startsWith('http')) {
-            return (
-                 (URI.parse(localAddress))
-            );
-        }
-        const protocol = attributes?.protocol ?? 'http';
-        return (
-             (URI.parse(`${protocol}://${localAddress}`))
-        );
-    }
-    async getStorageKey() {
-        const workspace = this.workspaceContextService.getWorkspace();
-        const workspaceHash = workspace.configuration ? hash(workspace.configuration.path) : (workspace.folders.length > 0 ? hash(workspace.folders[0].uri.path) : undefined);
-        if (workspaceHash === undefined) {
-            this.logService.debug('Could not get workspace hash for forwarded ports storage key.');
-            return undefined;
-        }
-        return `${TUNNELS_TO_RESTORE}.${this.environmentService.remoteAuthority}.${workspaceHash}`;
-    }
-    async getTunnelRestoreValue() {
-        const deprecatedValue = this.storageService.get(TUNNELS_TO_RESTORE, 1 );
-        if (deprecatedValue) {
-            this.storageService.remove(TUNNELS_TO_RESTORE, 1 );
-            await this.storeForwarded();
-            return deprecatedValue;
-        }
-        const storageKey = await this.getStorageKey();
-        if (!storageKey) {
-            return undefined;
-        }
-        return this.storageService.get(storageKey, 0 );
-    }
-    async restoreForwarded() {
-        if (this.configurationService.getValue('remote.restoreForwardedPorts')) {
-            const tunnelRestoreValue = await this.tunnelRestoreValue;
-            if (tunnelRestoreValue && (tunnelRestoreValue !== this.knownPortsRestoreValue)) {
-                const tunnels = JSON.parse(tunnelRestoreValue) ?? [];
-                this.logService.trace(`ForwardedPorts: (TunnelModel) restoring ports ${( ( tunnels.map(tunnel => tunnel.remotePort))).join(', ')}`);
-                for (const tunnel of tunnels) {
-                    const alreadyForwarded = mapHasAddressLocalhostOrAllInterfaces(this.detected, tunnel.remoteHost, tunnel.remotePort);
-                    if ((tunnel.source.source === TunnelSource.User && !alreadyForwarded) || (tunnel.source.source === TunnelSource.Extension && alreadyForwarded)) {
-                        await this.forward({
-                            remote: { host: tunnel.remoteHost, port: tunnel.remotePort },
-                            local: tunnel.localPort,
-                            name: tunnel.name,
-                            privacy: tunnel.privacy,
-                            elevateIfNeeded: true
-                        });
-                    }
-                    else if (tunnel.source.source === TunnelSource.Extension && !alreadyForwarded) {
-                        this.unrestoredExtensionTunnels.set(makeAddress(tunnel.remoteHost, tunnel.remotePort), tunnel);
-                    }
-                }
-            }
-        }
-        if (!this.restoreListener) {
-            const key = await this.getStorageKey();
-            this.restoreListener = this._register(this.storageService.onDidChangeValue(async (e) => {
-                if (e.key === key) {
-                    this.tunnelRestoreValue = Promise.resolve(this.storageService.get(key, 0 ));
-                    await this.restoreForwarded();
-                }
-            }));
-        }
-    }
-    async storeForwarded() {
-        if (this.configurationService.getValue('remote.restoreForwardedPorts')) {
-            const valueToStore = JSON.stringify(Array.from(( (this.forwarded.values()))).filter(value => value.source.source !== TunnelSource.Auto));
-            if (valueToStore !== this.knownPortsRestoreValue) {
-                this.knownPortsRestoreValue = valueToStore;
-                const key = await this.getStorageKey();
-                if (key) {
-                    this.storageService.store(key, this.knownPortsRestoreValue, 0 , 0 );
-                }
-            }
-        }
-    }
-    async showPortMismatchModalIfNeeded(tunnel, expectedLocal, attributes) {
-        if (!tunnel.tunnelLocalPort || !attributes?.requireLocalPort) {
-            return;
-        }
-        if (tunnel.tunnelLocalPort === expectedLocal) {
-            return;
-        }
-        const newCooldown = ( (new Date()));
-        if ((this.mismatchCooldown.getTime() + MISMATCH_LOCAL_PORT_COOLDOWN) > newCooldown.getTime()) {
-            return;
-        }
-        this.mismatchCooldown = newCooldown;
-        const mismatchString = ( (nls.localize(
-            'remote.localPortMismatch.single',
-            "Local port {0} could not be used for forwarding to remote port {1}.\n\nThis usually happens when there is already another process using local port {0}.\n\nPort number {2} has been used instead.",
-            expectedLocal,
-            tunnel.tunnelRemotePort,
-            tunnel.tunnelLocalPort
-        )));
-        return this.dialogService.info(mismatchString);
-    }
-    async forward(tunnelProperties, attributes) {
-        const existingTunnel = mapHasAddressLocalhostOrAllInterfaces(this.forwarded, tunnelProperties.remote.host, tunnelProperties.remote.port);
-        attributes = attributes ??
-            ((attributes !== null)
-                ? (await this.getAttributes([tunnelProperties.remote]))?.get(tunnelProperties.remote.port)
-                : undefined);
-        const localPort = (tunnelProperties.local !== undefined) ? tunnelProperties.local : tunnelProperties.remote.port;
-        if (!existingTunnel) {
-            const authority = this.environmentService.remoteAuthority;
-            const addressProvider = authority ? {
-                getAddress: async () => { return (await this.remoteAuthorityResolverService.resolveAuthority(authority)).authority; }
-            } : undefined;
-            const key = makeAddress(tunnelProperties.remote.host, tunnelProperties.remote.port);
-            this.inProgress.set(key, true);
-            tunnelProperties = this.mergeCachedAndUnrestoredProperties(key, tunnelProperties);
-            const tunnel = await this.tunnelService.openTunnel(addressProvider, tunnelProperties.remote.host, tunnelProperties.remote.port, undefined, localPort, (!tunnelProperties.elevateIfNeeded) ? attributes?.elevateIfNeeded : tunnelProperties.elevateIfNeeded, tunnelProperties.privacy, attributes?.protocol);
-            if (tunnel && tunnel.localAddress) {
-                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnelProperties.remote.host, tunnelProperties.remote.port);
-                const protocol = (tunnel.protocol ?
-                    ((tunnel.protocol === TunnelProtocol.Https) ? TunnelProtocol.Https : TunnelProtocol.Http)
-                    : (attributes?.protocol ?? TunnelProtocol.Http));
-                const newForward = {
-                    remoteHost: tunnel.tunnelRemoteHost,
-                    remotePort: tunnel.tunnelRemotePort,
-                    localPort: tunnel.tunnelLocalPort,
-                    name: attributes?.label ?? tunnelProperties.name,
-                    closeable: true,
-                    localAddress: tunnel.localAddress,
-                    protocol,
-                    localUri: await this.makeLocalUri(tunnel.localAddress, attributes),
-                    runningProcess: matchingCandidate?.detail,
-                    hasRunningProcess: !!matchingCandidate,
-                    pid: matchingCandidate?.pid,
-                    source: tunnelProperties.source ?? UserTunnelSource,
-                    privacy: tunnel.privacy,
-                };
-                this.forwarded.set(key, newForward);
-                this.remoteTunnels.set(key, tunnel);
-                this.inProgress.delete(key);
-                await this.storeForwarded();
-                await this.showPortMismatchModalIfNeeded(tunnel, localPort, attributes);
-                this._onForwardPort.fire(newForward);
-                return tunnel;
-            }
-            this.inProgress.delete(key);
-        }
-        else {
-            return this.mergeAttributesIntoExistingTunnel(existingTunnel, tunnelProperties, attributes);
-        }
-        return undefined;
-    }
-    mergeCachedAndUnrestoredProperties(key, tunnelProperties) {
-        const map = ( (this.unrestoredExtensionTunnels.has(key))) ? this.unrestoredExtensionTunnels : (( (this.sessionCachedProperties.has(key))) ? this.sessionCachedProperties : undefined);
-        if (map) {
-            const updateProps = map.get(key);
-            map.delete(key);
-            if (updateProps) {
-                tunnelProperties.name = updateProps.name ?? tunnelProperties.name;
-                tunnelProperties.local = (('local' in updateProps) ? updateProps.local : (('localPort' in updateProps) ? updateProps.localPort : undefined)) ?? tunnelProperties.local;
-                tunnelProperties.privacy = updateProps.privacy ?? tunnelProperties.privacy;
-            }
-        }
-        return tunnelProperties;
-    }
-    async mergeAttributesIntoExistingTunnel(existingTunnel, tunnelProperties, attributes) {
-        const newName = attributes?.label ?? tunnelProperties.name;
-        let MergedAttributeAction;
-        ( ((function(MergedAttributeAction) {
-            MergedAttributeAction[MergedAttributeAction["None"] = 0] = "None";
-            MergedAttributeAction[MergedAttributeAction["Fire"] = 1] = "Fire";
-            MergedAttributeAction[MergedAttributeAction["Reopen"] = 2] = "Reopen";
-        })(MergedAttributeAction || (MergedAttributeAction = {}))));
-        let mergedAction = MergedAttributeAction.None;
-        if (newName !== existingTunnel.name) {
-            existingTunnel.name = newName;
-            mergedAction = MergedAttributeAction.Fire;
-        }
-        if ((attributes?.protocol || (existingTunnel.protocol !== TunnelProtocol.Http)) && (attributes?.protocol !== existingTunnel.protocol)) {
-            tunnelProperties.source = existingTunnel.source;
-            mergedAction = MergedAttributeAction.Reopen;
-        }
-        if (tunnelProperties.privacy && (existingTunnel.privacy !== tunnelProperties.privacy)) {
-            mergedAction = MergedAttributeAction.Reopen;
-        }
-        switch (mergedAction) {
-            case MergedAttributeAction.Fire: {
-                this._onForwardPort.fire();
-                break;
-            }
-            case MergedAttributeAction.Reopen: {
-                await this.close(existingTunnel.remoteHost, existingTunnel.remotePort, TunnelCloseReason.User);
-                await this.forward(tunnelProperties, attributes);
-            }
-        }
-        return mapHasAddressLocalhostOrAllInterfaces(this.remoteTunnels, tunnelProperties.remote.host, tunnelProperties.remote.port);
-    }
-    async name(host, port, name) {
-        const existingForwarded = mapHasAddressLocalhostOrAllInterfaces(this.forwarded, host, port);
-        const key = makeAddress(host, port);
-        if (existingForwarded) {
-            existingForwarded.name = name;
-            await this.storeForwarded();
-            this._onPortName.fire({ host, port });
-            return;
-        }
-        else if (( (this.detected.has(key)))) {
-            this.detected.get(key).name = name;
-            this._onPortName.fire({ host, port });
-        }
-    }
-    async close(host, port, reason) {
-        const key = makeAddress(host, port);
-        const oldTunnel = this.forwarded.get(key);
-        if ((reason === TunnelCloseReason.AutoForwardEnd) && oldTunnel && (oldTunnel.source.source === TunnelSource.Auto)) {
-            this.sessionCachedProperties.set(key, {
-                local: oldTunnel.localPort,
-                name: oldTunnel.name,
-                privacy: oldTunnel.privacy,
-            });
-        }
-        await this.tunnelService.closeTunnel(host, port);
-        return this.onTunnelClosed({ host, port }, reason);
-    }
-    address(host, port) {
-        const key = makeAddress(host, port);
-        return (this.forwarded.get(key) || this.detected.get(key))?.localAddress;
-    }
-    get environmentTunnelsSet() {
-        return this._environmentTunnelsSet;
-    }
-    addEnvironmentTunnels(tunnels) {
-        if (tunnels) {
-            for (const tunnel of tunnels) {
-                const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnel.remoteAddress.host, tunnel.remoteAddress.port);
-                const localAddress = typeof tunnel.localAddress === 'string' ? tunnel.localAddress : makeAddress(tunnel.localAddress.host, tunnel.localAddress.port);
-                this.detected.set(makeAddress(tunnel.remoteAddress.host, tunnel.remoteAddress.port), {
-                    remoteHost: tunnel.remoteAddress.host,
-                    remotePort: tunnel.remoteAddress.port,
-                    localAddress: localAddress,
-                    protocol: TunnelProtocol.Http,
-                    localUri: this.makeLocalUri(localAddress),
-                    closeable: false,
-                    runningProcess: matchingCandidate?.detail,
-                    hasRunningProcess: !!matchingCandidate,
-                    pid: matchingCandidate?.pid,
-                    privacy: TunnelPrivacyId.ConstantPrivate,
-                    source: {
-                        source: TunnelSource.Extension,
-                        description: ( (nls.localize('tunnel.staticallyForwarded', "Statically Forwarded")))
-                    }
-                });
-                this.tunnelService.setEnvironmentTunnel(tunnel.remoteAddress.host, tunnel.remoteAddress.port, localAddress, TunnelPrivacyId.ConstantPrivate, TunnelProtocol.Http);
-            }
-        }
-        this._environmentTunnelsSet = true;
-        this._onEnvironmentTunnelsSet.fire();
-        this._onForwardPort.fire();
-    }
-    setCandidateFilter(filter) {
-        this._candidateFilter = filter;
-    }
-    async setCandidates(candidates) {
-        let processedCandidates = candidates;
-        if (this._candidateFilter) {
-            processedCandidates = await this._candidateFilter(candidates);
-        }
-        const removedCandidates = this.updateInResponseToCandidates(processedCandidates);
-        this.logService.trace(`ForwardedPorts: (TunnelModel) removed candidates ${( ( Array.from(( ( removedCandidates.values()))).map(candidate => candidate.port))).join(', ')}`);
-        this._onCandidatesChanged.fire(removedCandidates);
-    }
-    updateInResponseToCandidates(candidates) {
-        const removedCandidates = this._candidates ?? ( (new Map()));
-        const candidatesMap = ( (new Map()));
-        this._candidates = candidatesMap;
-        candidates.forEach(value => {
-            const addressKey = makeAddress(value.host, value.port);
-            candidatesMap.set(addressKey, {
-                host: value.host,
-                port: value.port,
-                detail: value.detail,
-                pid: value.pid
-            });
-            if (( (removedCandidates.has(addressKey)))) {
-                removedCandidates.delete(addressKey);
-            }
-            const forwardedValue = mapHasAddressLocalhostOrAllInterfaces(this.forwarded, value.host, value.port);
-            if (forwardedValue) {
-                forwardedValue.runningProcess = value.detail;
-                forwardedValue.hasRunningProcess = true;
-                forwardedValue.pid = value.pid;
-            }
-        });
-        removedCandidates.forEach((_value, key) => {
-            const parsedAddress = parseAddress(key);
-            if (!parsedAddress) {
-                return;
-            }
-            const forwardedValue = mapHasAddressLocalhostOrAllInterfaces(this.forwarded, parsedAddress.host, parsedAddress.port);
-            if (forwardedValue) {
-                forwardedValue.runningProcess = undefined;
-                forwardedValue.hasRunningProcess = false;
-                forwardedValue.pid = undefined;
-            }
-            const detectedValue = mapHasAddressLocalhostOrAllInterfaces(this.detected, parsedAddress.host, parsedAddress.port);
-            if (detectedValue) {
-                detectedValue.runningProcess = undefined;
-                detectedValue.hasRunningProcess = false;
-                detectedValue.pid = undefined;
-            }
-        });
-        return removedCandidates;
-    }
-    get candidates() {
-        return this._candidates ? Array.from(( (this._candidates.values()))) : [];
-    }
-    get candidatesOrUndefined() {
-        return this._candidates ? this.candidates : undefined;
-    }
-    async updateAttributes() {
-        const tunnels = Array.from(( (this.forwarded.values())));
-        const allAttributes = await this.getAttributes(( (tunnels.map(tunnel => {
-            return { port: tunnel.remotePort, host: tunnel.remoteHost };
-        }))), false);
-        if (!allAttributes) {
-            return;
-        }
-        for (const forwarded of tunnels) {
-            const attributes = allAttributes.get(forwarded.remotePort);
-            if ((attributes?.protocol || (forwarded.protocol !== TunnelProtocol.Http)) && (attributes?.protocol !== forwarded.protocol)) {
-                await this.forward({
-                    remote: { host: forwarded.remoteHost, port: forwarded.remotePort },
-                    local: forwarded.localPort,
-                    name: forwarded.name,
-                    source: forwarded.source
-                }, attributes);
-            }
-            if (!attributes) {
-                continue;
-            }
-            if (attributes.label && attributes.label !== forwarded.name) {
-                await this.name(forwarded.remoteHost, forwarded.remotePort, attributes.label);
-            }
-        }
-    }
-    async getAttributes(forwardedPorts, checkProviders = true) {
-        const matchingCandidates = ( (new Map()));
-        const pidToPortsMapping = ( (new Map()));
-        forwardedPorts.forEach(forwardedPort => {
-            const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), LOCALHOST_ADDRESSES[0], forwardedPort.port) ?? forwardedPort;
-            if (matchingCandidate) {
-                matchingCandidates.set(forwardedPort.port, matchingCandidate);
-                const pid = isCandidatePort(matchingCandidate) ? matchingCandidate.pid : undefined;
-                if (!( (pidToPortsMapping.has(pid)))) {
-                    pidToPortsMapping.set(pid, []);
-                }
-                pidToPortsMapping.get(pid)?.push(forwardedPort.port);
-            }
-        });
-        const configAttributes = ( (new Map()));
-        forwardedPorts.forEach(forwardedPort => {
-            const attributes = this.configPortsAttributes.getAttributes(forwardedPort.port, forwardedPort.host, matchingCandidates.get(forwardedPort.port)?.detail);
-            if (attributes) {
-                configAttributes.set(forwardedPort.port, attributes);
-            }
-        });
-        if ((this.portAttributesProviders.length === 0) || !checkProviders) {
-            return (configAttributes.size > 0) ? configAttributes : undefined;
-        }
-        const allProviderResults = await Promise.all(flatten(( (this.portAttributesProviders.map(provider => {
-            return (
-                 (Array.from(pidToPortsMapping.entries()).map(entry => {
-                    const portGroup = entry[1];
-                    const matchingCandidate = matchingCandidates.get(portGroup[0]);
-                    return provider.providePortAttributes(portGroup, matchingCandidate?.pid, matchingCandidate?.detail, ( (new CancellationTokenSource())).token);
-                }))
-            );
-        })))));
-        const providedAttributes = ( (new Map()));
-        allProviderResults.forEach(attributes => attributes.forEach(attribute => {
-            if (attribute) {
-                providedAttributes.set(attribute.port, attribute);
-            }
-        }));
-        if (!configAttributes && !providedAttributes) {
-            return undefined;
-        }
-        const mergedAttributes = ( (new Map()));
-        forwardedPorts.forEach(forwardedPorts => {
-            const config = configAttributes.get(forwardedPorts.port);
-            const provider = providedAttributes.get(forwardedPorts.port);
-            mergedAttributes.set(forwardedPorts.port, {
-                elevateIfNeeded: config?.elevateIfNeeded,
-                label: config?.label,
-                onAutoForward: config?.onAutoForward ?? PortsAttributes.providedActionToAction(provider?.autoForwardAction),
-                requireLocalPort: config?.requireLocalPort,
-                protocol: config?.protocol
-            });
-        });
-        return mergedAttributes;
-    }
-    addAttributesProvider(provider) {
-        this.portAttributesProviders.push(provider);
-    }
-};
-TunnelModel.__decorator = ( (__decorate([
-    debounce(1000)
-], TunnelModel.prototype, "storeForwarded", null)));
-TunnelModel = ( (__decorate([
-    ( (__param(0, ITunnelService))),
-    ( (__param(1, IStorageService))),
-    ( (__param(2, IConfigurationService))),
-    ( (__param(3, IWorkbenchEnvironmentService))),
-    ( (__param(4, IRemoteAuthorityResolverService))),
-    ( (__param(5, IWorkspaceContextService))),
-    ( (__param(6, ILogService))),
-    ( (__param(7, IDialogService)))
-], TunnelModel)));
-function isCandidatePort(candidate) {
-    return candidate && 'host' in candidate && typeof candidate.host === 'string'
-        && 'port' in candidate && typeof candidate.port === 'number'
-        && (!('detail' in candidate) || typeof candidate.detail === 'string')
-        && (!('pid' in candidate) || typeof candidate.pid === 'string');
-}
-export { AutoTunnelSource, IRemoteExplorerService, OnPortForward, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, PortsAttributes, TUNNEL_VIEW_ID, TunnelCloseReason, TunnelEditId, TunnelModel, TunnelSource, TunnelType, UserTunnelSource, isCandidatePort, makeAddress, mapHasAddress, mapHasAddressLocalhostOrAllInterfaces, parseAddress };
+})(TunnelEditId || (TunnelEditId = {})));
+export { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT, TUNNEL_VIEW_ID, TunnelEditId, TunnelType };