feat: warn when useLocalServer disables proxy propagation

When a proxy applies to the deployment but remote.SSH.useLocalServer is off,
the spawned SSH connection won't inherit the proxy env. Surface a dismissable
warning offering to enable the local server, via a reusable
showDismissibleNotification helper.

Author: EhabY

src/remote/remote.ts

@@ -58,10 +58,15 @@ import {
 	expandPath,
 	parseRemoteAuthority,
 } from "../util";
+import { showDismissibleNotification } from "../util/notifications";
 import { vscodeProposed } from "../vscodeProposed";
 import { WorkspaceMonitor } from "../workspace/workspaceMonitor";
 
-import { applySshProxyEnvironment, SSH_PROXY_SETTINGS } from "./environment";
+import {
+	applySshProxyEnvironment,
+	getSshProxyEnvironment,
+	SSH_PROXY_SETTINGS,
+} from "./environment";
 import {
 	SshConfig,
 	type SshValues,
@@ -206,6 +211,7 @@ export class Remote {
 			disposables.push(
 				applySshProxyEnvironment(baseUrl, vscode.workspace.getConfiguration()),
 			);
+			void this.warnIfProxyEnvNotInherited(baseUrl);
 			// Create OAuth session manager for this remote deployment
 			const remoteOAuthManager = OAuthSessionManager.create(
 				{ url: baseUrl, safeHostname: parts.safeHostname },
@@ -827,6 +833,51 @@ export class Remote {
 		return this.pathResolver.getProxyLogPath();
 	}
 
+	/**
+	 * MS VS Code with `remote.SSH.useLocalServer=false` spawns ssh without
+	 * inheriting process.env, so the proxy variables never reach it. Warn once and
+	 * offer to enable the local server when a proxy applies to this deployment.
+	 * Catches internally so the caller can safely fire-and-forget.
+	 */
+	private async warnIfProxyEnvNotInherited(baseUrl: string): Promise<void> {
+		try {
+			const cfg = vscode.workspace.getConfiguration();
+			// HTTP_PROXY is only set when a proxy actually applies to this deployment.
+			if (!getSshProxyEnvironment(baseUrl, cfg).HTTP_PROXY) {
+				return;
+			}
+			if (cfg.get<boolean>("remote.SSH.useLocalServer") !== false) {
+				return;
+			}
+
+			const ENABLE = "Enable Local Server";
+			const choice = await showDismissibleNotification(
+				"Your proxy settings may not reach the SSH connection because `remote.SSH.useLocalServer` is disabled. Enable it so Coder can apply the proxy to the connection.",
+				this.extensionContext.globalState,
+				{ key: "coder.proxyUseLocalServerWarningDismissed", actions: [ENABLE] },
+			);
+			if (choice !== ENABLE) {
+				return;
+			}
+
+			await cfg.update(
+				"remote.SSH.useLocalServer",
+				true,
+				vscode.ConfigurationTarget.Global,
+			);
+			const RELOAD = "Reload";
+			const reload = await vscode.window.showInformationMessage(
+				"Local server enabled. Reload the window to apply.",
+				RELOAD,
+			);
+			if (reload === RELOAD) {
+				await vscode.commands.executeCommand("workbench.action.reloadWindow");
+			}
+		} catch (error) {
+			this.logger.debug("Failed to surface proxy useLocalServer warning", error);
+		}
+	}
+
 	/**
 	 * Builds the ProxyCommand for SSH connections to Coder workspaces.
 	 * Uses `coder ssh` for modern deployments with wildcard support,

src/util/notifications.ts

@@ -0,0 +1,43 @@
+import * as vscode from "vscode";
+
+type NotificationLevel = "info" | "warning" | "error";
+
+/**
+ * Show a notification with a "Don't Show Again" button that persists dismissal
+ * under `key`. Returns the chosen action, or undefined if dismissed or closed.
+ */
+export async function showDismissibleNotification(
+	message: string,
+	memento: vscode.Memento,
+	options: {
+		key: string;
+		actions?: string[];
+		level?: NotificationLevel;
+		dismissLabel?: string;
+	},
+): Promise<string | undefined> {
+	const {
+		key,
+		actions = [],
+		level = "info",
+		dismissLabel = "Don't Show Again",
+	} = options;
+
+	if (memento.get<boolean>(key)) {
+		return undefined;
+	}
+
+	const items = [...actions, dismissLabel];
+	const choice =
+		level === "error"
+			? await vscode.window.showErrorMessage(message, ...items)
+			: level === "warning"
+				? await vscode.window.showWarningMessage(message, ...items)
+				: await vscode.window.showInformationMessage(message, ...items);
+
+	if (choice === dismissLabel) {
+		await memento.update(key, true);
+		return undefined;
+	}
+	return choice;
+}

test/unit/util/notifications.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as vscode from "vscode";
+
+import { showDismissibleNotification } from "@/util/notifications";
+
+function fakeMemento(initial: Record<string, unknown> = {}): vscode.Memento {
+	const store = new Map(Object.entries(initial));
+	return {
+		get: (key: string) => store.get(key),
+		update: (key: string, value: unknown) => {
+			store.set(key, value);
+			return Promise.resolve();
+		},
+		keys: () => [...store.keys()],
+	};
+}
+
+describe("showDismissibleNotification", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("returns the chosen action without persisting", async () => {
+		vi.mocked(vscode.window.showInformationMessage).mockResolvedValue(
+			"Enable" as never,
+		);
+		const memento = fakeMemento();
+
+		const choice = await showDismissibleNotification("m", memento, {
+			key: "k",
+			actions: ["Enable"],
+		});
+
+		expect(choice).toBe("Enable");
+		expect(memento.get("k")).toBeUndefined();
+	});
+
+	it("persists dismissal and returns undefined when dismissed", async () => {
+		vi.mocked(vscode.window.showInformationMessage).mockResolvedValue(
+			"Don't Show Again" as never,
+		);
+		const memento = fakeMemento();
+
+		const choice = await showDismissibleNotification("m", memento, { key: "k" });
+
+		expect(choice).toBeUndefined();
+		expect(memento.get("k")).toBe(true);
+	});
+
+	it("shows nothing once dismissed", async () => {
+		const memento = fakeMemento({ k: true });
+
+		const choice = await showDismissibleNotification("m", memento, { key: "k" });
+
+		expect(choice).toBeUndefined();
+		expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+	});
+});