rea-agents 6.4.0 → 6.7.0

package/dist/application/ClientConfigurationDocument.js

@@ -1,9 +1,12 @@
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-import { parse as parseYaml, parseDocument as parseYamlDocument, stringify as stringifyYaml, } from "yaml";
 import { isDeepStrictEqual } from "node:util";
-import { applyEdits, findNodeAtLocation, modify, parse as parseJsonc, parseTree, printParseErrorCode, } from "jsonc-parser";
+import { parseDshCordisDocument, serializeDshDocument, editDshDocument, dshClientRegistrationEntry, } from "./DshCordisPatch.js";
+import { editHermesConfigurationYaml, parseHermesConfigurationYaml, stringifyHermesConfigurationYaml, } from "./HermesConfigurationYaml.js";
+import { applyEdits, createScanner, format as formatJson, parse as parseJsonc, parseTree, printParseErrorCode, } from "jsonc-parser";
 import { z } from "zod";
+import { err, ok } from "../domain/result.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 const objectSchema = z.record(z.string(), z.unknown());
 /** Compare parsed configuration values without depending on parser prototypes. */
 export const clientConfigurationValuesEqual = (left, right) => isDeepStrictEqual(normalizeConfigurationValue(left), normalizeConfigurationValue(right));
@@ -13,7 +16,7 @@ const normalizeConfigurationValue = (value) => {
     if (typeof value !== "object" || value === null || value instanceof Date)
         return value;
     return Object.fromEntries(Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
+        .sort(([left], [right]) => compareUnicodeCodePoints(left, right))
         .map(([key, nested]) => [key, normalizeConfigurationValue(nested)]));
 };
 /** Return the top-level object used for MCP server registrations by a client. */
@@ -24,6 +27,7 @@ export const clientConfigurationServersKey = (format) => {
         case "hermes":
             return "mcp_servers";
         case "opencode":
+        case "zcode":
             return "mcp";
         case "vscode":
             return "servers";
@@ -36,21 +40,56 @@ export const clientConfigurationServersKey = (format) => {
  * create a zero-byte config file before any server is added.
  */
 const isEmptyClientConfigurationText = (text) => text.replace(/^\uFEFF/, "").trim() === "";
+const INT64_MIN = -(2n ** 63n);
+const INT64_MAX = 2n ** 63n - 1n;
+/**
+ * Parse client TOML with TOML 1.0's signed 64-bit integer contract. Integers
+ * beyond JavaScript's safe range stay exact as bigint; values outside Int64,
+ * which Codex rejects, are malformed.
+ */
+const parseClientToml = (text) => {
+    const parsed = parseToml(text, { integersAsBigInt: "asNeeded" });
+    const pending = [parsed];
+    for (let value = pending.pop(); value !== undefined; value = pending.pop()) {
+        if (typeof value === "bigint") {
+            if (value < INT64_MIN || value > INT64_MAX)
+                throw new SyntaxError(`Invalid TOML document: integer ${String(value)} is outside the signed 64-bit range`);
+        }
+        else if (typeof value === "object" &&
+            value !== null &&
+            !(value instanceof Date))
+            // Large documents can exceed argument limits, so do not spread.
+            for (const nested of Object.values(value))
+                pending.push(nested);
+    }
+    return parsed;
+};
 const parseDocument = (text, format) => {
     if (format === "toml" || format === "grok")
-        return objectSchema.parse(parseToml(text));
+        return requireObject(parseClientToml(text), "The configuration root");
     // Pi loads `mcp.json` with a strict `JSON.parse` and no BOM tolerance, so
     // comments, trailing commas, a BOM, or an empty existing file must be
-    // rejected instead of registering into a document Pi cannot load.
-    if (format === "pi")
-        return objectSchema.parse(JSON.parse(text));
-    // Hermes stores MCP servers in `mcp_servers` inside a YAML document.
-    if (format === "hermes")
-        return objectSchema.parse(parseYaml(text));
+    // rejected instead of registering into a document the client cannot load.
+    // Kimi also reads mcp.json with JSON.parse and an empty-file fallback.
+    if (format === "pi" || format === "kimi") {
+        if (format === "kimi" && text.trim().length === 0)
+            return {};
+        return requireObject(JSON.parse(text), "The configuration root");
+    }
     // An empty file, which some clients create before any server is added,
     // holds no settings to preserve.
     if (isEmptyClientConfigurationText(text))
         return {};
+    // Hermes stores MCP servers in `mcp_servers` inside a YAML document.
+    if (format === "hermes")
+        return requireObject(parseHermesConfigurationYaml(text), "The configuration root");
+    // ZCode loads nonempty native files with strict JSON.parse.
+    if (format === "zcode")
+        return requireObject(JSON.parse(text), "The configuration root");
+    // Claude Code loads `.claude.json` with strict JSON.parse after a UTF-8 BOM,
+    // so comments and trailing commas it rejects must not be admitted as JSONC.
+    if (format === "claude_code")
+        return requireObject(JSON.parse(text.replace(/^\uFEFF/, "")), "The configuration root");
     const errors = [];
     // Accept a UTF-8 BOM without shifting diagnostics or editing the original text.
     const jsonText = text.startsWith("\uFEFF") ? ` ${text.slice(1)}` : text;
@@ -58,7 +97,32 @@ const parseDocument = (text, format) => {
     const firstError = errors[0];
     if (firstError !== undefined)
         throw new SyntaxError(`Invalid JSON/JSONC at offset ${firstError.offset}: ${printParseErrorCode(firstError.error)}`);
-    return objectSchema.parse(document);
+    return requireObject(document, "The configuration root");
+};
+/** A parsed configuration whose structure, not its syntax, cannot hold MCP servers. */
+export class ClientConfigurationShapeError extends TypeError {
+}
+/** Validate and copy own properties, excluding non-record YAML values and parser-injected prototypes. */
+const requireObject = (value, description) => {
+    const parsed = objectSchema.safeParse(value);
+    if (parsed.success)
+        return parsed.data;
+    throw new ClientConfigurationShapeError(`${description} must be an object`, {
+        cause: parsed.error,
+    });
+};
+/** ZCode reads the same-scope fallback as strict JSON with a mcpServers table. */
+export const parseZcodeFallbackConfiguration = (text) => {
+    const document = requireObject(JSON.parse(text), "ZCode fallback root");
+    return {
+        document,
+        servers: document.mcpServers === undefined
+            ? {}
+            : requireObject(document.mcpServers, "ZCode fallback mcpServers"),
+        serversPath: ["mcpServers"],
+        dialect: "zcode_fallback",
+        legacyServers: {},
+    };
 };
 /** Members of OpenCode V2's `mcp` object that are not server names. */
 const OPENCODE_V2_MCP_SETTINGS = new Set(["servers", "timeout"]);
@@ -66,10 +130,29 @@ const OPENCODE_V2_MCP_SETTINGS = new Set(["servers", "timeout"]);
 export const parseClientConfiguration = (text, format) => {
     if (format === undefined || format === "unsupported")
         throw new TypeError("client does not have a supported MCP config format");
+    // DeepSeek Harness stores a Cordis patch list, not a server table.
+    if (format === "zcode_fallback")
+        return parseZcodeFallbackConfiguration(text);
+    if (format === "dsh")
+        return parseDshCordisDocument(text);
     const document = parseDocument(text, format);
     const serversKey = clientConfigurationServersKey(format);
     const value = document[serversKey];
-    const servers = value === undefined ? {} : objectSchema.parse(value);
+    const servers = value === undefined ? {} : requireObject(value, `"${serversKey}"`);
+    // ZCode reads stdio servers from the nested `mcp.servers` table of
+    // `~/.zcode/cli/config.json`; entries carry `command`, `args`, and `env`.
+    if (format === "zcode") {
+        const nested = servers.servers;
+        return {
+            document,
+            servers: nested === undefined
+                ? {}
+                : requireObject(nested, `"${serversKey}.servers"`),
+            serversPath: [serversKey, "servers"],
+            dialect: format,
+            legacyServers: {},
+        };
+    }
     const native = servers.servers;
     // A V1 server named `servers` has a string `type` discriminator; the V2
     // table may instead hold a server object named `type`.
@@ -88,7 +171,7 @@ export const parseClientConfiguration = (text, format) => {
         };
     return {
         document,
-        servers: objectSchema.parse(native),
+        servers: requireObject(native, `"${serversKey}.servers"`),
         serversPath: [serversKey, "servers"],
         dialect: "opencode_v2",
         legacyServers: Object.fromEntries(Object.entries(servers).filter(([name]) => !OPENCODE_V2_MCP_SETTINGS.has(name))),
@@ -103,11 +186,21 @@ export const effectiveClientServer = (parsed, name) => Object.hasOwn(parsed.serv
  * V1 member named in `removeLegacy` is removed beside a native V2 table.
  */
 export const withClientServers = (parsed, servers, removeLegacy) => {
+    // The Harness patch list upserts or removes by entry id, not by table.
+    if (parsed.dialect === "dsh")
+        return Object.hasOwn(servers, PRODUCT_IDENTITY.mcpServerKey)
+            ? editDshDocument(parsed, objectSchema.parse(servers[PRODUCT_IDENTITY.mcpServerKey]))
+            : editDshDocument(parsed);
     const [key = "", nested] = parsed.serversPath;
     if (nested === undefined)
         return { ...parsed.document, [key]: servers };
-    const outer = { ...objectSchema.parse(parsed.document[key]) };
-    if (removeLegacy !== undefined && !OPENCODE_V2_MCP_SETTINGS.has(removeLegacy))
+    // A fresh document may not hold the outer table yet (for example a new
+    // ZCode `config.json` without an `mcp` object), so treat absence as empty.
+    const outerValue = parsed.document[key];
+    const outer = outerValue === undefined ? {} : { ...objectSchema.parse(outerValue) };
+    if (parsed.dialect === "opencode_v2" &&
+        removeLegacy !== undefined &&
+        !OPENCODE_V2_MCP_SETTINGS.has(removeLegacy))
         delete outer[removeLegacy];
     return { ...parsed.document, [key]: { ...outer, [nested]: servers } };
 };
@@ -447,6 +540,8 @@ const tomlInlineValue = (value) => {
         return value ? "true" : "false";
     if (typeof value === "number" && Number.isFinite(value))
         return String(value);
+    if (typeof value === "bigint")
+        return String(value);
     if (Array.isArray(value))
         return `[${value.map((item) => tomlInlineValue(item)).join(", ")}]`;
     if (typeof value === "object" && value !== null) {
@@ -589,7 +684,7 @@ const rebuildDelimitedEntries = (pairs, trailing, insertion, open, close) => {
  */
 const tomlStringValue = (text) => {
     try {
-        const value = parseToml(`value = ${text}`)["value"];
+        const value = parseClientToml(`value = ${text}`)["value"];
         return typeof value === "string" ? value : undefined;
     }
     catch (cause) {
@@ -676,6 +771,13 @@ const disabledServerListLines = (edit, lines, lineIndex, endLine) => {
         }
     }
 };
+/** Strip terminal LF without rescanning internal blank-line runs. */
+const withoutTrailingLineFeeds = (text) => {
+    let end = text.length;
+    while (end > 0 && text.charCodeAt(end - 1) === 10)
+        end -= 1;
+    return text.slice(0, end);
+};
 /**
  * Replace REA's TOML server tables and assignments. Comments that introduce a
  * following table stay. Codex also retains comments around REA's own table.
@@ -706,17 +808,15 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
     const discardPending = () => {
         pending.length = 0;
     };
+    // Document line counts must not become engine-limited argument counts.
+    const appendLines = (lines) => {
+        for (const line of lines)
+            kept.push(line);
+    };
     const flushPending = () => {
-        kept.push(...pending);
+        appendLines(pending);
         pending.length = 0;
     };
-    const lineIndexAt = (offset) => {
-        let line = 0;
-        for (let index = 0; index < lineStarts.length; index += 1)
-            if ((lineStarts[index] ?? 0) <= offset)
-                line = index;
-        return line;
-    };
     let lineIndex = 0;
     while (lineIndex < lines.length) {
         const physical = lines[lineIndex] ?? "";
@@ -753,7 +853,12 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
             let statementEnd = valueEnd;
             while (statementEnd < text.length && text[statementEnd] !== "\n")
                 statementEnd += 1;
-            const endLine = lineIndexAt(Math.max(statementEnd - 1, lineStart));
+            const lastOffset = Math.max(statementEnd - 1, lineStart);
+            let endLine = lineIndex;
+            // Statements advance through the source; only inspect their own lines.
+            while (endLine + 1 < lineStarts.length &&
+                (lineStarts[endLine + 1] ?? 0) <= lastOffset)
+                endLine += 1;
             if (skipping) {
                 discardPending();
                 lineIndex = endLine + 1;
@@ -775,7 +880,7 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
                 : undefined;
             if (disabledLines !== undefined) {
                 flushPending();
-                kept.push(...disabledLines);
+                appendLines(disabledLines);
                 lineIndex = endLine + 1;
                 mode = "none";
                 continue;
@@ -794,7 +899,7 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
                     const replacement = edited === undefined
                         ? text.slice(lineStart, statementEnd)
                         : `${prefix}${edited}${suffix}`;
-                    kept.push(...replacement.split("\n"));
+                    appendLines(replacement.split("\n"));
                     inlineServerTable = true;
                 }
                 else
@@ -843,14 +948,12 @@ const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
     if (body.endsWith("\r"))
         body += "\n";
     if (entry !== undefined && !inlineServerTable) {
-        let fragment = stringifyToml({
-            mcp_servers: { [serverKey]: entry },
-        }).replace(/\n+$/u, "");
+        let fragment = withoutTrailingLineFeeds(stringifyToml({ mcp_servers: { [serverKey]: entry } }));
         if (crlf)
             fragment = fragment.replaceAll("\n", "\r\n");
         const nl = crlf ? "\r\n" : "\n";
         const endedWithNewline = body.endsWith("\n");
-        const base = body.replace(/\n+$/u, "");
+        const base = withoutTrailingLineFeeds(body);
         const trimmed = endedWithNewline && base.endsWith("\r") ? base.slice(0, -1) : base;
         body =
             trimmed.length === 0
@@ -929,7 +1032,7 @@ const serializeCodexConfiguration = (document, originalText) => {
 };
 const tomlTextHolds = (text, document) => {
     try {
-        return clientConfigurationValuesEqual(withoutEmptyServerTable(objectSchema.parse(parseToml(text))), withoutEmptyServerTable(document));
+        return clientConfigurationValuesEqual(withoutEmptyServerTable(objectSchema.parse(parseClientToml(text))), withoutEmptyServerTable(document));
     }
     catch (cause) {
         // An unparsable edit is rejected in favor of the full rewrite.
@@ -937,129 +1040,134 @@ const tomlTextHolds = (text, document) => {
         return false;
     }
 };
-/** Comments in the trivia between two properties. `undefined` when there are none. */
-const commentsBetweenProperties = (gap) => {
-    const pieces = [];
-    let index = 0;
-    while (index < gap.length) {
-        const line = gap.indexOf("//", index);
-        const block = gap.indexOf("/*", index);
-        if (line < 0 && block < 0)
-            break;
-        const start = line < 0 ? block : block < 0 ? line : Math.min(line, block);
-        const lineComment = start === line;
-        const close = lineComment
-            ? gap.indexOf("\n", start)
-            : gap.indexOf("*/", start + 2);
-        if (!lineComment && close < 0)
-            return undefined;
-        const end = lineComment ? (close < 0 ? gap.length : close) : close + 2;
-        const comment = gap.slice(start, end);
-        const lineBreak = gap.lastIndexOf("\n", start - 1);
-        if (lineBreak < 0)
-            pieces.push(` ${comment}`);
-        else {
-            const prefix = gap.slice(lineBreak + 1, start);
-            let indentEnd = 0;
-            while (prefix[indentEnd] === " " || prefix[indentEnd] === "\t")
-                indentEnd += 1;
-            const newline = lineBreak > 0 && gap[lineBreak - 1] === "\r" ? "\r\n" : "\n";
-            pieces.push(`${newline}${prefix.slice(0, indentEnd)}${comment}`);
-        }
-        index = end;
+// jsonc-parser declares SyntaxKind as an ambient const enum, so keep its token
+// code local and type-checked as in the JSON scanner used by IDA diagnostics.
+const JSON_COMMA = 5;
+/** Find the next non-trivia JSONC token at or after `offset`. */
+const nextJsoncToken = (text, offset) => {
+    const scanner = createScanner(text, true);
+    scanner.setPosition(offset);
+    const kind = scanner.scan();
+    return { kind, offset: scanner.getTokenOffset() };
+};
+const isJsonMember = (property, key) => property.children?.length === 2 && property.children[0]?.value === key;
+/**
+ * The property a client reads for `key`. `JSON.parse` and JSONC `parse` keep
+ * the last duplicate member, while jsonc-parser's `findNodeAtLocation` and
+ * `modify` select the first, so JSON text edits locate members only here.
+ */
+const effectiveJsonProperty = (object, key) => object.children?.findLast((property) => isJsonMember(property, key));
+/** Apply one edit and format the lines it touched, as `modify` does. */
+const applyFormattedJsonEdit = (text, edit) => {
+    const edited = applyEdits(text, [edit]);
+    let begin = edit.offset;
+    let end = edit.offset + edit.content.length;
+    if (edit.length === 0) {
+        while (begin > 0 && !"\r\n".includes(edited.charAt(begin - 1)))
+            begin -= 1;
+        while (end < edited.length && !"\r\n".includes(edited.charAt(end)))
+            end += 1;
     }
-    return pieces.length === 0 ? undefined : pieces.join("");
+    return applyEdits(edited, formatJson(edited, { offset: begin, length: end - begin }, { insertSpaces: true, tabSize: 2, eol: "\n", keepLines: false }));
 };
 /**
- * Delete an object property without taking a comment from the gap before it.
- * jsonc-parser's removal span includes that gap, so a trailing comment on the
- * previous property would disappear. Returns `undefined` to keep the stock edit.
+ * Delete a property by its JSONC AST span and the separator needed to keep its
+ * parent object valid. All whitespace and comments outside those tokens stay
+ * byte-for-byte in place.
  */
-const deleteJsonPropertyPreservingComments = (text, path) => {
-    const root = parseTree(text, [], { allowTrailingComma: true });
-    const value = root === undefined ? undefined : findNodeAtLocation(root, [...path]);
-    const property = value?.parent;
-    const parent = property?.parent;
-    if (property === undefined ||
-        parent?.type !== "object" ||
-        property.type !== "property" ||
-        parent.children === undefined)
-        return undefined;
-    const propertyIndex = parent.children.indexOf(property);
-    const previous = parent.children[propertyIndex - 1];
-    if (propertyIndex <= 0 || previous === undefined)
-        return undefined;
-    const comments = commentsBetweenProperties(text.slice(previous.offset + previous.length, property.offset));
-    if (comments === undefined)
-        return undefined;
-    let removeEnd = property.offset + property.length;
-    const hasNext = parent.children[propertyIndex + 1] !== undefined;
-    if (hasNext) {
-        let comma = removeEnd;
-        while (comma < text.length) {
-            const char = text[comma];
-            if (char === " " || char === "\t" || char === "\r" || char === "\n") {
-                comma += 1;
-                continue;
-            }
-            if (text.startsWith("/*", comma)) {
-                const close = text.indexOf("*/", comma + 2);
-                if (close < 0)
-                    return undefined;
-                comma = close + 2;
-                continue;
-            }
-            if (text.startsWith("//", comma)) {
-                while (comma < text.length &&
-                    text[comma] !== "\n" &&
-                    text[comma] !== "\r")
-                    comma += 1;
-                continue;
-            }
-            break;
+const deleteJsonProperty = (text, object, property) => {
+    const siblings = object.children ?? [];
+    const propertyIndex = siblings.indexOf(property);
+    const previous = siblings[propertyIndex - 1];
+    const next = siblings[propertyIndex + 1];
+    const comma = nextJsoncToken(text, previous === undefined
+        ? property.offset + property.length
+        : previous.offset + previous.length);
+    if (propertyIndex < 0 ||
+        (comma.kind !== JSON_COMMA &&
+            (previous !== undefined || next !== undefined)))
+        throw new TypeError("JSON property separator was not found");
+    const edits = [
+        { offset: property.offset, length: property.length, content: "" },
+        ...(comma.kind === JSON_COMMA
+            ? [{ offset: comma.offset, length: 1, content: "" }]
+            : []),
+    ];
+    return applyEdits(text, edits);
+};
+/**
+ * Set or delete the member a client reads at `path`, keeping every byte
+ * outside that member. Shadowed duplicates stay in place, and deleting a
+ * member that shadows one is refused so the earlier member never becomes
+ * active, whatever its ownership.
+ */
+const editJsonMember = (text, path, value) => {
+    let object = parseTree(text, [], { allowTrailingComma: true });
+    for (const [index, key] of path.entries()) {
+        if (object?.type !== "object")
+            throw new TypeError("JSON edit parent is not an object");
+        const property = effectiveJsonProperty(object, key);
+        const member = property?.children?.[1];
+        if (property === undefined || member === undefined) {
+            if (value === undefined)
+                return ok(text);
+            const content = `${JSON.stringify(key)}: ${JSON.stringify(path
+                .slice(index + 1)
+                .reduceRight((nested, name) => ({ [name]: nested }), value))}`;
+            const previous = object.children?.at(-1);
+            return ok(applyFormattedJsonEdit(text, previous === undefined
+                ? { offset: object.offset + 1, length: 0, content }
+                : {
+                    offset: previous.offset + previous.length,
+                    length: 0,
+                    content: `,${content}`,
+                }));
         }
-        if (text[comma] !== ",")
-            return undefined;
-        removeEnd = comma + 1;
+        if (index < path.length - 1) {
+            object = member;
+            continue;
+        }
+        if (value !== undefined)
+            return ok(applyFormattedJsonEdit(text, {
+                offset: member.offset,
+                length: member.length,
+                content: JSON.stringify(value),
+            }));
+        if (object.children?.some((sibling) => sibling !== property && isJsonMember(sibling, key)))
+            return err({ kind: "shadowed_member", path });
+        return ok(deleteJsonProperty(text, object, property));
     }
-    // A line comment runs to the next break. Keep the following token outside it.
-    const remainder = text.slice(removeEnd);
-    let suffix = `${hasNext ? "," : ""}${comments}`;
-    if (suffix.includes("//") &&
-        !suffix.endsWith("\n") &&
-        !suffix.endsWith("\r") &&
-        !remainder.startsWith("\n") &&
-        !remainder.startsWith("\r"))
-        suffix += "\n";
-    return `${text.slice(0, previous.offset + previous.length)}${suffix}${remainder}`;
+    throw new TypeError("JSON edit path is empty");
 };
-/** Serialize a validated client document, retaining JSONC and TOML comments. */
+/**
+ * Serialize a validated client document, retaining JSONC and TOML comments.
+ * JSON edits fail only when they would activate a shadowed duplicate member.
+ */
 export const serializeClientConfiguration = (document, format, originalText, editedPaths) => {
     if (format === undefined || format === "unsupported")
         throw new TypeError("client does not have a supported MCP config format");
     if (format === "toml")
-        return serializeCodexConfiguration(document, originalText);
+        return ok(serializeCodexConfiguration(document, originalText));
     if (format === "grok")
-        return serializeGrokConfiguration(document, originalText);
+        return ok(serializeGrokConfiguration(document, originalText));
     if (format === "hermes")
-        return serializeHermesConfiguration(document, originalText);
+        return ok(serializeHermesConfiguration(document, originalText));
+    if (format === "dsh")
+        return ok(serializeDshDocument(document));
     // An empty original holds no comments or settings to preserve. Writing a
     // fresh document also keeps a lone BOM from shifting past the closing brace.
-    if (originalText !== undefined &&
-        !isEmptyClientConfigurationText(originalText) &&
-        editedPaths !== undefined)
-        return editedPaths.reduce((text, path) => {
-            const value = valueAt(document, path);
-            if (value === undefined) {
-                const preserved = deleteJsonPropertyPreservingComments(text, path);
-                if (preserved !== undefined)
-                    return preserved;
-            }
-            return applyEdits(text, modify(text, [...path], value, {
-                formattingOptions: { insertSpaces: true, tabSize: 2, eol: "\n" },
-            }));
-        }, originalText);
-    return `${JSON.stringify(document, null, 2)}\n`;
+    if (originalText === undefined ||
+        isEmptyClientConfigurationText(originalText) ||
+        editedPaths === undefined)
+        return ok(`${JSON.stringify(document, null, 2)}\n`);
+    let text = originalText;
+    for (const path of editedPaths) {
+        const edited = editJsonMember(text, path, valueAt(document, path));
+        if (!edited.ok)
+            return edited;
+        text = edited.value;
+    }
+    return ok(text);
 };
 /** Key path of a named registration in the server table. */
 export const clientServerPath = (parsed, name) => [...parsed.serversPath, name];
@@ -1076,18 +1184,13 @@ export const legacyClientServerPath = (parsed, name) => Object.hasOwn(parsed.leg
 const serializeHermesConfiguration = (document, originalText) => {
     if (originalText === undefined ||
         isEmptyClientConfigurationText(originalText))
-        return stringifyYaml(document);
+        return stringifyHermesConfigurationYaml(document);
     const serversKey = clientConfigurationServersKey("hermes");
     const servers = document[serversKey];
     const entry = typeof servers === "object" && servers !== null
         ? servers[PRODUCT_IDENTITY.mcpServerKey]
         : undefined;
-    const yamlDocument = parseYamlDocument(originalText);
-    if (entry === undefined)
-        yamlDocument.deleteIn([serversKey, PRODUCT_IDENTITY.mcpServerKey]);
-    else
-        yamlDocument.setIn([serversKey, PRODUCT_IDENTITY.mcpServerKey], entry);
-    return yamlDocument.toString();
+    return editHermesConfigurationYaml(originalText, [serversKey, PRODUCT_IDENTITY.mcpServerKey], entry);
 };
 /** Build the stdio entry shape expected by one client's configuration dialect. */
 export const clientRegistrationEntry = (format, command, environment) => {
@@ -1102,6 +1205,13 @@ export const clientRegistrationEntry = (format, command, environment) => {
                     ? {}
                     : { environment: { ...environment } }),
             };
+        case "kimi":
+            // Kimi infers stdio from command; it uses `transport`, not `type`.
+            return {
+                command: executable,
+                args,
+                ...(Object.keys(environment).length === 0 ? {} : { env: environment }),
+            };
         case "opencode_v2":
             // V2 connects servers unless `disabled` is true.
             return {
@@ -1136,6 +1246,8 @@ export const clientRegistrationEntry = (format, command, environment) => {
                 args,
                 ...(Object.keys(environment).length === 0 ? {} : { env: environment }),
             };
+        case "dsh":
+            return dshClientRegistrationEntry(command, environment);
         case "hermes":
             // Hermes reads stdio servers from `mcp_servers.<name>` and connects them
             // unless `enabled` is false, so the entry states it explicitly.
@@ -1161,21 +1273,28 @@ export const parseGeminiMcpPolicy = (parsed) => z
 })
     .passthrough()
     .parse(parsed.document.mcp ?? {});
+/** One server-name comparison for the exclusion, intersection and membership rules below. */
+const normalizeGeminiServerName = (name) => name.toLowerCase().trim();
 /** Gemini consolidates excludes by union and allowlists by normalized intersection. */
 export const geminiServerPolicyBlock = (policies, serverKey) => {
-    if (policies.some(({ excluded }) => excluded?.includes(serverKey)))
+    // Hand-authored settings cannot be assumed to spell the product key exactly,
+    // so every rule compares normalized names. Testing the consolidated list
+    // against the raw key instead would make the outcome depend on which policy
+    // supplied the spelling that survived the intersection.
+    const key = normalizeGeminiServerName(serverKey);
+    if (policies.some(({ excluded }) => excluded?.some((name) => normalizeGeminiServerName(name) === key)))
         return `Gemini mcp.excluded blocks ${serverKey}. Review the selected settings policies before rerunning setup.`;
     const allowlists = policies.flatMap(({ allowed }) => allowed === undefined ? [] : [allowed]);
     const allowed = allowlists.reduce((previous, current) => {
         if (previous === undefined)
             return current;
-        const normalized = new Set(current.map((name) => name.toLowerCase().trim()));
-        return previous.filter((name) => normalized.has(name.toLowerCase().trim()));
+        const normalized = new Set(current.map(normalizeGeminiServerName));
+        return previous.filter((name) => normalized.has(normalizeGeminiServerName(name)));
     }, undefined);
     // Gemini's manager applies the consolidated allowlist only when nonempty.
     if (allowed !== undefined &&
         allowed.length > 0 &&
-        !allowed.includes(serverKey))
+        !allowed.some((name) => normalizeGeminiServerName(name) === key))
         return `Gemini mcp.allowed does not include ${serverKey}. Review the selected settings policies before rerunning setup.`;
     return undefined;
 };