fix: clean up vscode connection profile when sqlcmd delete runs

Removes the mssql.connections entry (and any inline password persisted for container-backed endpoints) from both stable and insiders VS Code settings.json when the underlying sqlcmd context is deleted. Best-effort: missing files or parse errors never fail the delete. JSONC comments and unrelated keys are preserved via hujson Patch.

Author: dlevy-msft-sql

cmd/modern/root/open/vscode.go

@@ -199,7 +199,7 @@ func (c *VSCode) readSettings(path string) ([]byte, map[string]interface{}) {
 		}, localizer.Sprintf("Failed to read VS Code settings"))
 	}
 
-	settings, err := parseJSONCSettings(data)
+	settings, err := parseJSONCSettings(append([]byte(nil), data...))
 	if err != nil {
 		c.Output().FatalWithHintExamples([][]string{
 			{localizer.Sprintf("Error"), err.Error()},
@@ -344,8 +344,27 @@ func ensureRootGroup(existing interface{}) []interface{} {
 }
 
 func (c *VSCode) getVSCodeSettingsPath(build string) string {
+	path, err := vsCodeSettingsPath(build)
+	if err != nil {
+		hint := [][]string{
+			{localizer.Sprintf("Set the HOME environment variable"), "export HOME=/your/home"},
+		}
+		if runtime.GOOS == "windows" {
+			hint = [][]string{
+				{localizer.Sprintf("Set the USERPROFILE environment variable"), `set USERPROFILE=C:\Users\you`},
+			}
+		}
+		c.Output().FatalWithHintExamples(hint, localizer.Sprintf("Could not resolve home directory: %s", err.Error()))
+	}
+	return path
+}
+
+// vsCodeSettingsPath resolves the settings.json path for the given VS Code
+// build without exiting on failure, so callers like the uninstall cleanup
+// path can degrade gracefully when the home directory is unavailable.
+func vsCodeSettingsPath(build string) (string, error) {
 	if testSettingsPathOverride != "" {
-		return testSettingsPathOverride
+		return testSettingsPathOverride, nil
 	}
 
 	appName := "Code"
@@ -354,20 +373,11 @@ func (c *VSCode) getVSCodeSettingsPath(build string) string {
 	}
 
 	home, err := os.UserHomeDir()
-	if err != nil || home == "" {
-		hint := [][]string{
-			{localizer.Sprintf("Set the HOME environment variable"), "export HOME=/your/home"},
-		}
-		if runtime.GOOS == "windows" {
-			hint = [][]string{
-				{localizer.Sprintf("Set the USERPROFILE environment variable"), `set USERPROFILE=C:\Users\you`},
-			}
-		}
-		reason := localizer.Sprintf("empty home directory")
-		if err != nil {
-			reason = err.Error()
-		}
-		c.Output().FatalWithHintExamples(hint, localizer.Sprintf("Could not resolve home directory: %s", reason))
+	if err != nil {
+		return "", err
+	}
+	if home == "" {
+		return "", fmt.Errorf("empty home directory")
 	}
 
 	var configDir string
@@ -384,7 +394,7 @@ func (c *VSCode) getVSCodeSettingsPath(build string) string {
 		configDir = linuxVSCodeConfigDir(home, appName, build, vsCodeExePath(build), os.Getenv("XDG_CONFIG_HOME"))
 	}
 
-	return filepath.Join(configDir, "settings.json")
+	return filepath.Join(configDir, "settings.json"), nil
 }
 
 // linuxVSCodeConfigDir resolves the VS Code User config directory on Linux.
@@ -446,3 +456,80 @@ func isLocalEndpoint(endpoint sqlconfig.Endpoint) bool {
 	asset := endpoint.AssetDetails
 	return asset != nil && asset.ContainerDetails != nil
 }
+
+// RemoveContextFromVSCodeSettings deletes any mssql connection profile named
+// contextName from each known VS Code build's settings.json. It is best
+// effort: missing files, unresolvable home dirs, and parse/write errors are
+// swallowed so `sqlcmd delete` never fails on cleanup. Returns the list of
+// settings paths that were actually modified, so callers can report what
+// they cleaned up.
+func RemoveContextFromVSCodeSettings(contextName string) []string {
+	if contextName == "" {
+		return nil
+	}
+	var cleaned []string
+	seen := map[string]bool{}
+	for _, build := range []string{"stable", "insiders"} {
+		path, err := vsCodeSettingsPath(build)
+		if err != nil || path == "" || seen[path] {
+			continue
+		}
+		seen[path] = true
+		removed, err := removeProfileFromVSCodeSettings(path, contextName)
+		if err == nil && removed {
+			cleaned = append(cleaned, path)
+		}
+	}
+	return cleaned
+}
+
+// removeProfileFromVSCodeSettings rewrites settings.json with any
+// mssql.connections entry whose profileName matches contextName stripped out.
+// Returns (true, nil) when the file was modified, (false, nil) when no
+// matching profile was present or the file does not exist.
+func removeProfileFromVSCodeSettings(settingsPath, contextName string) (bool, error) {
+	data, err := os.ReadFile(settingsPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	// parseJSONCSettings may mutate the input bytes via hujson.Standardize,
+	// so peek on a copy and keep the pristine original for the JSONC-aware
+	// rewrite below.
+	settings, err := parseJSONCSettings(append([]byte(nil), data...))
+	if err != nil {
+		return false, err
+	}
+
+	existing, ok := settings["mssql.connections"].([]interface{})
+	if !ok || len(existing) == 0 {
+		return false, nil
+	}
+
+	filtered := make([]interface{}, 0, len(existing))
+	for _, conn := range existing {
+		if connMap, ok := conn.(map[string]interface{}); ok {
+			if name, _ := connMap["profileName"].(string); name == contextName {
+				continue
+			}
+		}
+		filtered = append(filtered, conn)
+	}
+	if len(filtered) == len(existing) {
+		return false, nil
+	}
+
+	out, err := applyJSONCSettingsUpdates(data, map[string]interface{}{
+		"mssql.connections": filtered,
+	})
+	if err != nil {
+		return false, err
+	}
+	if err := os.WriteFile(settingsPath, out, 0600); err != nil {
+		return false, err
+	}
+	return true, nil
+}

cmd/modern/root/open/vscode_cleanup_test.go

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+package open
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestRemoveContextFromVSCodeSettings(t *testing.T) {
+	tmp := t.TempDir()
+	path := filepath.Join(tmp, "settings.json")
+	testSettingsPathOverride = path
+	t.Cleanup(func() { testSettingsPathOverride = "" })
+
+	initial := `{
+    // user comment that must survive
+    "editor.fontSize": 14,
+    "mssql.connections": [
+        { "profileName": "keep-me",   "server": "kept,1433" },
+        { "profileName": "doomed-ctx", "server": "localhost,1433", "password": "shh" }
+    ]
+}
+`
+	if err := os.WriteFile(path, []byte(initial), 0600); err != nil {
+		t.Fatal(err)
+	}
+
+	cleaned := RemoveContextFromVSCodeSettings("doomed-ctx")
+	if len(cleaned) != 1 || cleaned[0] != path {
+		t.Fatalf("expected cleanup to report %s, got %v", path, cleaned)
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !strings.Contains(string(data), "user comment that must survive") {
+		t.Errorf("comment was stripped: %s", data)
+	}
+
+	settings, err := parseJSONCSettings(data)
+	if err != nil {
+		t.Fatalf("settings no longer parse: %v\n%s", err, data)
+	}
+
+	conns, _ := settings["mssql.connections"].([]interface{})
+	if len(conns) != 1 {
+		t.Fatalf("expected exactly 1 remaining connection, got %d: %s", len(conns), mustJSON(conns))
+	}
+	name, _ := conns[0].(map[string]interface{})["profileName"].(string)
+	if name != "keep-me" {
+		t.Errorf("wrong connection survived: %s", name)
+	}
+
+	// Second call is a no-op once the entry is gone.
+	if cleaned := RemoveContextFromVSCodeSettings("doomed-ctx"); len(cleaned) != 0 {
+		t.Errorf("expected no cleanup on second call, got %v", cleaned)
+	}
+}
+
+func TestRemoveContextFromVSCodeSettings_MissingFile(t *testing.T) {
+	testSettingsPathOverride = filepath.Join(t.TempDir(), "does-not-exist.json")
+	t.Cleanup(func() { testSettingsPathOverride = "" })
+
+	if cleaned := RemoveContextFromVSCodeSettings("anything"); len(cleaned) != 0 {
+		t.Errorf("expected no cleanup when file is missing, got %v", cleaned)
+	}
+}
+
+func TestRemoveContextFromVSCodeSettings_EmptyName(t *testing.T) {
+	if cleaned := RemoveContextFromVSCodeSettings(""); cleaned != nil {
+		t.Errorf("expected nil for empty context name, got %v", cleaned)
+	}
+}
+
+func mustJSON(v interface{}) string {
+	b, _ := json.MarshalIndent(v, "", "  ")
+	return string(b)
+}

cmd/modern/root/uninstall.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/microsoft/go-sqlcmd/cmd/modern/root/open"
 	"github.com/microsoft/go-sqlcmd/internal/cmdparser"
 	"github.com/microsoft/go-sqlcmd/internal/config"
 	"github.com/microsoft/go-sqlcmd/internal/container"
@@ -84,6 +85,7 @@ func (c *Uninstall) run() {
 		}, localizer.Sprintf("No current context"))
 	}
 	if c.currentContextEndPointExists() {
+		contextName := config.CurrentContextName()
 		if config.CurrentContextEndpointHasContainer() {
 			controller := container.NewController()
 			id := config.ContainerId()
@@ -129,6 +131,10 @@ func (c *Uninstall) run() {
 		config.RemoveCurrentContext()
 		config.Save()
 
+		for _, path := range open.RemoveContextFromVSCodeSettings(contextName) {
+			output.Info(localizer.Sprintf("Removed VS Code connection profile from %s", path))
+		}
+
 		newContextName := config.CurrentContextName()
 		if newContextName != "" {
 			output.Info(localizer.Sprintf("Current context is now %s", newContextName))