@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/hostFilterActionViewItem.js

@@ -0,0 +1,353 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as hostFilter from './media/hostFilter.css';
+import { append, $, EventType, addDisposableListener, EventHelper, clearNode, isMouseEvent, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Gesture, EventType as EventType$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { renderIcon, renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { AgentHostFilterConnectionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter';
+import { IAgentHostFilterService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service';
+
+registerCss(hostFilter, 1);
+let HostFilterActionViewItem = class HostFilterActionViewItem extends BaseActionViewItem {
+    constructor(
+        action,
+        _appearance = "titlebar",
+        _filterService,
+        _contextMenuService,
+        _hoverService
+    ) {
+        super(undefined, action);
+        this._appearance = _appearance;
+        this._filterService = _filterService;
+        this._contextMenuService = _contextMenuService;
+        this._hoverService = _hoverService;
+        this._dropdownHover = this._register(( new MutableDisposable()));
+        this._connectHover = this._register(( new MutableDisposable()));
+        this._register(this._filterService.onDidChange(() => this._update()));
+        this._register(this._filterService.onDidChangeDiscovering(() => this._update()));
+    }
+    render(container) {
+        super.render(container);
+        if (!this.element) {
+            return;
+        }
+        this.element.classList.add("agent-host-filter-combo");
+        if (this._appearance === "sidebar") {
+            this.element.classList.add("sidebar");
+            this._renderSidebar();
+        } else {
+            this._renderTitlebar();
+        }
+        this._update();
+    }
+    _renderTitlebar() {
+        if (!this.element) {
+            return;
+        }
+        this._dropdownElement = append(this.element, $("div.agent-host-filter-dropdown"));
+        const iconWrap = append(this._dropdownElement, $("span.agent-host-filter-icon"));
+        this._titlebarLeadingIcon = append(iconWrap, renderIcon(Codicon.remote));
+        this._labelElement = append(this._dropdownElement, $("span.agent-host-filter-label"));
+        this._chevronElement = append(this._dropdownElement, $("span.agent-host-filter-chevron"));
+        this._chevronElement.append(...renderLabelWithIcons(`$(${Codicon.chevronDown.id})`));
+        this._register(Gesture.addTarget(this._dropdownElement));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            this._register(addDisposableListener(this._dropdownElement, eventType, e => {
+                if (!this._isInteractive()) {
+                    return;
+                }
+                EventHelper.stop(e, true);
+                this._showMenu(e);
+            }));
+        }
+        this._register(
+            addDisposableListener(this._dropdownElement, EventType.KEY_DOWN, e => {
+                if (!this._isInteractive()) {
+                    return;
+                }
+                const event = ( new StandardKeyboardEvent(e));
+                if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                    EventHelper.stop(e, true);
+                    this._showMenu(e);
+                }
+            })
+        );
+        this._connectElement = append(this.element, $("div.agent-host-filter-connect"));
+        this._wireConnectButton(this._connectElement);
+    }
+    _renderSidebar() {
+        if (!this.element) {
+            return;
+        }
+        this.element.classList.add("sidebar-action");
+        const buttonContainer = append(this.element, $(".customization-link-button-container"));
+        this._sidebarButton = this._register(( new Button(buttonContainer, {
+            ...defaultButtonStyles,
+            secondary: true,
+            title: false,
+            supportIcons: true,
+            buttonSecondaryBackground: "transparent",
+            buttonSecondaryHoverBackground: undefined,
+            buttonSecondaryForeground: undefined,
+            buttonSecondaryBorder: undefined
+        })));
+        this._sidebarButton.element.classList.add(
+            "customization-link-button",
+            "sidebar-action-button",
+            "agent-host-filter-button",
+            "monaco-text-button"
+        );
+        this._dropdownElement = this._sidebarButton.element;
+        this._sidebarLeadingIcon = append(this._sidebarButton.element, $("span.agent-host-filter-leading-icon"));
+        this._sidebarLeadingIcon.classList.add("codicon", `codicon-${Codicon.remote.id}`);
+        this._labelElement = append(this._sidebarButton.element, $("span.agent-host-filter-label"));
+        this._sidebarTrailingIcon = $("span.agent-host-filter-trailing-icon.codicon");
+        this._sidebarTrailingIcon.classList.add(`codicon-${Codicon.chevronDown.id}`);
+        this._register(this._sidebarButton.onDidClick(e => {
+            if (!this._isInteractive()) {
+                return;
+            }
+            this._showMenu(e);
+        }));
+        this._connectElement = append(this.element, $("div.agent-host-filter-connect"));
+        this._wireConnectButton(this._connectElement);
+    }
+    _wireConnectButton(connectElement) {
+        this._register(Gesture.addTarget(connectElement));
+        for (const eventType of [EventType.CLICK, EventType$1.Tap]) {
+            this._register(addDisposableListener(connectElement, eventType, e => {
+                EventHelper.stop(e, true);
+                this._onConnectClick();
+            }));
+        }
+        this._register(addDisposableListener(connectElement, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                EventHelper.stop(e, true);
+                this._onConnectClick();
+            }
+        }));
+    }
+    _renderSidebarButtonAffordances(interactive, retryOnClick) {
+        if (!this._sidebarButton || !this._sidebarTrailingIcon) {
+            return;
+        }
+        const showChevron = interactive && !retryOnClick;
+        if (showChevron) {
+            if (!this._sidebarTrailingIcon.isConnected) {
+                this._sidebarButton.element.appendChild(this._sidebarTrailingIcon);
+            }
+        } else {
+            this._sidebarTrailingIcon.remove();
+        }
+    }
+    _isInteractive() {
+        return this._filterService.hosts.length > 1 || this._canRetry();
+    }
+    _canRetry() {
+        return !( this._filterService.hosts.some(h => h.connectable));
+    }
+    _retriesOnClick() {
+        return this._filterService.hosts.length <= 1 && this._canRetry();
+    }
+    _update() {
+        if (!this.element || !this._dropdownElement || !this._labelElement || !this._connectElement) {
+            return;
+        }
+        if (!this._sidebarButton && !this._chevronElement) {
+            return;
+        }
+        const hosts = this._filterService.hosts;
+        const selected = this._filterService.selectedHost;
+        const hasMenu = hosts.length > 1;
+        const canRetry = this._canRetry();
+        const retryOnClick = this._retriesOnClick();
+        const interactive = this._isInteractive();
+        const discovering = this._filterService.isDiscovering;
+        const text = selected ? selected.label : discovering ? ( localize(4272, "Searching…")) : ( localize(4273, "No Host"));
+        if (this._sidebarButton) {
+            this._labelElement.textContent = text;
+            this._renderSidebarButtonAffordances(interactive, retryOnClick);
+        } else {
+            this._labelElement.textContent = text;
+        }
+        this._renderLeadingIcon(selected?.icon ?? Codicon.remote);
+        this.element.classList.toggle("single-host", !interactive);
+        this._dropdownElement.classList.toggle("discovering", discovering);
+        this._dropdownElement.classList.toggle("no-hosts", hosts.length === 0);
+        if (this._chevronElement) {
+            clearNode(this._chevronElement);
+            const chevronIconId = retryOnClick ? Codicon.refresh.id : Codicon.chevronDown.id;
+            this._chevronElement.append(...renderLabelWithIcons(`$(${chevronIconId})`));
+        }
+        if (interactive) {
+            if (!this._sidebarButton) {
+                this._dropdownElement.tabIndex = 0;
+                this._dropdownElement.role = "button";
+                if (hasMenu) {
+                    this._dropdownElement.setAttribute("aria-haspopup", "menu");
+                } else {
+                    this._dropdownElement.removeAttribute("aria-haspopup");
+                }
+            } else if (hasMenu) {
+                this._dropdownElement.setAttribute("aria-haspopup", "menu");
+            } else {
+                this._dropdownElement.removeAttribute("aria-haspopup");
+            }
+            const ariaLabel = !selected ? (retryOnClick ? ( localize(4274, "No hosts found. Click to re-discover hosts.")) : ( localize(4275, "No agent host selected."))) : retryOnClick ? ( localize(
+                4276,
+                "Sessions scoped to host {0}. Click to re-discover hosts.",
+                selected.label
+            )) : ( localize(4277, "Sessions scoped to host {0}. Click to change host.", selected.label));
+            this._dropdownElement.setAttribute("aria-label", ariaLabel);
+            const hoverText = retryOnClick ? (discovering ? ( localize(4278, "Searching for hosts…")) : ( localize(4279, "Re-discover hosts"))) : ( localize(4280, "Change the host the sessions list is scoped to"));
+            this._dropdownHover.value = this._hoverService.setupManagedHover(getDefaultHoverDelegate("element"), this._dropdownElement, () => hoverText);
+        } else {
+            if (!this._sidebarButton) {
+                this._dropdownElement.removeAttribute("tabindex");
+                this._dropdownElement.removeAttribute("role");
+            }
+            this._dropdownElement.removeAttribute("aria-haspopup");
+            this._dropdownElement.setAttribute("aria-label", selected ? ( localize(4281, "Sessions scoped to host {0}", selected.label)) : ( localize(4275, "No agent host selected.")));
+            this._dropdownHover.clear();
+        }
+        this._updateConnectButton(selected, canRetry, discovering);
+    }
+    _renderLeadingIcon(icon) {
+        for (const element of [this._sidebarLeadingIcon, this._titlebarLeadingIcon]) {
+            if (!element) {
+                continue;
+            }
+            const classes = ThemeIcon.asClassNameArray(icon);
+            if (classes.every(c => element.classList.contains(c))) {
+                continue;
+            }
+            element.classList.remove(...[...element.classList].filter(c => c.startsWith("codicon")));
+            element.classList.add(...classes);
+        }
+    }
+    _updateConnectButton(selected, canRetry, discovering) {
+        if (!this._connectElement) {
+            return;
+        }
+        clearNode(this._connectElement);
+        this._connectElement.classList.remove("connected", "connecting", "disconnected", "rediscover", "hidden");
+        this._connectHover.clear();
+        if (canRetry && this._sidebarButton && !selected?.connectable) {
+            this._connectElement.setAttribute("role", "button");
+            this._connectElement.tabIndex = 0;
+            this._connectElement.classList.add("rediscover");
+            this._connectElement.append(...renderLabelWithIcons(`$(${Codicon.refresh.id})`));
+            const hoverText = discovering ? ( localize(4278, "Searching for hosts…")) : ( localize(4279, "Re-discover hosts"));
+            this._connectElement.setAttribute("aria-label", hoverText);
+            this._connectHover.value = this._hoverService.setupManagedHover(getDefaultHoverDelegate("element"), this._connectElement, () => hoverText);
+            return;
+        }
+        if (!selected) {
+            this._connectElement.classList.add("hidden");
+            this._connectElement.removeAttribute("role");
+            this._connectElement.removeAttribute("tabindex");
+            return;
+        }
+        if (!selected.connectable) {
+            this._connectElement.classList.add("hidden");
+            this._connectElement.removeAttribute("role");
+            this._connectElement.removeAttribute("tabindex");
+            return;
+        }
+        this._connectElement.setAttribute("role", "button");
+        this._connectElement.tabIndex = 0;
+        let iconId;
+        let hoverText;
+        switch (selected.status) {
+        case AgentHostFilterConnectionStatus.Connected:
+            iconId = Codicon.debugConnected.id;
+            this._connectElement.classList.add("connected");
+            hoverText = ( localize(4282, "Connected to {0}. Click to disconnect.", selected.label));
+            break;
+        case AgentHostFilterConnectionStatus.Connecting:
+            iconId = Codicon.debugConnected.id;
+            this._connectElement.classList.add("connecting");
+            hoverText = ( localize(4283, "Connecting to {0}… Click to cancel.", selected.label));
+            break;
+        case AgentHostFilterConnectionStatus.Disconnected:
+        default:
+            iconId = Codicon.debugDisconnect.id;
+            this._connectElement.classList.add("disconnected");
+            hoverText = ( localize(4284, "Disconnected from {0}. Click to connect.", selected.label));
+            break;
+        }
+        this._connectElement.append(...renderLabelWithIcons(`$(${iconId})`));
+        this._connectElement.setAttribute("aria-label", hoverText);
+        const connectHoverDelegate = getDefaultHoverDelegate("element");
+        this._connectHover.value = this._hoverService.setupManagedHover(connectHoverDelegate, this._connectElement, () => hoverText);
+    }
+    _onConnectClick() {
+        if (this._connectElement?.classList.contains("rediscover")) {
+            if (!this._filterService.isDiscovering) {
+                this._filterService.rediscover();
+            }
+            return;
+        }
+        const selected = this._filterService.selectedHost;
+        if (!selected || !selected.connectable) {
+            return;
+        }
+        if (selected.status === AgentHostFilterConnectionStatus.Disconnected) {
+            this._filterService.reconnect(selected.id);
+        } else {
+            this._filterService.disconnect(selected.id);
+        }
+    }
+    _showMenu(e) {
+        if (!this._dropdownElement) {
+            return;
+        }
+        if (this._retriesOnClick()) {
+            if (!this._filterService.isDiscovering) {
+                this._filterService.rediscover();
+            }
+            return;
+        }
+        const hosts = this._filterService.hosts;
+        if (hosts.length <= 1) {
+            return;
+        }
+        const selectedId = this._filterService.selectedHostId;
+        const actions = [];
+        for (const host of hosts) {
+            const label = !host.connectable || host.status === AgentHostFilterConnectionStatus.Connected ? host.label : host.status === AgentHostFilterConnectionStatus.Connecting ? ( localize(4285, "{0} (connecting…)", host.label)) : ( localize(4286, "{0} (disconnected)", host.label));
+            actions.push(( new Action(
+                `agentHostFilter.host.${host.id}`,
+                label,
+                selectedId === host.id ? "codicon codicon-check" : undefined,
+                true,
+                async () => this._filterService.setSelectedHostId(host.id)
+            )));
+        }
+        const anchor = isMouseEvent(e) ? ( new StandardMouseEvent(getWindow(this._dropdownElement), e)) : this._dropdownElement;
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => actions,
+            domForShadowRoot: this._dropdownElement
+        });
+    }
+};
+HostFilterActionViewItem = ( __decorate([( __param(2, IAgentHostFilterService)), ( __param(3, IContextMenuService)), ( __param(4, IHoverService))], HostFilterActionViewItem));
+
+export { HostFilterActionViewItem };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/manageRemoteAgentHosts.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/manageRemoteAgentHosts.js

@@ -0,0 +1,161 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { RemoteAgentHostsEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { TUNNEL_ADDRESS_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SessionsCategories } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/categories';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { getStatusLabel, removeRemoteHost, showRemoteHostOptions } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteHostOptions';
+import { RemoteAgentHostCommandIds } from './remoteAgentHostActions.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.manageRemoteAgentHosts,
+            title: ( localize2(4287, "Manage Remote Agent Hosts...")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            precondition: ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true))
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const sessionsProvidersService = accessor.get(ISessionsProvidersService);
+        const remoteAgentHostService = accessor.get(IRemoteAgentHostService);
+        const configurationService = accessor.get(IConfigurationService);
+        const menuService = accessor.get(IMenuService);
+        const contextKeyService = accessor.get(IContextKeyService);
+        const commandService = accessor.get(ICommandService);
+        const instantiationService = accessor.get(IInstantiationService);
+        const removeButton = {
+            iconClass: ThemeIcon.asClassName(Codicon.close),
+            tooltip: ( localize(4288, "Remove"))
+        };
+        const buildItems = () => {
+            const remoteProviders =
+            sessionsProvidersService.getProviders().filter(isAgentHostProvider).filter(p => !!p.remoteAddress).filter(p => !p.hostGroup);
+            const remoteItems = remoteProviders.map(p => {
+                const isTunnel = p.remoteAddress?.startsWith(TUNNEL_ADDRESS_PREFIX);
+                const status = p.connectionStatus?.get();
+                const item = {
+                    kind: "remote",
+                    provider: p,
+                    label: `$(${isTunnel ? "cloud" : "remote"}) ${p.label}`,
+                    description: status !== undefined ? getStatusLabel(status) : undefined,
+                    detail: p.remoteAddress
+                };
+                item.buttons = [removeButton];
+                return item;
+            });
+            const menuActionItems = [];
+            const menuActions = menuService.getMenuActions(Menus.SessionWorkspaceManage, contextKeyService, {
+                renderShortTitle: true
+            });
+            for (const [, actions] of menuActions) {
+                for (const action of actions) {
+                    if (action instanceof MenuItemAction) {
+                        const icon = ThemeIcon.isThemeIcon(action.item.icon) ? action.item.icon : undefined;
+                        menuActionItems.push({
+                            kind: "menu-action",
+                            action,
+                            label: icon ? `$(${icon.id}) ${action.label}` : action.label,
+                            description: action.tooltip || undefined
+                        });
+                    }
+                }
+            }
+            const items = [];
+            if (remoteItems.length > 0) {
+                items.push({
+                    type: "separator",
+                    label: ( localize(4289, "Remote Agent Hosts"))
+                });
+                items.push(...remoteItems);
+            }
+            if (menuActionItems.length > 0) {
+                items.push({
+                    type: "separator",
+                    label: ( localize(4290, "Add or Manage"))
+                });
+                items.push(...menuActionItems);
+            }
+            return items;
+        };
+        const showManagePicker = () => {
+            const store = ( new DisposableStore());
+            const picker = quickInputService.createQuickPick({
+                useSeparators: true
+            });
+            store.add(picker);
+            picker.title = ( localize(4291, "Manage Remote Agent Hosts"));
+            picker.placeholder = ( localize(4292, "Select a remote to manage or pick an action"));
+            picker.matchOnDescription = true;
+            picker.matchOnDetail = true;
+            let lastFilter = "";
+            const refresh = () => {
+                lastFilter = picker.value;
+                picker.items = buildItems();
+                picker.value = lastFilter;
+            };
+            refresh();
+            store.add(sessionsProvidersService.onDidChangeProviders(() => refresh()));
+            const observerStore = store.add(( new DisposableStore()));
+            const subscribeToProviders = () => {
+                observerStore.clear();
+                for (const p of sessionsProvidersService.getProviders()) {
+                    if (isAgentHostProvider(p) && p.connectionStatus) {
+                        observerStore.add(autorun(reader => {
+                            p.connectionStatus.read(reader);
+                            refresh();
+                        }));
+                    }
+                }
+            };
+            subscribeToProviders();
+            store.add(
+                sessionsProvidersService.onDidChangeProviders(() => subscribeToProviders())
+            );
+            store.add(picker.onDidTriggerItemButton(async e => {
+                if (e.item.kind === "remote" && e.button === removeButton) {
+                    await removeRemoteHost(e.item.provider, remoteAgentHostService, configurationService);
+                }
+            }));
+            store.add(picker.onDidAccept(() => {
+                const selected = picker.selectedItems[0];
+                picker.hide();
+                if (!selected) {
+                    return;
+                }
+                if (selected.kind === "remote") {
+                    void instantiationService.invokeFunction(a => showRemoteHostOptions(a, selected.provider, {
+                        showBackButton: true
+                    })).then(result => {
+                        if (result === "back") {
+                            showManagePicker();
+                        }
+                    });
+                } else if (selected.kind === "menu-action") {
+                    commandService.executeCommand(selected.action.id, () => showManagePicker());
+                }
+            }));
+            store.add(picker.onDidHide(() => store.dispose()));
+            picker.show();
+        };
+        showManagePicker();
+    }
+});

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/managedReconnectAgentHostContribution.d.ts

@@ -0,0 +1,95 @@
+import { Disposable, DisposableMap } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { type IRemoteAgentHostReconnectPolicy } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/reconnectPolicy";
+import { type IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { type IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { type ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { type INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { type ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { EntryDrivenProviderContribution } from "./entryDrivenProviderContribution.js";
+/**
+ * Per-host auto-reconnect state for a managed (in-renderer relay) remote
+ * agent host. Owned by a {@link DisposableMap} on the contribution, which
+ * disposes the entry — and therefore the pending timer — when the host is no
+ * longer present or the contribution itself is disposed.
+ */
+export declare class ManagedReconnectState extends Disposable {
+    private readonly _timer;
+    /** Consecutive failed reconnect attempts. */
+    attempts: number;
+    /** True after we've given up auto-reconnecting until something resumes us. */
+    paused: boolean;
+    /** Wall-clock timestamp when {@link paused} was last set to true. */
+    pausedAt: number;
+    /** Whether automatic triggers must not resume this state. */
+    requiresUserInitiatedResume: boolean;
+    get hasPendingTimer(): boolean;
+    scheduleRetry(delayMs: number, handler: () => void): void;
+    cancelTimer(): void;
+    resetForResume(): void;
+    resumeAutomatically(): boolean;
+}
+/** Options controlling a single managed-reconnect attempt. */
+export interface IManagedReconnectAttemptOptions {
+    /** Human-readable connection kind for logging (e.g. `SSH`, `WSL`). */
+    readonly kind: string;
+    /** Reconnect-state key (e.g. `sshConfigHost`, `distro`). */
+    readonly key: string;
+    /** Display address used to look up the provider and live connection. */
+    readonly address: string;
+    /** Whether the attempt was triggered by an explicit user action. */
+    readonly userInitiated: boolean;
+    /** Policy controlling automatic reconnect attempts. */
+    readonly reconnectPolicy: IRemoteAgentHostReconnectPolicy;
+    /** Whether the given error should pause (rather than retry) auto-reconnect. */
+    readonly shouldPause: (err: unknown) => boolean;
+    /** Whether the pause must be resumed by an explicit user action. */
+    readonly requiresUserInitiatedResume?: (err: unknown) => boolean;
+    /** Describes why a reconnect was paused for logging. */
+    readonly getPauseReason?: (err: unknown) => string;
+    /**
+     * Optional pre-flight gate. Return `{ skip: true }` to bail WITHOUT
+     * incrementing the attempt counter (so a long-unavailable host can't burn
+     * the retry budget).
+     */
+    readonly preCheck?: (userInitiated: boolean) => Promise<{
+        readonly skip: boolean;
+        readonly reason?: string;
+    } | undefined>;
+    /** Perform the actual (re)connect. */
+    readonly doConnect: () => Promise<void>;
+    /** Schedule the next retry after a non-terminal failure. Omit for on-demand-only reconnects. */
+    readonly schedule?: (state: ManagedReconnectState) => void;
+}
+/**
+ * Shared base for contributions that own in-renderer relay remote agent hosts
+ * (WSL and SSH). Encapsulates the sessions-provider
+ * registry and the managed auto-reconnect state machine so concrete
+ * contributions only implement their type-specific discovery/connect logic.
+ */
+export declare abstract class ManagedReconnectAgentHostContribution extends EntryDrivenProviderContribution {
+    protected readonly _logService: ILogService;
+    /** Per-key auto-reconnect state (timer + attempts + paused). */
+    protected readonly _reconnectStates: DisposableMap<string, ManagedReconnectState>;
+    /**
+     * In-flight reconnect attempts keyed by reconnect-state key. Stored so
+     * concurrent on-demand callers join the existing attempt rather than
+     * racing it.
+     */
+    protected readonly _pendingReconnects: Map<string, Promise<void>>;
+    constructor(remoteAgentHostService: IRemoteAgentHostService, configurationService: IConfigurationService, _logService: ILogService, instantiationService: IInstantiationService, sessionsProvidersService: ISessionsProvidersService, notificationService: INotificationService);
+    protected _getOrCreateReconnectState(key: string): ManagedReconnectState;
+    /**
+     * Resume auto-reconnect for any paused entries. Called when a fresh
+     * trigger (config change, new connection event) gives paused hosts another
+     * chance. Returns the number of entries resumed.
+     */
+    protected _resumeReconnects(logKind: string): number;
+    /**
+     * Shared retry-loop body for managed-reconnect entries. Handles
+     * `connecting`/`reconnecting`/`disconnected`/`incompatible` provider status, cached-session
+     * unpublishing on failure, pause-on-cancel, and pause-after-max-attempts.
+     * Type-specific behaviour is provided via {@link IManagedReconnectAttemptOptions}.
+     */
+    protected _attemptManagedReconnect(opts: IManagedReconnectAttemptOptions): Promise<void>;
+}