fix(hostConfig): deep-clone nested JSON records in DTO conversion

clientCapabilities and hostContext can be nested (e.g. the SDK's
default capabilities include `extensions.mimeTypes` arrays). The
shallow spread in hostConfigDtoToInput and emptyHostConfigInputV2
left those inner trees aliased to the source DTO, so any nested edit
through the returned mutable input would silently mutate the
baseline used for resets and dirty comparisons.

Replace shallow spreads with a recursive deepCloneJsonValue helper
that walks objects and arrays. Add a regression test that mutates
nested mimeTypes / hostContext.nested.deep.value through the input
and asserts the source DTO is unchanged.

https://claude.ai/code/session_01FjxdHVhJba5KpLjXiiuuCu

Author: claude

mcpjam-inspector/client/src/lib/__tests__/host-config-v2.test.ts

@@ -149,4 +149,53 @@ describe("hostConfigDtoToInput", () => {
     expect(dto.clientCapabilities).toEqual({ c: 1 });
     expect(dto.hostContext).toEqual({ h: 2 });
   });
+
+  it("deep-clones nested clientCapabilities and hostContext", () => {
+    const dto: HostConfigDtoV2 = {
+      id: "host-2",
+      schemaVersion: 2,
+      hostStyle: "claude",
+      modelId: "x",
+      systemPrompt: "",
+      temperature: 0.7,
+      requireToolApproval: false,
+      serverIds: [],
+      optionalServerIds: [],
+      connectionDefaults: { headers: {}, requestTimeout: 10000 },
+      clientCapabilities: {
+        extensions: { mimeTypes: ["a", "b"] },
+      } as Record<string, unknown>,
+      hostContext: {
+        nested: { deep: { value: 1 } },
+      } as Record<string, unknown>,
+    };
+    const input = hostConfigDtoToInput(dto);
+
+    // Mutate inside the nested trees and confirm the source DTO is
+    // unaffected — proves the clone descends into nested structures.
+    (
+      (input.clientCapabilities.extensions as Record<string, unknown>)
+        .mimeTypes as string[]
+    ).push("c");
+    (
+      (
+        (input.hostContext.nested as Record<string, unknown>).deep as Record<
+          string,
+          unknown
+        >
+      ) as { value: number }
+    ).value = 999;
+
+    expect(
+      (dto.clientCapabilities.extensions as Record<string, unknown>).mimeTypes,
+    ).toEqual(["a", "b"]);
+    expect(
+      (
+        (dto.hostContext.nested as Record<string, unknown>).deep as Record<
+          string,
+          unknown
+        >
+      ),
+    ).toEqual({ value: 1 });
+  });
 });

mcpjam-inspector/client/src/lib/host-config-v2.ts

@@ -123,16 +123,31 @@ export function emptyHostConfigInputV2(
     // ProjectClientConfig path also seeds from getDefaultClientCapabilities;
     // an empty {} here would silently drop MCP Apps support until the
     // user manually edited the capability JSON.
+    //
+    // Deep-clone — clientCapabilities and hostContext can be nested
+    // (e.g. extensions.mimeTypes arrays). A shallow spread would alias
+    // the inner trees with the partial/source, allowing later mutations
+    // to leak through.
     clientCapabilities: partial.clientCapabilities
-      ? { ...partial.clientCapabilities }
-      : (getDefaultClientCapabilities() as Record<string, unknown>),
-    hostContext: partial.hostContext ? { ...partial.hostContext } : {},
+      ? deepCloneJsonRecord(partial.clientCapabilities)
+      : deepCloneJsonRecord(
+          getDefaultClientCapabilities() as Record<string, unknown>,
+        ),
+    hostContext: partial.hostContext
+      ? deepCloneJsonRecord(partial.hostContext)
+      : {},
   };
 }
 
 export function hostConfigDtoToInput(
   dto: HostConfigDtoV2,
 ): HostConfigInputV2 {
+  // Deep-clone the JSON record fields. clientCapabilities and
+  // hostContext can be nested (e.g. the SDK's default capabilities
+  // include an `extensions` object with arrays). A shallow spread
+  // would leave the inner trees aliased to the source DTO; any nested
+  // edit through the returned input would silently mutate the
+  // baseline used for resets and dirty comparisons.
   return {
     hostStyle: dto.hostStyle,
     modelId: dto.modelId,
@@ -145,11 +160,31 @@ export function hostConfigDtoToInput(
       headers: { ...dto.connectionDefaults.headers },
       requestTimeout: dto.connectionDefaults.requestTimeout,
     },
-    clientCapabilities: { ...dto.clientCapabilities },
-    hostContext: { ...dto.hostContext },
+    clientCapabilities: deepCloneJsonRecord(dto.clientCapabilities),
+    hostContext: deepCloneJsonRecord(dto.hostContext),
   };
 }
 
+function deepCloneJsonRecord(
+  value: Record<string, unknown>,
+): Record<string, unknown> {
+  return deepCloneJsonValue(value) as Record<string, unknown>;
+}
+
+function deepCloneJsonValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(deepCloneJsonValue);
+  }
+  if (value && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = deepCloneJsonValue(v);
+    }
+    return out;
+  }
+  return value;
+}
+
 /**
  * Equality on the canonical fields (ignoring `id` and any extra
  * metadata). Used by editors to detect "no changes" before submitting.