Fix false "setting changed" notifications on remote connect

The watchSettings function was using affectsConfiguration() which can
return true even when values haven't changed (e.g., during Remote SSH
connection setup). Now compares actual values using getter functions
that properly resolve defaults.

Also:
- Add coder.headerCommand to watched settings
- Show single notification listing all changed settings

Author: EhabY

src/cliConfig.ts

@@ -3,6 +3,13 @@ import { type WorkspaceConfiguration } from "vscode";
 import { getHeaderArgs } from "./headers";
 import { escapeCommandArg } from "./util";
 
+/**
+ * Returns the raw global flags from user configuration.
+ */
+export function getGlobalFlagsRaw(configs: WorkspaceConfiguration): string[] {
+	return configs.get<string[]>("coder.globalFlags", []);
+}
+
 /**
  * Returns global configuration flags for Coder CLI commands.
  * Always includes the `--global-config` argument with the specified config directory.
@@ -13,7 +20,7 @@ export function getGlobalFlags(
 ): string[] {
 	// Last takes precedence/overrides previous ones
 	return [
-		...(configs.get<string[]>("coder.globalFlags") || []),
+		...getGlobalFlagsRaw(configs),
 		"--global-config",
 		escapeCommandArg(configDir),
 		...getHeaderArgs(configs),

src/remote/remote.ts

@@ -20,14 +20,15 @@ import {
 import { extractAgents } from "../api/api-helper";
 import { CoderApi } from "../api/coderApi";
 import { needToken } from "../api/utils";
-import { getGlobalFlags, getSshFlags } from "../cliConfig";
+import { getGlobalFlags, getGlobalFlagsRaw, getSshFlags } from "../cliConfig";
 import { type Commands } from "../commands";
 import { type CliManager } from "../core/cliManager";
 import * as cliUtils from "../core/cliUtils";
 import { type ServiceContainer } from "../core/container";
 import { type ContextManager } from "../core/contextManager";
 import { type PathResolver } from "../core/pathResolver";
 import { featureSetForVersion, type FeatureSet } from "../featureSet";
+import { getHeaderCommand } from "../headers";
 import { Inbox } from "../inbox";
 import { type Logger } from "../logging/logger";
 import {
@@ -515,14 +516,34 @@ export class Remote {
 				...(await this.createAgentMetadataStatusBar(agent, workspaceClient)),
 			);
 
-			const settingsToWatch = [
-				{ setting: "coder.globalFlags", title: "Global flags" },
-				{ setting: "coder.sshFlags", title: "SSH flags" },
+			const settingsToWatch: Array<{
+				setting: string;
+				title: string;
+				getValue: () => unknown;
+			}> = [
+				{
+					setting: "coder.globalFlags",
+					title: "Global Flags",
+					getValue: () =>
+						getGlobalFlagsRaw(vscode.workspace.getConfiguration()),
+				},
+				{
+					setting: "coder.headerCommand",
+					title: "Header Command",
+					getValue: () =>
+						getHeaderCommand(vscode.workspace.getConfiguration()) ?? "",
+				},
+				{
+					setting: "coder.sshFlags",
+					title: "SSH Flags",
+					getValue: () => getSshFlags(vscode.workspace.getConfiguration()),
+				},
 			];
 			if (featureSet.proxyLogDirectory) {
 				settingsToWatch.push({
 					setting: "coder.proxyLogDirectory",
-					title: "Proxy log directory",
+					title: "Proxy Log Directory",
+					getValue: () => this.getLogDir(featureSet),
 				});
 			}
 			disposables.push(this.watchSettings(settingsToWatch));
@@ -801,25 +822,48 @@ export class Remote {
 	}
 
 	private watchSettings(
-		settings: Array<{ setting: string; title: string }>,
+		settings: Array<{
+			setting: string;
+			title: string;
+			getValue: () => unknown;
+		}>,
 	): vscode.Disposable {
+		// Capture applied values at setup time
+		const appliedValues = new Map(
+			settings.map((s) => [s.setting, s.getValue()]),
+		);
+
 		return vscode.workspace.onDidChangeConfiguration((e) => {
-			for (const { setting, title } of settings) {
+			const changedTitles: string[] = [];
+
+			for (const { setting, title, getValue } of settings) {
 				if (!e.affectsConfiguration(setting)) {
 					continue;
 				}
-				vscode.window
-					.showInformationMessage(
-						`${title} setting changed. Reload window to apply.`,
-						"Reload",
-					)
-					.then((action) => {
-						if (action === "Reload") {
-							vscode.commands.executeCommand("workbench.action.reloadWindow");
-						}
-					});
-				break;
+
+				const newValue = getValue();
+				if (
+					JSON.stringify(newValue) !==
+					JSON.stringify(appliedValues.get(setting))
+				) {
+					changedTitles.push(title);
+				}
+			}
+
+			if (changedTitles.length === 0) {
+				return;
 			}
+
+			const message =
+				changedTitles.length === 1
+					? `${changedTitles[0]} setting changed. Reload window to apply.`
+					: `${changedTitles.join(", ")} settings changed. Reload window to apply.`;
+
+			vscode.window.showInformationMessage(message, "Reload").then((action) => {
+				if (action === "Reload") {
+					vscode.commands.executeCommand("workbench.action.reloadWindow");
+				}
+			});
 		});
 	}
 

test/unit/cliConfig.test.ts

@@ -1,15 +1,15 @@
 import { it, expect, describe } from "vitest";
 import { type WorkspaceConfiguration } from "vscode";
 
-import { getGlobalFlags, getSshFlags } from "@/cliConfig";
+import { getGlobalFlags, getGlobalFlagsRaw, getSshFlags } from "@/cliConfig";
 
 import { isWindows } from "../utils/platform";
 
 describe("cliConfig", () => {
 	describe("getGlobalFlags", () => {
 		it("should return global-config and header args when no global flags configured", () => {
 			const config = {
-				get: () => undefined,
+				get: (_key: string, defaultValue: unknown) => defaultValue,
 			} as unknown as WorkspaceConfiguration;
 
 			expect(getGlobalFlags(config, "/config/dir")).toStrictEqual([
@@ -82,6 +82,30 @@ describe("cliConfig", () => {
 		});
 	});
 
+	describe("getGlobalFlagsRaw", () => {
+		it("returns empty array when no global flags configured", () => {
+			const config = {
+				get: (_key: string, defaultValue: unknown) => defaultValue,
+			} as unknown as WorkspaceConfiguration;
+
+			expect(getGlobalFlagsRaw(config)).toStrictEqual([]);
+		});
+
+		it("returns global flags from config", () => {
+			const config = {
+				get: (key: string) =>
+					key === "coder.globalFlags"
+						? ["--verbose", "--disable-direct-connections"]
+						: undefined,
+			} as unknown as WorkspaceConfiguration;
+
+			expect(getGlobalFlagsRaw(config)).toStrictEqual([
+				"--verbose",
+				"--disable-direct-connections",
+			]);
+		});
+	});
+
 	describe("getSshFlags", () => {
 		it("returns default flags when no SSH flags configured", () => {
 			const config = {