fix: handle JSONC in VS Code settings.json and use atomic write

VS Code settings.json is JSONC (JSON with Comments) which allows line
comments (//), block comments (/* */), and trailing commas. The previous
implementation used plain json.Unmarshal which fails on any JSONC input.

Add stripJSONC() to remove comments and trailing commas before parsing,
preserving comment-like content inside string literals.

Also make writeSettings() atomic: write to a temp file then rename, with
fallback to direct write if rename fails. This prevents settings.json
corruption if the process is interrupted mid-write.

Author: dlevy-msft-sql

cmd/modern/root/open/jsonc.go

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+package open
+
+// stripJSONC removes comments (// and /* */) and trailing commas from JSONC
+// data, producing valid JSON. String literals are preserved as-is.
+func stripJSONC(data []byte) []byte {
+	var result []byte
+	i := 0
+	n := len(data)
+
+	for i < n {
+		// String literal: copy verbatim, respecting escape sequences
+		if data[i] == '"' {
+			result = append(result, data[i])
+			i++
+			for i < n && data[i] != '"' {
+				if data[i] == '\\' && i+1 < n {
+					result = append(result, data[i], data[i+1])
+					i += 2
+					continue
+				}
+				result = append(result, data[i])
+				i++
+			}
+			if i < n {
+				result = append(result, data[i]) // closing "
+				i++
+			}
+			continue
+		}
+
+		// Line comment: skip to end of line
+		if i+1 < n && data[i] == '/' && data[i+1] == '/' {
+			i += 2
+			for i < n && data[i] != '\n' {
+				i++
+			}
+			continue
+		}
+
+		// Block comment: skip to closing */
+		if i+1 < n && data[i] == '/' && data[i+1] == '*' {
+			i += 2
+			for i+1 < n {
+				if data[i] == '*' && data[i+1] == '/' {
+					i += 2
+					break
+				}
+				i++
+			}
+			continue
+		}
+
+		result = append(result, data[i])
+		i++
+	}
+
+	// Second pass: remove trailing commas before ] or }
+	cleaned := make([]byte, 0, len(result))
+	for i := 0; i < len(result); i++ {
+		if result[i] == ',' {
+			j := i + 1
+			for j < len(result) && (result[j] == ' ' || result[j] == '\t' || result[j] == '\n' || result[j] == '\r') {
+				j++
+			}
+			if j < len(result) && (result[j] == ']' || result[j] == '}') {
+				continue // skip trailing comma
+			}
+		}
+		cleaned = append(cleaned, result[i])
+	}
+
+	return cleaned
+}

cmd/modern/root/open/jsonc_test.go

@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+package open
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestStripJSONC_LineComments(t *testing.T) {
+	input := []byte(`{
+  // This is a comment
+  "key": "value" // inline comment
+}`)
+	result := stripJSONC(input)
+	var m map[string]interface{}
+	if err := json.Unmarshal(result, &m); err != nil {
+		t.Fatalf("Failed to parse stripped JSONC: %v\nResult: %s", err, result)
+	}
+	if m["key"] != "value" {
+		t.Errorf("Expected 'value', got %v", m["key"])
+	}
+}
+
+func TestStripJSONC_BlockComments(t *testing.T) {
+	input := []byte(`{
+  /* block comment */
+  "key": "value",
+  /*
+   * multi-line
+   * block comment
+   */
+  "other": 42
+}`)
+	result := stripJSONC(input)
+	var m map[string]interface{}
+	if err := json.Unmarshal(result, &m); err != nil {
+		t.Fatalf("Failed to parse stripped JSONC: %v\nResult: %s", err, result)
+	}
+	if m["key"] != "value" {
+		t.Errorf("Expected 'value', got %v", m["key"])
+	}
+	if m["other"] != float64(42) {
+		t.Errorf("Expected 42, got %v", m["other"])
+	}
+}
+
+func TestStripJSONC_TrailingCommas(t *testing.T) {
+	input := []byte(`{
+  "a": 1,
+  "b": [1, 2, 3,],
+  "c": {"x": 1,},
+}`)
+	result := stripJSONC(input)
+	var m map[string]interface{}
+	if err := json.Unmarshal(result, &m); err != nil {
+		t.Fatalf("Failed to parse stripped JSONC: %v\nResult: %s", err, result)
+	}
+	if m["a"] != float64(1) {
+		t.Errorf("Expected 1, got %v", m["a"])
+	}
+}
+
+func TestStripJSONC_CommentsInStringsPreserved(t *testing.T) {
+	input := []byte(`{
+  "url": "http://example.com",
+  "note": "has // slashes and /* stars */",
+  "path": "C:\\Users\\test"
+}`)
+	result := stripJSONC(input)
+	var m map[string]interface{}
+	if err := json.Unmarshal(result, &m); err != nil {
+		t.Fatalf("Failed to parse stripped JSONC: %v\nResult: %s", err, result)
+	}
+	if m["url"] != "http://example.com" {
+		t.Errorf("URL mangled: %v", m["url"])
+	}
+	if m["note"] != "has // slashes and /* stars */" {
+		t.Errorf("String with comment-like content mangled: %v", m["note"])
+	}
+	if m["path"] != `C:\Users\test` {
+		t.Errorf("Escaped path mangled: %v", m["path"])
+	}
+}
+
+func TestStripJSONC_RealWorldVSCodeSettings(t *testing.T) {
+	// Realistic VS Code settings.json with JSONC features
+	input := []byte(`{
+  // Editor settings
+  "editor.fontSize": 14,
+  "editor.tabSize": 2,
+
+  /* Database connections */
+  "mssql.connections": [
+    {
+      "server": "localhost,1433",
+      "profileName": "my-db",
+      "encrypt": "Optional",
+      "trustServerCertificate": true,
+    },
+  ],
+
+  // Terminal settings
+  "terminal.integrated.fontSize": 12,
+}`)
+	result := stripJSONC(input)
+	var m map[string]interface{}
+	if err := json.Unmarshal(result, &m); err != nil {
+		t.Fatalf("Failed to parse real-world JSONC: %v\nResult: %s", err, result)
+	}
+	if m["editor.fontSize"] != float64(14) {
+		t.Errorf("Expected fontSize 14, got %v", m["editor.fontSize"])
+	}
+	conns, ok := m["mssql.connections"].([]interface{})
+	if !ok || len(conns) != 1 {
+		t.Fatalf("Expected 1 connection, got %v", m["mssql.connections"])
+	}
+}
+
+func TestStripJSONC_EmptyInput(t *testing.T) {
+	result := stripJSONC([]byte{})
+	if len(result) != 0 {
+		t.Errorf("Expected empty result, got %s", result)
+	}
+}
+
+func TestStripJSONC_PureJSON(t *testing.T) {
+	// No comments, no trailing commas - should pass through cleanly
+	input := []byte(`{"key": "value", "num": 42}`)
+	result := stripJSONC(input)
+	var m map[string]interface{}
+	if err := json.Unmarshal(result, &m); err != nil {
+		t.Fatalf("Failed to parse pure JSON: %v", err)
+	}
+	if m["key"] != "value" || m["num"] != float64(42) {
+		t.Errorf("Values changed: %v", m)
+	}
+}

cmd/modern/root/open/vscode.go

@@ -163,7 +163,10 @@ func (c *VSCode) readSettings(path string) map[string]interface{} {
 	}
 
 	if len(data) > 0 {
-		if err := json.Unmarshal(data, &settings); err != nil {
+		// VS Code settings.json is JSONC (allows comments and trailing commas).
+		// Strip those before parsing so standard json.Unmarshal succeeds.
+		clean := stripJSONC(data)
+		if err := json.Unmarshal(clean, &settings); err != nil {
 			output := c.Output()
 			output.FatalWithHintExamples([][]string{
 				{localizer.Sprintf("Error"), err.Error()},
@@ -184,6 +187,28 @@ func (c *VSCode) writeSettings(path string, settings map[string]interface{}) {
 		}, localizer.Sprintf("Failed to encode VS Code settings"))
 	}
 
+	// Append a final newline for consistency with VS Code's own formatting
+	data = append(data, '\n')
+
+	// Atomic write: write to a temp file in the same directory, then rename.
+	// If rename fails (e.g. another process holds the file), fall back to
+	// a direct write so the command still succeeds.
+	dir := filepath.Dir(path)
+	tmp, tmpErr := os.CreateTemp(dir, ".settings-*.tmp")
+	if tmpErr == nil {
+		tmpPath := tmp.Name()
+		_, writeErr := tmp.Write(data)
+		closeErr := tmp.Close()
+		if writeErr != nil || closeErr != nil {
+			os.Remove(tmpPath)
+		} else if renameErr := os.Rename(tmpPath, path); renameErr != nil {
+			os.Remove(tmpPath)
+		} else {
+			return // atomic write succeeded
+		}
+	}
+
+	// Fallback: direct write
 	if err := os.WriteFile(path, data, 0600); err != nil {
 		output.FatalWithHintExamples([][]string{
 			{localizer.Sprintf("Error"), err.Error()},