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

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

@@ -0,0 +1,1210 @@
+
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+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 { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { isCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { EndOfLinePreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { SnippetController2 } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/snippet/browser/snippetController2';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { RemoteAgentHostsEnabledSettingId, parseRemoteAgentHostInput, RemoteAgentHostInputValidationError, addWebSocketRemoteAgentHostEntry, RemoteAgentHostEntryType, RemoteAgentHostConnectionStatus } 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 { SSHAuthMethod, isSSHHostKeyDeniedError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sshRemoteAgentHost';
+import { ISSHRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sshRemoteAgentHost.service';
+import { isTunnelHosted, TUNNEL_ADDRESS_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost';
+import { ITunnelAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost.service';
+import { WSL_INSTALL_DOCS_URL } from '../../../../../platform/agentHost/common/wslRemoteAgentHost.js';
+import { IWSLRemoteAgentHostService } from '../../../../../platform/agentHost/common/wslRemoteAgentHost.service.js';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IRemoteTunnelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/remoteTunnel/common/remoteTunnel.service';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { SessionsCategories } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/categories';
+import { logSSHConnectAttempt, categorizeSSHConnectError } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { SessionWorkspacePickerGroupContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { runServerUpgrade } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteHostOptions';
+import { SESSION_WORKSPACE_GROUP_REMOTE } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+
+const RemoteAgentHostCommandIds = {
+    addRemoteAgentHost: "sessions.remoteAgentHost.add",
+    connectViaSSH: "workbench.action.sessions.connectViaSSH",
+    addNewSSHHost: "workbench.action.sessions.addNewSSHHost",
+    configureSSHHosts: "workbench.action.sessions.configureSSHHosts",
+    connectViaTunnel: "workbench.action.sessions.connectViaTunnel",
+    connectViaWSL: "workbench.action.sessions.connectViaWSL",
+    manageRemoteAgentHosts: "workbench.action.sessions.manageRemoteAgentHosts",
+    updateRemoteAgentHost: "workbench.action.sessions.updateRemoteAgentHost"
+};
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.addRemoteAgentHost,
+            title: ( localize2(4323, "Add Remote Agent Host...")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            precondition: ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true))
+        });
+    }
+    async run(accessor) {
+        const remoteAgentHostService = accessor.get(IRemoteAgentHostService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const notificationService = accessor.get(INotificationService);
+        const configurationService = accessor.get(IConfigurationService);
+        const address = await quickInputService.input({
+            title: ( localize(4324, "Add Remote Agent Host")),
+            prompt: ( localize(
+                4325,
+                "Paste a host, host:port, or WebSocket URL. Example: {0}",
+                "ws://127.0.0.1:8089"
+            )),
+            placeHolder: "ws://127.0.0.1:8080?tkn=abc-123",
+            ignoreFocusLost: true,
+            validateInput: async value => {
+                const result = parseRemoteAgentHostInput(value);
+                if (result.error === RemoteAgentHostInputValidationError.Empty) {
+                    return localize(4326, "Enter a remote agent host address.");
+                }
+                if (result.error === RemoteAgentHostInputValidationError.Invalid) {
+                    return localize(4327, "Enter a valid host, host:port, or WebSocket URL.");
+                }
+                return undefined;
+            }
+        });
+        if (!address) {
+            return;
+        }
+        const parsed = parseRemoteAgentHostInput(address);
+        if (!parsed.parsed) {
+            return;
+        }
+        const defaultName = parsed.parsed.suggestedName;
+        const name = await quickInputService.input({
+            title: ( localize(4328, "Name Remote Agent Host")),
+            prompt: ( localize(4329, "Enter a display name for this remote agent host.")),
+            placeHolder: ( localize(4330, "My Remote")),
+            value: defaultName,
+            valueSelection: [0, defaultName.length],
+            ignoreFocusLost: true,
+            validateInput: async value => value.trim() ? undefined : ( localize(4331, "Enter a name for this remote agent host."))
+        });
+        if (!name?.trim()) {
+            return;
+        }
+        try {
+            await addWebSocketRemoteAgentHostEntry(configurationService, {
+                name: name.trim(),
+                connectionToken: parsed.parsed.connectionToken,
+                connection: {
+                    type: RemoteAgentHostEntryType.WebSocket,
+                    address: parsed.parsed.address
+                }
+            });
+            await remoteAgentHostService.waitForConnection(parsed.parsed.address);
+        } catch {
+            notificationService.error(( localize(4332, "Failed to connect to remote agent host {0}.", parsed.parsed.address)));
+        }
+    }
+});
+function parseSSHHostInput(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const atIdx = trimmed.indexOf("@");
+    if (atIdx === 0 || atIdx === trimmed.length - 1) {
+        return undefined;
+    }
+    let username;
+    let hostPart;
+    if (atIdx !== -1) {
+        username = trimmed.substring(0, atIdx);
+        hostPart = trimmed.substring(atIdx + 1);
+    } else {
+        hostPart = trimmed;
+    }
+    if (!hostPart) {
+        return undefined;
+    }
+    let host;
+    let port;
+    const colonIdx = hostPart.lastIndexOf(":");
+    if (colonIdx !== -1) {
+        host = hostPart.substring(0, colonIdx);
+        const portStr = hostPart.substring(colonIdx + 1);
+        if (!host) {
+            return undefined;
+        }
+        if (portStr) {
+            const portNum = Number(portStr);
+            if (!Number.isInteger(portNum) || portNum <= 0 || portNum > 65535) {
+                return undefined;
+            }
+            port = portNum;
+        }
+    } else {
+        host = hostPart;
+    }
+    if (!host) {
+        return undefined;
+    }
+    return {
+        host,
+        username,
+        port
+    };
+}
+function validateSSHHostInput(value) {
+    const v = value.trim();
+    if (!v) {
+        return localize(4333, "Enter an SSH host.");
+    }
+    const atIdx = v.indexOf("@");
+    if (atIdx === 0) {
+        return localize(4334, "Enter a username before '@'.");
+    }
+    if (atIdx === v.length - 1) {
+        return localize(4335, "Enter a host name after '@'.");
+    }
+    const hostPart = atIdx !== -1 ? v.substring(atIdx + 1) : v;
+    if (!hostPart) {
+        return localize(4335, "Enter a host name after '@'.");
+    }
+    const colonIdx = hostPart.lastIndexOf(":");
+    if (colonIdx !== -1) {
+        const hostName = hostPart.substring(0, colonIdx);
+        const portStr = hostPart.substring(colonIdx + 1);
+        if (!hostName) {
+            return localize(4335, "Enter a host name after '@'.");
+        }
+        if (portStr) {
+            const portNum = Number(portStr);
+            if (!Number.isInteger(portNum) || portNum <= 0 || portNum > 65535) {
+                return localize(4336, "Enter a valid port number.");
+            }
+        }
+    }
+    return undefined;
+}
+async function promptToConnectViaSSH(accessor, options = {}) {
+    const sshService = accessor.get(ISSHRemoteAgentHostService);
+    const quickInputService = accessor.get(IQuickInputService);
+    const notificationService = accessor.get(INotificationService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const commandService = accessor.get(ICommandService);
+    const configHosts = await sshService.listSSHConfigHosts().catch(() => []);
+    const aliasItems = configHosts.map(h => ({
+        kind: "alias",
+        hostAlias: h,
+        label: h
+    }));
+    const addHostItem = {
+        kind: "add-config",
+        label: "$(plus) " + ( localize(4337, "Add New SSH Host...")),
+        alwaysShow: true
+    };
+    const configureHostsItem = {
+        kind: "configure",
+        label: ( localize(4338, "Configure SSH Hosts...")),
+        alwaysShow: true
+    };
+    const newHostItem = {
+        kind: "new-host",
+        hostInput: "",
+        label: "",
+        alwaysShow: true
+    };
+    const result = await ( new Promise(resolve => {
+        const store = ( new DisposableStore());
+        const picker = store.add(quickInputService.createQuickPick());
+        picker.title = ( localize(4339, "Connect via SSH"));
+        picker.placeholder = ( localize(4340, "Select configured SSH host or enter user@host"));
+        picker.ignoreFocusOut = true;
+        picker.matchOnDescription = true;
+        if (options.showBackButton) {
+            picker.buttons = [quickInputService.backButton];
+        }
+        let newHostVisible = false;
+        const updateItems = () => {
+            const items = [...aliasItems];
+            if (newHostVisible) {
+                items.push(newHostItem);
+            }
+            items.push(addHostItem);
+            items.push(configureHostsItem);
+            picker.items = items;
+        };
+        updateItems();
+        store.add(picker.onDidChangeValue(value => {
+            const parsed = parseSSHHostInput(value);
+            if (parsed) {
+                newHostItem.hostInput = value.trim();
+                newHostItem.label = `\u27a4 ${value.trim()}`;
+                if (!newHostVisible) {
+                    newHostVisible = true;
+                    updateItems();
+                } else {
+                    picker.items = picker.items;
+                }
+            } else if (newHostVisible) {
+                newHostVisible = false;
+                updateItems();
+            }
+        }));
+        store.add(picker.onDidTriggerButton(button => {
+            if (button === quickInputService.backButton) {
+                resolve("back");
+                picker.hide();
+            }
+        }));
+        store.add(picker.onDidAccept(() => {
+            const selected = picker.selectedItems[0];
+            resolve(selected);
+            picker.hide();
+        }));
+        store.add(picker.onDidHide(() => {
+            resolve(undefined);
+            store.dispose();
+        }));
+        picker.show();
+    }));
+    if (result === "back") {
+        return "back";
+    }
+    if (!result) {
+        return;
+    }
+    if (result.kind === "add-config" || result.kind === "configure") {
+        const cmdId = result.kind === "add-config" ? RemoteAgentHostCommandIds.addNewSSHHost : RemoteAgentHostCommandIds.configureSSHHosts;
+        const onBackToSSH = () => instantiationService.invokeFunction(a => promptToConnectViaSSH(a, options));
+        await commandService.executeCommand(cmdId, onBackToSSH);
+        return;
+    }
+    if (result.kind === "alias") {
+        await instantiationService.invokeFunction(accessor => connectToConfiguredSSHHost(accessor, result.hostAlias));
+        return;
+    }
+    const newHost = result;
+    const parsed = parseSSHHostInput(newHost.hostInput);
+    if (!parsed) {
+        notificationService.error(validateSSHHostInput(newHost.hostInput) ?? ( localize(4341, "Invalid SSH host.")));
+        return;
+    }
+    await instantiationService.invokeFunction(
+        accessor => promptForCredentialsAndConnect(accessor, parsed.host, parsed.username, parsed.port)
+    );
+}
+async function connectToConfiguredSSHHost(accessor, hostAlias) {
+    const sshService = accessor.get(ISSHRemoteAgentHostService);
+    const notificationService = accessor.get(INotificationService);
+    const instantiationService = accessor.get(IInstantiationService);
+    let resolvedConfig;
+    try {
+        resolvedConfig = await sshService.resolveSSHConfig(hostAlias);
+    } catch (err) {
+        notificationService.error(( localize(4342, "Failed to resolve SSH config for {0}: {1}", hostAlias, String(err))));
+        return;
+    }
+    const host = resolvedConfig.hostname;
+    const username = resolvedConfig.user;
+    const port = resolvedConfig.port !== 22 ? resolvedConfig.port : undefined;
+    const suggestedName = hostAlias;
+    const defaultKeyPath = resolvedConfig.identityFile[0];
+    if (username) {
+        const config = {
+            host,
+            port,
+            username,
+            authMethod: SSHAuthMethod.Agent,
+            privateKeyPath: defaultKeyPath,
+            identityAgent: resolvedConfig.identityAgent,
+            agentForward: resolvedConfig.forwardAgent || undefined,
+            name: suggestedName,
+            sshConfigHost: hostAlias
+        };
+        const connection = await instantiationService.invokeFunction(accessor => connectWithProgress(accessor, config, suggestedName));
+        if (connection) {
+            await instantiationService.invokeFunction(accessor => promptForRemoteFolder(accessor, connection));
+        }
+        return;
+    }
+    await instantiationService.invokeFunction(accessor => promptForCredentialsAndConnect(
+        accessor,
+        host,
+        undefined,
+        port,
+        suggestedName,
+        defaultKeyPath,
+        resolvedConfig.identityAgent
+    ));
+}
+async function promptForCredentialsAndConnect(
+    accessor,
+    host,
+    username,
+    port,
+    suggestedName,
+    defaultKeyPath,
+    identityAgent
+) {
+    const quickInputService = accessor.get(IQuickInputService);
+    const instantiationService = accessor.get(IInstantiationService);
+    if (!username) {
+        const usernameInput = await quickInputService.input({
+            title: ( localize(4343, "SSH Username")),
+            prompt: ( localize(4344, "Enter the username for {0}.", host)),
+            placeHolder: "root",
+            ignoreFocusLost: true,
+            validateInput: async value => value.trim() ? undefined : ( localize(4345, "Enter a username."))
+        });
+        if (!usernameInput) {
+            return;
+        }
+        username = usernameInput.trim();
+    }
+    const authPicks = [{
+        method: SSHAuthMethod.Agent,
+        label: ( localize(4346, "SSH Agent")),
+        description: ( localize(4347, "Use the running SSH agent for authentication"))
+    }, {
+        method: SSHAuthMethod.KeyFile,
+        label: ( localize(4348, "Private Key File")),
+        description: ( localize(4349, "Authenticate with a private key file"))
+    }, {
+        method: SSHAuthMethod.Password,
+        label: ( localize(4350, "Password")),
+        description: ( localize(4351, "Authenticate with a password"))
+    }];
+    const authPicked = await quickInputService.pick(authPicks, {
+        title: ( localize(4352, "Authentication Method")),
+        placeHolder: ( localize(4353, "Choose how to authenticate with {0}", host))
+    });
+    if (!authPicked) {
+        return;
+    }
+    const authMethod = authPicked.method;
+    let privateKeyPath;
+    let password;
+    if (authMethod === SSHAuthMethod.KeyFile) {
+        const keyPath = await quickInputService.input({
+            title: ( localize(4354, "Private Key Path")),
+            prompt: ( localize(4355, "Enter the path to your SSH private key.")),
+            placeHolder: "~/.ssh/id_rsa",
+            value: defaultKeyPath ?? "~/.ssh/id_rsa",
+            ignoreFocusLost: true,
+            validateInput: async value => value.trim() ? undefined : ( localize(4356, "Enter a key file path."))
+        });
+        if (!keyPath) {
+            return;
+        }
+        privateKeyPath = keyPath.trim();
+    } else if (authMethod === SSHAuthMethod.Password) {
+        const pw = await quickInputService.input({
+            title: ( localize(4357, "SSH Password")),
+            prompt: ( localize(4358, "Enter the password for {0}@{1}.", username, host)),
+            password: true,
+            ignoreFocusLost: true,
+            validateInput: async value => value ? undefined : ( localize(4359, "Enter a password."))
+        });
+        if (!pw) {
+            return;
+        }
+        password = pw;
+    }
+    const defaultName = suggestedName ?? `${username}@${host}`;
+    const name = await quickInputService.input({
+        title: ( localize(4360, "Name Remote")),
+        prompt: ( localize(4361, "Enter a display name for this SSH remote.")),
+        placeHolder: ( localize(4362, "My Remote")),
+        value: defaultName,
+        valueSelection: [0, defaultName.length],
+        ignoreFocusLost: true,
+        validateInput: async value => value.trim() ? undefined : ( localize(4363, "Enter a name."))
+    });
+    if (!name) {
+        return;
+    }
+    const config = {
+        host,
+        port,
+        username,
+        authMethod,
+        privateKeyPath,
+        identityAgent,
+        password,
+        name: name.trim()
+    };
+    const connection = await instantiationService.invokeFunction(accessor => connectWithProgress(accessor, config, host));
+    if (connection) {
+        await instantiationService.invokeFunction(accessor => promptForRemoteFolder(accessor, connection));
+    }
+}
+async function connectWithProgress(accessor, config, displayHost) {
+    const sshService = accessor.get(ISSHRemoteAgentHostService);
+    const notificationService = accessor.get(INotificationService);
+    const telemetryService = accessor.get(ITelemetryService);
+    const stopwatch = StopWatch.create(false);
+    const handle = notificationService.notify({
+        severity: Severity.Info,
+        message: ( localize(4364, "Connecting to {0} via SSH...", displayHost)),
+        progress: {
+            infinite: true
+        }
+    });
+    const expectedKey = config.sshConfigHost ? `ssh:${config.sshConfigHost}` : `${config.username}@${config.host}:${config.port ?? 22}`;
+    const progressListener = sshService.onDidReportConnectProgress?.(progress => {
+        if (progress.connectionKey === expectedKey) {
+            handle.updateMessage(progress.message);
+        }
+    });
+    try {
+        const connection = await sshService.connect(config);
+        logSSHConnectAttempt(telemetryService, {
+            operation: "connect",
+            userInitiated: config.userInitiated ?? true,
+            attempt: 1,
+            durationMs: stopwatch.elapsed(),
+            success: true,
+            willRetry: false
+        });
+        handle.close();
+        return connection;
+    } catch (err) {
+        logSSHConnectAttempt(telemetryService, {
+            operation: "connect",
+            userInitiated: config.userInitiated ?? true,
+            attempt: 1,
+            durationMs: stopwatch.elapsed(),
+            success: false,
+            willRetry: false,
+            errorCategory: categorizeSSHConnectError(err)
+        });
+        handle.close();
+        if (isCancellationError(err) || isSSHHostKeyDeniedError(err)) {
+            return undefined;
+        }
+        notificationService.error(( localize(4365, "Failed to connect via SSH to {0}: {1}", displayHost, String(err))));
+        return undefined;
+    } finally {
+        progressListener?.dispose();
+    }
+}
+async function promptForRemoteFolder(accessor, connection) {
+    const sessionsProvidersService = accessor.get(ISessionsProvidersService);
+    const sessionsService = accessor.get(ISessionsService);
+    const sessionsPartService = accessor.get(ISessionsPartService);
+    const provider = sessionsProvidersService.getProviders().find(p => isAgentHostProvider(p) && p.remoteAddress === connection.localAddress);
+    if (!provider) {
+        return;
+    }
+    const browseAction = provider.browseActions[0];
+    if (!browseAction) {
+        return;
+    }
+    const workspace = await browseAction.run();
+    if (!workspace) {
+        return;
+    }
+    const folderUri = workspace.folders[0]?.root;
+    if (!folderUri) {
+        return;
+    }
+    sessionsService.openNewSession();
+    sessionsPartService.getSessionView(sessionsService.activeSession.get()?.sessionId)?.selectWorkspace(folderUri);
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.connectViaSSH,
+            title: ( localize2(4366, "Connect to Remote Agent Host via SSH")),
+            shortTitle: ( localize2(4367, "SSH")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            icon: Codicon.remote,
+            precondition: ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true)),
+            menu: {
+                id: Menus.SessionWorkspaceManage,
+                order: 20,
+                when: ( SessionWorkspacePickerGroupContext.isEqualTo(SESSION_WORKSPACE_GROUP_REMOTE))
+            }
+        });
+    }
+    async run(accessor, onBack) {
+        const result = await promptToConnectViaSSH(accessor, {
+            showBackButton: !!onBack
+        });
+        if (result === "back") {
+            onBack?.();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.addNewSSHHost,
+            title: ( localize2(4368, "Add New SSH Host...")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            precondition: ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true))
+        });
+    }
+    async run(accessor) {
+        const sshService = accessor.get(ISSHRemoteAgentHostService);
+        const editorService = accessor.get(IEditorService);
+        const fileService = accessor.get(IFileService);
+        const notificationService = accessor.get(INotificationService);
+        let configUri;
+        try {
+            configUri = await sshService.ensureUserSSHConfig();
+        } catch (err) {
+            notificationService.error(( localize(4369, "Failed to create SSH config file: {0}", String(err))));
+            return;
+        }
+        const editorPane = await editorService.openEditor({
+            resource: configUri,
+            options: {
+                pinned: true
+            }
+        });
+        if (!editorPane) {
+            return;
+        }
+        const control = editorPane.getControl();
+        if (!isCodeEditor(control) || !control.hasModel()) {
+            return;
+        }
+        const editor = control;
+        const model = editor.getModel();
+        if (!model) {
+            return;
+        }
+        let appendNewline = false;
+        try {
+            const stat = await fileService.stat(configUri);
+            if (stat.size > 0) {
+                const content = model.getValueInRange(model.getFullModelRange(), EndOfLinePreference.LF);
+                appendNewline = content.length > 0 && !content.endsWith("\n");
+            }
+        } catch {}
+        const lastLine = model.getLineCount();
+        const lastCol = model.getLineMaxColumn(lastLine);
+        editor.setSelection(( new Range(lastLine, lastCol, lastLine, lastCol)));
+        const snippet = (appendNewline ? "\n" : "") + "Host ${1:alias}\n    HostName ${2:hostname}\n    User ${3:user}\n";
+        SnippetController2.get(editor)?.insert(snippet);
+        editor.focus();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.configureSSHHosts,
+            title: ( localize2(4370, "Configure SSH Hosts...")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            precondition: ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true))
+        });
+    }
+    async run(accessor, onBack) {
+        const sshService = accessor.get(ISSHRemoteAgentHostService);
+        const editorService = accessor.get(IEditorService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const notificationService = accessor.get(INotificationService);
+        let configFiles;
+        try {
+            configFiles = await sshService.listSSHConfigFiles();
+        } catch (err) {
+            notificationService.error(( localize(4371, "Failed to list SSH config files: {0}", String(err))));
+            return;
+        }
+        if (configFiles.length === 0) {
+            try {
+                const uri = await sshService.ensureUserSSHConfig();
+                await editorService.openEditor({
+                    resource: uri,
+                    options: {
+                        pinned: true
+                    }
+                });
+            } catch (err) {
+                notificationService.error(( localize(4372, "Failed to open SSH config file: {0}", String(err))));
+            }
+            return;
+        }
+        const userConfigUri = configFiles[0];
+        const items = configFiles.map((uri, index) => ({
+            label: uri.fsPath,
+            uri,
+            isUserConfig: index === 0
+        }));
+        if (items.length === 1 && !onBack) {
+            const picked = items[0];
+            try {
+                const uri = picked.isUserConfig ? await sshService.ensureUserSSHConfig().catch(() => userConfigUri) : picked.uri;
+                await editorService.openEditor({
+                    resource: uri,
+                    options: {
+                        pinned: true
+                    }
+                });
+            } catch (err) {
+                notificationService.error(( localize(4372, "Failed to open SSH config file: {0}", String(err))));
+            }
+            return;
+        }
+        const picked = await ( new Promise(resolve => {
+            const store = ( new DisposableStore());
+            const picker = store.add(quickInputService.createQuickPick());
+            picker.title = ( localize(4373, "Select SSH configuration file to edit"));
+            picker.placeholder = ( localize(4374, "Select an SSH configuration file"));
+            picker.items = items;
+            if (onBack) {
+                picker.buttons = [quickInputService.backButton];
+            }
+            store.add(picker.onDidTriggerButton(button => {
+                if (button === quickInputService.backButton) {
+                    resolve("back");
+                    picker.hide();
+                }
+            }));
+            store.add(picker.onDidAccept(() => {
+                resolve(picker.selectedItems[0]);
+                picker.hide();
+            }));
+            store.add(picker.onDidHide(() => {
+                resolve(undefined);
+                store.dispose();
+            }));
+            picker.show();
+        }));
+        if (picked === "back") {
+            onBack?.();
+            return;
+        }
+        if (!picked) {
+            return;
+        }
+        try {
+            const uri = picked.isUserConfig ? await sshService.ensureUserSSHConfig().catch(() => userConfigUri) : picked.uri;
+            await editorService.openEditor({
+                resource: uri,
+                options: {
+                    pinned: true
+                }
+            });
+        } catch (err) {
+            notificationService.error(( localize(4372, "Failed to open SSH config file: {0}", String(err))));
+        }
+    }
+});
+function sortTunnelsByName(tunnels) {
+    return [...tunnels].sort((a, b) => a.name.localeCompare(b.name));
+}
+async function promptToConnectViaTunnel(accessor, options = {}) {
+    const tunnelService = accessor.get(ITunnelAgentHostService);
+    const quickInputService = accessor.get(IQuickInputService);
+    const notificationService = accessor.get(INotificationService);
+    const authenticationService = accessor.get(IAuthenticationService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const productService = accessor.get(IProductService);
+    const dialogService = accessor.get(IDialogService);
+    const remoteTunnelService = accessor.get(IRemoteTunnelService);
+    const store = ( new DisposableStore());
+    let remoteTunnelStatus = {
+        type: "uninitialized"
+    };
+    let hasReceivedRemoteTunnelStatus = false;
+    let tunnels = [];
+    let tunnelPicker;
+    const deleteTunnelButton = {
+        iconClass: ThemeIcon.asClassName(Codicon.trash),
+        tooltip: ( localize(4375, "Delete Dev Tunnel"))
+    };
+    const isHostedTunnel = tunnel => isTunnelHosted(
+        remoteTunnelStatus.type === "connected" ? remoteTunnelStatus.info : undefined,
+        tunnel
+    );
+    const toTunnelPickItems = tunnelInfos => sortTunnelsByName(tunnelInfos).filter(tunnel => !isHostedTunnel(tunnel)).map(tunnel => ({
+        label: tunnel.name,
+        description: tunnel.hostConnectionCount > 0 ? ( localize(4376, "{0} · Online", tunnel.tunnelId)) : ( localize(4377, "{0} · Offline", tunnel.tunnelId)),
+        buttons: tunnelService.canDeleteTunnels ? [deleteTunnelButton] : undefined,
+        tunnel
+    }));
+    const updateTunnelPickerItems = () => {
+        if (tunnelPicker) {
+            tunnelPicker.items = toTunnelPickItems(tunnels);
+        }
+    };
+    store.add(remoteTunnelService.onDidChangeTunnelStatus(status => {
+        hasReceivedRemoteTunnelStatus = true;
+        remoteTunnelStatus = status;
+        updateTunnelPickerItems();
+    }));
+    const initialRemoteTunnelStatus = await remoteTunnelService.getTunnelStatus();
+    if (!hasReceivedRemoteTunnelStatus) {
+        remoteTunnelStatus = initialRemoteTunnelStatus;
+    }
+    const authProvider = "github";
+    const scopes = productService.tunnelApplicationConfig?.authenticationProviders?.[authProvider]?.scopes ?? [];
+    try {
+        if (!(await authenticationService.getSessions(authProvider, scopes)).length) {
+            await authenticationService.createSession(authProvider, scopes, {
+                activateImmediate: true
+            });
+        }
+    } catch {
+        store.dispose();
+        notificationService.error(( localize(4378, "Authentication failed. Please try again.")));
+        return;
+    }
+    tunnelPicker = store.add(quickInputService.createQuickPick());
+    tunnelPicker.title = ( localize(4379, "Connect via Dev Tunnel"));
+    tunnelPicker.placeholder = ( localize(4380, "Select a dev tunnel to connect to"));
+    tunnelPicker.busy = true;
+    if (options.showBackButton) {
+        tunnelPicker.buttons = [quickInputService.backButton];
+    }
+    tunnelPicker.show();
+    try {
+        tunnels = await tunnelService.listTunnels();
+    } catch (err) {
+        store.dispose();
+        notificationService.error(( localize(
+            4381,
+            "Failed to list dev tunnels: {0}",
+            err instanceof Error ? err.message : String(err)
+        )));
+        return;
+    }
+    if (tunnels.length === 0) {
+        store.dispose();
+        notificationService.info(( localize(
+            4382,
+            "No dev tunnels with agent host support were found. Start a tunnel with 'code tunnel' on another machine."
+        )));
+        return;
+    }
+    if (toTunnelPickItems(tunnels).length === 0) {
+        store.dispose();
+        notificationService.info(( localize(4383, "This machine is already hosting the only available dev tunnel.")));
+        return;
+    }
+    updateTunnelPickerItems();
+    tunnelPicker.busy = false;
+    const picked = await ( new Promise(resolve => {
+        let isDeleting = false;
+        store.add(tunnelPicker.onDidTriggerButton(button => {
+            if (button === quickInputService.backButton) {
+                resolve("back");
+                tunnelPicker.hide();
+            }
+        }));
+        store.add(tunnelPicker.onDidAccept(() => {
+            if (isDeleting) {
+                return;
+            }
+            const picked = tunnelPicker.selectedItems[0];
+            if (picked && isHostedTunnel(picked.tunnel)) {
+                updateTunnelPickerItems();
+                return;
+            }
+            resolve(picked);
+            tunnelPicker.hide();
+        }));
+        store.add(tunnelPicker.onDidTriggerItemButton(async event => {
+            if (event.button !== deleteTunnelButton || isDeleting) {
+                return;
+            }
+            if (isHostedTunnel(event.item.tunnel)) {
+                updateTunnelPickerItems();
+                return;
+            }
+            const previousIgnoreFocusOut = tunnelPicker.ignoreFocusOut;
+            isDeleting = true;
+            tunnelPicker.ignoreFocusOut = true;
+            let keepOpen = true;
+            try {
+                const confirmation = await dialogService.confirm({
+                    type: "warning",
+                    message: ( localize(
+                        4384,
+                        "Are you sure you want to delete dev tunnel '{0}'?",
+                        event.item.tunnel.name
+                    )),
+                    detail: ( localize(4385, "The tunnel may be recreated if a machine starts hosting it again.")),
+                    primaryButton: ( localize(4386, "&&Delete"))
+                });
+                if (!confirmation.confirmed) {
+                    return;
+                }
+                if (isHostedTunnel(event.item.tunnel)) {
+                    updateTunnelPickerItems();
+                    return;
+                }
+                tunnelPicker.busy = true;
+                await tunnelService.deleteTunnel(event.item.tunnel);
+                tunnels = await tunnelService.listTunnels();
+                if (toTunnelPickItems(tunnels).length === 0) {
+                    keepOpen = false;
+                    notificationService.info(( localize(
+                        4387,
+                        "No dev tunnels with agent host support were found. Start a tunnel with 'code tunnel' on another machine."
+                    )));
+                    return;
+                }
+                updateTunnelPickerItems();
+            } catch (err) {
+                notificationService.error(( localize(
+                    4388,
+                    "Failed to delete dev tunnel '{0}': {1}",
+                    event.item.tunnel.name,
+                    err instanceof Error ? err.message : String(err)
+                )));
+            } finally {
+                tunnelPicker.busy = false;
+                tunnelPicker.ignoreFocusOut = previousIgnoreFocusOut;
+                isDeleting = false;
+                if (keepOpen) {
+                    tunnelPicker.show();
+                } else {
+                    resolve(undefined);
+                    tunnelPicker.hide();
+                    store.dispose();
+                }
+            }
+        }));
+        store.add(tunnelPicker.onDidHide(() => {
+            if (isDeleting) {
+                return;
+            }
+            resolve(undefined);
+            store.dispose();
+        }));
+    }));
+    if (picked === "back") {
+        return "back";
+    }
+    if (!picked) {
+        return;
+    }
+    const handle = notificationService.notify({
+        severity: Severity.Info,
+        message: ( localize(4389, "Connecting to tunnel '{0}'...", picked.tunnel.name)),
+        progress: {
+            infinite: true
+        }
+    });
+    try {
+        tunnelService.clearTunnelDismissal(picked.tunnel.tunnelId);
+        await tunnelService.connect(picked.tunnel, authProvider, {
+            userInitiated: true
+        });
+        handle.close();
+    } catch (err) {
+        handle.close();
+        notificationService.error(( localize(
+            4390,
+            "Failed to connect to tunnel '{0}': {1}",
+            picked.tunnel.name,
+            err instanceof Error ? err.message : String(err)
+        )));
+        return;
+    }
+    await instantiationService.invokeFunction(accessor => promptForTunnelFolder(accessor, picked.tunnel));
+}
+async function promptForTunnelFolder(accessor, tunnel) {
+    const sessionsProvidersService = accessor.get(ISessionsProvidersService);
+    const sessionsService = accessor.get(ISessionsService);
+    const sessionsPartService = accessor.get(ISessionsPartService);
+    const tunnelAddress = `${TUNNEL_ADDRESS_PREFIX}${tunnel.tunnelId}`;
+    const provider = sessionsProvidersService.getProviders().find(p => isAgentHostProvider(p) && p.remoteAddress === tunnelAddress);
+    if (!provider) {
+        return;
+    }
+    const browseAction = provider.browseActions[0];
+    if (!browseAction) {
+        return;
+    }
+    const workspace = await browseAction.run();
+    if (!workspace) {
+        return;
+    }
+    const folderUri = workspace.folders[0]?.root;
+    if (!folderUri) {
+        return;
+    }
+    sessionsService.openNewSession();
+    sessionsPartService.getSessionView(sessionsService.activeSession.get()?.sessionId)?.selectWorkspace(folderUri, {
+        providerId: provider.id
+    });
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.connectViaTunnel,
+            title: ( localize2(4391, "Connect to Remote Agent Host via Dev Tunnel")),
+            shortTitle: ( localize2(4392, "Tunnels")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            icon: Codicon.cloud,
+            precondition: ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true)),
+            menu: {
+                id: Menus.SessionWorkspaceManage,
+                order: 10,
+                when: ( SessionWorkspacePickerGroupContext.isEqualTo(SESSION_WORKSPACE_GROUP_REMOTE))
+            }
+        });
+    }
+    async run(accessor, onBack) {
+        const result = await promptToConnectViaTunnel(accessor, {
+            showBackButton: !!onBack
+        });
+        if (result === "back") {
+            onBack?.();
+        }
+    }
+});
+async function promptToConnectViaWSL(accessor, options = {}) {
+    const wslService = accessor.get(IWSLRemoteAgentHostService);
+    const notificationService = accessor.get(INotificationService);
+    const quickInputService = accessor.get(IQuickInputService);
+    const openerService = accessor.get(IOpenerService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const logService = accessor.get(ILogService);
+    const installAction = ( new Action("wsl.openDocs", ( localize(4393, "Install WSL")), undefined, true, () => openerService.open(( URI.parse(WSL_INSTALL_DOCS_URL)))));
+    if (!(await wslService.isWSLAvailable())) {
+        notificationService.notify({
+            severity: Severity.Info,
+            message: ( localize(4394, "Windows Subsystem for Linux is not installed or not enabled.")),
+            actions: {
+                primary: [installAction]
+            }
+        });
+        return;
+    }
+    let distros;
+    try {
+        distros = await wslService.listDistros();
+    } catch (err) {
+        logService.error("[WSL] listDistros failed", err);
+        notificationService.error(( localize(4395, "Failed to list WSL distributions: {0}", toErrorMessage(err))));
+        return;
+    }
+    if (distros.length === 0) {
+        notificationService.notify({
+            severity: Severity.Info,
+            message: ( localize(4396, "No WSL 2 distributions are installed.")),
+            actions: {
+                primary: [installAction]
+            }
+        });
+        return;
+    }
+    const items = distros.map(d => ({
+        label: d.name,
+        description: d.isRunning ? ( localize(4397, "Running")) : ( localize(4398, "Stopped")),
+        detail: d.isDefault ? ( localize(4399, "Default distribution")) : undefined,
+        distro: d
+    }));
+    let picked;
+    if (items.length === 1 && !options.showBackButton) {
+        picked = items[0];
+    } else {
+        const result = await ( new Promise(resolve => {
+            const store = ( new DisposableStore());
+            const picker = store.add(quickInputService.createQuickPick());
+            picker.title = ( localize(4400, "Connect via WSL"));
+            picker.placeholder = ( localize(4401, "Select a WSL distribution to connect to"));
+            picker.items = items;
+            if (options.showBackButton) {
+                picker.buttons = [quickInputService.backButton];
+            }
+            store.add(picker.onDidTriggerButton(button => {
+                if (button === quickInputService.backButton) {
+                    resolve("back");
+                    picker.hide();
+                }
+            }));
+            store.add(picker.onDidAccept(() => {
+                resolve(picker.selectedItems[0]);
+                picker.hide();
+            }));
+            store.add(picker.onDidHide(() => {
+                resolve(undefined);
+                store.dispose();
+            }));
+            picker.show();
+        }));
+        if (result === "back") {
+            return "back";
+        }
+        if (!result) {
+            return;
+        }
+        picked = result;
+    }
+    const handle = notificationService.notify({
+        severity: Severity.Info,
+        message: ( localize(4402, "Connecting to WSL distribution '{0}'...", picked.distro.name)),
+        progress: {
+            infinite: true
+        }
+    });
+    const expectedKey = `wsl:${picked.distro.name}`;
+    const progressListener = wslService.onDidReportConnectProgress?.(progress => {
+        if (progress.connectionKey === expectedKey) {
+            handle.updateMessage(progress.message);
+        }
+    });
+    try {
+        await wslService.connect({
+            distro: picked.distro.name,
+            name: picked.distro.name
+        });
+        handle.close();
+    } catch (err) {
+        handle.close();
+        if (isCancellationError(err)) {
+            return;
+        }
+        logService.error(`[WSL] Connect to '${picked.distro.name}' failed`, err);
+        notificationService.error(( localize(
+            4403,
+            "Failed to connect to WSL distribution '{0}': {1}",
+            picked.distro.name,
+            toErrorMessage(err)
+        )));
+        return;
+    } finally {
+        progressListener?.dispose();
+    }
+    await instantiationService.invokeFunction(accessor => promptForWSLFolder(accessor, picked.distro.name));
+}
+async function promptForWSLFolder(accessor, distro) {
+    const sessionsProvidersService = accessor.get(ISessionsProvidersService);
+    const sessionsService = accessor.get(ISessionsService);
+    const sessionsPartService = accessor.get(ISessionsPartService);
+    const wslAddress = `wsl:${distro}`;
+    const provider = sessionsProvidersService.getProviders().find(p => isAgentHostProvider(p) && p.remoteAddress === wslAddress);
+    if (!provider) {
+        return;
+    }
+    const browseAction = provider.browseActions[0];
+    if (!browseAction) {
+        return;
+    }
+    const workspace = await browseAction.run();
+    if (!workspace) {
+        return;
+    }
+    const folderUri = workspace.folders[0]?.root;
+    if (!folderUri) {
+        return;
+    }
+    sessionsService.openNewSession();
+    sessionsPartService.getSessionView(sessionsService.activeSession.get()?.sessionId)?.selectWorkspace(folderUri, {
+        providerId: provider.id
+    });
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.connectViaWSL,
+            title: ( localize2(4404, "Connect to Remote Agent Host via WSL")),
+            shortTitle: ( localize2(4405, "WSL...")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            icon: Codicon.terminalLinux,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals("isWindows", true)), ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true)))),
+            menu: {
+                id: Menus.SessionWorkspaceManage,
+                order: 15,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("isWindows", true)), ( SessionWorkspacePickerGroupContext.isEqualTo(SESSION_WORKSPACE_GROUP_REMOTE))))
+            }
+        });
+    }
+    async run(accessor, onBack) {
+        const result = await promptToConnectViaWSL(accessor, {
+            showBackButton: !!onBack
+        });
+        if (result === "back") {
+            onBack?.();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: RemoteAgentHostCommandIds.updateRemoteAgentHost,
+            title: ( localize2(4406, "Update Remote Agent Host Server...")),
+            category: SessionsCategories.Sessions,
+            f1: true,
+            precondition: ( ContextKeyExpr.equals(`config.${RemoteAgentHostsEnabledSettingId}`, true))
+        });
+    }
+    async run(accessor) {
+        const sessionsProvidersService = accessor.get(ISessionsProvidersService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const notificationService = accessor.get(INotificationService);
+        const instantiationService = accessor.get(IInstantiationService);
+        const remoteHosts = sessionsProvidersService.getProviders().filter(isAgentHostProvider).filter(provider => !!provider.remoteAddress);
+        let incompatibleCount = 0;
+        const upgradable = remoteHosts.map(provider => {
+            const status = provider.connectionStatus?.get();
+            if (!RemoteAgentHostConnectionStatus.isIncompatible(status)) {
+                return undefined;
+            }
+            incompatibleCount++;
+            return status.vscodeUpgradeMethod ? {
+                provider,
+                method: status.vscodeUpgradeMethod
+            } : undefined;
+        }).filter(entry => !!entry);
+        if (upgradable.length === 0) {
+            notificationService.info(incompatibleCount > 0 ? ( localize(
+                4407,
+                "No remote agent hosts can be updated from here. Incompatible hosts must be updated manually, then reconnected."
+            )) : ( localize(4408, "No remote agent hosts need updating.")));
+            return;
+        }
+        let target = upgradable[0];
+        if (upgradable.length > 1) {
+            const picked = await quickInputService.pick(upgradable.map(entry => ({
+                label: entry.provider.label,
+                description: entry.provider.remoteAddress,
+                entry
+            })), {
+                placeHolder: ( localize(4409, "Select a remote agent host to update"))
+            });
+            if (!picked) {
+                return;
+            }
+            target = picked.entry;
+        }
+        await instantiationService.invokeFunction(runServerUpgrade, target.provider, target.method);
+    }
+});
+
+export { RemoteAgentHostCommandIds, parseSSHHostInput };