@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution.js

@@ -0,0 +1,129 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { HelpQuickAccessProvider } from 'monaco-editor/esm/vs/platform/quickinput/browser/helpQuickAccess.js';
+import { ViewQuickAccessProvider, OpenViewPickerAction, QuickAccessViewPickerAction } from './viewQuickAccess.js';
+import { CommandsQuickAccessProvider, ShowAllCommandsAction, ClearCommandHistoryAction } from './commandsQuickAccess.js';
+import { MenuRegistry, MenuId, registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { getQuickNavigateHandler, inQuickPickContext } from '../../../browser/quickaccess.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+const quickAccessRegistry = ( Registry.as(Extensions.Quickaccess));
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: HelpQuickAccessProvider,
+    prefix: HelpQuickAccessProvider.PREFIX,
+    placeholder: ( localize(
+        'helpQuickAccessPlaceholder',
+        "Type '{0}' to get help on the actions you can take from here.",
+        HelpQuickAccessProvider.PREFIX
+    )),
+    helpEntries: [{ description: ( localize('helpQuickAccess', "Show all Quick Access Providers")) }]
+});
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: ViewQuickAccessProvider,
+    prefix: ViewQuickAccessProvider.PREFIX,
+    contextKey: 'inViewsPicker',
+    placeholder: ( localize(
+        'viewQuickAccessPlaceholder',
+        "Type the name of a view, output channel or terminal to open."
+    )),
+    helpEntries: [{ description: ( localize('viewQuickAccess', "Open View")), commandId: OpenViewPickerAction.ID }]
+});
+quickAccessRegistry.registerQuickAccessProvider({
+    ctor: CommandsQuickAccessProvider,
+    prefix: CommandsQuickAccessProvider.PREFIX,
+    contextKey: 'inCommandsPicker',
+    placeholder: ( localize('commandsQuickAccessPlaceholder', "Type the name of a command to run.")),
+    helpEntries: [{ description: ( localize('commandsQuickAccess', "Show and Run Commands")), commandId: ShowAllCommandsAction.ID }]
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
+    group: '1_open',
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize(
+            { key: 'miCommandPalette', comment: ['&& denotes a mnemonic'] },
+            "&&Command Palette..."
+        ))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarHelpMenu, {
+    group: '1_welcome',
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize(
+            { key: 'miShowAllCommands', comment: ['&& denotes a mnemonic'] },
+            "Show All Commands"
+        ))
+    },
+    order: 2
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarViewMenu, {
+    group: '1_open',
+    command: {
+        id: OpenViewPickerAction.ID,
+        title: ( localize(
+            { key: 'miOpenView', comment: ['&& denotes a mnemonic'] },
+            "&&Open View..."
+        ))
+    },
+    order: 2
+});
+MenuRegistry.appendMenuItem(MenuId.MenubarGoMenu, {
+    group: '5_infile_nav',
+    command: {
+        id: 'workbench.action.gotoLine',
+        title: ( localize(
+            { key: 'miGotoLine', comment: ['&& denotes a mnemonic'] },
+            "Go to &&Line/Column..."
+        ))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
+    group: '1_command',
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize('commandPalette', "Command Palette..."))
+    },
+    order: 1
+});
+MenuRegistry.appendMenuItem(MenuId.EditorContext, {
+    group: 'z_commands',
+    when: ( EditorContextKeys.editorSimpleInput.toNegated()),
+    command: {
+        id: ShowAllCommandsAction.ID,
+        title: ( localize('commandPalette', "Command Palette...")),
+    },
+    order: 1
+});
+registerAction2(ClearCommandHistoryAction);
+registerAction2(ShowAllCommandsAction);
+registerAction2(OpenViewPickerAction);
+registerAction2(QuickAccessViewPickerAction);
+const inViewsPickerContextKey = 'inViewsPicker';
+const inViewsPickerContext = ( ContextKeyExpr.and(inQuickPickContext, ( ContextKeyExpr.has(inViewsPickerContextKey))));
+const viewPickerKeybinding = QuickAccessViewPickerAction.KEYBINDING;
+const quickAccessNavigateNextInViewPickerId = 'workbench.action.quickOpenNavigateNextInViewPicker';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: quickAccessNavigateNextInViewPickerId,
+    weight: 200  + 50,
+    handler: getQuickNavigateHandler(quickAccessNavigateNextInViewPickerId, true),
+    when: inViewsPickerContext,
+    primary: viewPickerKeybinding.primary,
+    linux: viewPickerKeybinding.linux,
+    mac: viewPickerKeybinding.mac
+});
+const quickAccessNavigatePreviousInViewPickerId = 'workbench.action.quickOpenNavigatePreviousInViewPicker';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: quickAccessNavigatePreviousInViewPickerId,
+    weight: 200  + 50,
+    handler: getQuickNavigateHandler(quickAccessNavigatePreviousInViewPickerId, false),
+    when: inViewsPickerContext,
+    primary: viewPickerKeybinding.primary | 1024 ,
+    linux: viewPickerKeybinding.linux,
+    mac: {
+        primary: viewPickerKeybinding.mac.primary | 1024
+    }
+});

package/dist/vscode/vs/workbench/contrib/quickaccess/browser/viewQuickAccess.js

@@ -0,0 +1,225 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IQuickInputService, ItemActivation } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { PickerQuickAccessProvider } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { IViewDescriptorService, IViewsService } from '../../../common/views.js';
+import { IOutputService } from '../../../services/output/common/output.js';
+import { ITerminalService, ITerminalGroupService } from '../../terminal/browser/terminal.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { fuzzyContains } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { REPL_VIEW_ID, IDebugService } from '../../debug/common/debug.js';
+let ViewQuickAccessProvider = class ViewQuickAccessProvider extends PickerQuickAccessProvider {
+    constructor(viewDescriptorService, viewsService, outputService, terminalService, terminalGroupService, debugService, paneCompositeService, contextKeyService) {
+        super(ViewQuickAccessProvider.PREFIX, {
+            noResultsPick: {
+                label: ( localize('noViewResults', "No matching views")),
+                containerLabel: ''
+            }
+        });
+        this.viewDescriptorService = viewDescriptorService;
+        this.viewsService = viewsService;
+        this.outputService = outputService;
+        this.terminalService = terminalService;
+        this.terminalGroupService = terminalGroupService;
+        this.debugService = debugService;
+        this.paneCompositeService = paneCompositeService;
+        this.contextKeyService = contextKeyService;
+    }
+    _getPicks(filter) {
+        const filteredViewEntries = this.doGetViewPickItems().filter(entry => {
+            if (!filter) {
+                return true;
+            }
+            entry.highlights = { label: withNullAsUndefined(matchesFuzzy(filter, entry.label, true)) };
+            return entry.highlights.label || fuzzyContains(entry.containerLabel, filter);
+        });
+        const mapEntryToContainer = ( new Map());
+        for (const entry of filteredViewEntries) {
+            if (!( mapEntryToContainer.has(entry.label))) {
+                mapEntryToContainer.set(entry.label, entry.containerLabel);
+            }
+        }
+        const filteredViewEntriesWithSeparators = [];
+        let lastContainer = undefined;
+        for (const entry of filteredViewEntries) {
+            if (lastContainer !== entry.containerLabel) {
+                lastContainer = entry.containerLabel;
+                let separatorLabel;
+                if (( mapEntryToContainer.has(lastContainer))) {
+                    separatorLabel = `${mapEntryToContainer.get(lastContainer)} / ${lastContainer}`;
+                }
+                else {
+                    separatorLabel = lastContainer;
+                }
+                filteredViewEntriesWithSeparators.push({ type: 'separator', label: separatorLabel });
+            }
+            filteredViewEntriesWithSeparators.push(entry);
+        }
+        return filteredViewEntriesWithSeparators;
+    }
+    doGetViewPickItems() {
+        const viewEntries = [];
+        const getViewEntriesForPaneComposite = (paneComposite, viewContainer) => {
+            const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
+            const result = [];
+            for (const view of viewContainerModel.allViewDescriptors) {
+                if (this.contextKeyService.contextMatchesRules(view.when)) {
+                    result.push({
+                        label: view.name,
+                        containerLabel: viewContainerModel.title,
+                        accept: () => this.viewsService.openView(view.id, true)
+                    });
+                }
+            }
+            return result;
+        };
+        const addPaneComposites = (location, containerLabel) => {
+            const paneComposites = this.paneCompositeService.getPaneComposites(location);
+            const visiblePaneCompositeIds = this.paneCompositeService.getVisiblePaneCompositeIds(location);
+            paneComposites.sort((a, b) => {
+                let aIndex = visiblePaneCompositeIds.findIndex(id => a.id === id);
+                let bIndex = visiblePaneCompositeIds.findIndex(id => b.id === id);
+                if (aIndex < 0) {
+                    aIndex = paneComposites.indexOf(a) + visiblePaneCompositeIds.length;
+                }
+                if (bIndex < 0) {
+                    bIndex = paneComposites.indexOf(b) + visiblePaneCompositeIds.length;
+                }
+                return aIndex - bIndex;
+            });
+            for (const paneComposite of paneComposites) {
+                if (this.includeViewContainer(paneComposite)) {
+                    const viewContainer = this.viewDescriptorService.getViewContainerById(paneComposite.id);
+                    if (viewContainer) {
+                        viewEntries.push({
+                            label: this.viewDescriptorService.getViewContainerModel(viewContainer).title,
+                            containerLabel,
+                            accept: () => this.paneCompositeService.openPaneComposite(paneComposite.id, location, true)
+                        });
+                    }
+                }
+            }
+        };
+        addPaneComposites(0 , ( localize('views', "Side Bar")));
+        addPaneComposites(1 , ( localize('panels', "Panel")));
+        addPaneComposites(2 , ( localize('secondary side bar', "Secondary Side Bar")));
+        const addPaneCompositeViews = (location) => {
+            const paneComposites = this.paneCompositeService.getPaneComposites(location);
+            for (const paneComposite of paneComposites) {
+                const viewContainer = this.viewDescriptorService.getViewContainerById(paneComposite.id);
+                if (viewContainer) {
+                    viewEntries.push(...getViewEntriesForPaneComposite(paneComposite, viewContainer));
+                }
+            }
+        };
+        addPaneCompositeViews(0 );
+        addPaneCompositeViews(1 );
+        addPaneCompositeViews(2 );
+        this.terminalGroupService.groups.forEach((group, groupIndex) => {
+            group.terminalInstances.forEach((terminal, terminalIndex) => {
+                const label = ( localize(
+                    'terminalTitle',
+                    "{0}: {1}",
+                    `${groupIndex + 1}.${terminalIndex + 1}`,
+                    terminal.title
+                ));
+                viewEntries.push({
+                    label,
+                    containerLabel: ( localize('terminals', "Terminal")),
+                    accept: async () => {
+                        await this.terminalGroupService.showPanel(true);
+                        this.terminalService.setActiveInstance(terminal);
+                    }
+                });
+            });
+        });
+        this.debugService.getModel().getSessions(true).filter(s => s.hasSeparateRepl()).forEach((session, _) => {
+            const label = session.name;
+            viewEntries.push({
+                label,
+                containerLabel: ( localize('debugConsoles', "Debug Console")),
+                accept: async () => {
+                    await this.debugService.focusStackFrame(undefined, undefined, session, { explicit: true });
+                    if (!this.viewsService.isViewVisible(REPL_VIEW_ID)) {
+                        await this.viewsService.openView(REPL_VIEW_ID, true);
+                    }
+                }
+            });
+        });
+        const channels = this.outputService.getChannelDescriptors();
+        for (const channel of channels) {
+            viewEntries.push({
+                label: channel.label,
+                containerLabel: ( localize('channels', "Output")),
+                accept: () => this.outputService.showChannel(channel.id)
+            });
+        }
+        return viewEntries;
+    }
+    includeViewContainer(container) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(container.id);
+        if (viewContainer?.hideIfEmpty) {
+            return this.viewDescriptorService.getViewContainerModel(viewContainer).activeViewDescriptors.length > 0;
+        }
+        return true;
+    }
+};
+ViewQuickAccessProvider.PREFIX = 'view ';
+ViewQuickAccessProvider = ( __decorate([
+    ( __param(0, IViewDescriptorService)),
+    ( __param(1, IViewsService)),
+    ( __param(2, IOutputService)),
+    ( __param(3, ITerminalService)),
+    ( __param(4, ITerminalGroupService)),
+    ( __param(5, IDebugService)),
+    ( __param(6, IPaneCompositePartService)),
+    ( __param(7, IContextKeyService))
+], ViewQuickAccessProvider));
+class OpenViewPickerAction extends Action2 {
+    constructor() {
+        super({
+            id: OpenViewPickerAction.ID,
+            title: { value: ( localize('openView', "Open View")), original: 'Open View' },
+            category: Categories.View,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        accessor.get(IQuickInputService).quickAccess.show(ViewQuickAccessProvider.PREFIX);
+    }
+}
+OpenViewPickerAction.ID = 'workbench.action.openView';
+class QuickAccessViewPickerAction extends Action2 {
+    constructor() {
+        super({
+            id: QuickAccessViewPickerAction.ID,
+            title: { value: ( localize('quickOpenView', "Quick Open View")), original: 'Quick Open View' },
+            category: Categories.View,
+            f1: false,
+            keybinding: {
+                weight: 200 ,
+                when: undefined,
+                ...QuickAccessViewPickerAction.KEYBINDING
+            }
+        });
+    }
+    async run(accessor) {
+        const keybindingService = accessor.get(IKeybindingService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const keys = keybindingService.lookupKeybindings(QuickAccessViewPickerAction.ID);
+        quickInputService.quickAccess.show(ViewQuickAccessProvider.PREFIX, { quickNavigateConfiguration: { keybindings: keys }, itemActivation: ItemActivation.FIRST });
+    }
+}
+QuickAccessViewPickerAction.ID = 'workbench.action.quickOpenView';
+QuickAccessViewPickerAction.KEYBINDING = {
+    primary: 2048  | 47 ,
+    mac: { primary: 256  | 47  },
+    linux: { primary: 0 }
+};
+export { OpenViewPickerAction, QuickAccessViewPickerAction, ViewQuickAccessProvider };

package/dist/vscode/vs/workbench/contrib/remote/browser/media/tunnelView.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".ports-view .monaco-icon-label,.ports-view .monaco-list .monaco-list-row.focused .monaco-icon-label,.ports-view .monaco-list .monaco-list-row:hover:not(.highlighted) .monaco-icon-label{flex:1}.ports-view .monaco-list .monaco-list-row .actionBarContainer{flex:1 0 auto;flex:0 0 auto;text-align:right}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell{display:flex;flex:1;flex-wrap:nowrap;height:22px;overflow:hidden;text-overflow:ellipsis}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell .monaco-inputbox{flex:1;height:22px;line-height:19px}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell .monaco-inputbox input{margin-top:-40px}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell .ports-view-actionbar-cell-localaddress:hover{text-decoration:underline}.ports-view .monaco-table-td[data-col-index=\"0\"],.ports-view .monaco-table-th,.ports-view .monaco-table-th[data-col-index=\"0\"]{padding-left:10px}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell .monaco-button{line-height:1.4em;margin-bottom:3px;margin-left:3px;margin-top:4px;padding:2px 14px;width:auto}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell>.ports-view-actionbar-cell-icon.codicon{margin-top:3px;padding-right:3px}.ports-view .monaco-list .monaco-list-row.selected .ports-view-actionbar-cell>.ports-view-actionbar-cell-icon.codicon{color:currentColor!important}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell .ports-view-actionbar-cell-resourceLabel .monaco-icon-label-container>.monaco-icon-name-container{flex:1}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell .ports-view-actionbar-cell-resourceLabel:after{padding-right:0}.ports-view .monaco-list .monaco-list-row .ports-view-actionbar-cell .actions{display:none}.ports-view .monaco-list .monaco-list-row.focused .ports-view-actionbar-cell .actions,.ports-view .monaco-list .monaco-list-row.selected .ports-view-actionbar-cell .actions,.ports-view .monaco-list .monaco-list-row:hover .ports-view-actionbar-cell .actions{display:block}.ports-view .monaco-list .ports-view-actionbar-cell .actions .action-label{background-position:50% 50%;background-repeat:no-repeat;background-size:16px;height:100%;padding:2px;width:16px}.monaco-workbench .codicon.codicon-ports-forwarded-with-process-icon{color:var(--vscode-ports-iconRunningProcessForeground)}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/contrib/remote/browser/remoteExplorer.js

@@ -1,9 +1,10 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { OnPortForward, AutoTunnelSource, makeAddress } from '../../../services/remote/common/remoteExplorerService.js';
+import { OnPortForward, mapHasAddressLocalhostOrAllInterfaces, TunnelCloseReason, AutoTunnelSource, makeAddress } from '../../../services/remote/common/remoteExplorerService.js';
 import { OpenPortInPreviewAction, OpenPortInBrowserAction, TunnelPanel, openPreviewEnabledContext } from './tunnelView.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { TunnelPrivacyId } from '../../../../platform/tunnel/common/tunnel.js';
 const VIEWLET_ID = 'workbench.view.remote';
 class OnAutoForwardedAction extends Disposable {
     constructor(notificationService, remoteExplorerService, openerService, externalOpenerService, tunnelService, hostService, logService, contextKeyService) {
@@ -130,6 +131,9 @@ class OnAutoForwardedAction extends Disposable {
             ));
             choices.unshift(this.elevateChoice(tunnel));
         }
+        if (tunnel.privacy === TunnelPrivacyId.Private && isWeb && this.tunnelService.canChangePrivacy) {
+            choices.push(this.makePublicChoice(tunnel));
+        }
         message += this.linkMessage();
         this.lastNotification = this.notificationService.prompt(Severity.Info, message, choices, { neverShowAgain: { id: 'remote.tunnelsView.autoForwardNeverShow', isSecondary: true } });
         this.lastShownPort = tunnel.tunnelRemotePort;
@@ -139,6 +143,23 @@ class OnAutoForwardedAction extends Disposable {
             this.lastShownPort = undefined;
         });
     }
+    makePublicChoice(tunnel) {
+        return {
+            label: ( nls.localize('remote.tunnelsView.makePublic', "Make Public")),
+            run: async () => {
+                const oldTunnelDetails = mapHasAddressLocalhostOrAllInterfaces(this.remoteExplorerService.tunnelModel.forwarded, tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
+                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
+                return this.remoteExplorerService.forward({
+                    remote: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort },
+                    local: tunnel.tunnelLocalPort,
+                    name: oldTunnelDetails?.name,
+                    elevateIfNeeded: true,
+                    privacy: TunnelPrivacyId.Public,
+                    source: oldTunnelDetails?.source
+                });
+            }
+        };
+    }
     openBrowserChoice(tunnel) {
         const address = makeAddress(tunnel.tunnelRemoteHost, tunnel.tunnelRemotePort);
         return {
@@ -161,7 +182,7 @@ class OnAutoForwardedAction extends Disposable {
                 tunnel.tunnelRemotePort
             )),
             run: async () => {
-                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort });
+                await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
                 const newTunnel = await this.remoteExplorerService.forward({
                     remote: { host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort },
                     local: tunnel.tunnelRemotePort,

package/dist/vscode/vs/workbench/contrib/remote/browser/remoteIcons.js

@@ -1,23 +1,27 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-const privatePortIcon = ( registerIcon('private-ports-view-icon', Codicon.lock, ( nls.localize('privatePortIcon', 'Icon representing a private remote port.'))));
-const forwardPortIcon = ( registerIcon('ports-forward-icon', Codicon.plus, ( nls.localize('forwardPortIcon', 'Icon for the forward action.'))));
-const stopForwardIcon = ( registerIcon('ports-stop-forward-icon', Codicon.x, ( nls.localize('stopForwardIcon', 'Icon for the stop forwarding action.'))));
-const openBrowserIcon = ( registerIcon('ports-open-browser-icon', Codicon.globe, ( nls.localize('openBrowserIcon', 'Icon for the open browser action.'))));
-const openPreviewIcon = ( registerIcon('ports-open-preview-icon', Codicon.openPreview, ( nls.localize('openPreviewIcon', 'Icon for the open preview action.'))));
-const copyAddressIcon = ( registerIcon('ports-copy-address-icon', Codicon.clippy, ( nls.localize('copyAddressIcon', 'Icon for the copy local address action.'))));
-const labelPortIcon = ( registerIcon('ports-label-icon', Codicon.tag, ( nls.localize('labelPortIcon', 'Icon for the label port action.'))));
-const forwardedPortWithoutProcessIcon = ( registerIcon(
- 'ports-forwarded-without-process-icon',
- Codicon.circleOutline,
- ( nls.localize(
-  'forwardedPortWithoutProcessIcon',
-  'Icon for forwarded ports that don\'t have a running process.'
- ))
-));
-const forwardedPortWithProcessIcon = ( registerIcon('ports-forwarded-with-process-icon', Codicon.circleFilled, ( nls.localize(
+registerIcon('remote-explorer-get-started', Codicon.star, ( nls.localize('getStartedIcon', 'Getting started icon in the remote explorer view.')));
+registerIcon('remote-explorer-documentation', Codicon.book, ( nls.localize('documentationIcon', 'Documentation icon in the remote explorer view.')));
+registerIcon('remote-explorer-feedback', Codicon.twitter, ( nls.localize('feedbackIcon', 'Feedback icon in the remote explorer view.')));
+registerIcon('remote-explorer-review-issues', Codicon.issues, ( nls.localize('reviewIssuesIcon', 'Review issue icon in the remote explorer view.')));
+registerIcon('remote-explorer-report-issues', Codicon.comment, ( nls.localize('reportIssuesIcon', 'Report issue icon in the remote explorer view.')));
+registerIcon('remote-explorer-view-icon', Codicon.remoteExplorer, ( nls.localize('remoteExplorerViewIcon', 'View icon of the remote explorer view.')));
+registerIcon('ports-view-icon', Codicon.plug, ( nls.localize('portsViewIcon', 'View icon of the remote ports view.')));
+registerIcon('ports-view-icon', Codicon.plug, ( nls.localize('portIcon', 'Icon representing a remote port.')));
+const privatePortIcon = registerIcon('private-ports-view-icon', Codicon.lock, ( nls.localize('privatePortIcon', 'Icon representing a private remote port.')));
+const forwardPortIcon = registerIcon('ports-forward-icon', Codicon.plus, ( nls.localize('forwardPortIcon', 'Icon for the forward action.')));
+const stopForwardIcon = registerIcon('ports-stop-forward-icon', Codicon.x, ( nls.localize('stopForwardIcon', 'Icon for the stop forwarding action.')));
+const openBrowserIcon = registerIcon('ports-open-browser-icon', Codicon.globe, ( nls.localize('openBrowserIcon', 'Icon for the open browser action.')));
+const openPreviewIcon = registerIcon('ports-open-preview-icon', Codicon.openPreview, ( nls.localize('openPreviewIcon', 'Icon for the open preview action.')));
+const copyAddressIcon = registerIcon('ports-copy-address-icon', Codicon.clippy, ( nls.localize('copyAddressIcon', 'Icon for the copy local address action.')));
+const labelPortIcon = registerIcon('ports-label-icon', Codicon.tag, ( nls.localize('labelPortIcon', 'Icon for the label port action.')));
+const forwardedPortWithoutProcessIcon = registerIcon('ports-forwarded-without-process-icon', Codicon.circleOutline, ( nls.localize(
+ 'forwardedPortWithoutProcessIcon',
+ 'Icon for forwarded ports that don\'t have a running process.'
+)));
+const forwardedPortWithProcessIcon = registerIcon('ports-forwarded-with-process-icon', Codicon.circleFilled, ( nls.localize(
  'forwardedPortWithProcessIcon',
  'Icon for forwarded ports that do have a running process.'
-))));
+)));
 export { copyAddressIcon, forwardPortIcon, forwardedPortWithProcessIcon, forwardedPortWithoutProcessIcon, labelPortIcon, openBrowserIcon, openPreviewIcon, privatePortIcon, stopForwardIcon };

package/dist/vscode/vs/workbench/contrib/remote/browser/tunnelView.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/tunnelView.css";
+import './media/tunnelView.css.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { IViewDescriptorService, IViewsService } from '../../../common/views.js';
@@ -18,7 +18,7 @@ import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLa
 import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { MenuRegistry, MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { createAndFillInActionBarActions, createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { TUNNEL_VIEW_ID, TunnelType, makeAddress, IRemoteExplorerService, TunnelEditId, parseAddress, mapHasAddressLocalhostOrAllInterfaces } from '../../../services/remote/common/remoteExplorerService.js';
+import { TUNNEL_VIEW_ID, TunnelType, makeAddress, IRemoteExplorerService, TunnelEditId, parseAddress, TunnelCloseReason, mapHasAddressLocalhostOrAllInterfaces } from '../../../services/remote/common/remoteExplorerService.js';
 import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
 import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
@@ -1099,7 +1099,7 @@ var ClosePortAction;
                 return;
             }
             return Promise.all(( (ports.map(
-                port => remoteExplorerService.close({ host: port.remoteHost, port: port.remotePort })
+                port => remoteExplorerService.close({ host: port.remoteHost, port: port.remotePort }, TunnelCloseReason.User)
             ))));
         };
     }
@@ -1113,7 +1113,7 @@ var ClosePortAction;
             const picks = makeTunnelPicks(Array.from(( (remoteExplorerService.tunnelModel.forwarded.values()))).filter(tunnel => tunnel.closeable), remoteExplorerService, tunnelService);
             const result = await quickInputService.pick(picks, { placeHolder: ( (nls.localize('remote.tunnel.closePlaceholder', "Choose a port to stop forwarding"))) });
             if (result && result.tunnel) {
-                await remoteExplorerService.close({ host: result.tunnel.remoteHost, port: result.tunnel.remotePort });
+                await remoteExplorerService.close({ host: result.tunnel.remoteHost, port: result.tunnel.remotePort }, TunnelCloseReason.User);
             }
             else if (result) {
                 await commandService.executeCommand(ForwardPortAction.COMMANDPALETTE_ID);
@@ -1322,7 +1322,7 @@ var ChangeLocalPortAction;
                     onFinish: async (value, success) => {
                         remoteExplorerService.setEditable(tunnelItem, TunnelEditId.LocalPort, null);
                         if (success) {
-                            await remoteExplorerService.close({ host: tunnelItem.remoteHost, port: tunnelItem.remotePort });
+                            await remoteExplorerService.close({ host: tunnelItem.remoteHost, port: tunnelItem.remotePort }, TunnelCloseReason.Other);
                             const numberValue = Number(value);
                             const newForward = await remoteExplorerService.forward({
                                 remote: { host: tunnelItem.remoteHost, port: tunnelItem.remotePort },
@@ -1355,7 +1355,7 @@ var ChangeTunnelPrivacyAction;
         return async (accessor, arg) => {
             if (isITunnelItem(arg)) {
                 const remoteExplorerService = accessor.get(IRemoteExplorerService);
-                await remoteExplorerService.close({ host: arg.remoteHost, port: arg.remotePort });
+                await remoteExplorerService.close({ host: arg.remoteHost, port: arg.remotePort }, TunnelCloseReason.Other);
                 return remoteExplorerService.forward({
                     remote: { host: arg.remoteHost, port: arg.remotePort },
                     local: arg.localPort,