fix(mcp): fix MCP server removal not persisting to settings (#10098)

Co-authored-by: Jacob Richman <jacob314@gmail.com>
2026-04-21 18:44:30 -07:00 · 2025-10-09 04:29:57 +08:00
parent 467a305f26
commit b92e3bca50
3 changed files with 498 additions and 66 deletions
@@ -7,6 +7,11 @@
 import * as fs from 'node:fs';
 import { parse, stringify } from 'comment-json';

+/**
+ * Type representing an object that may contain Symbol keys for comments.
+ */
+type CommentedRecord = Record<string | symbol, unknown>;
+
 /**
 * Updates a JSON file while preserving comments and formatting.
 */
@@ -38,30 +43,120 @@ export function updateSettingsFilePreservingFormat(
  fs.writeFileSync(filePath, updatedContent, 'utf-8');
 }

+/**
+ * When deleting a property from a comment-json parsed object, relocate any
+ * leading/trailing comments that were attached to that property so they are not lost.
+ *
+ * This function re-attaches comments to the next sibling's leading comments if
+ * available, otherwise to the previous sibling's trailing comments, otherwise
+ * to the container's leading/trailing comments.
+ */
+function preserveCommentsOnPropertyDeletion(
+  container: Record<string, unknown>,
+  propName: string,
+): void {
+  const target = container as CommentedRecord;
+  const beforeSym = Symbol.for(`before:${propName}`);
+  const afterSym = Symbol.for(`after:${propName}`);
+
+  const beforeComments = target[beforeSym] as unknown[] | undefined;
+  const afterComments = target[afterSym] as unknown[] | undefined;
+
+  if (!beforeComments && !afterComments) return;
+
+  const keys = Object.getOwnPropertyNames(container);
+  const idx = keys.indexOf(propName);
+  const nextKey = idx >= 0 && idx + 1 < keys.length ? keys[idx + 1] : undefined;
+  const prevKey = idx > 0 ? keys[idx - 1] : undefined;
+
+  function appendToSymbol(destSym: symbol, comments: unknown[]) {
+    if (!comments || comments.length === 0) return;
+    const existing = target[destSym];
+    target[destSym] = Array.isArray(existing)
+      ? existing.concat(comments)
+      : comments;
+  }
+
+  if (beforeComments && beforeComments.length > 0) {
+    if (nextKey) {
+      appendToSymbol(Symbol.for(`before:${nextKey}`), beforeComments);
+    } else if (prevKey) {
+      appendToSymbol(Symbol.for(`after:${prevKey}`), beforeComments);
+    } else {
+      appendToSymbol(Symbol.for('before'), beforeComments);
+    }
+    delete target[beforeSym];
+  }
+
+  if (afterComments && afterComments.length > 0) {
+    if (nextKey) {
+      appendToSymbol(Symbol.for(`before:${nextKey}`), afterComments);
+    } else if (prevKey) {
+      appendToSymbol(Symbol.for(`after:${prevKey}`), afterComments);
+    } else {
+      appendToSymbol(Symbol.for('after'), afterComments);
+    }
+    delete target[afterSym];
+  }
+}
+
+/**
+ * Applies sync-by-omission semantics: synchronizes base to match desired.
+ * - Adds/updates keys from desired
+ * - Removes keys from base that are not in desired
+ * - Recursively applies to nested objects
+ * - Preserves comments when deleting keys
+ */
+function applyKeyDiff(
+  base: Record<string, unknown>,
+  desired: Record<string, unknown>,
+): void {
+  for (const existingKey of Object.getOwnPropertyNames(base)) {
+    if (!Object.prototype.hasOwnProperty.call(desired, existingKey)) {
+      preserveCommentsOnPropertyDeletion(base, existingKey);
+      delete base[existingKey];
+    }
+  }
+
+  for (const nextKey of Object.getOwnPropertyNames(desired)) {
+    const nextVal = desired[nextKey];
+    const baseVal = base[nextKey];
+
+    const isObj =
+      typeof nextVal === 'object' &&
+      nextVal !== null &&
+      !Array.isArray(nextVal);
+    const isBaseObj =
+      typeof baseVal === 'object' &&
+      baseVal !== null &&
+      !Array.isArray(baseVal);
+    const isArr = Array.isArray(nextVal);
+    const isBaseArr = Array.isArray(baseVal);
+
+    if (isObj && isBaseObj) {
+      applyKeyDiff(
+        baseVal as Record<string, unknown>,
+        nextVal as Record<string, unknown>,
+      );
+    } else if (isArr && isBaseArr) {
+      // In-place mutate arrays to preserve array-level comments on CommentArray
+      const baseArr = baseVal as unknown[];
+      const desiredArr = nextVal as unknown[];
+      baseArr.length = 0;
+      for (const el of desiredArr) {
+        baseArr.push(el);
+      }
+    } else {
+      base[nextKey] = nextVal;
+    }
+  }
+}
+
 function applyUpdates(
  current: Record<string, unknown>,
  updates: Record<string, unknown>,
 ): Record<string, unknown> {
-  const result = current;
-
-  for (const key of Object.getOwnPropertyNames(updates)) {
-    const value = updates[key];
-    if (
-      typeof value === 'object' &&
-      value !== null &&
-      !Array.isArray(value) &&
-      typeof result[key] === 'object' &&
-      result[key] !== null &&
-      !Array.isArray(result[key])
-    ) {
-      result[key] = applyUpdates(
-        result[key] as Record<string, unknown>,
-        value as Record<string, unknown>,
-      );
-    } else {
-      result[key] = value;
-    }
-  }
-
-  return result;
+  // Apply sync-by-omission semantics consistently at all levels
+  applyKeyDiff(current, updates);
+  return current;
 }